| 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 // G4VUserDetectorConstruction implementation <<
27 // 26 //
28 // Original author: M.Asai, 1999 << 27 //
29 // ------------------------------------------- <<
30 28
31 #include "G4VUserDetectorConstruction.hh" 29 #include "G4VUserDetectorConstruction.hh"
32 <<
33 #include "G4FieldManager.hh" 30 #include "G4FieldManager.hh"
34 #include "G4LogicalVolume.hh" 31 #include "G4LogicalVolume.hh"
35 #include "G4LogicalVolumeStore.hh" 32 #include "G4LogicalVolumeStore.hh"
36 #include "G4MultiSensitiveDetector.hh" 33 #include "G4MultiSensitiveDetector.hh"
37 #include "G4RunManager.hh" <<
38 #include "G4SDManager.hh" 34 #include "G4SDManager.hh"
39 #include "G4VPhysicalVolume.hh" 35 #include "G4VPhysicalVolume.hh"
40 #include "G4VSensitiveDetector.hh" 36 #include "G4VSensitiveDetector.hh"
41 #include "G4VUserParallelWorld.hh" 37 #include "G4VUserParallelWorld.hh"
42 << 38 #include <assert.h>
43 #include <cassert> <<
44 #include <map> <<
45 #include <sstream> 39 #include <sstream>
46 40
47 // ------------------------------------------- << 41 G4VUserDetectorConstruction::G4VUserDetectorConstruction() { ; }
48 void G4VUserDetectorConstruction::RegisterPara << 42
>> 43 G4VUserDetectorConstruction::~G4VUserDetectorConstruction() { ; }
>> 44
>> 45 void G4VUserDetectorConstruction::RegisterParallelWorld(
>> 46 G4VUserParallelWorld* aPW)
49 { 47 {
50 auto pwItr = std::find(parallelWorld.cbegin( << 48 std::vector<G4VUserParallelWorld*>::iterator pwItr;
51 if (pwItr != parallelWorld.cend()) { << 49 for(pwItr = parallelWorld.begin(); pwItr != parallelWorld.end(); pwItr++)
52 G4String eM = "A parallel world <"; << 50 {
53 eM += aPW->GetName(); << 51 if((*pwItr)->GetName() == aPW->GetName())
54 eM += "> is already registered to the user << 52 {
55 G4Exception("G4VUserDetectorConstruction:: << 53 G4String eM = "A parallel world <";
56 FatalErrorInArgument, eM); << 54 eM += aPW->GetName();
>> 55 eM += "> is already registered to the user detector construction.";
>> 56 G4Exception("G4VUserDetectorConstruction::RegisterParallelWorld",
>> 57 "Run0051", FatalErrorInArgument, eM);
>> 58 }
57 } 59 }
58 parallelWorld.push_back(aPW); 60 parallelWorld.push_back(aPW);
59 } 61 }
60 62
61 // ------------------------------------------- <<
62 G4int G4VUserDetectorConstruction::ConstructPa 63 G4int G4VUserDetectorConstruction::ConstructParallelGeometries()
63 { 64 {
64 G4int nP = 0; 65 G4int nP = 0;
65 for (const auto& pwItr : parallelWorld) { << 66 std::vector<G4VUserParallelWorld*>::iterator pwItr;
66 pwItr->Construct(); << 67 for(pwItr = parallelWorld.begin(); pwItr != parallelWorld.end(); pwItr++)
67 ++nP; << 68 {
>> 69 (*pwItr)->Construct();
>> 70 nP++;
68 } 71 }
69 return nP; 72 return nP;
70 } 73 }
71 74
72 // ------------------------------------------- <<
73 void G4VUserDetectorConstruction::ConstructPar 75 void G4VUserDetectorConstruction::ConstructParallelSD()
74 { 76 {
75 for (const auto& pwItr : parallelWorld) { << 77 std::vector<G4VUserParallelWorld*>::iterator pwItr;
76 pwItr->ConstructSD(); << 78 for(pwItr = parallelWorld.begin(); pwItr != parallelWorld.end(); pwItr++)
>> 79 {
>> 80 (*pwItr)->ConstructSD();
77 } 81 }
78 } 82 }
79 83
80 // ------------------------------------------- <<
81 G4int G4VUserDetectorConstruction::GetNumberOf 84 G4int G4VUserDetectorConstruction::GetNumberOfParallelWorld() const
82 { 85 {
83 return (G4int)parallelWorld.size(); << 86 return parallelWorld.size();
84 } 87 }
85 88
86 // ------------------------------------------- << 89 G4VUserParallelWorld* G4VUserDetectorConstruction::GetParallelWorld(
87 G4VUserParallelWorld* G4VUserDetectorConstruct << 90 G4int i) const
88 { 91 {
89 if (i < 0 || i >= GetNumberOfParallelWorld() << 92 if(i < 0 || i >= GetNumberOfParallelWorld())
>> 93 return 0;
90 return parallelWorld[i]; 94 return parallelWorld[i];
91 } 95 }
92 96
93 // ------------------------------------------- << 97 #include "G4RunManager.hh"
94 void G4VUserDetectorConstruction::ConstructSDa << 98
>> 99 void G4VUserDetectorConstruction::ConstructSDandField()
>> 100 {
>> 101 // G4RunManager::RMType rmtype =
>> 102 // G4RunManager::GetRunManager()->GetRunManagerType(); if(rmtype !=
>> 103 // G4RunManager::sequentialRM)
>> 104 // {
>> 105 // G4cout
>> 106 // << "User-derived detector construction class does not implement \n"
>> 107 // << "ConstructSDandFiled method: i.e. workers will not have SD and
>> 108 // fields!\n"
>> 109 // << "The user can safely ignore this message if (s)he has no sensitive\n"
>> 110 // << "detector or field in her/his application." << G4endl;
>> 111 // }
>> 112 }
95 113
96 // ------------------------------------------- << 114 #include <map>
97 void G4VUserDetectorConstruction::CloneF() 115 void G4VUserDetectorConstruction::CloneF()
98 { 116 {
99 using FMtoFMmap = std::map<G4FieldManager*, << 117 typedef std::map<G4FieldManager*, G4FieldManager*> FMtoFMmap;
100 using FMpair = std::pair<G4FieldManager*, G4 << 118 typedef std::pair<G4FieldManager*, G4FieldManager*> FMpair;
101 <<
102 FMtoFMmap masterToWorker; 119 FMtoFMmap masterToWorker;
103 G4LogicalVolumeStore* const logVolStore = G4 120 G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
104 for (const auto& g4LogicalVolume : *logVolSt << 121 assert(logVolStore != NULL);
>> 122 for(G4LogicalVolumeStore::const_iterator it = logVolStore->begin();
>> 123 it != logVolStore->end(); ++it)
>> 124 {
>> 125 G4LogicalVolume* g4LogicalVolume = *it;
105 // Use shadow of master to get instance of 126 // Use shadow of master to get instance of FM
106 G4FieldManager* masterFM = nullptr; // g4 << 127 G4FieldManager* masterFM = 0; // g4LogicalVolume->fFieldManager;
107 G4FieldManager* clonedFM = nullptr; << 128 G4FieldManager* clonedFM = 0;
108 if (masterFM != nullptr) { << 129 if(masterFM)
109 auto fmFound = masterToWorker.find(maste << 130 {
110 if (fmFound == masterToWorker.cend()) { << 131 FMtoFMmap::iterator fmFound = masterToWorker.find(masterFM);
>> 132 if(fmFound == masterToWorker.end())
>> 133 {
111 // First time we see this SD, let's cl 134 // First time we see this SD, let's clone and remember...
112 try { << 135 try
113 auto insertedEl = masterToWorker.ins << 136 {
>> 137 std::pair<FMtoFMmap::iterator, bool> insertedEl =
>> 138 masterToWorker.insert(FMpair(masterFM, masterFM->Clone()));
114 clonedFM = (insertedEl.first)->secon 139 clonedFM = (insertedEl.first)->second;
115 } << 140 } catch(...)
116 catch (...) { << 141 {
117 G4ExceptionDescription msg; 142 G4ExceptionDescription msg;
118 msg << "Cloning of G4FieldManager fa 143 msg << "Cloning of G4FieldManager failed."
119 << " But derived class does not 144 << " But derived class does not implement cloning. Cannot "
120 "continue."; 145 "continue.";
121 G4Exception("G4VUserDetectorConstruc << 146 G4Exception("G4VUserDetectorConstruction::CloneSD", "Run0053",
>> 147 FatalException, msg);
122 } 148 }
123 } 149 }
124 else { << 150 else
125 // We have already seen this SD attach << 151 {
>> 152 // We have already seen this SD attached to a fifferent LogicalVolume,
126 // let's re-use previous clone 153 // let's re-use previous clone
127 clonedFM = (*fmFound).second; 154 clonedFM = (*fmFound).second;
128 } 155 }
129 } // masterFM != 0 156 } // masterFM != 0
130 // Note that we do not push FM to daughter << 157 // Note that we do not push FM to doughters (false argument), however, since
131 // we area looping on all logical volumes 158 // we area looping on all logical volumes and we implemented the "trick" of
132 // the map master<->cloned the final effec 159 // the map master<->cloned the final effect is the same as using here the
133 // correct Boolean flag: log-volumes that << 160 // correct boolean flag: log-volumes that originally were sharing the same
134 // FM they will have cloned ones 161 // FM they will have cloned ones
135 g4LogicalVolume->SetFieldManager(clonedFM, 162 g4LogicalVolume->SetFieldManager(clonedFM, false);
136 } 163 }
137 } 164 }
138 165
139 // ------------------------------------------- <<
140 void G4VUserDetectorConstruction::CloneSD() 166 void G4VUserDetectorConstruction::CloneSD()
141 { 167 {
142 // Loop on ALL logial volumes to search for 168 // Loop on ALL logial volumes to search for attached SD
143 G4LogicalVolumeStore* const logVolStore = G4 169 G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
>> 170 assert(logVolStore != NULL);
144 171
145 using SDtoSDmap = std::map<G4VSensitiveDetec << 172 typedef std::map<G4VSensitiveDetector*, G4VSensitiveDetector*> SDtoSDmap;
146 using SDpair = std::pair<G4VSensitiveDetecto << 173 typedef std::pair<G4VSensitiveDetector*, G4VSensitiveDetector*> SDpair;
147 SDtoSDmap masterToWorker; 174 SDtoSDmap masterToWorker;
148 175
149 for (const auto& g4LogicalVolume : *logVolSt << 176 for(G4LogicalVolumeStore::const_iterator it = logVolStore->begin();
>> 177 it != logVolStore->end(); ++it)
>> 178 {
>> 179 G4LogicalVolume* g4LogicalVolume = *it;
150 // Use shadow of master to get the instanc 180 // Use shadow of master to get the instance of SD
151 G4VSensitiveDetector* masterSD = nullptr; << 181 G4VSensitiveDetector* masterSD = 0; // g4LogicalVolume->fSensitiveDetector;
152 G4VSensitiveDetector* clonedSD = nullptr; << 182 G4VSensitiveDetector* clonedSD = 0;
153 if (masterSD != nullptr) { << 183 if(masterSD)
154 auto sdFound = masterToWorker.find(maste << 184 {
155 if (sdFound == masterToWorker.cend()) { << 185 SDtoSDmap::iterator sdFound = masterToWorker.find(masterSD);
>> 186 if(sdFound == masterToWorker.end())
>> 187 {
156 // First time we see this SD, let's cl 188 // First time we see this SD, let's clone and remember...
157 try { << 189 try
158 auto insertedEl = masterToWorker.ins << 190 {
>> 191 std::pair<SDtoSDmap::iterator, bool> insertedEl =
>> 192 masterToWorker.insert(SDpair(masterSD, masterSD->Clone()));
159 clonedSD = (insertedEl.first)->secon 193 clonedSD = (insertedEl.first)->second;
160 } << 194 } catch(...)
161 catch (...) { << 195 {
162 G4ExceptionDescription msg; 196 G4ExceptionDescription msg;
163 msg << "Cloning of G4VSensitiveDetec << 197 msg << "Cloning of G4VSensitiveDetector requested for:"
>> 198 << masterSD->GetName() << "\n"
164 #ifndef WIN32 199 #ifndef WIN32
165 << " (full path name: " << maste 200 << " (full path name: " << masterSD->GetFullPathName() << ").\n"
166 #endif 201 #endif
167 << " But derived class does not 202 << " But derived class does not implement cloning. Cannot "
168 "continue."; 203 "continue.";
169 G4Exception("G4VUserDetectorConstruc << 204 G4Exception("G4VUserDetectorConstruction::CloneSD", "Run0053",
>> 205 FatalException, msg);
170 } 206 }
171 } 207 }
172 else { << 208 else
173 // We have already seen this SD attach << 209 {
>> 210 // We have already seen this SD attached to a fifferent LogicalVolume,
174 // let's re-use previous clone 211 // let's re-use previous clone
175 clonedSD = (*sdFound).second; 212 clonedSD = (*sdFound).second;
176 } 213 }
177 } // masterSD!=0 214 } // masterSD!=0
178 g4LogicalVolume->SetSensitiveDetector(clon 215 g4LogicalVolume->SetSensitiveDetector(clonedSD);
179 } 216 }
180 } 217 }
181 218
182 // ------------------------------------------- << 219 void G4VUserDetectorConstruction::SetSensitiveDetector(
183 void G4VUserDetectorConstruction::SetSensitive << 220 const G4String& logVolName, G4VSensitiveDetector* aSD, G4bool multi)
184 <<
185 { 221 {
186 G4bool found = false; << 222 G4bool found = false;
187 G4LogicalVolumeStore* store = G4LogicalVolum 223 G4LogicalVolumeStore* store = G4LogicalVolumeStore::GetInstance();
188 auto volmap = store->GetMap(); << 224 for(G4LogicalVolumeStore::iterator pos = store->begin(); pos != store->end();
189 auto pos = volmap.find(logVolName); << 225 pos++)
190 if (pos != volmap.cend()) { << 226 {
191 if ((pos->second.size() > 1) && !multi) { << 227 if((*pos)->GetName() == logVolName)
192 G4String eM = "More than one logical vol << 228 {
193 eM += pos->first; << 229 if(found && !multi)
194 eM += "> are found and thus the sensitiv << 230 {
195 eM += aSD->GetName(); << 231 G4String eM = "More than one logical volumes of the name <";
196 eM += "> cannot be uniquely assigned."; << 232 eM += (*pos)->GetName();
197 G4Exception("G4VUserDetectorConstruction << 233 eM += "> are found and thus the sensitive detector <";
198 FatalErrorInArgument, eM); << 234 eM += aSD->GetName();
199 } << 235 eM += "> cannot be uniquely assigned.";
200 found = true; << 236 G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector",
201 for (auto& i : pos->second) { << 237 "Run0052", FatalErrorInArgument, eM);
202 SetSensitiveDetector(i, aSD); << 238 }
>> 239 found = true;
>> 240 SetSensitiveDetector(*pos, aSD);
203 } 241 }
204 } 242 }
205 if (!found) { << 243 if(!found)
206 G4String eM2 = "No logical volume of name << 244 {
>> 245 G4String eM2 = "No logical volume of the name <";
207 eM2 += logVolName; 246 eM2 += logVolName;
208 eM2 += "> is found. The specified sensitiv 247 eM2 += "> is found. The specified sensitive detector <";
209 eM2 += aSD->GetName(); 248 eM2 += aSD->GetName();
210 eM2 += "> couldn't be assigned to any volu 249 eM2 += "> couldn't be assigned to any volume.";
211 G4Exception("G4VUserDetectorConstruction:: << 250 G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector", "Run0053",
212 FatalErrorInArgument, eM2); 251 FatalErrorInArgument, eM2);
213 } 252 }
214 } 253 }
215 254
216 // ------------------------------------------- << 255 void G4VUserDetectorConstruction::SetSensitiveDetector(
217 void G4VUserDetectorConstruction::SetSensitive << 256 G4LogicalVolume* logVol, G4VSensitiveDetector* aSD)
218 <<
219 { 257 {
220 assert(logVol != nullptr && aSD != nullptr); 258 assert(logVol != nullptr && aSD != nullptr);
221 259
222 // The aSD has already been added by user to 260 // The aSD has already been added by user to the manager if needed
223 // G4SDManager::GetSDMpointer()->AddNewDetec 261 // G4SDManager::GetSDMpointer()->AddNewDetector(aSD);
224 262
225 // New Logic: allow for "multiple" SDs being 263 // New Logic: allow for "multiple" SDs being attached to a single LV.
226 // To do that we use a special proxy SD call 264 // To do that we use a special proxy SD called G4MultiSensitiveDetector
227 265
228 // Get existing SD if already set and check 266 // Get existing SD if already set and check if it is of the special type
229 G4VSensitiveDetector* originalSD = logVol->G 267 G4VSensitiveDetector* originalSD = logVol->GetSensitiveDetector();
230 if (originalSD == aSD) { << 268 if(originalSD == aSD)
>> 269 {
231 G4ExceptionDescription msg; 270 G4ExceptionDescription msg;
232 msg << "Attempting to add multiple times t 271 msg << "Attempting to add multiple times the same sensitive detector (\"";
233 msg << originalSD->GetName() << "\") is no 272 msg << originalSD->GetName() << "\") is not allowed, skipping.";
234 G4Exception("G4VUserDetectorConstruction:: << 273 G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector", "Run0054",
>> 274 JustWarning, msg);
235 return; 275 return;
236 } 276 }
237 if (originalSD == nullptr) { << 277 if(originalSD == nullptr)
>> 278 {
238 logVol->SetSensitiveDetector(aSD); 279 logVol->SetSensitiveDetector(aSD);
239 } 280 }
240 else { << 281 else
241 auto msd = dynamic_cast<G4MultiSensitiveDe << 282 {
242 if (msd != nullptr) { << 283 G4MultiSensitiveDetector* msd =
>> 284 dynamic_cast<G4MultiSensitiveDetector*>(originalSD);
>> 285 if(msd != nullptr)
>> 286 {
243 msd->AddSD(aSD); 287 msd->AddSD(aSD);
244 } 288 }
245 else { << 289 else
>> 290 {
246 std::ostringstream mn; 291 std::ostringstream mn;
247 mn << "/MultiSD_" << logVol->GetName() < 292 mn << "/MultiSD_" << logVol->GetName() << "_" << logVol;
248 const G4String msdname = mn.str(); 293 const G4String msdname = mn.str();
249 msd = new G4MultiSensitiveDetector(msdna << 294 msd = new G4MultiSensitiveDetector(msdname);
250 // We need to register the proxy to have 295 // We need to register the proxy to have correct handling of IDs
251 G4SDManager::GetSDMpointer()->AddNewDete 296 G4SDManager::GetSDMpointer()->AddNewDetector(msd);
252 msd->AddSD(originalSD); 297 msd->AddSD(originalSD);
253 msd->AddSD(aSD); 298 msd->AddSD(aSD);
254 logVol->SetSensitiveDetector(msd); 299 logVol->SetSensitiveDetector(msd);
255 } 300 }
256 } 301 }
257 } 302 }
258 303