#include <G4mplAtlasTransportation.h>

Inheritance diagram for G4mplAtlasTransportation:

Collaboration diagram for G4mplAtlasTransportation:

Public Member Functions
	G4mplAtlasTransportation (const CustomMonopole *p, G4int verbosityLevel=1)
	~G4mplAtlasTransportation ()
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)
G4PropagatorInField *	GetPropagatorInField ()
void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)
void	SetVerboseLevel (G4int verboseLevel)
G4int	GetVerboseLevel () const
G4double	GetThresholdWarningEnergy () const
G4double	GetThresholdImportantEnergy () const
G4int	GetThresholdTrials () const
void	SetThresholdWarningEnergy (G4double newEnWarn)
void	SetThresholdImportantEnergy (G4double newEnImp)
void	SetThresholdTrials (G4int newMaxTrials)
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)
void	EndTracking ()

Protected Member Functions
G4bool	DoesGlobalFieldExist ()

Private Attributes
const CustomMonopole *	mplParticle
G4Navigator *	fLinearNavigator
G4PropagatorInField *	fFieldPropagator
G4ThreeVector	fTransportEndPosition
G4ThreeVector	fTransportEndMomentumDir
G4double	fTransportEndKineticEnergy
G4ThreeVector	fTransportEndSpin
G4bool	fMomentumChanged
G4bool	fEndGlobalTimeComputed
G4double	fCandidateEndGlobalTime
G4bool	fParticleIsLooping
G4TouchableHandle	fCurrentTouchableHandle
G4bool	fGeometryLimitedStep
G4ThreeVector	fPreviousSftOrigin
G4double	fPreviousSafety
G4ParticleChangeForTransport	fParticleChange
G4double	endpointDistance
G4double	fThreshold_Warning_Energy
G4double	fThreshold_Important_Energy
G4int	fThresholdTrials
G4int	fNoLooperTrials
G4double	fSumEnergyKilled
G4double	fMaxEnergyKilled
G4bool	fShortStepOptimisation
G4SafetyHelper *	fpSafetyHelper
G4int	fVerboseLevel
G4double	accumLength
G4mplEquationSetup *	fEquationSetup

Detailed Description

Definition at line 71 of file G4mplAtlasTransportation.h.

Constructor & Destructor Documentation

◆ G4mplAtlasTransportation()

G4mplAtlasTransportation::G4mplAtlasTransportation	(	const CustomMonopole *	p,
		G4int	verbosityLevel = 1 )

Definition at line 89 of file G4mplAtlasTransportation.cxx.

  : G4VProcess( G4String("mplAtlasTransportation"), fTransportation ),
    fTransportEndKineticEnergy (0.),
    fMomentumChanged( false ),
    //fEnergyChanged( false ), // Not used?
    fParticleIsLooping( false ),
    fCurrentTouchableHandle(),  // Points to (G4VTouchable*) 0
    fGeometryLimitedStep( false ),
    fPreviousSftOrigin (0.,0.,0.),
    fPreviousSafety    ( 0.0 ),
    endpointDistance   ( 0.0 ),
    fThreshold_Warning_Energy( 100 * CLHEP::MeV ),
    fThreshold_Important_Energy( 250 * CLHEP::MeV ),
    fThresholdTrials( 10 ),
    //fUnimportant_Energy( 1 * CLHEP::MeV ), // Not used?
    fNoLooperTrials(0),
    fSumEnergyKilled( 0.0 ), fMaxEnergyKilled( 0.0 ),
    fShortStepOptimisation(false),    // Old default: true (=fast short steps)
    fVerboseLevel( verboseLevel ),
    accumLength (0.0)
{
 
  mplParticle = mpl;
 
  G4TransportationManager* transportMgr ;
 
  G4cout << "!!! G4mplAtlasTransportation constructor " << G4endl;
 
  transportMgr = G4TransportationManager::GetTransportationManager() ;
 
  fLinearNavigator = transportMgr->GetNavigatorForTracking() ;
 
  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
 
  // Create object which sets up the equation of motion for monopole
  // or usual matter
  fEquationSetup= G4mplEquationSetup::GetInstance();
 
  fEndGlobalTimeComputed  = false;
  fCandidateEndGlobalTime = 0;
}

