#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) override=0

virtual void	PrintInfo ()=0

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

void	PreparePhysicsTable (const G4ParticleDefinition &) override

void	BuildPhysicsTable (const G4ParticleDefinition &) override

void	PrintInfoDefinition ()

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

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

void	StartTracking (G4Track *) override

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

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

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

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

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=nullptr)

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

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

size_t	NumberOfModels () const

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

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::G4VMultipleScattering	(	const G4String &	name = `"msc"`,
		G4ProcessType	type = `fElectromagnetic`
	)

Definition at line 91 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;
 
   geomMin   = 0.05*CLHEP::nm;
   minDisplacement2 = geomMin*geomMin;
 
   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 ( )

virtual

Definition at line 130 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:

Member Function Documentation

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

Definition at line 144 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:

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

overridevirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 481 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);
   
     /*    
     if(currParticle->GetPDGMass() > 0.9*GeV)    
     G4cout << "G4VMsc::AlongStepDoIt: GeomLength= " 
            << geomLength 
            << " tPathLength= " << tPathLength
            << " physStepLimit= " << physStepLimit
            << " dr= " << range - tPathLength
            << " ekin= " << track.GetKineticEnergy() << G4endl;
     */
     // protection against wrong t->g->t conversion
     tPathLength = std::min(tPathLength, physStepLimit);
 
     // do not sample scattering at the last or at a small step
     if(tPathLength < range && tPathLength > geomMin) {
 
       static const G4double minSafety = 1.20*CLHEP::nm;
       static const G4double sFact = 0.99;
 
       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;
     G4double dispR = std::sqrt(r2);
         G4double postSafety = 
       sFact*safetyHelper->ComputeSafety(fNewPosition, dispR); 
         //G4cout<<"    R= "<< dispR<<" postSafety= "<<postSafety<<G4endl;
 
         // far away from geometry boundary
         if(postSafety > 0.0 && dispR <= postSafety) {
           fNewPosition += displacement;
 
       //near the boundary
         } else {
           // 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;
           }
         }
     if(fPositionChanged) { 
       safetyHelper->ReLocateWithinVolume(fNewPosition);
       fParticleChange.ProposePosition(fNewPosition); 
     }
       }
     }
   }
   fParticleChange.ProposeTrueStepLength(tPathLength);
   return &fParticleChange;
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 414 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:

void G4VMultipleScattering::BuildPhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 291 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::BuildPhysicsTable() 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:

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:

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

Definition at line 163 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:

const G4ParticleDefinition * G4VMultipleScattering::FirstParticle ( ) const

inline

Definition at line 405 of file G4VMultipleScattering.hh.

 {
   return firstParticle;
 }

G4double G4VMultipleScattering::GeomFactor ( ) const

inline

Definition at line 361 of file G4VMultipleScattering.hh.

 {
   return theParameters->MscGeomFactor();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overrideprotectedvirtual

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:

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

overrideprotectedvirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 675 of file G4VMultipleScattering.cc.

 {
   *condition = Forced;
   return DBL_MAX;
 }

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

Definition at line 173 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:

virtual void G4VMultipleScattering::InitialiseProcess ( const G4ParticleDefinition * )

protectedpure virtual

Implemented in G4AdjointhMultipleScattering, G4eAdjointMultipleScattering, G4hMultipleScattering, G4MuMultipleScattering, and G4eMultipleScattering.

Here is the caller graph for this function:

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

overridepure virtual

Reimplemented from G4VProcess.

Implemented in G4AdjointhMultipleScattering, G4eAdjointMultipleScattering, G4hMultipleScattering, G4MuMultipleScattering, and G4eMultipleScattering.

G4bool G4VMultipleScattering::LateralDisplasmentFlag ( ) const

inline

Definition at line 316 of file G4VMultipleScattering.hh.

 {
   return latDisplacement;
 }

Here is the caller graph for this function:

G4double G4VMultipleScattering::LowestKinEnergy ( ) const

inline

Definition at line 391 of file G4VMultipleScattering.hh.

 {
   return lowestKinEnergy;
 }

size_t G4VMultipleScattering::NumberOfModels ( ) const

inlineprotected

Definition at line 412 of file G4VMultipleScattering.hh.

 {
   return modelManager->NumberOfModels();
 }

Here is the call graph for this function:

G4double G4VMultipleScattering::PolarAngleLimit ( ) const

inline

Definition at line 368 of file G4VMultipleScattering.hh.

 {
   return theParameters->MscThetaLimit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 639 of file G4VMultipleScattering.cc.

 {
   fParticleChange.Initialize(track);
   return &fParticleChange;
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 470 of file G4VMultipleScattering.cc.

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

void G4VMultipleScattering::PreparePhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 181 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();
     /*
         G4cout << "### G4VMultipleScattering::PreparePhysicsTable() for "
         << GetProcessName()
         << " and particle " << part.GetParticleName()
         << " Nmod= " << numberOfModels << "  " << this
         << G4endl;
     */
     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:

virtual void G4VMultipleScattering::PrintInfo ( )

pure virtual

Implemented in G4AdjointhMultipleScattering, G4eAdjointMultipleScattering, G4hMultipleScattering, G4MuMultipleScattering, and G4eMultipleScattering.

Here is the caller graph for this function:

void G4VMultipleScattering::PrintInfoDefinition ( )

Definition at line 367 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:

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:

G4double G4VMultipleScattering::RangeFactor ( ) const

inline

Definition at line 344 of file G4VMultipleScattering.hh.

 {
   return facrange;
 }

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from G4VProcess.

Definition at line 729 of file G4VMultipleScattering.cc.

 {
   return true;
 }

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

inline

Definition at line 309 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:

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

Definition at line 154 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:

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:

void G4VMultipleScattering::SetLateralDisplasmentFlag ( G4bool val )

inline

Definition at line 323 of file G4VMultipleScattering.hh.

 {
   latDisplacement = val;
 }

void G4VMultipleScattering::SetLowestKinEnergy ( G4double val )

inline

Definition at line 398 of file G4VMultipleScattering.hh.

 {
   lowestKinEnergy = val;
 }

void G4VMultipleScattering::SetRangeFactor ( G4double val )

inline

Definition at line 351 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:

void G4VMultipleScattering::SetSkin ( G4double val )

inline

Definition at line 337 of file G4VMultipleScattering.hh.

 {
   theParameters->SetMscSkin(val);
 }

Here is the call graph for this function:

void G4VMultipleScattering::SetStepLimitType ( G4MscStepLimitType val )

inline

Definition at line 382 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:

G4double G4VMultipleScattering::Skin ( ) const

inline

Definition at line 330 of file G4VMultipleScattering.hh.

 {
   return theParameters->MscSkin();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VMultipleScattering::StartTracking ( G4Track * track )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 381 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:

Here is the caller graph for this function:

G4MscStepLimitType G4VMultipleScattering::StepLimitType ( ) const

inline

Definition at line 375 of file G4VMultipleScattering.hh.

 {
   return stepLimit;
 }

Here is the caller graph for this function:

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

overridevirtual

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

G4ParticleChangeForMSC G4VMultipleScattering::fParticleChange

protected

Definition at line 284 of file G4VMultipleScattering.hh.

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

source/geant4.10.03.p03/source/processes/electromagnetic/utils/include/G4VMultipleScattering.hh
source/geant4.10.03.p03/source/processes/electromagnetic/utils/src/G4VMultipleScattering.cc

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation