Concrete class that does the geometrical transport. More...

#include <G4MonopoleTransportation.h>

Inheritance diagram for G4MonopoleTransportation:

Public Member Functions
	G4MonopoleTransportation (const G4Monopole *mpl, G4int verb=1)
	Constructor.

	~G4MonopoleTransportation ()
	Destructor.

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)
	G4VProcess::AlongStepGetPhysicalInteractionLength() implementation.

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)
	G4VProcess::AlongStepDoIt() implementation, Proposes changes during step to fParticleChange of this class.

virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)
	G4VProcess::PostStepDoIt() implementation.

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *pForceCond)
	G4VProcess::PostStepGetPhysicalInteractionLength() implementation.

G4PropagatorInField *	GetPropagatorInField ()
	Access fFieldPropagator, the assistant class that Propagate in a Field.

void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)
	Set fFieldPropagator, the assistant class that Propagate in a Field.

G4double	GetThresholdWarningEnergy () const
	Access fThreshold_Warning_Energy.

G4double	GetThresholdImportantEnergy () const
	Access fThreshold_Important_Energy.

G4int	GetThresholdTrials () const
	Access fThresholdTrials.

void	SetThresholdWarningEnergy (G4double newEnWarn)
	Set fThreshold_Warning_Energy.

void	SetThresholdImportantEnergy (G4double newEnImp)
	Set fThreshold_Important_Energy.

void	SetThresholdTrials (G4int newMaxTrials)
	Set fThresholdTrials.

G4double	GetMaxEnergyKilled () const
	Access fMaxEnergyKilled.

G4double	GetSumEnergyKilled () const
	Access fSumEnergyKilled.

void	ResetKilledStatistics (G4int report=1)
	Statistics for tracks killed (currently due to looping in field)

void	EnableShortStepOptimisation (G4bool optimise=true)
	Whether short steps < safety will avoid to call Navigator (if field=0)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
	No operation in AtRestDoIt.

virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
	No operation in AtRestDoIt.

virtual void	StartTracking (G4Track *aTrack)
	Reset state for new (potentially resumed) track.

Protected Member Functions
G4bool	DoesGlobalFieldExist ()
	Checks whether a field exists for the "global" field manager.

Private Attributes
const G4Monopole *	fParticleDef
	Monopole definition for charge and mass reference.

G4MonopoleFieldSetup *	fMagSetup
	Monpole field setup.

G4Navigator *	fLinearNavigator
	Propagator used to transport the particle.

G4PropagatorInField *	fFieldPropagator
	Propagator used to transport the particle.

G4ThreeVector	fTransportEndPosition
	The particle's state after this Step, Store for DoIt.

G4ThreeVector	fTransportEndMomentumDir
	The particle's state after this Step, Store for DoIt.

G4double	fTransportEndKineticEnergy
	The particle's state after this Step, Store for DoIt.

G4ThreeVector	fTransportEndSpin
	The particle's state after this Step, Store for DoIt.

G4bool	fMomentumChanged
	The particle's state after this Step, Store for DoIt.

G4bool	fEndGlobalTimeComputed
	The particle's state after this Step, Store for DoIt.

G4double	fCandidateEndGlobalTime
	The particle's state after this Step, Store for DoIt.

G4bool	fParticleIsLooping
	Is the monopole stuck in looping.

G4TouchableHandle	fCurrentTouchableHandle
	Current touchable handle.

G4bool	fGeometryLimitedStep
	Flag to determine whether a boundary was reached.

G4ThreeVector	fPreviousSftOrigin
	Remember last safety origin.

G4double	fPreviousSafety
	Remember last safety value.

G4ParticleChangeForTransport	fParticleChange
	New ParticleChange.

G4double	endpointDistance
	Endpint distance.

G4double	fThreshold_Trap_Energy
	Assume monopoles below this can bound to material.

G4double	fThreshold_Warning_Energy
	Warn above this energy about looping particle.

G4double	fThreshold_Important_Energy
	Hesitate above this about looping particle for a certain no of trials.

G4int	fThresholdTrials
	Nubmer of trials for looping particles.

G4int	fNoLooperTrials
	Counter for steps in which particle reports 'looping', if it is above 'Important' Energy.

G4double	fSumEnergyKilled
	Sum of abandoned looping tracks energies.

G4double	fMaxEnergyKilled
	Max of abandoned looping tracks energies.

G4bool	fShortStepOptimisation
	Whether to avoid calling G4Navigator for short step ( < safety) If using it, the safety estimate for endpoint will likely be smaller.

G4SafetyHelper *	fpSafetyHelper
	To pass it the safety value obtained.

Detailed Description

Concrete class that does the geometrical transport.

Quite big and clunky class of the monopole transportation.

Definition at line 44 of file G4MonopoleTransportation.h.

Constructor & Destructor Documentation

◆ G4MonopoleTransportation()

G4MonopoleTransportation	(	const G4Monopole *	mpl,
		G4int	verb = 1 )

