#include <G4CoupledTransportation.hh>

Inheritance diagram for G4CoupledTransportation:

Public Member Functions
	G4CoupledTransportation (G4int verbosityLevel=0)

	~G4CoupledTransportation ()

G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)

G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)

G4bool	IsFirstStepInAnyVolume () const

G4bool	IsLastStepInAnyVolume () const

G4bool	IsFirstStepInMassVolume () const

G4bool	IsLastStepInMassVolume () const

void	StartTracking (G4Track *aTrack)

void	EndTracking ()

Public Member Functions inherited from G4Transportation
	G4Transportation (G4int verbosityLevel=1, const G4String &aName="Transportation")

	~G4Transportation ()

G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)

G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)

G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)

G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4ForceCondition *pForceCond)

G4bool	FieldExertedForce ()

G4PropagatorInField *	GetPropagatorInField ()

void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)

G4double	GetThresholdWarningEnergy () const

G4double	GetThresholdImportantEnergy () const

G4int	GetThresholdTrials () const

void	SetThresholdWarningEnergy (G4double newEnWarn)

void	SetThresholdImportantEnergy (G4double newEnImp)

void	SetThresholdTrials (G4int newMaxTrials)

void	SetHighLooperThresholds ()

void	SetLowLooperThresholds ()

void	PushThresholdsToLogger ()

void	ReportLooperThresholds ()

G4double	GetMaxEnergyKilled () const

G4double	GetSumEnergyKilled () const

void	ResetKilledStatistics (G4int report=1)

void	EnableShortStepOptimisation (G4bool optimise=true)

G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)

void	StartTracking (G4Track *aTrack)

virtual void	ProcessDescription (std::ostream &outFile) const

void	PrintStatistics (std::ostream &outStr) const

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4VProcess &	operator= (const G4VProcess &)=delete

G4bool	operator== (const G4VProcess &right) const

G4bool	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual G4bool	IsApplicable (const G4ParticleDefinition &)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual const G4VProcess *	GetCreatorProcess () const

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Static Public Member Functions
static void	SetSignifyStepsInAnyVolume (G4bool anyVol)

static G4bool	GetSignifyStepsInAnyVolume ()

static G4bool	EnableUseMagneticMoment (G4bool useMoment=true)

Static Public Member Functions inherited from G4Transportation
static G4bool	EnableMagneticMoment (G4bool useMoment=true)

static G4bool	EnableGravity (G4bool useGravity=true)

static void	SetSilenceLooperWarnings (G4bool val)

static G4bool	GetSilenceLooperWarnings ()

static G4bool	EnableUseMagneticMoment (G4bool useMoment=true)

Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions
void	ReportInexactEnergy (G4double startEnergy, G4double endEnergy)

void	ReportMove (G4ThreeVector OldVector, G4ThreeVector NewVector, const G4String &Quantity)

Protected Member Functions inherited from G4Transportation
void	SetTouchableInformation (const G4TouchableHandle &touchable)

void	ReportMissingLogger (const char *methodName)

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Additional Inherited Members
Protected Attributes inherited from G4Transportation
G4Navigator *	fLinearNavigator

G4PropagatorInField *	fFieldPropagator

G4ThreeVector	fTransportEndPosition = G4ThreeVector( 0.0, 0.0, 0.0 )

G4ThreeVector	fTransportEndMomentumDir = G4ThreeVector( 0.0, 0.0, 0.0 )

G4double	fTransportEndKineticEnergy = 0.0

G4ThreeVector	fTransportEndSpin = G4ThreeVector( 0.0, 0.0, 0.0 )

G4bool	fMomentumChanged = true

G4bool	fEndGlobalTimeComputed = false

G4double	fCandidateEndGlobalTime = 0.0

G4bool	fAnyFieldExists = false

G4bool	fParticleIsLooping = false

G4bool	fNewTrack = true

G4bool	fFirstStepInVolume = true

G4bool	fLastStepInVolume = false

G4bool	fGeometryLimitedStep = true

G4bool	fFieldExertedForce = false

G4TouchableHandle	fCurrentTouchableHandle

G4ThreeVector	fPreviousSftOrigin

G4double	fPreviousSafety

G4ParticleChangeForTransport	fParticleChange

G4double	fEndPointDistance

