MonopoleTransportation Class Reference

#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::MonopoleTransportation	(	const Monopole *	p,
		G4int	verbosityLevel = 1
	)

Definition at line 33 of file MonopoleTransportation.cc.

References fCandidateEndGlobalTime, fCurrentTouchableHandle, fEndGlobalTimeComputed, fFieldPropagator, fLinearNavigator, fpSafetyHelper, and HLT_2024v14_cff::verboseLevel.

    : 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 * CLHEP::MeV),
      fThreshold_Important_Energy(250 * CLHEP::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::~MonopoleTransportation ( )

override

Definition at line 83 of file MonopoleTransportation.cc.

References fSumEnergyKilled, and HLT_2024v14_cff::verboseLevel.

                                                {
  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

AlongStepDoIt()

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, ecalTB2006H4_GenSimDigiReco_cfg::G4cout, beamSpotPI::startTime, HLT_2024v14_cff::track, and HLT_2024v14_cff::verboseLevel.

                                                                                                     {
  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() / CLHEP::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;
}

AlongStepGetPhysicalInteractionLength()

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, ecalTB2006H4_GenSimDigiReco_cfg::G4cout, mag(), Monopole::MagneticCharge(), corrVsCorr::selection, CMSFieldManager::setMonopoleTracking(), funct::sqr(), mathSSE::sqrt(), and HLT_2024v14_cff::track.

                                                                                                   {
  // 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;
}

AtRestDoIt()

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

override

Definition at line 576 of file MonopoleTransportation.cc.

{ return nullptr; }

AtRestGetPhysicalInteractionLength()

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

override

Definition at line 572 of file MonopoleTransportation.cc.

{ return -1.0; }

DoesGlobalFieldExist()

G4bool MonopoleTransportation::DoesGlobalFieldExist ( )

inlineprotected

Definition at line 167 of file MonopoleTransportation.h.

Referenced by StartTracking().

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

EnableShortStepOptimisation()

void MonopoleTransportation::EnableShortStepOptimisation ( G4bool  optimise = true )

inline

Definition at line 197 of file MonopoleTransportation.h.

References fShortStepOptimisation.

                                                                                        {
  fShortStepOptimisation = optimiseShortStep;
}

GetMaxEnergyKilled()

G4double MonopoleTransportation::GetMaxEnergyKilled ( ) const

inline

Definition at line 193 of file MonopoleTransportation.h.

References fMaxEnergyKilled.

{ return fMaxEnergyKilled; }

GetPropagatorInField()

G4PropagatorInField * MonopoleTransportation::GetPropagatorInField ( )

inline

Definition at line 165 of file MonopoleTransportation.h.

References fFieldPropagator.

{ return fFieldPropagator; }

GetSumEnergyKilled()

G4double MonopoleTransportation::GetSumEnergyKilled ( ) const

inline

Definition at line 195 of file MonopoleTransportation.h.

References fSumEnergyKilled.

{ return fSumEnergyKilled; }

GetThresholdImportantEnergy()

G4double MonopoleTransportation::GetThresholdImportantEnergy ( ) const

inline

Definition at line 174 of file MonopoleTransportation.h.

References fThreshold_Important_Energy.

{ return fThreshold_Important_Energy; }

GetThresholdTrials()

G4int MonopoleTransportation::GetThresholdTrials ( ) const

inline

Definition at line 176 of file MonopoleTransportation.h.

References fThresholdTrials.

{ return fThresholdTrials; }

GetThresholdWarningEnergy()

G4double MonopoleTransportation::GetThresholdWarningEnergy ( ) const

inline

Definition at line 172 of file MonopoleTransportation.h.

References fThreshold_Warning_Energy.

{ return fThreshold_Warning_Energy; }

PostStepDoIt()

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

override

Definition at line 443 of file MonopoleTransportation.cc.

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

                                                                                           {
  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;
}

PostStepGetPhysicalInteractionLength()

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
}

ResetKilledStatistics()

void MonopoleTransportation::ResetKilledStatistics

(

G4int

report = 1

)

Definition at line 580 of file MonopoleTransportation.cc.

References fMaxEnergyKilled, fSumEnergyKilled, ecalTB2006H4_GenSimDigiReco_cfg::G4cout, and edmIntegrityCheck::report.

{
  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;
}

SetPropagatorInField()

void MonopoleTransportation::SetPropagatorInField ( G4PropagatorInField *  pFieldPropagator )

inline

Definition at line 161 of file MonopoleTransportation.h.

References fFieldPropagator.

                                                                                              {
  fFieldPropagator = pFieldPropagator;
}

SetThresholdImportantEnergy()

void MonopoleTransportation::SetThresholdImportantEnergy ( G4double  newEnImp )

inline

Definition at line 182 of file MonopoleTransportation.h.

References fThreshold_Important_Energy.

                                                                                 {
  fThreshold_Important_Energy = newEnImp;
}

SetThresholdTrials()

void MonopoleTransportation::SetThresholdTrials ( G4int  newMaxTrials )

inline

Definition at line 186 of file MonopoleTransportation.h.

References fThresholdTrials.

{ fThresholdTrials = newMaxTrials; }

SetThresholdWarningEnergy()

void MonopoleTransportation::SetThresholdWarningEnergy ( G4double  newEnWarn )

inline

Definition at line 178 of file MonopoleTransportation.h.

References fThreshold_Warning_Energy.

                                                                                {
  fThreshold_Warning_Energy = newEnWarn;
}

StartTracking()

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();
}

