| 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 // G4RunManagerKernel implementation <<
27 // 26 //
28 // Author: M.Asai, 1 August 2003 << 27 // $Id: G4RunManagerKernel.cc,v 1.47.2.1 2010/09/10 13:10:28 gcosmo Exp $
29 // ------------------------------------------- << 28 // GEANT4 tag $Name: geant4-09-03-patch-02 $
>> 29 //
>> 30 //
30 31
31 #include "G4RunManagerKernel.hh" 32 #include "G4RunManagerKernel.hh"
32 33
33 #include "G4AllocatorList.hh" << 34 #include <vector>
>> 35
>> 36 #include "G4StateManager.hh"
34 #include "G4ApplicationState.hh" 37 #include "G4ApplicationState.hh"
35 #include "G4AutoLock.hh" <<
36 #include "G4ExceptionHandler.hh" 38 #include "G4ExceptionHandler.hh"
37 #include "G4FieldManagerStore.hh" << 39 #include "G4PrimaryTransformer.hh"
38 #include "G4Geantino.hh" <<
39 #include "G4GeometryManager.hh" 40 #include "G4GeometryManager.hh"
40 #include "G4IonConstructor.hh" << 41 #include "G4TransportationManager.hh"
41 #include "G4IonTable.hh" << 42 #include "G4VPhysicalVolume.hh"
42 #include "G4LogicalVolume.hh" 43 #include "G4LogicalVolume.hh"
43 #include "G4LogicalVolumeStore.hh" << 44 #include "G4VUserPhysicsList.hh"
44 #include "G4MTRunManager.hh" <<
45 #include "G4NavigationHistoryPool.hh" <<
46 #include "G4ParallelWorldProcessStore.hh" <<
47 #include "G4ParticleDefinition.hh" <<
48 #include "G4ParticleTable.hh" 45 #include "G4ParticleTable.hh"
49 #include "G4ParticleTableIterator.hh" <<
50 #include "G4PathFinder.hh" <<
51 #include "G4PrimaryTransformer.hh" <<
52 #include "G4ProcessManager.hh" <<
53 #include "G4ProcessVector.hh" <<
54 #include "G4ProductionCuts.hh" <<
55 #include "G4ProductionCutsTable.hh" <<
56 #include "G4RNGHelper.hh" <<
57 #include "G4Region.hh" 46 #include "G4Region.hh"
58 #include "G4RegionStore.hh" 47 #include "G4RegionStore.hh"
>> 48 #include "G4ProductionCuts.hh"
>> 49 #include "G4ProductionCutsTable.hh"
59 #include "G4SDManager.hh" 50 #include "G4SDManager.hh"
60 #include "G4ScoreSplittingProcess.hh" <<
61 #include "G4StateManager.hh" <<
62 #include "G4TransportationManager.hh" <<
63 #include "G4UImanager.hh" 51 #include "G4UImanager.hh"
64 #include "G4UnitsTable.hh" <<
65 #include "G4VPhysicalVolume.hh" <<
66 #include "G4VProcess.hh" <<
67 #include "G4VUserPhysicsList.hh" <<
68 #include "G4VVisManager.hh" 52 #include "G4VVisManager.hh"
>> 53 #include "G4UnitsTable.hh"
69 #include "G4Version.hh" 54 #include "G4Version.hh"
70 #include "G4ios.hh" 55 #include "G4ios.hh"
71 56
72 #include <vector> <<
73 <<
74 #ifdef G4BT_DEBUG <<
75 # include "G4Backtrace.hh" <<
76 #endif <<
77 <<
78 #ifdef G4FPE_DEBUG 57 #ifdef G4FPE_DEBUG
79 # include "G4FPEDetection.hh" << 58 #include "G4FPEDetection.hh"
80 #endif 59 #endif
81 60
82 // The following lines are needed since G4VUse << 61 G4RunManagerKernel* G4RunManagerKernel::fRunManagerKernel = 0;
83 // uses a #define theParticleIterator <<
84 #ifdef theParticleIterator <<
85 # undef theParticleIterator <<
86 #endif <<
87 <<
88 G4ThreadLocal G4RunManagerKernel* G4RunManager <<
89 62
90 // ------------------------------------------- <<
91 G4RunManagerKernel* G4RunManagerKernel::GetRun 63 G4RunManagerKernel* G4RunManagerKernel::GetRunManagerKernel()
92 { << 64 { return fRunManagerKernel; }
93 return fRunManagerKernel; <<
94 } <<
95 65
96 // ------------------------------------------- <<
97 G4RunManagerKernel::G4RunManagerKernel() 66 G4RunManagerKernel::G4RunManagerKernel()
>> 67 :physicsList(0),currentWorld(0),
>> 68 geometryInitialized(false),physicsInitialized(false),
>> 69 geometryNeedsToBeClosed(true),geometryToBeOptimized(true),
>> 70 physicsNeedsToBeReBuilt(true),verboseLevel(0),
>> 71 numberOfParallelWorld(0)
98 { 72 {
99 #ifdef G4FPE_DEBUG 73 #ifdef G4FPE_DEBUG
100 InvalidOperationDetection(); 74 InvalidOperationDetection();
101 #endif 75 #endif
102 76
103 #ifdef G4BT_DEBUG << 77 defaultExceptionHandler = new G4ExceptionHandler();
104 auto _signals = G4GetEnv<std::string>("G4BAC << 78 if(fRunManagerKernel)
105 if (_signals.empty()) { << 79 {
106 G4Backtrace::Enable(); << 80 G4Exception("G4RunManagerKernel::G4RunManagerKernel()","MoreThanOneRunManager",
107 } << 81 FatalException,"More than one G4RunManagerKernel is constructed.");
108 else { <<
109 G4Backtrace::Enable(_signals); <<
110 } <<
111 #endif <<
112 <<
113 G4AllocatorList* allocList = G4AllocatorList <<
114 if (allocList != nullptr) numberOfStaticAllo <<
115 <<
116 if (G4StateManager::GetStateManager()->GetEx <<
117 defaultExceptionHandler = new G4ExceptionH <<
118 } <<
119 if (fRunManagerKernel != nullptr) { <<
120 G4Exception("G4RunManagerKernel::G4RunMana <<
121 "More than one G4RunManagerKer <<
122 } 82 }
123 fRunManagerKernel = this; 83 fRunManagerKernel = this;
124 84
125 G4ParticleTable* particleTable = G4ParticleT 85 G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
126 if (particleTable->entries() > 0) { << 86 if(particleTable->entries()>0)
>> 87 {
127 // No particle should be registered before 88 // No particle should be registered beforehand
128 G4ExceptionDescription ED; << 89 G4cerr<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<G4endl;
129 ED << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 90 G4cerr<<" G4RunManagerKernel fatal exception"<<G4endl;
130 ED << " G4RunManagerKernel fatal exception << 91 G4cerr<<" -- Following particles have already been registered"<<G4endl;
131 ED << " -- Following particles have alrea << 92 G4cerr<<" before G4RunManagerKernel is instantiated."<<G4endl;
132 ED << " before G4RunManagerKernel is i << 93 for(int i=0;i<particleTable->entries();i++)
133 for (G4int i = 0; i < particleTable->entri << 94 { G4cerr<<" "<<particleTable->GetParticle(i)->GetParticleName()<<G4endl; }
134 ED << " " << particleTable->GetParti << 95 G4cerr<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<G4endl;
135 } << 96 G4Exception("G4RunManagerKernel::G4RunManagerKernel()","StaticParticleDefinition",
136 ED << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! << 97 FatalException,"Particles have already been instantiated before G4RunManagerKernel.");
137 G4Exception("G4RunManagerKernel::G4RunMana <<
138 } 98 }
139 << 99
140 // construction of Geant4 kernel classes 100 // construction of Geant4 kernel classes
141 eventManager = new G4EventManager(); 101 eventManager = new G4EventManager();
142 << 102 defaultRegion = new G4Region("DefaultRegionForTheWorld"); // deleted by store
143 defaultRegion = new G4Region("DefaultRegionF <<
144 defaultRegionForParallelWorld = <<
145 new G4Region("DefaultRegionForParallelWorl <<
146 defaultRegion->SetProductionCuts( 103 defaultRegion->SetProductionCuts(
147 G4ProductionCutsTable::GetProductionCutsTa 104 G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
148 defaultRegionForParallelWorld->SetProduction <<
149 G4ProductionCutsTable::GetProductionCutsTa <<
150 105
151 runManagerKernelType = sequentialRMK; << 106 // Following line is tentatively moved from SetPhysics method
>> 107 // Commented out for introduction of non-static particle definition // G4ParticleTable::GetParticleTable()->SetReadiness();
152 // set the initial application state 108 // set the initial application state
153 G4StateManager::GetStateManager()->SetNewSta 109 G4StateManager::GetStateManager()->SetNewState(G4State_PreInit);
154 110
155 // version banner 111 // version banner
156 G4String vs = G4Version; 112 G4String vs = G4Version;
157 vs = vs.substr(1, vs.size() - 2); << 113 vs = vs.substr(1,vs.size()-2);
158 versionString = " Geant4 version "; 114 versionString = " Geant4 version ";
159 versionString += vs; 115 versionString += vs;
160 versionString += " "; 116 versionString += " ";
161 versionString += G4Date; 117 versionString += G4Date;
162 G4cout << G4endl << "*********************** << 118 G4cout << G4endl
163 << versionString << G4endl << " << 119 << "*************************************************************" << G4endl
164 << G4endl << " R << 120 << versionString << G4endl
165 << " << 121 << " Copyright : Geant4 Collaboration" << G4endl
166 << " << 122 << " Reference : NIM A 506 (2003), 250-303" << G4endl
167 << " WWW << 123 << " WWW : http://cern.ch/geant4" << G4endl
168 << "********************************* << 124 << "*************************************************************" << G4endl
169 } << 125 << G4endl;
170 <<
171 // ------------------------------------------- <<
172 G4RunManagerKernel::G4RunManagerKernel(RMKType <<
173 { <<
174 // This version of the constructor should neve <<
175 #ifndef G4MULTITHREADED <<
176 G4ExceptionDescription msg; <<
177 msg << "Geant4 code is compiled without mult <<
178 "(-DG4MULTITHREADED is set to off)."; <<
179 msg << " This type of RunManagerKernel can o <<
180 "applications."; <<
181 G4Exception("G4RunManagerKernel::G4RunManage <<
182 #endif <<
183 <<
184 #ifdef G4FPE_DEBUG <<
185 if (G4Threading::IsMasterThread()) { <<
186 InvalidOperationDetection(); <<
187 } <<
188 #endif <<
189 <<
190 #ifdef G4BT_DEBUG <<
191 auto _signals = G4GetEnv<std::string>("G4BAC <<
192 if (_signals.empty()) { <<
193 G4Backtrace::Enable(); <<
194 } <<
195 else { <<
196 G4Backtrace::Enable(_signals); <<
197 } <<
198 #endif <<
199 <<
200 if (G4StateManager::GetStateManager()->GetEx <<
201 defaultExceptionHandler = new G4ExceptionH <<
202 } <<
203 <<
204 if (fRunManagerKernel != nullptr) { <<
205 G4Exception("G4RunManagerKernel::G4RunMana <<
206 "More than one G4RunManagerKer <<
207 } <<
208 fRunManagerKernel = this; <<
209 // construction of Geant4 kernel classes <<
210 eventManager = new G4EventManager(); <<
211 <<
212 switch (rmkType) { <<
213 case masterRMK: <<
214 // Master thread behvior <<
215 defaultRegion = new G4Region("DefaultReg <<
216 defaultRegionForParallelWorld = <<
217 new G4Region("DefaultRegionForParallel <<
218 defaultRegion->SetProductionCuts( <<
219 G4ProductionCutsTable::GetProductionCu <<
220 defaultRegionForParallelWorld->SetProduc <<
221 G4ProductionCutsTable::GetProductionCu <<
222 break; <<
223 case workerRMK: <<
224 // Worker thread behavior <<
225 defaultRegion = G4RegionStore::GetInstan <<
226 defaultRegionForParallelWorld = <<
227 G4RegionStore::GetInstance()->GetRegio <<
228 break; <<
229 default: <<
230 defaultRegion = nullptr; <<
231 defaultRegionForParallelWorld = nullptr; <<
232 G4ExceptionDescription msgx; <<
233 msgx << " This type of RunManagerKernel <<
234 "applications."; <<
235 G4Exception("G4RunManagerKernel::G4RunMa <<
236 msgx); <<
237 } <<
238 runManagerKernelType = rmkType; <<
239 <<
240 // set the initial application state <<
241 G4StateManager::GetStateManager()->SetNewSta <<
242 <<
243 // version banner <<
244 G4String vs = G4Version; <<
245 vs = vs.substr(1, vs.size() - 2); <<
246 switch (rmkType) { <<
247 case masterRMK: <<
248 versionString = " Geant4 version "; <<
249 versionString += vs; <<
250 versionString += " "; <<
251 versionString += G4Date; <<
252 G4cout << G4endl << "******************* <<
253 << versionString << G4endl << " <<
254 << " Copyri <<
255 << " Referen <<
256 << " <<
257 << " <<
258 << " <<
259 << "***************************** <<
260 << G4endl; <<
261 break; <<
262 default: <<
263 if (verboseLevel != 0) { <<
264 versionString = " Local thread RunMana <<
265 versionString += vs; <<
266 G4cout << G4endl <<
267 << "^^^^^^^^^^^^^^^^^^^^^^^^^^^ <<
268 "^^^^^^^^^" <<
269 << G4endl << versionString << G <<
270 << "^^^^^^^^^^^^^^^^^^^^^^^^^^^ <<
271 "^^^^^^^^^" <<
272 << G4endl << G4endl; <<
273 } <<
274 } <<
275 <<
276 #ifdef G4MULTITHREADED <<
277 G4UnitDefinition::GetUnitsTable().Synchroniz <<
278 #endif <<
279 } 126 }
280 127
281 // ------------------------------------------- <<
282 void G4RunManagerKernel::SetupDefaultRegion() <<
283 { <<
284 if (runManagerKernelType == workerRMK) retur <<
285 <<
286 // Remove old world logical volume from the <<
287 if (defaultRegion->GetNumberOfRootVolumes() <<
288 if (defaultRegion->GetNumberOfRootVolumes( <<
289 G4Exception("G4RunManager::SetupDefaultR <<
290 "Default world region should <<
291 } <<
292 auto lvItr = defaultRegion->GetRootLogical <<
293 defaultRegion->RemoveRootLogicalVolume(*lv <<
294 if (verboseLevel > 1) <<
295 G4cout << "Obsolete world logical volume <<
296 } <<
297 } <<
298 <<
299 // ------------------------------------------- <<
300 G4RunManagerKernel::~G4RunManagerKernel() 128 G4RunManagerKernel::~G4RunManagerKernel()
301 { 129 {
302 G4StateManager* pStateManager = G4StateManag <<
303 // set the application state to the quite st 130 // set the application state to the quite state
304 if (pStateManager->GetCurrentState() != G4St << 131 if(verboseLevel>0) G4cout << "G4 kernel has come to Quit state." << G4endl;
305 if (verboseLevel > 1) G4cout << "G4 kernel << 132 G4StateManager* pStateManager = G4StateManager::GetStateManager();
306 pStateManager->SetNewState(G4State_Quit); << 133 pStateManager->SetNewState(G4State_Quit);
307 } <<
308 134
309 // open geometry for deletion 135 // open geometry for deletion
310 G4GeometryManager::GetInstance()->OpenGeomet 136 G4GeometryManager::GetInstance()->OpenGeometry();
311 137
312 // deletion of Geant4 kernel classes 138 // deletion of Geant4 kernel classes
313 delete G4ParallelWorldProcessStore::GetInsta << 139 G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
314 delete G4SDManager::GetSDMpointerIfExist(); << 140 if(fSDM)
315 if (verboseLevel > 1) G4cout << "G4SDManager << 141 {
316 delete eventManager; << 142 delete fSDM;
317 if (verboseLevel > 1) G4cout << "EventManage << 143 if(verboseLevel>1) G4cout << "G4SDManager deleted." << G4endl;
318 <<
319 G4UnitDefinition::ClearUnitsTable(); <<
320 if (verboseLevel > 1) G4cout << "Units table <<
321 <<
322 // deletion of path-finder field-manager sto <<
323 // manager <<
324 delete G4PathFinder::GetInstanceIfExist(); <<
325 delete G4FieldManagerStore::GetInstanceIfExi <<
326 delete G4GeometryManager::GetInstanceIfExist <<
327 delete G4TransportationManager::GetInstanceI <<
328 if (verboseLevel > 1) G4cout << "Transportat <<
329 <<
330 // deletion of navigation levels <<
331 if (verboseLevel > 1) G4NavigationHistoryPoo <<
332 delete G4NavigationHistoryPool::GetInstance( <<
333 <<
334 // deletion of G4RNGHelper singleton <<
335 if (runManagerKernelType != workerRMK) { <<
336 delete G4RNGHelper::GetInstanceIfExist(); <<
337 if (verboseLevel > 1) G4cout << "G4RNGHelp <<
338 } <<
339 <<
340 // deletion of allocators <<
341 G4AllocatorList* allocList = G4AllocatorList <<
342 if (allocList != nullptr) { <<
343 allocList->Destroy(numberOfStaticAllocator <<
344 delete allocList; <<
345 if (verboseLevel > 1) G4cout << "G4Allocat <<
346 } 144 }
347 << 145 delete eventManager;
>> 146 if(verboseLevel>1) G4cout << "EventManager deleted." << G4endl;
348 G4UImanager* pUImanager = G4UImanager::GetUI 147 G4UImanager* pUImanager = G4UImanager::GetUIpointer();
349 if ((runManagerKernelType == workerRMK) && ( << 148 {
350 G4cout << "Thread-local UImanager is to be << 149 if(pUImanager) delete pUImanager;
351 << "There should not be any thread- << 150 if(verboseLevel>1) G4cout << "UImanager deleted." << G4endl;
352 } 151 }
353 delete pUImanager; << 152 G4UnitDefinition::ClearUnitsTable();
354 if (verboseLevel > 1) G4cout << "UImanager d << 153 if(verboseLevel>1) G4cout << "Units table cleared." << G4endl;
355 << 154 delete pStateManager;
356 delete pStateManager; << 155 if(verboseLevel>1) G4cout << "StateManager deleted." << G4endl;
357 if (verboseLevel > 1) G4cout << "StateManage <<
358 delete defaultExceptionHandler; 156 delete defaultExceptionHandler;
359 if (verboseLevel > 1) G4cout << "RunManagerK << 157 if(verboseLevel>1) G4cout << "RunManagerKernel is deleted." << G4endl;
360 fRunManagerKernel = nullptr; << 158 fRunManagerKernel = 0;
361 } 159 }
362 160
363 // ------------------------------------------- << 161 void G4RunManagerKernel::DefineWorldVolume(G4VPhysicalVolume* worldVol,
364 void G4RunManagerKernel::WorkerUpdateWorldVolu << 162 G4bool topologyIsChanged)
365 { 163 {
366 G4MTRunManager* masterRM = G4MTRunManager::G << 164 G4StateManager* stateManager = G4StateManager::GetStateManager();
367 G4TransportationManager* transM = G4Transpor <<
368 G4MTRunManager::masterWorlds_t masterWorlds <<
369 for (const auto& masterWorld : masterWorlds) <<
370 G4VPhysicalVolume* wv = masterWorld.second <<
371 G4VPhysicalVolume* pWorld = <<
372 G4TransportationManager::GetTransportati <<
373 if (pWorld == nullptr) { <<
374 transM->RegisterWorld(wv); <<
375 } <<
376 } <<
377 } <<
378 <<
379 // ------------------------------------------- <<
380 void G4RunManagerKernel::WorkerDefineWorldVolu <<
381 <<
382 { <<
383 G4StateManager* stateManager = G4StateManage <<
384 G4ApplicationState currentState = stateManag <<
385 if (currentState != G4State_Init) { <<
386 if (currentState != G4State_Idle && curren <<
387 G4cout << "Current application state is <<
388 << G4endl; <<
389 G4Exception("G4RunManagerKernel::DefineW <<
390 FatalException, "Geant4 kern <<
391 return; <<
392 } <<
393 <<
394 stateManager->SetNewState(G4State_Init); <<
395 } <<
396 <<
397 currentWorld = worldVol; <<
398 G4MTRunManager* masterRM = G4MTRunManager::G <<
399 G4TransportationManager* transM = G4Transpor <<
400 G4MTRunManager::masterWorlds_t masterWorlds <<
401 for (const auto& masterWorld : masterWorlds) <<
402 if (masterWorld.first == 0) { <<
403 if (masterWorld.second != currentWorld) <<
404 G4Exception("G4RunManagerKernel::Worke <<
405 "Mass world is inconsisten <<
406 } <<
407 transM->SetWorldForTracking(masterWorld. <<
408 } <<
409 else { <<
410 transM->RegisterWorld(masterWorld.second <<
411 } <<
412 } <<
413 <<
414 if (topologyIsChanged) geometryNeedsToBeClos <<
415 <<
416 // Notify the VisManager as well <<
417 if (G4Threading::IsMasterThread()) { <<
418 G4VVisManager* pVVisManager = G4VVisManage <<
419 if (pVVisManager != nullptr) pVVisManager- <<
420 } <<
421 <<
422 geometryInitialized = true; <<
423 stateManager->SetNewState(currentState); <<
424 if (physicsInitialized && currentState != G4 <<
425 stateManager->SetNewState(G4State_Idle); <<
426 } <<
427 } <<
428 <<
429 // ------------------------------------------- <<
430 void G4RunManagerKernel::DefineWorldVolume(G4V <<
431 { <<
432 G4StateManager* stateManager = G4StateManage <<
433 G4ApplicationState currentState = stateManag 165 G4ApplicationState currentState = stateManager->GetCurrentState();
434 << 166 if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
435 if (currentState != G4State_Init) { << 167 {
436 if (currentState != G4State_Idle && curren << 168 G4Exception("G4RunManagerKernel::DefineWorldVolume",
437 G4cout << "Current application state is << 169 "DefineWorldVolumeAtIncorrectState",
438 << G4endl; << 170 JustWarning,
439 G4Exception("G4RunManagerKernel::DefineW << 171 "Geant4 kernel is not PreInit or Idle state : Method ignored.");
440 FatalException, "Geant4 kern << 172 if(verboseLevel>1) G4cerr << "Current application state is "
441 return; << 173 << stateManager->GetStateString(currentState) << G4endl;
442 } << 174 return;
443 <<
444 stateManager->SetNewState(G4State_Init); <<
445 } 175 }
446 176
447 // The world volume MUST NOT have a region d 177 // The world volume MUST NOT have a region defined by the user
448 if (worldVol->GetLogicalVolume()->GetRegion( << 178 if(worldVol->GetLogicalVolume()->GetRegion())
449 if (worldVol->GetLogicalVolume()->GetRegio << 179 {
450 G4ExceptionDescription ED; << 180 if(worldVol->GetLogicalVolume()->GetRegion()!=defaultRegion)
451 ED << "The world volume has a user-defin << 181 {
452 << worldVol->GetLogicalVolume()->GetR << 182 G4cerr << "The world volume has a user-defined region <"
453 ED << "World would have a default region << 183 << worldVol->GetLogicalVolume()->GetRegion()->GetName()
454 G4Exception("G4RunManager::DefineWorldVo << 184 << ">." << G4endl;
>> 185 G4Exception("G4RunManager::DefineWorldVolume",
>> 186 "RUN:WorldHasUserDefinedRegion",
>> 187 FatalException,
>> 188 "World would have a default region assigned by RunManagerKernel.");
455 } 189 }
456 } 190 }
457 191
458 SetupDefaultRegion(); << 192 // Remove old world logical volume from the default region, if exist
>> 193 if(defaultRegion->GetNumberOfRootVolumes())
>> 194 {
>> 195 if(defaultRegion->GetNumberOfRootVolumes()>size_t(1))
>> 196 {
>> 197 G4Exception("G4RunManager::DefineWorldVolume",
>> 198 "DefaultRegionHasMoreThanOneVolume",
>> 199 FatalException,
>> 200 "Default world region should have a unique logical volume.");
>> 201 }
>> 202 std::vector<G4LogicalVolume*>::iterator lvItr
>> 203 = defaultRegion->GetRootLogicalVolumeIterator();
>> 204 defaultRegion->RemoveRootLogicalVolume(*lvItr,false);
>> 205 if(verboseLevel>1) G4cout
>> 206 << "Obsolete world logical volume is removed from the default region." << G4endl;
>> 207 }
459 208
460 // Accept the world volume 209 // Accept the world volume
461 currentWorld = worldVol; << 210 currentWorld = worldVol;
462 211
463 // Set the default region to the world 212 // Set the default region to the world
464 <<
465 G4LogicalVolume* worldLog = currentWorld->Ge 213 G4LogicalVolume* worldLog = currentWorld->GetLogicalVolume();
466 worldLog->SetRegion(defaultRegion); 214 worldLog->SetRegion(defaultRegion);
467 defaultRegion->AddRootLogicalVolume(worldLog 215 defaultRegion->AddRootLogicalVolume(worldLog);
468 if (verboseLevel > 1) << 216 if(verboseLevel>1) G4cout << worldLog->GetName()
469 G4cout << worldLog->GetName() << " is regi << 217 << " is registered to the default region." << G4endl;
470 218
471 // Set the world volume, notify the Navigato 219 // Set the world volume, notify the Navigator and reset its state
472 G4TransportationManager::GetTransportationMa << 220 G4TransportationManager::GetTransportationManager()
473 if (topologyIsChanged) geometryNeedsToBeClos << 221 ->SetWorldForTracking(currentWorld);
474 << 222 if(topologyIsChanged) geometryNeedsToBeClosed = true;
>> 223
475 // Notify the VisManager as well 224 // Notify the VisManager as well
476 if (G4Threading::IsMasterThread()) { << 225 G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
477 G4VVisManager* pVVisManager = G4VVisManage << 226 if(pVVisManager) pVVisManager->GeometryHasChanged();
478 if (pVVisManager != nullptr) pVVisManager- <<
479 } <<
480 227
481 geometryInitialized = true; 228 geometryInitialized = true;
482 stateManager->SetNewState(currentState); << 229 if(physicsInitialized && currentState!=G4State_Idle)
483 if (physicsInitialized && currentState != G4 << 230 { stateManager->SetNewState(G4State_Idle); }
484 stateManager->SetNewState(G4State_Idle); << 231 }
485 } << 232
486 } <<
487 <<
488 // ------------------------------------------- <<
489 void G4RunManagerKernel::SetPhysics(G4VUserPhy 233 void G4RunManagerKernel::SetPhysics(G4VUserPhysicsList* uPhys)
490 { 234 {
491 physicsList = uPhys; 235 physicsList = uPhys;
492 << 236 G4ParticleTable::GetParticleTable()->SetReadiness();
493 if (runManagerKernelType == workerRMK) retur << 237 physicsList->ConstructParticle();
494 << 238 if(verboseLevel>2) G4ParticleTable::GetParticleTable()->DumpTable();
495 SetupPhysics(); << 239 if(verboseLevel>1)
496 if (verboseLevel > 2) G4ParticleTable::GetPa << 240 {
497 if (verboseLevel > 1) { << 241 G4cout << "List of instantiated particles ============================================" << G4endl;
498 G4cout << "List of instantiated particles <<
499 "=============================== <<
500 << G4endl; <<
501 G4int nPtcl = G4ParticleTable::GetParticle 242 G4int nPtcl = G4ParticleTable::GetParticleTable()->entries();
502 for (G4int i = 0; i < nPtcl; ++i) { << 243 for(G4int i=0;i<nPtcl;i++)
>> 244 {
503 G4ParticleDefinition* pd = G4ParticleTab 245 G4ParticleDefinition* pd = G4ParticleTable::GetParticleTable()->GetParticle(i);
504 G4cout << pd->GetParticleName() << " "; 246 G4cout << pd->GetParticleName() << " ";
505 if (i % 10 == 9) G4cout << G4endl; << 247 if(i%10==9) G4cout << G4endl;
506 } 248 }
507 G4cout << G4endl; 249 G4cout << G4endl;
508 } 250 }
509 } 251 }
510 << 252
511 // ------------------------------------------- <<
512 void G4RunManagerKernel::SetupPhysics() <<
513 { <<
514 G4ParticleTable::GetParticleTable()->SetRead <<
515 <<
516 physicsList->ConstructParticle(); <<
517 <<
518 // For sanity reason <<
519 G4Geantino::GeantinoDefinition(); <<
520 G4ParticleDefinition* gion = G4ParticleTable <<
521 if (gion != nullptr) { <<
522 G4IonConstructor::ConstructParticle(); <<
523 } <<
524 G4ParticleTable::GetParticleTable()->GetIonT <<
525 <<
526 auto pItr = G4ParticleTable::GetParticleTabl <<
527 pItr->reset(); <<
528 while ((*pItr)()) { <<
529 G4ParticleDefinition* particle = pItr->val <<
530 if (!(particle->IsGeneralIon())) particle- <<
531 } <<
532 <<
533 if (gion != nullptr) { <<
534 G4int gionId = gion->GetParticleDefinition <<
535 pItr->reset(false); <<
536 while ((*pItr)()) { <<
537 G4ParticleDefinition* particle = pItr->v <<
538 if (particle->IsGeneralIon()) particle-> <<
539 } <<
540 } <<
541 #ifdef G4MULTITHREADED <<
542 G4UnitDefinition::GetUnitsTable().Synchroniz <<
543 #endif <<
544 } <<
545 <<
546 // ------------------------------------------- <<
547 namespace <<
548 { <<
549 G4Mutex initphysicsmutex = G4MUTEX_INITIALIZER <<
550 } <<
551 <<
552 // ------------------------------------------- <<
553 void G4RunManagerKernel::InitializePhysics() 253 void G4RunManagerKernel::InitializePhysics()
554 { 254 {
555 G4StateManager* stateManager = G4StateManage << 255 G4StateManager* stateManager = G4StateManager::GetStateManager();
556 G4ApplicationState currentState = stateManag 256 G4ApplicationState currentState = stateManager->GetCurrentState();
557 if (currentState != G4State_Init) { << 257 if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
558 G4cout << "Current application state is " << 258 {
559 << G4endl; << 259 G4Exception("G4RunManagerKernel::InitializePhysics",
560 if (currentState != G4State_Idle && curren << 260 "InitializePhysicsAtIncorrectState", JustWarning,
561 G4Exception("G4RunManagerKernel::Initial << 261 "Geant4 kernel is not PreInit or Idle state : Method ignored.");
562 FatalException, "Geant4 kern << 262 return;
563 return; <<
564 } <<
565 <<
566 G4cout << "Warning : Geant4 kernel is not <<
567 stateManager->SetNewState(G4State_Init); <<
568 } 263 }
569 264
570 if (physicsList == nullptr) { << 265 if(!physicsList)
571 G4Exception("G4RunManagerKernel::Initializ << 266 {
>> 267 G4Exception("G4RunManagerKernel::InitializePhysics",
>> 268 "PhysicsListIsNotDefined", FatalException,
572 "G4VUserPhysicsList is not def 269 "G4VUserPhysicsList is not defined");
573 return; 270 return;
574 } 271 }
575 272
576 if (verboseLevel > 1) G4cout << "physicsList << 273 if(verboseLevel>1) G4cout << "physicsList->Construct() start." << G4endl;
577 if (numberOfParallelWorld > 0) physicsList-> << 274 if(numberOfParallelWorld>0) physicsList->UseCoupledTransportation();
578 physicsList->Construct(); 275 physicsList->Construct();
579 276
580 if (verboseLevel > 1) G4cout << "physicsList << 277 if(verboseLevel>1) G4cout << "physicsList->CheckParticleList() start." << G4endl;
581 physicsList->CheckParticleList(); 278 physicsList->CheckParticleList();
582 << 279 if(verboseLevel>1) G4cout << "physicsList->setCut() start." << G4endl;
583 // Cannot assume that SetCuts() and CheckReg << 280 physicsList->SetCuts();
584 // We need to mutex (report from valgrind -- <<
585 G4AutoLock l(&initphysicsmutex); <<
586 if (G4Threading::IsMasterThread()) { <<
587 if (verboseLevel > 1) G4cout << "physicsLi <<
588 physicsList->SetCuts(); <<
589 } <<
590 CheckRegions(); 281 CheckRegions();
591 l.unlock(); <<
592 <<
593 physicsInitialized = true; 282 physicsInitialized = true;
594 << 283 if(geometryInitialized && currentState!=G4State_Idle)
595 #ifdef G4MULTITHREADED << 284 { stateManager->SetNewState(G4State_Idle); }
596 G4UnitDefinition::GetUnitsTable().Synchroniz <<
597 #endif <<
598 <<
599 stateManager->SetNewState(currentState); <<
600 if (geometryInitialized && currentState != G <<
601 stateManager->SetNewState(G4State_Idle); <<
602 } <<
603 } 285 }
604 286
605 // ------------------------------------------- << 287 G4bool G4RunManagerKernel::RunInitialization()
606 G4bool G4RunManagerKernel::RunInitialization(G <<
607 { 288 {
608 G4StateManager* stateManager = G4StateManage << 289 G4StateManager* stateManager = G4StateManager::GetStateManager();
609 G4ApplicationState currentState = stateManag 290 G4ApplicationState currentState = stateManager->GetCurrentState();
610 291
611 if (!geometryInitialized) { << 292 if(!geometryInitialized)
612 G4Exception("G4RunManagerKernel::RunInitia << 293 {
>> 294 G4Exception("G4RunManagerKernel::RunInitialization",
>> 295 "GeometryHasNotYetInitialized",
>> 296 JustWarning,
613 "Geometry has not yet initiali 297 "Geometry has not yet initialized : method ignored.");
614 return false; 298 return false;
615 } 299 }
616 << 300
617 if (!physicsInitialized) { << 301 if(!physicsInitialized)
618 G4Exception("G4RunManagerKernel::RunInitia << 302 {
>> 303 G4Exception("G4RunManagerKernel::RunInitialization",
>> 304 "PhysicsHasNotYetInitialized",
>> 305 JustWarning,
619 "Physics has not yet initializ 306 "Physics has not yet initialized : method ignored.");
620 return false; 307 return false;
621 } 308 }
622 309
623 if (currentState != G4State_Idle) { << 310 if( currentState != G4State_Idle )
624 G4Exception("G4RunManagerKernel::RunInitia << 311 {
>> 312 G4Exception("G4RunManagerKernel::RunInitialization",
>> 313 "RunInitializationAtIncorrectState",
>> 314 JustWarning,
625 "Geant4 kernel not in Idle sta 315 "Geant4 kernel not in Idle state : method ignored.");
626 return false; 316 return false;
627 } 317 }
628 318
629 if (geometryNeedsToBeClosed) CheckRegularGeo << 319 //if(numberOfParallelWorld>0)
630 << 320 //{ // Confirm G4CoupledTransportation is used
631 stateManager->SetNewState(G4State_Init); << 321 // if(!ConfirmCoupledTransportation())
632 PropagateGenericIonID(); << 322 // { G4Exception("G4CoupledTransportation must be used for parallel world."); }
633 SetupShadowProcess(); << 323 //}
>> 324
634 UpdateRegion(); 325 UpdateRegion();
635 BuildPhysicsTables(fakeRun); << 326 BuildPhysicsTables();
636 <<
637 if (geometryNeedsToBeClosed) { <<
638 if(!fakeRun || resetNavigatorAtInitializat <<
639 // CheckRegularGeometry(); <<
640 // Notify the VisManager as well <<
641 if (G4Threading::IsMasterThread()) { <<
642 G4VVisManager* pVVisManager = G4VVisMana <<
643 if (pVVisManager != nullptr) pVVisManage <<
644 } <<
645 } <<
646 327
>> 328 if(geometryNeedsToBeClosed) ResetNavigator();
>> 329
647 GetPrimaryTransformer()->CheckUnknown(); 330 GetPrimaryTransformer()->CheckUnknown();
648 331
649 #ifdef G4MULTITHREADED <<
650 G4UnitDefinition::GetUnitsTable().Synchroniz <<
651 #endif <<
652 <<
653 stateManager->SetNewState(G4State_Idle); <<
654 stateManager->SetNewState(G4State_GeomClosed 332 stateManager->SetNewState(G4State_GeomClosed);
655 return true; 333 return true;
656 } 334 }
657 335
658 // ------------------------------------------- <<
659 void G4RunManagerKernel::PropagateGenericIonID <<
660 { <<
661 G4ParticleDefinition* gion = G4ParticleTable <<
662 if (gion != nullptr) { <<
663 G4int gionId = gion->GetParticleDefinition <<
664 auto pItr = G4ParticleTable::GetParticleTa <<
665 pItr->reset(false); <<
666 while ((*pItr)()) { <<
667 G4ParticleDefinition* particle = pItr->v <<
668 if (particle->IsGeneralIon()) particle-> <<
669 } <<
670 } <<
671 } <<
672 <<
673 // ------------------------------------------- <<
674 void G4RunManagerKernel::RunTermination() 336 void G4RunManagerKernel::RunTermination()
675 { << 337 { G4StateManager::GetStateManager()->SetNewState(G4State_Idle); }
676 if (runManagerKernelType != workerRMK) <<
677 { G4ProductionCutsTable::GetProductionCutsTa <<
678 G4StateManager::GetStateManager()->SetNewSta <<
679 } <<
680 338
681 // ------------------------------------------- <<
682 void G4RunManagerKernel::ResetNavigator() 339 void G4RunManagerKernel::ResetNavigator()
683 { 340 {
684 G4GeometryManager* geomManager = G4GeometryM <<
685 if (runManagerKernelType == workerRMK) { <<
686 // To ensure that it is called when using <<
687 if( geomManager->IsParallelOptimisationCon <<
688 !geomManager->IsParallelOptimisationFin <<
689 { <<
690 geomManager->UndertakeOptimisation(); <<
691 } <<
692 geometryNeedsToBeClosed = false; <<
693 return; <<
694 } <<
695 <<
696 // We have to tweak the navigator's state in 341 // We have to tweak the navigator's state in case a geometry has been
697 // modified between runs. By the following c 342 // modified between runs. By the following calls we ensure that navigator's
698 // state is reset properly. It is required t 343 // state is reset properly. It is required the geometry to be closed
699 // and previous optimisations to be cleared. 344 // and previous optimisations to be cleared.
700 << 345
701 if (verboseLevel > 1) G4cout << "Start closi << 346 G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
702 << 347 if(verboseLevel>1) G4cout << "Start closing geometry." << G4endl;
703 geomManager->OpenGeometry(); 348 geomManager->OpenGeometry();
704 geomManager->CloseGeometry(geometryToBeOptim << 349 geomManager->CloseGeometry(geometryToBeOptimized, verboseLevel>1);
>> 350
>> 351 // Reseting Navigator has been moved to G4Eventmanager, so that resetting
>> 352 // is now done for every event.
>> 353 // G4ThreeVector center(0,0,0);
>> 354 // G4Navigator* navigator =
>> 355 // G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
>> 356 // navigator->LocateGlobalPointAndSetup(center,0,false);
705 357
706 geometryNeedsToBeClosed = false; 358 geometryNeedsToBeClosed = false;
707 } 359 }
708 360
709 // ------------------------------------------- <<
710 void G4RunManagerKernel::UpdateRegion() 361 void G4RunManagerKernel::UpdateRegion()
711 { 362 {
712 G4StateManager* stateManager = G4StateManage << 363 G4StateManager* stateManager = G4StateManager::GetStateManager();
713 G4ApplicationState currentState = stateManag 364 G4ApplicationState currentState = stateManager->GetCurrentState();
714 if (currentState != G4State_Init) { << 365 if( currentState != G4State_Idle )
715 G4Exception("G4RunManagerKernel::UpdateReg << 366 {
716 "Geant4 kernel not in Init sta << 367 G4Exception("G4RunManagerKernel::UpdateRegion",
>> 368 "RegionUpdateAtIncorrectState",
>> 369 JustWarning,
>> 370 "Geant4 kernel not in Idle state : method ignored.");
717 return; 371 return;
718 } 372 }
719 373
720 if (runManagerKernelType == workerRMK) retur <<
721 <<
722 CheckRegions(); 374 CheckRegions();
723 <<
724 G4RegionStore::GetInstance()->UpdateMaterial 375 G4RegionStore::GetInstance()->UpdateMaterialList(currentWorld);
725 <<
726 G4ProductionCutsTable::GetProductionCutsTabl 376 G4ProductionCutsTable::GetProductionCutsTable()->UpdateCoupleTable(currentWorld);
727 } 377 }
728 378
729 // ------------------------------------------- << 379 void G4RunManagerKernel::BuildPhysicsTables()
730 void G4RunManagerKernel::BuildPhysicsTables(G4 << 380 {
731 { << 381 if(G4ProductionCutsTable::GetProductionCutsTable()->IsModified()
732 if (G4ProductionCutsTable::GetProductionCuts << 382 || physicsNeedsToBeReBuilt)
733 #ifdef G4MULTITHREADED << 383 {
734 if (runManagerKernelType == masterRMK) { <<
735 // make sure workers also rebuild physic <<
736 G4UImanager* pUImanager = G4UImanager::G <<
737 pUImanager->ApplyCommand("/run/physicsMo <<
738 } <<
739 #endif <<
740 physicsList->BuildPhysicsTable(); 384 physicsList->BuildPhysicsTable();
>> 385 G4ProductionCutsTable::GetProductionCutsTable()->PhysicsTableUpdated();
741 physicsNeedsToBeReBuilt = false; 386 physicsNeedsToBeReBuilt = false;
742 } 387 }
743 388
744 if (!fakeRun && verboseLevel > 1) DumpRegion << 389 if(verboseLevel>1) DumpRegion();
745 if (!fakeRun && verboseLevel > 0) physicsLis << 390 if(verboseLevel>0) physicsList->DumpCutValuesTable();
746 if (!fakeRun) physicsList->DumpCutValuesTabl << 391 physicsList->DumpCutValuesTableIfRequested();
747 } 392 }
748 393
749 // ------------------------------------------- <<
750 void G4RunManagerKernel::CheckRegions() 394 void G4RunManagerKernel::CheckRegions()
751 { 395 {
752 G4TransportationManager* transM = G4Transpor 396 G4TransportationManager* transM = G4TransportationManager::GetTransportationManager();
753 std::size_t nWorlds = transM->GetNoWorlds(); << 397 size_t nWorlds = transM->GetNoWorlds();
754 std::vector<G4VPhysicalVolume*>::iterator wI 398 std::vector<G4VPhysicalVolume*>::iterator wItr;
755 for (auto region : *G4RegionStore::GetInstan << 399 for(size_t i=0;i<G4RegionStore::GetInstance()->size();i++)
756 // Let each region have a pointer to the w << 400 {
757 // G4Region::SetWorld() checks if the regi << 401 G4Region* region = (*(G4RegionStore::GetInstance()))[i];
758 // set it only if it does. Thus, here we g << 402
759 // volumes. << 403 //Let each region have a pointer to the world volume where it belongs to.
760 region->SetWorld(nullptr); // reset << 404 //G4Region::SetWorld() checks if the region belongs to the given world and set it
761 region->UsedInMassGeometry(false); << 405 //only if it does. Thus, here we go through all the registered world volumes.
762 region->UsedInParallelGeometry(false); <<
763 wItr = transM->GetWorldsIterator(); 406 wItr = transM->GetWorldsIterator();
764 for (std::size_t iw = 0; iw < nWorlds; ++i << 407 for(size_t iw=0;iw<nWorlds;iw++)
765 if (region->BelongsTo(*wItr)) { << 408 {
766 if (*wItr == currentWorld) { <<
767 region->UsedInMassGeometry(true); <<
768 } <<
769 else { <<
770 region->UsedInParallelGeometry(true) <<
771 } <<
772 } <<
773 region->SetWorld(*wItr); 409 region->SetWorld(*wItr);
774 ++wItr; << 410 wItr++;
775 } 411 }
776 412
777 G4ProductionCuts* cuts = region->GetProduc << 413 //Now check for the regions which belongs to the tracking world
778 if (cuts == nullptr) { << 414 if(region->GetWorldPhysical()!=currentWorld) continue;
779 if (region->IsInMassGeometry() && verbos <<
780 G4cout << "Warning : Region <" << regi <<
781 << "> does not have specific pr <<
782 << "even though it appears in t <<
783 G4cout << "Default cuts are used for t <<
784 } <<
785 415
786 if (region->IsInMassGeometry() || region << 416 G4ProductionCuts* cuts = region->GetProductionCuts();
787 region->SetProductionCuts( << 417 if(!cuts)
>> 418 {
>> 419 G4cerr << "Warning : Region <" << region->GetName()
>> 420 << "> does not have specific production cuts," << G4endl
>> 421 << "even though it appears in the current tracking world." << G4endl;
>> 422 G4cerr << "Default cuts are used for this region." << G4endl;
>> 423 region->SetProductionCuts(
788 G4ProductionCutsTable::GetProduction 424 G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
789 } <<
790 } 425 }
791 } 426 }
792 <<
793 // <<
794 // If a parallel world has no region, set de <<
795 // <<
796 <<
797 wItr = transM->GetWorldsIterator(); <<
798 for (std::size_t iw = 0; iw < nWorlds; ++iw) <<
799 if (*wItr != currentWorld) { <<
800 G4LogicalVolume* pwLogical = (*wItr)->Ge <<
801 if (pwLogical->GetRegion() == nullptr) { <<
802 pwLogical->SetRegion(defaultRegionForP <<
803 defaultRegionForParallelWorld->AddRoot <<
804 } <<
805 } <<
806 ++wItr; <<
807 } <<
808 } 427 }
809 428
810 // ------------------------------------------- <<
811 void G4RunManagerKernel::DumpRegion(const G4St 429 void G4RunManagerKernel::DumpRegion(const G4String& rname) const
812 { 430 {
813 G4Region* region = G4RegionStore::GetInstanc 431 G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
814 if (region != nullptr) DumpRegion(region); << 432 if(region) DumpRegion(region);
815 } 433 }
816 434
817 // ------------------------------------------- <<
818 void G4RunManagerKernel::DumpRegion(G4Region* 435 void G4RunManagerKernel::DumpRegion(G4Region* region) const
819 { 436 {
820 if (region == nullptr) { << 437 if(!region)
821 for (const auto& i : *G4RegionStore::GetIn << 438 {
822 DumpRegion(i); << 439 for(size_t i=0;i<G4RegionStore::GetInstance()->size();i++)
823 } << 440 { DumpRegion((*(G4RegionStore::GetInstance()))[i]); }
824 } 441 }
825 else { << 442 else
826 if (G4Threading::IsWorkerThread()) return; << 443 {
827 G4cout << G4endl; 444 G4cout << G4endl;
828 G4cout << "Region <" << region->GetName() << 445 G4cout << "Region <" << region->GetName() << ">";
829 if (region->GetWorldPhysical() != nullptr) << 446 if(region->GetWorldPhysical())
830 G4cout << " -- appears in <" << region-> << 447 {
831 } << 448 G4cout << " -- appears in <"
832 else { << 449 << region->GetWorldPhysical()->GetName() << "> world volume";
833 G4cout << " -- is not associated to any <<
834 } 450 }
>> 451 else
>> 452 { G4cout << " -- is not associated to any world."; }
835 G4cout << G4endl; 453 G4cout << G4endl;
836 if (region->IsInMassGeometry()) { <<
837 G4cout << " This region is in the mass w <<
838 } <<
839 if (region->IsInParallelGeometry()) { <<
840 G4cout << " This region is in the parall <<
841 } <<
842 454
843 G4cout << " Root logical volume(s) : "; 455 G4cout << " Root logical volume(s) : ";
844 std::size_t nRootLV = region->GetNumberOfR << 456 size_t nRootLV = region->GetNumberOfRootVolumes();
845 auto lvItr = region->GetRootLogicalVolumeI << 457 std::vector<G4LogicalVolume*>::iterator lvItr = region->GetRootLogicalVolumeIterator();
846 for (std::size_t j = 0; j < nRootLV; ++j) << 458 for(size_t j=0;j<nRootLV;j++)
847 G4cout << (*lvItr)->GetName() << " "; << 459 { G4cout << (*lvItr)->GetName() << " "; lvItr++; }
848 ++lvItr; <<
849 } <<
850 G4cout << G4endl; 460 G4cout << G4endl;
851 461
852 G4cout << " Pointers : G4VUserRegionInform << 462 G4cout << " Pointers : G4VUserRegionInformation[" << region->GetUserInformation()
853 << "], G4UserLimits[" << region->Ge << 463 << "], G4UserLimits[" << region->GetUserLimits()
854 << region->GetFastSimulationManager << 464 << "], G4FastSimulationManager[" << region->GetFastSimulationManager()
855 << region->GetRegionalSteppingActio << 465 << "], G4UserSteppingAction[" << region->GetRegionalSteppingAction() << "]" << G4endl;
856 << 466
>> 467 if(region->GetWorldPhysical()!=currentWorld)
>> 468 {
>> 469 G4cout << G4endl;
>> 470 return;
>> 471 }
857 G4cout << " Materials : "; 472 G4cout << " Materials : ";
858 auto mItr = region->GetMaterialIterator(); << 473 std::vector<G4Material*>::const_iterator mItr = region->GetMaterialIterator();
859 std::size_t nMaterial = region->GetNumberO << 474 size_t nMaterial = region->GetNumberOfMaterials();
860 for (std::size_t iMate = 0; iMate < nMater << 475 for(size_t iMate=0;iMate<nMaterial;iMate++)
>> 476 {
861 G4cout << (*mItr)->GetName() << " "; 477 G4cout << (*mItr)->GetName() << " ";
862 ++mItr; << 478 mItr++;
863 } 479 }
864 G4cout << G4endl; 480 G4cout << G4endl;
865 G4ProductionCuts* cuts = region->GetProduc 481 G4ProductionCuts* cuts = region->GetProductionCuts();
866 if ((cuts == nullptr) && region->IsInMassG << 482 if(!cuts)
>> 483 {
867 G4cerr << "Warning : Region <" << region 484 G4cerr << "Warning : Region <" << region->GetName()
868 << "> does not have specific prod 485 << "> does not have specific production cuts." << G4endl;
869 G4cerr << "Default cuts are used for thi 486 G4cerr << "Default cuts are used for this region." << G4endl;
870 region->SetProductionCuts( 487 region->SetProductionCuts(
871 G4ProductionCutsTable::GetProductionCu << 488 G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
872 } 489 }
873 else if (cuts != nullptr) { << 490 else
>> 491 {
874 G4cout << " Production cuts : " 492 G4cout << " Production cuts : "
875 << " gamma " << G4BestUnit(cuts- << 493 << " gamma "
876 << G4BestUnit(cuts->GetProduction << 494 << G4BestUnit(cuts->GetProductionCut("gamma"),"Length")
877 << G4BestUnit(cuts->GetProduction << 495 << " e- "
878 << G4BestUnit(cuts->GetProduction << 496 << G4BestUnit(cuts->GetProductionCut("e-"),"Length")
879 } << 497 << " e+ "
880 } << 498 << G4BestUnit(cuts->GetProductionCut("e+"),"Length")
881 } << 499 << " proton "
882 << 500 << G4BestUnit(cuts->GetProductionCut("proton"),"Length")
883 // ------------------------------------------- << 501 << G4endl;
884 void G4RunManagerKernel::CheckRegularGeometry( <<
885 { <<
886 G4LogicalVolumeStore* store = G4LogicalVolum <<
887 for (const auto& pos : *store) { <<
888 if ((pos != nullptr) && (pos->GetNoDaughte <<
889 if (pos->GetDaughter(0)->IsRegularStruct <<
890 SetScoreSplitter(); <<
891 return; <<
892 } <<
893 } 502 }
894 } 503 }
895 } 504 }
896 505
897 // ------------------------------------------- << 506 #include "G4ParticleTable.hh"
>> 507 #include "G4ParticleDefinition.hh"
>> 508 #include "G4ProcessManager.hh"
>> 509 #include "G4ProcessVector.hh"
>> 510 #include "G4VProcess.hh"
898 G4bool G4RunManagerKernel::ConfirmCoupledTrans 511 G4bool G4RunManagerKernel::ConfirmCoupledTransportation()
899 { 512 {
900 G4ParticleTable* theParticleTable = G4Partic 513 G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
901 auto theParticleIterator = theParticleTable- << 514 G4ParticleTable::G4PTblDicIterator* theParticleIterator = theParticleTable->GetIterator();
902 theParticleIterator->reset(); 515 theParticleIterator->reset();
903 while ((*theParticleIterator)()) { << 516 if((*theParticleIterator)())
>> 517 {
904 G4ParticleDefinition* pd = theParticleIter 518 G4ParticleDefinition* pd = theParticleIterator->value();
905 G4ProcessManager* pm = pd->GetProcessManag 519 G4ProcessManager* pm = pd->GetProcessManager();
906 if (pm != nullptr) { << 520 G4ProcessVector* pv = pm->GetAlongStepProcessVector(typeDoIt);
907 G4ProcessVector* pv = pm->GetAlongStepPr << 521 G4VProcess* p = (*pv)[0];
908 G4VProcess* p = (*pv)[0]; << 522 return ( (p->GetProcessName()) == "CoupledTransportation" );
909 return ((p->GetProcessName()) == "Couple <<
910 } <<
911 } 523 }
912 return false; 524 return false;
913 } 525 }
914 526
915 // ------------------------------------------- <<
916 void G4RunManagerKernel::SetScoreSplitter() <<
917 { <<
918 auto pSplitter = new G4ScoreSplittingProcess <<
919 G4ParticleTable* theParticleTable = G4Partic <<
920 auto theParticleIterator = theParticleTable- <<
921 <<
922 // Ensure that Process is added only once to <<
923 static G4ThreadLocal G4bool InitSplitter = f <<
924 if (!InitSplitter) { <<
925 InitSplitter = true; <<
926 <<
927 theParticleIterator->reset(); <<
928 while ((*theParticleIterator)()) { <<
929 G4ParticleDefinition* particle = thePart <<
930 G4ProcessManager* pmanager = particle->G <<
931 if (pmanager != nullptr) { <<
932 pmanager->AddDiscreteProcess(pSplitter <<
933 } <<
934 } <<
935 <<
936 if (verboseLevel > 0) { <<
937 G4cout << "G4RunManagerKernel -- G4Score <<
938 "particles." <<
939 << G4endl; <<
940 } <<
941 } <<
942 } <<
943 <<
944 // ------------------------------------------- <<
945 void G4RunManagerKernel::SetupShadowProcess() <<
946 { <<
947 G4ParticleTable* theParticleTable = G4Partic <<
948 auto theParticleIterator = theParticleTable- <<
949 theParticleIterator->reset(); <<
950 // loop on particles and get process manager <<
951 while ((*theParticleIterator)()) { <<
952 G4ParticleDefinition* pd = theParticleIter <<
953 G4ProcessManager* pm = pd->GetProcessManag <<
954 if (pm != nullptr) { <<
955 G4ProcessVector& procs = *(pm->GetProces <<
956 for (G4int idx = 0; idx < (G4int)procs.s <<
957 const G4VProcess* masterP = procs[idx] <<
958 if (masterP == nullptr) { <<
959 // Process does not have an associat <<
960 // We are in master mode or sequenti <<
961 procs[idx]->SetMasterProcess(const_c <<
962 } <<
963 } <<
964 } <<
965 } <<
966 } <<
967 527