#include <G4VMultipleScattering.hh>

Inheritance diagram for G4VMultipleScattering:

Collaboration diagram for G4VMultipleScattering:

Public Member Functions
	G4VMultipleScattering (const G4String &name="msc", G4ProcessType type=fElectromagnetic)

virtual	~G4VMultipleScattering ()

virtual G4bool	IsApplicable (const G4ParticleDefinition &p)=0

virtual void	PrintInfo ()=0

virtual void	ProcessDescription (std::ostream &outFile) const

void	PreparePhysicsTable (const G4ParticleDefinition &)

void	BuildPhysicsTable (const G4ParticleDefinition &)

void	PrintInfoDefinition ()

G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)

G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii)

void	StartTracking (G4Track *)

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

G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4ForceCondition *condition)

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

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

G4double	ContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimalStep, G4double &currentSafety)

G4VEmModel *	SelectModel (G4double kinEnergy, size_t idx)

void	AddEmModel (G4int order, G4VEmModel , const G4Region region=0)

void	SetEmModel (G4VMscModel *, G4int index=1)

G4VMscModel *	EmModel (G4int index=1) const

G4VEmModel *	GetModelByIndex (G4int idx=0, G4bool ver=false) const

void	SetIonisation (G4VEnergyLossProcess *)

G4bool	LateralDisplasmentFlag () const

void	SetLateralDisplasmentFlag (G4bool val)

G4double	Skin () const

void	SetSkin (G4double val)

G4double	RangeFactor () const

void	SetRangeFactor (G4double val)

G4double	GeomFactor () const

G4double	PolarAngleLimit () const

G4MscStepLimitType	StepLimitType () const

void	SetStepLimitType (G4MscStepLimitType val)

G4double	LowestKinEnergy () const

void	SetLowestKinEnergy (G4double val)

const G4ParticleDefinition *	FirstParticle () const

Public Member Functions inherited from G4VContinuousDiscreteProcess
	G4VContinuousDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)

	G4VContinuousDiscreteProcess (G4VContinuousDiscreteProcess &)

virtual	~G4VContinuousDiscreteProcess ()

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

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)

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 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

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 &)

Protected Member Functions
virtual void	InitialiseProcess (const G4ParticleDefinition *)=0

G4double	GetMeanFreePath (const G4Track &track, G4double, G4ForceCondition *condition)

G4double	GetContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimalStep, G4double &currentSafety)

Protected Member Functions inherited from G4VContinuousDiscreteProcess
void	SetGPILSelection (G4GPILSelection selection)

G4GPILSelection	GetGPILSelection () const

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4ParticleChangeForMSC	fParticleChange

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Private Member Functions
	G4VMultipleScattering (G4VMultipleScattering &)

G4VMultipleScattering &	operator= (const G4VMultipleScattering &right)

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Detailed Description

Definition at line 92 of file G4VMultipleScattering.hh.

Constructor & Destructor Documentation

◆ G4VMultipleScattering() [1/2]

G4VMultipleScattering::G4VMultipleScattering	(	const G4String &	name = `"msc"`,
		G4ProcessType	type = `fElectromagnetic`
	)

Definition at line 95 of file G4VMultipleScattering.cc.

                                                       :
   G4VContinuousDiscreteProcess("msc", fElectromagnetic),
   numberOfModels(0),
   firstParticle(nullptr),
   currParticle(nullptr),
   stepLimit(fUseSafety),
   facrange(0.04),
   latDisplacement(true),
   isIon(false),
   fDispBeyondSafety(false),
   fNewPosition(0.,0.,0.),
   fNewDirection(0.,0.,1.)
 {
   theParameters = G4EmParameters::Instance();
   SetVerboseLevel(1);
   SetProcessSubType(fMultipleScattering);
   if("ionmsc" == name) { firstParticle = G4GenericIon::GenericIon(); }
 
   lowestKinEnergy = 10*CLHEP::eV;
 
   physStepLimit = gPathLength = tPathLength = 0.0;
   fIonisation = nullptr;
 
   pParticleChange = &fParticleChange;
   safetyHelper = nullptr;
   fPositionChanged = false;
   isActive = false;
 
   currentModel = nullptr;
   modelManager = new G4EmModelManager();
   emManager = G4LossTableManager::Instance();
   emManager->Register(this);
 }

Here is the call graph for this function:

◆ ~G4VMultipleScattering()

G4VMultipleScattering::~G4VMultipleScattering ( )

virtual

Definition at line 132 of file G4VMultipleScattering.cc.

 {
   /*
   if(1 < verboseLevel) {
     G4cout << "G4VMultipleScattering destruct " << GetProcessName() 
           << G4endl;
   }
   */
   delete modelManager;
   emManager->DeRegister(this);
 }

Here is the call graph for this function:

◆ G4VMultipleScattering() [2/2]

