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

Last change on this file since 1331 was 1315, checked in by garnier, 14 years ago

update geant4-09-04-beta-cand-01 interfaces-V09-03-09 vis-V09-03-08
File size: 19.1 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.48 2010/06/11 09:02:55 gcosmo Exp $
28// GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
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  G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
86  if(particleTable->entries()>0)
87  {
88    // No particle should be registered beforehand
89    G4cerr<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<G4endl;
90    G4cerr<<" G4RunManagerKernel fatal exception"<<G4endl;
91    G4cerr<<"  -- Following particles have already been registered"<<G4endl;
92    G4cerr<<"     before G4RunManagerKernel is instantiated."<<G4endl;
93    for(int i=0;i<particleTable->entries();i++)
94    { G4cerr<<"     "<<particleTable->GetParticle(i)->GetParticleName()<<G4endl; }
95    G4cerr<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<G4endl;
96    G4Exception("G4RunManagerKernel::G4RunManagerKernel()","StaticParticleDefinition",
97       FatalException,"Particles have already been instantiated before G4RunManagerKernel.");
98  }
99 
100  // construction of Geant4 kernel classes
101  eventManager = new G4EventManager();
102  defaultRegion = new G4Region("DefaultRegionForTheWorld"); // deleted by store
103  defaultRegion->SetProductionCuts(
104    G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
105
106  // Following line is tentatively moved from SetPhysics method
107  // Commented out for introduction of non-static particle definition // G4ParticleTable::GetParticleTable()->SetReadiness();
108  // set the initial application state
109  G4StateManager::GetStateManager()->SetNewState(G4State_PreInit);
110
111  // version banner
112  G4String vs = G4Version;
113  vs = vs.substr(1,vs.size()-2);
114  versionString = " Geant4 version ";
115  versionString += vs;
116  versionString += "   ";
117  versionString += G4Date;
118  G4cout << G4endl
119    << "*************************************************************" << G4endl
120    << versionString << G4endl
121    << "                      Copyright : Geant4 Collaboration" << G4endl
122    << "                      Reference : NIM A 506 (2003), 250-303" << G4endl
123    << "                            WWW : http://cern.ch/geant4" << G4endl
124    << "*************************************************************" << G4endl
125    << G4endl;
126}
127
128G4RunManagerKernel::~G4RunManagerKernel()
129{
130  // set the application state to the quite state
131  if(verboseLevel>0) G4cout << "G4 kernel has come to Quit state." << G4endl;
132  G4StateManager* pStateManager = G4StateManager::GetStateManager();
133  pStateManager->SetNewState(G4State_Quit);
134
135  // open geometry for deletion
136  G4GeometryManager::GetInstance()->OpenGeometry();
137
138  // deletion of Geant4 kernel classes
139  G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
140  if(fSDM)
141  {
142    delete fSDM;
143    if(verboseLevel>1) G4cout << "G4SDManager deleted." << G4endl;
144  }
145  delete eventManager;
146  if(verboseLevel>1) G4cout << "EventManager deleted." << G4endl;
147  G4UImanager* pUImanager = G4UImanager::GetUIpointer();
148  {
149    if(pUImanager) delete pUImanager;
150    if(verboseLevel>1) G4cout << "UImanager deleted." << G4endl;
151  }
152  G4UnitDefinition::ClearUnitsTable();
153  if(verboseLevel>1) G4cout << "Units table cleared." << G4endl;
154  delete pStateManager; 
155  if(verboseLevel>1) G4cout << "StateManager deleted." << G4endl;
156  delete defaultExceptionHandler;
157  if(verboseLevel>1) G4cout << "RunManagerKernel is deleted." << G4endl;
158  fRunManagerKernel = 0;
159}
160
161void G4RunManagerKernel::DefineWorldVolume(G4VPhysicalVolume* worldVol,
162                                     G4bool topologyIsChanged)
163{
164  G4StateManager*    stateManager = G4StateManager::GetStateManager();
165  G4ApplicationState currentState = stateManager->GetCurrentState();
166  if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
167  { 
168    G4Exception("G4RunManagerKernel::DefineWorldVolume",
169                "DefineWorldVolumeAtIncorrectState",
170                JustWarning,
171                "Geant4 kernel is not PreInit or Idle state : Method ignored.");
172    if(verboseLevel>1) G4cerr << "Current application state is " 
173      << stateManager->GetStateString(currentState) << G4endl;
174    return;
175  }
176
177  // The world volume MUST NOT have a region defined by the user
178  if(worldVol->GetLogicalVolume()->GetRegion())
179  {
180    if(worldVol->GetLogicalVolume()->GetRegion()!=defaultRegion)
181    {
182      G4cerr << "The world volume has a user-defined region <"
183           << worldVol->GetLogicalVolume()->GetRegion()->GetName()
184           << ">." << G4endl;
185      G4Exception("G4RunManager::DefineWorldVolume",
186                "RUN:WorldHasUserDefinedRegion",
187                FatalException,
188                "World would have a default region assigned by RunManagerKernel.");
189    }
190  }
191
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  }
208
209  // Accept the world volume
210  currentWorld = worldVol; 
211
212  // Set the default region to the world
213  G4LogicalVolume* worldLog = currentWorld->GetLogicalVolume();
214  worldLog->SetRegion(defaultRegion);
215  defaultRegion->AddRootLogicalVolume(worldLog);
216  if(verboseLevel>1) G4cout << worldLog->GetName()
217   << " is registered to the default region." << G4endl;
218
219  // Set the world volume, notify the Navigator and reset its state
220  G4TransportationManager::GetTransportationManager()
221      ->SetWorldForTracking(currentWorld);
222  if(topologyIsChanged) geometryNeedsToBeClosed = true;
223 
224  // Notify the VisManager as well
225  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
226  if(pVVisManager) pVVisManager->GeometryHasChanged();
227
228  geometryInitialized = true;
229  if(physicsInitialized && currentState!=G4State_Idle)
230  { stateManager->SetNewState(G4State_Idle); }
231} 
232 
233void G4RunManagerKernel::SetPhysics(G4VUserPhysicsList* uPhys)
234{
235  physicsList = uPhys;
236  G4ParticleTable::GetParticleTable()->SetReadiness();
237  physicsList->ConstructParticle();
238  if(verboseLevel>2) G4ParticleTable::GetParticleTable()->DumpTable();
239  if(verboseLevel>1)
240  {
241    G4cout << "List of instantiated particles ============================================" << G4endl;
242    G4int nPtcl = G4ParticleTable::GetParticleTable()->entries();
243    for(G4int i=0;i<nPtcl;i++)
244    {
245      G4ParticleDefinition* pd = G4ParticleTable::GetParticleTable()->GetParticle(i);
246      G4cout << pd->GetParticleName() << " ";
247      if(i%10==9) G4cout << G4endl;
248    }
249    G4cout << G4endl;
250  }
251}
252 
253void G4RunManagerKernel::InitializePhysics()
254{
255  G4StateManager*    stateManager = G4StateManager::GetStateManager();
256  G4ApplicationState currentState = stateManager->GetCurrentState();
257  if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
258  { 
259    G4Exception("G4RunManagerKernel::InitializePhysics",
260                "InitializePhysicsAtIncorrectState",
261                JustWarning,
262                "Geant4 kernel is not PreInit or Idle state : Method ignored.");
263    return;
264  }
265
266  if(!physicsList)
267  {
268    G4Exception("G4RunManagerKernel::InitializePhysics",
269                "PhysicsListIsNotDefined",
270                FatalException,
271                "G4VUserPhysicsList is not defined");
272  }
273
274  //if(verboseLevel>1) G4cout << "physicsList->ConstructParticle() start." << G4endl;
275  //physicsList->ConstructParticle();
276
277  if(verboseLevel>1) G4cout << "physicsList->Construct() start." << G4endl;
278  if(numberOfParallelWorld>0) physicsList->UseCoupledTransportation();
279  physicsList->Construct();
280
281  if(verboseLevel>1) G4cout << "physicsList->CheckParticleList() start." << G4endl;
282  physicsList->CheckParticleList();
283  if(verboseLevel>1) G4cout << "physicsList->setCut() start." << G4endl;
284  physicsList->SetCuts();
285  CheckRegions();
286  physicsInitialized = true;
287  if(geometryInitialized && currentState!=G4State_Idle)
288  { stateManager->SetNewState(G4State_Idle); }
289}
290
291G4bool G4RunManagerKernel::RunInitialization()
292{
293  G4StateManager*    stateManager = G4StateManager::GetStateManager();
294  G4ApplicationState currentState = stateManager->GetCurrentState();
295
296  if(!geometryInitialized) 
297  { 
298    G4Exception("G4RunManagerKernel::RunInitialization",
299                "GeometryHasNotYetInitialized",
300                JustWarning,
301                "Geometry has not yet initialized : method ignored.");
302    return false;
303  }
304 
305  if(!physicsInitialized) 
306  { 
307    G4Exception("G4RunManagerKernel::RunInitialization",
308                "PhysicsHasNotYetInitialized",
309                JustWarning,
310                "Physics has not yet initialized : method ignored.");
311    return false;
312  }
313
314  if( currentState != G4State_Idle )
315  { 
316    G4Exception("G4RunManagerKernel::RunInitialization",
317                "RunInitializationAtIncorrectState",
318                JustWarning,
319                "Geant4 kernel not in Idle state : method ignored.");
320    return false;
321  }
322
323  //if(numberOfParallelWorld>0)
324  //{ // Confirm G4CoupledTransportation is used
325  //  if(!ConfirmCoupledTransportation())
326  //  { G4Exception("G4CoupledTransportation must be used for parallel world."); }
327  //}
328   
329  UpdateRegion();
330  BuildPhysicsTables();
331
332  if(geometryNeedsToBeClosed) ResetNavigator();
333 
334  GetPrimaryTransformer()->CheckUnknown();
335
336  stateManager->SetNewState(G4State_GeomClosed);
337  return true;
338}
339
340void G4RunManagerKernel::RunTermination()
341{ G4StateManager::GetStateManager()->SetNewState(G4State_Idle); }
342
343void G4RunManagerKernel::ResetNavigator()
344{
345  // We have to tweak the navigator's state in case a geometry has been
346  // modified between runs. By the following calls we ensure that navigator's
347  // state is reset properly. It is required the geometry to be closed
348  // and previous optimisations to be cleared.
349 
350  G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
351  if(verboseLevel>1) G4cout << "Start closing geometry." << G4endl;
352  geomManager->OpenGeometry();
353  geomManager->CloseGeometry(geometryToBeOptimized, verboseLevel>1);
354 
355  // Reseting Navigator has been moved to G4Eventmanager, so that resetting
356  // is now done for every event. 
357  // G4ThreeVector center(0,0,0);
358  // G4Navigator* navigator =
359  //     G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
360  // navigator->LocateGlobalPointAndSetup(center,0,false);
361
362  geometryNeedsToBeClosed = false;
363}
364
365void G4RunManagerKernel::UpdateRegion()
366{
367  G4StateManager*    stateManager = G4StateManager::GetStateManager();
368  G4ApplicationState currentState = stateManager->GetCurrentState();
369  if( currentState != G4State_Idle )
370  { 
371    G4Exception("G4RunManagerKernel::UpdateRegion",
372                "RegionUpdateAtIncorrectState",
373                JustWarning,
374                "Geant4 kernel not in Idle state : method ignored.");
375    return;
376  }
377
378  CheckRegions();
379  G4RegionStore::GetInstance()->UpdateMaterialList(currentWorld);
380  G4ProductionCutsTable::GetProductionCutsTable()->UpdateCoupleTable(currentWorld);
381}
382
383void G4RunManagerKernel::BuildPhysicsTables()
384{ 
385  if(G4ProductionCutsTable::GetProductionCutsTable()->IsModified()
386  || physicsNeedsToBeReBuilt)
387  {
388    physicsList->BuildPhysicsTable();
389    G4ProductionCutsTable::GetProductionCutsTable()->PhysicsTableUpdated();
390    physicsNeedsToBeReBuilt = false;
391  }
392
393  if(verboseLevel>1) DumpRegion();
394  if(verboseLevel>0) physicsList->DumpCutValuesTable();
395  physicsList->DumpCutValuesTableIfRequested();
396}
397
398void G4RunManagerKernel::CheckRegions()
399{
400  G4TransportationManager* transM = G4TransportationManager::GetTransportationManager();
401  size_t nWorlds = transM->GetNoWorlds();
402  std::vector<G4VPhysicalVolume*>::iterator wItr;
403  for(size_t i=0;i<G4RegionStore::GetInstance()->size();i++)
404  { 
405    G4Region* region = (*(G4RegionStore::GetInstance()))[i];
406
407    //Let each region have a pointer to the world volume where it belongs to.
408    //G4Region::SetWorld() checks if the region belongs to the given world and set it
409    //only if it does. Thus, here we go through all the registered world volumes.
410    wItr = transM->GetWorldsIterator();
411    for(size_t iw=0;iw<nWorlds;iw++)
412    {
413      region->SetWorld(*wItr);
414      wItr++;
415    }
416
417    //Now check for the regions which belongs to the tracking world
418    if(region->GetWorldPhysical()!=currentWorld) continue;
419
420    G4ProductionCuts* cuts = region->GetProductionCuts();
421    if(!cuts)
422    {
423      G4cerr << "Warning : Region <" << region->GetName()
424             << "> does not have specific production cuts," << G4endl
425             << "even though it appears in the current tracking world." << G4endl;
426      G4cerr << "Default cuts are used for this region." << G4endl;
427      region->SetProductionCuts(
428          G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
429    }
430  }
431}
432
433void G4RunManagerKernel::DumpRegion(const G4String& rname) const
434{
435  G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
436  if(region) DumpRegion(region);
437}
438
439void G4RunManagerKernel::DumpRegion(G4Region* region) const
440{
441  if(!region)
442  {
443    for(size_t i=0;i<G4RegionStore::GetInstance()->size();i++)
444    { DumpRegion((*(G4RegionStore::GetInstance()))[i]); }
445  }
446  else
447  {
448    G4cout << G4endl;
449    G4cout << "Region <" << region->GetName() << ">";
450    if(region->GetWorldPhysical())
451    {
452      G4cout << " -- appears in <" 
453           << region->GetWorldPhysical()->GetName() << "> world volume";
454    }
455    else
456    { G4cout << " -- is not associated to any world."; }
457    G4cout << G4endl;
458
459    G4cout << " Root logical volume(s) : ";
460    size_t nRootLV = region->GetNumberOfRootVolumes();
461    std::vector<G4LogicalVolume*>::iterator lvItr = region->GetRootLogicalVolumeIterator();
462    for(size_t j=0;j<nRootLV;j++)
463    { G4cout << (*lvItr)->GetName() << " "; lvItr++; }
464    G4cout << G4endl;
465
466    G4cout << " Pointers : G4VUserRegionInformation[" << region->GetUserInformation() 
467           << "], G4UserLimits[" << region->GetUserLimits() 
468           << "], G4FastSimulationManager[" << region->GetFastSimulationManager()
469           << "], G4UserSteppingAction[" << region->GetRegionalSteppingAction() << "]" << G4endl;
470   
471    if(region->GetWorldPhysical()!=currentWorld)
472    {
473      G4cout << G4endl;
474      return;
475    }
476    G4cout << " Materials : ";
477    std::vector<G4Material*>::const_iterator mItr = region->GetMaterialIterator();
478    size_t nMaterial = region->GetNumberOfMaterials();
479    for(size_t iMate=0;iMate<nMaterial;iMate++)
480    {
481      G4cout << (*mItr)->GetName() << " ";
482      mItr++;
483    }
484    G4cout << G4endl;
485    G4ProductionCuts* cuts = region->GetProductionCuts();
486    if(!cuts)
487    {
488      G4cerr << "Warning : Region <" << region->GetName()
489             << "> does not have specific production cuts." << G4endl;
490      G4cerr << "Default cuts are used for this region." << G4endl;
491      region->SetProductionCuts(
492          G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
493    }
494    G4cout << " Production cuts : "
495           << "  gamma " << G4BestUnit(cuts->GetProductionCut("gamma"),"Length")
496           << "     e- " << G4BestUnit(cuts->GetProductionCut("e-"),"Length")
497           << "     e+ " << G4BestUnit(cuts->GetProductionCut("e+"),"Length")
498           << " proton " << G4BestUnit(cuts->GetProductionCut("proton"),"Length")
499           << G4endl;
500  }
501}
502
503#include "G4ParticleTable.hh"
504#include "G4ParticleDefinition.hh"
505#include "G4ProcessManager.hh"
506#include "G4ProcessVector.hh"
507#include "G4VProcess.hh"
508G4bool G4RunManagerKernel::ConfirmCoupledTransportation()
509{
510  G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
511  G4ParticleTable::G4PTblDicIterator* theParticleIterator = theParticleTable->GetIterator();
512  theParticleIterator->reset();
513  if((*theParticleIterator)())
514  {
515    G4ParticleDefinition* pd = theParticleIterator->value();
516    G4ProcessManager* pm = pd->GetProcessManager();
517    G4ProcessVector* pv = pm->GetAlongStepProcessVector(typeDoIt);
518    G4VProcess* p = (*pv)[0];
519    return ( (p->GetProcessName()) == "CoupledTransportation" );
520  }
521  return false;
522}
523
Note: See TracBrowser for help on using the repository browser.