explicit

Constructor.

Parameters

mpl	Reference to the monopole definition in GEANT4
verb	Verbosity level, if GEANT4 was set to be verbose

Definition at line 30 of file G4MonopoleTransportation.cc.

  : G4VProcess(G4String("MonopoleTransportation"), fTransportation),
    fParticleDef(mpl),
    fMagSetup(0),
    fLinearNavigator(0),
    fFieldPropagator(0),
    fParticleIsLooping(false),
    fPreviousSftOrigin(0., 0., 0.),
    fPreviousSafety(0.0),
    fThreshold_Trap_Energy(10 * MeV),
    fThreshold_Warning_Energy(100 * MeV),
    fThreshold_Important_Energy(250 * MeV),
    fThresholdTrials(10),
    fNoLooperTrials(0),
    fSumEnergyKilled(0.0), fMaxEnergyKilled(0.0),
    fShortStepOptimisation(false),    // Old default: true (=fast short steps)
    fpSafetyHelper(0)
{
  verboseLevel = verb;
 
  // set Process Sub Type
  SetProcessSubType(TRANSPORTATION);
 
  fMagSetup = G4MonopoleFieldSetup::GetMonopoleFieldSetup();
 
  G4TransportationManager* transportMgr ;
 
  transportMgr = G4TransportationManager::GetTransportationManager() ;
 
  fLinearNavigator = transportMgr->GetNavigatorForTracking() ;
 
  // fGlobalFieldMgr = transportMgr->GetFieldManager() ;
 
  fFieldPropagator = transportMgr->GetPropagatorInField() ;
 
  fpSafetyHelper =   transportMgr->GetSafetyHelper();  // New
 
  // Cannot determine whether a field exists here,
  //  because it would only work if the field manager has informed
  //  about the detector's field before this transportation process
  //  is constructed.
  // Instead later the method DoesGlobalFieldExist() is called
 
  static G4TouchableHandle nullTouchableHandle;  // Points to (G4VTouchable*) 0
  fCurrentTouchableHandle = nullTouchableHandle;
 
  fEndGlobalTimeComputed  = false;
  fCandidateEndGlobalTime = 0;
}

◆ ~G4MonopoleTransportation()

~G4MonopoleTransportation ( )

Destructor.

Definition at line 81 of file G4MonopoleTransportation.cc.

{
  if ((verboseLevel > 0) && (fSumEnergyKilled > 0.0)) {
    B2DEBUG(25, " G4MonopoleTransportation: Statistics for looping particles ");
    B2DEBUG(25, "   Sum of energy of loopers killed: " <<  fSumEnergyKilled);
    B2DEBUG(25, "   Max energy of loopers killed: " <<  fMaxEnergyKilled);
  }
}

Member Function Documentation

◆ AlongStepDoIt()

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

virtual

G4VProcess::AlongStepDoIt() implementation, Proposes changes during step to fParticleChange of this class.

Parameters

track	Propagating particle track reference
stepData	Current step reference

Returns: Reference to modified fParticleChange

Definition at line 345 of file G4MonopoleTransportation.cc.

