| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
>> 26 // $Id: ElectronRun.cc 78175 2013-12-04 14:11:29Z gunter $
26 // 27 //
27 /// \file medical/electronScattering2/src/Elec 28 /// \file medical/electronScattering2/src/ElectronRun.cc
28 /// \brief Implementation of the ElectronRun c 29 /// \brief Implementation of the ElectronRun class
29 30
30 #include "ElectronRun.hh" 31 #include "ElectronRun.hh"
31 <<
32 #include "G4MultiFunctionalDetector.hh" 32 #include "G4MultiFunctionalDetector.hh"
33 #include "G4SDManager.hh" 33 #include "G4SDManager.hh"
34 #include "G4SystemOfUnits.hh" <<
35 #include "G4VPrimitiveScorer.hh" 34 #include "G4VPrimitiveScorer.hh"
36 << 35 #include "G4SystemOfUnits.hh"
37 #include <assert.h> 36 #include <assert.h>
38 37
39 //....oooOO0OOooo........oooOO0OOooo........oo 38 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
40 39
41 ElectronRun::ElectronRun() : G4Run(), fMap() << 40 ElectronRun::ElectronRun()
>> 41 : G4Run(), fMap()
42 { 42 {
43 fMap[0] = new G4THitsMap<G4double>("MyDetect << 43 fMap[0] = new G4THitsMap<G4double>("MyDetector", "cell flux");
44 fMap[1] = new G4THitsMap<G4double>("MyDetect << 44 fMap[1] = new G4THitsMap<G4double>("MyDetector", "e cell flux");
45 fMap[2] = new G4THitsMap<G4double>("MyDetect << 45 fMap[2] = new G4THitsMap<G4double>("MyDetector", "population");
46 fMap[3] = new G4THitsMap<G4double>("MyDetect << 46 fMap[3] = new G4THitsMap<G4double>("MyDetector", "e population");
47 } 47 }
48 48
49 //....oooOO0OOooo........oooOO0OOooo........oo 49 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
50 50
51 ElectronRun::~ElectronRun() 51 ElectronRun::~ElectronRun()
52 { 52 {
53 // Important to clean up the map << 53 // Important to clean up the map
54 std::map<G4int, G4THitsMap<G4double>*>::iter << 54 std::map<G4int, G4THitsMap<G4double>* >::iterator iter = fMap.begin();
55 << 55
56 while (iter != fMap.end()) { << 56 while (iter != fMap.end()) {
57 delete iter->second; << 57 delete iter->second;
58 iter++; << 58 iter++;
59 } << 59 }
60 } 60 }
61 61
62 //....oooOO0OOooo........oooOO0OOooo........oo 62 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
63 63
64 void ElectronRun::RecordEvent(const G4Event* a 64 void ElectronRun::RecordEvent(const G4Event* anEvent)
65 { 65 {
66 // Get the hits collection << 66 // Get the hits collection
67 G4HCofThisEvent* eventHitCollection = anEven << 67 G4HCofThisEvent* eventHitCollection = anEvent->GetHCofThisEvent();
68 << 68
69 if (!eventHitCollection) return; << 69 if (!eventHitCollection) return;
70 << 70
71 // Update our private fMap << 71 // Update our private fMap
72 std::map<G4int, G4THitsMap<G4double>*>::iter << 72 std::map< G4int, G4THitsMap<G4double>* >::iterator iter = fMap.begin();
73 << 73
74 while (iter != fMap.end()) { << 74 while (iter != fMap.end()) {
75 G4int id = iter->first; << 75 G4int id = iter->first;
76 << 76
77 // Get the hit collection corresponding to << 77 // Get the hit collection corresponding to "id"
78 G4THitsMap<G4double>* eventHitsMap = << 78 G4THitsMap<G4double>* eventHitsMap
79 dynamic_cast<G4THitsMap<G4double>*>(even << 79 = dynamic_cast< G4THitsMap<G4double>* >(eventHitCollection->GetHC(id));
80 << 80
81 // Expect this to exist << 81 // Expect this to exist
82 assert(0 != eventHitsMap); << 82 assert (0 != eventHitsMap);
83 << 83
84 // Accumulate event data into our G4THitsM << 84 // Accumulate event data into our G4THitsMap<G4double> map
85 *(iter->second) += *eventHitsMap; << 85 *(iter->second) += *eventHitsMap;
86 << 86
87 iter++; << 87 iter++;
88 } << 88 }
89 << 89
90 G4Run::RecordEvent(anEvent); << 90 G4Run::RecordEvent(anEvent);
91 } 91 }
92 92
93 //....oooOO0OOooo........oooOO0OOooo........oo 93 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
94 94
95 void ElectronRun::DumpData(G4String& outputFil << 95 void ElectronRun::DumpData(G4String &outputFileSpec) const
96 { 96 {
97 // Titles << 97 // Titles
98 std::vector<G4String> title; << 98 std::vector<G4String> title;
99 title.push_back("Radius"); << 99 title.push_back("Radius");
100 << 100
101 // Output map - energy binning on x axis, th << 101 // Output map - energy binning on x axis, theta on y
102 std::map<G4int, std::vector<G4double>> outpu << 102 std::map< G4int, std::vector<G4double> > output;
103 << 103
104 G4int nThetaBins = 233; << 104 G4int nThetaBins = 233;
105 << 105
106 // Energy bins depends on the number of scor << 106 // Energy bins depends on the number of scorers
107 G4int nEnergyBins = fMap.size(); << 107 G4int nEnergyBins = fMap.size();
108 << 108
109 G4int i(0), j(0); << 109 G4int i(0), j(0);
110 << 110
111 // Initialise current to 0 in all bins << 111 // Initialise current to 0 in all bins
112 for (i = 0; i < nThetaBins; i++) { << 112 for (i=0; i<nThetaBins; i++) {
113 for (j = 0; j < nEnergyBins; j++) { << 113 for (j=0; j<nEnergyBins; j++) {
114 output[i].push_back(0); << 114 output[i].push_back(0);
>> 115 }
115 } 116 }
116 } << 117
117 << 118 i=0;
118 i = 0; << 119
119 << 120 // Fill the output map
120 // Fill the output map << 121 std::map< G4int, G4THitsMap<G4double>* >::const_iterator iter = fMap.begin();
121 std::map<G4int, G4THitsMap<G4double>*>::cons << 122
122 << 123 while (iter != fMap.end()) {
123 while (iter != fMap.end()) { << 124 G4THitsMap<G4double>* hitMap = iter->second;
124 G4THitsMap<G4double>* hitMap = iter->secon << 125
125 << 126 title.push_back(hitMap->GetName());
126 title.push_back(hitMap->GetName()); << 127
127 << 128 std::map<G4int,G4double*>* myMap = hitMap->GetMap();
128 std::map<G4int, G4double*>* myMap = hitMap << 129
129 << 130 for (j=0; j<nThetaBins; j++) {
130 for (j = 0; j < nThetaBins; j++) { << 131 G4double* current = (*myMap)[j];
131 G4double* current = (*myMap)[j]; << 132 if (0 != current) output[j][i] = (*current);
132 if (0 != current) output[j][i] = (*curre << 133 }
>> 134
>> 135 i++;
>> 136 iter++;
133 } 137 }
134 << 138
135 i++; << 139 Print(title, output, outputFileSpec);
136 iter++; <<
137 } <<
138 <<
139 Print(title, output, outputFileSpec); <<
140 } 140 }
141 141
142 //....oooOO0OOooo........oooOO0OOooo........oo 142 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
143 143
144 void ElectronRun::Print(const std::vector<G4St 144 void ElectronRun::Print(const std::vector<G4String>& title,
145 const std::map<G4int, << 145 const std::map< G4int, std::vector<G4double> >&myMap,
146 G4String& outputFileSp << 146 G4String &outputFileSpec) const
147 { 147 {
148 // Print to G4cout and an output file << 148 // Print to G4cout and an output file
149 std::ofstream outFile(outputFileSpec); << 149 std::ofstream outFile(outputFileSpec);
150 << 150
151 // Print title vector << 151 // Print title vector
152 std::vector<G4String>::const_iterator titleI << 152 std::vector<G4String>::const_iterator titleIter = title.begin();
153 << 153
154 while (titleIter != title.end()) { << 154 while (titleIter != title.end()) {
155 G4cout << std::setw(8) << *titleIter << " << 155 G4cout << std::setw(8)<<*titleIter<<" ";
156 titleIter++; << 156 titleIter++;
157 } << 157 }
158 << 158
159 G4cout << G4endl; << 159 G4cout<<G4endl;
160 << 160
161 // Print current data << 161 // Print current data
162 std::map<G4int, std::vector<G4double>>::cons << 162 std::map< G4int, std::vector<G4double> >::const_iterator iter = myMap.begin();
163 << 163
164 while (iter != myMap.end()) { << 164 while (iter != myMap.end()) {
165 G4cout << std::setw(8) << std::setprecisio << 165 G4cout << std::setw(8)<<std::setprecision(3)<< iter->first<<" ";
166 << 166
167 std::vector<G4double>::const_iterator ener << 167 std::vector<G4double>::const_iterator energyBinIter = iter->second.begin();
168 << 168
169 // The built-in scorers do not automatical << 169 // The built-in scorers do not automatically account for the area of the
170 // cylinder replica rings. We must account << 170 // cylinder replica rings. We must account for this now by multiplying our result
171 // by the ratio of the area of the full cy << 171 // by the ratio of the area of the full cylinder end over the area of the actual
172 // scoring ring. << 172 // scoring ring.
173 // In this ratio, PI divides out, as does << 173 // In this ratio, PI divides out, as does the width of the scoring rings.
174 // Left with just the number of rings squa << 174 // Left with just the number of rings squared divided by the ring index plus
175 // 1 squared minus ring index squared. << 175 // 1 squared minus ring index squared.
176 G4int ringNum = iter->first; << 176 G4int ringNum = iter->first;
177 G4double areaCorrection = 233. * 233. / (( << 177 G4double areaCorrection = 233.*233. /
178 G4int counter = 0; << 178 ( (ringNum+1)*(ringNum+1) - ringNum*ringNum );
179 << 179 G4int counter = 0;
180 while (energyBinIter != iter->second.end() << 180
181 G4double value = *energyBinIter; << 181 while (energyBinIter != iter->second.end()) {
182 if (counter < 2) value = value * areaCor << 182 G4double value = *energyBinIter;
183 G4cout << std::setw(10) << std::setpreci << 183 if (counter < 2) value = value*areaCorrection;
184 outFile << value * mm * mm; << 184 G4cout << std::setw(10)<<std::setprecision(5)<< value*mm*mm<<" ";
185 if (counter < 3) outFile << ","; << 185 outFile << value*mm*mm;
186 counter++; << 186 if (counter < 3) outFile <<",";
187 energyBinIter++; << 187 counter++;
188 } << 188 energyBinIter++;
189 outFile << G4endl; << 189 }
190 G4cout << G4endl; << 190 outFile<<G4endl;
191 iter++; << 191 G4cout<<G4endl;
192 } << 192 iter++;
>> 193 }
193 } 194 }
194 195
195 //....oooOO0OOooo........oooOO0OOooo........oo 196 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
196 197
197 void ElectronRun::Merge(const G4Run* aRun) 198 void ElectronRun::Merge(const G4Run* aRun)
198 { 199 {
199 // This method is called at the end of the r << 200 // This method is called at the end of the run for each worker thread.
200 // It accumulates the worker's results into << 201 // It accumulates the worker's results into global results.
201 const ElectronRun* localRun = static_cast<co << 202 const ElectronRun* localRun = static_cast<const ElectronRun*>(aRun);
202 const std::map<G4int, G4THitsMap<G4double>*> << 203 const std::map< G4int, G4THitsMap<G4double>* >& localMap = localRun->fMap;
203 std::map<G4int, G4THitsMap<G4double>*>::cons << 204 std::map< G4int, G4THitsMap<G4double>* >::const_iterator iter = localMap.begin();
204 for (; iter != localMap.end(); ++iter) << 205 for ( ; iter != localMap.end() ; ++iter)
205 (*(fMap[iter->first])) += (*(iter->second) << 206 (*(fMap[iter->first])) += (*(iter->second));
206 << 207
207 // This call lets Geant4 maintain overall su << 208 // This call lets Geant4 maintain overall summary information.
208 G4Run::Merge(aRun); << 209 G4Run::Merge(aRun);
209 } 210 }
210 211
211 //....oooOO0OOooo........oooOO0OOooo........oo 212 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
212 213