G4double	fThreshold_Warning_Energy = 1.0 * CLHEP::keV

G4double	fThreshold_Important_Energy = 1.0 * CLHEP::MeV

G4int	fThresholdTrials = 10

G4int	fAbandonUnstableTrials = 0

G4int	fNoLooperTrials = 0

G4double	fSumEnergyKilled = 0.0

G4double	fSumEnerSqKilled = 0.0

G4double	fMaxEnergyKilled = -1.0

G4int	fMaxEnergyKilledPDG = 0

unsigned long	fNumLoopersKilled = 0

G4double	fSumEnergyKilled_NonElectron = 0.0

G4double	fSumEnerSqKilled_NonElectron = 0.0

G4double	fMaxEnergyKilled_NonElectron = -1.0

G4int	fMaxEnergyKilled_NonElecPDG = 0

unsigned long	fNumLoopersKilled_NonElectron = 0

G4double	fSumEnergySaved = 0.0

G4double	fMaxEnergySaved = -1.0

G4double	fSumEnergyUnstableSaved = 0.0

G4bool	fShortStepOptimisation

G4SafetyHelper *	fpSafetyHelper

G4TransportationLogger *	fpLogger

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr

G4VParticleChange *	pParticleChange = nullptr

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft = -1.0

G4double	currentInteractionLength = -1.0

G4double	theInitialNumberOfInteractionLength = -1.0

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType = fNotDefined

G4int	theProcessSubType = -1

G4double	thePILfactor = 1.0

G4int	verboseLevel = 0

G4bool	enableAtRestDoIt = true

G4bool	enableAlongStepDoIt = true

G4bool	enablePostStepDoIt = true

Static Protected Attributes inherited from G4Transportation
static G4bool	fUseMagneticMoment =false

static G4bool	fUseGravity = false

static G4bool	fSilenceLooperWarnings = false

Detailed Description

Definition at line 56 of file G4CoupledTransportation.hh.

Constructor & Destructor Documentation

◆ G4CoupledTransportation()

G4CoupledTransportation::G4CoupledTransportation ( G4int verbosityLevel = 0 )

Definition at line 61 of file G4CoupledTransportation.cc.

  : G4Transportation( verbosity, "CoupledTransportation" ),
    fPreviousMassSafety( 0.0 ),
    fPreviousFullSafety( 0.0 ),
    fMassGeometryLimitedStep( false ), 
    fFirstStepInMassVolume( true )
{
  SetProcessSubType(static_cast<G4int>(COUPLED_TRANSPORTATION));
  // SetVerboseLevel is called in the constructor of G4Transportation
 
  if( verboseLevel > 0 )
  {
    G4cout << " G4CoupledTransportation constructor: ----- " << G4endl;
    G4cout << " Verbose level is " << verboseLevel << G4endl;
    G4cout << " Reports First/Last in " 
           << (fSignifyStepInAnyVolume ? " any " : " mass " )
           << " geometry " << G4endl;
  }
  fPathFinder=  G4PathFinder::GetInstance(); 
}

◆ ~G4CoupledTransportation()

G4CoupledTransportation::~G4CoupledTransportation ( )

Definition at line 84 of file G4CoupledTransportation.cc.

85{

86}

Member Function Documentation

◆ AlongStepGetPhysicalInteractionLength()

G4double G4CoupledTransportation::AlongStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	currentSafety,
		G4GPILSelection *	selection )

virtual

Implements G4VProcess.

Definition at line 95 of file G4CoupledTransportation.cc.

