Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ErrorPropagatorManager.cc
Go to the documentation of this file.
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 // $Id: G4ErrorPropagatorManager.cc 78318 2013-12-11 15:02:40Z gcosmo $
27 //
28 // ------------------------------------------------------------
29 // GEANT 4 class implementation file
30 // ------------------------------------------------------------
31 //
32 
34 
35 #include "G4SystemOfUnits.hh"
37 #include "G4Mag_UsualEqRhs.hh"
38 #include "G4Mag_EqRhs.hh"
39 #include "G4MagIntegratorDriver.hh"
40 
41 #include "G4ClassicalRK4.hh"
42 #include "G4ExactHelixStepper.hh"
43 #include "G4HelixExplicitEuler.hh"
44 
45 #include "G4EventManager.hh"
47 #include "G4ErrorPropagator.hh"
48 #include "G4ErrorMag_UsualEqRhs.hh"
49 
50 #include "G4VParticleChange.hh"
52 #include "G4ParticleChange.hh"
53 #include "G4Track.hh"
56 #include "G4GeometryManager.hh"
57 #include "G4StateManager.hh"
58 #include "G4ChordFinder.hh"
59 #include "G4EquationOfMotion.hh"
60 #include "G4FieldManager.hh"
61 #include "G4PropagatorInField.hh"
62 #include "G4RunManager.hh"
63 #include "G4VParticleChange.hh"
64 
66 G4ErrorPropagatorManager::theG4ErrorPropagatorManager = 0;
67 
68 //-----------------------------------------------------------------------
70 {
71  if( theG4ErrorPropagatorManager == NULL ) {
72  theG4ErrorPropagatorManager = new G4ErrorPropagatorManager;
73  }
74 
75  return theG4ErrorPropagatorManager;
76 }
77 
78 
79 //-----------------------------------------------------------------------
81 {
82  //----- Initialize a few things
83  //o theG4ErrorPropagatorManager = this;
84 
85  char* g4emverb = getenv("G4EVERBOSE");
86  if( !g4emverb ) {
88  } else {
90  }
91 
92  thePropagator = 0;
93 
94  theEquationOfMotion = 0;
95 
96  StartG4ErrorRunManagerHelper();
97 
99 
100  theG4ErrorPropagationNavigator = 0;
101 
102  StartNavigator(); //navigator has to be initialized at the beggining !?!?!
103 
104 
105 }
106 
107 
108 //-----------------------------------------------------------------------
110 {
111  delete theEquationOfMotion;
112  delete theG4ErrorPropagationNavigator;
113  delete thePropagator;
114  delete theG4ErrorRunManagerHelper;
115  delete theG4ErrorPropagatorManager;
116 }
117 
118 
119 //-----------------------------------------------------------------------
120 void G4ErrorPropagatorManager::StartG4ErrorRunManagerHelper()
121 {
122  //----- Initialize G4ErrorRunManagerHelper
123  theG4ErrorRunManagerHelper = G4ErrorRunManagerHelper::GetRunManagerKernel();
124 
125  if( theG4ErrorRunManagerHelper == 0 ) {
126  theG4ErrorRunManagerHelper = new G4ErrorRunManagerHelper();
127  }
128 
129  //----- User Initialization classes
130  //--- GEANT4e PhysicsList
131  if( G4ErrorPropagatorData::verbose() >= 4 ) G4cout << " G4ErrorPropagatorManager::StartG4eRunManager() done " << theG4ErrorRunManagerHelper << G4endl;
132  //- theG4eRunManager->SetUserInitialization(new G4ErrorPhysicsList);
133 
134 }
135 
136 
137 //-----------------------------------------------------------------------
138 void G4ErrorPropagatorManager::StartNavigator()
139 {
140  if( theG4ErrorPropagationNavigator == 0 ) {
142 
143  G4Navigator* g4navi = transportationManager->GetNavigatorForTracking();
144 
145  G4VPhysicalVolume* world = g4navi->GetWorldVolume();
146  G4int verb = g4navi->GetVerboseLevel();
147  delete g4navi;
148 
149  theG4ErrorPropagationNavigator = new G4ErrorPropagationNavigator();
150 
151  if( world != 0 ) {
152  theG4ErrorPropagationNavigator->SetWorldVolume( world );
153  }
154  theG4ErrorPropagationNavigator->SetVerboseLevel( verb );
155 
156  transportationManager->SetNavigatorForTracking(theG4ErrorPropagationNavigator);
157  transportationManager->GetPropagatorInField()->GetIntersectionLocator()
158  ->SetNavigatorFor(theG4ErrorPropagationNavigator);
160  ->SetNavigator(theG4ErrorPropagationNavigator);
161  // G4ThreeVector center(0,0,0);
162  // theG4ErrorPropagationNavigator->LocateGlobalPointAndSetup(center,0,false);
163 
164  }
165 
166  if( G4ErrorPropagatorData::verbose() >= 2 ) G4cout << " theState at StartNavigator " << PrintG4ErrorState() << G4endl;
167 
168 }
169 
170 
171 //-----------------------------------------------------------------------
173 {
174  if( G4ErrorPropagatorData::verbose() >= 1 ) G4cout << "InitGeant4e GEANT4e State= " << PrintG4ErrorState() << " GEANT4 State= " << PrintG4State() << G4endl;
176  //----- Initialize run
177  // if( G4StateManager::GetStateManager()->GetCurrentState() == G4State_PreInit) {
178 
180  if ( currentState == G4State_PreInit || currentState == G4State_Idle) {
181  // G4eRunManager::GetRunManager()->Initialize();
182  theG4ErrorRunManagerHelper->InitializeGeometry();
183  theG4ErrorRunManagerHelper->InitializePhysics();
184  }
185 
187 
188  //- G4StateManager::GetStateManager()->SetNewState(G4State_Idle);
189 
190  if( G4ErrorPropagatorData::verbose() >= 4 ) G4cout << " bef theG4ErrorPropagatorManager->RunInitialization() " << G4StateManager::GetStateManager()->GetCurrentState() << G4endl;
191  theG4ErrorRunManagerHelper->RunInitialization();
192  if( G4ErrorPropagatorData::verbose() >= 4 ) G4cout << " aft theG4ErrorPropagatorManager->RunInitialization() " << G4StateManager::GetStateManager()->GetCurrentState() << G4endl;
193 
194  if( !thePropagator ) thePropagator = new G4ErrorPropagator(); // currently the only propagator possible
195 
197  } else {
198  std::ostringstream message;
199  message << "Illegal GEANT4e State= " << PrintG4ErrorState();
200  G4Exception("G4ErrorPropagatorManager::InitGeant4e()",
201  "IllegalState", JustWarning, message);
202  }
203 
204  //----- Set the tracking geometry for this propagation
205  //t SetTrackingGeometry();
206  //----- Set the physics list for this propagation
207  //t SetPhysicsList();
208  //----- Set the field propagation parameters for this propagation
209  //t SetFieldPropagationParameters();
211 
212  if( G4ErrorPropagatorData::verbose() >= 2 ) G4cout << "End InitGeant4e GEANT4e State= " << PrintG4ErrorState() << " GEANT4 State= " << PrintG4State() << G4endl;
213 
214 
215 }
216 
217 
218 //-----------------------------------------------------------------------
220 {
221  thePropagator->SetStepN( 0 );
222 
224 
225 }
226 
227 
228 //-----------------------------------------------------------------------
230 {
231 
232  if( G4ErrorPropagatorData::verbose() >= 4 ) G4cout << " G4ErrorPropagatorManager::InitFieldForBackwards() " << G4endl;
233  //----- Gets the current equation of motion
235  // G4cout << " fieldMgr " << fieldMgr << G4endl;
236  if( !fieldMgr ) return 0;
237 
238  // G4Field* myfield = fieldMgr->GetDetectorField();
239  G4ChordFinder* cf = fieldMgr ->GetChordFinder();
240  if( !cf ) return 0;
242  if( !mid ) return 0;
243  G4MagIntegratorStepper* stepper = const_cast<G4MagIntegratorStepper*>(mid->GetStepper());
244  if( !stepper ) return 0;
245  G4EquationOfMotion* equation = stepper->GetEquationOfMotion();
246 
247  //----- Replaces the equation by a G4ErrorMag_UsualEqRhs to handle backwards tracking
248  if ( !dynamic_cast<G4ErrorMag_UsualEqRhs*>(equation) ) {
249 
250  G4MagneticField* myfield = (G4MagneticField*)fieldMgr->GetDetectorField();
251 
252  // G4Mag_UsualEqRhs* fEquation_usual = dynamic_cast<G4Mag_UsualEqRhs*>(equation);
253  if( theEquationOfMotion == 0 ) theEquationOfMotion = new G4ErrorMag_UsualEqRhs(myfield);
254 
255  //---- Pass the equation of motion to the G4MagIntegratorStepper
256  stepper->SetEquationOfMotion( theEquationOfMotion );
257 
258  //--- change stepper for speed tests
259  G4MagIntegratorStepper* g4eStepper = new G4ClassicalRK4(theEquationOfMotion);
260  // G4MagIntegratorStepper* g4eStepper = new G4ExactHelixStepper(theEquationOfMotion);
261 
262  //----
263  G4MagneticField* field = static_cast<G4MagneticField*>(const_cast<G4Field*>(fieldMgr->GetDetectorField()));
264  G4ChordFinder* pChordFinder = new G4ChordFinder(field, 1.0e-2*mm, g4eStepper);
265 
266  fieldMgr->SetChordFinder(pChordFinder);
267 
268  }
269 
270  return 1;
271 }
272 
273 
274 //-----------------------------------------------------------------------
276 {
278  if( !thePropagator ) thePropagator = new G4ErrorPropagator(); // currently the only propagator possible
279 
282 
283  G4int ierr = thePropagator->Propagate( currentTS, target, mode );
284 
286 
287  return ierr;
288 }
289 
290 
291 //-----------------------------------------------------------------------
293 {
295 
296  if( !thePropagator ) thePropagator = new G4ErrorPropagator(); // currently the only propagator possible
297 
299 
300  return thePropagator->PropagateOneStep( currentTS );
301 }
302 
303 
304 //-----------------------------------------------------------------------
306 {
308  geomManager->OpenGeometry();
309  if( G4StateManager::GetStateManager()->GetCurrentState() != G4State_GeomClosed) {
311  }
312 
313  return TRUE;
314 }
315 
316 
317 //---------------------------------------------------------------------------
319 {
320  theG4ErrorRunManagerHelper->SetUserInitialization( userInit);
321 }
322 
323 
324 //---------------------------------------------------------------------------
326 {
327  theG4ErrorRunManagerHelper->SetUserInitialization( userInit);
328 }
329 
330 
331 //---------------------------------------------------------------------------
333 {
334  theG4ErrorRunManagerHelper->SetUserInitialization( userInit);
335 }
336 
337 
338 //---------------------------------------------------------------------------
340 {
342 }
343 
344 
345 //---------------------------------------------------------------------------
347 {
349 }
350 
351 
352 //---------------------------------------------------------------------------
354 {
356  trkmgr->GetSteppingManager()->SetVerboseLevel( trkmgr->GetVerboseLevel() );
357 }
358 
359 
360 //---------------------------------------------------------------------------
362 {
364 }
365 
366 
367 //---------------------------------------------------------------------------
369 {
371  theG4ErrorRunManagerHelper->RunTermination();
372 }
373 
374 
375 //---------------------------------------------------------------------------
377 {
379 }
380 
381 
382 //---------------------------------------------------------------------------
384 {
385  G4String nam = "";
386  switch (state){
387  case G4ErrorState_PreInit:
388  nam = "G4ErrorState_PreInit";
389  break;
390  case G4ErrorState_Init:
391  nam = "G4ErrorState_Init";
392  break;
394  nam = "G4ErrorState_Propagating";
395  break;
397  nam = "G4ErrorState_TargetCloserThanBoundary";
398  break;
400  nam = "G4ErrorState_StoppedAtTarget";
401  break;
402  }
403 
404  return nam;
405 }
406 
407 
408 //---------------------------------------------------------------------------
410 {
411  return PrintG4State(G4StateManager::GetStateManager()->GetCurrentState());
412 }
413 
414 
415 //---------------------------------------------------------------------------
417 {
418  G4String nam = "";
419  switch ( state ){
420  case G4State_PreInit:
421  nam = "G4State_PreInit";
422  break;
423  case G4State_Init:
424  nam = "G4State_Init";
425  break;
426  case G4State_Idle:
427  nam = "G4State_Idle";
428  break;
429  case G4State_GeomClosed:
430  nam = "G4State_GeomClosed";
431  break;
432  case G4State_EventProc:
433  nam = "G4State_EventProc";
434  break;
435  case G4State_Quit:
436  nam = "G4State_Quit";
437  break;
438  case G4State_Abort:
439  nam = "G4State_Abort";
440  break;
441  }
442 
443  return nam;
444 
445 }
G4int PropagateOneStep(G4ErrorTrajState *currentTS, G4ErrorMode mode=G4ErrorMode_PropForwards)
G4ChordFinder * GetChordFinder()
void SetUserAction(G4UserTrackingAction *userAction)
void SetEquationOfMotion(G4EquationOfMotion *newEquation)
static constexpr double mm
Definition: G4SIunits.hh:115
const XML_Char * target
Definition: expat.h:268
G4SteppingManager * GetSteppingManager() const
void SetNavigator(G4Navigator *value)
G4int Propagate(G4ErrorTrajState *currentTS, const G4ErrorTarget *target, G4ErrorMode mode=G4ErrorMode_PropForwards)
const G4MagIntegratorStepper * GetStepper() const
G4int PropagateOneStep(G4ErrorTrajState *currentTS)
void SetVerboseLevel(G4int vLevel)
G4int GetVerboseLevel() const
G4Navigator * GetNavigatorForTracking() const
#define G4ThreadLocal
Definition: tls.hh:89
void SetChordFinder(G4ChordFinder *aChordFinder)
static G4ErrorPropagatorManager * GetErrorPropagatorManager()
int G4int
Definition: G4Types.hh:78
void SetVerboseLevel(G4int level)
void SetState(G4ErrorState sta)
static G4StateManager * GetStateManager()
G4TrackingManager * GetTrackingManager() const
G4EquationOfMotion * GetEquationOfMotion()
static void SetVerbose(G4int ver)
G4GLOB_DLL std::ostream G4cout
G4bool SetNewState(G4ApplicationState requestedState)
void SetUserInitialization(G4VUserDetectorConstruction *userInit)
bool G4bool
Definition: G4Types.hh:79
void SetMode(G4ErrorMode mode)
#define TRUE
Definition: globals.hh:55
G4ApplicationState GetCurrentState() const
static G4GeometryManager * GetInstance()
void SetStepN(const G4int sn)
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
static G4TransportationManager * GetTransportationManager()
G4FieldManager * GetFieldManager() const
void SetUserAction(G4UserEventAction *userAction)
void SetWorldVolume(G4VPhysicalVolume *pWorld)
static G4EventManager * GetEventManager()
G4int Propagate(G4ErrorTrajState *currentTS, const G4ErrorTarget *target, G4ErrorMode mode=G4ErrorMode_PropForwards)
void SetNavigatorFor(G4Navigator *fNavigator)
#define G4endl
Definition: G4ios.hh:61
G4int GetVerboseLevel() const
void OpenGeometry(G4VPhysicalVolume *vol=0)
static G4ErrorRunManagerHelper * GetRunManagerKernel()
static G4ErrorPropagatorData * GetErrorPropagatorData()
const G4Field * GetDetectorField() const
G4MagInt_Driver * GetIntegrationDriver()
G4PropagatorInField * GetPropagatorInField() const
G4VIntersectionLocator * GetIntersectionLocator()
void SetNavigatorForTracking(G4Navigator *newNavigator)
G4VPhysicalVolume * GetWorldVolume() const
G4ApplicationState
void SetUserInitialization(G4VUserDetectorConstruction *userInit)