| 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: G4ITStepProcessor.cc 65022 2012-11-12 16:43:12Z gcosmo $
26 // 27 //
27 // Author: Mathieu Karamitros (kara (AT) cenbg 28 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
28 // 29 //
29 // History: 30 // History:
30 // ----------- 31 // -----------
31 // 10 Oct 2011 M.Karamitros created 32 // 10 Oct 2011 M.Karamitros created
32 // 33 //
33 // ------------------------------------------- 34 // -------------------------------------------------------------------
34 35
35 #include "G4ITStepProcessor.hh" 36 #include "G4ITStepProcessor.hh"
36 << 37 #include "G4UImanager.hh"
37 #include "G4ForceCondition.hh" 38 #include "G4ForceCondition.hh"
38 #include "G4GPILSelection.hh" 39 #include "G4GPILSelection.hh"
39 #include "G4GeometryTolerance.hh" <<
40 #include "G4IT.hh" <<
41 #include "G4ITNavigator.hh" // Inc <<
42 #include "G4ITSteppingVerbose.hh" <<
43 #include "G4ITTrackHolder.hh" <<
44 #include "G4ITTrackingInteractivity.hh" <<
45 #include "G4ITTrackingManager.hh" <<
46 #include "G4ITTransportation.hh" <<
47 #include "G4ITTransportationManager.hh" 40 #include "G4ITTransportationManager.hh"
>> 41 // #include "G4VSensitiveDetector.hh" // Include from 'hits/digi'
>> 42 #include "G4GeometryTolerance.hh"
48 #include "G4ParticleTable.hh" 43 #include "G4ParticleTable.hh"
>> 44 #include "G4ITTrackingManager.hh"
49 #include "G4TrackingInformation.hh" 45 #include "G4TrackingInformation.hh"
50 #include "G4UImanager.hh" << 46 #include "G4IT.hh"
>> 47 #include "G4ITNavigator.hh" // Include from 'geometry'
>> 48
51 #include "G4VITProcess.hh" 49 #include "G4VITProcess.hh"
52 #include "G4VITSteppingVerbose.hh" <<
53 #include "G4VProcess.hh" 50 #include "G4VProcess.hh"
>> 51 #include "G4ITTransportation.hh"
54 52
55 #include <iomanip> // Include fro 53 #include <iomanip> // Include from 'system'
56 #include <vector> // Include fro 54 #include <vector> // Include from 'system'
57 55
58 using namespace std; 56 using namespace std;
59 57
60 static const std::size_t SizeOfSelectedDoItVec << 58 static const size_t SizeOfSelectedDoItVector=100;
>> 59 static const size_t& gMaxNProcesses(G4VITProcess::GetMaxProcessIndex());
61 60
62 template<typename T> << 61 //____________________________________________________________________________________
63 inline bool IsInf(T value) <<
64 { <<
65 return std::numeric_limits<T>::has_infinit <<
66 && value == std::numeric_limits<T>::in <<
67 } <<
68 <<
69 //____________________________________________ <<
70 62
71 G4ITStepProcessor::G4ITStepProcessor() 63 G4ITStepProcessor::G4ITStepProcessor()
72 { 64 {
73 fpVerbose = nullptr; << 65 verboseLevel = 0 ;
74 // fpUserSteppingAction = 0 ; << 66 // fpUserSteppingAction = 0 ;
75 fStoreTrajectory = 0; << 67 fStoreTrajectory = 0;
76 fpTrackingManager = nullptr; << 68 fpTrackingManager = 0;
77 fpNavigator = nullptr; << 69 fpNavigator = 0;
78 kCarTolerance = -1.; << 70 kCarTolerance = -1.;
79 fInitialized = false; << 71 fInitialized = false;
80 fPreviousTimeStep = DBL_MAX; << 72 fPreviousTimeStep = DBL_MAX;
81 fILTimeStep = DBL_MAX; << 73 CleanProcessor();
82 fpTrackContainer = nullptr; << 74 ResetSecondaries();
83 <<
84 CleanProcessor(); <<
85 ResetSecondaries(); <<
86 } 75 }
87 76
88 //____________________________________________ << 77 G4ITStepProcessor::G4ITStepProcessorState::G4ITStepProcessorState() :
89 <<
90 //G4ITStepProcessor:: <<
91 G4ITStepProcessorState::G4ITStepProcessorState <<
92 G4ITStepProcessorState_Lock(), 78 G4ITStepProcessorState_Lock(),
93 fSelectedAtRestDoItVector(G4VITProcess::Ge << 79 fSelectedAtRestDoItVector (gMaxNProcesses,0),
94 fSelectedPostStepDoItVector(G4VITProcess:: << 80 fSelectedPostStepDoItVector (gMaxNProcesses,0)
95 { 81 {
96 fPhysicalStep = -1.; << 82 fPhysicalStep = -1.;
97 fPreviousStepSize = -1.; << 83 fPreviousStepSize = -1.;
98 84
99 fSafety = -1.; << 85 fSafety = -1.;
100 fProposedSafety = -1.; << 86 proposedSafety = -1.;
101 fEndpointSafety = -1; << 87 endpointSafety = -1;
102 88
103 fStepStatus = fUndefined; << 89 fStepStatus = fUndefined;
104 90
105 fTouchableHandle = nullptr; << 91 fTouchableHandle = 0;
106 } 92 }
107 93
108 //____________________________________________ << 94 // should not be used
109 << 95 G4ITStepProcessor::G4ITStepProcessorState::G4ITStepProcessorState(const G4ITStepProcessorState& ) :
110 //G4ITStepProcessor:: <<
111 G4ITStepProcessorState::G4ITStepProcessorState <<
112 G4ITStepProcessorState_Lock(), 96 G4ITStepProcessorState_Lock(),
113 fSelectedAtRestDoItVector(right.fSelectedA << 97 fSelectedAtRestDoItVector (gMaxNProcesses,0),
114 fSelectedPostStepDoItVector(right.fSelecte << 98 fSelectedPostStepDoItVector (gMaxNProcesses,0)
115 { 99 {
116 fPhysicalStep = right.fPhysicalStep; << 100 fPhysicalStep = -1.;
117 fPreviousStepSize = right.fPreviousStepSize; << 101 fPreviousStepSize = -1.;
118 102
119 fSafety = right.fSafety; << 103 fSafety = -1.;
120 fProposedSafety = right.fProposedSafety; << 104 proposedSafety = -1.;
121 fEndpointSafety = right.fEndpointSafety; << 105 endpointSafety = -1;
122 106
123 fStepStatus = right.fStepStatus; << 107 fStepStatus = fUndefined;
124 108
125 fTouchableHandle = right.fTouchableHandle; << 109 fTouchableHandle = 0;
126 } 110 }
127 111
128 //____________________________________________ << 112 // should not be used
129 << 113 G4ITStepProcessor::G4ITStepProcessorState& G4ITStepProcessor::G4ITStepProcessorState::operator=(const G4ITStepProcessorState& rhs)
130 //G4ITStepProcessor:: <<
131 G4ITStepProcessorState& <<
132 //G4ITStepProcessor:: <<
133 G4ITStepProcessorState::operator=(const G4ITSt <<
134 { 114 {
135 if(this == &right) return *this; << 115 if(this == &rhs) return *this;
136 116
137 fSelectedAtRestDoItVector.clear(); << 117 fSelectedAtRestDoItVector.clear();
138 fSelectedAtRestDoItVector = right.fSelectedA << 118 fSelectedAtRestDoItVector.resize(gMaxNProcesses,0);
139 fSelectedPostStepDoItVector.clear(); << 119 fSelectedPostStepDoItVector.clear();
140 fSelectedPostStepDoItVector = right.fSelecte << 120 fSelectedPostStepDoItVector.resize(gMaxNProcesses,0);
141 121
142 fPhysicalStep = right.fPhysicalStep; << 122 fPhysicalStep = -1.;
143 fPreviousStepSize = right.fPreviousStepSize; << 123 fPreviousStepSize = -1.;
144 124
145 fSafety = right.fSafety; << 125 fSafety = -1.;
146 fProposedSafety = right.fProposedSafety; << 126 proposedSafety = -1.;
147 fEndpointSafety = right.fEndpointSafety; << 127 endpointSafety = -1;
148 128
149 fStepStatus = right.fStepStatus; << 129 fStepStatus = fUndefined;
150 130
151 fTouchableHandle = right.fTouchableHandle; << 131 fTouchableHandle = 0;
152 return *this; << 132 return *this;
153 } 133 }
>> 134 //____________________________________________________________________________________
154 135
155 //____________________________________________ << 136 G4ITStepProcessor::G4ITStepProcessorState::~G4ITStepProcessorState()
156 << 137 {;}
157 //G4ITStepProcessor:: << 138 //____________________________________________________________________________________
158 G4ITStepProcessorState::~G4ITStepProcessorStat <<
159 { <<
160 ; <<
161 } <<
162 <<
163 //____________________________________________ <<
164 139
165 void G4ITStepProcessor::ClearProcessInfo() 140 void G4ITStepProcessor::ClearProcessInfo()
166 { 141 {
167 std::map<const G4ParticleDefinition*, Proces << 142 std::map<const G4ParticleDefinition*, ProcessGeneralInfo*> ::iterator it;
168 143
169 for(it = fProcessGeneralInfoMap.begin(); it << 144 for(it = fProcessGeneralInfoMap.begin();it != fProcessGeneralInfoMap.end();it++)
170 it++) <<
171 { <<
172 if(it->second != nullptr) <<
173 { 145 {
174 delete it->second; << 146 if(it->second)
175 it->second = 0; << 147 {
>> 148 delete it->second;
>> 149 it->second = 0;
>> 150 }
176 } 151 }
177 } <<
178 152
179 fProcessGeneralInfoMap.clear(); << 153 fProcessGeneralInfoMap.clear();
180 } 154 }
181 155
182 //____________________________________________ << 156 //____________________________________________________________________________________
183 157
184 void G4ITStepProcessor::ForceReInitialization( 158 void G4ITStepProcessor::ForceReInitialization()
185 { 159 {
186 fInitialized = false; << 160 fInitialized = false;
187 ClearProcessInfo(); << 161 ClearProcessInfo();
188 Initialize(); << 162 Initialize();
189 } 163 }
190 164
191 //____________________________________________ << 165 //____________________________________________________________________________________
192 166
193 void G4ITStepProcessor::Initialize() 167 void G4ITStepProcessor::Initialize()
194 { 168 {
195 CleanProcessor(); << 169 CleanProcessor();
196 if(fInitialized) return; << 170 if(fInitialized) return;
197 // ActiveOnlyITProcess(); << 171 // ActiveOnlyITProcess();
198 <<
199 SetNavigator(G4ITTransportationManager::GetT <<
200 ->GetNavigatorForTracking()); <<
201 <<
202 fPhysIntLength = DBL_MAX; <<
203 kCarTolerance = 0.5 <<
204 * G4GeometryTolerance::GetInstance()->Ge <<
205 <<
206 if(fpVerbose == nullptr) <<
207 { <<
208 G4ITTrackingInteractivity* interactivity = <<
209 172
210 if(interactivity != nullptr) << 173 SetNavigator(G4ITTransportationManager::GetTransportationManager()
211 { << 174 ->GetNavigatorForTracking());
212 fpVerbose = interactivity->GetSteppingVe <<
213 fpVerbose->SetStepProcessor(this); <<
214 } <<
215 } <<
216 175
217 fpTrackContainer = G4ITTrackHolder::Instance << 176 fPhysIntLength = DBL_MAX;
>> 177 kCarTolerance = 0.5*G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
218 178
219 fInitialized = true; << 179 fInitialized = true;
220 } 180 }
221 //____________________________________________ 181 //______________________________________________________________________________
222 182
223 G4ITStepProcessor::~G4ITStepProcessor() 183 G4ITStepProcessor::~G4ITStepProcessor()
224 { 184 {
225 if(fpStep != nullptr) << 185 if(fpStep)
226 { << 186 {
227 fpStep->DeleteSecondaryVector(); << 187 fpStep->DeleteSecondaryVector();
228 delete fpStep; << 188 delete fpStep;
229 } << 189 }
230 <<
231 delete fpSecondary; <<
232 ClearProcessInfo(); <<
233 //G4ITTransportationManager::DeleteInstance( <<
234 190
235 // if(fpUserSteppingAction) d << 191 if(fpSecondary) delete fpSecondary;
>> 192 ClearProcessInfo();
>> 193 G4ITTransportationManager::DeleteInstance();
>> 194
>> 195 // if(fpUserSteppingAction) delete fpUserSteppingAction;
236 } 196 }
237 //____________________________________________ 197 //______________________________________________________________________________
238 // should not be used 198 // should not be used
239 G4ITStepProcessor::G4ITStepProcessor(const G4I 199 G4ITStepProcessor::G4ITStepProcessor(const G4ITStepProcessor& rhs)
240 { 200 {
241 fpVerbose = rhs.fpVerbose; << 201 verboseLevel = rhs.verboseLevel ;
242 fStoreTrajectory = rhs.fStoreTrajectory; << 202 fStoreTrajectory = rhs.fStoreTrajectory ;
243 <<
244 // fpUserSteppingAction = 0 ; <<
245 fpTrackingManager = nullptr; <<
246 fpNavigator = nullptr; <<
247 fInitialized = false; <<
248 <<
249 kCarTolerance = rhs.kCarTolerance; <<
250 fInitialized = false; <<
251 fPreviousTimeStep = DBL_MAX; <<
252 <<
253 CleanProcessor(); <<
254 ResetSecondaries(); <<
255 fpTrackContainer = nullptr; <<
256 fILTimeStep = DBL_MAX; <<
257 } <<
258 203
259 //____________________________________________ << 204 // fpUserSteppingAction = 0 ;
260 << 205 fpTrackingManager = 0;
261 void G4ITStepProcessor::ResetLeadingTracks() << 206 fpNavigator = 0;
262 { << 207 fInitialized = false;
263 fLeadingTracks.Reset(); << 208
264 } << 209 kCarTolerance = rhs.kCarTolerance;
265 << 210 fInitialized = false;
266 //____________________________________________ << 211 fPreviousTimeStep = DBL_MAX;
267 212
268 void G4ITStepProcessor::PrepareLeadingTracks() << 213 CleanProcessor();
269 { << 214 ResetSecondaries();
270 fLeadingTracks.PrepareLeadingTracks(); <<
271 } 215 }
272 <<
273 //____________________________________________ 216 //______________________________________________________________________________
274 217
275 G4ITStepProcessor& G4ITStepProcessor::operator 218 G4ITStepProcessor& G4ITStepProcessor::operator=(const G4ITStepProcessor& rhs)
276 { 219 {
277 if(this == &rhs) return *this; // handle sel << 220 if (this == &rhs) return *this; // handle self assignment
278 //assignment operator << 221 //assignment operator
279 return *this; << 222 return *this;
280 } 223 }
281 << 224 // ******************************************************************
282 //____________________________________________ <<
283 225
284 void G4ITStepProcessor::ActiveOnlyITProcess() 226 void G4ITStepProcessor::ActiveOnlyITProcess()
285 { 227 {
286 // Method not used for the time being << 228 // Method not used for the time being
287 #ifdef debug 229 #ifdef debug
288 G4cout<<"G4ITStepProcessor::CloneProcesses: << 230 G4cout<<"G4ITStepProcessor::CloneProcesses: is called"<<G4endl;
289 #endif 231 #endif
290 232
291 G4ParticleTable* theParticleTable = G4Partic << 233 G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
292 G4ParticleTable::G4PTblDicIterator* theParti << 234 G4ParticleTable::G4PTblDicIterator* theParticleIterator = theParticleTable->GetIterator();
293 ->GetIterator(); <<
294 <<
295 theParticleIterator->reset(); <<
296 // TODO : Ne faire la boucle que sur les IT <<
297 while((*theParticleIterator)()) <<
298 { <<
299 G4ParticleDefinition* particle = thePartic <<
300 G4ProcessManager* pm = particle->GetProces <<
301 <<
302 if(pm == nullptr) <<
303 { <<
304 G4cerr << "ERROR - G4ITStepProcessor::Ge <<
305 << particle->GetParticleName() << ", PDG <<
306 << particle->GetPDGEncoding() << G4endl; <<
307 G4Exception("G4ITStepProcessor::GetProce <<
308 FatalException, "Process Manager is <<
309 return; <<
310 } <<
311 235
312 ActiveOnlyITProcess(pm); << 236 theParticleIterator->reset();
313 } << 237 // TODO : Ne faire la boucle que sur les IT **** !!!
314 } << 238 while( (*theParticleIterator)() )
>> 239 {
>> 240 G4ParticleDefinition* particle = theParticleIterator->value();
>> 241 G4ProcessManager* pm= particle->GetProcessManager();
315 242
316 //____________________________________________ << 243 if(!pm)
>> 244 {
>> 245 G4cerr << "ERROR - G4ITStepProcessor::GetProcessNumber()" << G4endl
>> 246 << " ProcessManager is NULL for particle = "
>> 247 << particle->GetParticleName() << ", PDG_code = "
>> 248 << particle->GetPDGEncoding() << G4endl;
>> 249 G4Exception("G4ITStepProcessor::GetProcessNumber()", "ITStepProcessor0001",
>> 250 FatalException, "Process Manager is not found.");
>> 251 return;
>> 252 }
>> 253
>> 254 ActiveOnlyITProcess(pm);
>> 255 }
>> 256 }
>> 257 // ******************************************************************
317 258
318 void G4ITStepProcessor::ActiveOnlyITProcess(G4 259 void G4ITStepProcessor::ActiveOnlyITProcess(G4ProcessManager* processManager)
319 { 260 {
320 // Method not used for the time being << 261 // Method not used for the time being
321 G4ProcessVector* processVector = processMana << 262 G4ProcessVector* processVector = processManager->GetProcessList();
322 <<
323 G4VITProcess* itProcess = nullptr; <<
324 for(G4int i = 0; i < (G4int)processVector->s <<
325 { <<
326 G4VProcess* base_process = (*processVector <<
327 itProcess = dynamic_cast<G4VITProcess*>(ba <<
328 263
329 if(itProcess == nullptr) << 264 G4VITProcess* itProcess = 0 ;
>> 265 for(int i = 0 ; i < processVector->size() ; i++)
330 { 266 {
331 processManager->SetProcessActivation(bas << 267 G4VProcess* base_process = (*processVector)[i];
>> 268 itProcess = dynamic_cast<G4VITProcess*>(base_process);
>> 269
>> 270 if(!itProcess)
>> 271 {
>> 272 processManager->SetProcessActivation(base_process, false);
>> 273 }
332 } 274 }
333 } <<
334 } 275 }
335 << 276 // ******************************************************************
336 //____________________________________________ <<
337 <<
338 void G4ITStepProcessor::SetupGeneralProcessInf 277 void G4ITStepProcessor::SetupGeneralProcessInfo(G4ParticleDefinition* particle,
339 278 G4ProcessManager* pm)
340 { 279 {
341 280
342 #ifdef debug 281 #ifdef debug
343 G4cout<<"G4ITStepProcessor::GetProcessNumber << 282 G4cout<<"G4ITStepProcessor::GetProcessNumber: is called track"<<G4endl;
344 #endif 283 #endif
345 if(pm == nullptr) << 284 if(!pm)
346 { << 285 {
347 G4cerr << "ERROR - G4SteppingManager::GetP << 286 G4cerr << "ERROR - G4SteppingManager::GetProcessNumber()" << G4endl
348 << particle->GetParticleName() << ", PDG_c << 287 << " ProcessManager is NULL for particle = "
349 << particle->GetPDGEncoding() << G4endl; << 288 << particle->GetParticleName() << ", PDG_code = "
350 G4Exception("G4SteppingManager::GetProcess << 289 << particle->GetPDGEncoding() << G4endl;
351 FatalException, "Process Manager is no << 290 G4Exception("G4SteppingManager::GetProcessNumber()", "ITStepProcessor0002",
352 return; << 291 FatalException, "Process Manager is not found.");
353 } << 292 return;
354 << 293 }
355 auto it = << 294
356 fProcessGeneralInfoMap.find(particle); << 295 std::map<const G4ParticleDefinition*, ProcessGeneralInfo*>::iterator it = fProcessGeneralInfoMap.find(particle);
357 if(it != fProcessGeneralInfoMap.end()) << 296 if(it != fProcessGeneralInfoMap.end())
358 { << 297 {
359 G4Exception("G4SteppingManager::SetupGener << 298 G4Exception("G4SteppingManager::SetupGeneralProcessInfo()", "ITStepProcessor0003",
360 "ITStepProcessor0003", << 299 FatalException, "Process info already registered.");
361 FatalException, "Process info already << 300 return;
362 return; << 301 }
363 } << 302
364 << 303 // here used as temporary
365 // here used as temporary << 304 fpProcessInfo = new ProcessGeneralInfo();
366 fpProcessInfo = new ProcessGeneralInfo(); << 305
367 << 306 // AtRestDoits
368 // AtRestDoits << 307 fpProcessInfo->MAXofAtRestLoops = pm->GetAtRestProcessVector()->entries();
369 fpProcessInfo->MAXofAtRestLoops = pm->GetAtR << 308 fpProcessInfo->fpAtRestDoItVector = pm->GetAtRestProcessVector(typeDoIt);
370 fpProcessInfo->fpAtRestDoItVector = pm->GetA << 309 fpProcessInfo->fpAtRestGetPhysIntVector = pm->GetAtRestProcessVector(typeGPIL);
371 fpProcessInfo->fpAtRestGetPhysIntVector = <<
372 pm->GetAtRestProcessVector(typeGPIL); <<
373 #ifdef debug 310 #ifdef debug
374 G4cout << "G4ITStepProcessor::GetProcessNumb << 311 G4cout << "G4ITStepProcessor::GetProcessNumber: #ofAtRest="
375 << fpProcessInfo->MAXofAtRestLoops << G4endl << 312 << fpProcessInfo->MAXofAtRestLoops << G4endl;
376 #endif 313 #endif
377 314
378 // AlongStepDoits << 315 // AlongStepDoits
379 fpProcessInfo->MAXofAlongStepLoops = << 316 fpProcessInfo->MAXofAlongStepLoops = pm->GetAlongStepProcessVector()->entries();
380 pm->GetAlongStepProcessVector()->entries(); << 317 fpProcessInfo->fpAlongStepDoItVector = pm->GetAlongStepProcessVector(typeDoIt);
381 fpProcessInfo->fpAlongStepDoItVector = << 318 fpProcessInfo->fpAlongStepGetPhysIntVector = pm->GetAlongStepProcessVector(typeGPIL);
382 pm->GetAlongStepProcessVector(typeDoIt); <<
383 fpProcessInfo->fpAlongStepGetPhysIntVector = <<
384 pm->GetAlongStepProcessVector(typeGPIL); <<
385 #ifdef debug 319 #ifdef debug
386 G4cout << "G4ITStepProcessor::GetProcessNumb << 320 G4cout << "G4ITStepProcessor::GetProcessNumber:#ofAlongStp="
387 << fpProcessInfo->MAXofAlongStepLoops << G4e << 321 << fpProcessInfo->MAXofAlongStepLoops << G4endl;
388 #endif 322 #endif
389 323
390 // PostStepDoits << 324 // PostStepDoits
391 fpProcessInfo->MAXofPostStepLoops = << 325 fpProcessInfo->MAXofPostStepLoops = pm->GetPostStepProcessVector()->entries();
392 pm->GetPostStepProcessVector()->entries(); << 326 fpProcessInfo->fpPostStepDoItVector = pm->GetPostStepProcessVector(typeDoIt);
393 fpProcessInfo->fpPostStepDoItVector = pm->Ge << 327 fpProcessInfo->fpPostStepGetPhysIntVector = pm->GetPostStepProcessVector(typeGPIL);
394 fpProcessInfo->fpPostStepGetPhysIntVector = <<
395 pm->GetPostStepProcessVector(typeGPIL); <<
396 #ifdef debug 328 #ifdef debug
397 G4cout << "G4ITStepProcessor::GetProcessNumb << 329 G4cout << "G4ITStepProcessor::GetProcessNumber: #ofPostStep="
398 << fpProcessInfo->MAXofPostStepLoops << G4en << 330 << fpProcessInfo->MAXofPostStepLoops << G4endl;
399 #endif 331 #endif
400 332
401 if (SizeOfSelectedDoItVector<fpProcessInfo-> << 333 if (SizeOfSelectedDoItVector<fpProcessInfo->MAXofAtRestLoops ||
402 SizeOfSelectedDoItVector<fpProcessInfo-> << 334 SizeOfSelectedDoItVector<fpProcessInfo->MAXofAlongStepLoops ||
403 SizeOfSelectedDoItVector<fpProcessInfo-> << 335 SizeOfSelectedDoItVector<fpProcessInfo->MAXofPostStepLoops )
404 { << 336 {
405 G4cerr << "ERROR - G4ITStepProcessor::GetP << 337 G4cerr << "ERROR - G4ITStepProcessor::GetProcessNumber()" << G4endl
406 << " SizeOfSelectedDoItVector= " << << 338 << " SizeOfSelectedDoItVector= " << SizeOfSelectedDoItVector
407 << " ; is smaller then one of MAXofAtRestL << 339 << " ; is smaller then one of MAXofAtRestLoops= "
408 << fpProcessInfo->MAXofAtRestLoops << G4en << 340 << fpProcessInfo->MAXofAtRestLoops << G4endl
409 << " or MAXofAlongStepLoops= " << f << 341 << " or MAXofAlongStepLoops= " << fpProcessInfo->MAXofAlongStepLoops
410 << " or MAXofPostStepLoops= " << fpProcess << 342 << " or MAXofPostStepLoops= " << fpProcessInfo->MAXofPostStepLoops << G4endl;
411 G4Exception("G4ITStepProcessor::GetProcess << 343 G4Exception("G4ITStepProcessor::GetProcessNumber()",
412 "ITStepProcessor0004", FatalException, << 344 "ITStepProcessor0004", FatalException,
413 "The array size is smaller than the ac << 345 "The array size is smaller than the actual No of processes.");
414 } << 346 }
415 << 347
416 if((fpProcessInfo->fpAtRestDoItVector == nul << 348 if(!fpProcessInfo->fpAtRestDoItVector &&
417 (fpProcessInfo->fpAlongStepDoItVector == << 349 !fpProcessInfo->fpAlongStepDoItVector &&
418 (fpProcessInfo->fpPostStepDoItVector == << 350 !fpProcessInfo->fpPostStepDoItVector)
419 { << 351 {
420 G4ExceptionDescription exceptionDescriptio << 352 G4ExceptionDescription exceptionDescription ;
421 exceptionDescription << "No DoIt process f << 353 exceptionDescription << "No DoIt process found " ;
422 G4Exception("G4ITStepProcessor::DoStepping << 354 G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0005",
423 FatalErrorInArgument,exceptionDescript << 355 FatalErrorInArgument,exceptionDescription);
424 return; << 356 return ;
425 } << 357 }
426 << 358
427 if((fpProcessInfo->fpAlongStepGetPhysIntVect << 359 if(fpProcessInfo->fpAlongStepGetPhysIntVector && fpProcessInfo->MAXofAlongStepLoops>0)
428 && fpProcessInfo->MAXofAlongStepLoops>0) << 360 {
429 { << 361 fpProcessInfo->fpTransportation = dynamic_cast<G4ITTransportation*>
430 fpProcessInfo->fpTransportation = dynamic_ << 362 ((*fpProcessInfo->fpAlongStepGetPhysIntVector)[fpProcessInfo->MAXofAlongStepLoops-1]);
431 ((*fpProcessInfo->fpAlongStepGetPhysIntVec << 363
432 [G4int(fpProcessInfo->MAXofAlongStepLo << 364 if(fpProcessInfo->fpTransportation == 0)
433 << 365 {
434 if(fpProcessInfo->fpTransportation == null << 366 G4ExceptionDescription exceptionDescription ;
435 { << 367 exceptionDescription << "No transportation process found " ;
436 G4ExceptionDescription exceptionDescript << 368 G4Exception("G4ITStepProcessor::SetupGeneralProcessInfo","ITStepProcessor0006",
437 exceptionDescription << "No transportati << 369 FatalErrorInArgument,exceptionDescription);
438 G4Exception("G4ITStepProcessor::SetupGen << 370 }
439 "ITStepProcessor0006", << 371 }
440 FatalErrorInArgument,exceptionDescri << 372 fProcessGeneralInfoMap[particle] = fpProcessInfo;
441 } << 373 // fpProcessInfo = 0;
442 } <<
443 fProcessGeneralInfoMap[particle] = fpProcess <<
444 // fpProcessInfo = 0; <<
445 } 374 }
446 375
447 //____________________________________________ << 376 // ******************************************************************
448 377
449 void G4ITStepProcessor::SetTrack(G4Track* trac 378 void G4ITStepProcessor::SetTrack(G4Track* track)
450 { 379 {
451 fpTrack = track; << 380 fpTrack = track ;
452 if(fpTrack != nullptr) << 381 if(fpTrack)
453 { <<
454 fpITrack = GetIT(fpTrack); <<
455 fpStep = const_cast<G4Step*>(fpTrack->GetS <<
456 <<
457 if(fpITrack != nullptr) <<
458 { 382 {
459 fpTrackingInfo = fpITrack->GetTrackingIn << 383 fpITrack = GetIT(fpTrack) ;
>> 384 fpStep = const_cast<G4Step*>(fpTrack -> GetStep());
>> 385
>> 386 if(fpITrack)
>> 387 {
>> 388 fpTrackingInfo = fpITrack->GetTrackingInfo() ;
>> 389 }
>> 390 else
>> 391 {
>> 392 fpTrackingInfo = 0;
>> 393 G4cerr << "Track ID : " << fpTrack->GetTrackID() << G4endl;
>> 394
>> 395 G4ExceptionDescription exceptionDescription ("No IT pointer was attached to the track you try to process.");
>> 396 G4Exception("G4ITStepProcessor::SetTrack","ITStepProcessor0007",
>> 397 FatalErrorInArgument,exceptionDescription);
>> 398 }
460 } 399 }
461 else 400 else
462 { 401 {
463 fpTrackingInfo = nullptr; << 402 fpITrack = 0;
464 G4cerr << "Track ID : " << fpTrack->GetT << 403 fpStep = 0 ;
465 << 404 }
466 G4ExceptionDescription errMsg; <<
467 errMsg << "No IT pointer was attached to <<
468 G4Exception("G4ITStepProcessor::SetTrack <<
469 "ITStepProcessor0007", <<
470 FatalErrorInArgument, <<
471 errMsg); <<
472 } <<
473 } <<
474 else <<
475 { <<
476 fpITrack = nullptr; <<
477 fpStep = nullptr; <<
478 } <<
479 } 405 }
480 //____________________________________________ 406 //______________________________________________________________________________
481 407
482 void G4ITStepProcessor::GetProcessInfo() 408 void G4ITStepProcessor::GetProcessInfo()
483 { 409 {
484 G4ParticleDefinition* particle = fpTrack->Ge << 410 G4ParticleDefinition* particle = fpTrack->GetDefinition();
485 auto it = << 411 std::map<const G4ParticleDefinition*, ProcessGeneralInfo*>::iterator it = fProcessGeneralInfoMap.find(particle);
486 fProcessGeneralInfoMap.find(particle); <<
487 <<
488 if(it == fProcessGeneralInfoMap.end()) <<
489 { <<
490 SetupGeneralProcessInfo(particle, <<
491 fpTrack->GetDefini <<
492 if(fpProcessInfo == nullptr) <<
493 { <<
494 G4ExceptionDescription exceptionDescript <<
495 G4Exception("G4ITStepProcessor::GetProce <<
496 "ITStepProcessor0008", <<
497 FatalErrorInArgument, <<
498 exceptionDescription); <<
499 return; <<
500 } <<
501 } <<
502 else <<
503 { <<
504 fpProcessInfo = it->second; <<
505 } <<
506 } <<
507 412
>> 413 if(it == fProcessGeneralInfoMap.end())
>> 414 {
>> 415 SetupGeneralProcessInfo(particle,fpTrack->GetDefinition()->GetProcessManager());
>> 416 if(fpProcessInfo == 0)
>> 417 {
>> 418 G4ExceptionDescription exceptionDescription ("...");
>> 419 G4Exception("G4ITStepProcessor::GetProcessNumber","ITStepProcessor0008",
>> 420 FatalErrorInArgument,exceptionDescription);
>> 421 return;
>> 422 }
>> 423 }
>> 424 else
>> 425 {
>> 426 fpProcessInfo = it->second;
>> 427 }
>> 428 }
508 //____________________________________________ 429 //______________________________________________________________________________
509 430
510 void G4ITStepProcessor::SetupMembers() 431 void G4ITStepProcessor::SetupMembers()
511 { 432 {
512 fpSecondary = fpStep->GetfSecondary(); << 433 fpSecondary = fpStep->GetfSecondary();
513 fpPreStepPoint = fpStep->GetPreStepPoint(); << 434 fpPreStepPoint = fpStep->GetPreStepPoint();
514 fpPostStepPoint = fpStep->GetPostStepPoint() << 435 fpPostStepPoint = fpStep->GetPostStepPoint();
515 436
516 fpState = (G4ITStepProcessorState*) fpITrack << 437 fpState = (G4ITStepProcessorState*) fpITrack->GetTrackingInfo()->GetStepProcessorState();
517 ->GetStepProcessorState(); <<
518 438
519 GetProcessInfo(); << 439 GetProcessInfo();
520 ResetSecondaries(); << 440 ResetSecondaries();
521 } 441 }
522 <<
523 //____________________________________________ 442 //______________________________________________________________________________
524 443
525 void G4ITStepProcessor::ResetSecondaries() 444 void G4ITStepProcessor::ResetSecondaries()
526 { 445 {
527 // Reset the secondary particles << 446 // Reset the secondary particles
528 fN2ndariesAtRestDoIt = 0; << 447 fN2ndariesAtRestDoIt = 0;
529 fN2ndariesAlongStepDoIt = 0; << 448 fN2ndariesAlongStepDoIt = 0;
530 fN2ndariesPostStepDoIt = 0; << 449 fN2ndariesPostStepDoIt = 0;
531 } 450 }
532 <<
533 //____________________________________________ 451 //______________________________________________________________________________
534 452
535 void G4ITStepProcessor::GetAtRestIL() 453 void G4ITStepProcessor::GetAtRestIL()
536 { 454 {
537 // Select the rest process which has the sho << 455 // Select the rest process which has the shortest time before
538 // it is invoked. In rest processes, GPIL() << 456 // it is invoked. In rest processes, GPIL()
539 // returns the time before a process occurs. << 457 // returns the time before a process occurs.
540 G4double lifeTime(DBL_MAX), shortestLifeTime << 458 G4double lifeTime (DBL_MAX), shortestLifeTime (DBL_MAX);
541 459
542 fAtRestDoItProcTriggered = 0; << 460 fAtRestDoItProcTriggered = 0;
543 shortestLifeTime = DBL_MAX; << 461 shortestLifeTime = DBL_MAX;
544 462
545 unsigned int NofInactiveProc=0; << 463 unsigned int NofInactiveProc=0;
546 464
547 for( G4int ri=0; ri < (G4int)fpProcessInfo-> << 465 for( size_t ri=0 ; ri < fpProcessInfo->MAXofAtRestLoops ; ri++ )
548 { <<
549 fpCurrentProcess = dynamic_cast<G4VITProce <<
550 if (fpCurrentProcess== nullptr) <<
551 { 466 {
552 (fpState->fSelectedAtRestDoItVector)[ri] << 467 fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAtRestGetPhysIntVector)[ri];
553 NofInactiveProc++; << 468 if (fpCurrentProcess== 0)
554 continue; << 469 {
555 } // NULL means the process is inactivated << 470 (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
>> 471 NofInactiveProc++;
>> 472 continue;
>> 473 } // NULL means the process is inactivated by a user on fly.
>> 474
>> 475 fCondition=NotForced;
>> 476 fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
>> 477 lifeTime = fpCurrentProcess->AtRestGPIL( *fpTrack, &fCondition );
>> 478 fpCurrentProcess->SetProcessState(0);
556 479
557 fCondition=NotForced; << 480 if(fCondition==Forced)
558 fpCurrentProcess->SetProcessState( << 481 {
559 fpTrackingInfo->GetProcessState(fpCurr << 482 (fpState->fSelectedAtRestDoItVector)[ri] = Forced;
>> 483 }
>> 484 else
>> 485 {
>> 486 (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
>> 487 if(lifeTime < shortestLifeTime )
>> 488 {
>> 489 shortestLifeTime = lifeTime;
>> 490 fAtRestDoItProcTriggered = G4int(ri);
>> 491 (fpState->fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;
>> 492 }
>> 493 }
>> 494 }
560 495
561 lifeTime = fpCurrentProcess->AtRestGPIL( * << 496 fTimeStep = shortestLifeTime ;
562 fpCurrentProcess->ResetProcessState(); <<
563 497
564 if(fCondition==Forced) << 498 // at least one process is necessary to destroy the particle
>> 499 // exit with warning
>> 500 if(NofInactiveProc==fpProcessInfo->MAXofAtRestLoops)
565 { 501 {
566 (fpState->fSelectedAtRestDoItVector)[ri] << 502 G4cerr << "ERROR - G4ITStepProcessor::InvokeAtRestDoItProcs()" << G4endl
>> 503 << " No AtRestDoIt process is active!" << G4endl;
567 } 504 }
568 else <<
569 { <<
570 (fpState->fSelectedAtRestDoItVector)[ri] <<
571 if(lifeTime < shortestLifeTime ) <<
572 { <<
573 shortestLifeTime = lifeTime; <<
574 fAtRestDoItProcTriggered = G4int(ri); <<
575 } <<
576 } <<
577 } <<
578 <<
579 (fpState->fSelectedAtRestDoItVector)[fAtRest <<
580 <<
581 // G4cout << " --> Selected at rest process : <<
582 // << (*fpProcessInfo->fpAtRestGetPhys <<
583 // ->GetProcessName() <<
584 // << G4endl; <<
585 <<
586 fTimeStep = shortestLifeTime; <<
587 <<
588 // at least one process is necessary to dest <<
589 // exit with warning <<
590 if(NofInactiveProc==fpProcessInfo->MAXofAtRe <<
591 { <<
592 G4cerr << "ERROR - G4ITStepProcessor::Invo <<
593 << " No AtRestDoIt process is activ <<
594 } <<
595 } 505 }
>> 506 //___________________________________________________________________________
596 507
597 //____________________________________________ << 508 void G4ITStepProcessor::DefinePhysicalStepLength(G4Track* track)
598 G4double G4ITStepProcessor::ComputeInteraction <<
599 { 509 {
600 G4TrackManyList* mainList = fpTrackContainer << 510 SetTrack(track);
601 G4TrackManyList::iterator it = mainList ->be << 511 DoDefinePhysicalStepLength();
602 G4TrackManyList::iterator end = mainList ->e << 512 }
>> 513 //______________________________________________________________________________
603 514
604 SetPreviousStepTime(previousTimeStep); <<
605 515
606 fILTimeStep = DBL_MAX; << 516 void G4ITStepProcessor::SetInitialStep()
>> 517 {
>> 518 // DEBUG
>> 519 // G4cout << "SetInitialStep for : " << fpITrack-> GetName() << G4endl;
>> 520 //________________________________________________________
>> 521 // Initialize geometry
607 522
608 for (; it != end; ) <<
609 { <<
610 G4Track * track = *it; <<
611 523
612 #ifdef DEBUG << 524 if ( ! fpTrack->GetTouchableHandle())
613 G4cout << "*CIL* " << GetIT(track)->GetNam << 525 {
614 << " ID: " << track->GetTrackID() << 526 G4ThreeVector direction= fpTrack->GetMomentumDirection();
615 << " at time : " << track->GetGlobalT << 527 fpNavigator->LocateGlobalPointAndSetup( fpTrack->GetPosition(),
616 << G4endl; << 528 &direction, false, false );
617 #endif << 529 fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
618 530
619 ++it; << 531 fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
620 DefinePhysicalStepLength(track); << 532 fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
>> 533 }
>> 534 else
>> 535 {
>> 536 fpState->fTouchableHandle = fpTrack->GetTouchableHandle();
>> 537 fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
>> 538 G4VPhysicalVolume* oldTopVolume= fpTrack->GetTouchableHandle()->GetVolume();
>> 539 G4VPhysicalVolume* newTopVolume=
>> 540 fpNavigator->ResetHierarchyAndLocate( fpTrack->GetPosition(),
>> 541 fpTrack->GetMomentumDirection(),
>> 542 *((G4TouchableHistory*)fpTrack->GetTouchableHandle()()) );
>> 543 if(newTopVolume != oldTopVolume || oldTopVolume->GetRegularStructureId() == 1 )
>> 544 {
>> 545 fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
>> 546 fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
>> 547 fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
>> 548 }
>> 549 }
621 550
622 ExtractILData(); << 551 fpCurrentVolume = fpState->fTouchableHandle->GetVolume();
623 } <<
624 552
625 return fILTimeStep; << 553 //________________________________________________________
626 } << 554 // If the primary track has 'Suspend' or 'PostponeToNextEvent' state,
>> 555 // set the track state to 'Alive'.
>> 556 if( (fpTrack->GetTrackStatus()==fSuspend) ||
>> 557 (fpTrack->GetTrackStatus()==fPostponeToNextEvent) )
>> 558 {
>> 559 fpTrack->SetTrackStatus(fAlive);
>> 560 }
627 561
628 //____________________________________________ << 562 // If the primary track has 'zero' kinetic energy, set the track
>> 563 // state to 'StopButAlive'.
>> 564 if(fpTrack->GetKineticEnergy() <= 0.0)
>> 565 {
>> 566 fpTrack->SetTrackStatus( fStopButAlive );
>> 567 }
>> 568 //________________________________________________________
>> 569 // Set vertex information of G4Track at here
>> 570 if ( fpTrack->GetCurrentStepNumber() == 0 )
>> 571 {
>> 572 fpTrack->SetVertexPosition( fpTrack->GetPosition() );
>> 573 fpTrack->SetVertexMomentumDirection( fpTrack->GetMomentumDirection() );
>> 574 fpTrack->SetVertexKineticEnergy( fpTrack->GetKineticEnergy() );
>> 575 fpTrack->SetLogicalVolumeAtVertex( fpTrack->GetVolume()->GetLogicalVolume() );
>> 576 }
>> 577 //________________________________________________________
>> 578 // If track is already outside the world boundary, kill it
>> 579 if( fpCurrentVolume==0 )
>> 580 {
>> 581 // If the track is a primary, stop processing
>> 582 if(fpTrack->GetParentID()==0)
>> 583 {
>> 584 G4cerr << "ERROR - G4ITStepProcessor::SetInitialStep()" << G4endl
>> 585 << " Primary particle starting at - "
>> 586 << fpTrack->GetPosition()
>> 587 << " - is outside of the world volume." << G4endl;
>> 588 G4Exception("G4ITStepProcessor::SetInitialStep()", "ITStepProcessor0011",
>> 589 FatalException, "Primary vertex outside of the world!");
>> 590 }
629 591
630 void G4ITStepProcessor::ExtractILData() << 592 fpTrack->SetTrackStatus( fStopAndKill );
631 { << 593 G4cout << "WARNING - G4ITStepProcessor::SetInitialStep()" << G4endl
632 assert(fpTrack != 0); << 594 << " Initial track position is outside world! - "
633 if (fpTrack == nullptr) << 595 << fpTrack->GetPosition() << G4endl;
634 { << 596 }
635 CleanProcessor(); << 597 else{
636 return; << 598 // Initial set up for attribues of 'Step'
637 } << 599 fpStep->InitializeStep( fpTrack );
>> 600 }
638 601
639 // assert(fpTrack->GetTrackStatus() != fStop <<
640 602
641 if (fpTrack->GetTrackStatus() == fStopAndKil << 603 if( fpTrack->GetTrackStatus() == fStopAndKill ) return ;
642 { <<
643 // trackContainer->GetMainList()->pop(fpTra <<
644 fpTrackingManager->EndTracking(fpTrack); <<
645 CleanProcessor(); <<
646 return; <<
647 } <<
648 604
649 if (IsInf(fTimeStep)) << 605 fpTrackingManager->StartTracking(fpTrack);
650 { <<
651 // G4cout << "!!!!!!!!!!!! IS INF " << tra <<
652 CleanProcessor(); <<
653 return; <<
654 } <<
655 if (fTimeStep < fILTimeStep - DBL_EPSILON) <<
656 { <<
657 // G4cout << "!!!!!!!!!!!! TEMPS DIFFERENT <<
658 // << track->GetTrackID() << G4endl; <<
659 <<
660 fLeadingTracks.Reset(); <<
661 <<
662 fILTimeStep = GetInteractionTime(); <<
663 <<
664 // G4cout << "Will set leading step to true <<
665 // << SP -> GetInteractionTime() << <<
666 // << G4BestUnit(fILTimeStep, "Time" <<
667 // << G4endl; <<
668 <<
669 // GetIT(fpTrack)->GetTrackingInfo()->SetLe <<
670 fLeadingTracks.Push(fpTrack); <<
671 } <<
672 else if(fabs(fILTimeStep - fTimeStep) < DBL_ <<
673 { <<
674 <<
675 // G4cout << "!!!!!!!!!!!! MEME TEMPS " << <<
676 // G4cout << "Will set leading step to tru <<
677 // << SP -> GetInteractionTime() << <<
678 // << fTimeStep << " the trackID is <<
679 // GetIT(fpTrack)->GetTrackingInfo()->SetLe <<
680 fLeadingTracks.Push(fpTrack); <<
681 } <<
682 // else <<
683 // { <<
684 // G4cout << "!!!! Bigger time : " << "c <<
685 // << " proposedTime : " << SP -> GetIntera <<
686 // } <<
687 606
688 CleanProcessor(); << 607 fpState->fStepStatus = fUndefined;
689 } 608 }
>> 609 //______________________________________________________________________________
690 610
691 //____________________________________________ << 611 void G4ITStepProcessor::InitDefineStep()
692 <<
693 void G4ITStepProcessor::DefinePhysicalStepLeng <<
694 { 612 {
695 SetTrack(track); <<
696 DoDefinePhysicalStepLength(); <<
697 } <<
698 613
699 //____________________________________________ << 614 if(!fpStep)
>> 615 {
700 616
701 void G4ITStepProcessor::SetInitialStep() << 617 // Create new Step and give it to the track
702 { << 618 fpStep = new G4Step();
703 // DEBUG << 619 fpTrack->SetStep(fpStep);
704 // G4cout << "SetInitialStep for : " << f << 620 fpSecondary = fpStep->NewSecondaryVector();
705 //__________________________________________ << 621
706 // Initialize geometry << 622 // Create new state and set it in the trackingInfo
707 << 623 fpState = new G4ITStepProcessorState();
708 if(!fpTrack->GetTouchableHandle()) << 624 fpITrack->GetTrackingInfo()->SetStepProcessorState((G4ITStepProcessorState_Lock*)fpState);
709 { << 625
710 //======================================== << 626 SetupMembers();
711 // Create navigator state and Locate parti << 627 fpNavigator->NewNavigatorState();
712 //======================================== << 628
713 /* << 629 SetInitialStep();
714 fpNavigator->NewNavigatorStateAndLocate(f <<
715 fpTrack->GetMomentumDirection()); <<
716 <<
717 fpITrack->GetTrackingInfo()-> <<
718 SetNavigatorState(fpNavigator->GetNavigat <<
719 */ <<
720 fpNavigator->NewNavigatorState(); <<
721 fpITrack->GetTrackingInfo()->SetNavigatorS <<
722 ->GetNavigatorState()); <<
723 <<
724 G4ThreeVector direction = fpTrack->GetMome <<
725 fpNavigator->LocateGlobalPointAndSetup(fpT <<
726 &di <<
727 fal <<
728 fal <<
729 <<
730 fpState->fTouchableHandle = fpNavigator->C <<
731 <<
732 fpTrack->SetTouchableHandle(fpState->fTouc <<
733 fpTrack->SetNextTouchableHandle(fpState->f <<
734 } <<
735 else <<
736 { <<
737 fpState->fTouchableHandle = fpTrack->GetTo <<
738 fpTrack->SetNextTouchableHandle(fpState->f <<
739 <<
740 //======================================== <<
741 // Create OR set navigator state <<
742 //======================================== <<
743 <<
744 if(fpITrack->GetTrackingInfo()->GetNavigat <<
745 { <<
746 fpNavigator->SetNavigatorState(fpITrack- <<
747 ->GetNavigatorState()); <<
748 fpITrack->GetTrackingInfo()->SetNavigato <<
749 ->GetNavigatorState()); <<
750 } 630 }
751 else 631 else
752 { 632 {
753 fpNavigator->NewNavigatorState(*((G4Touc << 633 SetupMembers();
754 ->fTouchableHandle())); <<
755 fpITrack->GetTrackingInfo()->SetNavigato <<
756 ->GetNavigatorState()); <<
757 } <<
758 <<
759 G4VPhysicalVolume* oldTopVolume = <<
760 fpTrack->GetTouchableHandle()->GetVolu <<
761 <<
762 //======================================== <<
763 // Locate particle in geometry <<
764 //======================================== <<
765 <<
766 // G4VPhysicalVolume* newTopVolume = <<
767 // fpNavigator->LocateGlobalPointAndSet <<
768 // fpTrack->GetPosition(), <<
769 // &fpTrack->GetMomentumDirection() <<
770 // true, false); <<
771 <<
772 G4VPhysicalVolume* newTopVolume = <<
773 fpNavigator->ResetHierarchyAndLocate(f <<
774 f <<
775 * <<
776 <<
777 <<
778 if(newTopVolume != oldTopVolume || oldTopV <<
779 == 1) <<
780 { <<
781 fpState->fTouchableHandle = fpNavigator- <<
782 fpTrack->SetTouchableHandle(fpState->fTo <<
783 fpTrack->SetNextTouchableHandle(fpState- <<
784 } <<
785 } <<
786 <<
787 fpCurrentVolume = fpState->fTouchableHandle- <<
788 <<
789 //__________________________________________ <<
790 // If the primary track has 'Suspend' or 'Po <<
791 // set the track state to 'Alive'. <<
792 if((fpTrack->GetTrackStatus() == fSuspend) | <<
793 == fPostponeToNextEvent)) <<
794 { <<
795 fpTrack->SetTrackStatus(fAlive); <<
796 } <<
797 <<
798 //HoangTRAN: it's better to check the status <<
799 if(fpTrack->GetTrackStatus() == fStopAndKill <<
800 <<
801 // If the primary track has 'zero' kinetic e <<
802 // state to 'StopButAlive'. <<
803 if(fpTrack->GetKineticEnergy() <= 0.0) <<
804 { <<
805 fpTrack->SetTrackStatus(fStopButAlive); <<
806 } <<
807 //__________________________________________ <<
808 // Set vertex information of G4Track at here <<
809 if(fpTrack->GetCurrentStepNumber() == 0) <<
810 { <<
811 fpTrack->SetVertexPosition(fpTrack->GetPos <<
812 fpTrack->SetVertexMomentumDirection(fpTrac <<
813 fpTrack->SetVertexKineticEnergy(fpTrack->G <<
814 fpTrack->SetLogicalVolumeAtVertex(fpTrack- <<
815 } <<
816 //__________________________________________ <<
817 // If track is already outside the world bou <<
818 if(fpCurrentVolume == nullptr) <<
819 { <<
820 // If the track is a primary, stop process <<
821 if(fpTrack->GetParentID() == 0) <<
822 { <<
823 G4cerr << "ERROR - G4ITStepProcessor::Se <<
824 << fpTrack->GetPosition() <<
825 << " - is outside of the world volume." <<
826 G4Exception("G4ITStepProcessor::SetIniti <<
827 FatalException, "Primary vertex outs <<
828 } <<
829 <<
830 fpTrack->SetTrackStatus( fStopAndKill ); <<
831 G4cout << "WARNING - G4ITStepProcessor::Se <<
832 << " Initial track position is ou <<
833 << fpTrack->GetPosition() << G4endl; <<
834 } <<
835 else <<
836 { <<
837 // Initial set up for attribues of 'Step' <<
838 fpStep->InitializeStep( fpTrack ); <<
839 } <<
840 634
841 fpState->fStepStatus = fUndefined; << 635 fpState->fPreviousStepSize = fpTrack->GetStepLength();
842 } << 636 /***
843 //____________________________________________ << 637 // Send G4Step information to Hit/Dig if the volume is sensitive
>> 638 fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
>> 639 StepControlFlag = fpStep->GetControlFlag();
>> 640 if( fpCurrentVolume != 0 && StepControlFlag != AvoidHitInvocation)
>> 641 {
>> 642 fpSensitive = fpStep->GetPreStepPoint()->
>> 643 GetSensitiveDetector();
844 644
845 void G4ITStepProcessor::InitDefineStep() << 645 // if( fSensitive != 0 ) {
846 { << 646 // fSensitive->Hit(fStep);
>> 647 // }
>> 648 }
>> 649 ***/
>> 650 // Store last PostStepPoint to PreStepPoint, and swap current and next
>> 651 // volume information of G4Track. Reset total energy deposit in one Step.
>> 652 fpStep->CopyPostToPreStepPoint();
>> 653 fpStep->ResetTotalEnergyDeposit();
>> 654
>> 655 //JA Set the volume before it is used (in DefineStepLength() for User Limit)
>> 656 fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
>> 657 /*
>> 658 G4cout << G4endl;
>> 659 G4cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" << G4endl;
>> 660 G4cout << "PreStepPoint Volume : " << fpCurrentVolume->GetName() << G4endl;
>> 661 G4cout << "Track Touchable : " << fpTrack->GetTouchableHandle()->GetVolume()->GetName() << G4endl;
>> 662 G4cout << "Track NextTouchable : " << fpTrack->GetNextTouchableHandle()->GetVolume()->GetName() << G4endl;
>> 663 */
>> 664 // Reset the step's auxiliary points vector pointer
>> 665 fpStep->SetPointerToVectorOfAuxiliaryPoints(0);
>> 666
>> 667 // Switch next touchable in track to current one
>> 668 fpTrack->SetTouchableHandle(fpTrack->GetNextTouchableHandle());
>> 669 fpState->fTouchableHandle = fpTrack->GetTouchableHandle();
>> 670 fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
>> 671 G4VPhysicalVolume* oldTopVolume= fpTrack->GetTouchableHandle()->GetVolume();
>> 672 fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
>> 673
>> 674 G4VPhysicalVolume* newTopVolume=
>> 675 fpNavigator->ResetHierarchyAndLocate( fpTrack->GetPosition(),
>> 676 fpTrack->GetMomentumDirection(),
>> 677 *((G4TouchableHistory*)fpTrack->GetTouchableHandle()()) );
847 678
848 if(fpStep == nullptr) << 679 // G4cout << "New Top Volume : " << newTopVolume->GetName() << G4endl;
849 { <<
850 // Create new Step and give it to the trac <<
851 fpStep = new G4Step(); <<
852 fpTrack->SetStep(fpStep); <<
853 fpSecondary = fpStep->NewSecondaryVector() <<
854 <<
855 // Create new state and set it in the trac <<
856 fpState = new G4ITStepProcessorState(); <<
857 fpITrack->GetTrackingInfo()->SetStepProces <<
858 680
859 SetupMembers(); << 681 if(newTopVolume != oldTopVolume || oldTopVolume->GetRegularStructureId() == 1 )
860 SetInitialStep(); << 682 {
>> 683 fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
>> 684 fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
>> 685 fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
>> 686 }
861 687
862 fpTrackingManager->StartTracking(fpTrack); << 688 fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
863 } << 689 }
864 else <<
865 { <<
866 SetupMembers(); <<
867 <<
868 fpState->fPreviousStepSize = fpTrack->GetS <<
869 /*** <<
870 // Send G4Step information to Hit/Dig if <<
871 fpCurrentVolume = fpStep->GetPreStepPoint <<
872 StepControlFlag = fpStep->GetControlFlag <<
873 if( fpCurrentVolume != 0 && StepControlFl <<
874 { <<
875 fpSensitive = fpStep->GetPreStepPoint()-> <<
876 GetSensitiveDetector(); <<
877 <<
878 // if( fSensitive != 0 ) { <<
879 // fSensitive->Hit(fStep); <<
880 // } <<
881 } <<
882 ***/ <<
883 // Store last PostStepPoint to PreStepPoin <<
884 // volume information of G4Track. Reset to <<
885 fpStep->CopyPostToPreStepPoint(); <<
886 fpStep->ResetTotalEnergyDeposit(); <<
887 <<
888 //JA Set the volume before it is used (in <<
889 fpCurrentVolume = fpStep->GetPreStepPoint( <<
890 /* <<
891 G4cout << G4endl; <<
892 G4cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" < <<
893 G4cout << "PreStepPoint Volume : " <<
894 << fpCurrentVolume->GetName() << G4endl; <<
895 G4cout << "Track Touchable : " <<
896 << fpTrack->GetTouchableHandle()->GetVolu <<
897 G4cout << "Track NextTouchable : " <<
898 << fpTrack->GetNextTouchableHandle()->Get <<
899 << G4endl; <<
900 */ <<
901 // Reset the step's auxiliary points vecto <<
902 fpStep->SetPointerToVectorOfAuxiliaryPoint <<
903 <<
904 // Switch next touchable in track to curre <<
905 fpTrack->SetTouchableHandle(fpTrack->GetNe <<
906 fpState->fTouchableHandle = fpTrack->GetTo <<
907 fpTrack->SetNextTouchableHandle(fpState->f <<
908 <<
909 //! ADDED BACK <<
910 /* <<
911 G4VPhysicalVolume* oldTopVolume = <<
912 fpTrack->GetTouchableHandle()->GetVolume( <<
913 fpNavigator->SetNavigatorState( <<
914 fpITrack->GetTrackingInfo()->GetNavigator <<
915 <<
916 G4VPhysicalVolume* newTopVolume = fpNavig <<
917 fpTrack->GetPosition(), fpTrack->GetMomen <<
918 *((G4TouchableHistory*) fpTrack->GetTouch <<
919 <<
920 // G4VPhysicalVolume* newTopVolume= <<
921 // fpNavigator->LocateGlobalPointAndS <<
922 // <<
923 // <<
924 <<
925 // G4cout << "New Top Volume : " < <<
926 <<
927 if (newTopVolume != oldTopVolume || oldTo <<
928 == 1) <<
929 { <<
930 fpState->fTouchableHandle = fpNavigator-> <<
931 fpTrack->SetTouchableHandle(fpState->fTou <<
932 fpTrack->SetNextTouchableHandle(fpState-> <<
933 } <<
934 <<
935 */ <<
936 //! ADDED BACK <<
937 //======================================== <<
938 // Only reset navigator state + reset volu <<
939 // No need to relocate <<
940 //======================================== <<
941 fpNavigator->SetNavigatorState(fpITrack->G <<
942 ->GetNavigatorState()); <<
943 } <<
944 } 690 }
945 691
946 //____________________________________________ 692 //______________________________________________________________________________
947 693
948 // ------------------------------------------- << 694
>> 695 // ************************************************************************
949 // Compute Interaction Length 696 // Compute Interaction Length
950 // ------------------------------------------- << 697 // ************************************************************************
951 void G4ITStepProcessor::DoDefinePhysicalStepLe 698 void G4ITStepProcessor::DoDefinePhysicalStepLength()
952 { 699 {
953 700
954 InitDefineStep(); << 701 InitDefineStep();
955 702
956 #ifdef G4VERBOSE << 703 G4TrackStatus trackStatus = fpTrack -> GetTrackStatus() ;
957 // !!!!! Verbose <<
958 if(fpVerbose != nullptr) fpVerbose->DPSLStar <<
959 #endif <<
960 704
961 G4TrackStatus trackStatus = fpTrack->GetTrac << 705 if(trackStatus == fStopAndKill)
>> 706 {
>> 707 return ;
>> 708 }
962 709
963 if(trackStatus == fStopAndKill) << 710 if(trackStatus == fStopButAlive)
964 { << 711 {
965 return; << 712 fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
966 } << 713 fpNavigator->SetNavigatorState(0);
967 << 714 return GetAtRestIL() ;
968 if(trackStatus == fStopButAlive) << 715 }
969 { <<
970 fpITrack->GetTrackingInfo()->SetNavigatorS <<
971 ->GetNavigatorState()); <<
972 fpNavigator->ResetNavigatorState(); <<
973 return GetAtRestIL(); <<
974 } <<
975 <<
976 // Find minimum Step length and correspondin <<
977 // demanded by active disc./cont. processes <<
978 <<
979 // ReSet the counter etc. <<
980 fpState->fPhysicalStep = DBL_MAX; // Initial <<
981 fPhysIntLength = DBL_MAX; // Initialize by a <<
982 <<
983 G4double proposedTimeStep = DBL_MAX; <<
984 G4VProcess* processWithPostStepGivenByTimeSt <<
985 <<
986 // GPIL for PostStep <<
987 fPostStepDoItProcTriggered = fpProcessInfo-> <<
988 fPostStepAtTimeDoItProcTriggered = fpProcess <<
989 <<
990 // G4cout << "fpProcessInfo->MAXofPostStepL <<
991 // << fpProcessInfo->MAXofPostStepLo <<
992 // << " mol : " << fpITrack -> GetNa <<
993 // << " id : " << fpTrack->GetTrackI <<
994 // << G4endl; <<
995 <<
996 for(std::size_t np = 0; np < fpProcessInfo-> <<
997 { <<
998 fpCurrentProcess = dynamic_cast<G4VITProce <<
999 ->fpPostStepGetPhysIntVector)[(G4int)n <<
1000 if(fpCurrentProcess == nullptr) <<
1001 { <<
1002 (fpState->fSelectedPostStepDoItVector)[ <<
1003 continue; <<
1004 } // NULL means the process is inactivate <<
1005 <<
1006 fCondition = NotForced; <<
1007 fpCurrentProcess->SetProcessState(fpTrack <<
1008 ->GetProcessID())); <<
1009 <<
1010 // G4cout << "Is going to call : " <<
1011 // << fpCurrentProcess -> GetProce <<
1012 // << G4endl; <<
1013 fPhysIntLength = fpCurrentProcess->PostSt <<
1014 <<
1015 <<
1016 <<
1017 #ifdef G4VERBOSE <<
1018 // !!!!! Verbose <<
1019 if(fpVerbose != nullptr) fpVerbose->DPSLP <<
1020 #endif <<
1021 716
1022 fpCurrentProcess->ResetProcessState(); <<
1023 //fpCurrentProcess->SetProcessState(0); <<
1024 717
1025 switch(fCondition) << 718 // Find minimum Step length and corresponding time
1026 { << 719 // demanded by active disc./cont. processes
1027 case ExclusivelyForced: // Will need sp <<
1028 (fpState->fSelectedPostStepDoItVector <<
1029 fpState->fStepStatus = fExclusivelyFo <<
1030 fpStep->GetPostStepPoint()->SetProces <<
1031 break; <<
1032 <<
1033 case Conditionally: <<
1034 // (fpState->fSelectedPostStepD <<
1035 G4Exception("G4ITStepProcessor::Defin <<
1036 "ITStepProcessor0008", <<
1037 FatalException, <<
1038 "This feature is no more <<
1039 break; <<
1040 <<
1041 case Forced: <<
1042 (fpState->fSelectedPostStepDoItVector <<
1043 break; <<
1044 <<
1045 case StronglyForced: <<
1046 (fpState->fSelectedPostStepDoItVector <<
1047 break; <<
1048 <<
1049 default: <<
1050 (fpState->fSelectedPostStepDoItVector <<
1051 break; <<
1052 } <<
1053 <<
1054 if(fCondition == ExclusivelyForced) <<
1055 { <<
1056 for(std::size_t nrest = np + 1; nrest < <<
1057 ++nrest) <<
1058 { <<
1059 (fpState->fSelectedPostStepDoItVector <<
1060 } <<
1061 return; // Please note the 'return' at <<
1062 } <<
1063 <<
1064 if(fPhysIntLength < fpState->fPhysicalSte <<
1065 { <<
1066 // To avoid checking whether the proces <<
1067 // proposing a time step, the returned <<
1068 // negative (just for tagging) <<
1069 if(fpCurrentProcess->ProposesTimeStep() <<
1070 { <<
1071 fPhysIntLength *= -1; <<
1072 if(fPhysIntLength < proposedTimeStep) <<
1073 { <<
1074 proposedTimeStep = fPhysIntLength; <<
1075 fPostStepAtTimeDoItProcTriggered = <<
1076 processWithPostStepGivenByTimeStep <<
1077 } <<
1078 } <<
1079 else <<
1080 { <<
1081 fpState->fPhysicalStep = fPhysIntLeng <<
1082 fpState->fStepStatus = fPostStepDoItP <<
1083 fPostStepDoItProcTriggered = G4int(np <<
1084 fpStep->GetPostStepPoint()->SetProces <<
1085 } <<
1086 } <<
1087 } <<
1088 <<
1089 // GPIL for AlongStep <<
1090 fpState->fProposedSafety = DBL_MAX; <<
1091 G4double safetyProposedToAndByProcess = fpS <<
1092 <<
1093 for(std::size_t kp = 0; kp < fpProcessInfo- <<
1094 { <<
1095 fpCurrentProcess = dynamic_cast<G4VITProc <<
1096 ->fpAlongStepGetPhysIntVector)[(G4int <<
1097 if(fpCurrentProcess == nullptr) continue; <<
1098 // NULL means the process is inactivated <<
1099 <<
1100 fpCurrentProcess->SetProcessState( <<
1101 fpTrackingInfo->GetProcessState(fpCur <<
1102 fPhysIntLength = <<
1103 fpCurrentProcess->AlongStepGPIL(*fpTr <<
1104 fpSta <<
1105 fpSta <<
1106 safet <<
1107 &fGPI <<
1108 <<
1109 #ifdef G4VERBOSE <<
1110 // !!!!! Verbose <<
1111 if(fpVerbose != nullptr) fpVerbose->DPSLA <<
1112 #endif <<
1113 720
1114 if(fPhysIntLength < fpState->fPhysicalSte << 721 // ReSet the counter etc.
1115 { << 722 fpState->fPhysicalStep = DBL_MAX; // Initialize by a huge number
1116 fpState->fPhysicalStep = fPhysIntLength << 723 fPhysIntLength = DBL_MAX; // Initialize by a huge number
1117 // Should save PS and TS in IT <<
1118 724
1119 // Check if the process wants to be the << 725 double proposedTimeStep = DBL_MAX;
1120 // multi-scattering proposes Step limit << 726 G4VProcess* processWithPostStepGivenByTimeStep(0);
1121 if(fGPILSelection == CandidateForSelect <<
1122 { <<
1123 fpState->fStepStatus = fAlongStepDoIt <<
1124 fpStep->GetPostStepPoint()->SetProces <<
1125 } <<
1126 <<
1127 // Transportation is assumed to be the <<
1128 if(kp == fpProcessInfo->MAXofAlongStepL <<
1129 { <<
1130 fpTransportation = dynamic_cast<G4ITT <<
1131 <<
1132 if(fpTransportation == nullptr) <<
1133 { <<
1134 G4ExceptionDescription exceptionDes <<
1135 exceptionDescription << "No transpo <<
1136 G4Exception("G4ITStepProcessor::DoD <<
1137 "ITStepProcessor0009", <<
1138 FatalErrorInArgument, <<
1139 exceptionDescription); <<
1140 } <<
1141 727
1142 fTimeStep = fpTransportation->GetInte << 728 // GPIL for PostStep
>> 729 fPostStepDoItProcTriggered = fpProcessInfo->MAXofPostStepLoops;
>> 730 fPostStepAtTimeDoItProcTriggered = fpProcessInfo->MAXofPostStepLoops;
1143 731
1144 if(fpTrack->GetNextVolume() != nullpt << 732 // G4cout << "fpProcessInfo->MAXofPostStepLoops : " << fpProcessInfo->MAXofPostStepLoops
1145 else fpState->fStepStatus = fWorldBou << 733 // << " mol : " << fpITrack -> GetName() << " id : " << fpTrack->GetTrackID()
1146 } << 734 // << G4endl;
1147 } << 735
1148 else << 736 for(size_t np=0; np < fpProcessInfo->MAXofPostStepLoops; np++)
1149 { 737 {
1150 if(kp == fpProcessInfo->MAXofAlongStepL << 738 fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpPostStepGetPhysIntVector)[np];
1151 { << 739 if (fpCurrentProcess== 0)
1152 fpTransportation = dynamic_cast<G4ITT << 740 {
1153 << 741 (fpState->fSelectedPostStepDoItVector)[np] = InActivated;
1154 if(fpTransportation == nullptr) << 742 continue;
1155 { << 743 } // NULL means the process is inactivated by a user on fly.
1156 G4ExceptionDescription exceptionDes << 744
1157 exceptionDescription << "No transpo << 745 fCondition=NotForced;
1158 G4Exception("G4ITStepProcessor::DoD << 746 fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
1159 "ITStepProcessor0010", << 747
1160 FatalErrorInArgument, << 748 // G4cout << "Is going to call : " << fpCurrentProcess -> GetProcessName() << G4endl;
1161 exceptionDescription); << 749 fPhysIntLength = fpCurrentProcess->
>> 750 PostStepGPIL( *fpTrack,
>> 751 fpState->fPreviousStepSize,
>> 752 &fCondition );
>> 753 fpCurrentProcess->SetProcessState(0);
>> 754
>> 755 switch (fCondition)
>> 756 {
>> 757 case ExclusivelyForced: // Will need special treatment
>> 758 (fpState->fSelectedPostStepDoItVector)[np] = ExclusivelyForced;
>> 759 fpState->fStepStatus = fExclusivelyForcedProc;
>> 760 fpStep->GetPostStepPoint()
>> 761 ->SetProcessDefinedStep(fpCurrentProcess);
>> 762 break;
>> 763
>> 764 case Conditionally:
>> 765 // (fpState->fSelectedPostStepDoItVector)[np] = Conditionally;
>> 766 G4Exception("G4ITStepProcessor::DefinePhysicalStepLength()", "ITStepProcessor0008",
>> 767 FatalException, "This feature is no more supported");
>> 768 break;
>> 769
>> 770 case Forced:
>> 771 (fpState->fSelectedPostStepDoItVector)[np] = Forced;
>> 772 break;
>> 773
>> 774 case StronglyForced:
>> 775 (fpState->fSelectedPostStepDoItVector)[np] = StronglyForced;
>> 776 break;
>> 777
>> 778 default:
>> 779 (fpState->fSelectedPostStepDoItVector)[np] = InActivated;
>> 780 break;
1162 } 781 }
1163 782
1164 fTimeStep = fpTransportation->GetInte << 783 if (fCondition==ExclusivelyForced)
1165 } << 784 {
>> 785 for(size_t nrest=np+1; nrest < fpProcessInfo->MAXofPostStepLoops; nrest++)
>> 786 {
>> 787 (fpState->fSelectedPostStepDoItVector)[nrest] = InActivated;
>> 788 }
>> 789 return; // Please note the 'return' at here !!!
>> 790 }
>> 791 else
>> 792 {
>> 793 if(fPhysIntLength < fpState->fPhysicalStep )
>> 794 {
>> 795 // To avoid checking whether the process is actually
>> 796 // proposing a time step, the returned time steps are
>> 797 // negative (just for tagging)
>> 798 if(fpCurrentProcess->ProposesTimeStep())
>> 799 {
>> 800 fPhysIntLength *= -1;
>> 801 if(fPhysIntLength < proposedTimeStep)
>> 802 {
>> 803 proposedTimeStep = fPhysIntLength;
>> 804 fPostStepAtTimeDoItProcTriggered = np;
>> 805 processWithPostStepGivenByTimeStep = fpCurrentProcess;
>> 806 }
>> 807 }
>> 808 else
>> 809 {
>> 810 fpState->fPhysicalStep = fPhysIntLength;
>> 811 fpState->fStepStatus = fPostStepDoItProc;
>> 812 fPostStepDoItProcTriggered = G4int(np);
>> 813 fpStep->GetPostStepPoint()
>> 814 ->SetProcessDefinedStep(fpCurrentProcess);
>> 815 }
>> 816 }
>> 817 }
1166 } 818 }
1167 819
1168 // Handle PostStep processes sending back << 820 // GPIL for AlongStep
1169 if(proposedTimeStep < fTimeStep) << 821 fpState->proposedSafety = DBL_MAX;
1170 { << 822 G4double safetyProposedToAndByProcess = fpState->proposedSafety;
1171 if(fPostStepAtTimeDoItProcTriggered < f << 823
1172 { << 824 for(size_t kp=0; kp < fpProcessInfo->MAXofAlongStepLoops; kp++)
1173 if((fpState->fSelectedPostStepDoItVec << 825 {
>> 826 fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAlongStepGetPhysIntVector)[kp];
>> 827 if (fpCurrentProcess== 0) continue;
>> 828 // NULL means the process is inactivated by a user on fly.
>> 829
>> 830 fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
>> 831 fPhysIntLength = fpCurrentProcess-> AlongStepGPIL( *fpTrack,
>> 832 fpState->fPreviousStepSize,
>> 833 fpState->fPhysicalStep,
>> 834 safetyProposedToAndByProcess,
>> 835 &fGPILSelection );
>> 836
>> 837 if(fPhysIntLength < fpState->fPhysicalStep)
1174 { 838 {
1175 (fpState->fSelectedPostStepDoItVect << 839 fpState->fPhysicalStep = fPhysIntLength;
1176 NotForced; << 840 // Should save PS and TS in IT
1177 // (fpState->fSelectedPostStepDoItV <<
1178 841
1179 fpState->fStepStatus = fPostStepDoI << 842 // Check if the process wants to be the GPIL winner. For example,
1180 fpStep->GetPostStepPoint()->SetProc << 843 // multi-scattering proposes Step limit, but won't be the winner.
>> 844 if(fGPILSelection==CandidateForSelection)
>> 845 {
>> 846 fpState->fStepStatus = fAlongStepDoItProc;
>> 847 fpStep->GetPostStepPoint()
>> 848 ->SetProcessDefinedStep(fpCurrentProcess);
>> 849 }
>> 850
>> 851 // Transportation is assumed to be the last process in the vector
>> 852 if(kp == fpProcessInfo->MAXofAlongStepLoops-1)
>> 853 {
>> 854 fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);
>> 855
>> 856 if(! fpTransportation)
>> 857 {
>> 858 G4ExceptionDescription exceptionDescription ;
>> 859 exceptionDescription << "No transportation process found " ;
>> 860 G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength","ITStepProcessor0009",
>> 861 FatalErrorInArgument,exceptionDescription);
>> 862 }
>> 863
>> 864 fTimeStep = fpTransportation->GetInteractionTimeLeft();
>> 865
>> 866
>> 867 if (fpTrack->GetNextVolume() != 0)
>> 868 fpState->fStepStatus = fGeomBoundary;
>> 869 else
>> 870 fpState->fStepStatus = fWorldBoundary;
>> 871 }
>> 872 }
>> 873 else
>> 874 {
>> 875 if(kp == fpProcessInfo->MAXofAlongStepLoops-1)
>> 876 {
>> 877 fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);
>> 878
>> 879 if(! fpTransportation)
>> 880 {
>> 881 G4ExceptionDescription exceptionDescription ;
>> 882 exceptionDescription << "No transportation process found " ;
>> 883 G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength","ITStepProcessor0010",
>> 884 FatalErrorInArgument,exceptionDescription);
>> 885 }
1181 886
1182 fTimeStep = proposedTimeStep; << 887 fTimeStep = fpTransportation->GetInteractionTimeLeft();
>> 888 }
>> 889 }
1183 890
1184 fpTransportation->ComputeStep(*fpTr << 891 if(proposedTimeStep < fTimeStep)
1185 *fpSt << 892 {
1186 fTime << 893 if(fPostStepAtTimeDoItProcTriggered<fpProcessInfo->MAXofPostStepLoops)
1187 fpSta << 894 {
>> 895 if ((fpState->fSelectedPostStepDoItVector)[fPostStepAtTimeDoItProcTriggered] ==
>> 896 InActivated)
>> 897 {
>> 898 (fpState->fSelectedPostStepDoItVector)[fPostStepAtTimeDoItProcTriggered] = NotForced;
>> 899 // (fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] = InActivated;
>> 900
>> 901 fpState->fStepStatus = fPostStepDoItProc;
>> 902 fpStep->GetPostStepPoint()->SetProcessDefinedStep(processWithPostStepGivenByTimeStep);
>> 903
>> 904 fTimeStep = proposedTimeStep;
>> 905
>> 906 fpTransportation->ComputeStep(*fpTrack,*fpStep,fTimeStep,fpState->fPhysicalStep);
>> 907 }
>> 908 }
1188 } 909 }
1189 } << 910 else
1190 } <<
1191 else <<
1192 { <<
1193 if(fPostStepDoItProcTriggered < fpProce <<
1194 { <<
1195 if((fpState->fSelectedPostStepDoItVec <<
1196 { 911 {
1197 (fpState->fSelectedPostStepDoItVect << 912 if (fPostStepDoItProcTriggered<fpProcessInfo->MAXofPostStepLoops)
1198 NotForced; << 913 {
>> 914 if ((fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] ==
>> 915 InActivated)
>> 916 {
>> 917 (fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] =
>> 918 NotForced;
>> 919 }
>> 920 }
1199 } 921 }
1200 } <<
1201 } <<
1202 922
1203 // fpCurrentProcess->SetProcessState(0); << 923 fpCurrentProcess->SetProcessState(0);
1204 fpCurrentProcess->ResetProcessState(); <<
1205 924
1206 // Make sure to check the safety, even if << 925 // Make sure to check the safety, even if Step is not limited
1207 // by this process. << 926 // by this process. J. Apostolakis, June 20, 1998
1208 // << 927 //
1209 if(safetyProposedToAndByProcess < fpState << 928 if (safetyProposedToAndByProcess < fpState->proposedSafety)
1210 // proposedSafety keeps the smallest valu << 929 // proposedSafety keeps the smallest value:
1211 fpState->fProposedSafety = safetyProposed << 930 fpState->proposedSafety = safetyProposedToAndByProcess;
1212 else << 931 else
1213 // safetyProposedToAndByProcess always pr << 932 // safetyProposedToAndByProcess always proposes a valid safety:
1214 safetyProposedToAndByProcess = fpState->f << 933 safetyProposedToAndByProcess = fpState->proposedSafety;
1215 934
1216 } << 935 }
1217 936
1218 fpITrack->GetTrackingInfo()->SetNavigatorSt << 937 fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
1219 fpNavigator->ResetNavigatorState(); << 938 fpNavigator->SetNavigatorState(0);
1220 } 939 }
1221 940
1222 //___________________________________________ 941 //______________________________________________________________________________
1223 942