◆ ~G4mplAtlasTransportation()

G4mplAtlasTransportation::~G4mplAtlasTransportation ( )

Definition at line 141 of file G4mplAtlasTransportation.cxx.

{
  G4cout << "!!! G4mplAtlasTransportation destructor " << G4endl;
 
  if( (fVerboseLevel > 0) && (fSumEnergyKilled > 0.0 ) ){
    G4cout << " G4mplAtlasTransportation: Statistics for looping particles " << G4endl;
    G4cout << "   Sum of energy of loopers killed: " <<  fSumEnergyKilled << G4endl;
    G4cout << "   Max energy of loopers killed: " <<  fMaxEnergyKilled << G4endl;
  }
}

Member Function Documentation

◆ AlongStepDoIt()

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

Definition at line 540 of file G4mplAtlasTransportation.cxx.

{
#ifdef G4VERBOSE
  static std::atomic<G4int> noCalls=0;
  noCalls++;
#endif
 
  static const G4ParticleDefinition* const fOpticalPhoton =
           G4ParticleTable::GetParticleTable()->FindParticle("opticalphoton");
 
  //  G4cout << "SB:  G4mplAtlasTransportation:  AlongStepDoIt" << G4endl;
 
  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() ;
//   G4cout << "SB:  G4mplAtlasTransportation:  startTime=" <<  startTime
//       <<"  fEndGlobalTimeComputed="<< fEndGlobalTimeComputed
//       <<"  fCandidateEndGlobalTime="<< fCandidateEndGlobalTime
//       << G4endl;
 
  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() ) ;
 
//   G4cout << "SB:  G4mplAtlasTransportation:  deltaTime=" <<  deltaTime
//       <<"  deltaProperTime="<< deltaProperTime
//       <<"  fCandidateEndGlobalTime="<< fCandidateEndGlobalTime
//       <<"  fParticleIsLooping="<< fParticleIsLooping
//       << G4endl;
 
  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 ...
  //
//   fParticleIsLooping = true;
 
  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( (fVerboseLevel > 1) ||
            ( endEnergy > fThreshold_Warning_Energy )  ) {
          G4cout << " G4mplAtlasTransportation is killing track that is looping or stuck "
                 << G4endl
                 << "   This track has " << track.GetKineticEnergy() / CLHEP::MeV
                 << " MeV energy." << G4endl;
          G4cout << "   Number of trials = " << fNoLooperTrials
                 << "   No of calls to AlongStepDoIt = " << noCalls
                 << G4endl;
        }
#endif
        fNoLooperTrials=0;
      }
      else{
        fNoLooperTrials ++;
#ifdef G4VERBOSE
        if( (fVerboseLevel > 2) ){
          G4cout << "   G4mplAtlasTransportation::AlongStepDoIt(): Particle looping -  "
                 << "   Number of trials = " << fNoLooperTrials
                 << "   No of calls to  = " << noCalls
                 << G4endl;
        }
#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() );
 
  if (track.GetStepLength() < 0){ // Issue with interpolation in Geant4 range table can cause negative step lengths specifically for dyons
     fParticleChange.ProposeTrackStatus( fStopAndKill ) ; // to avoid crash, kill particle before this happens since negative step length has no physical meaning
     G4cout << "Warning HIP Killed due to negative step length" << G4endl;
  }
  return &fParticleChange ;
}

◆ AlongStepGetPhysicalInteractionLength()

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

Definition at line 159 of file G4mplAtlasTransportation.cxx.