{
#ifdef G4VERBOSE
  static G4int noCalls = 0;
  noCalls++;
#endif
 
  static const G4ParticleDefinition* fOpticalPhoton =
    G4ParticleTable::GetParticleTable()->FindParticle("opticalphoton");
 
  fParticleChange.Initialize(track) ;
 
  //  Code for specific process
  //
  fParticleChange.ProposePosition(fTransportEndPosition) ;
  fParticleChange.ProposeMomentumDirection(fTransportEndMomentumDir) ;
  fParticleChange.ProposeEnergy(fTransportEndKineticEnergy) ;
  fParticleChange.SetMomentumChanged(fMomentumChanged) ;
 
  fParticleChange.ProposePolarization(fTransportEndSpin);
 
  G4double deltaTime = 0.0 ;
 
  // Calculate  Lab Time of Flight (ONLY if field Equations used it!)
  // G4double endTime   = fCandidateEndGlobalTime;
  // G4double delta_time = endTime - startTime;
 
  G4double startTime = track.GetGlobalTime() ;
 
  if (!fEndGlobalTimeComputed) {
    // The time was not integrated .. make the best estimate possible
    //
    G4double finalVelocity   = track.GetVelocity() ;
    G4double initialVelocity = stepData.GetPreStepPoint()->GetVelocity() ;
    G4double stepLength      = track.GetStepLength() ;
 
    deltaTime = 0.0; // in case initialVelocity = 0
    const G4DynamicParticle* fpDynamicParticle = track.GetDynamicParticle();
    if (fpDynamicParticle->GetDefinition() == fOpticalPhoton) {
      //  A photon is in the medium of the final point
      //  during the step, so it has the final velocity.
      deltaTime = stepLength / finalVelocity ;
    } else if (finalVelocity > 0.0) {
      G4double meanInverseVelocity ;
      // deltaTime = stepLength/finalVelocity ;
      meanInverseVelocity = 0.5
                            * (1.0 / initialVelocity + 1.0 / finalVelocity) ;
      deltaTime = stepLength * meanInverseVelocity ;
    } else if (initialVelocity > 0.0) {
      deltaTime = stepLength / initialVelocity ;
    }
    fCandidateEndGlobalTime   = startTime + deltaTime ;
  } else {
    deltaTime = fCandidateEndGlobalTime - startTime ;
  }
 
  fParticleChange.ProposeGlobalTime(fCandidateEndGlobalTime) ;
 
  // Now Correct by Lorentz factor to get "proper" deltaTime
 
  G4double  restMass       = track.GetDynamicParticle()->GetMass() ;
  G4double deltaProperTime = deltaTime * (restMass / track.GetTotalEnergy()) ;
 
  fParticleChange.ProposeProperTime(track.GetProperTime() + deltaProperTime) ;
  //fParticleChange. ProposeTrueStepLength( track.GetStepLength() ) ;
 
  // If the particle is caught looping or is stuck (in very difficult
  // boundaries) in a magnetic field (doing many steps)
  //   THEN this kills it ...
  //
  if (fParticleIsLooping) {
    G4double endEnergy = fTransportEndKineticEnergy;
 
    if ((endEnergy < fThreshold_Important_Energy)
        || (fNoLooperTrials >= fThresholdTrials)) {
      // Kill the looping particle
      //
      fParticleChange.ProposeTrackStatus(fStopAndKill)  ;
 
      // 'Bare' statistics
      fSumEnergyKilled += endEnergy;
      if (endEnergy > fMaxEnergyKilled) { fMaxEnergyKilled = endEnergy; }
 
#ifdef G4VERBOSE
      if ((verboseLevel > 1) ||
          (endEnergy > fThreshold_Warning_Energy)) {
        B2DEBUG(25, " G4MonopoleTransportation is killing track that is looping or stuck ");
        B2DEBUG(25, "   This track has " << track.GetKineticEnergy() / MeV << " MeV energy.");
        B2DEBUG(25, "   Number of trials = " << fNoLooperTrials
                << "   No of calls to AlongStepDoIt = " << noCalls);
      }
#endif
      fNoLooperTrials = 0;
    } else {
      fNoLooperTrials ++;
#ifdef G4VERBOSE
      if ((verboseLevel > 2)) {
        B2DEBUG(25, "   G4MonopoleTransportation::AlongStepDoIt(): Particle looping -  "
                << "   Number of trials = " << fNoLooperTrials
                << "   No of calls to  = " << noCalls);
      }
#endif
    }
  } else {
    fNoLooperTrials = 0;
  }
 
  // Another (sometimes better way) is to use a user-limit maximum Step size
  // to alleviate this problem ..
 
  // Introduce smooth curved trajectories to particle-change
  //
  fParticleChange.SetPointerToVectorOfAuxiliaryPoints
  (fFieldPropagator->GimmeTrajectoryVectorAndForgetIt());
 
  //Monopole bounding
  if (fTransportEndKineticEnergy < fThreshold_Trap_Energy) {
    fParticleChange.ProposeTrackStatus(fStopAndKill);
    B2DEBUG(150, "Monopole bound in " << fCurrentTouchableHandle->GetVolume()->GetName());
    B2DEBUG(150, "with energy " << fTransportEndKineticEnergy << " MeV");
  }
 
  return &fParticleChange ;
}

◆ AlongStepGetPhysicalInteractionLength()

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

virtual

G4VProcess::AlongStepGetPhysicalInteractionLength() implementation.

Responsibilities: Find whether the geometry limits the Step, and to what length Calculate the new value of the safety and return it. Store the final time, position and momentum.

Parameters

track	Propagating particle track reference
previousStepSize	This argument of base function is ignored
currentMinimumStep	Current minimum step size
currentSafety	Reference to current step safety
selection	Pointer for return value of GPILSelection, which is set to default value of CandidateForSelection

Returns: Next geometry step length

Definition at line 95 of file G4MonopoleTransportation.cc.