G4VMultipleScattering::G4VMultipleScattering ( G4VMultipleScattering & )

private

Member Function Documentation

◆ AddEmModel()

void G4VMultipleScattering::AddEmModel	(	G4int	order,
		G4VEmModel *	p,
		const G4Region *	region = `0`
	)

Definition at line 146 of file G4VMultipleScattering.cc.

 {
   G4VEmFluctuationModel* fm = nullptr;
   modelManager->AddEmModel(order, p, fm, region);
   if(p) { p->SetParticleChange(pParticleChange); }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AlongStepDoIt()

G4VParticleChange * G4VMultipleScattering::AlongStepDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 476 of file G4VMultipleScattering.cc.

 {
   fParticleChange.ProposeMomentumDirection(
     step.GetPostStepPoint()->GetMomentumDirection());
   fNewPosition = step.GetPostStepPoint()->GetPosition();
   fParticleChange.ProposePosition(fNewPosition);
   fPositionChanged = false;
 
   G4double geomLength = step.GetStepLength();
 
   // very small step - no msc
   if(!isActive) {
     tPathLength = geomLength;
 
     // sample msc
   } else {
     G4double range = 
       currentModel->GetRange(currParticle,track.GetKineticEnergy(),
                              track.GetMaterialCutsCouple());
 
     tPathLength = currentModel->ComputeTrueStepLength(geomLength);
   
     // protection against wrong t->g->t conversion
     /*    
     if(currParticle->GetPDGMass() > 0.9*GeV)    
     G4cout << "G4VMsc::AlongStepDoIt: GeomLength= " 
            << geomLength 
            << " tPathLength= " << tPathLength
            << " physStepLimit= " << physStepLimit
            << " dr= " << range - tPathLength
            << " ekin= " << track.GetKineticEnergy() << G4endl;
     */
     tPathLength = std::min(tPathLength, physStepLimit);
 
     // do not sample scattering at the last or at a small step
     if(tPathLength < range && tPathLength > geomMin) {
 
       G4ThreeVector displacement = currentModel->SampleScattering(
         step.GetPostStepPoint()->GetMomentumDirection(),minSafety);
 
       G4double r2 = displacement.mag2();
       //G4cout << "    R= " << sqrt(r2) << " Rmin= " << sqrt(minDisplacement2)
       //     << " flag= " << fDispBeyondSafety << G4endl;
       if(r2 > minDisplacement2) {
 
         fPositionChanged = true;
         const G4double sFact = 0.99;
         G4double postSafety = 
           sFact*(step.GetPreStepPoint()->GetSafety() - geomLength); 
         //G4cout<<"    R= "<<sqrt(r2)<<" postSafety= "<<postSafety<<G4endl;
 
         // far away from geometry boundary
         if(postSafety > 0.0 && r2 <= postSafety*postSafety) {
           fNewPosition += displacement;
 
       //near the boundary
         } else {
           G4double dispR = std::sqrt(r2);
           postSafety = 
             sFact*safetyHelper->ComputeSafety(fNewPosition, dispR); 
 
           // displaced point is definitely within the volume
           //G4cout<<"    R= "<<dispR<<" postSafety= "<<postSafety<<G4endl;
           if(dispR < postSafety) {
             fNewPosition += displacement;
 
             // optional extra mechanism is applied only if a particle
             // is stopped by the boundary
           } else if(fDispBeyondSafety && 0.0 == postSafety) {
             fNewPosition += displacement;
             G4double maxshift = 
               std::min(2.0*dispR, geomLength*(physStepLimit/tPathLength - 1.0));
             G4double dist = 0.0;
             G4double safety = postSafety + dispR;
             fNewDirection = *(fParticleChange.GetMomentumDirection());
             /*
               G4cout << "##MSC before Recheck maxshift= " << maxshift
                      << " postsafety= " << postSafety
                      << " Ekin= " << track.GetKineticEnergy()
                      << "  " << track.GetDefinition()->GetParticleName()
                      << G4endl; 
             */
             // check if it is possible to shift to the boundary
         // and the shift is not large
             if(safetyHelper->RecheckDistanceToCurrentBoundary(fNewPosition,
                fNewDirection, maxshift, &dist, &safety) 
            && std::abs(dist) < maxshift) {
              /* 
             G4cout << "##MSC after Recheck dist= " << dist
             << " postsafety= " << postSafety
             << " t= " << tPathLength
             << " g=  " << geomLength
             << " p=  " << physStepLimit
             << G4endl; 
              */
           // shift is positive
           if(dist >= 0.0) {
         tPathLength *= (1.0 + dist/geomLength);
         fNewPosition += dist*fNewDirection; 
 
         // shift is negative cannot be larger than geomLength
           } else {
         maxshift = std::min(maxshift, geomLength);
         if(0.0 < maxshift + dist) {
           G4ThreeVector postpoint = step.GetPostStepPoint()->GetPosition();
           G4ThreeVector point = fNewPosition + dist*fNewDirection;
           G4double R2 = (postpoint - point).mag2();
           G4double newdist = dist;
           // check not more than 10 extra boundaries
           for(G4int i=0; i<10; ++i) {
             dist = 0.0;
             if(safetyHelper->RecheckDistanceToCurrentBoundary(
                point, fNewDirection, maxshift, &dist, &safety) 
                && std::abs(newdist + dist) < maxshift) {
               point += dist*fNewDirection;
               G4double R2new = (postpoint - point).mag2();
               //G4cout << "Backward  i= " << i << " dist= " << dist 
               //     << " R2= " << R2new << G4endl; 
               if(dist >= 0.0 || R2new > R2) { break; }
               R2 = R2new;
               fNewPosition = point;
               newdist += dist;
             } else { 
               break; 
             }
           }
           tPathLength *= (1.0 + newdist/geomLength);
         // shift on boundary is not possible for negative disp
         } else {
           fNewPosition += displacement*(postSafety/dispR - 1.0); 
         }
           }
           // shift on boundary is not possible for any disp
         } else {
           fNewPosition += displacement*(postSafety/dispR - 1.0); 
         }
         // reduced displacement
       } else if(postSafety > geomMin) {
         fNewPosition += displacement*(postSafety/dispR); 
 
             // very small postSafety
           } else {
             fPositionChanged = false;
           }
         }
         //safetyHelper->ReLocateWithinVolume(fNewPosition);
       }
     }
   }
   fParticleChange.ProposeTrueStepLength(tPathLength);
   //fParticleChange.ProposePosition(fNewPosition);
   return &fParticleChange;
 }

Here is the call graph for this function:

◆ AlongStepGetPhysicalInteractionLength()

G4double G4VMultipleScattering::AlongStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimalStep,
		G4double &	currentSafety,
		G4GPILSelection *	selection
	)

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 409 of file G4VMultipleScattering.cc.

 {
   // get Step limit proposed by the process
   *selection = NotCandidateForSelection;
   physStepLimit = gPathLength = tPathLength = currentMinimalStep;
 
   G4double ekin = track.GetKineticEnergy();
   /*
   G4cout << "MSC::AlongStepGPIL: Ekin= " << ekin
          << "  " << currParticle->GetParticleName() 
          << " currMod " << currentModel 
          << G4endl;
   */
   // isIon flag is used only to select a model
   if(isIon) { 
     ekin *= proton_mass_c2/track.GetParticleDefinition()->GetPDGMass(); 
   }
   
   // select new model
   if(1 < numberOfModels) {
     currentModel = static_cast<G4VMscModel*>(
       SelectModel(ekin,track.GetMaterialCutsCouple()->GetIndex()));
   }
   // msc is active is model is active, energy above the limit,
   // and step size is above the limit;
   // if it is active msc may limit the step
   if(currentModel->IsActive(ekin) && tPathLength > geomMin
      && ekin >= lowestKinEnergy) {
     isActive = true;
     tPathLength = 
       currentModel->ComputeTruePathLengthLimit(track, gPathLength);
     if (tPathLength < physStepLimit) { 
       *selection = CandidateForSelection; 
     }
   } else { isActive = false; }
   
   //if(currParticle->GetPDGMass() > GeV)    
   /*
   G4cout << "MSC::AlongStepGPIL: Ekin= " << ekin
          << "  " << currParticle->GetParticleName()
          << " gPathLength= " << gPathLength
          << " tPathLength= " << tPathLength
          << " currentMinimalStep= " << currentMinimalStep
          << " isActive " << isActive << G4endl;
   */
   return gPathLength;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildPhysicsTable()

void G4VMultipleScattering::BuildPhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Definition at line 286 of file G4VMultipleScattering.cc.

 {
   G4String num = part.GetParticleName();
   if(1 < verboseLevel) {
     G4cout << "### G4VMultipleScattering::BuildPhysicsTable() for "
            << GetProcessName()
            << " and particle " << num
            << " IsMaster= " << G4LossTableManager::Instance()->IsMaster()
            << G4endl;
   }
   G4bool master = true;
   const G4VMultipleScattering* masterProcess = 
     static_cast<const G4VMultipleScattering*>(GetMasterProcess()); 
   if(masterProcess && masterProcess != this) { master = false; }
 
   if(firstParticle == &part) { 
     /*    
     G4cout << "### G4VMultipleScattering::BuildPhysicsTable() for "
            << GetProcessName()
            << " and particle " << num
            << " IsMaster= " << G4LossTableManager::Instance()->IsMaster()
            << "  " << this
            << G4endl;
     */
     emManager->BuildPhysicsTable(firstParticle);
 
     if(!master) {
       // initialisation of models
       G4bool printing = true;
       numberOfModels = modelManager->NumberOfModels();
       /*
         G4cout << "### G4VMultipleScattering::SlaveBuildPhysicsTable() for "
         << GetProcessName()
         << " and particle " << num
         << " Nmod= " << numberOfModels << "  " << this
         << G4endl;
       */
       for(G4int i=0; i<numberOfModels; ++i) {
         G4VMscModel* msc = 
           static_cast<G4VMscModel*>(GetModelByIndex(i, printing));
         G4VMscModel* msc0= 
           static_cast<G4VMscModel*>(masterProcess->GetModelByIndex(i,printing));
         msc->SetCrossSectionTable(msc0->GetCrossSectionTable(), false);
         msc->InitialiseLocal(firstParticle, msc0);
       }
     }
   }
 
   // explicitly defined printout by particle name
   if(1 < verboseLevel || 
      (0 < verboseLevel && (num == "e-" || 
                            num == "e+"    || num == "mu+" || 
                            num == "mu-"   || num == "proton"|| 
                            num == "pi+"   || num == "pi-" || 
                            num == "kaon+" || num == "kaon-" || 
                            num == "alpha" || num == "anti_proton" || 
                            num == "GenericIon")))
     { 
       G4cout << G4endl << GetProcessName() 
              << ":   for " << num
              << "    SubType= " << GetProcessSubType() 
              << G4endl;
       PrintInfo();
       modelManager->DumpModelList(verboseLevel);
     }
 
   if(1 < verboseLevel) {
     G4cout << "### G4VMultipleScattering::BuildPhysicsTable() done for "
            << GetProcessName()
            << " and particle " << num
            << G4endl;
   }
 }

Here is the call graph for this function:

◆ ContinuousStepLimit()

G4double G4VMultipleScattering::ContinuousStepLimit	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimalStep,
		G4double &	currentSafety
	)

