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.hh 64057 2012-10-30 15:04:49Z gcosmo $ 26 // 27 // 27 // Author: Mathieu Karamitros << 28 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr) 28 << 29 // The code is developed in the framework of t << 30 // << 31 // We would be very happy hearing from you, se << 32 // << 33 // In order for Geant4-DNA to be maintained an << 34 // article citations are crucial. << 35 // If you use Geant4-DNA chemistry and you pub << 36 // in addition to the general paper on Geant4- << 37 // 29 // 38 // Int. J. Model. Simul. Sci. Comput. 1 (2010) << 30 // WARNING : This class is released as a prototype. >> 31 // It might strongly evolve or even disapear in the next releases. 39 // 32 // 40 // we would be very happy if you could please << 33 // History: 41 // reference papers on chemistry: << 34 // ----------- >> 35 // 10 Oct 2011 M.Karamitros created 42 // 36 // 43 // J. Comput. Phys. 274 (2014) 841-882 << 37 // ------------------------------------------------------------------- 44 // Prog. Nucl. Sci. Tec. 2 (2011) 503-508 << 45 38 46 #ifndef G4ITSTEPPROCESSOR_H 39 #ifndef G4ITSTEPPROCESSOR_H 47 #define G4ITSTEPPROCESSOR_H 40 #define G4ITSTEPPROCESSOR_H 48 41 49 #include "G4ios.hh" // Inclu 42 #include "G4ios.hh" // Include from 'system' 50 #include "globals.hh" // Inclu 43 #include "globals.hh" // Include from 'global' 51 #include "Randomize.hh" // Inclu 44 #include "Randomize.hh" // Include from 'global' 52 45 53 #include "G4LogicalVolume.hh" // Inclu 46 #include "G4LogicalVolume.hh" // Include from 'geometry' 54 #include "G4VPhysicalVolume.hh" // Inclu 47 #include "G4VPhysicalVolume.hh" // Include from 'geometry' 55 #include "G4ProcessManager.hh" // Inclu 48 #include "G4ProcessManager.hh" // Include from 'piim' 56 49 57 #include "G4Track.hh" // Inclu 50 #include "G4Track.hh" // Include from 'track' 58 #include "G4TrackVector.hh" // Inclu 51 #include "G4TrackVector.hh" // Include from 'track' 59 #include "G4TrackStatus.hh" // Inclu 52 #include "G4TrackStatus.hh" // Include from 'track' 60 #include "G4StepStatus.hh" // Inclu 53 #include "G4StepStatus.hh" // Include from 'track' >> 54 //#include "G4UserSteppingAction.hh" // Include from 'tracking' >> 55 //#include "G4UserTrackingAction.hh" // Include from 'tracking' 61 #include "G4Step.hh" // Inclu 56 #include "G4Step.hh" // Include from 'track' 62 #include "G4StepPoint.hh" // Inclu 57 #include "G4StepPoint.hh" // Include from 'track' 63 #include "G4TouchableHandle.hh" // Inclu << 58 #include "G4TouchableHandle.hh" // Include from 'geometry' >> 59 #include "G4TouchableHistoryHandle.hh" // Include from 'geometry' 64 60 65 #include "G4ITStepProcessorState_Lock.hh" << 66 #include "G4ITLeadingTracks.hh" << 67 61 68 #include <vector> << 62 #include "G4TrackingInformation.hh" 69 63 >> 64 //class G4Navigator; 70 class G4ITNavigator; 65 class G4ITNavigator; 71 class G4ParticleDefinition; << 66 class G4ParticleDefinition ; 72 class G4ITTrackingManager; 67 class G4ITTrackingManager; 73 class G4IT; 68 class G4IT; 74 class G4TrackingInformation; 69 class G4TrackingInformation; 75 class G4ITTransportation; 70 class G4ITTransportation; 76 class G4VITProcess; 71 class G4VITProcess; 77 class G4VITSteppingVerbose; << 72 typedef class std::vector<int, std::allocator<int> > G4SelectedAtRestDoItVector; 78 class G4ITTrackHolder; << 73 typedef class std::vector<int, std::allocator<int> > G4SelectedAlongStepDoItVector; 79 using G4SelectedAtRestDoItVector = std::vector << 74 typedef class std::vector<int, std::allocator<int> > G4SelectedPostStepDoItVector; 80 using G4SelectedAlongStepDoItVector = std::vec << 81 using G4SelectedPostStepDoItVector = std::vect << 82 75 83 //____________________________________________ << 84 // << 85 // Members related to ParticleDefinition and n << 86 // proper to a track << 87 //____________________________________________ << 88 struct ProcessGeneralInfo << 89 { << 90 G4ProcessVector* fpAtRestDoItVector; << 91 G4ProcessVector* fpAlongStepDoItVector; << 92 G4ProcessVector* fpPostStepDoItVector; << 93 << 94 G4ProcessVector* fpAtRestGetPhysIntVector; << 95 G4ProcessVector* fpAlongStepGetPhysIntVector << 96 G4ProcessVector* fpPostStepGetPhysIntVector; << 97 // << 98 // Note: DoItVector has inverse order agains << 99 // and SelectedPostStepDoItVector. << 100 // << 101 // * Max number of processes << 102 std::size_t MAXofAtRestLoops; << 103 std::size_t MAXofAlongStepLoops; << 104 std::size_t MAXofPostStepLoops; << 105 // Maximum number of processes for each type << 106 // These depend on the G4ParticleDefinition, << 107 76 108 // * Transportation process << 77 /** 109 G4ITTransportation* fpTransportation; << 78 * Its role is the same as G4StepManager : 110 }; << 79 * - Find the minimum physical length and corresponding time step >> 80 * - Step one track BUT on a given time step. >> 81 */ 111 82 112 //____________________________________________ << 83 class G4ITStepProcessor 113 // << 114 // Members proper to a track << 115 //____________________________________________ << 116 class G4ITStepProcessorState : public G4ITStep << 117 { 84 { >> 85 118 public: 86 public: 119 G4ITStepProcessorState(); << 87 G4ITStepProcessor(); 120 ~G4ITStepProcessorState() override; << 88 virtual ~G4ITStepProcessor(); 121 89 122 G4ITStepProcessorState(const G4ITStepProcess << 90 inline void SetPreviousStepTime(G4double); 123 G4ITStepProcessorState& operator=(const G4IT << 124 91 125 // * Max Number of Process << 92 inline G4Track* GetTrack() {return fpTrack;} 126 G4SelectedAtRestDoItVector fSelectedAtRestDo << 93 inline G4Step* GetStep() {return fpStep;} 127 G4SelectedPostStepDoItVector fSelectedPostSt << 94 inline const G4Step* GetStep() const {return fpStep;} 128 << 95 inline void SetStep(G4Step* val) {fpStep = val;} 129 G4double fPhysicalStep; << 130 G4double fPreviousStepSize; << 131 G4double fSafety; << 132 << 133 G4StepStatus fStepStatus; << 134 << 135 // * Safety << 136 G4double fProposedSafety; << 137 // This keeps the minimum safety value propo << 138 G4ThreeVector fEndpointSafOrigin; << 139 G4double fEndpointSafety; << 140 // To get the true safety value at the PostS << 141 // to subtract the distance to 'endpointSafO << 142 96 143 G4TouchableHandle fTouchableHandle; << 97 inline G4TrackVector* GetSecondaries() {return fpSecondary;} 144 }; << 98 inline void SetTrackingManager(G4ITTrackingManager* trackMan) {fpTrackingManager = trackMan;} >> 99 inline G4ITTrackingManager* GetTrackingManager() {return fpTrackingManager;} 145 100 146 /** << 101 virtual void Initialize(); 147 * Its role is the same as G4StepManager : << 102 void ForceReInitialization(); 148 * - Find the minimum physical length and corr << 149 * - Step one track BUT on a given time step. << 150 */ << 151 103 152 class G4ITStepProcessor << 104 void DefinePhysicalStepLength(G4Track*); 153 { << 105 void Stepping(G4Track*, const double&); 154 friend class G4Scheduler; << 106 void CalculateStep(G4Track*, const double&); 155 public: << 107 void CalculateStep(G4Track*); 156 G4ITStepProcessor(); << 157 virtual ~G4ITStepProcessor(); << 158 108 159 inline void SetPreviousStepTime(G4double); << 109 void DoIt(G4Track*,double); 160 110 161 inline G4Track* GetTrack() << 111 void FindTransportationStep(); 162 { << 112 void UpdateTrack(G4Track*); 163 return fpTrack; << 113 164 } << 114 inline double GetInteractionTime(); 165 inline G4Step* GetStep() << 115 inline const G4Track* GetTrack() const ; 166 { << 116 inline void CleanProcessor(); 167 return fpStep; << 168 } << 169 inline const G4Step* GetStep() const << 170 { << 171 return fpStep; << 172 } << 173 inline void SetStep(G4Step* val) << 174 { << 175 fpStep = val; << 176 } << 177 << 178 inline G4TrackVector* GetSecondaries() const << 179 { << 180 return fpSecondary; << 181 } << 182 inline void SetTrackingManager(G4ITTrackingM << 183 { << 184 fpTrackingManager = trackMan; << 185 } << 186 inline G4ITTrackingManager* GetTrackingManag << 187 { << 188 return fpTrackingManager; << 189 } << 190 << 191 //___________________________________ << 192 << 193 virtual void Initialize(); << 194 void ForceReInitialization(); << 195 << 196 void ResetLeadingTracks(); << 197 void PrepareLeadingTracks(); << 198 << 199 //___________________________________ << 200 G4double ComputeInteractionLength(double pre << 201 void DefinePhysicalStepLength(G4Track*); << 202 G4double GetILTimeStep() << 203 { << 204 return fILTimeStep; << 205 } << 206 << 207 //___________________________________ << 208 // DoIt << 209 void DoIt(double timeStep); << 210 void ExtractDoItData(); << 211 void Stepping(G4Track*, const double&); << 212 void FindTransportationStep(); << 213 //___________________________________ << 214 << 215 inline double GetInteractionTime(); << 216 inline const G4Track* GetTrack() const; << 217 inline void CleanProcessor(); << 218 << 219 std::size_t GetAtRestDoItProcTriggered() con << 220 { << 221 return fAtRestDoItProcTriggered; << 222 } << 223 << 224 G4GPILSelection GetGPILSelection() const << 225 { << 226 return fGPILSelection; << 227 } << 228 << 229 G4int GetN2ndariesAlongStepDoIt() const << 230 { << 231 return fN2ndariesAlongStepDoIt; << 232 } << 233 << 234 G4int GetN2ndariesAtRestDoIt() const << 235 { << 236 return fN2ndariesAtRestDoIt; << 237 } << 238 << 239 G4int GetN2ndariesPostStepDoIt() const << 240 { << 241 return fN2ndariesPostStepDoIt; << 242 } << 243 << 244 const G4VITProcess* GetCurrentProcess() cons << 245 { << 246 return fpCurrentProcess; << 247 } << 248 << 249 G4double GetPhysIntLength() const << 250 { << 251 return fPhysIntLength; << 252 } << 253 << 254 std::size_t GetPostStepAtTimeDoItProcTrigger << 255 { << 256 return fPostStepAtTimeDoItProcTriggered; << 257 } << 258 << 259 std::size_t GetPostStepDoItProcTriggered() c << 260 { << 261 return fPostStepDoItProcTriggered; << 262 } << 263 << 264 const ProcessGeneralInfo* GetCurrentProcessI << 265 { << 266 return fpProcessInfo; << 267 } << 268 << 269 const G4ITStepProcessorState* GetProcessorSt << 270 { << 271 return fpState; << 272 } << 273 << 274 const G4VParticleChange* GetParticleChange() << 275 { << 276 return fpParticleChange; << 277 } << 278 << 279 const G4VPhysicalVolume* GetCurrentVolume() << 280 { << 281 return fpCurrentVolume; << 282 } << 283 << 284 G4ForceCondition GetCondition() const << 285 { << 286 return fCondition; << 287 } << 288 117 289 protected: 118 protected: >> 119 void SetupGeneralProcessInfo(G4ParticleDefinition*,G4ProcessManager*); >> 120 void ClearProcessInfo(); >> 121 void SetTrack(G4Track*); >> 122 >> 123 void GetProcessInfo(); 290 124 291 void ExtractILData(); << 125 void SetupMembers(); >> 126 void ResetSecondaries(); >> 127 void InitDefineStep(); 292 128 293 void SetupGeneralProcessInfo(G4ParticleDefin << 129 void SetInitialStep(); 294 void ClearProcessInfo(); << 295 void SetTrack(G4Track*); << 296 << 297 void GetProcessInfo(); << 298 << 299 void SetupMembers(); << 300 void ResetSecondaries(); << 301 void InitDefineStep(); << 302 << 303 void SetInitialStep(); << 304 << 305 void GetAtRestIL(); << 306 void DoDefinePhysicalStepLength(); << 307 void DoStepping(); << 308 void PushSecondaries(); << 309 << 310 // void CalculateStep(); << 311 // void DoCalculateStep(); << 312 << 313 // void CloneProcesses(); << 314 void ActiveOnlyITProcess(); << 315 void ActiveOnlyITProcess(G4ProcessManager*); << 316 << 317 void DealWithSecondaries(G4int&); << 318 void InvokeAtRestDoItProcs(); << 319 void InvokeAlongStepDoItProcs(); << 320 void InvokePostStepDoItProcs(); << 321 void InvokePSDIP(std::size_t); // << 322 void InvokeTransportationProc(); << 323 void SetNavigator(G4ITNavigator *value); << 324 G4double CalculateSafety(); << 325 130 326 // Return the estimated safety value at the << 131 void GetAtRestIL(); 327 void ApplyProductionCut(G4Track*); << 132 void DoDefinePhysicalStepLength(); >> 133 void DoStepping(); 328 134 329 G4ITStepProcessor(const G4ITStepProcessor& o << 135 void CalculateStep(); 330 G4ITStepProcessor& operator=(const G4ITStepP << 136 void DoCalculateStep(); >> 137 >> 138 void CloneProcesses(); >> 139 void ActiveOnlyITProcess(); >> 140 void ActiveOnlyITProcess(G4ProcessManager*); >> 141 >> 142 void DealWithSecondaries(G4int&); >> 143 void InvokeAtRestDoItProcs(); >> 144 void InvokeAlongStepDoItProcs(); >> 145 void InvokePostStepDoItProcs(); >> 146 void InvokePSDIP(size_t); // >> 147 void InvokeTransportationProc(); >> 148 void SetNavigator(G4ITNavigator *value); >> 149 G4double CalculateSafety(); >> 150 >> 151 // Return the estimated safety value at the PostStepPoint >> 152 void ApplyProductionCut(G4Track*); >> 153 >> 154 >> 155 G4ITStepProcessor(const G4ITStepProcessor& other); >> 156 G4ITStepProcessor& operator=(const G4ITStepProcessor& other); 331 157 332 private: 158 private: 333 //__________________________________________ << 159 //________________________________________________ 334 // << 160 // 335 // General members << 161 // General members 336 //__________________________________________ << 162 //________________________________________________ 337 << 163 338 G4bool fInitialized; << 164 G4bool fInitialized; 339 << 165 340 G4ITTrackingManager* fpTrackingManager; << 166 G4ITTrackingManager* fpTrackingManager; 341 << 167 // G4UserSteppingAction* fpUserSteppingAction; 342 G4double kCarTolerance; << 168 343 // Cached geometrical tolerance on surface << 169 G4double kCarTolerance; 344 << 170 // Cached geometrical tolerance on surface 345 G4ITNavigator* fpNavigator; << 171 346 G4int fStoreTrajectory; << 172 G4ITNavigator* fpNavigator; 347 G4VITSteppingVerbose* fpVerbose; << 173 // G4Navigator* fpNavigator; 348 << 174 G4int fStoreTrajectory; 349 G4ITTrackHolder* fpTrackContainer; << 175 G4int verboseLevel; 350 G4ITLeadingTracks fLeadingTracks; << 176 351 << 177 //________________________________________________ 352 //__________________________________________ << 178 // 353 // << 179 // Members used as temporaries (= not proper to a track) 354 // Members used as temporaries (= not proper << 180 //________________________________________________ 355 //__________________________________________ << 181 356 << 182 G4double fTimeStep ; // not proper to a track 357 G4double fTimeStep; // not proper to a track << 183 G4double fPreviousTimeStep; 358 G4double fILTimeStep; // proper to a track e << 184 G4TrackVector* fpSecondary ; // get from fpStep at every configuration setup 359 << 185 G4VParticleChange* fpParticleChange; 360 G4double fPreviousTimeStep; << 186 361 G4TrackVector* fpSecondary; // get from fpSt << 187 G4VITProcess* fpCurrentProcess; 362 G4VParticleChange* fpParticleChange; << 188 // The pointer to the process of which DoIt or 363 << 189 // GetPhysicalInteractionLength has been just executed 364 G4VITProcess* fpCurrentProcess; << 190 365 // The pointer to the process of which DoIt << 191 // * Secondaries 366 // GetPhysicalInteractionLength has been jus << 192 G4int fN2ndariesAtRestDoIt; 367 << 193 G4int fN2ndariesAlongStepDoIt; 368 // * Secondaries << 194 G4int fN2ndariesPostStepDoIt; 369 G4int fN2ndariesAtRestDoIt; << 195 // These are the numbers of secondaries generated by the process 370 G4int fN2ndariesAlongStepDoIt; << 196 // just executed. 371 G4int fN2ndariesPostStepDoIt; << 197 372 // These are the numbers of secondaries gene << 198 // * Process selection 373 // just executed. << 199 size_t fAtRestDoItProcTriggered; 374 << 200 size_t fPostStepDoItProcTriggered; 375 // * Process selection << 201 size_t fPostStepAtTimeDoItProcTriggered; 376 std::size_t fAtRestDoItProcTriggered; << 202 // Record the selected process 377 std::size_t fPostStepDoItProcTriggered; << 203 378 std::size_t fPostStepAtTimeDoItProcTriggered << 204 G4ForceCondition fCondition; 379 // Record the selected process << 205 G4GPILSelection fGPILSelection; 380 << 206 // Above three variables are for the method 381 G4ForceCondition fCondition; << 207 // DefinePhysicalStepLength(). To pass these information to 382 G4GPILSelection fGPILSelection; << 208 // the method Verbose, they are kept at here. Need a more 383 // Above three variables are for the method << 209 // elegant mechanism. 384 // DefinePhysicalStepLength(). To pass these << 210 385 // the method Verbose, they are kept at here << 211 G4double fPhysIntLength; 386 // elegant mechanism. << 212 // The minimum physical interaction length over all possible processes 387 << 213 388 G4double fPhysIntLength; << 214 // * Sensitive detector 389 // The minimum physical interaction length o << 215 // G4SteppingControl StepControlFlag; 390 << 216 // G4VSensitiveDetector* fpSensitive; 391 // * Sensitive detector << 217 392 // G4SteppingControl StepControlFlag; << 218 G4VPhysicalVolume* fpCurrentVolume; // Get from fpStep or touchable, keep as member for user interface 393 // G4VSensitiveDetector* fpSensitive; << 219 394 << 220 //________________________________________________ 395 G4VPhysicalVolume* fpCurrentVolume; << 221 // 396 // Get from fpStep or touchable, keep as mem << 222 // Members related to ParticleDefinition and not 397 << 223 // proper to a track 398 //__________________________________________ << 224 //________________________________________________ 399 // << 225 struct ProcessGeneralInfo 400 // Members related to ParticleDefinition and << 226 { 401 // proper to a track << 227 G4ProcessVector* fpAtRestDoItVector; 402 //__________________________________________ << 228 G4ProcessVector* fpAlongStepDoItVector; 403 << 229 G4ProcessVector* fpPostStepDoItVector; 404 std::map<const G4ParticleDefinition*, Proces << 230 405 ProcessGeneralInfo* fpProcessInfo; << 231 G4ProcessVector* fpAtRestGetPhysIntVector; 406 G4ITTransportation* fpTransportation; << 232 G4ProcessVector* fpAlongStepGetPhysIntVector; 407 << 233 G4ProcessVector* fpPostStepGetPhysIntVector; 408 //__________________________________________ << 234 // 409 // << 235 // Note: DoItVector has inverse order against GetPhysIntVector 410 // Members used for setting up the processor << 236 // and SelectedPostStepDoItVector. 411 //__________________________________________ << 237 // 412 << 238 // * Max Number of Process 413 G4Track* fpTrack; // Set track << 239 size_t MAXofAtRestLoops; 414 G4IT* fpITrack; // Set track << 240 size_t MAXofAlongStepLoops; 415 G4TrackingInformation* fpTrackingInfo; // Se << 241 size_t MAXofPostStepLoops; >> 242 // Maximum number of processes for each type of process >> 243 // These depend on the G4ParticleDefinition, so on the track >> 244 >> 245 // * Transportation process >> 246 G4ITTransportation* fpTransportation ; >> 247 }; >> 248 >> 249 std::map<const G4ParticleDefinition*, ProcessGeneralInfo*> fProcessGeneralInfoMap; >> 250 ProcessGeneralInfo* fpProcessInfo; >> 251 >> 252 G4ITTransportation* fpTransportation ; >> 253 >> 254 //________________________________________________ >> 255 // >> 256 // Members proper to a track >> 257 //________________________________________________ >> 258 class G4ITStepProcessorState : public G4ITStepProcessorState_Lock >> 259 { >> 260 public: >> 261 G4ITStepProcessorState(); >> 262 virtual ~G4ITStepProcessorState(); >> 263 >> 264 // * Max Number of Process >> 265 G4SelectedAtRestDoItVector fSelectedAtRestDoItVector; >> 266 G4SelectedPostStepDoItVector fSelectedPostStepDoItVector; >> 267 >> 268 G4double fPhysicalStep; >> 269 G4double fPreviousStepSize; >> 270 G4double fSafety; >> 271 >> 272 G4StepStatus fStepStatus; >> 273 >> 274 // * Safety >> 275 G4double proposedSafety; >> 276 // This keeps the minimum safety value proposed by AlongStepGPILs. >> 277 G4ThreeVector endpointSafOrigin; >> 278 G4double endpointSafety; >> 279 // To get the true safety value at the PostStepPoint, you have >> 280 // to subtract the distance to 'endpointSafOrigin' from this value. >> 281 >> 282 G4TouchableHandle fTouchableHandle; >> 283 private : >> 284 G4ITStepProcessorState(const G4ITStepProcessorState&); >> 285 G4ITStepProcessorState& operator=(const G4ITStepProcessorState&); >> 286 }; >> 287 >> 288 //________________________________________________ >> 289 // >> 290 // Members used for configurating the processor >> 291 //________________________________________________ >> 292 >> 293 G4Track* fpTrack; // Set track >> 294 G4IT* fpITrack ; // Set track >> 295 G4TrackingInformation* fpTrackingInfo ; // Set track 416 296 417 G4ITStepProcessorState* fpState; // SetupMem << 297 G4ITStepProcessorState* fpState; // SetupMembers or InitDefineStep 418 G4Step* fpStep; // Set track or InitDefineSt << 298 G4Step* fpStep; // Set track or InitDefineStep 419 299 420 G4StepPoint* fpPreStepPoint; // SetupMembers << 300 G4StepPoint* fpPreStepPoint; // SetupMembers 421 G4StepPoint* fpPostStepPoint; // SetupMember << 301 G4StepPoint* fpPostStepPoint; // SetupMembers 422 }; 302 }; 423 303 424 //____________________________________________ << 425 << 426 inline void G4ITStepProcessor::SetPreviousStep 304 inline void G4ITStepProcessor::SetPreviousStepTime(G4double previousTimeStep) 427 { 305 { 428 fPreviousTimeStep = previousTimeStep; << 306 fPreviousTimeStep = previousTimeStep; 429 } 307 } 430 308 431 //____________________________________________ << 432 << 433 inline const G4Track* G4ITStepProcessor::GetTr 309 inline const G4Track* G4ITStepProcessor::GetTrack() const 434 { 310 { 435 return fpTrack; << 311 return fpTrack; 436 } 312 } 437 313 438 //____________________________________________ << 439 << 440 inline G4double G4ITStepProcessor::CalculateSa 314 inline G4double G4ITStepProcessor::CalculateSafety() 441 { 315 { 442 return std::max(fpState->fEndpointSafety - ( << 316 return std::max( fpState->endpointSafety - 443 - fpPostStepPoint->GetPo << 317 (fpState->endpointSafOrigin - fpPostStepPoint->GetPosition()).mag(), 444 kCarTolerance); << 318 kCarTolerance ); 445 } 319 } 446 320 447 //____________________________________________ << 448 << 449 inline void G4ITStepProcessor::SetNavigator(G4 321 inline void G4ITStepProcessor::SetNavigator(G4ITNavigator *value) 450 { 322 { 451 fpNavigator = value; << 323 fpNavigator = value; 452 } 324 } 453 325 454 //____________________________________________ << 455 << 456 inline void G4ITStepProcessor::CleanProcessor( 326 inline void G4ITStepProcessor::CleanProcessor() 457 { 327 { 458 fTimeStep = DBL_MAX; << 328 fTimeStep = DBL_MAX ; 459 fPhysIntLength = DBL_MAX; << 329 fPhysIntLength = DBL_MAX; 460 330 461 fpState = nullptr; << 331 fpState = 0; 462 fpTrack = nullptr; << 332 fpTrack = 0; 463 fpTrackingInfo = nullptr; << 333 fpTrackingInfo = 0 ; 464 fpITrack = nullptr; << 334 fpITrack = 0; 465 fpStep = nullptr; << 335 fpStep = 0; 466 fpPreStepPoint = nullptr; << 336 fpPreStepPoint = 0; 467 fpPostStepPoint = nullptr; << 337 fpPostStepPoint = 0; 468 << 338 469 fpParticleChange = nullptr; << 339 fpParticleChange = 0; 470 << 340 471 fpCurrentVolume = nullptr; << 341 fpCurrentVolume = 0; 472 // fpSensitive = 0; << 342 // fpSensitive = 0; 473 << 343 474 fpSecondary = nullptr; << 344 fpSecondary = 0 ; 475 << 345 476 fpTransportation = nullptr; << 346 fpTransportation = 0; 477 << 347 478 fpCurrentProcess= nullptr; << 348 fpCurrentProcess= 0; 479 fpProcessInfo = nullptr; << 349 fpProcessInfo = 0; 480 << 350 481 fAtRestDoItProcTriggered = INT_MAX; << 351 fAtRestDoItProcTriggered = INT_MAX; 482 fPostStepDoItProcTriggered = INT_MAX; << 352 fPostStepDoItProcTriggered = INT_MAX; 483 fPostStepAtTimeDoItProcTriggered = INT_MAX; << 353 fPostStepAtTimeDoItProcTriggered = INT_MAX; 484 fGPILSelection = NotCandidateForSelection; << 354 fGPILSelection = NotCandidateForSelection ; 485 fCondition = NotForced; << 355 fCondition = NotForced; 486 } 356 } 487 357 488 //____________________________________________ 358 //______________________________________________________________________________ 489 << 490 inline double G4ITStepProcessor::GetInteractio 359 inline double G4ITStepProcessor::GetInteractionTime() 491 { 360 { 492 return fTimeStep; << 361 return fTimeStep ; 493 } 362 } >> 363 494 364 495 #endif // G4ITSTEPPROCESSOR_H 365 #endif // G4ITSTEPPROCESSOR_H 496 366