{
  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() ;
  const G4ParticleDefinition* pParticleDef   = pParticle->GetDefinition() ;
  const 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 particle charged ?
  //
  G4double   particleMagCharge = mplParticle->MagneticCharge();
  G4double   particleElCharge = pParticle->GetCharge() ;
 
//   G4cout << "SB:  G4mplAtlasTransportation:  charge=" << particleCharge
//       << " mass=" << pParticle->GetMass()
//       << "  PDG=" << pParticle->GetPDGcode() << G4endl;
 
  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 has an (EM) field force exerting upon it
  //
  G4FieldManager* fieldMgr=0;
  G4bool          fieldExertsForce = false ;
  if( (particleElCharge != 0.0) || (particleMagCharge!=0.0) )        //  SB
  {
     G4FieldManager* oldFieldMgr= fFieldPropagator->GetCurrentFieldManager();
 
     fieldMgr= fFieldPropagator->FindAndSetFieldManager( track.GetVolume() );
 
     // if fieldMgr changed, need to flush it's association with our ChordFinder
     //     and then below to update stepper and chord finder
     if (fieldMgr != oldFieldMgr) {
        fEquationSetup->ResetIntegration( oldFieldMgr );
        // Now ensure that it is configured for the new field-manager
        fEquationSetup->InitialiseForField( fieldMgr );
     }
 
     if (fieldMgr != nullptr) {
        // 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 (particleMagCharge!=0.0) fieldMgr->SetFieldChangesEnergy(true);
 
        // If the field manager has no field, there is no field !
        fieldExertsForce = (fieldMgr->GetDetectorField() != nullptr);
 
        if( fieldExertsForce)
          fEquationSetup->SwitchStepperAndChordFinder( (particleMagCharge != 0.0), fieldMgr );
        // else ...
        // Is there extra safety measure to take if the fieldMgr has no field attached ??
     }
     // oldFieldMgr= fieldMgr;
  }
 
  // 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
  {
     G4ThreeVector  EndUnitMomentum ;
     G4double       lengthAlongCurve ;
     G4double       restMass = pParticleDef->GetPDGMass() ;
#if G4VERSION_NUMBER > 1009
     G4double       momentumMagnitude = pParticle->GetTotalMomentum();
     G4ChargeState  chargeState(particleElCharge,    // in e+ units
                                pParticleDef->GetPDGSpin(),
                                0,
                                0,
                                particleMagCharge); // in e+ units
     G4EquationOfMotion* equationOfMotion = (fFieldPropagator->GetChordFinder()->GetIntegrationDriver()->GetStepper())->GetEquationOfMotion();
     equationOfMotion->SetChargeMomentumMass(chargeState,
                                             momentumMagnitude,
                                             -restMass           ); // to distinguish between the monopoles and ordinary particles
#else
     fFieldPropagator->SetChargeMomentumMass( particleElCharge,  // in e+ units
                                              particleMagCharge, // in e+ units
                                              -restMass           ); // to distinguish between the monopoles and ordinary particles
#endif
 
     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)
         //
 
         lengthAlongCurve = fFieldPropagator->ComputeStep( aFieldTrack,
                                                           currentMinimumStep,
                                                           currentSafety,
                                                           track.GetVolume() ) ;
         fGeometryLimitedStep= lengthAlongCurve < currentMinimumStep;
         if( fGeometryLimitedStep ) {
           geometryStepLength   = lengthAlongCurve ;
         } else {
           geometryStepLength   = currentMinimumStep ;
         }
       }
     else
       {
         geometryStepLength   = lengthAlongCurve= 0.0 ;
         fGeometryLimitedStep = false ;
       }
     accumLength += lengthAlongCurve;
 
     // 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() ;
 
     if( fFieldPropagator->GetCurrentFieldManager()->DoesFieldChangeEnergy())
       {
         // If the field can change energy, then the time must be integrated
         //    - so this should have been updated
         //
         fCandidateEndGlobalTime   = aFieldTrack.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;
 
         // Check that the integration preserved the energy
         //     -  and if not correct this!
         G4double  startEnergy= track.GetKineticEnergy();
         G4double  endEnergy= fTransportEndKineticEnergy;
 
         static std::atomic<G4int> no_inexact_steps=0, no_large_ediff;
         G4double absEdiff = std::fabs(startEnergy- endEnergy);
         if( absEdiff > CLHEP::perMillion * endEnergy )
           {
             no_inexact_steps++;
             // Possible statistics keeping here ...
           }
         if( fVerboseLevel > 1 )
           {
             if( std::fabs(startEnergy- endEnergy) > CLHEP::perThousand * endEnergy )
               {
                 static std::atomic<G4int> no_warnings= 0, warnModulo=1,  moduloFactor= 10;
                 no_large_ediff ++;
                 if( (no_large_ediff% warnModulo) == 0 )
                   {
                     no_warnings++;
                     G4cout << "WARNING - G4mplAtlasTransportation::AlongStepGetPIL() "
                            << "   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 / CLHEP::MeV << " MeV " << G4endl
                            << "     Ending   E= " << std::setw(12) << endEnergy   / CLHEP::MeV << " MeV " << G4endl;
                     G4cout << " Energy has been corrected -- however, review"
                            << " field propagation parameters for accuracy."  << G4endl;
                     if( (fVerboseLevel > 2 ) || (no_warnings<4) || (no_large_ediff == warnModulo * moduloFactor) ){
                       G4cout << " These include EpsilonStepMax(/Min) in G4FieldManager "
                              << " which determine fractional error per step for integrated quantities. " << G4endl
                              << " Note also the influence of the permitted number of integration steps."
                              << G4endl;
                     }
                     G4cerr << "ERROR - G4mplAtlasTransportation::AlongStepGetPIL()" << G4endl
                            << "        Bad 'endpoint'. Energy change detected"
                            << " and corrected. "
                            << " Has occurred already "
                            << no_large_ediff << " times." << G4endl;
                     if( no_large_ediff == warnModulo * moduloFactor )
                       {
                         warnModulo = warnModulo * moduloFactor;
                       }
                   }
               }
           }  // end of if (fVerboseLevel)
 
              // Correct the energy for fields that conserve it
              //  This - hides the integration error
         //       - but gives a better physical answer
         fTransportEndKineticEnergy= track.GetKineticEnergy();
       }
 
     fTransportEndSpin = aFieldTrack.GetSpin();
     fParticleIsLooping = fFieldPropagator->IsParticleLooping() ;
     endpointDistance   = (fTransportEndPosition - startPosition).mag() ;
 
     fieldMgr->SetFieldChangesEnergy(false);
 
  }
 
  // 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( particleCharge == 0.0 )
      //    G4cout  << "  Avoiding call to ComputeSafety : charge = 0.0 " << G4endl;
 