Member Data Documentation

endpointDistance

G4double MonopoleTransportation::endpointDistance

private

Definition at line 137 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength().

fCandidateEndGlobalTime

G4double MonopoleTransportation::fCandidateEndGlobalTime

private

Definition at line 120 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), and MonopoleTransportation().

fCurrentTouchableHandle

G4TouchableHandle MonopoleTransportation::fCurrentTouchableHandle

private

Definition at line 125 of file MonopoleTransportation.h.

Referenced by MonopoleTransportation(), PostStepDoIt(), and StartTracking().

fEndGlobalTimeComputed

G4bool MonopoleTransportation::fEndGlobalTimeComputed

private

Definition at line 119 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), and MonopoleTransportation().

fFieldPropagator

G4PropagatorInField* MonopoleTransportation::fFieldPropagator

private

Definition at line 110 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), GetPropagatorInField(), MonopoleTransportation(), SetPropagatorInField(), and StartTracking().

fGeometryLimitedStep

G4bool MonopoleTransportation::fGeometryLimitedStep

private

Definition at line 127 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength(), and PostStepDoIt().

fieldMgrCMS

CMSFieldManager* MonopoleTransportation::fieldMgrCMS

private

Definition at line 107 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength(), PostStepDoIt(), and StartTracking().

fLinearNavigator

G4Navigator* MonopoleTransportation::fLinearNavigator

private

Definition at line 109 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength(), MonopoleTransportation(), and PostStepDoIt().

fMaxEnergyKilled

G4double MonopoleTransportation::fMaxEnergyKilled

private

Definition at line 152 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), GetMaxEnergyKilled(), and ResetKilledStatistics().

fMomentumChanged

G4bool MonopoleTransportation::fMomentumChanged

private

Definition at line 117 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fNoLooperTrials

G4int MonopoleTransportation::fNoLooperTrials

private

Definition at line 149 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), and StartTracking().

fParticleChange

G4ParticleChangeForTransport MonopoleTransportation::fParticleChange

private

Definition at line 134 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), and PostStepDoIt().

fParticleDef

const Monopole* MonopoleTransportation::fParticleDef

private

Definition at line 105 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength().

fParticleIsLooping

G4bool MonopoleTransportation::fParticleIsLooping

private

Definition at line 123 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fPreviousSafety

G4double MonopoleTransportation::fPreviousSafety

private

Definition at line 131 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength(), and StartTracking().

fPreviousSftOrigin

G4ThreeVector MonopoleTransportation::fPreviousSftOrigin

private

Definition at line 130 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength(), and StartTracking().

fpSafetyHelper

G4SafetyHelper* MonopoleTransportation::fpSafetyHelper

private

Definition at line 158 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength(), and MonopoleTransportation().

fShortStepOptimisation

G4bool MonopoleTransportation::fShortStepOptimisation

private

Definition at line 156 of file MonopoleTransportation.h.

Referenced by AlongStepGetPhysicalInteractionLength(), and EnableShortStepOptimisation().

fSumEnergyKilled

G4double MonopoleTransportation::fSumEnergyKilled

private

Definition at line 151 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), GetSumEnergyKilled(), ResetKilledStatistics(), and ~MonopoleTransportation().

fThreshold_Important_Energy

G4double MonopoleTransportation::fThreshold_Important_Energy

private

Definition at line 142 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), GetThresholdImportantEnergy(), and SetThresholdImportantEnergy().

fThreshold_Warning_Energy

G4double MonopoleTransportation::fThreshold_Warning_Energy

private

Definition at line 141 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), GetThresholdWarningEnergy(), and SetThresholdWarningEnergy().

fThresholdTrials

G4int MonopoleTransportation::fThresholdTrials

private

Definition at line 143 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), GetThresholdTrials(), and SetThresholdTrials().

fTransportEndKineticEnergy

G4double MonopoleTransportation::fTransportEndKineticEnergy

private

Definition at line 115 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fTransportEndMomentumDir

G4ThreeVector MonopoleTransportation::fTransportEndMomentumDir

private

Definition at line 114 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fTransportEndPosition

G4ThreeVector MonopoleTransportation::fTransportEndPosition

private

Definition at line 113 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().

fTransportEndSpin

G4ThreeVector MonopoleTransportation::fTransportEndSpin

private

Definition at line 116 of file MonopoleTransportation.h.

Referenced by AlongStepDoIt(), and AlongStepGetPhysicalInteractionLength().