Geant4_10
G4ITStepProcessor2.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // $Id: G4ITStepProcessor2.cc 77292 2013-11-22 10:58:39Z gcosmo $
27 //
28 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
29 //
30 // History:
31 // -----------
32 // 10 Oct 2011 M.Karamitros created
33 //
34 // -------------------------------------------------------------------
35 
36 #include "G4ITStepProcessor.hh"
37 #include "G4LossTableManager.hh"
38 #include "G4ProductionCuts.hh"
39 #include "G4ProductionCutsTable.hh"
40 #include "G4VITProcess.hh"
41 #include "G4TrackingInformation.hh"
42 #include "G4IT.hh"
43 #include "G4ITTrackingManager.hh"
44 #include "G4ITTransportation.hh"
45 
46 #include "G4ITNavigator.hh" // Include from 'geometry'
47 //#include "G4Navigator.hh" // Include from 'geometry'
48 
50 {
51  // Now Store the secondaries from ParticleChange to SecondaryList
52  G4Track* tempSecondaryTrack;
53 
54  for(G4int DSecLoop=0 ;
55  DSecLoop<fpParticleChange->GetNumberOfSecondaries() ;
56  DSecLoop++)
57  {
58  tempSecondaryTrack = fpParticleChange->GetSecondary(DSecLoop);
59 
60  if(tempSecondaryTrack->GetDefinition()->GetApplyCutsFlag())
61  {
62  ApplyProductionCut(tempSecondaryTrack);
63  }
64 
65  // Set parentID
66  tempSecondaryTrack->SetParentID( fpTrack->GetTrackID() );
67 
68  // Set the process pointer which created this track
69  tempSecondaryTrack->SetCreatorProcess( fpCurrentProcess );
70 
71  // If this 2ndry particle has 'zero' kinetic energy, make sure
72  // it invokes a rest process at the beginning of the tracking
73  if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN)
74  {
75  G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()->GetProcessManager();
76  if (pm->GetAtRestProcessVector()->entries()>0){
77  tempSecondaryTrack->SetTrackStatus( fStopButAlive );
78  fpSecondary->push_back( tempSecondaryTrack );
79  fN2ndariesAtRestDoIt++;
80  } else {
81  delete tempSecondaryTrack;
82  }
83  }
84  else
85  {
86  fpSecondary->push_back( tempSecondaryTrack );
87  counter++;
88  }
89  } //end of loop on secondary
90 }
91 
92 //______________________________________________________________________________
93 
94 void G4ITStepProcessor::Stepping(G4Track* track, const double & timeStep)
95 {
97  if(track == 0) return ; // maybe put an exception here
98  fTimeStep = timeStep ;
99  SetTrack(track);
100  DoStepping();
101 }
102 //______________________________________________________________________________
103 
104 // ************************************************************************
105 // Stepping
106 // ************************************************************************
108 {
109  SetupMembers() ;
110 
111  if(!fpProcessInfo)
112  {
113  G4ExceptionDescription exceptionDescription ;
114  exceptionDescription << "No process info found for particle :"
115  << fpTrack->GetDefinition()->GetParticleName();
116  G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0012",
117  FatalErrorInArgument,exceptionDescription);
118  return ;
119  }
120  else if(fpTrack->GetTrackStatus() == fStopAndKill )
121  {
122  fpState->fStepStatus = fUndefined;
123  return ;
124  }
125 
126  if(fpProcessInfo->MAXofPostStepLoops == 0
127  && fpProcessInfo->MAXofAlongStepLoops == 0
128  && fpProcessInfo->MAXofAtRestLoops == 0)
129  {
130  fpTrack -> SetTrackStatus(fStopAndKill) ;
131  fpState->fStepStatus = fUndefined;
132  return ;
133  }
134  //---------------------------------
135  // AtRestStep, AlongStep and PostStep Processes
136  //---------------------------------
137  else
138  {
139  fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
140  fpNavigator->ResetHierarchyAndLocate( fpTrack->GetPosition(),
141  fpTrack->GetMomentumDirection(),
142  *((G4TouchableHistory*)fpTrack->GetTouchableHandle()()) );
143  fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
144  // We reset the navigator state before checking for AtRest
145  // in case a AtRest processe would use a navigator info
146 
147  if( fpTrack->GetTrackStatus() == fStopButAlive )
148  {
149  if( fpProcessInfo->MAXofAtRestLoops>0 &&
150  fpProcessInfo->fpAtRestDoItVector != 0) // second condition to make coverity happy
151  {
152  //-----------------
153  // AtRestStepDoIt
154  //-----------------
156  fpState->fStepStatus = fAtRestDoItProc;
157  fpStep->GetPostStepPoint()->SetStepStatus( fpState->fStepStatus );
158 
159  }
160  // Make sure the track is killed
161  fpTrack->SetTrackStatus( fStopAndKill );
162  }
163  else // if(fTimeStep > 0.) // Bye, because PostStepIL can return 0 => time =0
164  {
165  if(fpITrack == 0)
166  {
167  G4ExceptionDescription exceptionDescription ;
168  exceptionDescription
169  << " !!! TrackID : "<< fpTrack->GetTrackID() << G4endl
170  << " !!! Track status : "<< fpTrack->GetTrackStatus() << G4endl
171  << " !!! Particle Name : "<< fpTrack -> GetDefinition() -> GetParticleName() << G4endl
172  << "No G4ITStepProcessor::fpITrack found" << G4endl;
173 
174  G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0013",
175  FatalErrorInArgument,exceptionDescription);
176  return ; // to make coverity happy
177  }
178 
179  if(fpITrack->GetTrackingInfo()->IsLeadingStep() == false)
180  {
181  // In case the track has NOT the minimum step length
182  // Given the final step time, the transportation
183  // will compute the final position of the particle
184 
185  fpState->fStepStatus = fPostStepDoItProc;
186  fpStep->GetPostStepPoint()
187  ->SetProcessDefinedStep(fpTransportation);
189  }
190 
191 
192  // Store the Step length (geometrical length) to G4Step and G4Track
193  fpTrack->SetStepLength( fpState->fPhysicalStep );
194  fpStep->SetStepLength( fpState->fPhysicalStep );
195 
196  G4double GeomStepLength = fpState->fPhysicalStep;
197 
198  // Store StepStatus to PostStepPoint
199  fpStep->GetPostStepPoint()->SetStepStatus( fpState->fStepStatus );
200 
201  // Invoke AlongStepDoIt
203 
204  // Update track by taking into account all changes by AlongStepDoIt
205  // fpStep->UpdateTrack(); // done in InvokeAlongStepDoItProcs
206 
207  // Update safety after invocation of all AlongStepDoIts
208  fpState->endpointSafOrigin= fpPostStepPoint->GetPosition();
209 
210  fpState->endpointSafety= std::max( fpState->proposedSafety - GeomStepLength, kCarTolerance);
211 
212  fpStep->GetPostStepPoint()->SetSafety( fpState->endpointSafety );
213 
214  if(GetIT(fpTrack)->GetTrackingInfo()->IsLeadingStep())
215  {
216  // Invoke PostStepDoIt including G4ITTransportation::PSDI
218  }
219  else
220  {
221  // Only invoke transportation
223  }
224  }
225 
226  fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
227  fpNavigator->SetNavigatorState(0);
228  }
229  //-------
230  // Finale
231  //-------
232 
233  // Update 'TrackLength' and remeber the Step length of the current Step
234  fpTrack->AddTrackLength(fpStep->GetStepLength());
235  fpTrack->IncrementCurrentStepNumber();
236 
237  // Send G4Step information to Hit/Dig if the volume is sensitive
238 /***
239  fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
240  StepControlFlag = fpStep->GetControlFlag();
241 
242  if( fpCurrentVolume != 0 && StepControlFlag != AvoidHitInvocation)
243  {
244  fpSensitive = fpStep->GetPreStepPoint()->
245  GetSensitiveDetector();
246  if( fpSensitive != 0 )
247  {
248  fpSensitive->Hit(fpStep);
249  }
250  }
251 
252  User intervention process.
253  if( fpUserSteppingAction != 0 )
254  {
255  fpUserSteppingAction->UserSteppingAction(fpStep);
256  }
257  G4UserSteppingAction* regionalAction
258  = fpStep->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()
259  ->GetRegionalSteppingAction();
260  if( regionalAction ) regionalAction->UserSteppingAction(fpStep);
261 ***/
262  fpTrackingManager->AppendStep(fpTrack,fpStep);
263  // Stepping process finish. Return the value of the StepStatus.
264 
265  // return fpState->fStepStatus;
266 }
267 
268 //______________________________________________________________________________
269 
270 // ************************************************************************
271 // AtRestDoIt
272 // ************************************************************************
273 
275 {
276  fpStep->SetStepLength( 0. ); //the particle has stopped
277  fpTrack->SetStepLength( 0. );
278 
279  G4SelectedAtRestDoItVector& selectedAtRestDoItVector = fpState->fSelectedAtRestDoItVector;
280 
281  // invoke selected process
282  for(size_t np=0; np < fpProcessInfo->MAXofAtRestLoops; np++)
283  {
284  //
285  // Note: DoItVector has inverse order against GetPhysIntVector
286  // and SelectedAtRestDoItVector.
287  //
288  if( selectedAtRestDoItVector[fpProcessInfo->MAXofAtRestLoops-np-1] != InActivated)
289  {
290  fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAtRestDoItVector)[np];
291 
292  fpCurrentProcess->SetProcessState(
293  fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
294  fpParticleChange
295  = fpCurrentProcess->AtRestDoIt( *fpTrack, *fpStep);
296  fpCurrentProcess->SetProcessState(0);
297 
298  // Set the current process as a process which defined this Step length
299  fpStep->GetPostStepPoint()
300  ->SetProcessDefinedStep(fpCurrentProcess);
301 
302  // Update Step
303  fpParticleChange->UpdateStepForAtRest(fpStep);
304 
305  // Now Store the secondaries from ParticleChange to SecondaryList
306  DealWithSecondaries(fN2ndariesAtRestDoIt) ;
307 
308  // clear ParticleChange
309  fpParticleChange->Clear();
310 
311  } //if(fSelectedAtRestDoItVector[np] != InActivated){
312  } //for(size_t np=0; np < MAXofAtRestLoops; np++){
313  fpStep->UpdateTrack();
314 
315  fpTrack->SetTrackStatus( fStopAndKill );
316 }
317 
318 //______________________________________________________________________________
319 
320 // ************************************************************************
321 // AlongStepDoIt
322 // ************************************************************************
323 
325 {
326 
327  // If the current Step is defined by a 'ExclusivelyForced'
328  // PostStepDoIt, then don't invoke any AlongStepDoIt
329  if(fpState->fStepStatus == fExclusivelyForcedProc)
330  {
331  return; // Take note 'return' at here !!!
332  }
333 
334  // Invoke the all active continuous processes
335  for( size_t ci=0 ; ci<fpProcessInfo->MAXofAlongStepLoops ; ci++ )
336  {
337  fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAlongStepDoItVector)[ci];
338  if (fpCurrentProcess== 0) continue;
339  // NULL means the process is inactivated by a user on fly.
340 
341  fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
342  fpParticleChange
343  = fpCurrentProcess->AlongStepDoIt( *fpTrack, *fpStep );
344  fpCurrentProcess->SetProcessState(0);
345  // Update the PostStepPoint of Step according to ParticleChange
346 
347  fpParticleChange->UpdateStepForAlongStep(fpStep);
348 
349  // Now Store the secondaries from ParticleChange to SecondaryList
350  DealWithSecondaries(fN2ndariesAlongStepDoIt) ;
351 
352  // Set the track status according to what the process defined
353  // if kinetic energy >0, otherwise set fStopButAlive
354  fpTrack->SetTrackStatus( fpParticleChange->GetTrackStatus() );
355 
356  // clear ParticleChange
357  fpParticleChange->Clear();
358  }
359 
360  fpStep->UpdateTrack();
361 
362  G4TrackStatus fNewStatus = fpTrack->GetTrackStatus();
363 
364  if ( fNewStatus == fAlive && fpTrack->GetKineticEnergy() <= DBL_MIN )
365  {
366  // G4cout << "G4ITStepProcessor::InvokeAlongStepDoItProcs : Track will be killed" << G4endl;
367  if(fpProcessInfo->MAXofAtRestLoops>0) fNewStatus = fStopButAlive;
368  else fNewStatus = fStopAndKill;
369  fpTrack->SetTrackStatus( fNewStatus );
370  }
371 
372 }
373 
374 //______________________________________________________________________________
375 
376 
377 // ************************************************************************
378 // PostStepDoIt
379 // ************************************************************************
380 
381 
383 {
384 
385  G4SelectedPostStepDoItVector& selectedPostStepDoItVector = fpState->fSelectedPostStepDoItVector;
386  G4StepStatus& stepStatus = fpState->fStepStatus;
387 
388  // Invoke the specified discrete processes
389  for(size_t np=0; np < fpProcessInfo->MAXofPostStepLoops; np++)
390  {
391  //
392  // Note: DoItVector has inverse order against GetPhysIntVector
393  // and SelectedPostStepDoItVector.
394  //
395  G4int Cond = selectedPostStepDoItVector[fpProcessInfo->MAXofPostStepLoops-np-1];
396  if(Cond != InActivated)
397  {
398  if( ((Cond == NotForced) && (stepStatus == fPostStepDoItProc)) ||
399  ((Cond == Forced) && (stepStatus != fExclusivelyForcedProc)) ||
400  // ((Cond == Conditionally) && (stepStatus == fAlongStepDoItProc)) ||
401  ((Cond == ExclusivelyForced) && (stepStatus == fExclusivelyForcedProc)) ||
402  ((Cond == StronglyForced) )
403  )
404  {
405 
406  InvokePSDIP(np);
407  }
408  } //if(*fSelectedPostStepDoItVector(np)........
409 
410  // Exit from PostStepLoop if the track has been killed,
411  // but extra treatment for processes with Strongly Forced flag
412  if(fpTrack->GetTrackStatus() == fStopAndKill)
413  {
414  for(size_t np1=np+1; np1 < fpProcessInfo->MAXofPostStepLoops; np1++)
415  {
416  G4int Cond2 = selectedPostStepDoItVector[fpProcessInfo->MAXofPostStepLoops-np1-1];
417  if (Cond2 == StronglyForced)
418  {
419  InvokePSDIP(np1);
420  }
421  }
422  break;
423  }
424  } //for(size_t np=0; np < MAXofPostStepLoops; np++){
425 }
426 
427 //______________________________________________________________________________
428 
430 {
431  fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpPostStepDoItVector)[np];
432 
433  fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
434  fpParticleChange
435  = fpCurrentProcess->PostStepDoIt( *fpTrack, *fpStep);
436  fpCurrentProcess->SetProcessState(0);
437 
438  // Update PostStepPoint of Step according to ParticleChange
439  fpParticleChange->UpdateStepForPostStep(fpStep);
440 
441  // Update G4Track according to ParticleChange after each PostStepDoIt
442  fpStep->UpdateTrack();
443 
444  // Update safety after each invocation of PostStepDoIts
446 
447  // Now Store the secondaries from ParticleChange to SecondaryList
448  DealWithSecondaries(fN2ndariesPostStepDoIt) ;
449 
450  // Set the track status according to what the process defined
451  fpTrack->SetTrackStatus( fpParticleChange->GetTrackStatus() );
452 
453  // clear ParticleChange
454  fpParticleChange->Clear();
455 }
456 
457 //______________________________________________________________________________
458 
459 // ************************************************************************
460 // Transport on a given time
461 // ************************************************************************
462 
464 {
465  double physicalStep(0.) ;
466 
467  fpTransportation = fpProcessInfo->fpTransportation;
468  // dynamic_cast<G4ITTransportation*>((fpProcessInfo->fpAlongStepGetPhysIntVector)[MAXofAlongStepLoops-1]);
469 
470  if(!fpTrack)
471  {
472  G4ExceptionDescription exceptionDescription ;
473  exceptionDescription
474  << "No G4ITStepProcessor::fpTrack found";
475  G4Exception("G4ITStepProcessor::FindTransportationStep","ITStepProcessor0013",
476  FatalErrorInArgument,exceptionDescription);
477  return;
478 
479  }
480  if(!fpITrack)
481  {
482  G4ExceptionDescription exceptionDescription ;
483  exceptionDescription
484  << "No G4ITStepProcessor::fITrack" ;
485  G4Exception("G4ITStepProcessor::FindTransportationStep","ITStepProcessor0014",
486  FatalErrorInArgument,exceptionDescription);
487  return;
488  }
489  if(!(fpITrack->GetTrack()))
490  {
491  G4ExceptionDescription exceptionDescription ;
492  exceptionDescription
493  << "No G4ITStepProcessor::fITrack->GetTrack()" ;
494  G4Exception("G4ITStepProcessor::FindTransportationStep","ITStepProcessor0015",
495  FatalErrorInArgument,exceptionDescription);
496  return;
497  }
498 
499  if(fpTransportation)
500  {
501  fpTransportation->SetProcessState(fpTrackingInfo->GetProcessState(fpTransportation->GetProcessID()));
502  fpTransportation->ComputeStep(*fpTrack, *fpStep, fTimeStep, physicalStep) ;
503  fpTransportation->SetProcessState(0);
504  }
505 
506  if(physicalStep >= DBL_MAX)
507  {
508  fpTrack -> SetTrackStatus(fStopAndKill) ;
509  return ;
510  }
511 
512  fpState->fPhysicalStep = physicalStep ;
513 }
514 
515 //______________________________________________________________________________
516 
518 {
519  size_t _MAXofPostStepLoops = fpProcessInfo->MAXofPostStepLoops;
520  G4SelectedPostStepDoItVector& selectedPostStepDoItVector = fpState->fSelectedPostStepDoItVector;
521  G4StepStatus& stepStatus = fpState->fStepStatus;
522 
523  // Invoke the specified discrete processes
524  for(size_t np=0; np < _MAXofPostStepLoops; np++)
525  {
526  //
527  // Note: DoItVector has inverse order against GetPhysIntVector
528  // and SelectedPostStepDoItVector.
529  //
530  G4int Cond = selectedPostStepDoItVector[_MAXofPostStepLoops-np-1];
531  if(Cond != InActivated)
532  {
533  if(
534  ((Cond == Forced) && (stepStatus != fExclusivelyForcedProc)) ||
535  // ((Cond == Conditionally) && (stepStatus == fAlongStepDoItProc)) ||
536  ((Cond == ExclusivelyForced) && (stepStatus == fExclusivelyForcedProc)) ||
537  ((Cond == StronglyForced) )
538  )
539  {
540 
541  InvokePSDIP(np);
542  }
543  } //if(*fSelectedPostStepDoItVector(np)........
544 
545  // Exit from PostStepLoop if the track has been killed,
546  // but extra treatment for processes with Strongly Forced flag
547  if(fpTrack->GetTrackStatus() == fStopAndKill)
548  {
549  for(size_t np1=np+1; np1 < _MAXofPostStepLoops; np1++)
550  {
551  G4int Cond2 = selectedPostStepDoItVector[_MAXofPostStepLoops-np1-1];
552  if (Cond2 == StronglyForced)
553  {
554  InvokePSDIP(np1);
555  }
556  }
557  break;
558  }
559  }
560 }
561 
562 //______________________________________________________________________________
563 
564 // ************************************************************************
565 // Apply cuts
566 // ************************************************************************
567 
568 
570 {
571  G4bool tBelowCutEnergyAndSafety = false;
572  G4int tPtclIdx
573  = G4ProductionCuts::GetIndex(aSecondary->GetDefinition());
574  if (tPtclIdx<0)
575  {
576  return;
577  }
578  G4ProductionCutsTable* tCutsTbl
580  G4int tCoupleIdx
581  = tCutsTbl->GetCoupleIndex(fpPreStepPoint->GetMaterialCutsCouple());
582  G4double tProdThreshold
583  = (*(tCutsTbl->GetEnergyCutsVector(tPtclIdx)))[tCoupleIdx];
584  if( aSecondary->GetKineticEnergy()<tProdThreshold )
585  {
586  tBelowCutEnergyAndSafety = true;
587  if(std::abs(aSecondary->GetDynamicParticle()->GetCharge()) > DBL_MIN)
588  {
589  G4double currentRange
591  aSecondary->GetKineticEnergy(),
592  fpPreStepPoint->GetMaterialCutsCouple());
593  tBelowCutEnergyAndSafety = (currentRange < CalculateSafety() );
594  }
595  }
596 
597  if( tBelowCutEnergyAndSafety )
598  {
599  if( !(aSecondary->IsGoodForTracking()) )
600  {
601  // Add kinetic energy to the total energy deposit
602  fpStep->AddTotalEnergyDeposit(
603  aSecondary->GetKineticEnergy() );
604  aSecondary->SetKineticEnergy(0.0);
605  }
606  }
607 }
void SetTrackStatus(const G4TrackStatus aTrackStatus)
G4ParticleDefinition * GetDefinition() const
void SetStepLength(G4double value)
virtual G4VPhysicalVolume * ResetHierarchyAndLocate(const G4ThreeVector &point, const G4ThreeVector &direction, const G4TouchableHistory &h)
G4int GetNumberOfSecondaries() const
virtual G4Step * UpdateStepForAlongStep(G4Step *Step)
const std::vector< G4double > * GetEnergyCutsVector(size_t pcIdx) const
static G4LossTableManager * Instance()
G4Track * GetSecondary(G4int anIndex) const
static G4int GetIndex(const G4String &name)
void SetProcessDefinedStep(const G4VProcess *aValue)
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
G4double GetStepLength() const
const G4DynamicParticle * GetDynamicParticle() const
class std::vector< int, std::allocator< int > > G4SelectedAtRestDoItVector
const G4ThreeVector & GetPosition() const
G4TrackStatus GetTrackStatus() const
G4ProcessManager * GetProcessManager() const
int G4int
Definition: G4Types.hh:78
const G4MaterialCutsCouple * GetMaterialCutsCouple() const
void SetStepStatus(const G4StepStatus aValue)
const G4String & GetParticleName() const
G4StepStatus
Definition: G4StepStatus.hh:49
void SetCreatorProcess(const G4VProcess *aValue)
void SetTrack(G4Track *)
void UpdateTrack()
G4ITNavigatorState_Lock * GetNavigatorState()
G4IT * GetIT(const G4Track *track)
Definition: G4IT.cc:48
G4ProcessVector * GetAtRestProcessVector(G4ProcessVectorTypeIndex typ=typeGPIL) const
G4double GetKineticEnergy() const
G4int entries() const
class std::vector< int, std::allocator< int > > G4SelectedPostStepDoItVector
const G4ThreeVector & GetPosition() const
virtual void ComputeStep(const G4Track &, const G4Step &, const double timeStep, double &spaceStep)
void ApplyProductionCut(G4Track *)
bool G4bool
Definition: G4Types.hh:79
void SetStepLength(G4double value)
G4int GetCoupleIndex(const G4MaterialCutsCouple *aCouple) const
G4double GetCharge() const
void DealWithSecondaries(G4int &)
G4ITNavigatorState_Lock * GetNavigatorState() const
G4int GetTrackID() const
void SetProcessState(G4ProcessState_Lock *aProcInfo)
Definition: G4VITProcess.hh:90
const G4TouchableHandle & GetTouchableHandle() const
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4TrackingInformation * GetTrackingInfo()
Definition: G4IT.hh:134
static G4ProductionCutsTable * GetProductionCutsTable()
const G4ThreeVector & GetMomentumDirection() const
void IncrementCurrentStepNumber()
T max(const T t1, const T t2)
brief Return the largest of the two arguments
G4ProcessState_Lock * GetProcessState(size_t index)
virtual G4VParticleChange * AlongStepDoIt(const G4Track &track, const G4Step &stepData)=0
void Stepping(G4Track *, const double &)
void SetParentID(const G4int aValue)
G4StepPoint * GetPostStepPoint() const
void AddTotalEnergyDeposit(G4double value)
#define DBL_MIN
Definition: templates.hh:75
void SetNavigatorState(G4ITNavigatorState_Lock *)
G4Track * GetTrack()
Definition: G4IT.hh:208
void SetNavigatorState(G4ITNavigatorState_Lock *)
G4bool IsGoodForTracking() const
#define G4endl
Definition: G4ios.hh:61
G4bool GetApplyCutsFlag() const
G4TrackStatus GetTrackStatus() const
void AddTrackLength(const G4double aValue)
void SetKineticEnergy(const G4double aValue)
double G4double
Definition: G4Types.hh:76
virtual G4Step * UpdateStepForPostStep(G4Step *Step)
void SetSafety(const G4double aValue)
virtual G4VParticleChange * PostStepDoIt(const G4Track &track, const G4Step &stepData)=0
#define DBL_MAX
Definition: templates.hh:83
size_t GetProcessID() const
Definition: G4VITProcess.hh:80
G4double GetRange(const G4ParticleDefinition *aParticle, G4double kineticEnergy, const G4MaterialCutsCouple *couple)
G4TrackStatus
virtual void AppendStep(G4Track *track, G4Step *step)
virtual G4Step * UpdateStepForAtRest(G4Step *Step)
virtual G4VParticleChange * AtRestDoIt(const G4Track &track, const G4Step &stepData)=0