{
  G4double geometryStepLength; 
  G4double startFullSafety= 0.0; // estimated safety for start point (all geometries)
  G4double safetyProposal= -1.0; // local copy of proposal 
 
  G4ThreeVector  EndUnitMomentum ;
  G4double       lengthAlongCurve = 0.0 ;
 
  fParticleIsLooping = false ;
 
  // Initial actions moved to  StartTrack()   
  // --------------------------------------
  // Note: in case another process changes touchable handle
  //    it will be necessary to add here (for all steps)   
  // fCurrentTouchableHandle = aTrack->GetTouchableHandle();
 
  // GPILSelection is set to defaule value of CandidateForSelection
  // It is a return value
  //
  *selection = CandidateForSelection ;
 
  fFirstStepInMassVolume = fNewTrack || fMassGeometryLimitedStep ; 
  fFirstStepInVolume     = fNewTrack || fGeometryLimitedStep ;
 
#ifdef G4DEBUG_TRANSPORT
  G4cout << "  CoupledTransport::AlongStep GPIL:  "
         << "  1st-step:  any= "  <<fFirstStepInVolume  << " ( geom= "
         << fGeometryLimitedStep << " ) "
         <<           " mass= " << fFirstStepInMassVolume << " ( geom= "
         << fMassGeometryLimitedStep << " ) " 
         << "  newTrack= " << fNewTrack << G4endl;
#endif
  
  // fLastStepInVolume= false;
  fNewTrack = false;
 
  // Get initial Energy/Momentum of the track
  //
  const G4DynamicParticle*    pParticle  = track.GetDynamicParticle() ;
  const G4ParticleDefinition* pParticleDef   = pParticle->GetDefinition() ;
  G4ThreeVector startMomentumDir       = pParticle->GetMomentumDirection() ;
  G4ThreeVector startPosition          = track.GetPosition() ;
  G4VPhysicalVolume* currentVolume= track.GetVolume(); 
 
#ifdef G4DEBUG_TRANSPORT
  if( verboseLevel > 1 )
  {
    G4cout << "G4CoupledTransportation::AlongStepGPIL> called in volume " 
           << currentVolume->GetName() << G4endl; 
  }
#endif
  // G4double   theTime        = track.GetGlobalTime() ;
 
  // The Step Point safety can be limited by other geometries and/or the 
  // assumptions of any process - it's not always the geometrical safety.
  // We calculate the starting point's isotropic safety here.
  //
  G4ThreeVector OriginShift = startPosition - fPreviousSftOrigin ;
  G4double      MagSqShift  = OriginShift.mag2() ;
  startFullSafety= 0.0; 
 
  // Recall that FullSafety <= MassSafety 
  // Original: if( MagSqShift < sqr(fPreviousMassSafety) ) {
  if( MagSqShift < sqr(fPreviousFullSafety) )
  {
     G4double mag_shift= std::sqrt(MagSqShift); 
     startFullSafety = std::max( (fPreviousFullSafety - mag_shift), 0.0);
       // Need to be consistent between full safety with Mass safety
       // in order reproduce results in simple case
       // --> use same calculation method
 
     // Only compute full safety if massSafety > 0.  Else it remains 0
     // startFullSafety = fPathFinder->ComputeSafety( startPosition ); 
  }
 
  // Is the particle charged or has it a magnetic moment?
  //
  G4double particleCharge = pParticle->GetCharge() ;
  G4double magneticMoment = pParticle->GetMagneticMoment() ;
  G4double       restMass = pParticle->GetMass() ; 
 
  fMassGeometryLimitedStep = false ; //  Set default - alex
  fGeometryLimitedStep     = false;
 
  // There is no need to locate the current volume. It is Done elsewhere:
  //   On track construction 
  //   By the tracking, after all AlongStepDoIts, in "Relocation"
 
  // Check if the particle has a force, EM or gravitational, exerted on it
  //
  G4FieldManager* fieldMgr= nullptr;
  G4bool          fieldExertsForce = false ;
 
  const G4Field* ptrField= nullptr;
 
  fieldMgr = fFieldPropagator->FindAndSetFieldManager( track.GetVolume() );
  G4bool eligibleEM = (particleCharge != 0.0)
                   || ( fUseMagneticMoment && (magneticMoment != 0.0) );
  G4bool eligibleGrav =  fUseGravity && (restMass != 0.0) ;
 
  if( (fieldMgr!=nullptr) && (eligibleEM||eligibleGrav) )
  {
     // Message the field Manager, to configure it for this track
     //
     fieldMgr->ConfigureForTrack( &track );
 
     // The above call can transition from a null field-ptr oto a finite field.
     // If the field manager has no field ptr, the field is zero 
     // by definition ( = there is no field ! )
     //
     ptrField= fieldMgr->GetDetectorField();
 
     if( ptrField != nullptr)
     { 
        fieldExertsForce = eligibleEM
              || ( eligibleGrav && ptrField->IsGravityActive() );
     }
  }
  G4double momentumMagnitude = pParticle->GetTotalMomentum() ;
 
  if( fieldExertsForce )
  {
     auto equationOfMotion= fFieldPropagator->GetCurrentEquationOfMotion();
 
     G4ChargeState chargeState(particleCharge, // Charge can change (dynamic)
                               magneticMoment,
                               pParticleDef->GetPDGSpin() );
     if( equationOfMotion )
     {
        equationOfMotion->SetChargeMomentumMass( chargeState,
                                                 momentumMagnitude,
                                                 restMass );
     }
#ifdef G4DEBUG_TRANSPORT
     else
     {
        G4cerr << " ERROR in G4CoupledTransportation> "
               << "Cannot find valid Equation of motion: "      << G4endl;
               << " Unable to pass Charge, Momentum and Mass "  << G4endl;
     }
#endif     
  }
 
  G4ThreeVector polarizationVec  = track.GetPolarization() ;
  G4FieldTrack  aFieldTrack = G4FieldTrack(startPosition, 
                                           track.GetGlobalTime(), // Lab.
                                           track.GetMomentumDirection(),
                                           track.GetKineticEnergy(),
                                           restMass,
                                           particleCharge, 
                                           polarizationVec, 
                                           pParticleDef->GetPDGMagneticMoment(),
                                           0.0,  // Length along track
                                           pParticleDef->GetPDGSpin() ) ;
  G4int stepNo= track.GetCurrentStepNumber(); 
 
  ELimited limitedStep; 
  G4FieldTrack endTrackState('a');  //  Default values
 
  fMassGeometryLimitedStep = false ;    //  default
  fGeometryLimitedStep     = false;
  if( currentMinimumStep > 0 )
  {
      G4double newMassSafety= 0.0;     //  temp. for recalculation
 
      // Do the Transport in the field (non recti-linear)
      //
      lengthAlongCurve = fPathFinder->ComputeStep( aFieldTrack,
                                                   currentMinimumStep, 
                                                   G4TransportationManager::kMassNavigatorId,
                                                   stepNo,
                                                   newMassSafety,
                                                   limitedStep,
                                                   endTrackState,
                                                   currentVolume ) ;
 
      G4double newFullSafety= fPathFinder->GetCurrentSafety();  
        // this was estimated already in step above
 
      if( limitedStep == kUnique || limitedStep == kSharedTransport )
      {
        fMassGeometryLimitedStep = true ;
      }
      
      fGeometryLimitedStep = (fPathFinder->GetNumberGeometriesLimitingStep() != 0);
 
#ifdef G4DEBUG_TRANSPORT
      if( fMassGeometryLimitedStep && !fGeometryLimitedStep )
      {
        std::ostringstream message;
        message << " ERROR in determining geometries limiting the step" << G4endl;
        message << "  Limiting:  mass=" << fMassGeometryLimitedStep
                << " any= " << fGeometryLimitedStep << G4endl;
        message << "Incompatible conditions - by which geometries was it limited ?";
        G4Exception("G4CoupledTransportation::AlongStepGetPhysicalInteractionLength()", 
                    "PathFinderConfused", FatalException, message); 
      }
#endif
 
      geometryStepLength = std::min( lengthAlongCurve, currentMinimumStep); 
 
      // Momentum:  Magnitude and direction can be changed too now ...
      //
      fMomentumChanged         = true ; 
      fTransportEndMomentumDir = endTrackState.GetMomentumDir() ;
 
      // Remember last safety origin & value.
      fPreviousSftOrigin  = startPosition ;
      fPreviousMassSafety = newMassSafety ;         
      fPreviousFullSafety = newFullSafety ; 
      // fpSafetyHelper->SetCurrentSafety( newFullSafety, startPosition);
 
#ifdef G4DEBUG_TRANSPORT
      if( verboseLevel > 1 )
      {
        G4cout << "G4Transport:CompStep> " 
               << " called the pathfinder for a new step at " << startPosition
               << " and obtained step = " << lengthAlongCurve << G4endl;
        G4cout << "  New safety (preStep) = " << newMassSafety << G4endl;
      }
#endif
 
      // Store as best estimate value
      startFullSafety    = newFullSafety ; 
 
      // Get the End-Position and End-Momentum (Dir-ection)
      fTransportEndPosition = endTrackState.GetPosition() ;
      fTransportEndKineticEnergy  = endTrackState.GetKineticEnergy() ; 
  }
  else
  {
      geometryStepLength   = lengthAlongCurve= 0.0 ;
      fMomentumChanged         = false ; 
      // fMassGeometryLimitedStep = false ;   //  --- ???
      // fGeometryLimitedStep = true;
      fTransportEndMomentumDir = track.GetMomentumDirection();
      fTransportEndKineticEnergy  = track.GetKineticEnergy();
 
      fTransportEndPosition = startPosition;
 
      endTrackState= aFieldTrack;  // Ensures that time is updated
  }
  // G4FieldTrack aTrackState(endTrackState);  
 
  if( !fieldExertsForce ) 
  { 
      fParticleIsLooping         = false ; 
      fMomentumChanged           = false ; 
      fEndGlobalTimeComputed     = false ; 
  } 
  else 
  { 
      fParticleIsLooping = fFieldPropagator->IsParticleLooping() ;
  
#ifdef G4DEBUG_TRANSPORT
      if( verboseLevel > 1 )
      {
        G4cout << " G4CT::CS End Position = "
               << fTransportEndPosition << G4endl; 
        G4cout << " G4CT::CS End Direction = "
               << fTransportEndMomentumDir << G4endl; 
      }
#endif
      if( fFieldPropagator->GetCurrentFieldManager()->DoesFieldChangeEnergy() )
      {
          // If the field can change energy, then the time must be integrated
          //    - so this should have been updated
          //
          fCandidateEndGlobalTime   = endTrackState.GetLabTimeOfFlight();
          fEndGlobalTimeComputed    = true;
  
          // was ( fCandidateEndGlobalTime != track.GetGlobalTime() );
          // a cleaner way is to have FieldTrack knowing whether time
          // is updated
      }
      else
      {
          // The energy should be unchanged by field transport,
          //    - so the time changed will be calculated elsewhere
          //
          fEndGlobalTimeComputed = false;
  
#ifdef G4VERBOSE
          // Check that the integration preserved the energy 
          //     -  and if not correct this!
          G4double  startEnergy= track.GetKineticEnergy();
          G4double  endEnergy= fTransportEndKineticEnergy; 
      
          G4double absEdiff = std::fabs(startEnergy- endEnergy);
          if( (verboseLevel > 1) && ( absEdiff > perThousand * endEnergy) )
          {
            ReportInexactEnergy(startEnergy, endEnergy); 
          }  // end of if (verboseLevel)
#endif
          // Correct the energy for fields that conserve it
          //  This - hides the integration error
          //       - but gives a better physical answer
          fTransportEndKineticEnergy= track.GetKineticEnergy();
      }
  }
 
  fEndPointDistance   = (fTransportEndPosition - startPosition).mag() ;
  fTransportEndSpin = endTrackState.GetSpin();
 
  // Calculate the safety
 
  safetyProposal= startFullSafety;   // used to be startMassSafety
    // Changed to accomodate processes that cannot update the safety
 
  // Update safety for the end-point, if becomes negative at the end-point.
 
  if(   (startFullSafety < fEndPointDistance )
        && ( particleCharge != 0.0 ) )  // Only needed to prepare for MSC
   //   && !fGeometryLimitedStep ) // To-Try: No safety update if at boundary
  {
      G4double endFullSafety =
        fPathFinder->ComputeSafety( fTransportEndPosition); 
        // Expected mission -- only mass geometry's safety
        //   fLinearNavigator->ComputeSafety( fTransportEndPosition) ;
        // Yet discrete processes only have poststep -- and this cannot 
        //   currently revise the safety  
        //   ==> so we use the all-geometry safety as a precaution
 
      fpSafetyHelper->SetCurrentSafety( endFullSafety, fTransportEndPosition);
        // Pushing safety to Helper avoids recalculation at this point
 
      G4ThreeVector centerPt= G4ThreeVector(0.0, 0.0, 0.0);  // Used for return value
      G4double endMassSafety= fPathFinder->ObtainSafety( G4TransportationManager::kMassNavigatorId, centerPt);
        //  Retrieves the mass value from PathFinder (it calculated it)
 
      fPreviousMassSafety = endMassSafety ; 
      fPreviousFullSafety = endFullSafety; 
      fPreviousSftOrigin = fTransportEndPosition ;
 
      // The convention (Stepping Manager's) is safety from the start point
      //
      safetyProposal = endFullSafety + fEndPointDistance;
          //  --> was endMassSafety
      // Changed to accomodate processes that cannot update the safety
 
#ifdef G4DEBUG_TRANSPORT 
      G4int prec= G4cout.precision(12) ;
      G4cout << "***CoupledTransportation::AlongStepGPIL ** " << G4endl  ;
      G4cout << "  Revised Safety at endpoint "  << fTransportEndPosition
             << "   give safety values: Mass= " << endMassSafety 
             << "  All= " << endFullSafety << G4endl ; 
      G4cout << "  Adding endpoint distance " << fEndPointDistance
             << "   to obtain pseudo-safety= " << safetyProposal << G4endl ; 
      G4cout.precision(prec); 
  }  
  else
  {
      G4int prec= G4cout.precision(12) ;
      G4cout << "***CoupledTransportation::AlongStepGPIL ** " << G4endl  ;
      G4cout << "  Quick Safety estimate at endpoint "
             << fTransportEndPosition
             << "   gives safety endpoint value = "
             << startFullSafety - fEndPointDistance
             << "  using start-point value " << startFullSafety 
             << "  and endpointDistance " << fEndPointDistance << G4endl;
      G4cout.precision(prec); 
#endif
  }          
 
  proposedSafetyForStart= safetyProposal; 
  fParticleChange.ProposeTrueStepLength(geometryStepLength) ;
 
  return geometryStepLength ;
}

