#include <MonopoleTransportation.h>

Inheritance diagram for MonopoleTransportation:

Public Member Functions
G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData) override

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

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

G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *) override

void	EnableShortStepOptimisation (G4bool optimise=true)

G4double	GetMaxEnergyKilled () const

G4PropagatorInField *	GetPropagatorInField ()

G4double	GetSumEnergyKilled () const

G4double	GetThresholdImportantEnergy () const

G4int	GetThresholdTrials () const

G4double	GetThresholdWarningEnergy () const

	MonopoleTransportation (const Monopole *p, G4int verbosityLevel=1)

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

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

void	ResetKilledStatistics (G4int report=1)

void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)

void	SetThresholdImportantEnergy (G4double newEnImp)

void	SetThresholdTrials (G4int newMaxTrials)

void	SetThresholdWarningEnergy (G4double newEnWarn)

void	StartTracking (G4Track *aTrack) override

	~MonopoleTransportation () override

Protected Member Functions
G4bool	DoesGlobalFieldExist ()

Private Attributes
G4double	endpointDistance

G4double	fCandidateEndGlobalTime

G4TouchableHandle	fCurrentTouchableHandle

G4bool	fEndGlobalTimeComputed

G4PropagatorInField *	fFieldPropagator

G4bool	fGeometryLimitedStep

CMSFieldManager *	fieldMgrCMS

G4Navigator *	fLinearNavigator

G4double	fMaxEnergyKilled

G4bool	fMomentumChanged

G4int	fNoLooperTrials

G4ParticleChangeForTransport	fParticleChange

const Monopole *	fParticleDef

G4bool	fParticleIsLooping

G4double	fPreviousSafety

G4ThreeVector	fPreviousSftOrigin

G4SafetyHelper *	fpSafetyHelper

G4bool	fShortStepOptimisation

G4double	fSumEnergyKilled

G4double	fThreshold_Important_Energy

G4double	fThreshold_Warning_Energy

G4int	fThresholdTrials

G4double	fTransportEndKineticEnergy

G4ThreeVector	fTransportEndMomentumDir

G4ThreeVector	fTransportEndPosition

G4ThreeVector	fTransportEndSpin

Detailed Description

Definition at line 45 of file MonopoleTransportation.h.

Constructor & Destructor Documentation

MonopoleTransportation::MonopoleTransportation	(	const Monopole *	p,
		G4int	verbosityLevel = `1`
	)

Definition at line 33 of file MonopoleTransportation.cc.

References fCandidateEndGlobalTime, fCurrentTouchableHandle, fEndGlobalTimeComputed, fFieldPropagator, fLinearNavigator, and fpSafetyHelper.

     : G4VProcess(G4String("MonopoleTransportation"), fTransportation),
       fParticleDef(mpl),
       fieldMgrCMS(nullptr),
       fLinearNavigator(nullptr),
       fFieldPropagator(nullptr),
       fParticleIsLooping(false),
       fPreviousSftOrigin(0., 0., 0.),
       fPreviousSafety(0.0),
       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(nullptr) {
   verboseLevel = verb;
 
   // set Process Sub Type
   SetProcessSubType(TRANSPORTATION);
 
 #ifdef G4MULTITHREADED
   // Do not finalize the MonopoleTransportation class
   if (G4Threading::IsMasterThread()) {
     return;
   }
 #endif
 
   G4TransportationManager* transportMgr = G4TransportationManager::GetTransportationManager();
 
   fLinearNavigator = transportMgr->GetNavigatorForTracking();
 
   fFieldPropagator = transportMgr->GetPropagatorInField();
   fpSafetyHelper = transportMgr->GetSafetyHelper();
 
   // 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
 
   fCurrentTouchableHandle = nullptr;
 
   fEndGlobalTimeComputed = false;
   fCandidateEndGlobalTime = 0;
 }

MonopoleTransportation::~MonopoleTransportation ( )

override

Definition at line 83 of file MonopoleTransportation.cc.

