G4TransportationWithMsc Class Reference

#include <G4TransportationWithMsc.hh>

Inheritance diagram for G4TransportationWithMsc:

Public Types
enum class	ScatteringType { MultipleScattering }

Public Member Functions
	G4TransportationWithMsc (ScatteringType type, G4int verbosity=0)
	~G4TransportationWithMsc () override
void	SetMultipleSteps (G4bool val)
G4bool	MultipleSteps () const
void	AddMscModel (G4VMscModel *mscModel, G4int order=0, const G4Region *region=nullptr)
void	PreparePhysicsTable (const G4ParticleDefinition &part) override
void	BuildPhysicsTable (const G4ParticleDefinition &part) override
void	StartTracking (G4Track *track) override
G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection) override
Public Member Functions inherited from G4Transportation
	G4Transportation (G4int verbosityLevel=1, const G4String &aName="Transportation")
	~G4Transportation ()
G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)
G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)
G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)
G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4ForceCondition *pForceCond)
G4bool	FieldExertedForce ()
G4PropagatorInField *	GetPropagatorInField ()
void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)
G4double	GetThresholdWarningEnergy () const
G4double	GetThresholdImportantEnergy () const
G4int	GetThresholdTrials () const
void	SetThresholdWarningEnergy (G4double newEnWarn)
void	SetThresholdImportantEnergy (G4double newEnImp)
void	SetThresholdTrials (G4int newMaxTrials)
void	SetHighLooperThresholds ()
void	SetLowLooperThresholds ()
void	PushThresholdsToLogger ()
void	ReportLooperThresholds ()
G4double	GetMaxEnergyKilled () const
G4double	GetSumEnergyKilled () const
void	ResetKilledStatistics (G4int report=1)
void	EnableShortStepOptimisation (G4bool optimise=true)
G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
void	StartTracking (G4Track *aTrack)
virtual void	ProcessDescription (std::ostream &outFile) const
void	PrintStatistics (std::ostream &outStr) const
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4VProcess &	operator= (const G4VProcess &)=delete
G4bool	operator== (const G4VProcess &right) const
G4bool	operator!= (const G4VProcess &right) const
virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0
G4double	GetCurrentInteractionLength () const
void	SetPILfactor (G4double value)
G4double	GetPILfactor () const
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4bool	IsApplicable (const G4ParticleDefinition &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
const G4String &	GetProcessName () const
G4ProcessType	GetProcessType () const
void	SetProcessType (G4ProcessType)
G4int	GetProcessSubType () const
void	SetProcessSubType (G4int)
virtual const G4VProcess *	GetCreatorProcess () const
virtual void	StartTracking (G4Track *)
virtual void	EndTracking ()
virtual void	SetProcessManager (const G4ProcessManager *)
virtual const G4ProcessManager *	GetProcessManager ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4double	GetNumberOfInteractionLengthLeft () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4bool	isAtRestDoItIsEnabled () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
virtual void	DumpInfo () const
virtual void	ProcessDescription (std::ostream &outfile) const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
virtual void	SetMasterProcess (G4VProcess *masterP)
const G4VProcess *	GetMasterProcess () const
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Additional Inherited Members
Static Public Member Functions inherited from G4Transportation
static G4bool	EnableMagneticMoment (G4bool useMoment=true)
static G4bool	EnableGravity (G4bool useGravity=true)
static void	SetSilenceLooperWarnings (G4bool val)
static G4bool	GetSilenceLooperWarnings ()
static G4bool	EnableUseMagneticMoment (G4bool useMoment=true)
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)
Protected Member Functions inherited from G4Transportation
void	SetTouchableInformation (const G4TouchableHandle &touchable)
void	ReportMissingLogger (const char *methodName)
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
void	ClearNumberOfInteractionLengthLeft ()
Protected Attributes inherited from G4Transportation
G4Navigator *	fLinearNavigator
G4PropagatorInField *	fFieldPropagator
G4ThreeVector	fTransportEndPosition = G4ThreeVector( 0.0, 0.0, 0.0 )
G4ThreeVector	fTransportEndMomentumDir = G4ThreeVector( 0.0, 0.0, 0.0 )
G4double	fTransportEndKineticEnergy = 0.0
G4ThreeVector	fTransportEndSpin = G4ThreeVector( 0.0, 0.0, 0.0 )
G4bool	fMomentumChanged = true
G4bool	fEndGlobalTimeComputed = false
G4double	fCandidateEndGlobalTime = 0.0
G4bool	fAnyFieldExists = false
G4bool	fParticleIsLooping = false
G4bool	fNewTrack = true
G4bool	fFirstStepInVolume = true
G4bool	fLastStepInVolume = false
G4bool	fGeometryLimitedStep = true
G4bool	fFieldExertedForce = false
G4TouchableHandle	fCurrentTouchableHandle
G4ThreeVector	fPreviousSftOrigin
G4double	fPreviousSafety
G4ParticleChangeForTransport	fParticleChange
G4double	fEndPointDistance
G4double	fThreshold_Warning_Energy = 1.0 * CLHEP::keV
G4double	fThreshold_Important_Energy = 1.0 * CLHEP::MeV
G4int	fThresholdTrials = 10
G4int	fAbandonUnstableTrials = 0
G4int	fNoLooperTrials = 0
G4double	fSumEnergyKilled = 0.0
G4double	fSumEnerSqKilled = 0.0
G4double	fMaxEnergyKilled = -1.0
G4int	fMaxEnergyKilledPDG = 0
unsigned long	fNumLoopersKilled = 0
G4double	fSumEnergyKilled_NonElectron = 0.0
G4double	fSumEnerSqKilled_NonElectron = 0.0
G4double	fMaxEnergyKilled_NonElectron = -1.0
G4int	fMaxEnergyKilled_NonElecPDG = 0
unsigned long	fNumLoopersKilled_NonElectron = 0
G4double	fSumEnergySaved = 0.0
G4double	fMaxEnergySaved = -1.0
G4double	fSumEnergyUnstableSaved = 0.0
G4bool	fShortStepOptimisation
G4SafetyHelper *	fpSafetyHelper
G4TransportationLogger *	fpLogger
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr
G4VParticleChange *	pParticleChange = nullptr
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft = -1.0
G4double	currentInteractionLength = -1.0
G4double	theInitialNumberOfInteractionLength = -1.0
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType = fNotDefined
G4int	theProcessSubType = -1
G4double	thePILfactor = 1.0
G4int	verboseLevel = 0
G4bool	enableAtRestDoIt = true
G4bool	enableAlongStepDoIt = true
G4bool	enablePostStepDoIt = true
Static Protected Attributes inherited from G4Transportation
static G4bool	fUseMagneticMoment =false
static G4bool	fUseGravity = false
static G4bool	fSilenceLooperWarnings = false

