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