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

Last change on this file since 842 was 828, checked in by garnier, 16 years ago

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