Detailed Description

Definition at line 50 of file G4TransportationWithMsc.hh.

Member Enumeration Documentation

ScatteringType

enum class G4TransportationWithMsc::ScatteringType

strong

Enumerator
MultipleScattering

Definition at line 53 of file G4TransportationWithMsc.hh.

  {
    MultipleScattering,
  };

Constructor & Destructor Documentation

G4TransportationWithMsc()

G4TransportationWithMsc::G4TransportationWithMsc ( ScatteringType  type, G4int  verbosity = 0  )

explicit

Definition at line 65 of file G4TransportationWithMsc.cc.

  : G4Transportation(verbosity, "TransportationWithMsc")
  , fType(type)
{
  SetVerboseLevel(1);
 
  fEmManager    = G4LossTableManager::Instance();
  fModelManager = new G4EmModelManager;
 
  G4ThreeVector zero;
  fSubStepDynamicParticle =
    new G4DynamicParticle(G4Electron::Definition(), zero);
  fSubStepTrack = new G4Track(fSubStepDynamicParticle, 0, zero);
  fSubStep      = new G4Step;
  fSubStepTrack->SetStep(fSubStep);
}

~G4TransportationWithMsc()

G4TransportationWithMsc::~G4TransportationWithMsc ( )

override

Definition at line 85 of file G4TransportationWithMsc.cc.

{
  delete fModelManager;
  // fSubStepDynamicParticle is owned and also deleted by fSubStepTrack!
  delete fSubStepTrack;
  delete fSubStep;
}

Member Function Documentation

AddMscModel()

void G4TransportationWithMsc::AddMscModel	(	G4VMscModel *	mscModel,
		G4int	order = 0,
		const G4Region *	region = nullptr
	)

Definition at line 95 of file G4TransportationWithMsc.cc.