{
  fMagSetup->SwitchChordFinder(1);
  // change to monopole equation
 
  G4double geometryStepLength, newSafety ;
  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 ;
 
  // Get initial Energy/Momentum of the track
  //
  const G4DynamicParticle* pParticle      = track.GetDynamicParticle() ;
  G4ThreeVector startMomentumDir          = pParticle->GetMomentumDirection() ;
  G4ThreeVector startPosition             = track.GetPosition() ;
 
  // 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() ;
  if (MagSqShift >= sqr(fPreviousSafety)) {
    currentSafety = 0.0 ;
  } else {
    currentSafety = fPreviousSafety - std::sqrt(MagSqShift) ;
  }
 
  // Is the monopole charged ?
  //
  G4double particleMagneticCharge = fParticleDef->MagneticCharge() ;
  G4double particleElectricCharge = pParticle->GetCharge();
 
  fGeometryLimitedStep = false ;
  // fEndGlobalTimeComputed = 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 whether the particle have an (EM) field force exerting upon it
  //
  G4FieldManager* fieldMgr = nullptr;
  G4bool          fieldExertsForce = false ;
 
  if ((particleMagneticCharge != 0.0)) {
    fieldMgr = fFieldPropagator->FindAndSetFieldManager(track.GetVolume());
    if (fieldMgr != 0) {
      // Message the field Manager, to configure it for this track
      fieldMgr->ConfigureForTrack(&track);
      // Moved here, in order to allow a transition
      //   from a zero-field  status (with fieldMgr->(field)0
      //   to a finite field  status
 
      // If the field manager has no field, there is no field !
      fieldExertsForce = (fieldMgr->GetDetectorField() != 0);
    }
  }
 
  // Choose the calculation of the transportation: Field or not
  //
  if (!fieldExertsForce) {
    G4double linearStepLength ;
    if (fShortStepOptimisation && (currentMinimumStep <= currentSafety)) {
      // The Step is guaranteed to be taken
      //
      geometryStepLength   = currentMinimumStep ;
      fGeometryLimitedStep = false ;
    } else {
      //  Find whether the straight path intersects a volume
      //
      linearStepLength = fLinearNavigator->ComputeStep(startPosition,
                                                       startMomentumDir,
                                                       currentMinimumStep,
                                                       newSafety) ;
      // Remember last safety origin & value.
      //
      fPreviousSftOrigin = startPosition ;
      fPreviousSafety    = newSafety ;
      // fpSafetyHelper->SetCurrentSafety( newSafety, startPosition);
 
      // The safety at the initial point has been re-calculated:
      //
      currentSafety = newSafety ;
 
      fGeometryLimitedStep = (linearStepLength <= currentMinimumStep);
      if (fGeometryLimitedStep) {
        // The geometry limits the Step size (an intersection was found.)
        geometryStepLength   = linearStepLength ;
      } else {
        // The full Step is taken.
        geometryStepLength   = currentMinimumStep ;
      }
    }
    endpointDistance = geometryStepLength ;
 
    // Calculate final position
    //
    fTransportEndPosition = startPosition + geometryStepLength * startMomentumDir ;
 
    // Momentum direction, energy and polarisation are unchanged by transport
    //
    fTransportEndMomentumDir   = startMomentumDir ;
    fTransportEndKineticEnergy = track.GetKineticEnergy() ;
    fTransportEndSpin          = track.GetPolarization();
    fParticleIsLooping         = false ;
    fMomentumChanged           = false ;
    fEndGlobalTimeComputed     = false ;
  } else { //  A field exerts force
    G4double       momentumMagnitude = pParticle->GetTotalMomentum() ;
    G4ThreeVector  EndUnitMomentum ;
    G4double       restMass = fParticleDef->GetPDGMass() ;
 
    G4ChargeState chargeState(particleElectricCharge,  // The charge can change (dynamic)
                              fParticleDef->GetPDGSpin(),
                              0,   //  Magnetic moment:  pParticleDef->GetMagneticMoment(),
                              0,   //  Electric Dipole moment - not in Particle Definition
                              particleMagneticCharge);    // in units of the positron charge
 
    G4EquationOfMotion* equationOfMotion =
      (fFieldPropagator->GetChordFinder()->GetIntegrationDriver()->GetStepper())
      ->GetEquationOfMotion();
 
    equationOfMotion
    ->SetChargeMomentumMass(chargeState,
                            momentumMagnitude,
                            restMass) ;
    // SetChargeMomentumMass now passes both the electric and magnetic charge - in chargeState
 
    G4ThreeVector spin        = track.GetPolarization() ;
    G4FieldTrack  aFieldTrack = G4FieldTrack(startPosition,
                                             track.GetMomentumDirection(),
                                             0.0,
                                             track.GetKineticEnergy(),
                                             restMass,
                                             track.GetVelocity(),
                                             track.GetGlobalTime(), // Lab.
                                             track.GetProperTime(), // Part.
                                             &spin) ;
    if (currentMinimumStep > 0) {
      // Do the Transport in the field (non recti-linear)
      //
      G4double lengthAlongCurve = fFieldPropagator->ComputeStep(
                                    aFieldTrack,
                                    currentMinimumStep,
                                    currentSafety,
                                    track.GetVolume()) ;
      fGeometryLimitedStep = lengthAlongCurve < currentMinimumStep;
      if (fGeometryLimitedStep) {
        geometryStepLength   = lengthAlongCurve ;
      } else {
        geometryStepLength   = currentMinimumStep ;
      }
    } else {
      geometryStepLength   = 0.0 ;
      fGeometryLimitedStep = false ;
    }
 
    // Remember last safety origin & value.
    //
    fPreviousSftOrigin = startPosition ;
    fPreviousSafety    = currentSafety ;
    // fpSafetyHelper->SetCurrentSafety( newSafety, startPosition);
 
    // Get the End-Position and End-Momentum (Dir-ection)
    //
    fTransportEndPosition = aFieldTrack.GetPosition() ;
 
    // Momentum:  Magnitude and direction can be changed too now ...
    //
    fMomentumChanged         = true ;
    fTransportEndMomentumDir = aFieldTrack.GetMomentumDir() ;
 
    fTransportEndKineticEnergy  = aFieldTrack.GetKineticEnergy() ;
 
    fCandidateEndGlobalTime   = aFieldTrack.GetLabTimeOfFlight();
    fEndGlobalTimeComputed    = true;
 
    fTransportEndSpin = aFieldTrack.GetSpin();
    fParticleIsLooping = fFieldPropagator->IsParticleLooping() ;
    endpointDistance   = (fTransportEndPosition - startPosition).mag() ;
  }
 
  // If we are asked to go a step length of 0, and we are on a boundary
  // then a boundary will also limit the step -> we must flag this.
  //
  if (currentMinimumStep == 0.0) {
    if (currentSafety == 0.0)  fGeometryLimitedStep = true ;
  }
 
  // Update the safety starting from the end-point,
  // if it will become negative at the end-point.
  //
  if (currentSafety < endpointDistance) {
    // if( particleMagneticCharge == 0.0 )
    //    G4cout  << "  Avoiding call to ComputeSafety : charge = 0.0 " << G4endl;
 
    if (particleMagneticCharge != 0.0) {
 
      G4double endSafety =
        fLinearNavigator->ComputeSafety(fTransportEndPosition) ;
      currentSafety      = endSafety ;
      fPreviousSftOrigin = fTransportEndPosition ;
      fPreviousSafety    = currentSafety ;
      fpSafetyHelper->SetCurrentSafety(currentSafety, fTransportEndPosition);
 
      // Because the Stepping Manager assumes it is from the start point,
      //  add the StepLength
      //
      currentSafety     += endpointDistance ;
 
#ifdef G4DEBUG_TRANSPORT
      G4cout.precision(12) ;
      G4cout << "***G4MonopoleTransportation::AlongStepGPIL ** " << G4endl  ;
      G4cout << "  Called Navigator->ComputeSafety at " << fTransportEndPosition
             << "    and it returned safety= " << endSafety << G4endl ;
      G4cout << "  Adding endpoint distance " << endpointDistance
             << "   to obtain pseudo-safety= " << currentSafety << G4endl ;
#endif
    }
  }
 
  fParticleChange.ProposeTrueStepLength(geometryStepLength) ;
 
  fMagSetup->SwitchChordFinder(0);
  // change back to usual equation
 
  return geometryStepLength ;
}

