| Geant4 Cross Reference |
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