{
  if(fType != ScatteringType::MultipleScattering)
  {
    G4Exception("G4TransportationWithMsc::AddMscModel", "em0051",
                FatalException,
                "not allowed unless type == MultipleScattering");
  }
 
  fModelManager->AddEmModel(order, mscModel, nullptr, region);
  mscModel->SetParticleChange(&fParticleChange);
}

Referenced by G4EmBuilder::ConstructElectronMscProcess(), and G4EmConfigurator::PrepareModels().

AlongStepGetPhysicalInteractionLength()

G4double G4TransportationWithMsc::AlongStepGetPhysicalInteractionLength ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimumStep, G4double &  proposedSafety, G4GPILSelection *  selection  )

overridevirtual

Implements G4VProcess.

Definition at line 218 of file G4TransportationWithMsc.cc.

{
  *selection = NotCandidateForSelection;
 
  const G4double physStepLimit = currentMinimumStep;
 
  switch(fType)
  {
    case ScatteringType::MultipleScattering: {
      // Select the MSC model for the current kinetic energy.
      G4VMscModel* mscModel          = nullptr;
      const G4double ekin            = track.GetKineticEnergy();
      const auto* couple             = track.GetMaterialCutsCouple();
      const auto* particleDefinition = track.GetParticleDefinition();
      if(physStepLimit > kGeomMin)
      {
        G4double ekinForSelection = ekin;
        G4double pdgMass          = particleDefinition->GetPDGMass();
        if(pdgMass > CLHEP::GeV)
        {
          ekinForSelection *= proton_mass_c2 / pdgMass;
        }
 
        if(ekinForSelection >= kLowestKinEnergy)
        {
          mscModel = static_cast<G4VMscModel*>(
            fModelManager->SelectModel(ekinForSelection, couple->GetIndex()));
          if(mscModel == nullptr)
          {
            G4Exception("G4TransportationWithMsc::AlongStepGPIL", "em0052",
                        FatalException, "no MSC model found");
          }
          if(!mscModel->IsActive(ekinForSelection))
          {
            mscModel = nullptr;
          }
        }
      }
 
      // Call the MSC model to potentially limit the step and convert to
      // geometric path length.
      if(mscModel != nullptr)
      {
        mscModel->SetCurrentCouple(couple);
 
        // Use the provided track for the first step.
        const G4Track* currentTrackPtr = &track;
 
        G4double currentSafety = proposedSafety;
        G4double currentEnergy = ekin;
 
        G4double stepLimitLeft           = physStepLimit;
        G4double totalGeometryStepLength = 0, totalTruePathLength = 0;
        G4bool firstStep = true, continueStepping = fMultipleSteps;
 
        do
        {
          G4double gPathLength = stepLimitLeft;
          G4double tPathLength =
            mscModel->ComputeTruePathLengthLimit(*currentTrackPtr, gPathLength);
          G4bool mscLimitsStep = (tPathLength < stepLimitLeft);
          if(!fMultipleSteps && mscLimitsStep)
          {
            // MSC limits the step.
            *selection = CandidateForSelection;
          }
 
          if(!firstStep)
          {
            // Move the navigator to where the previous step ended.
            fLinearNavigator->LocateGlobalPointWithinVolume(
              fTransportEndPosition);
          }
 
          G4GPILSelection transportSelection;
          G4double geometryStepLength =
            G4Transportation::AlongStepGetPhysicalInteractionLength(
              *currentTrackPtr, previousStepSize, gPathLength, currentSafety,
              &transportSelection);
          if(geometryStepLength < gPathLength)
          {
            // Transportation limits the step, ie the track hit a boundary.
            *selection       = CandidateForSelection;
            continueStepping = false;
          }
          if(fTransportEndKineticEnergy != currentEnergy)
          {
            // Field propagation changed the energy, it's not possible to
            // estimate the continuous energy loss and continue stepping.
            continueStepping = false;
          }
 
          if(firstStep)
          {
            proposedSafety = currentSafety;
          }
          totalGeometryStepLength += geometryStepLength;
 
          // Sample MSC direction change and displacement.
          const G4double range =
            mscModel->GetRange(particleDefinition, currentEnergy, couple);
 
          tPathLength = mscModel->ComputeTrueStepLength(geometryStepLength);
 
          // Protect against wrong t->g->t conversion.
          tPathLength = std::min(tPathLength, stepLimitLeft);
 
          totalTruePathLength += tPathLength;
          if(*selection != CandidateForSelection && !mscLimitsStep)
          {
            // If neither MSC nor transportation limits the step, we got the
            // distance we want - make sure we exit the loop.
            continueStepping = false;
          }
          else if(tPathLength >= range)
          {
            // The particle will stop, exit the loop.
            continueStepping = false;
          }
          else
          {
            stepLimitLeft -= tPathLength;
          }
 
          // Do not sample scattering at the last or at a small step.
          if(tPathLength < range && tPathLength > kGeomMin)
          {
            static constexpr G4double minSafety = 1.20 * CLHEP::nm;
            static constexpr G4double sFact     = 0.99;
 
            // The call to SampleScattering() *may* directly fill in the changed
            // direction into fParticleChange, so we have to:
            // 1) Make sure the momentum direction is initialized.
            fParticleChange.ProposeMomentumDirection(fTransportEndMomentumDir);
            // 2) Call SampleScattering(), which *may* change it.
            const G4ThreeVector displacement =
              mscModel->SampleScattering(fTransportEndMomentumDir, minSafety);
            // 3) Get the changed direction and inform G4Transportation.
            fMomentumChanged         = true;
            fTransportEndMomentumDir = *fParticleChange.GetMomentumDirection();
 
            const G4double r2 = displacement.mag2();
            if(r2 > kMinDisplacement2)
            {
              G4bool positionChanged = true;
              G4double dispR         = std::sqrt(r2);
              G4double postSafety    = sFact * fpSafetyHelper->ComputeSafety(
                                                 fTransportEndPosition, dispR);
 
              // Far away from geometry boundary
              if(postSafety > 0.0 && dispR <= postSafety)
              {
                fTransportEndPosition += displacement;
 
                // Near the boundary
              }
              else
              {
                // displaced point is definitely within the volume
                if(dispR < postSafety)
                {
                  fTransportEndPosition += displacement;
 
                  // reduced displacement
                }
                else if(postSafety > kGeomMin)
                {
                  fTransportEndPosition += displacement * (postSafety / dispR);
 
                  // very small postSafety
                }
                else
                {
                  positionChanged = false;
                }
              }
              if(positionChanged)
              {
                fpSafetyHelper->ReLocateWithinVolume(fTransportEndPosition);
              }
            }
          }
 
          if(continueStepping)
          {
            // Update safety according to the geometry distance.
            if(currentSafety < fEndPointDistance)
            {
              currentSafety = 0;
            }
            else
            {
              currentSafety -= fEndPointDistance;
            }
 
            // Update the kinetic energy according to the continuous loss.
            currentEnergy = mscModel->GetEnergy(particleDefinition,
                                                range - tPathLength, couple);
 
            // From now on, use the track that we can update below.
            currentTrackPtr = fSubStepTrack;
 
            fSubStepDynamicParticle->SetKineticEnergy(currentEnergy);
            fSubStepDynamicParticle->SetMomentumDirection(
              fTransportEndMomentumDir);
            fSubStepTrack->SetPosition(fTransportEndPosition);
 
            G4StepPoint& subPreStepPoint = *fSubStep->GetPreStepPoint();
            subPreStepPoint.SetMaterialCutsCouple(couple);
            subPreStepPoint.SetPosition(fTransportEndPosition);
            subPreStepPoint.SetSafety(currentSafety);
            subPreStepPoint.SetStepStatus(fAlongStepDoItProc);
          }
          firstStep = false;
        } while(continueStepping);
 
        // Note: currentEnergy is only updated if continueStepping is true.
        // In case field propagation changed the energy, this flag is
        // immediately set to false and currentEnergy is still equal to the
        // initial kinetic energy stored in ekin.
        if(currentEnergy != ekin)
        {
          // If field propagation didn't change the energy and we potentially
          // did multiple steps, reset the energy that G4Transportation will
          // propose to not subtract the energy loss twice.
          fTransportEndKineticEnergy = ekin;
          // Also ask for the range again with the initial energy so it is
          // correctly cached in the G4VEnergyLossProcess.
          // FIXME: Asking for a range should never change the cached values!
          (void) mscModel->GetRange(particleDefinition, ekin, couple);
        }
 
        fParticleChange.ProposeTrueStepLength(totalTruePathLength);
 
        return totalGeometryStepLength;
      }
    }
  }
 
  // If we get here, no scattering has happened.
  return G4Transportation::AlongStepGetPhysicalInteractionLength(
    track, previousStepSize, currentMinimumStep, proposedSafety, selection);
}