◆ EnableUseMagneticMoment()

static G4bool G4CoupledTransportation::EnableUseMagneticMoment ( G4bool useMoment = true )

inlinestatic

Definition at line 104 of file G4CoupledTransportation.hh.

105 { return EnableMagneticMoment(useMoment); }

G4Transportation::EnableMagneticMoment

static G4bool EnableMagneticMoment(G4bool useMoment=true)

Definition G4Transportation.cc:835

◆ EndTracking()

void G4CoupledTransportation::EndTracking ( )

virtual

Reimplemented from G4VProcess.

Definition at line 639 of file G4CoupledTransportation.cc.

{
  G4TransportationManager::GetTransportationManager()->InactivateAll();
  fPathFinder->EndTrack(); 
    // Resets TransportationManager to use ordinary Navigator
}

◆ GetSignifyStepsInAnyVolume()

static G4bool G4CoupledTransportation::GetSignifyStepsInAnyVolume ( )

inlinestatic

Definition at line 85 of file G4CoupledTransportation.hh.

86 { return fSignifyStepInAnyVolume; }

◆ IsFirstStepInAnyVolume()

G4bool G4CoupledTransportation::IsFirstStepInAnyVolume ( ) const

inline

Definition at line 94 of file G4CoupledTransportation.hh.