◆ AtRestDoIt()

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

inlinevirtual

No operation in AtRestDoIt.

Definition at line 163 of file G4MonopoleTransportation.h.

166 {return 0;};

◆ AtRestGetPhysicalInteractionLength()

virtual G4double AtRestGetPhysicalInteractionLength	(	const G4Track &	,
		G4ForceCondition *	)

inlinevirtual

No operation in AtRestDoIt.

Definition at line 155 of file G4MonopoleTransportation.h.

158 { return -1.0; };

◆ DoesGlobalFieldExist()

G4bool DoesGlobalFieldExist ( )

inlineprotected

Checks whether a field exists for the "global" field manager.

Definition at line 35 of file G4MonopoleTransportationInline.h.

    {
      G4TransportationManager* transportMgr;
      transportMgr = G4TransportationManager::GetTransportationManager();
 
      // fFieldExists= transportMgr->GetFieldManager()->DoesFieldExist();
      // return fFieldExists;
      return transportMgr->GetFieldManager()->DoesFieldExist();
    }

◆ EnableShortStepOptimisation()

void EnableShortStepOptimisation ( G4bool optimise = true )

inline

Whether short steps < safety will avoid to call Navigator (if field=0)

Definition at line 103 of file G4MonopoleTransportationInline.h.

    {
      fShortStepOptimisation = optimiseShortStep;
    }

◆ GetMaxEnergyKilled()

G4double GetMaxEnergyKilled ( ) const

inline

Access fMaxEnergyKilled.

Definition at line 80 of file G4MonopoleTransportationInline.h.

    {
      return fMaxEnergyKilled;
    }

◆ GetPropagatorInField()

G4PropagatorInField * GetPropagatorInField ( )

inline

Access fFieldPropagator, the assistant class that Propagate in a Field.

Definition at line 30 of file G4MonopoleTransportationInline.h.

    {
      return fFieldPropagator;
    }

◆ GetSumEnergyKilled()

G4double GetSumEnergyKilled ( ) const

inline

Access fSumEnergyKilled.

Definition at line 85 of file G4MonopoleTransportationInline.h.

    {
      return fSumEnergyKilled;
    }

