Geant4  v4-10.4-release
 모두 클래스 네임스페이스들 파일들 함수 변수 타입정의 열거형 타입 열거형 멤버 Friends 매크로 그룹들 페이지들
G4SteppingManager2.cc
이 파일의 문서화 페이지로 가기
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 //
27 // $Id: G4SteppingManager2.cc 109172 2018-04-03 06:49:31Z gcosmo $
28 //
29 //---------------------------------------------------------------
30 //
31 // G4SteppingManager2.cc
32 //
33 // Description:
34 // This class represents the manager who steers to move the give
35 // particle from the TrackingManger by one Step.
36 //
37 // Contact:
38 // Questions and comments to this code should be sent to
39 // Katsuya Amako (e-mail: Katsuya.Amako@kek.jp)
40 // Takashi Sasaki (e-mail: Takashi.Sasaki@kek.jp)
41 //
42 //---------------------------------------------------------------
43 
44 //#define debug
45 
46 #include "G4UImanager.hh"
47 #include "G4ForceCondition.hh"
48 #include "G4GPILSelection.hh"
49 #include "G4SteppingControl.hh"
51 #include "G4SteppingManager.hh"
52 #include "G4LossTableManager.hh"
53 #include "G4ParticleTable.hh"
54 
58 {
59 #ifdef debug
60  G4cout<<"G4SteppingManager::GetProcessNumber: is called track="
61  <<fTrack<<G4endl;
62 #endif
63 
65  if(!pm)
66  {
67  G4cerr << "ERROR - G4SteppingManager::GetProcessNumber()" << G4endl
68  << " ProcessManager is NULL for particle = "
69  << fTrack->GetDefinition()->GetParticleName() << ", PDG_code = "
71  G4Exception("G4SteppingManager::GetProcessNumber()", "Tracking0011",
72  FatalException, "Process Manager is not found.");
73  return;
74  }
75 
76 // AtRestDoits
80 #ifdef debug
81  G4cout << "G4SteppingManager::GetProcessNumber: #ofAtRest="
83 #endif
84 
85 // AlongStepDoits
89 #ifdef debug
90  G4cout << "G4SteppingManager::GetProcessNumber:#ofAlongStp="
92 #endif
93 
94 // PostStepDoits
98 #ifdef debug
99  G4cout << "G4SteppingManager::GetProcessNumber: #ofPostStep="
101 #endif
102 
106  {
107  G4cerr << "ERROR - G4SteppingManager::GetProcessNumber()" << G4endl
108  << " SizeOfSelectedDoItVector= " << SizeOfSelectedDoItVector
109  << " ; is smaller then one of MAXofAtRestLoops= "
110  << MAXofAtRestLoops << G4endl
111  << " or MAXofAlongStepLoops= " << MAXofAlongStepLoops
112  << " or MAXofPostStepLoops= " << MAXofPostStepLoops << G4endl;
113  G4Exception("G4SteppingManager::GetProcessNumber()",
114  "Tracking0012", FatalException,
115  "The array size is smaller than the actual No of processes.");
116  }
117 }
118 
119 
120 // ************************************************************************
121 //
122 // Private Member Functions
123 //
124 // ************************************************************************
125 
126 
130 {
131 
132 // ReSet the counter etc.
133  PhysicalStep = DBL_MAX; // Initialize by a huge number
134  physIntLength = DBL_MAX; // Initialize by a huge number
135 #ifdef G4VERBOSE
136  // !!!!! Verbose
138 #endif
139 
140 // Obtain the user defined maximum allowed Step in the volume
141 // 1997.12.13 adds argument for GetMaxAllowedStep by K.Kurashige
142 // 2004.01.20 This block will be removed by Geant4 7.0
143 // G4UserLimits* ul= fCurrentVolume->GetLogicalVolume()->GetUserLimits();
144 // if (ul) {
145 // physIntLength = ul->GetMaxAllowedStep(*fTrack);
146 //#ifdef G4VERBOSE
147 // // !!!!! Verbose
148 // if(verboseLevel>0) fVerbose->DPSLUserLimit();
149 //#endif
150 // }
151 //
152 // if(physIntLength < PhysicalStep ){
153 // PhysicalStep = physIntLength;
154 // fStepStatus = fUserDefinedLimit;
155 // fStep->GetPostStepPoint()
156 // ->SetProcessDefinedStep(0);
157 // // Take note that the process pointer is 'NULL' if the Step
158 // // is defined by the user defined limit.
159 // }
160 // 2004.01.20 This block will be removed by Geant4 7.0
161 
162 // GPIL for PostStep
164 
165  for(size_t np=0; np < MAXofPostStepLoops; np++){
166  fCurrentProcess = (*fPostStepGetPhysIntVector)(np);
167  if (fCurrentProcess== 0) {
168  (*fSelectedPostStepDoItVector)[np] = InActivated;
169  continue;
170  } // NULL means the process is inactivated by a user on fly.
171 
173  PostStepGPIL( *fTrack,
175  &fCondition );
176 #ifdef G4VERBOSE
177  // !!!!! Verbose
179 #endif
180 
181  switch (fCondition) {
182  case ExclusivelyForced:
183  (*fSelectedPostStepDoItVector)[np] = ExclusivelyForced;
187  break;
188  case Conditionally:
189  // (*fSelectedPostStepDoItVector)[np] = Conditionally;
190  G4Exception("G4SteppingManager::DefinePhysicalStepLength()", "Tracking1001", FatalException, "This feature no more supported");
191 
192  break;
193  case Forced:
194  (*fSelectedPostStepDoItVector)[np] = Forced;
195  break;
196  case StronglyForced:
197  (*fSelectedPostStepDoItVector)[np] = StronglyForced;
198  break;
199  default:
200  (*fSelectedPostStepDoItVector)[np] = InActivated;
201  break;
202  }
203 
204 
205 
207  for(size_t nrest=np+1; nrest < MAXofPostStepLoops; nrest++){
208  (*fSelectedPostStepDoItVector)[nrest] = InActivated;
209  }
210  return; // Take note the 'return' at here !!!
211  }
212  else{
219  }
220  }
221 
222 
223  }
224 
225  if (fPostStepDoItProcTriggered<MAXofPostStepLoops) {
227  InActivated) {
228  (*fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] =
229  NotForced;
230  }
231  }
232 
233 // GPIL for AlongStep
235  G4double safetyProposedToAndByProcess = proposedSafety;
236 
237  for(size_t kp=0; kp < MAXofAlongStepLoops; kp++){
238  fCurrentProcess = (*fAlongStepGetPhysIntVector)[kp];
239  if (fCurrentProcess== 0) continue;
240  // NULL means the process is inactivated by a user on fly.
241 
243  AlongStepGPIL( *fTrack, fPreviousStepSize,
244  PhysicalStep,
245  safetyProposedToAndByProcess,
246  &fGPILSelection );
247 #ifdef G4VERBOSE
248  // !!!!! Verbose
250 #endif
253 
254  // Check if the process wants to be the GPIL winner. For example,
255  // multi-scattering proposes Step limit, but won't be the winner.
260  }
261 
262  // Transportation is assumed to be the last process in the vector
263  if(kp == MAXofAlongStepLoops-1)
265  }
266 
267  // Make sure to check the safety, even if Step is not limited
268  // by this process. J. Apostolakis, June 20, 1998
269  //
270  if (safetyProposedToAndByProcess < proposedSafety)
271  // proposedSafety keeps the smallest value:
272  proposedSafety = safetyProposedToAndByProcess;
273  else
274  // safetyProposedToAndByProcess always proposes a valid safety:
275  safetyProposedToAndByProcess = proposedSafety;
276 
277  }
278 } // void G4SteppingManager::DefinePhysicalStepLength() //
279 
280 
284 {
285 // Select the rest process which has the shortest time before
286 // it is invoked. In rest processes, GPIL()
287 // returns the time before a process occurs.
288  G4double lifeTime, shortestLifeTime;
289 
291  shortestLifeTime = DBL_MAX;
292 
293  unsigned int NofInactiveProc=0;
294  for( size_t ri=0 ; ri < MAXofAtRestLoops ; ri++ ){
295  fCurrentProcess = (*fAtRestGetPhysIntVector)[ri];
296  if (fCurrentProcess== 0) {
297  (*fSelectedAtRestDoItVector)[ri] = InActivated;
298  NofInactiveProc++;
299  continue;
300  } // NULL means the process is inactivated by a user on fly.
301 
302  lifeTime =
304 
305 
306 
308  (*fSelectedAtRestDoItVector)[ri] = Forced;
309  }
310  else{
311  (*fSelectedAtRestDoItVector)[ri] = InActivated;
312  if(lifeTime < shortestLifeTime ){
313  shortestLifeTime = lifeTime;
315  }
316  }
317  }
318 
319  (*fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;
320 
321 // at least one process is necessary to destroy the particle
322 // exit with warning
323  if(NofInactiveProc==MAXofAtRestLoops){
324  G4Exception("G4SteppingManager::InvokeAtRestDoItProcs()", "Tracking0013",
325  JustWarning, "No AtRestDoIt process is active!" );
326  }
327 
328  fStep->SetStepLength( 0. ); //the particle has stopped
329  fTrack->SetStepLength( 0. );
330 
331 // invoke selected process
332  for(size_t np=0; np < MAXofAtRestLoops; np++){
333  //
334  // Note: DoItVector has inverse order against GetPhysIntVector
335  // and SelectedAtRestDoItVector.
336  //
337  if( (*fSelectedAtRestDoItVector)[MAXofAtRestLoops-np-1] != InActivated){
338 
339  fCurrentProcess = (*fAtRestDoItVector)[np];
342 
343  // Set the current process as a process which defined this Step length
346 
347  // Update Step
349 
350  // Now Store the secondaries from ParticleChange to SecondaryList
351  G4Track* tempSecondaryTrack;
352  G4int num2ndaries;
353 
354  num2ndaries = fParticleChange->GetNumberOfSecondaries();
355 
356  for(G4int DSecLoop=0 ; DSecLoop< num2ndaries; DSecLoop++){
357  tempSecondaryTrack = fParticleChange->GetSecondary(DSecLoop);
358 
359  if(tempSecondaryTrack->GetDefinition()->GetApplyCutsFlag())
360  { ApplyProductionCut(tempSecondaryTrack); }
361 
362  // Set parentID
363  tempSecondaryTrack->SetParentID( fTrack->GetTrackID() );
364 
365  // Set the process pointer which created this track
366  tempSecondaryTrack->SetCreatorProcess( fCurrentProcess );
367 
368  // If this 2ndry particle has 'zero' kinetic energy, make sure
369  // it invokes a rest process at the beginning of the tracking
370  if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN){
371  G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()->GetProcessManager();
372  if(!pm)
373  {
375  ED << "A track without proper process manager is pushed into the track stack.\n"
376  << " Particle name : " << tempSecondaryTrack->GetDefinition()->GetParticleName() << " -- ";
377  if(tempSecondaryTrack->GetParentID()<0)
378  { ED << "created by a primary particle generator."; }
379  else
380  {
381  const G4VProcess* vp = tempSecondaryTrack->GetCreatorProcess();
382  if(vp)
383  { ED << "created by " << vp->GetProcessName() << "."; }
384  else
385  { ED << "creaded by unknown process."; }
386  }
387  G4Exception("G4SteppingManager::InvokeAtRestDoItProcs()","Tracking10051",
388  FatalException,ED);
389  }
390  if (pm->GetAtRestProcessVector()->entries()>0){
391  tempSecondaryTrack->SetTrackStatus( fStopButAlive );
392  fSecondary->push_back( tempSecondaryTrack );
394  } else {
395  delete tempSecondaryTrack;
396  }
397  } else {
398  fSecondary->push_back( tempSecondaryTrack );
400  }
401  } //end of loop on secondary
402 
403 
404  // clear ParticleChange
406 
407  } //if(fSelectedAtRestDoItVector[np] != InActivated){
408  } //for(size_t np=0; np < MAXofAtRestLoops; np++){
409  fStep->UpdateTrack();
410 
412 }
413 
414 
418 {
419 
420 // If the current Step is defined by a 'ExclusivelyForced'
421 // PostStepDoIt, then don't invoke any AlongStepDoIt
423  return; // Take note 'return' is here !!!
424  }
425 
426 // Invoke the all active continuous processes
427  for( size_t ci=0 ; ci<MAXofAlongStepLoops ; ci++ ){
428  fCurrentProcess = (*fAlongStepDoItVector)[ci];
429  if (fCurrentProcess== 0) continue;
430  // NULL means the process is inactivated by a user on fly.
431 
434 
435  // Update the PostStepPoint of Step according to ParticleChange
437 #ifdef G4VERBOSE
438  // !!!!! Verbose
440 #endif
441 
442  // Now Store the secondaries from ParticleChange to SecondaryList
443  G4Track* tempSecondaryTrack;
444  G4int num2ndaries;
445 
446  num2ndaries = fParticleChange->GetNumberOfSecondaries();
447 
448  for(G4int DSecLoop=0 ; DSecLoop< num2ndaries; DSecLoop++){
449  tempSecondaryTrack = fParticleChange->GetSecondary(DSecLoop);
450 
451  if(tempSecondaryTrack->GetDefinition()->GetApplyCutsFlag())
452  { ApplyProductionCut(tempSecondaryTrack); }
453 
454  // Set parentID
455  tempSecondaryTrack->SetParentID( fTrack->GetTrackID() );
456 
457  // Set the process pointer which created this track
458  tempSecondaryTrack->SetCreatorProcess( fCurrentProcess );
459 
460  // If this 2ndry particle has 'zero' kinetic energy, make sure
461  // it invokes a rest process at the beginning of the tracking
462  if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN){
463  G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()->GetProcessManager();
464  if(!pm)
465  {
467  ED << "A track without proper process manager is pushed into the track stack.\n"
468  << " Particle name : " << tempSecondaryTrack->GetDefinition()->GetParticleName() << " -- ";
469  if(tempSecondaryTrack->GetParentID()<0)
470  { ED << "created by a primary particle generator."; }
471  else
472  {
473  const G4VProcess* vp = tempSecondaryTrack->GetCreatorProcess();
474  if(vp)
475  { ED << "created by " << vp->GetProcessName() << "."; }
476  else
477  { ED << "creaded by unknown process."; }
478  }
479  G4Exception("G4SteppingManager::InvokeAlongStepDoItProcs()","Tracking10051",
480  FatalException,ED);
481  }
482  if (pm->GetAtRestProcessVector()->entries()>0){
483  tempSecondaryTrack->SetTrackStatus( fStopButAlive );
484  fSecondary->push_back( tempSecondaryTrack );
486  } else {
487  delete tempSecondaryTrack;
488  }
489  } else {
490  fSecondary->push_back( tempSecondaryTrack );
492  }
493  } //end of loop on secondary
494 
495  // Set the track status according to what the process defined
496  // if kinetic energy >0, otherwise set fStopButAlive
498 
499  // clear ParticleChange
501  }
502 
503  fStep->UpdateTrack();
504  G4TrackStatus fNewStatus = fTrack->GetTrackStatus();
505 
506  if ( fNewStatus == fAlive && fTrack->GetKineticEnergy() <= DBL_MIN ) {
507  if(MAXofAtRestLoops>0) fNewStatus = fStopButAlive;
508  else fNewStatus = fStopAndKill;
509  fTrack->SetTrackStatus( fNewStatus );
510  }
511 
512 }
513 
517 {
518 
519 // Invoke the specified discrete processes
520  for(size_t np=0; np < MAXofPostStepLoops; np++){
521  //
522  // Note: DoItVector has inverse order against GetPhysIntVector
523  // and SelectedPostStepDoItVector.
524  //
525  G4int Cond = (*fSelectedPostStepDoItVector)[MAXofPostStepLoops-np-1];
526  if(Cond != InActivated){
527  if( ((Cond == NotForced) && (fStepStatus == fPostStepDoItProc)) ||
528  ((Cond == Forced) && (fStepStatus != fExclusivelyForcedProc)) ||
529  // ((Cond == Conditionally) && (fStepStatus == fAlongStepDoItProc)) ||
531  ((Cond == StronglyForced) )
532  ) {
533 
534  InvokePSDIP(np);
535  if ((np==0) && (fTrack->GetNextVolume() == 0)){
538  }
539  }
540  } //if(*fSelectedPostStepDoItVector(np)........
541 
542  // Exit from PostStepLoop if the track has been killed,
543  // but extra treatment for processes with Strongly Forced flag
545  for(size_t np1=np+1; np1 < MAXofPostStepLoops; np1++){
546  G4int Cond2 = (*fSelectedPostStepDoItVector)[MAXofPostStepLoops-np1-1];
547  if (Cond2 == StronglyForced) {
548  InvokePSDIP(np1);
549  }
550  }
551  break;
552  }
553  } //for(size_t np=0; np < MAXofPostStepLoops; np++){
554 }
555 
556 
557 
559 {
560  fCurrentProcess = (*fPostStepDoItVector)[np];
563 
564  // Update PostStepPoint of Step according to ParticleChange
566 #ifdef G4VERBOSE
567  // !!!!! Verbose
569 #endif
570  // Update G4Track according to ParticleChange after each PostStepDoIt
571  fStep->UpdateTrack();
572 
573  // Update safety after each invocation of PostStepDoIts
575 
576  // Now Store the secondaries from ParticleChange to SecondaryList
577  G4Track* tempSecondaryTrack;
578  G4int num2ndaries;
579 
580  num2ndaries = fParticleChange->GetNumberOfSecondaries();
581 
582  for(G4int DSecLoop=0 ; DSecLoop< num2ndaries; DSecLoop++){
583  tempSecondaryTrack = fParticleChange->GetSecondary(DSecLoop);
584 
585  if(tempSecondaryTrack->GetDefinition()->GetApplyCutsFlag())
586  { ApplyProductionCut(tempSecondaryTrack); }
587 
588  // Set parentID
589  tempSecondaryTrack->SetParentID( fTrack->GetTrackID() );
590 
591  // Set the process pointer which created this track
592  tempSecondaryTrack->SetCreatorProcess( fCurrentProcess );
593 
594  // If this 2ndry particle has 'zero' kinetic energy, make sure
595  // it invokes a rest process at the beginning of the tracking
596  if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN){
597  G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()->GetProcessManager();
598  if(!pm)
599  {
601  ED << "A track without proper process manager is pushed into the track stack.\n"
602  << " Particle name : " << tempSecondaryTrack->GetDefinition()->GetParticleName() << " -- ";
603  if(tempSecondaryTrack->GetParentID()<0)
604  { ED << "created by a primary particle generator."; }
605  else
606  {
607  const G4VProcess* vp = tempSecondaryTrack->GetCreatorProcess();
608  if(vp)
609  { ED << "created by " << vp->GetProcessName() << "."; }
610  else
611  { ED << "creaded by unknown process."; }
612  }
613  G4Exception("G4SteppingManager::InvokePSDIP()","Tracking10053",
614  FatalException,ED);
615  }
616  if (pm->GetAtRestProcessVector()->entries()>0){
617  tempSecondaryTrack->SetTrackStatus( fStopButAlive );
618  fSecondary->push_back( tempSecondaryTrack );
620  } else {
621  delete tempSecondaryTrack;
622  }
623  } else {
624  fSecondary->push_back( tempSecondaryTrack );
626  }
627  } //end of loop on secondary
628 
629  // Set the track status according to what the process defined
631 
632  // clear ParticleChange
634 }
635 
636 #include "G4EnergyLossTables.hh"
637 #include "G4ProductionCuts.hh"
638 #include "G4ProductionCutsTable.hh"
639 
641 {
642  G4bool tBelowCutEnergyAndSafety = false;
643  G4int tPtclIdx
644  = G4ProductionCuts::GetIndex(aSecondary->GetDefinition());
645  if (tPtclIdx<0) { return; }
646  G4ProductionCutsTable* tCutsTbl
648  G4int tCoupleIdx
650  G4double tProdThreshold
651  = (*(tCutsTbl->GetEnergyCutsVector(tPtclIdx)))[tCoupleIdx];
652  if( aSecondary->GetKineticEnergy()<tProdThreshold )
653  {
654  tBelowCutEnergyAndSafety = true;
655  if(std::abs(aSecondary->GetDynamicParticle()->GetCharge()) > DBL_MIN)
656  {
657  G4double currentRange
659  aSecondary->GetKineticEnergy(),
661  tBelowCutEnergyAndSafety = (currentRange < CalculateSafety() );
662  }
663  }
664 
665  if( tBelowCutEnergyAndSafety )
666  {
667  if( !(aSecondary->IsGoodForTracking()) )
668  {
669 //G4cout << "!! Warning - G4SteppingManager:" << G4endl
670 //<< " This physics process generated a secondary"
671 //<< " of which energy is below cut but"
672 //<< " GoodForTracking is off !!!!!" << G4endl;
673  // Add kinetic energy to the total energy deposit
675  aSecondary->GetKineticEnergy() );
676  aSecondary->SetKineticEnergy(0.0);
677  }
678  }
679 }
680 
G4double GetKineticEnergy() const
G4ProcessVector * fAtRestGetPhysIntVector
G4int entries() const
G4int GetCoupleIndex(const G4MaterialCutsCouple *aCouple) const
G4int GetNumberOfSecondaries() const
virtual void DPSLStarted()=0
void SetStepLength(G4double value)
std::ostringstream G4ExceptionDescription
Definition: G4Exception.hh:45
G4SelectedPostStepDoItVector * fSelectedPostStepDoItVector
virtual void DPSLPostStep()=0
G4ProcessVector * fPostStepDoItVector
G4double AtRestGPIL(const G4Track &track, G4ForceCondition *condition)
Definition: G4VProcess.hh:493
static const size_t SizeOfSelectedDoItVector
G4TrackVector * fSecondary
#define G4endl
Definition: G4ios.hh:61
const G4String & GetParticleName() const
G4int GetTrackID() const
static G4int GetIndex(const G4String &name)
virtual void AlongStepDoItOneByOne()=0
void SetCreatorProcess(const G4VProcess *aValue)
G4VPhysicalVolume * GetNextVolume() const
G4VParticleChange * fParticleChange
G4ParticleDefinition * GetDefinition() const
G4ProcessVector * GetAlongStepProcessVector(G4ProcessVectorTypeIndex typ=typeGPIL) const
virtual G4Step * UpdateStepForAtRest(G4Step *Step)
const std::vector< G4double > * GetEnergyCutsVector(size_t pcIdx) const
G4GPILSelection fGPILSelection
void SetProcessDefinedStep(const G4VProcess *aValue)
double G4double
Definition: G4Types.hh:76
bool G4bool
Definition: G4Types.hh:79
G4bool IsGoodForTracking() const
void UpdateTrack()
void SetStepLength(G4double value)
G4ProcessVector * fAtRestDoItVector
G4double GetCharge() const
G4StepPoint * fPreStepPoint
virtual void PostStepDoItOneByOne()=0
G4ProcessVector * fPostStepGetPhysIntVector
const G4String & GetProcessName() const
Definition: G4VProcess.hh:411
G4VSteppingVerbose * fVerbose
void SetKineticEnergy(const G4double aValue)
virtual G4VParticleChange * AtRestDoIt(const G4Track &track, const G4Step &stepData)=0
G4StepPoint * GetPostStepPoint() const
G4double GetRange(const G4ParticleDefinition *aParticle, G4double kineticEnergy, const G4MaterialCutsCouple *couple)
const G4MaterialCutsCouple * GetMaterialCutsCouple() const
G4GLOB_DLL std::ostream G4cerr
void AddTotalEnergyDeposit(G4double value)
G4ProcessVector * GetPostStepProcessVector(G4ProcessVectorTypeIndex typ=typeGPIL) const
G4ProcessVector * fAlongStepDoItVector
virtual G4VParticleChange * AlongStepDoIt(const G4Track &track, const G4Step &stepData)=0
static G4ProductionCutsTable * GetProductionCutsTable()
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.hh:65
G4ProcessVector * fAlongStepGetPhysIntVector
int G4int
Definition: G4Types.hh:78
G4ProcessVector * GetAtRestProcessVector(G4ProcessVectorTypeIndex typ=typeGPIL) const
G4ProcessManager * GetProcessManager() const
void SetParentID(const G4int aValue)
const G4VProcess * GetCreatorProcess() const
G4ForceCondition fCondition
void ApplyProductionCut(G4Track *)
G4TrackStatus GetTrackStatus() const
#define DBL_MIN
Definition: templates.hh:75
void SetSafety(const G4double aValue)
G4GLOB_DLL std::ostream G4cout
G4Track * GetSecondary(G4int anIndex) const
virtual void DPSLAlongStep()=0
static G4LossTableManager * Instance()
virtual G4Step * UpdateStepForAlongStep(G4Step *Step)
G4bool GetApplyCutsFlag() const
G4VProcess * fCurrentProcess
void SetTrackStatus(const G4TrackStatus aTrackStatus)
virtual G4Step * UpdateStepForPostStep(G4Step *Step)
G4TrackStatus GetTrackStatus() const
G4SelectedAtRestDoItVector * fSelectedAtRestDoItVector
#define DBL_MAX
Definition: templates.hh:83
virtual G4VParticleChange * PostStepDoIt(const G4Track &track, const G4Step &stepData)=0
const G4DynamicParticle * GetDynamicParticle() const
void SetStepStatus(const G4StepStatus aValue)
G4TrackStatus
G4int GetParentID() const
G4StepStatus fStepStatus