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