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