BuildPhysicsTable()

void G4TransportationWithMsc::BuildPhysicsTable ( const G4ParticleDefinition &  part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 157 of file G4TransportationWithMsc.cc.

{
  if(fFirstParticle == &part)
  {
    fEmManager->BuildPhysicsTable(fFirstParticle);
 
    if(!fEmManager->IsMaster())
    {
      const auto masterProcess =
        static_cast<const G4TransportationWithMsc*>(GetMasterProcess());
 
      // Initialisation of models.
      const G4int numberOfModels = fModelManager->NumberOfModels();
      for(G4int i = 0; i < numberOfModels; ++i)
      {
        auto msc = static_cast<G4VMscModel*>(fModelManager->GetModel(i));
        auto msc0 =
          static_cast<G4VMscModel*>(masterProcess->fModelManager->GetModel(i));
        msc->SetCrossSectionTable(msc0->GetCrossSectionTable(), false);
        msc->InitialiseLocal(fFirstParticle, msc0);
      }
    }
  }
 
  if(!G4EmParameters::Instance()->IsPrintLocked() && verboseLevel > 0)
  {
    G4cout << G4endl;
    G4cout << GetProcessName() << ": for " << part.GetParticleName();
    if(fMultipleSteps)
    {
      G4cout << " (multipleSteps: 1)";
    }
    G4cout << G4endl;
    fModelManager->DumpModelList(G4cout, verboseLevel);
  }
}

MultipleSteps()

G4bool G4TransportationWithMsc::MultipleSteps ( ) const

inline

Definition at line 101 of file G4TransportationWithMsc.hh.

{
  return fMultipleSteps;
}

PreparePhysicsTable()

void G4TransportationWithMsc::PreparePhysicsTable ( const G4ParticleDefinition &  part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 111 of file G4TransportationWithMsc.cc.

{
  if(nullptr == fFirstParticle)
  {
    fFirstParticle = ∂
    G4VMultipleScattering* ptr = nullptr;
    auto emConfigurator = fEmManager->EmConfigurator();
    emConfigurator->PrepareModels(&part, ptr, this);
  }
 
  if(fFirstParticle == &part)
  {
    G4bool master             = fEmManager->IsMaster();
    G4LossTableBuilder* bld   = fEmManager->GetTableBuilder();
    G4bool baseMat            = bld->GetBaseMaterialFlag();
    const auto* theParameters = G4EmParameters::Instance();
 
    if(master)
    {
      SetVerboseLevel(theParameters->Verbose());
    }
    else
    {
      SetVerboseLevel(theParameters->WorkerVerbose());
    }
 
    const G4int numberOfModels = fModelManager->NumberOfModels();
    for(G4int i = 0; i < numberOfModels; ++i)
    {
      auto msc = static_cast<G4VMscModel*>(fModelManager->GetModel(i));
      msc->SetMasterThread(master);
      msc->SetPolarAngleLimit(theParameters->MscThetaLimit());
      G4double emax =
        std::min(msc->HighEnergyLimit(), theParameters->MaxKinEnergy());
      msc->SetHighEnergyLimit(emax);
      msc->SetUseBaseMaterials(baseMat);
    }
 
    fModelManager->Initialise(fFirstParticle, G4Electron::Electron(),
                              verboseLevel);
  }
}

SetMultipleSteps()

void G4TransportationWithMsc::SetMultipleSteps ( G4bool  val )

inline

Definition at line 94 of file G4TransportationWithMsc.hh.

{
  fMultipleSteps = val;
}

Referenced by G4EmBuilder::ConstructElectronMscProcess().

StartTracking()

void G4TransportationWithMsc::StartTracking ( G4Track *  track )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 197 of file G4TransportationWithMsc.cc.

{
  auto* currParticle = track->GetParticleDefinition();
  auto* ionisation   = fEmManager->GetEnergyLossProcess(currParticle);
 
  fSubStepDynamicParticle->SetDefinition(currParticle);
 
  const G4int numberOfModels = fModelManager->NumberOfModels();
  for(G4int i = 0; i < numberOfModels; ++i)
  {
    auto msc = static_cast<G4VMscModel*>(fModelManager->GetModel(i));
    msc->StartTracking(track);
    msc->SetIonisation(ionisation, currParticle);
  }
 
  // Ensure that field propagation state is also cleared / prepared
  G4Transportation::StartTracking(track);
}

---

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

• G4TransportationWithMsc.hh
• G4TransportationWithMsc.cc