94{ return fFirstStepInVolume; }

◆ IsFirstStepInMassVolume()

G4bool G4CoupledTransportation::IsFirstStepInMassVolume ( ) const

inline

Definition at line 96 of file G4CoupledTransportation.hh.

96{ return fFirstStepInMassVolume; }

◆ IsLastStepInAnyVolume()

G4bool G4CoupledTransportation::IsLastStepInAnyVolume ( ) const

inline

Definition at line 95 of file G4CoupledTransportation.hh.

95{ return fGeometryLimitedStep; }

◆ IsLastStepInMassVolume()

G4bool G4CoupledTransportation::IsLastStepInMassVolume ( ) const

inline

Definition at line 97 of file G4CoupledTransportation.hh.

97{ return fMassGeometryLimitedStep; }

◆ PostStepDoIt()

G4VParticleChange * G4CoupledTransportation::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	stepData )

virtual

Implements G4VProcess.

Definition at line 493 of file G4CoupledTransportation.cc.

{
  G4TouchableHandle retCurrentTouchable ;   // The one to return
 
  // Initialize ParticleChange  (by setting all its members equal
  //                             to corresponding members in G4Track)
  // fParticleChange.Initialize(track) ;  // To initialise TouchableChange
 
  fParticleChange.ProposeTrackStatus(track.GetTrackStatus()) ;
 
  if( fSignifyStepInAnyVolume )
  {
     fParticleChange.ProposeFirstStepInVolume( fFirstStepInVolume );
  }
  else
  {
     fParticleChange.ProposeFirstStepInVolume( fFirstStepInMassVolume );
  }
  
  // Check that the end position and direction are preserved 
  // since call to AlongStepDoIt
 
#ifdef G4DEBUG_TRANSPORT
  if( ( verboseLevel > 0 )
     && ((fTransportEndPosition - track.GetPosition()).mag2() >= 1.0e-16) )
  {
     ReportMove( track.GetPosition(), fTransportEndPosition,
                 "End of Step Position" ); 
     G4cerr << " Problem in G4CoupledTransportation::PostStepDoIt " << G4endl; 
  }
 
  // If the Step was determined by the volume boundary, relocate the particle
  // The pathFinder will know that the geometry limited the step (!?)
 
  if( verboseLevel > 0 )
  {
     G4cout << " Calling PathFinder::Locate() from " 
            << " G4CoupledTransportation::PostStepDoIt " << G4endl;
     G4cout << "   fGeometryLimitedStep is " << fGeometryLimitedStep << G4endl;
  }
#endif
 
  if(fGeometryLimitedStep)
  {  
    fPathFinder->Locate( track.GetPosition(), 
                         track.GetMomentumDirection(),
                         true); 
 
    // fCurrentTouchable will now become the previous touchable, 
    // and what was the previous will be freed.
    // (Needed because the preStepPoint can point to the previous touchable)
 
    fCurrentTouchableHandle= 
      fPathFinder->CreateTouchableHandle( G4TransportationManager::kMassNavigatorId );
 
#ifdef G4DEBUG_TRANSPORT
    if( verboseLevel > 1 )
    {
       G4VPhysicalVolume* vol= fCurrentTouchableHandle->GetVolume(); 
       G4cout << "CHECK !!!!!!!!!!! fCurrentTouchableHandle->GetVolume() = "
              << vol;
       if( vol ) { G4cout << "Name=" << vol->GetName(); }
       G4cout << G4endl;
    }
#endif
 
    // Check whether the particle is out of the world volume 
    // If so it has exited and must be killed.
    //
    if( fCurrentTouchableHandle->GetVolume() == 0 )
    {
       fParticleChange.ProposeTrackStatus( fStopAndKill ) ;
    }
    retCurrentTouchable = fCurrentTouchableHandle ;
    // fParticleChange.SetTouchableHandle( fCurrentTouchableHandle ) ;
  }
  else  // fGeometryLimitedStep  is false
  { 
#ifdef G4DEBUG_TRANSPORT
    if( verboseLevel > 1 )
    {
      G4cout << "G4CoupledTransportation::PostStepDoIt -- "
             << " fGeometryLimitedStep  = " << fGeometryLimitedStep
             << " must be false " << G4endl;
    }
#endif
    // This serves only to move each of the Navigator's location
    //
    // fLinearNavigator->LocateGlobalPointWithinVolume( track.GetPosition() ) ;
 
    fPathFinder->ReLocate( track.GetPosition() );
                           // track.GetMomentumDirection() ); 
 
    // Keep the value of the track's current Touchable is retained,
    //  and use it to overwrite the (unset) one in particle change.
    // Expect this must be fCurrentTouchable too
    //   - could it be different, eg at the start of a step ?
    //
    retCurrentTouchable = track.GetTouchableHandle() ;
    // fParticleChange.SetTouchableHandle( track.GetTouchableHandle() ) ;
  }  // endif ( fGeometryLimitedStep )
 
#ifdef G4DEBUG_NAVIGATION  
  G4cout << "  CoupledTransport::AlongStep GPIL:  "
         << " last-step:  any= " << fGeometryLimitedStep << " . ..... x . "
         << " mass= " << fMassGeometryLimitedStep << G4endl;
#endif
  
  if( fSignifyStepInAnyVolume )
    fParticleChange.ProposeLastStepInVolume(fGeometryLimitedStep);
  else
     fParticleChange.ProposeLastStepInVolume(fMassGeometryLimitedStep);
  
  SetTouchableInformation(retCurrentTouchable);
 
  return &fParticleChange ;
}