//       if( particleCharge != 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 << "***G4mplAtlasTransportation::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
//       }
    }
 
  //  if (accumLength > 10.0){
  if (accumLength > 1.0){
    //  if (fCandidateEndGlobalTime > 7.5){
      //    G4cout<<fCandidateEndGlobalTime<<" "
 
//     to<<fCandidateEndGlobalTime<<" "
//       <<fTransportEndKineticEnergy<<" "
//       << startPosition[0]<< " "
//       << startPosition[1] << " "
//       << startPosition[2] << " "
//       <<fTransportEndMomentumDir[0]<<" "
//       <<fTransportEndMomentumDir[1]<<" "
//       <<fTransportEndMomentumDir[2]<<" "
//       << fTransportEndPosition[0]<< "  "
//       << fTransportEndPosition[1] << "  "
//       << fTransportEndPosition[2] << "  "
//       << (track.GetVolume())->GetName()
//       << std::endl;
    //    << G4endl;
 
    accumLength = 0.0;
  }
  fParticleChange.ProposeTrueStepLength(geometryStepLength) ;
 
  return geometryStepLength ;
}

◆ AtRestDoIt()

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

inline

Definition at line 145 of file G4mplAtlasTransportation.h.

148 {return 0;};

◆ AtRestGetPhysicalInteractionLength()

G4double G4mplAtlasTransportation::AtRestGetPhysicalInteractionLength	(	const G4Track &	,
		G4ForceCondition *	)

inline

Definition at line 139 of file G4mplAtlasTransportation.h.

142 { return -1.0; };

◆ DoesGlobalFieldExist()

G4bool G4mplAtlasTransportation::DoesGlobalFieldExist ( )

protected

◆ EnableShortStepOptimisation()

void G4mplAtlasTransportation::EnableShortStepOptimisation ( G4bool optimise = true )

inline

◆ EndTracking()

void G4mplAtlasTransportation::EndTracking ( )

Definition at line 862 of file G4mplAtlasTransportation.cxx.

{
  G4VProcess::EndTracking();
  fEquationSetup->ResetIntegration( fFieldPropagator->GetCurrentFieldManager() );
}