◆ GetThresholdImportantEnergy()

G4double GetThresholdImportantEnergy ( ) const

inline

Access fThreshold_Important_Energy.

Definition at line 50 of file G4MonopoleTransportationInline.h.

    {
      return fThreshold_Important_Energy;
    }

◆ GetThresholdTrials()

G4int GetThresholdTrials ( ) const

inline

Access fThresholdTrials.

Definition at line 55 of file G4MonopoleTransportationInline.h.

    {
      return fThresholdTrials;
    }

◆ GetThresholdWarningEnergy()

G4double GetThresholdWarningEnergy ( ) const

inline

Access fThreshold_Warning_Energy.

Definition at line 45 of file G4MonopoleTransportationInline.h.

    {
      return fThreshold_Warning_Energy;
    }

◆ PostStepDoIt()

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

virtual

G4VProcess::PostStepDoIt() implementation.

Proposes changes after the step to fParticleChange of this class.

Responsible for the relocation

Parameters

track	Propagating particle track reference
stepData	Current step reference

Returns: Reference to modified fParticleChange

Definition at line 484 of file G4MonopoleTransportation.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 the Step was determined by the volume boundary,
  // logically relocate the particle
 
  if (fGeometryLimitedStep) {
    // 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)
 
    fLinearNavigator->SetGeometricallyLimitedStep() ;
    fLinearNavigator->
    LocateGlobalPointAndUpdateTouchableHandle(track.GetPosition(),
                                              track.GetMomentumDirection(),
                                              fCurrentTouchableHandle,
                                              true) ;
    // 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
    // This serves only to move the Navigator's location
    //
    fLinearNavigator->LocateGlobalPointWithinVolume(track.GetPosition()) ;
 
    // The value of the track's current Touchable is retained.
    // (and it must be correct because we must use it below to
    // overwrite the (unset) one in particle change)
    //  It must be fCurrentTouchable too ??
    //
    fParticleChange.SetTouchableHandle(track.GetTouchableHandle()) ;
    retCurrentTouchable = track.GetTouchableHandle() ;
  }         // endif ( fGeometryLimitedStep )
 
  const G4VPhysicalVolume* pNewVol = retCurrentTouchable->GetVolume() ;
  G4Material* pNewMaterial   = nullptr ;
  G4VSensitiveDetector* pNewSensitiveDetector   = nullptr ;
 
  if (pNewVol != 0) {
    pNewMaterial = pNewVol->GetLogicalVolume()->GetMaterial();
    pNewSensitiveDetector = pNewVol->GetLogicalVolume()->GetSensitiveDetector();
  }
 
  fParticleChange.SetMaterialInTouchable(
    pNewMaterial) ;
  fParticleChange.SetSensitiveDetectorInTouchable(
    pNewSensitiveDetector) ;
 
  const G4MaterialCutsCouple* pNewMaterialCutsCouple = 0;
  if (pNewVol != 0) {
    pNewMaterialCutsCouple = pNewVol->GetLogicalVolume()->GetMaterialCutsCouple();
  }
 
  if (pNewVol != 0 && pNewMaterialCutsCouple != 0 &&
      pNewMaterialCutsCouple->GetMaterial() != pNewMaterial) {
    // for parametrized volume
    //
    pNewMaterialCutsCouple =
      G4ProductionCutsTable::GetProductionCutsTable()
      ->GetMaterialCutsCouple(pNewMaterial,
                              pNewMaterialCutsCouple->GetProductionCuts());
  }
  fParticleChange.SetMaterialCutsCoupleInTouchable(pNewMaterialCutsCouple);
 
  // temporarily until Get/Set Material of ParticleChange,
  // and StepPoint can be made const.
  // Set the touchable in ParticleChange
  // this must always be done because the particle change always
  // uses this value to overwrite the current touchable pointer.
  //
  fParticleChange.SetTouchableHandle(retCurrentTouchable) ;
 
  return &fParticleChange ;
}

◆ PostStepGetPhysicalInteractionLength()

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

virtual

G4VProcess::PostStepGetPhysicalInteractionLength() implementation.

Forces the PostStepDoIt action to be called, so that it can do the relocation if it is needed, but does not limit the step.

Parameters

track	This argument of base function is ignored
previousStepSize	This argument of base function is ignored
pForceCond	Force condition by default

Returns: DBL_MAX

Definition at line 475 of file G4MonopoleTransportation.cc.

{
  *pForceCond = Forced ;
  return DBL_MAX ;  // was kInfinity ; but convention now is DBL_MAX
}

◆ ResetKilledStatistics()

void ResetKilledStatistics ( G4int report = 1 )

inline

Statistics for tracks killed (currently due to looping in field)

Definition at line 90 of file G4MonopoleTransportationInline.h.

    {
      if (report) {
        B2INFO(" G4MonopoleTransportation: Statistics for looping particles ");
        B2INFO("   Sum of energy of loopers killed: " <<  fSumEnergyKilled);
        B2INFO("   Max energy of loopers killed: " <<  fMaxEnergyKilled);
      }
 
      fSumEnergyKilled = 0;
      fMaxEnergyKilled = -1.0 * CLHEP::GeV;
    }