◆ ReportInexactEnergy()

void G4CoupledTransportation::ReportInexactEnergy	(	G4double	startEnergy,
		G4double	endEnergy )

protected

Definition at line 649 of file G4CoupledTransportation.cc.

{
  static G4ThreadLocal G4int no_warnings= 0, warnModulo=1,
                             moduloFactor= 10, no_large_ediff= 0; 
 
  if( std::fabs(startEnergy- endEnergy) > perThousand * endEnergy )
  {
    no_large_ediff ++;
    if( (no_large_ediff% warnModulo) == 0 )
    {
      no_warnings++;
      std::ostringstream message;
      message << "Energy change in Step is above 1^-3 relative value. "
              << G4endl
              << "   Relative change in 'tracking' step = " 
              << std::setw(15) << (endEnergy-startEnergy)/startEnergy
              << G4endl
              << "   Starting E= " << std::setw(12) << startEnergy / MeV
              << " MeV " << G4endl
              << "   Ending   E= " << std::setw(12) << endEnergy   / MeV
              << " MeV " << G4endl
              << "Energy has been corrected -- however, review"
              << " field propagation parameters for accuracy." << G4endl;
      if ( (verboseLevel > 2 ) || (no_warnings<4)
        || (no_large_ediff == warnModulo * moduloFactor) )
      {
        message << "These include EpsilonStepMax(/Min) in G4FieldManager,"
                << G4endl
                << "which determine fractional error per step for integrated quantities."
                << G4endl
                << "Note also the influence of the permitted number of integration steps."
                << G4endl;
      }
      message << "Bad 'endpoint'. Energy change detected and corrected."
              << G4endl
              << "Has occurred already " << no_large_ediff << " times.";
      G4Exception("G4CoupledTransportation::AlongStepGetPIL()", 
                  "EnergyChange", JustWarning, message);
      if( no_large_ediff == warnModulo * moduloFactor )
      {
        warnModulo *= moduloFactor;
      }
    }
  }
}