◆ GetMaxEnergyKilled()

G4double G4mplAtlasTransportation::GetMaxEnergyKilled ( ) const

inline

◆ GetPropagatorInField()

G4PropagatorInField * G4mplAtlasTransportation::GetPropagatorInField ( )

◆ GetSumEnergyKilled()

G4double G4mplAtlasTransportation::GetSumEnergyKilled ( ) const

inline

◆ GetThresholdImportantEnergy()

G4double G4mplAtlasTransportation::GetThresholdImportantEnergy ( ) const

inline

◆ GetThresholdTrials()

G4int G4mplAtlasTransportation::GetThresholdTrials ( ) const

inline

◆ GetThresholdWarningEnergy()

G4double G4mplAtlasTransportation::GetThresholdWarningEnergy ( ) const

inline

◆ GetVerboseLevel()

G4int G4mplAtlasTransportation::GetVerboseLevel ( ) const

inline

◆ PostStepDoIt()

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

Definition at line 709 of file G4mplAtlasTransportation.cxx.

{
  G4TouchableHandle retCurrentTouchable ;   // The one to return
 
  //  G4cout << "SB:  G4mplAtlasTransportation:  PostStepDoIt" << G4endl;
 
 
  // 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   = 0 ;
  G4VSensitiveDetector* pNewSensitiveDetector   = 0 ;
 
  if( pNewVol != 0 )
  {
    pNewMaterial= pNewVol->GetLogicalVolume()->GetMaterial();
    pNewSensitiveDetector= pNewVol->GetLogicalVolume()->GetSensitiveDetector();
  }
 
  // ( <const_cast> pNewMaterial ) ;
  // ( <const_cast> pNewSensitiveDetector) ;
 
  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 G4mplAtlasTransportation::PostStepGetPhysicalInteractionLength	(	const G4Track &	,
		G4double	previousStepSize,
		G4ForceCondition *	pForceCond )

Definition at line 697 of file G4mplAtlasTransportation.cxx.

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

◆ ResetKilledStatistics()

void G4mplAtlasTransportation::ResetKilledStatistics ( G4int report = 1 )

inline

◆ SetPropagatorInField()

void G4mplAtlasTransportation::SetPropagatorInField ( G4PropagatorInField * pFieldPropagator )

◆ SetThresholdImportantEnergy()

void G4mplAtlasTransportation::SetThresholdImportantEnergy ( G4double newEnImp )

inline

◆ SetThresholdTrials()

void G4mplAtlasTransportation::SetThresholdTrials ( G4int newMaxTrials )

inline

◆ SetThresholdWarningEnergy()

void G4mplAtlasTransportation::SetThresholdWarningEnergy ( G4double newEnWarn )

inline

◆ SetVerboseLevel()

void G4mplAtlasTransportation::SetVerboseLevel ( G4int verboseLevel )

inline

◆ StartTracking()

void G4mplAtlasTransportation::StartTracking ( G4Track * aTrack )

Definition at line 811 of file G4mplAtlasTransportation.cxx.

{
  G4VProcess::StartTracking(aTrack);
 
  //  G4cout << "SB:  G4mplAtlasTransportation:  StartTracking" << G4endl;
 
  // 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)
  G4FieldManagerStore::GetInstance()->ClearAllChordFindersState();
 
  // Set up the Field Propagation to integrate time in case of magnetic charge
  G4double   particleMagCharge = mplParticle->MagneticCharge();
 
  // To be certain that equations etc are created *after* the field managers (global + other/s)
  //   are constructed and registered, we initialise here.
  G4FieldManager* fieldMgr= fFieldPropagator->GetCurrentFieldManager();
 
  // Set up the equation of motion for monopole  
  fEquationSetup->InitialiseForField( fieldMgr );
 
  fEquationSetup->SwitchStepperAndChordFinder( (particleMagCharge != 0.0), fieldMgr );
  //  If local fields exist, this done again for each local field manager, 
  //   when the track enters a volume which has it.
 
  // Update the current touchable handle  (from the track's)
  //
  fCurrentTouchableHandle = aTrack->GetTouchableHandle();
}