source: trunk/source/run/src/G4RunManagerKernel.cc@ 1064

Last change on this file since 1064 was 1058, checked in by garnier, 17 years ago

file release beta
File size: 18.0 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4RunManagerKernel.cc,v 1.43 2008/07/10 09:27:19 gcosmo Exp $
28// GEANT4 tag $Name: geant4-09-02-ref-02 $
29//
30//
31
32#include "G4RunManagerKernel.hh"
33
34#include <vector>
35
36#include "G4StateManager.hh"
37#include "G4ApplicationState.hh"
38#include "G4ExceptionHandler.hh"
39#include "G4PrimaryTransformer.hh"
40#include "G4GeometryManager.hh"
41#include "G4TransportationManager.hh"
42#include "G4VPhysicalVolume.hh"
43#include "G4LogicalVolume.hh"
44#include "G4VUserPhysicsList.hh"
45#include "G4ParticleTable.hh"
46#include "G4Region.hh"
47#include "G4RegionStore.hh"
48#include "G4ProductionCuts.hh"
49#include "G4ProductionCutsTable.hh"
50#include "G4SDManager.hh"
51#include "G4UImanager.hh"
52#include "G4VVisManager.hh"
53#include "G4UnitsTable.hh"
54#include "G4Version.hh"
55#include "G4ios.hh"
56
57#ifdef G4FPE_DEBUG
58 #include "G4FPEDetection.hh"
59#endif
60
61G4RunManagerKernel* G4RunManagerKernel::fRunManagerKernel = 0;
62
63G4RunManagerKernel* G4RunManagerKernel::GetRunManagerKernel()
64{ return fRunManagerKernel; }
65
66G4RunManagerKernel::G4RunManagerKernel()
67:physicsList(0),currentWorld(0),
68 geometryInitialized(false),physicsInitialized(false),
69 geometryNeedsToBeClosed(true),geometryToBeOptimized(true),
70 physicsNeedsToBeReBuilt(true),verboseLevel(0),
71 numberOfParallelWorld(0)
72{
73#ifdef G4FPE_DEBUG
74 InvalidOperationDetection();
75#endif
76
77 defaultExceptionHandler = new G4ExceptionHandler();
78 if(fRunManagerKernel)
79 {
80 G4Exception("G4RunManagerKernel::G4RunManagerKernel()","MoreThanOneRunManager",
81 FatalException,"More than one G4RunManagerKernel is constructed.");
82 }
83 fRunManagerKernel = this;
84
85 // construction of Geant4 kernel classes
86 eventManager = new G4EventManager();
87 defaultRegion = new G4Region("DefaultRegionForTheWorld"); // deleted by store
88 defaultRegion->SetProductionCuts(
89 G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
90
91 // Following line is tentatively moved from SetPhysics method
92 // Commented out for introduction of non-static particle definition // G4ParticleTable::GetParticleTable()->SetReadiness();
93 // set the initial application state
94 G4StateManager::GetStateManager()->SetNewState(G4State_PreInit);
95
96 // version banner
97 G4String vs = G4Version;
98 vs = vs.substr(1,vs.size()-2);
99 versionString = " Geant4 version ";
100 versionString += vs;
101 versionString += " ";
102 versionString += G4Date;
103 G4cout << G4endl
104 << "*************************************************************" << G4endl
105 << versionString << G4endl
106 << " Copyright : Geant4 Collaboration" << G4endl
107 << " Reference : NIM A 506 (2003), 250-303" << G4endl
108 << " WWW : http://cern.ch/geant4" << G4endl
109 << "*************************************************************" << G4endl
110 << G4endl;
111}
112
113G4RunManagerKernel::~G4RunManagerKernel()
114{
115 // set the application state to the quite state
116 if(verboseLevel>0) G4cout << "G4 kernel has come to Quit state." << G4endl;
117 G4StateManager* pStateManager = G4StateManager::GetStateManager();
118 pStateManager->SetNewState(G4State_Quit);
119
120 // open geometry for deletion
121 G4GeometryManager::GetInstance()->OpenGeometry();
122
123 // deletion of Geant4 kernel classes
124 G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
125 if(fSDM)
126 {
127 delete fSDM;
128 if(verboseLevel>1) G4cout << "G4SDManager deleted." << G4endl;
129 }
130 delete eventManager;
131 if(verboseLevel>1) G4cout << "EventManager deleted." << G4endl;
132 G4UImanager* pUImanager = G4UImanager::GetUIpointer();
133 {
134 if(pUImanager) delete pUImanager;
135 if(verboseLevel>1) G4cout << "UImanager deleted." << G4endl;
136 }
137 G4UnitDefinition::ClearUnitsTable();
138 if(verboseLevel>1) G4cout << "Units table cleared." << G4endl;
139 delete pStateManager;
140 if(verboseLevel>1) G4cout << "StateManager deleted." << G4endl;
141 delete defaultExceptionHandler;
142 if(verboseLevel>1) G4cout << "RunManagerKernel is deleted." << G4endl;
143 fRunManagerKernel = 0;
144}
145
146void G4RunManagerKernel::DefineWorldVolume(G4VPhysicalVolume* worldVol,
147 G4bool topologyIsChanged)
148{
149 G4StateManager* stateManager = G4StateManager::GetStateManager();
150 G4ApplicationState currentState = stateManager->GetCurrentState();
151 if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
152 {
153 G4Exception("G4RunManagerKernel::DefineWorldVolume",
154 "DefineWorldVolumeAtIncorrectState",
155 JustWarning,
156 "Geant4 kernel is not PreInit or Idle state : Method ignored.");
157 if(verboseLevel>1) G4cerr << "Current application state is "
158 << stateManager->GetStateString(currentState) << G4endl;
159 return;
160 }
161
162 // The world volume MUST NOT have a region defined by the user
163 if(worldVol->GetLogicalVolume()->GetRegion())
164 {
165 if(worldVol->GetLogicalVolume()->GetRegion()!=defaultRegion)
166 {
167 G4cerr << "The world volume has a user-defined region <"
168 << worldVol->GetLogicalVolume()->GetRegion()->GetName()
169 << ">." << G4endl;
170 G4Exception("G4RunManager::DefineWorldVolume",
171 "RUN:WorldHasUserDefinedRegion",
172 FatalException,
173 "World would have a default region assigned by RunManagerKernel.");
174 }
175 }
176
177 // Remove old world logical volume from the default region, if exist
178 if(defaultRegion->GetNumberOfRootVolumes())
179 {
180 if(defaultRegion->GetNumberOfRootVolumes()>size_t(1))
181 {
182 G4Exception("G4RunManager::DefineWorldVolume",
183 "DefaultRegionHasMoreThanOneVolume",
184 FatalException,
185 "Default world region should have a unique logical volume.");
186 }
187 std::vector<G4LogicalVolume*>::iterator lvItr
188 = defaultRegion->GetRootLogicalVolumeIterator();
189 defaultRegion->RemoveRootLogicalVolume(*lvItr,false);
190 if(verboseLevel>1) G4cout
191 << "Obsolete world logical volume is removed from the default region." << G4endl;
192 }
193
194 // Accept the world volume
195 currentWorld = worldVol;
196
197 // Set the default region to the world
198 G4LogicalVolume* worldLog = currentWorld->GetLogicalVolume();
199 worldLog->SetRegion(defaultRegion);
200 defaultRegion->AddRootLogicalVolume(worldLog);
201 if(verboseLevel>1) G4cout << worldLog->GetName()
202 << " is registered to the default region." << G4endl;
203
204 // Set the world volume, notify the Navigator and reset its state
205 G4TransportationManager::GetTransportationManager()
206 ->SetWorldForTracking(currentWorld);
207 if(topologyIsChanged) geometryNeedsToBeClosed = true;
208
209 // Notify the VisManager as well
210 G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
211 if(pVVisManager) pVVisManager->GeometryHasChanged();
212
213 geometryInitialized = true;
214 if(physicsInitialized && currentState!=G4State_Idle)
215 { stateManager->SetNewState(G4State_Idle); }
216}
217
218void G4RunManagerKernel::SetPhysics(G4VUserPhysicsList* uPhys)
219{
220 physicsList = uPhys;
221 G4ParticleTable::GetParticleTable()->SetReadiness();
222 physicsList->ConstructParticle();
223 if(verboseLevel>2) G4ParticleTable::GetParticleTable()->DumpTable();
224 if(verboseLevel>1)
225 {
226 G4cout << "List of instantiated particles ============================================" << G4endl;
227 G4int nPtcl = G4ParticleTable::GetParticleTable()->entries();
228 for(G4int i=0;i<nPtcl;i++)
229 {
230 G4ParticleDefinition* pd = G4ParticleTable::GetParticleTable()->GetParticle(i);
231 G4cout << pd->GetParticleName() << " ";
232 if(i%10==9) G4cout << G4endl;
233 }
234 G4cout << G4endl;
235 }
236}
237
238void G4RunManagerKernel::InitializePhysics()
239{
240 G4StateManager* stateManager = G4StateManager::GetStateManager();
241 G4ApplicationState currentState = stateManager->GetCurrentState();
242 if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
243 {
244 G4Exception("G4RunManagerKernel::InitializePhysics",
245 "InitializePhysicsAtIncorrectState",
246 JustWarning,
247 "Geant4 kernel is not PreInit or Idle state : Method ignored.");
248 return;
249 }
250
251 if(!physicsList)
252 {
253 G4Exception("G4RunManagerKernel::InitializePhysics",
254 "PhysicsListIsNotDefined",
255 FatalException,
256 "G4VUserPhysicsList is not defined");
257 }
258
259 //if(verboseLevel>1) G4cout << "physicsList->ConstructParticle() start." << G4endl;
260 //physicsList->ConstructParticle();
261
262 if(verboseLevel>1) G4cout << "physicsList->Construct() start." << G4endl;
263 if(numberOfParallelWorld>0) physicsList->UseCoupledTransportation();
264 physicsList->Construct();
265
266 if(verboseLevel>1) G4cout << "physicsList->setCut() start." << G4endl;
267 physicsList->SetCuts();
268 CheckRegions();
269 physicsInitialized = true;
270 if(geometryInitialized && currentState!=G4State_Idle)
271 { stateManager->SetNewState(G4State_Idle); }
272}
273
274G4bool G4RunManagerKernel::RunInitialization()
275{
276 G4StateManager* stateManager = G4StateManager::GetStateManager();
277 G4ApplicationState currentState = stateManager->GetCurrentState();
278
279 if(!geometryInitialized)
280 {
281 G4Exception("G4RunManagerKernel::RunInitialization",
282 "GeometryHasNotYetInitialized",
283 JustWarning,
284 "Geometry has not yet initialized : method ignored.");
285 return false;
286 }
287
288 if(!physicsInitialized)
289 {
290 G4Exception("G4RunManagerKernel::RunInitialization",
291 "PhysicsHasNotYetInitialized",
292 JustWarning,
293 "Physics has not yet initialized : method ignored.");
294 return false;
295 }
296
297 if( currentState != G4State_Idle )
298 {
299 G4Exception("G4RunManagerKernel::RunInitialization",
300 "RunInitializationAtIncorrectState",
301 JustWarning,
302 "Geant4 kernel not in Idle state : method ignored.");
303 return false;
304 }
305
306 //if(numberOfParallelWorld>0)
307 //{ // Confirm G4CoupledTransportation is used
308 // if(!ConfirmCoupledTransportation())
309 // { G4Exception("G4CoupledTransportation must be used for parallel world."); }
310 //}
311
312 UpdateRegion();
313 BuildPhysicsTables();
314
315 if(geometryNeedsToBeClosed) ResetNavigator();
316
317 GetPrimaryTransformer()->CheckUnknown();
318
319 stateManager->SetNewState(G4State_GeomClosed);
320 return true;
321}
322
323void G4RunManagerKernel::RunTermination()
324{ G4StateManager::GetStateManager()->SetNewState(G4State_Idle); }
325
326void G4RunManagerKernel::ResetNavigator()
327{
328 // We have to tweak the navigator's state in case a geometry has been
329 // modified between runs. By the following calls we ensure that navigator's
330 // state is reset properly. It is required the geometry to be closed
331 // and previous optimisations to be cleared.
332
333 G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
334 if(verboseLevel>1) G4cout << "Start closing geometry." << G4endl;
335 geomManager->OpenGeometry();
336 geomManager->CloseGeometry(geometryToBeOptimized, verboseLevel>1);
337
338 // Reseting Navigator has been moved to G4Eventmanager, so that resetting
339 // is now done for every event.
340 // G4ThreeVector center(0,0,0);
341 // G4Navigator* navigator =
342 // G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
343 // navigator->LocateGlobalPointAndSetup(center,0,false);
344
345 geometryNeedsToBeClosed = false;
346}
347
348void G4RunManagerKernel::UpdateRegion()
349{
350 G4StateManager* stateManager = G4StateManager::GetStateManager();
351 G4ApplicationState currentState = stateManager->GetCurrentState();
352 if( currentState != G4State_Idle )
353 {
354 G4Exception("G4RunManagerKernel::UpdateRegion",
355 "RegionUpdateAtIncorrectState",
356 JustWarning,
357 "Geant4 kernel not in Idle state : method ignored.");
358 return;
359 }
360
361 CheckRegions();
362 G4RegionStore::GetInstance()->UpdateMaterialList(currentWorld);
363 G4ProductionCutsTable::GetProductionCutsTable()->UpdateCoupleTable(currentWorld);
364}
365
366void G4RunManagerKernel::BuildPhysicsTables()
367{
368 if(G4ProductionCutsTable::GetProductionCutsTable()->IsModified()
369 || physicsNeedsToBeReBuilt)
370 {
371 physicsList->BuildPhysicsTable();
372 G4ProductionCutsTable::GetProductionCutsTable()->PhysicsTableUpdated();
373 physicsNeedsToBeReBuilt = false;
374 }
375
376 if(verboseLevel>1) DumpRegion();
377 if(verboseLevel>0) physicsList->DumpCutValuesTable();
378 physicsList->DumpCutValuesTableIfRequested();
379}
380
381void G4RunManagerKernel::CheckRegions()
382{
383 G4TransportationManager* transM = G4TransportationManager::GetTransportationManager();
384 size_t nWorlds = transM->GetNoWorlds();
385 std::vector<G4VPhysicalVolume*>::iterator wItr;
386 for(size_t i=0;i<G4RegionStore::GetInstance()->size();i++)
387 {
388 G4Region* region = (*(G4RegionStore::GetInstance()))[i];
389
390 //Let each region have a pointer to the world volume where it belongs to.
391 //G4Region::SetWorld() checks if the region belongs to the given world and set it
392 //only if it does. Thus, here we go through all the registered world volumes.
393 wItr = transM->GetWorldsIterator();
394 for(size_t iw=0;iw<nWorlds;iw++)
395 {
396 region->SetWorld(*wItr);
397 wItr++;
398 }
399
400 //Now check for the regions which belongs to the tracking world
401 if(region->GetWorldPhysical()!=currentWorld) continue;
402
403 G4ProductionCuts* cuts = region->GetProductionCuts();
404 if(!cuts)
405 {
406 G4cerr << "Warning : Region <" << region->GetName()
407 << "> does not have specific production cuts," << G4endl
408 << "even though it appears in the current tracking world." << G4endl;
409 G4cerr << "Default cuts are used for this region." << G4endl;
410 region->SetProductionCuts(
411 G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
412 }
413 }
414}
415
416void G4RunManagerKernel::DumpRegion(G4String rname) const
417{
418 G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
419 if(region) DumpRegion(region);
420}
421
422void G4RunManagerKernel::DumpRegion(G4Region* region) const
423{
424 if(!region)
425 {
426 for(size_t i=0;i<G4RegionStore::GetInstance()->size();i++)
427 { DumpRegion((*(G4RegionStore::GetInstance()))[i]); }
428 }
429 else
430 {
431 G4cout << G4endl;
432 G4cout << "Region <" << region->GetName() << ">";
433 if(region->GetWorldPhysical())
434 {
435 G4cout << " -- appears in <"
436 << region->GetWorldPhysical()->GetName() << "> world volume";
437 }
438 else
439 { G4cout << " -- is not associated to any world."; }
440 G4cout << G4endl;
441
442 G4cout << " Root logical volume(s) : ";
443 size_t nRootLV = region->GetNumberOfRootVolumes();
444 std::vector<G4LogicalVolume*>::iterator lvItr = region->GetRootLogicalVolumeIterator();
445 for(size_t j=0;j<nRootLV;j++)
446 { G4cout << (*lvItr)->GetName() << " "; }
447 G4cout << G4endl;
448
449 G4cout << " Pointers : G4VUserRegionInformation[" << region->GetUserInformation()
450 << "], G4UserLimits[" << region->GetUserLimits()
451 << "], G4FastSimulationManager[" << region->GetFastSimulationManager()
452 << "], G4UserSteppingAction[" << region->GetRegionalSteppingAction() << "]" << G4endl;
453
454 if(region->GetWorldPhysical()!=currentWorld)
455 {
456 G4cout << G4endl;
457 return;
458 }
459 G4cout << " Materials : ";
460 std::vector<G4Material*>::const_iterator mItr = region->GetMaterialIterator();
461 size_t nMaterial = region->GetNumberOfMaterials();
462 for(size_t iMate=0;iMate<nMaterial;iMate++)
463 {
464 G4cout << (*mItr)->GetName() << " ";
465 mItr++;
466 }
467 G4cout << G4endl;
468 G4ProductionCuts* cuts = region->GetProductionCuts();
469 if(!cuts)
470 {
471 G4cerr << "Warning : Region <" << region->GetName()
472 << "> does not have specific production cuts." << G4endl;
473 G4cerr << "Default cuts are used for this region." << G4endl;
474 region->SetProductionCuts(
475 G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
476 }
477 G4cout << " Production cuts : "
478 << " gamma " << G4BestUnit(cuts->GetProductionCut("gamma"),"Length")
479 << " e- " << G4BestUnit(cuts->GetProductionCut("e-"),"Length")
480 << " e+ " << G4BestUnit(cuts->GetProductionCut("e+"),"Length")
481 << G4endl;
482 }
483}
484
485#include "G4ParticleTable.hh"
486#include "G4ParticleDefinition.hh"
487#include "G4ProcessManager.hh"
488#include "G4ProcessVector.hh"
489#include "G4VProcess.hh"
490G4bool G4RunManagerKernel::ConfirmCoupledTransportation()
491{
492 G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
493 G4ParticleTable::G4PTblDicIterator* theParticleIterator = theParticleTable->GetIterator();
494 theParticleIterator->reset();
495 if((*theParticleIterator)())
496 {
497 G4ParticleDefinition* pd = theParticleIterator->value();
498 G4ProcessManager* pm = pd->GetProcessManager();
499 G4ProcessVector* pv = pm->GetAlongStepProcessVector(typeDoIt);
500 G4VProcess* p = (*pv)[0];
501 return ( (p->GetProcessName()) == "CoupledTransportation" );
502 }
503 return false;
504}
505
Note: See TracBrowser for help on using the repository browser.