Referenced by AlongStepGetPhysicalInteractionLength().

◆ ReportMove()

void G4CoupledTransportation::ReportMove	(	G4ThreeVector	OldVector,
		G4ThreeVector	NewVector,
		const G4String &	Quantity )

protected

Definition at line 473 of file G4CoupledTransportation.cc.

{
    G4ThreeVector moveVec = ( NewVector - OldVector );
 
    G4cerr << G4endl
           << "**************************************************************"
           << G4endl;
    G4cerr << "Endpoint has moved between value expected from TransportEndPosition "
           << " and value from Track in PostStepDoIt. " << G4endl
           << "Change of " << Quantity << " is " << moveVec.mag() / mm
           << " mm long, "
           << " and its vector is " << (1.0/mm) * moveVec << " mm " << G4endl
           << "Endpoint of ComputeStep was " << OldVector
           << " and current position to locate is " << NewVector << G4endl;
}

Referenced by PostStepDoIt().

◆ SetSignifyStepsInAnyVolume()

static void G4CoupledTransportation::SetSignifyStepsInAnyVolume ( G4bool anyVol )

inlinestatic

Definition at line 83 of file G4CoupledTransportation.hh.

84 { fSignifyStepInAnyVolume = anyVol; }

◆ StartTracking()

void G4CoupledTransportation::StartTracking ( G4Track * aTrack )

