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