◆ SetPropagatorInField()

void SetPropagatorInField ( G4PropagatorInField * pFieldPropagator )

inline

Set fFieldPropagator, the assistant class that Propagate in a Field.

Definition at line 25 of file G4MonopoleTransportationInline.h.

    {
      fFieldPropagator = pFieldPropagator;
    }

◆ SetThresholdImportantEnergy()

void SetThresholdImportantEnergy ( G4double newEnImp )

inline

Set fThreshold_Important_Energy.

Definition at line 65 of file G4MonopoleTransportationInline.h.

    {
      fThreshold_Important_Energy = newEnImp;
    }

◆ SetThresholdTrials()

void SetThresholdTrials ( G4int newMaxTrials )

inline

Set fThresholdTrials.

Definition at line 70 of file G4MonopoleTransportationInline.h.

    {
      fThresholdTrials = newMaxTrials;
    }

◆ SetThresholdWarningEnergy()

void SetThresholdWarningEnergy ( G4double newEnWarn )

inline

Set fThreshold_Warning_Energy.

Definition at line 60 of file G4MonopoleTransportationInline.h.

    {
      fThreshold_Warning_Energy = newEnWarn;
    }

◆ StartTracking()

void StartTracking ( G4Track * aTrack )

virtual

Reset state for new (potentially resumed) track.

Definition at line 577 of file G4MonopoleTransportation.cc.

{
  G4VProcess::StartTracking(aTrack);
 
// The actions here are those that were taken in AlongStepGPIL
//   when track.GetCurrentStepNumber()==1
 
  // reset safety value and center
  //
  fPreviousSafety    = 0.0 ;
  fPreviousSftOrigin = G4ThreeVector(0., 0., 0.) ;
 
  // reset looping counter -- for motion in field
  fNoLooperTrials = 0;
  // Must clear this state .. else it depends on last track's value
  //  --> a better solution would set this from state of suspended track TODO ?
  // Was if( aTrack->GetCurrentStepNumber()==1 ) { .. }
 
  // ChordFinder reset internal state
  //
  if (DoesGlobalFieldExist()) {
    fFieldPropagator->ClearPropagatorState();
    // Resets all state of field propagator class (ONLY)
    //  including safety values (in case of overlaps and to wipe for first track).
 
    // G4ChordFinder* chordF= fFieldPropagator->GetChordFinder();
    // if( chordF ) chordF->ResetStepEstimate();
  }
 
  // Make sure to clear the chord finders of all fields (ie managers)
  static G4FieldManagerStore* fieldMgrStore = G4FieldManagerStore::GetInstance();
  fieldMgrStore->ClearAllChordFindersState();
 
  // Update the current touchable handle  (from the track's)
  //
  fCurrentTouchableHandle = aTrack->GetTouchableHandle();
}

Member Data Documentation

◆ endpointDistance

G4double endpointDistance

private

Endpint distance.

Definition at line 203 of file G4MonopoleTransportation.h.

◆ fCandidateEndGlobalTime

G4double fCandidateEndGlobalTime

private

The particle's state after this Step, Store for DoIt.

Definition at line 190 of file G4MonopoleTransportation.h.

◆ fCurrentTouchableHandle

G4TouchableHandle fCurrentTouchableHandle

private

Current touchable handle.

Definition at line 194 of file G4MonopoleTransportation.h.

◆ fEndGlobalTimeComputed

G4bool fEndGlobalTimeComputed

private

The particle's state after this Step, Store for DoIt.

Definition at line 189 of file G4MonopoleTransportation.h.

◆ fFieldPropagator

G4PropagatorInField* fFieldPropagator

private

Propagator used to transport the particle.

Definition at line 181 of file G4MonopoleTransportation.h.

◆ fGeometryLimitedStep

G4bool fGeometryLimitedStep

private

Flag to determine whether a boundary was reached.

Definition at line 196 of file G4MonopoleTransportation.h.

◆ fLinearNavigator

G4Navigator* fLinearNavigator

private

Propagator used to transport the particle.

Definition at line 180 of file G4MonopoleTransportation.h.

◆ fMagSetup

G4MonopoleFieldSetup* fMagSetup

private

Monpole field setup.

Definition at line 178 of file G4MonopoleTransportation.h.

◆ fMaxEnergyKilled

G4double fMaxEnergyKilled

private

Max of abandoned looping tracks energies.

Definition at line 218 of file G4MonopoleTransportation.h.

◆ fMomentumChanged

G4bool fMomentumChanged

private

The particle's state after this Step, Store for DoIt.

Definition at line 187 of file G4MonopoleTransportation.h.

◆ fNoLooperTrials

G4int fNoLooperTrials

private