virtual

Reimplemented from G4VProcess.

Definition at line 619 of file G4CoupledTransportation.cc.

{
  G4Transportation::StartTracking(aTrack);
  
  G4ThreeVector position = aTrack->GetPosition(); 
  G4ThreeVector direction = aTrack->GetMomentumDirection();
 
  fPathFinder->PrepareNewTrack( position, direction); 
  // This implies a call to fPathFinder->Locate( position, direction ); 
 
  // reset safety value and center
  //
  fPreviousMassSafety  = 0.0 ; 
  fPreviousFullSafety  = 0.0 ; 
  fPreviousSftOrigin = G4ThreeVector(0.,0.,0.) ;
}

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4CoupledTransportation()

◆ ~G4CoupledTransportation()

Member Function Documentation

◆ AlongStepGetPhysicalInteractionLength()

◆ EnableUseMagneticMoment()

◆ EndTracking()

◆ GetSignifyStepsInAnyVolume()

◆ IsFirstStepInAnyVolume()

◆ IsFirstStepInMassVolume()

◆ IsLastStepInAnyVolume()

◆ IsLastStepInMassVolume()

◆ PostStepDoIt()

◆ ReportInexactEnergy()

◆ ReportMove()

◆ SetSignifyStepsInAnyVolume()

◆ StartTracking()