References fSumEnergyKilled.

                                                 {
   if ((verboseLevel > 0) && (fSumEnergyKilled > 0.0)) {
     /*
     G4cout << " MonopoleTransportation: 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

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

override

Definition at line 332 of file MonopoleTransportation.cc.

References fCandidateEndGlobalTime, fEndGlobalTimeComputed, fFieldPropagator, fMaxEnergyKilled, fMomentumChanged, fNoLooperTrials, fParticleChange, fParticleIsLooping, fSumEnergyKilled, fThreshold_Important_Energy, fThreshold_Warning_Energy, fThresholdTrials, fTransportEndKineticEnergy, fTransportEndMomentumDir, fTransportEndPosition, fTransportEndSpin, and dcs_trend_monitor_cfg::startTime.

                                                                                                      {
   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 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
     if (finalVelocity > 0.0) {
       G4double meanInverseVelocity;
       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)) {
         G4cout << " MonopoleTransportation is killing track that is looping or stuck " << G4endl << "   This track has "
                << track.GetKineticEnergy() / MeV << " MeV energy." << G4endl;
         G4cout << "   Number of trials = " << fNoLooperTrials << G4endl;
       }
 #endif
       fNoLooperTrials = 0;
     } else {
       fNoLooperTrials++;
 #ifdef G4VERBOSE
       if ((verboseLevel > 2)) {
         G4cout << "   MonopoleTransportation::AlongStepDoIt(): Particle looping -  "
                << "   Number of trials = " << fNoLooperTrials << 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());
 
   return &fParticleChange;
 }

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

override

Definition at line 101 of file MonopoleTransportation.cc.

References CMSFieldManager::ConfigureForTrack(), endpointDistance, fCandidateEndGlobalTime, fEndGlobalTimeComputed, fFieldPropagator, fGeometryLimitedStep, fieldMgrCMS, fLinearNavigator, fMomentumChanged, fParticleChange, fParticleDef, fParticleIsLooping, fPreviousSafety, fPreviousSftOrigin, fpSafetyHelper, fShortStepOptimisation, fTransportEndKineticEnergy, fTransportEndMomentumDir, fTransportEndPosition, fTransportEndSpin, mag(), Monopole::MagneticCharge(), CMSFieldManager::setMonopoleTracking(), sqr(), and mathSSE::sqrt().

                                                                                                    {
   // change to monopole equation
   fieldMgrCMS->setMonopoleTracking(true);
 
   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 G4ThreeVector& startMomentumDir = pParticle->GetMomentumDirection();
   G4ThreeVector startPosition = track.GetPosition();
 
   // 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;
 
   // 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
   G4bool fieldExertsForce = false;
 
   if (particleMagneticCharge != 0.0 && fieldMgrCMS) {
     // Message the field Manager, to configure it for this track
     fieldMgrCMS->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 = (fieldMgrCMS->GetDetectorField() != nullptr);
   }
 
   // G4cout << " G4Transport:  field exerts force= " << fieldExertsForce
   //          << "  fieldMgr= " << fieldMgr << G4endl;
 
   // 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 lengthAlongCurve;
     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 Mev/c
 
     G4EquationOfMotion* equationOfMotion =
         fFieldPropagator->GetChordFinder()->GetIntegrationDriver()->GetEquationOfMotion();
 
     equationOfMotion->SetChargeMomentumMass(chargeState,        //  Was particleMagneticCharge - in Mev/c
                                             momentumMagnitude,  //  Was particleElectricCharge
                                             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)
       //
       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) {
       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 << "***MonopoleTransportation::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);
 
   return geometryStepLength;
 }

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

override

Definition at line 576 of file MonopoleTransportation.cc.

576 { return nullptr; }

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

override

Definition at line 572 of file MonopoleTransportation.cc.

572 { return -1.0; }

G4bool MonopoleTransportation::DoesGlobalFieldExist ( )

inlineprotected

Definition at line 167 of file MonopoleTransportation.h.

Referenced by StartTracking().

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

void MonopoleTransportation::EnableShortStepOptimisation ( G4bool optimise = true )

inline

Definition at line 197 of file MonopoleTransportation.h.

References fShortStepOptimisation.

                                                                                         {
   fShortStepOptimisation = optimiseShortStep;
 }

G4double MonopoleTransportation::GetMaxEnergyKilled ( ) const

inline

Definition at line 193 of file MonopoleTransportation.h.

References fMaxEnergyKilled.

193 { return fMaxEnergyKilled; }

MonopoleTransportation::fMaxEnergyKilled

G4double fMaxEnergyKilled

Definition: MonopoleTransportation.h:152

G4PropagatorInField * MonopoleTransportation::GetPropagatorInField ( )

inline

Definition at line 165 of file MonopoleTransportation.h.

References fFieldPropagator.

165 { return fFieldPropagator; }

MonopoleTransportation::fFieldPropagator

G4PropagatorInField * fFieldPropagator

Definition: MonopoleTransportation.h:110

G4double MonopoleTransportation::GetSumEnergyKilled ( ) const

inline

Definition at line 195 of file MonopoleTransportation.h.

References fSumEnergyKilled.

195 { return fSumEnergyKilled; }

MonopoleTransportation::fSumEnergyKilled

G4double fSumEnergyKilled

Definition: MonopoleTransportation.h:151

G4double MonopoleTransportation::GetThresholdImportantEnergy ( ) const

inline

Definition at line 174 of file MonopoleTransportation.h.

References fThreshold_Important_Energy.

174 { return fThreshold_Important_Energy; }

MonopoleTransportation::fThreshold_Important_Energy

G4double fThreshold_Important_Energy

Definition: MonopoleTransportation.h:142

G4int MonopoleTransportation::GetThresholdTrials ( ) const

inline

Definition at line 176 of file MonopoleTransportation.h.

References fThresholdTrials.

176 { return fThresholdTrials; }

MonopoleTransportation::fThresholdTrials

G4int fThresholdTrials

Definition: MonopoleTransportation.h:143

G4double MonopoleTransportation::GetThresholdWarningEnergy ( ) const

inline

Definition at line 172 of file MonopoleTransportation.h.

References fThreshold_Warning_Energy.

172 { return fThreshold_Warning_Energy; }

MonopoleTransportation::fThreshold_Warning_Energy

G4double fThreshold_Warning_Energy

Definition: MonopoleTransportation.h:141

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

override

Definition at line 443 of file MonopoleTransportation.cc.

References fCurrentTouchableHandle, fGeometryLimitedStep, fieldMgrCMS, fLinearNavigator, fParticleChange, and CMSFieldManager::setMonopoleTracking().

                                                                                            {
   G4TouchableHandle retCurrentTouchable;  // The one to return
 
   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() == nullptr) {
       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();
   const G4Material* pNewMaterial = nullptr;
   G4VSensitiveDetector* pNewSensitiveDetector = nullptr;
 
   if (pNewVol != nullptr) {
     pNewMaterial = pNewVol->GetLogicalVolume()->GetMaterial();
     pNewSensitiveDetector = pNewVol->GetLogicalVolume()->GetSensitiveDetector();
   }
 
   fParticleChange.SetMaterialInTouchable((G4Material*)pNewMaterial);
   fParticleChange.SetSensitiveDetectorInTouchable((G4VSensitiveDetector*)pNewSensitiveDetector);
 
   const G4MaterialCutsCouple* pNewMaterialCutsCouple = nullptr;
   if (pNewVol != nullptr) {
     pNewMaterialCutsCouple = pNewVol->GetLogicalVolume()->GetMaterialCutsCouple();
   }
 
   if (pNewVol != nullptr && pNewMaterialCutsCouple != nullptr &&
       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);
 
   // change to normal equation
   fieldMgrCMS->setMonopoleTracking(false);
 
   return &fParticleChange;
 }

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

override

Definition at line 434 of file MonopoleTransportation.cc.

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

void MonopoleTransportation::ResetKilledStatistics ( G4int report = 1 )

Definition at line 580 of file MonopoleTransportation.cc.

References fMaxEnergyKilled, and fSumEnergyKilled.

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

void MonopoleTransportation::SetPropagatorInField ( G4PropagatorInField * pFieldPropagator )

inline

Definition at line 161 of file MonopoleTransportation.h.

References fFieldPropagator.

                                                                                               {
   fFieldPropagator = pFieldPropagator;
 }

void MonopoleTransportation::SetThresholdImportantEnergy ( G4double newEnImp )

inline

Definition at line 182 of file MonopoleTransportation.h.

References fThreshold_Important_Energy.

                                                                                  {
   fThreshold_Important_Energy = newEnImp;
 }

void MonopoleTransportation::SetThresholdTrials ( G4int newMaxTrials )

inline

Definition at line 186 of file MonopoleTransportation.h.

References fThresholdTrials.

186 { fThresholdTrials = newMaxTrials; }

MonopoleTransportation::fThresholdTrials

G4int fThresholdTrials

Definition: MonopoleTransportation.h:143

void MonopoleTransportation::SetThresholdWarningEnergy ( G4double newEnWarn )

inline

Definition at line 178 of file MonopoleTransportation.h.

References fThreshold_Warning_Energy.

                                                                                 {
   fThreshold_Warning_Energy = newEnWarn;
 }

void MonopoleTransportation::StartTracking ( G4Track * aTrack )

override

Definition at line 528 of file MonopoleTransportation.cc.

References DoesGlobalFieldExist(), fCurrentTouchableHandle, fFieldPropagator, fieldMgrCMS, fNoLooperTrials, fPreviousSafety, and fPreviousSftOrigin.

                                                           {
   // initialise pointer
   if (!fieldMgrCMS) {
     G4FieldManager* fieldMgr = fFieldPropagator->FindAndSetFieldManager(aTrack->GetVolume());
     fieldMgrCMS = static_cast<CMSFieldManager*>(fieldMgr);
   }
 
   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
 
   // 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* fieldMgrStore = G4FieldManagerStore::GetInstance();
   fieldMgrStore->ClearAllChordFindersState();
 
   // Update the current touchable handle  (from the track's)
   //
   fCurrentTouchableHandle = aTrack->GetTouchableHandle();
 }