Counter for steps in which particle reports 'looping', if it is above 'Important' Energy.

Definition at line 216 of file G4MonopoleTransportation.h.

◆ fParticleChange

G4ParticleChangeForTransport fParticleChange

private

New ParticleChange.

Definition at line 201 of file G4MonopoleTransportation.h.

◆ fParticleDef

const G4Monopole* fParticleDef

private

Monopole definition for charge and mass reference.

Definition at line 176 of file G4MonopoleTransportation.h.

◆ fParticleIsLooping

G4bool fParticleIsLooping

private

Is the monopole stuck in looping.

Definition at line 192 of file G4MonopoleTransportation.h.

◆ fPreviousSafety

G4double fPreviousSafety

private

Remember last safety value.

Definition at line 199 of file G4MonopoleTransportation.h.

◆ fPreviousSftOrigin

G4ThreeVector fPreviousSftOrigin

private

Remember last safety origin.

Definition at line 198 of file G4MonopoleTransportation.h.

◆ fpSafetyHelper

G4SafetyHelper* fpSafetyHelper

private

To pass it the safety value obtained.

Definition at line 226 of file G4MonopoleTransportation.h.

◆ fShortStepOptimisation

G4bool fShortStepOptimisation

private

Whether to avoid calling G4Navigator for short step ( < safety) If using it, the safety estimate for endpoint will likely be smaller.

Definition at line 224 of file G4MonopoleTransportation.h.

◆ fSumEnergyKilled

G4double fSumEnergyKilled

private

Sum of abandoned looping tracks energies.

Definition at line 217 of file G4MonopoleTransportation.h.

◆ fThreshold_Important_Energy

G4double fThreshold_Important_Energy

private

Hesitate above this about looping particle for a certain no of trials.

Definition at line 209 of file G4MonopoleTransportation.h.

◆ fThreshold_Trap_Energy

G4double fThreshold_Trap_Energy

private

Assume monopoles below this can bound to material.

Definition at line 205 of file G4MonopoleTransportation.h.

◆ fThreshold_Warning_Energy

G4double fThreshold_Warning_Energy

private

Warn above this energy about looping particle.

Definition at line 208 of file G4MonopoleTransportation.h.

◆ fThresholdTrials

G4int fThresholdTrials

private

Nubmer of trials for looping particles.

Definition at line 210 of file G4MonopoleTransportation.h.

◆ fTransportEndKineticEnergy

G4double fTransportEndKineticEnergy

private

The particle's state after this Step, Store for DoIt.

Definition at line 185 of file G4MonopoleTransportation.h.

◆ fTransportEndMomentumDir

G4ThreeVector fTransportEndMomentumDir

private

The particle's state after this Step, Store for DoIt.

Definition at line 184 of file G4MonopoleTransportation.h.

◆ fTransportEndPosition

G4ThreeVector fTransportEndPosition

private

The particle's state after this Step, Store for DoIt.

Definition at line 183 of file G4MonopoleTransportation.h.

◆ fTransportEndSpin

G4ThreeVector fTransportEndSpin

private

The particle's state after this Step, Store for DoIt.

Definition at line 186 of file G4MonopoleTransportation.h.

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

simulation/monopoles/include/G4MonopoleTransportation.h
simulation/monopoles/include/G4MonopoleTransportationInline.h
simulation/monopoles/src/G4MonopoleTransportation.cc

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4MonopoleTransportation()

◆ ~G4MonopoleTransportation()

Member Function Documentation

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ DoesGlobalFieldExist()

◆ EnableShortStepOptimisation()

◆ GetMaxEnergyKilled()

◆ GetPropagatorInField()

◆ GetSumEnergyKilled()

◆ GetThresholdImportantEnergy()

◆ GetThresholdTrials()

◆ GetThresholdWarningEnergy()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ ResetKilledStatistics()

◆ SetPropagatorInField()

◆ SetThresholdImportantEnergy()

◆ SetThresholdTrials()

◆ SetThresholdWarningEnergy()

◆ StartTracking()

Member Data Documentation

◆ endpointDistance

◆ fCandidateEndGlobalTime

◆ fCurrentTouchableHandle

◆ fEndGlobalTimeComputed

◆ fFieldPropagator

◆ fGeometryLimitedStep

◆ fLinearNavigator

◆ fMagSetup

◆ fMaxEnergyKilled

◆ fMomentumChanged

◆ fNoLooperTrials

◆ fParticleChange

◆ fParticleDef

◆ fParticleIsLooping

◆ fPreviousSafety

◆ fPreviousSftOrigin

◆ fpSafetyHelper

◆ fShortStepOptimisation

◆ fSumEnergyKilled

◆ fThreshold_Important_Energy

◆ fThreshold_Trap_Energy

◆ fThreshold_Warning_Energy

◆ fThresholdTrials

◆ fTransportEndKineticEnergy

◆ fTransportEndMomentumDir

◆ fTransportEndPosition

◆ fTransportEndSpin