Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/error_propagation/src/G4ErrorPropagatorManager.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /error_propagation/src/G4ErrorPropagatorManager.cc (Version 11.3.0) and /error_propagation/src/G4ErrorPropagatorManager.cc (Version 11.0)


  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 //                                                 26 //
 27 // -------------------------------------------     27 // ------------------------------------------------------------
 28 //      GEANT 4 class implementation file          28 //      GEANT 4 class implementation file
 29 // -------------------------------------------     29 // ------------------------------------------------------------
 30 //                                                 30 //
 31                                                    31 
 32 #include "G4ErrorPropagatorManager.hh"             32 #include "G4ErrorPropagatorManager.hh"
 33                                                    33 
 34 #include "G4SystemOfUnits.hh"                      34 #include "G4SystemOfUnits.hh"
 35 #include "G4MagIntegratorStepper.hh"               35 #include "G4MagIntegratorStepper.hh"
 36 #include "G4Mag_UsualEqRhs.hh"                     36 #include "G4Mag_UsualEqRhs.hh"
 37 #include "G4Mag_EqRhs.hh"                          37 #include "G4Mag_EqRhs.hh"
 38 #include "G4MagIntegratorDriver.hh"                38 #include "G4MagIntegratorDriver.hh"
 39                                                    39 
 40 #include "G4ClassicalRK4.hh"                       40 #include "G4ClassicalRK4.hh"
 41 #include "G4ExactHelixStepper.hh"                  41 #include "G4ExactHelixStepper.hh"
 42 #include "G4HelixExplicitEuler.hh"                 42 #include "G4HelixExplicitEuler.hh"
 43                                                    43 
 44 #include "G4EventManager.hh"                       44 #include "G4EventManager.hh"
 45 #include "G4ErrorRunManagerHelper.hh"              45 #include "G4ErrorRunManagerHelper.hh"
 46 #include "G4ErrorPropagator.hh"                    46 #include "G4ErrorPropagator.hh"
 47 #include "G4ErrorMag_UsualEqRhs.hh"                47 #include "G4ErrorMag_UsualEqRhs.hh"
 48                                                    48 
 49 #include "G4VParticleChange.hh"                    49 #include "G4VParticleChange.hh"
 50 #include "G4ParticleChangeForMSC.hh"               50 #include "G4ParticleChangeForMSC.hh"
 51 #include "G4ParticleChange.hh"                     51 #include "G4ParticleChange.hh"
 52 #include "G4Track.hh"                              52 #include "G4Track.hh"
 53 #include "G4TransportationManager.hh"              53 #include "G4TransportationManager.hh"
 54 #include "G4ErrorPropagationNavigator.hh"          54 #include "G4ErrorPropagationNavigator.hh"
 55 #include "G4GeometryManager.hh"                    55 #include "G4GeometryManager.hh"
 56 #include "G4StateManager.hh"                       56 #include "G4StateManager.hh"
 57 #include "G4ChordFinder.hh"                        57 #include "G4ChordFinder.hh"
 58 #include "G4EquationOfMotion.hh"                   58 #include "G4EquationOfMotion.hh"
 59 #include "G4FieldManager.hh"                       59 #include "G4FieldManager.hh"
 60 #include "G4PropagatorInField.hh"                  60 #include "G4PropagatorInField.hh"
 61 #include "G4RunManager.hh"                         61 #include "G4RunManager.hh"
 62 #include "G4VParticleChange.hh"                    62 #include "G4VParticleChange.hh"
 63                                                    63 
 64 G4ThreadLocal G4ErrorPropagatorManager*            64 G4ThreadLocal G4ErrorPropagatorManager*
 65   G4ErrorPropagatorManager::theG4ErrorPropagat     65   G4ErrorPropagatorManager::theG4ErrorPropagatorManager = 0;
 66                                                    66 
 67 //--------------------------------------------     67 //-----------------------------------------------------------------------
 68 G4ErrorPropagatorManager* G4ErrorPropagatorMan     68 G4ErrorPropagatorManager* G4ErrorPropagatorManager::GetErrorPropagatorManager()
 69 {                                                  69 {
 70   if(theG4ErrorPropagatorManager == NULL)          70   if(theG4ErrorPropagatorManager == NULL)
 71   {                                                71   {
 72     theG4ErrorPropagatorManager = new G4ErrorP     72     theG4ErrorPropagatorManager = new G4ErrorPropagatorManager;
 73   }                                                73   }
 74                                                    74 
 75   return theG4ErrorPropagatorManager;              75   return theG4ErrorPropagatorManager;
 76 }                                                  76 }
 77                                                    77 
 78 //--------------------------------------------     78 //-----------------------------------------------------------------------
 79 G4ErrorPropagatorManager::G4ErrorPropagatorMan     79 G4ErrorPropagatorManager::G4ErrorPropagatorManager()
 80 {                                                  80 {
 81   //----- Initialize a few things                  81   //----- Initialize a few things
 82   // o  theG4ErrorPropagatorManager = this;        82   // o  theG4ErrorPropagatorManager = this;
 83                                                    83 
 84   char* g4emverb = std::getenv("G4EVERBOSE");      84   char* g4emverb = std::getenv("G4EVERBOSE");
 85   if(!g4emverb)                                    85   if(!g4emverb)
 86   {                                                86   {
 87     G4ErrorPropagatorData::GetErrorPropagatorD     87     G4ErrorPropagatorData::GetErrorPropagatorData()->SetVerbose(0);
 88   }                                                88   }
 89   else                                             89   else
 90   {                                                90   {
 91     G4ErrorPropagatorData::GetErrorPropagatorD     91     G4ErrorPropagatorData::GetErrorPropagatorData()->SetVerbose(atoi(g4emverb));
 92   }                                                92   }
 93                                                    93 
 94   thePropagator = 0;                               94   thePropagator = 0;
 95                                                    95 
 96   theEquationOfMotion = 0;                         96   theEquationOfMotion = 0;
 97                                                    97 
 98   StartG4ErrorRunManagerHelper();                  98   StartG4ErrorRunManagerHelper();
 99                                                    99 
100   G4ErrorPropagatorData::GetErrorPropagatorDat    100   G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(
101     G4ErrorState_PreInit);                        101     G4ErrorState_PreInit);
102                                                   102 
103   theG4ErrorPropagationNavigator = 0;             103   theG4ErrorPropagationNavigator = 0;
104                                                   104 
105   StartNavigator();  // navigator has to be in    105   StartNavigator();  // navigator has to be initialized at the beggining !?!?!
106 }                                                 106 }
107                                                   107 
108 //--------------------------------------------    108 //-----------------------------------------------------------------------
109 G4ErrorPropagatorManager::~G4ErrorPropagatorMa    109 G4ErrorPropagatorManager::~G4ErrorPropagatorManager()
110 {                                                 110 {
111   delete theEquationOfMotion;                     111   delete theEquationOfMotion;
112   delete theG4ErrorPropagationNavigator;          112   delete theG4ErrorPropagationNavigator;
113   delete thePropagator;                           113   delete thePropagator;
114   delete theG4ErrorRunManagerHelper;              114   delete theG4ErrorRunManagerHelper;
115   delete theG4ErrorPropagatorManager;             115   delete theG4ErrorPropagatorManager;
116 }                                                 116 }
117                                                   117 
118 //--------------------------------------------    118 //-----------------------------------------------------------------------
119 void G4ErrorPropagatorManager::StartG4ErrorRun    119 void G4ErrorPropagatorManager::StartG4ErrorRunManagerHelper()
120 {                                                 120 {
121   //----- Initialize G4ErrorRunManagerHelper      121   //----- Initialize G4ErrorRunManagerHelper
122   theG4ErrorRunManagerHelper = G4ErrorRunManag    122   theG4ErrorRunManagerHelper = G4ErrorRunManagerHelper::GetRunManagerKernel();
123                                                   123 
124   if(theG4ErrorRunManagerHelper == 0)             124   if(theG4ErrorRunManagerHelper == 0)
125   {                                               125   {
126     theG4ErrorRunManagerHelper = new G4ErrorRu    126     theG4ErrorRunManagerHelper = new G4ErrorRunManagerHelper();
127   }                                               127   }
128                                                   128 
129   //----- User Initialization classes             129   //----- User Initialization classes
130   //--- GEANT4e PhysicsList                       130   //--- GEANT4e PhysicsList
131   if(G4ErrorPropagatorData::verbose() >= 4)       131   if(G4ErrorPropagatorData::verbose() >= 4)
132     G4cout << " G4ErrorPropagatorManager::Star    132     G4cout << " G4ErrorPropagatorManager::StartG4eRunManager() done "
133            << theG4ErrorRunManagerHelper << G4    133            << theG4ErrorRunManagerHelper << G4endl;
134   //-  theG4eRunManager->SetUserInitialization    134   //-  theG4eRunManager->SetUserInitialization(new G4ErrorPhysicsList);
135 }                                                 135 }
136                                                   136 
137 //--------------------------------------------    137 //-----------------------------------------------------------------------
138 void G4ErrorPropagatorManager::StartNavigator(    138 void G4ErrorPropagatorManager::StartNavigator()
139 {                                                 139 {
140   if(theG4ErrorPropagationNavigator == 0)         140   if(theG4ErrorPropagationNavigator == 0)
141   {                                               141   {
142     G4TransportationManager* transportationMan    142     G4TransportationManager* transportationManager =
143       G4TransportationManager::GetTransportati    143       G4TransportationManager::GetTransportationManager();
144                                                   144 
145     G4Navigator* g4navi = transportationManage    145     G4Navigator* g4navi = transportationManager->GetNavigatorForTracking();
146                                                   146 
147     G4VPhysicalVolume* world = g4navi->GetWorl    147     G4VPhysicalVolume* world = g4navi->GetWorldVolume();
148     G4int verb               = g4navi->GetVerb    148     G4int verb               = g4navi->GetVerboseLevel();
149     delete g4navi;                                149     delete g4navi;
150                                                   150 
151     theG4ErrorPropagationNavigator = new G4Err    151     theG4ErrorPropagationNavigator = new G4ErrorPropagationNavigator();
152                                                   152 
153     if(world != 0)                                153     if(world != 0)
154     {                                             154     {
155       theG4ErrorPropagationNavigator->SetWorld    155       theG4ErrorPropagationNavigator->SetWorldVolume(world);
156     }                                             156     }
157     theG4ErrorPropagationNavigator->SetVerbose    157     theG4ErrorPropagationNavigator->SetVerboseLevel(verb);
158                                                   158 
159     transportationManager->SetNavigatorForTrac    159     transportationManager->SetNavigatorForTracking(
160       theG4ErrorPropagationNavigator);            160       theG4ErrorPropagationNavigator);
161     transportationManager->GetPropagatorInFiel    161     transportationManager->GetPropagatorInField()
162       ->GetIntersectionLocator()                  162       ->GetIntersectionLocator()
163       ->SetNavigatorFor(theG4ErrorPropagationN    163       ->SetNavigatorFor(theG4ErrorPropagationNavigator);
164     G4EventManager::GetEventManager()             164     G4EventManager::GetEventManager()
165       ->GetTrackingManager()                      165       ->GetTrackingManager()
166       ->GetSteppingManager()                      166       ->GetSteppingManager()
167       ->SetNavigator(theG4ErrorPropagationNavi    167       ->SetNavigator(theG4ErrorPropagationNavigator);
168     //  G4ThreeVector center(0,0,0);              168     //  G4ThreeVector center(0,0,0);
169     //  theG4ErrorPropagationNavigator->Locate    169     //  theG4ErrorPropagationNavigator->LocateGlobalPointAndSetup(center,0,false);
170   }                                               170   }
171                                                   171 
172   if(G4ErrorPropagatorData::verbose() >= 2)       172   if(G4ErrorPropagatorData::verbose() >= 2)
173     G4cout << " theState at StartNavigator " <    173     G4cout << " theState at StartNavigator " << PrintG4ErrorState() << G4endl;
174 }                                                 174 }
175                                                   175 
176 //--------------------------------------------    176 //-----------------------------------------------------------------------
177 void G4ErrorPropagatorManager::InitGeant4e()      177 void G4ErrorPropagatorManager::InitGeant4e()
178 {                                                 178 {
179   if(G4ErrorPropagatorData::verbose() >= 1)       179   if(G4ErrorPropagatorData::verbose() >= 1)
180     G4cout << "InitGeant4e GEANT4e State= " <<    180     G4cout << "InitGeant4e GEANT4e State= " << PrintG4ErrorState()
181            << " GEANT4 State= " << PrintG4Stat    181            << " GEANT4 State= " << PrintG4State() << G4endl;
182   G4ApplicationState currentState =               182   G4ApplicationState currentState =
183     G4StateManager::GetStateManager()->GetCurr    183     G4StateManager::GetStateManager()->GetCurrentState();
184   //----- Initialize run                          184   //----- Initialize run
185   //  if( G4StateManager::GetStateManager()->G    185   //  if( G4StateManager::GetStateManager()->GetCurrentState() ==
186   //  G4State_PreInit) {                          186   //  G4State_PreInit) {
187                                                   187 
188   if(G4ErrorPropagatorData::GetErrorPropagator    188   if(G4ErrorPropagatorData::GetErrorPropagatorData()->GetState() ==
189      G4ErrorState_PreInit)                        189      G4ErrorState_PreInit)
190   {                                               190   {
191     if(currentState == G4State_PreInit || curr    191     if(currentState == G4State_PreInit || currentState == G4State_Idle)
192     {                                             192     {
193       //    G4eRunManager::GetRunManager()->In    193       //    G4eRunManager::GetRunManager()->Initialize();
194       theG4ErrorRunManagerHelper->InitializeGe    194       theG4ErrorRunManagerHelper->InitializeGeometry();
195       theG4ErrorRunManagerHelper->InitializePh    195       theG4ErrorRunManagerHelper->InitializePhysics();
196     }                                             196     }
197                                                   197 
198     InitFieldForBackwards();                      198     InitFieldForBackwards();
199                                                   199 
200     //-    G4StateManager::GetStateManager()->    200     //-    G4StateManager::GetStateManager()->SetNewState(G4State_Idle);
201                                                   201 
202     if(G4ErrorPropagatorData::verbose() >= 4)     202     if(G4ErrorPropagatorData::verbose() >= 4)
203       G4cout << " bef  theG4ErrorPropagatorMan    203       G4cout << " bef  theG4ErrorPropagatorManager->RunInitialization() "
204              << G4StateManager::GetStateManage    204              << G4StateManager::GetStateManager()->GetCurrentState() << G4endl;
205     theG4ErrorRunManagerHelper->RunInitializat    205     theG4ErrorRunManagerHelper->RunInitialization();
206     if(G4ErrorPropagatorData::verbose() >= 4)     206     if(G4ErrorPropagatorData::verbose() >= 4)
207       G4cout << " aft  theG4ErrorPropagatorMan    207       G4cout << " aft  theG4ErrorPropagatorManager->RunInitialization() "
208              << G4StateManager::GetStateManage    208              << G4StateManager::GetStateManager()->GetCurrentState() << G4endl;
209                                                   209 
210     if(!thePropagator)                            210     if(!thePropagator)
211       thePropagator =                             211       thePropagator =
212         new G4ErrorPropagator();  // currently    212         new G4ErrorPropagator();  // currently the only propagator possible
213                                                   213 
214     InitTrackPropagation();                       214     InitTrackPropagation();
215   }                                               215   }
216   else                                            216   else
217   {                                               217   {
218     std::ostringstream message;                   218     std::ostringstream message;
219     message << "Illegal GEANT4e State= " << Pr    219     message << "Illegal GEANT4e State= " << PrintG4ErrorState();
220     G4Exception("G4ErrorPropagatorManager::Ini    220     G4Exception("G4ErrorPropagatorManager::InitGeant4e()", "IllegalState",
221                 JustWarning, message);            221                 JustWarning, message);
222   }                                               222   }
223                                                   223 
224   //----- Set the tracking geometry for this p    224   //----- Set the tracking geometry for this propagation
225   // t  SetTrackingGeometry();                    225   // t  SetTrackingGeometry();
226   //----- Set the physics list for this propag    226   //----- Set the physics list for this propagation
227   // t  SetPhysicsList();                         227   // t  SetPhysicsList();
228   //----- Set the field propagation parameters    228   //----- Set the field propagation parameters for this propagation
229   // t  SetFieldPropagationParameters();          229   // t  SetFieldPropagationParameters();
230   G4ErrorPropagatorData::GetErrorPropagatorDat    230   G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(G4ErrorState_Init);
231                                                   231 
232   if(G4ErrorPropagatorData::verbose() >= 2)       232   if(G4ErrorPropagatorData::verbose() >= 2)
233     G4cout << "End InitGeant4e GEANT4e State=     233     G4cout << "End InitGeant4e GEANT4e State= " << PrintG4ErrorState()
234            << " GEANT4 State= " << PrintG4Stat    234            << " GEANT4 State= " << PrintG4State() << G4endl;
235 }                                                 235 }
236                                                   236 
237 //--------------------------------------------    237 //-----------------------------------------------------------------------
238 void G4ErrorPropagatorManager::InitTrackPropag    238 void G4ErrorPropagatorManager::InitTrackPropagation()
239 {                                                 239 {
240   thePropagator->SetStepN(0);                     240   thePropagator->SetStepN(0);
241                                                   241 
242   G4ErrorPropagatorData::GetErrorPropagatorDat    242   G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(
243     G4ErrorState_Propagating);                    243     G4ErrorState_Propagating);
244 }                                                 244 }
245                                                   245 
246 //--------------------------------------------    246 //-----------------------------------------------------------------------
247 G4bool G4ErrorPropagatorManager::InitFieldForB    247 G4bool G4ErrorPropagatorManager::InitFieldForBackwards()
248 {                                                 248 {
249   if(G4ErrorPropagatorData::verbose() >= 4)       249   if(G4ErrorPropagatorData::verbose() >= 4)
250     G4cout << " G4ErrorPropagatorManager::Init    250     G4cout << " G4ErrorPropagatorManager::InitFieldForBackwards() " << G4endl;
251   //----- Gets the current equation of motion     251   //----- Gets the current equation of motion
252   G4FieldManager* fieldMgr =                      252   G4FieldManager* fieldMgr =
253     G4TransportationManager::GetTransportation    253     G4TransportationManager::GetTransportationManager()->GetFieldManager();
254   //  G4cout << " fieldMgr " << fieldMgr << G4    254   //  G4cout << " fieldMgr " << fieldMgr << G4endl;
255   if(!fieldMgr)                                   255   if(!fieldMgr)
256     return 0;                                     256     return 0;
257                                                   257 
258   //  G4Field* myfield = fieldMgr->GetDetector    258   //  G4Field* myfield = fieldMgr->GetDetectorField();
259   G4ChordFinder* cf = fieldMgr->GetChordFinder    259   G4ChordFinder* cf = fieldMgr->GetChordFinder();
260   if(!cf)                                         260   if(!cf)
261     return 0;                                     261     return 0;
262   auto driver = cf->GetIntegrationDriver();       262   auto driver = cf->GetIntegrationDriver();
263   if(!driver)                                     263   if(!driver)
264     return 0;                                     264     return 0;
265   auto equation = driver->GetEquationOfMotion(    265   auto equation = driver->GetEquationOfMotion();
266                                                   266 
267   //----- Replaces the equation by a G4ErrorMa    267   //----- Replaces the equation by a G4ErrorMag_UsualEqRhs to handle backwards
268   //tracking                                      268   //tracking
269   if(!dynamic_cast<G4ErrorMag_UsualEqRhs*>(equ    269   if(!dynamic_cast<G4ErrorMag_UsualEqRhs*>(equation))
270   {                                               270   {
271     G4MagneticField* myfield = (G4MagneticFiel    271     G4MagneticField* myfield = (G4MagneticField*) fieldMgr->GetDetectorField();
272                                                   272 
273     //    G4Mag_UsualEqRhs* fEquation_usual =     273     //    G4Mag_UsualEqRhs* fEquation_usual =
274     //    dynamic_cast<G4Mag_UsualEqRhs*>(equa    274     //    dynamic_cast<G4Mag_UsualEqRhs*>(equation);
275     if(theEquationOfMotion == 0)                  275     if(theEquationOfMotion == 0)
276       theEquationOfMotion = new G4ErrorMag_Usu    276       theEquationOfMotion = new G4ErrorMag_UsualEqRhs(myfield);
277                                                   277 
278     //---- Pass the equation of motion to the     278     //---- Pass the equation of motion to the G4MagIntegratorStepper
279     driver->SetEquationOfMotion(theEquationOfM    279     driver->SetEquationOfMotion(theEquationOfMotion);
280                                                   280 
281     //--- change stepper for speed tests          281     //--- change stepper for speed tests
282     G4MagIntegratorStepper* g4eStepper =          282     G4MagIntegratorStepper* g4eStepper =
283       new G4ClassicalRK4(theEquationOfMotion);    283       new G4ClassicalRK4(theEquationOfMotion);
284     // G4MagIntegratorStepper* g4eStepper = ne    284     // G4MagIntegratorStepper* g4eStepper = new
285     // G4ExactHelixStepper(theEquationOfMotion    285     // G4ExactHelixStepper(theEquationOfMotion);
286                                                   286 
287     //----                                        287     //----
288     G4MagneticField* field = static_cast<G4Mag    288     G4MagneticField* field = static_cast<G4MagneticField*>(
289       const_cast<G4Field*>(fieldMgr->GetDetect    289       const_cast<G4Field*>(fieldMgr->GetDetectorField()));
290     G4ChordFinder* pChordFinder =                 290     G4ChordFinder* pChordFinder =
291       new G4ChordFinder(field, 1.0e-2 * mm, g4    291       new G4ChordFinder(field, 1.0e-2 * mm, g4eStepper);
292                                                   292 
293     fieldMgr->SetChordFinder(pChordFinder);       293     fieldMgr->SetChordFinder(pChordFinder);
294   }                                               294   }
295                                                   295 
296   return 1;                                       296   return 1;
297 }                                                 297 }
298                                                   298 
299 //--------------------------------------------    299 //-----------------------------------------------------------------------
300 G4int G4ErrorPropagatorManager::Propagate(G4Er    300 G4int G4ErrorPropagatorManager::Propagate(G4ErrorTrajState* currentTS,
301                                           cons    301                                           const G4ErrorTarget* target,
302                                           G4Er    302                                           G4ErrorMode mode)
303 {                                                 303 {
304   G4ErrorPropagatorData::GetErrorPropagatorDat    304   G4ErrorPropagatorData::GetErrorPropagatorData()->SetMode(mode);
305   if(!thePropagator)                              305   if(!thePropagator)
306     thePropagator =                               306     thePropagator =
307       new G4ErrorPropagator();  // currently t    307       new G4ErrorPropagator();  // currently the only propagator possible
308                                                   308 
309   SetSteppingManagerVerboseLevel();               309   SetSteppingManagerVerboseLevel();
310   InitTrackPropagation();                         310   InitTrackPropagation();
311                                                   311 
312   G4int ierr = thePropagator->Propagate(curren    312   G4int ierr = thePropagator->Propagate(currentTS, target, mode);
313                                                   313 
314   EventTermination();                             314   EventTermination();
315                                                   315 
316   return ierr;                                    316   return ierr;
317 }                                                 317 }
318                                                   318 
319 //--------------------------------------------    319 //-----------------------------------------------------------------------
320 G4int G4ErrorPropagatorManager::PropagateOneSt    320 G4int G4ErrorPropagatorManager::PropagateOneStep(G4ErrorTrajState* currentTS,
321                                                   321                                                  G4ErrorMode mode)
322 {                                                 322 {
323   G4ErrorPropagatorData::GetErrorPropagatorDat    323   G4ErrorPropagatorData::GetErrorPropagatorData()->SetMode(mode);
324                                                   324 
325   if(!thePropagator)                              325   if(!thePropagator)
326     thePropagator =                               326     thePropagator =
327       new G4ErrorPropagator();  // currently t    327       new G4ErrorPropagator();  // currently the only propagator possible
328                                                   328 
329   SetSteppingManagerVerboseLevel();               329   SetSteppingManagerVerboseLevel();
330                                                   330 
331   return thePropagator->PropagateOneStep(curre    331   return thePropagator->PropagateOneStep(currentTS);
332 }                                                 332 }
333                                                   333 
334 //--------------------------------------------    334 //-----------------------------------------------------------------------
335 G4bool G4ErrorPropagatorManager::CloseGeometry    335 G4bool G4ErrorPropagatorManager::CloseGeometry()
336 {                                                 336 {
337   G4GeometryManager* geomManager = G4GeometryM    337   G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
338   geomManager->OpenGeometry();                    338   geomManager->OpenGeometry();
339   if(G4StateManager::GetStateManager()->GetCur    339   if(G4StateManager::GetStateManager()->GetCurrentState() != G4State_GeomClosed)
340   {                                               340   {
341     G4StateManager::GetStateManager()->SetNewS    341     G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
342   }                                               342   }
343                                                   343 
344   return TRUE;                                    344   return TRUE;
345 }                                                 345 }
346                                                   346 
347 //--------------------------------------------    347 //---------------------------------------------------------------------------
348 void G4ErrorPropagatorManager::SetUserInitiali    348 void G4ErrorPropagatorManager::SetUserInitialization(
349   G4VUserDetectorConstruction* userInit)          349   G4VUserDetectorConstruction* userInit)
350 {                                                 350 {
351   theG4ErrorRunManagerHelper->SetUserInitializ    351   theG4ErrorRunManagerHelper->SetUserInitialization(userInit);
352 }                                                 352 }
353                                                   353 
354 //--------------------------------------------    354 //---------------------------------------------------------------------------
355 void G4ErrorPropagatorManager::SetUserInitiali    355 void G4ErrorPropagatorManager::SetUserInitialization(
356   G4VPhysicalVolume* userInit)                    356   G4VPhysicalVolume* userInit)
357 {                                                 357 {
358   theG4ErrorRunManagerHelper->SetUserInitializ    358   theG4ErrorRunManagerHelper->SetUserInitialization(userInit);
359 }                                                 359 }
360                                                   360 
361 //--------------------------------------------    361 //---------------------------------------------------------------------------
362 void G4ErrorPropagatorManager::SetUserInitiali    362 void G4ErrorPropagatorManager::SetUserInitialization(
363   G4VUserPhysicsList* userInit)                   363   G4VUserPhysicsList* userInit)
364 {                                                 364 {
365   theG4ErrorRunManagerHelper->SetUserInitializ    365   theG4ErrorRunManagerHelper->SetUserInitialization(userInit);
366 }                                                 366 }
367                                                   367 
368 //--------------------------------------------    368 //---------------------------------------------------------------------------
369 void G4ErrorPropagatorManager::SetUserAction(G    369 void G4ErrorPropagatorManager::SetUserAction(G4UserTrackingAction* userAction)
370 {                                                 370 {
371   G4EventManager::GetEventManager()->SetUserAc    371   G4EventManager::GetEventManager()->SetUserAction(userAction);
372 }                                                 372 }
373                                                   373 
374 //--------------------------------------------    374 //---------------------------------------------------------------------------
375 void G4ErrorPropagatorManager::SetUserAction(G    375 void G4ErrorPropagatorManager::SetUserAction(G4UserSteppingAction* userAction)
376 {                                                 376 {
377   G4EventManager::GetEventManager()->SetUserAc    377   G4EventManager::GetEventManager()->SetUserAction(userAction);
378 }                                                 378 }
379                                                   379 
380 //--------------------------------------------    380 //---------------------------------------------------------------------------
381 void G4ErrorPropagatorManager::SetSteppingMana    381 void G4ErrorPropagatorManager::SetSteppingManagerVerboseLevel()
382 {                                                 382 {
383   G4TrackingManager* trkmgr =                     383   G4TrackingManager* trkmgr =
384     G4EventManager::GetEventManager()->GetTrac    384     G4EventManager::GetEventManager()->GetTrackingManager();
385   trkmgr->GetSteppingManager()->SetVerboseLeve    385   trkmgr->GetSteppingManager()->SetVerboseLevel(trkmgr->GetVerboseLevel());
386 }                                                 386 }
387                                                   387 
388 //--------------------------------------------    388 //---------------------------------------------------------------------------
389 void G4ErrorPropagatorManager::EventTerminatio    389 void G4ErrorPropagatorManager::EventTermination()
390 {                                                 390 {
391   G4ErrorPropagatorData::GetErrorPropagatorDat    391   G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(G4ErrorState_Init);
392 }                                                 392 }
393                                                   393 
394 //--------------------------------------------    394 //---------------------------------------------------------------------------
395 void G4ErrorPropagatorManager::RunTermination(    395 void G4ErrorPropagatorManager::RunTermination()
396 {                                                 396 {
397   G4ErrorPropagatorData::GetErrorPropagatorDat    397   G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(
398     G4ErrorState_PreInit);                        398     G4ErrorState_PreInit);
399   theG4ErrorRunManagerHelper->RunTermination()    399   theG4ErrorRunManagerHelper->RunTermination();
400 }                                                 400 }
401                                                   401 
402 //--------------------------------------------    402 //---------------------------------------------------------------------------
403 G4String G4ErrorPropagatorManager::PrintG4Erro    403 G4String G4ErrorPropagatorManager::PrintG4ErrorState()
404 {                                                 404 {
405   return PrintG4ErrorState(                       405   return PrintG4ErrorState(
406     G4ErrorPropagatorData::GetErrorPropagatorD    406     G4ErrorPropagatorData::GetErrorPropagatorData()->GetState());
407 }                                                 407 }
408                                                   408 
409 //--------------------------------------------    409 //---------------------------------------------------------------------------
410 G4String G4ErrorPropagatorManager::PrintG4Erro    410 G4String G4ErrorPropagatorManager::PrintG4ErrorState(G4ErrorState state)
411 {                                                 411 {
412   G4String nam = "";                              412   G4String nam = "";
413   switch(state)                                   413   switch(state)
414   {                                               414   {
415     case G4ErrorState_PreInit:                    415     case G4ErrorState_PreInit:
416       nam = "G4ErrorState_PreInit";               416       nam = "G4ErrorState_PreInit";
417       break;                                      417       break;
418     case G4ErrorState_Init:                       418     case G4ErrorState_Init:
419       nam = "G4ErrorState_Init";                  419       nam = "G4ErrorState_Init";
420       break;                                      420       break;
421     case G4ErrorState_Propagating:                421     case G4ErrorState_Propagating:
422       nam = "G4ErrorState_Propagating";           422       nam = "G4ErrorState_Propagating";
423       break;                                      423       break;
424     case G4ErrorState_TargetCloserThanBoundary    424     case G4ErrorState_TargetCloserThanBoundary:
425       nam = "G4ErrorState_TargetCloserThanBoun    425       nam = "G4ErrorState_TargetCloserThanBoundary";
426       break;                                      426       break;
427     case G4ErrorState_StoppedAtTarget:            427     case G4ErrorState_StoppedAtTarget:
428       nam = "G4ErrorState_StoppedAtTarget";       428       nam = "G4ErrorState_StoppedAtTarget";
429       break;                                      429       break;
430   }                                               430   }
431                                                   431 
432   return nam;                                     432   return nam;
433 }                                                 433 }
434                                                   434 
435 //--------------------------------------------    435 //---------------------------------------------------------------------------
436 G4String G4ErrorPropagatorManager::PrintG4Stat    436 G4String G4ErrorPropagatorManager::PrintG4State()
437 {                                                 437 {
438   return PrintG4State(G4StateManager::GetState    438   return PrintG4State(G4StateManager::GetStateManager()->GetCurrentState());
439 }                                                 439 }
440                                                   440 
441 //--------------------------------------------    441 //---------------------------------------------------------------------------
442 G4String G4ErrorPropagatorManager::PrintG4Stat    442 G4String G4ErrorPropagatorManager::PrintG4State(G4ApplicationState state)
443 {                                                 443 {
444   G4String nam = "";                              444   G4String nam = "";
445   switch(state)                                   445   switch(state)
446   {                                               446   {
447     case G4State_PreInit:                         447     case G4State_PreInit:
448       nam = "G4State_PreInit";                    448       nam = "G4State_PreInit";
449       break;                                      449       break;
450     case G4State_Init:                            450     case G4State_Init:
451       nam = "G4State_Init";                       451       nam = "G4State_Init";
452       break;                                      452       break;
453     case G4State_Idle:                            453     case G4State_Idle:
454       nam = "G4State_Idle";                       454       nam = "G4State_Idle";
455       break;                                      455       break;
456     case G4State_GeomClosed:                      456     case G4State_GeomClosed:
457       nam = "G4State_GeomClosed";                 457       nam = "G4State_GeomClosed";
458       break;                                      458       break;
459     case G4State_EventProc:                       459     case G4State_EventProc:
460       nam = "G4State_EventProc";                  460       nam = "G4State_EventProc";
461       break;                                      461       break;
462     case G4State_Quit:                            462     case G4State_Quit:
463       nam = "G4State_Quit";                       463       nam = "G4State_Quit";
464       break;                                      464       break;
465     case G4State_Abort:                           465     case G4State_Abort:
466       nam = "G4State_Abort";                      466       nam = "G4State_Abort";
467       break;                                      467       break;
468   }                                               468   }
469                                                   469 
470   return nam;                                     470   return nam;
471 }                                                 471 }
472                                                   472