Definition at line 663 of file G4VMultipleScattering.cc.

 {
   return GetContinuousStepLimit(track,previousStepSize,currentMinimalStep,
                                 currentSafety);
 }

Here is the call graph for this function:

◆ EmModel()

G4VMscModel * G4VMultipleScattering::EmModel ( G4int index = 1 ) const

Definition at line 165 of file G4VMultipleScattering.cc.

 {
   G4VMscModel* p = nullptr;
   if(index >= 0 && index <  G4int(mscModels.size())) { p = mscModels[index]; }
   return p;
 }

Here is the caller graph for this function:

◆ FirstParticle()

const G4ParticleDefinition * G4VMultipleScattering::FirstParticle ( ) const

inline

Definition at line 399 of file G4VMultipleScattering.hh.

 {
   return firstParticle;
 }

◆ GeomFactor()

G4double G4VMultipleScattering::GeomFactor ( ) const

inline

Definition at line 355 of file G4VMultipleScattering.hh.

 {
   return theParameters->MscGeomFactor();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetContinuousStepLimit()

G4double G4VMultipleScattering::GetContinuousStepLimit	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimalStep,
		G4double &	currentSafety
	)

protectedvirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 647 of file G4VMultipleScattering.cc.

 {
   G4GPILSelection selection = NotCandidateForSelection;
   G4double x = AlongStepGetPhysicalInteractionLength(track,previousStepSize,
                                                      currentMinimalStep,
                                                      currentSafety, 
                                                      &selection);
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMeanFreePath()

G4double G4VMultipleScattering::GetMeanFreePath	(	const G4Track &	track,
		G4double	,
		G4ForceCondition *	condition
	)

protectedvirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 675 of file G4VMultipleScattering.cc.

 {
   *condition = Forced;
   return DBL_MAX;
 }

◆ GetModelByIndex()

G4VEmModel * G4VMultipleScattering::GetModelByIndex	(	G4int	idx = `0`,
		G4bool	ver = `false`
	)		const

Definition at line 175 of file G4VMultipleScattering.cc.

 {
   return modelManager->GetModel(idx, ver);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitialiseProcess()

virtual void G4VMultipleScattering::InitialiseProcess ( const G4ParticleDefinition * )

protectedpure virtual

Implemented in G4AdjointhMultipleScattering, G4hMultipleScattering, G4MuMultipleScattering, and G4eMultipleScattering.

Here is the caller graph for this function:

◆ IsApplicable()

virtual G4bool G4VMultipleScattering::IsApplicable ( const G4ParticleDefinition & p )

pure virtual

Reimplemented from G4VProcess.

Implemented in G4AdjointhMultipleScattering, G4hMultipleScattering, G4MuMultipleScattering, and G4eMultipleScattering.

◆ LateralDisplasmentFlag()

G4bool G4VMultipleScattering::LateralDisplasmentFlag ( ) const

inline

Definition at line 310 of file G4VMultipleScattering.hh.

 {
   return latDisplacement;
 }

Here is the caller graph for this function:

◆ LowestKinEnergy()

G4double G4VMultipleScattering::LowestKinEnergy ( ) const

inline

Definition at line 385 of file G4VMultipleScattering.hh.

 {
   return lowestKinEnergy;
 }

◆ operator=()

G4VMultipleScattering& G4VMultipleScattering::operator= ( const G4VMultipleScattering & right )

private

◆ PolarAngleLimit()

G4double G4VMultipleScattering::PolarAngleLimit ( ) const

inline

Definition at line 362 of file G4VMultipleScattering.hh.

 {
   return theParameters->MscThetaLimit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PostStepDoIt()

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

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 633 of file G4VMultipleScattering.cc.

 {
   fParticleChange.Initialize(track);
  
   if(fPositionChanged) { 
     safetyHelper->ReLocateWithinVolume(fNewPosition);
     fParticleChange.ProposePosition(fNewPosition); 
   }
  
   return &fParticleChange;
 }

Here is the call graph for this function:

◆ PostStepGetPhysicalInteractionLength()

G4double G4VMultipleScattering::PostStepGetPhysicalInteractionLength	(	const G4Track &	,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 465 of file G4VMultipleScattering.cc.

 {
   *condition = Forced;
   //*condition = NotForced;
   return DBL_MAX;
 }

◆ PreparePhysicsTable()

void G4VMultipleScattering::PreparePhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Definition at line 183 of file G4VMultipleScattering.cc.

 {
   G4bool master = true;
   const G4VMultipleScattering* masterProc = 
     static_cast<const G4VMultipleScattering*>(GetMasterProcess());
   if(masterProc && masterProc != this) { master = false; }
 
   if(!firstParticle) { firstParticle = &part; }
   if(part.GetParticleType() == "nucleus") {
     stepLimit = fMinimal;
     latDisplacement = false;
     facrange = 0.2;
     G4String pname = part.GetParticleName();
     if(pname != "deuteron" && pname != "triton" &&
        pname != "alpha+"   && pname != "helium" &&
        pname != "alpha"    && pname != "He3" &&
        pname != "hydrogen") {
 
       const G4ParticleDefinition* theGenericIon = 
         G4ParticleTable::GetParticleTable()->FindParticle("GenericIon");
       if(&part == theGenericIon) { isIon = true; }
      
       if(theGenericIon && firstParticle != theGenericIon) {
         G4ProcessManager* pm =  theGenericIon->GetProcessManager();
         G4ProcessVector* v = pm->GetAlongStepProcessVector();
         size_t n = v->size();
         for(size_t j=0; j<n; ++j) {
           if((*v)[j] == this) {
             firstParticle = theGenericIon;
             isIon = true; 
             break; 
           }
         }
       }
     }
   }
 
   emManager->PreparePhysicsTable(&part, this, master);
   currParticle = 0;
 
   if(1 < verboseLevel) {
     G4cout << "### G4VMultipleScattering::PrepearPhysicsTable() for "
            << GetProcessName()
            << " and particle " << part.GetParticleName()
            << " local particle " << firstParticle->GetParticleName()
            << " isIon= " << isIon 
            << G4endl;
   }
 
   if(firstParticle == &part) {
 
     // initialise process
     InitialiseProcess(firstParticle);
 
     // heavy particles and not ions
     if(!isIon) {
       if(part.GetPDGMass() > MeV) {
         stepLimit = theParameters->MscMuHadStepLimitType(); 
         facrange = theParameters->MscMuHadRangeFactor(); 
         latDisplacement = theParameters->MuHadLateralDisplacement();
       } else {
         stepLimit = theParameters->MscStepLimitType(); 
         facrange = theParameters->MscRangeFactor(); 
         latDisplacement = theParameters->LateralDisplacement();
       }
       if(latDisplacement) { 
         fDispBeyondSafety = theParameters->LatDisplacementBeyondSafety();
       }
     }
     if(master) { SetVerboseLevel(theParameters->Verbose()); }
     else {  SetVerboseLevel(theParameters->WorkerVerbose()); }
 
     // initialisation of models
     numberOfModels = modelManager->NumberOfModels();
     for(G4int i=0; i<numberOfModels; ++i) {
       G4VMscModel* msc = static_cast<G4VMscModel*>(modelManager->GetModel(i));
       msc->SetIonisation(0, firstParticle);
       msc->SetMasterThread(master);
       if(0 == i) { currentModel = msc; }
       msc->SetStepLimitType(stepLimit);
       msc->SetLateralDisplasmentFlag(latDisplacement);
       msc->SetSkin(theParameters->MscSkin());
       msc->SetRangeFactor(facrange);
       msc->SetGeomFactor(theParameters->MscGeomFactor());
       msc->SetPolarAngleLimit(theParameters->MscThetaLimit());
       G4double emax = 
         std::min(msc->HighEnergyLimit(),theParameters->MaxKinEnergy());
       msc->SetHighEnergyLimit(emax);
     }
 
     modelManager->Initialise(firstParticle, G4Electron::Electron(), 
                              10.0, verboseLevel);
 
     if(!safetyHelper) {
       safetyHelper = G4TransportationManager::GetTransportationManager()
         ->GetSafetyHelper();
       safetyHelper->InitialiseHelper();
     }
   }
 }

Here is the call graph for this function:

◆ PrintInfo()

virtual void G4VMultipleScattering::PrintInfo ( )

pure virtual

Implemented in G4AdjointhMultipleScattering, G4hMultipleScattering, G4MuMultipleScattering, and G4eMultipleScattering.

Here is the caller graph for this function:

◆ PrintInfoDefinition()

void G4VMultipleScattering::PrintInfoDefinition ( )

Definition at line 362 of file G4VMultipleScattering.cc.

 {
   if (0 < verboseLevel) {
     G4cout << G4endl << GetProcessName() 
            << ":   for " << firstParticle->GetParticleName()
            << "    SubType= " << GetProcessSubType() 
            << G4endl;
     PrintInfo();
     modelManager->DumpModelList(verboseLevel);
   }
 }

Here is the call graph for this function:

◆ ProcessDescription()

void G4VMultipleScattering::ProcessDescription ( std::ostream & outFile ) const

virtual

Definition at line 748 of file G4VMultipleScattering.cc.

 {
   outFile << "Multiple scattering process <" << GetProcessName() 
           << ">" << G4endl;
 }

Here is the call graph for this function:

◆ RangeFactor()

G4double G4VMultipleScattering::RangeFactor ( ) const

inline

Definition at line 338 of file G4VMultipleScattering.hh.

 {
   return facrange;
 }

Here is the caller graph for this function:

◆ RetrievePhysicsTable()

G4bool G4VMultipleScattering::RetrievePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	directory,
		G4bool	ascii
	)

virtual

Reimplemented from G4VProcess.

Definition at line 729 of file G4VMultipleScattering.cc.

 {
   return true;
 }

◆ SelectModel()

G4VEmModel * G4VMultipleScattering::SelectModel	(	G4double	kinEnergy,
		size_t	idx
	)

inline

Definition at line 303 of file G4VMultipleScattering.hh.

 {
   return modelManager->SelectModel(kinEnergy, coupleIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetEmModel()

void G4VMultipleScattering::SetEmModel	(	G4VMscModel *	p,
		G4int	index = `1`
	)

Definition at line 156 of file G4VMultipleScattering.cc.

 {
   G4int n = mscModels.size();
   if(index >= n) { for(G4int i=n; i<=index; ++i) { mscModels.push_back(0); } }
   mscModels[index] = p;
 }

Here is the caller graph for this function:

◆ SetIonisation()

void G4VMultipleScattering::SetIonisation ( G4VEnergyLossProcess * p )

Definition at line 738 of file G4VMultipleScattering.cc.

 {
   for(G4int i=0; i<numberOfModels; ++i) {
     G4VMscModel* msc = static_cast<G4VMscModel*>(GetModelByIndex(i, true));
     msc->SetIonisation(p, firstParticle);
   }
 }

Here is the call graph for this function:

◆ SetLateralDisplasmentFlag()

void G4VMultipleScattering::SetLateralDisplasmentFlag ( G4bool val )

inline

Definition at line 317 of file G4VMultipleScattering.hh.

 {
   latDisplacement = val;
 }

◆ SetLowestKinEnergy()

void G4VMultipleScattering::SetLowestKinEnergy ( G4double val )

inline

Definition at line 392 of file G4VMultipleScattering.hh.

 {
   lowestKinEnergy = val;
 }

◆ SetRangeFactor()

void G4VMultipleScattering::SetRangeFactor ( G4double val )

inline

Definition at line 345 of file G4VMultipleScattering.hh.

 {
   if(val > 0.0 && val < 1.0) { 
     facrange = val;
     theParameters->SetMscRangeFactor(val);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetSkin()

void G4VMultipleScattering::SetSkin ( G4double val )

inline

Definition at line 331 of file G4VMultipleScattering.hh.

 {
   theParameters->SetMscSkin(val);
 }

Here is the call graph for this function:

◆ SetStepLimitType()

void G4VMultipleScattering::SetStepLimitType ( G4MscStepLimitType val )

inline

Definition at line 376 of file G4VMultipleScattering.hh.

 {
   stepLimit = val;
   if(val == fMinimal) { SetRangeFactor(0.2); }
   theParameters->SetMscStepLimitType(val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Skin()

G4double G4VMultipleScattering::Skin ( ) const

inline

Definition at line 324 of file G4VMultipleScattering.hh.

 {
   return theParameters->MscSkin();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StartTracking()

void G4VMultipleScattering::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

Definition at line 376 of file G4VMultipleScattering.cc.

 {
   G4VEnergyLossProcess* eloss = nullptr;
   if(track->GetParticleDefinition() != currParticle) {
     currParticle = track->GetParticleDefinition();
     fIonisation = emManager->GetEnergyLossProcess(currParticle);
     eloss = fIonisation;
   }
   /*  
   G4cout << "G4VMultipleScattering::StartTracking Nmod= " << numberOfModels
          << "  " << currParticle->GetParticleName() 
          << " E(MeV)= " << track->GetKineticEnergy()
          << "  Ion= " << eloss << "  " << fIonisation << " IsMaster= " 
          << G4LossTableManager::Instance()->IsMaster() 
          << G4endl;
   */
   // one model
   if(1 == numberOfModels) {
     currentModel->StartTracking(track);
     if(eloss) { currentModel->SetIonisation(fIonisation, currParticle); }
 
     // many models
   } else { 
     for(G4int i=0; i<numberOfModels; ++i) {
       G4VMscModel* msc = static_cast<G4VMscModel*>(GetModelByIndex(i,true));
       msc->StartTracking(track);
       if(eloss) { msc->SetIonisation(fIonisation, currParticle); }
     }
   }
 } 

Here is the call graph for this function:

◆ StepLimitType()

G4MscStepLimitType G4VMultipleScattering::StepLimitType ( ) const

inline

Definition at line 369 of file G4VMultipleScattering.hh.

 {
   return stepLimit;
 }

Here is the caller graph for this function:

◆ StorePhysicsTable()

G4bool G4VMultipleScattering::StorePhysicsTable	(	const G4ParticleDefinition *	part,
		const G4String &	directory,
		G4bool	ascii = `false`
	)

virtual

Reimplemented from G4VProcess.

Definition at line 685 of file G4VMultipleScattering.cc.

 {
   G4bool yes = true;
   if(part != firstParticle) { return yes; }
   const G4VMultipleScattering* masterProcess = 
     static_cast<const G4VMultipleScattering*>(GetMasterProcess()); 
   if(masterProcess && masterProcess != this) { return yes; }
 
   G4int nmod = modelManager->NumberOfModels();
   static const G4String ss[4] = {"1","2","3","4"};
   for(G4int i=0; i<nmod; ++i) {
     G4VEmModel* msc = modelManager->GetModel(i);
     yes = true;
     G4PhysicsTable* table = msc->GetCrossSectionTable();
     if (table) {
       G4int j = std::min(i,3); 
       G4String name = 
         GetPhysicsTableFileName(part,directory,"LambdaMod"+ss[j],ascii);
       yes = table->StorePhysicsTable(name,ascii);
 
       if ( yes ) {
         if ( verboseLevel>0 ) {
           G4cout << "Physics table are stored for " 
                  << part->GetParticleName()
                  << " and process " << GetProcessName()
                  << " with a name <" << name << "> " << G4endl;
         }
       } else {
         G4cout << "Fail to store Physics Table for " 
                << part->GetParticleName()
                << " and process " << GetProcessName()
                << " in the directory <" << directory
                << "> " << G4endl;
       }
     }
   }
   return yes;
 }

Here is the call graph for this function:

Member Data Documentation

◆ currentModel

G4VMscModel* G4VMultipleScattering::currentModel

private

Definition at line 285 of file G4VMultipleScattering.hh.

◆ currParticle

const G4ParticleDefinition* G4VMultipleScattering::currParticle

private

Definition at line 265 of file G4VMultipleScattering.hh.

◆ emManager

G4LossTableManager* G4VMultipleScattering::emManager

private

Definition at line 254 of file G4VMultipleScattering.hh.

◆ facrange

G4double G4VMultipleScattering::facrange

private

Definition at line 269 of file G4VMultipleScattering.hh.

◆ fDispBeyondSafety

G4bool G4VMultipleScattering::fDispBeyondSafety

private

Definition at line 274 of file G4VMultipleScattering.hh.

◆ fIonisation

G4VEnergyLossProcess* G4VMultipleScattering::fIonisation

private

Definition at line 286 of file G4VMultipleScattering.hh.

◆ firstParticle

const G4ParticleDefinition* G4VMultipleScattering::firstParticle

private

Definition at line 264 of file G4VMultipleScattering.hh.

◆ fNewDirection

G4ThreeVector G4VMultipleScattering::fNewDirection

private

Definition at line 293 of file G4VMultipleScattering.hh.

◆ fNewPosition

G4ThreeVector G4VMultipleScattering::fNewPosition

private

Definition at line 292 of file G4VMultipleScattering.hh.

◆ fParticleChange

G4ParticleChangeForMSC G4VMultipleScattering::fParticleChange

protected

Definition at line 280 of file G4VMultipleScattering.hh.

◆ fPositionChanged

G4bool G4VMultipleScattering::fPositionChanged

private

Definition at line 294 of file G4VMultipleScattering.hh.

◆ gPathLength

G4double G4VMultipleScattering::gPathLength

private

Definition at line 290 of file G4VMultipleScattering.hh.

◆ isActive

G4bool G4VMultipleScattering::isActive

private

Definition at line 295 of file G4VMultipleScattering.hh.

◆ isIon

G4bool G4VMultipleScattering::isIon

private

Definition at line 273 of file G4VMultipleScattering.hh.

◆ latDisplacement

G4bool G4VMultipleScattering::latDisplacement

private

Definition at line 272 of file G4VMultipleScattering.hh.

◆ lowestKinEnergy

G4double G4VMultipleScattering::lowestKinEnergy

private

Definition at line 270 of file G4VMultipleScattering.hh.

◆ modelManager

G4EmModelManager* G4VMultipleScattering::modelManager

private

Definition at line 253 of file G4VMultipleScattering.hh.

◆ mscModels

std::vector<G4VMscModel*> G4VMultipleScattering::mscModels

private

Definition at line 261 of file G4VMultipleScattering.hh.

◆ numberOfModels

G4int G4VMultipleScattering::numberOfModels

private

Definition at line 262 of file G4VMultipleScattering.hh.

◆ physStepLimit

G4double G4VMultipleScattering::physStepLimit

private

Definition at line 288 of file G4VMultipleScattering.hh.

◆ safetyHelper

G4SafetyHelper* G4VMultipleScattering::safetyHelper

private

Definition at line 259 of file G4VMultipleScattering.hh.

◆ stepLimit

G4MscStepLimitType G4VMultipleScattering::stepLimit

private

Definition at line 267 of file G4VMultipleScattering.hh.

◆ theParameters

G4EmParameters* G4VMultipleScattering::theParameters

private

Definition at line 255 of file G4VMultipleScattering.hh.

◆ tPathLength

G4double G4VMultipleScattering::tPathLength

private

Definition at line 289 of file G4VMultipleScattering.hh.

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

Private Attributes
G4EmModelManager *	modelManager

G4LossTableManager *	emManager

G4EmParameters *	theParameters

G4SafetyHelper *	safetyHelper

std::vector< G4VMscModel * >	mscModels

G4int	numberOfModels

const G4ParticleDefinition *	firstParticle

const G4ParticleDefinition *	currParticle

G4MscStepLimitType	stepLimit

G4double	facrange

G4double	lowestKinEnergy

G4bool	latDisplacement

G4bool	isIon

G4bool	fDispBeyondSafety

G4VMscModel *	currentModel

G4VEnergyLossProcess *	fIonisation

G4double	physStepLimit

G4double	tPathLength

G4double	gPathLength

G4ThreeVector	fNewPosition

G4ThreeVector	fNewDirection

G4bool	fPositionChanged

G4bool	isActive

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4VMultipleScattering() [1/2]

◆ ~G4VMultipleScattering()

◆ G4VMultipleScattering() [2/2]

Member Function Documentation

◆ AddEmModel()

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ BuildPhysicsTable()

◆ ContinuousStepLimit()

◆ EmModel()

◆ FirstParticle()

◆ GeomFactor()

◆ GetContinuousStepLimit()

◆ GetMeanFreePath()

◆ GetModelByIndex()

◆ InitialiseProcess()

◆ IsApplicable()

◆ LateralDisplasmentFlag()

◆ LowestKinEnergy()

◆ operator=()

◆ PolarAngleLimit()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PreparePhysicsTable()

◆ PrintInfo()

◆ PrintInfoDefinition()

◆ ProcessDescription()

◆ RangeFactor()

◆ RetrievePhysicsTable()

◆ SelectModel()

◆ SetEmModel()

◆ SetIonisation()

◆ SetLateralDisplasmentFlag()

◆ SetLowestKinEnergy()

◆ SetRangeFactor()

◆ SetSkin()

◆ SetStepLimitType()

◆ Skin()

◆ StartTracking()

◆ StepLimitType()

◆ StorePhysicsTable()

Member Data Documentation

◆ currentModel

◆ currParticle

◆ emManager

◆ facrange

◆ fDispBeyondSafety

◆ fIonisation

◆ firstParticle

◆ fNewDirection

◆ fNewPosition

◆ fParticleChange

◆ fPositionChanged

◆ gPathLength

◆ isActive

◆ isIon

◆ latDisplacement

◆ lowestKinEnergy

◆ modelManager

◆ mscModels

◆ numberOfModels

◆ physStepLimit

◆ safetyHelper

◆ stepLimit

◆ theParameters

◆ tPathLength