#include <G4GoudsmitSaundersonMscModel.hh>

Inheritance diagram for G4GoudsmitSaundersonMscModel:

Public Member Functions
virtual G4double	ChargeSquareRatio (const G4Track &)

G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition , const G4Element , G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)

virtual G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A=0., G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)

virtual G4double	ComputeCrossSectionPerShell (const G4ParticleDefinition *, G4int Z, G4int shellIdx, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)

G4double	ComputeDEDX (const G4MaterialCutsCouple , const G4ParticleDefinition , G4double kineticEnergy, G4double cutEnergy=DBL_MAX)

virtual G4double	ComputeDEDXPerVolume (const G4Material , const G4ParticleDefinition , G4double kineticEnergy, G4double cutEnergy=DBL_MAX)

G4double	ComputeGeomLimit (const G4Track &, G4double &presafety, G4double limit)

G4double	ComputeGeomPathLength (G4double truePathLength) override

G4double	ComputeMeanFreePath (const G4ParticleDefinition , G4double kineticEnergy, const G4Material , G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)

G4double	ComputeSafety (const G4ThreeVector &position, G4double limit=DBL_MAX)

G4double	ComputeTruePathLengthLimit (const G4Track &track, G4double &currentMinimalStep) override

G4double	ComputeTrueStepLength (G4double geomStepLength) override

virtual void	CorrectionsAlongStep (const G4MaterialCutsCouple , const G4DynamicParticle , const G4double &length, G4double &eloss)

G4double	CrossSection (const G4MaterialCutsCouple , const G4ParticleDefinition , G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)

G4double	CrossSectionPerVolume (const G4Material , const G4ParticleDefinition , G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX) override

G4bool	DeexcitationFlag () const

virtual void	DefineForRegion (const G4Region *)

void	DumpParameters (std::ostream &out) const

virtual void	FillNumberOfSecondaries (G4int &numberOfTriplets, G4int &numberOfRecoil)

G4bool	ForceBuildTableFlag () const

	G4GoudsmitSaundersonMscModel (const G4GoudsmitSaundersonMscModel &)=delete

	G4GoudsmitSaundersonMscModel (const G4String &nam="GoudsmitSaunderson")

G4VEmAngularDistribution *	GetAngularDistribution ()

virtual G4double	GetChargeSquareRatio (const G4ParticleDefinition , const G4Material , G4double kineticEnergy)

G4PhysicsTable *	GetCrossSectionTable ()

const G4Element *	GetCurrentElement () const

const G4Isotope *	GetCurrentIsotope () const

G4double	GetDEDX (const G4ParticleDefinition part, G4double kineticEnergy, const G4MaterialCutsCouple couple)

G4double	GetDEDX (const G4ParticleDefinition part, G4double kineticEnergy, const G4MaterialCutsCouple couple, G4double logKineticEnergy)

G4ElementData *	GetElementData ()

std::vector< G4EmElementSelector * > *	GetElementSelectors ()

G4double	GetEnergy (const G4ParticleDefinition part, G4double range, const G4MaterialCutsCouple couple)

G4GoudsmitSaundersonTable *	GetGSTable ()

G4VEnergyLossProcess *	GetIonisation () const

G4VEmFluctuationModel *	GetModelOfFluctuations ()

const G4String &	GetName () const

G4bool	GetOptionMottCorrection () const

G4bool	GetOptionPWACorrection () const

virtual G4double	GetPartialCrossSection (const G4Material , G4int level, const G4ParticleDefinition , G4double kineticEnergy)

virtual G4double	GetParticleCharge (const G4ParticleDefinition , const G4Material , G4double kineticEnergy)

G4GSPWACorrections *	GetPWACorrection ()

G4double	GetRange (const G4ParticleDefinition part, G4double kineticEnergy, const G4MaterialCutsCouple couple)

G4double	GetRange (const G4ParticleDefinition part, G4double kineticEnergy, const G4MaterialCutsCouple couple, G4double logKineticEnergy)

G4double	GetTransportMeanFreePath (const G4ParticleDefinition *, G4double)

G4double	GetTransportMeanFreePath (const G4ParticleDefinition *part, G4double kinEnergy, G4double logKinEnergy)

G4VEmModel *	GetTripletModel ()

G4double	HighEnergyActivationLimit () const

G4double	HighEnergyLimit () const

void	Initialise (const G4ParticleDefinition *, const G4DataVector &) override

void	InitialiseElementSelectors (const G4ParticleDefinition *, const G4DataVector &)

virtual void	InitialiseForElement (const G4ParticleDefinition *, G4int Z)

virtual void	InitialiseForMaterial (const G4ParticleDefinition , const G4Material )

void	InitialiseLocal (const G4ParticleDefinition p, G4VEmModel masterModel) override

void	InitialiseParameters (const G4ParticleDefinition *)

G4bool	IsActive (G4double kinEnergy) const

G4bool	IsLocked () const

G4bool	IsMaster () const

G4double	LowEnergyActivationLimit () const

G4double	LowEnergyLimit () const

G4bool	LPMFlag () const

G4double	MaxSecondaryKinEnergy (const G4DynamicParticle *dynParticle)

virtual G4double	MinEnergyCut (const G4ParticleDefinition , const G4MaterialCutsCouple )

virtual G4double	MinPrimaryEnergy (const G4Material , const G4ParticleDefinition , G4double cut=0.0)

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

G4GoudsmitSaundersonMscModel &	operator= (const G4GoudsmitSaundersonMscModel &right)=delete

G4double	PolarAngleLimit () const

void	SampleMSC ()

G4ThreeVector &	SampleScattering (const G4ThreeVector &, G4double safety) override

void	SampleSecondaries (std::vector< G4DynamicParticle * > , const G4MaterialCutsCouple , const G4DynamicParticle *, G4double tmin, G4double tmax) override

G4double	SecondaryThreshold () const

G4int	SelectIsotopeNumber (const G4Element *)

const G4Element *	SelectRandomAtom (const G4Material , const G4ParticleDefinition , G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)

const G4Element *	SelectRandomAtom (const G4MaterialCutsCouple , const G4ParticleDefinition , G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)

G4int	SelectRandomAtomNumber (const G4Material *)

const G4Element *	SelectTargetAtom (const G4MaterialCutsCouple , const G4ParticleDefinition , G4double kineticEnergy, G4double logKineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)

void	SetActivationHighEnergyLimit (G4double)

void	SetActivationLowEnergyLimit (G4double)

void	SetAngularDistribution (G4VEmAngularDistribution *)

void	SetAngularGeneratorFlag (G4bool)

void	SetCrossSectionTable (G4PhysicsTable *, G4bool isLocal)

void	SetCurrentCouple (const G4MaterialCutsCouple *)

void	SetDeexcitationFlag (G4bool val)

void	SetElementSelectors (std::vector< G4EmElementSelector * > *)

void	SetFluctuationFlag (G4bool val)

void	SetForceBuildTable (G4bool val)

void	SetGeomFactor (G4double)

void	SetHighEnergyLimit (G4double)

void	SetIonisation (G4VEnergyLossProcess , const G4ParticleDefinition part)

void	SetLambdaLimit (G4double)

void	SetLateralDisplasmentFlag (G4bool val)

void	SetLocked (G4bool)

void	SetLowEnergyLimit (G4double)

void	SetLPMFlag (G4bool val)

void	SetMasterThread (G4bool val)

void	SetOptionMottCorrection (G4bool opt)

void	SetOptionPWACorrection (G4bool opt)

void	SetParticleChange (G4VParticleChange , G4VEmFluctuationModel f=nullptr)

void	SetPolarAngleLimit (G4double)

void	SetRangeFactor (G4double)

void	SetSafetyFactor (G4double)

void	SetSampleZ (G4bool)

void	SetSecondaryThreshold (G4double)

void	SetSkin (G4double)

void	SetStepLimitType (G4MscStepLimitType)

void	SetTripletModel (G4VEmModel *)

virtual void	SetupForMaterial (const G4ParticleDefinition , const G4Material , G4double kineticEnergy)

void	SetUseBaseMaterials (G4bool val)

void	StartTracking (G4Track *) override

G4bool	UseAngularGeneratorFlag () const

G4bool	UseBaseMaterials () const

virtual G4double	Value (const G4MaterialCutsCouple , const G4ParticleDefinition , G4double kineticEnergy)

	~G4GoudsmitSaundersonMscModel () override

Protected Member Functions
G4double	ConvertTrueToGeom (G4double &tLength, G4double &gLength)

const G4MaterialCutsCouple *	CurrentCouple () const

G4ParticleChangeForGamma *	GetParticleChangeForGamma ()

G4ParticleChangeForLoss *	GetParticleChangeForLoss ()

G4ParticleChangeForMSC *	GetParticleChangeForMSC (const G4ParticleDefinition *p=nullptr)

virtual G4double	MaxSecondaryEnergy (const G4ParticleDefinition *, G4double kineticEnergy)

void	SetCurrentElement (const G4Element *)

Protected Attributes
size_t	basedCoupleIndex = 0

size_t	currentCoupleIndex = 0

G4double	dtrl = 0.05

G4double	facgeom = 2.5

G4double	facrange = 0.04

G4double	facsafety = 0.6

G4ThreeVector	fDisplacement

G4ElementData *	fElementData = nullptr

G4double	geomMax

G4double	geomMin

G4double	inveplus

G4double	lambdalimit

G4bool	latDisplasment = true

G4bool	lossFlucFlag = true

const G4Material *	pBaseMaterial = nullptr

G4double	pFactor = 1.0

G4VParticleChange *	pParticleChange = nullptr

G4bool	samplez = false

G4double	skin = 1.0

G4MscStepLimitType	steppingAlgorithm

const std::vector< G4double > *	theDensityFactor = nullptr

const std::vector< G4int > *	theDensityIdx = nullptr

G4PhysicsTable *	xSectionTable = nullptr

Private Member Functions
G4double	GetLambda (G4double)

G4double	GetTransportMeanFreePathOnly (const G4ParticleDefinition *, G4double)

G4double	Randomizetlimit ()

void	SetParticle (const G4ParticleDefinition *p)

Private Attributes
G4VEmAngularDistribution *	anglModel = nullptr

G4int	charge

const G4MaterialCutsCouple *	currentCouple

G4double	currentKinEnergy

G4int	currentMaterialIndex

const G4ParticleDefinition *	currentPart = nullptr

G4double	currentRange

G4double	dedx = 0.0

std::vector< G4EmElementSelector * > *	elmSelectors = nullptr

G4double	eMaxActive = DBL_MAX

G4double	eMinActive = 0.0

const G4MaterialCutsCouple *	fCurrentCouple = nullptr

const G4Element *	fCurrentElement = nullptr

const G4Isotope *	fCurrentIsotope = nullptr

G4LossTableManager *	fEmManager

G4double	fG1

G4GoudsmitSaundersonTable *	fGSTable

G4bool	firstStep

G4bool	fIsEndedUpOnBoundary

G4bool	fIsEverythingWasDone

G4bool	fIsFirstRealStep

G4bool	fIsInsideSkin

G4bool	fIsMultipleSacettring

G4bool	fIsNoDisplace

G4bool	fIsNoScatteringInMSC

G4bool	fIsSingleScattering

G4bool	fIsUseMottCorrection

G4bool	fIsUsePWACorrection

G4bool	fIsWasOnBoundary

G4bool	flagDeexcitation = false

G4bool	flagForceBuildTable = false

G4double	fLambda0

G4double	fLambda1

G4VEmFluctuationModel *	flucModel = nullptr

G4double	fMCtoG2PerG1

G4double	fMCtoQ1

G4double	fMCtoScrA

G4ParticleChangeForMSC *	fParticleChange

G4GSPWACorrections *	fPWACorrection

G4double	fr

G4double	fScrA

G4ThreeVector	fTheDisplacementVector

G4ThreeVector	fTheNewDirection

G4double	fTheTransportDistance

G4double	fTheTrueStepLenght

G4double	fTheZPathLenght

G4VEmModel *	fTripletModel = nullptr

G4double	fZeff

G4double	geombig

G4double	geomlimit

G4double	highLimit

G4VEnergyLossProcess *	ionisation = nullptr

G4bool	isLocked = false

G4bool	isMaster = true

G4bool	localElmSelectors = true

G4double	localrange = DBL_MAX

G4bool	localTable = true

G4double	localtkin = 0.0

G4double	lowLimit

G4double	mass

const G4String	name

G4int	nsec = 5

G4int	nSelectors = 0

G4double	par1

G4double	par2

G4double	par3

const G4ParticleDefinition *	particle

G4double	polarAngleLimit

G4double	presafety

G4double	rangeinit

CLHEP::HepRandomEngine *	rndmEngineMod

G4SafetyHelper *	safetyHelper = nullptr

G4double	secondaryThreshold = DBL_MAX

G4double	taulim

G4double	tausmall

G4double	tgeom

G4bool	theLPMflag = false

G4LossTableManager *	theManager

G4double	tlimit

G4double	tlimitminfix2

G4bool	useAngularGenerator = false

G4bool	useBaseMaterials = false

std::vector< G4double >	xsec

Static Private Attributes
static G4bool	gIsOptimizationOn = true

static G4bool	gIsUseAccurate = true

Detailed Description

Definition at line 138 of file G4GoudsmitSaundersonMscModel.hh.

Constructor & Destructor Documentation

◆ G4GoudsmitSaundersonMscModel() [1/2]

G4GoudsmitSaundersonMscModel::G4GoudsmitSaundersonMscModel ( const G4String & nam = "GoudsmitSaunderson" )

Definition at line 163 of file G4GoudsmitSaundersonMscModel.cc.

  : G4VMscModel(nam) {
  charge                 = 0;
  currentMaterialIndex   = -1;
  //
  fr                     = 0.1;
  rangeinit              = 1.e+21;
  geombig                = 1.e+50*mm;
  geomlimit              = geombig;
  tgeom                  = geombig;
  tlimit                 = 1.e+10*mm;
  presafety              = 0.*mm;
  //
  particle               = 0;
  theManager             = G4LossTableManager::Instance();
  firstStep              = true;
  currentKinEnergy       = 0.0;
  currentRange           = 0.0;
  //
  tlimitminfix2          = 1.*nm;
  tausmall               = 1.e-16;
  mass                   = electron_mass_c2;
  taulim                 = 1.e-6;
  //
  currentCouple          = nullptr;
  fParticleChange        = nullptr;
  //
  fZeff                  = 1.;
  //
  par1                   = 0.;
  par2                   = 0.;
  par3                   = 0.;
  //
  // Moliere screeing parameter will be used and (by default) corrections are
  // appalied to the integrated quantities (screeing parameter, elastic mfp, first
  // and second moments) derived from the corresponding PWA quantities
  // this PWA correction is ignored if Mott-correction is set to true because
  // Mott-correction contains all these corrections as well
  fIsUsePWACorrection    = true;
  //
  fIsUseMottCorrection   = false;
  //
  fLambda0               = 0.0; // elastic mean free path
  fLambda1               = 0.0; // first transport mean free path
  fScrA                  = 0.0; // screening parameter
  fG1                    = 0.0; // first transport coef.
  //
  fMCtoScrA              = 1.0;
  fMCtoQ1                = 1.0;
  fMCtoG2PerG1           = 1.0;
  //
  fTheTrueStepLenght     = 0.;
  fTheTransportDistance  = 0.;
  fTheZPathLenght        = 0.;
  //
  fTheDisplacementVector.set(0.,0.,0.);
  fTheNewDirection.set(0.,0.,1.);
  //
  fIsEverythingWasDone   = false;
  fIsMultipleSacettring  = false;
  fIsSingleScattering    = false;
  fIsEndedUpOnBoundary   = false;
  fIsNoScatteringInMSC   = false;
  fIsNoDisplace          = false;
  fIsInsideSkin          = false;
  fIsWasOnBoundary       = false;
  fIsFirstRealStep       = false;
  rndmEngineMod          = G4Random::getTheEngine();
  //
  fGSTable               = nullptr;
  fPWACorrection         = nullptr;
}

References charge, currentCouple, currentKinEnergy, currentMaterialIndex, currentRange, source.hepunit::electron_mass_c2, fG1, fGSTable, firstStep, fIsEndedUpOnBoundary, fIsEverythingWasDone, fIsFirstRealStep, fIsInsideSkin, fIsMultipleSacettring, fIsNoDisplace, fIsNoScatteringInMSC, fIsSingleScattering, fIsUseMottCorrection, fIsUsePWACorrection, fIsWasOnBoundary, fLambda0, fLambda1, fMCtoG2PerG1, fMCtoQ1, fMCtoScrA, fParticleChange, fPWACorrection, fr, fScrA, fTheDisplacementVector, fTheNewDirection, fTheTransportDistance, fTheTrueStepLenght, fTheZPathLenght, fZeff, geombig, geomlimit, G4LossTableManager::Instance(), mass, mm, nm, par1, par2, par3, particle, presafety, rangeinit, rndmEngineMod, CLHEP::Hep3Vector::set(), taulim, tausmall, tgeom, theManager, tlimit, and tlimitminfix2.

◆ ~G4GoudsmitSaundersonMscModel()

G4GoudsmitSaundersonMscModel::~G4GoudsmitSaundersonMscModel ( )

override

Definition at line 237 of file G4GoudsmitSaundersonMscModel.cc.

                                                            {
  if (IsMaster()) {
    if (fGSTable) {
      delete fGSTable;
      fGSTable = nullptr;
    }
    if (fPWACorrection) {
      delete fPWACorrection;
      fPWACorrection = nullptr;
    }
  }
}

References fGSTable, fPWACorrection, and G4VEmModel::IsMaster().

◆ G4GoudsmitSaundersonMscModel() [2/2]

G4GoudsmitSaundersonMscModel::G4GoudsmitSaundersonMscModel ( const G4GoudsmitSaundersonMscModel & )

delete

Member Function Documentation

◆ ChargeSquareRatio()

G4double G4VEmModel::ChargeSquareRatio ( const G4Track & track )

virtualinherited

Reimplemented in G4BraggIonGasModel, and G4BetheBlochIonGasModel.

Definition at line 374 of file G4VEmModel.cc.

{
  return GetChargeSquareRatio(track.GetParticleDefinition(), 
                              track.GetMaterial(), track.GetKineticEnergy());
}

References G4VEmModel::GetChargeSquareRatio(), G4Track::GetKineticEnergy(), G4Track::GetMaterial(), and G4Track::GetParticleDefinition().

Referenced by G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ ComputeCrossSectionPerAtom() [1/2]

G4double G4VEmModel::ComputeCrossSectionPerAtom	(	const G4ParticleDefinition *	part,
		const G4Element *	elm,
		G4double	kinEnergy,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

inlineinherited

Definition at line 566 of file G4VEmModel.hh.

{
  SetCurrentElement(elm);
  return ComputeCrossSectionPerAtom(part,kinEnergy,elm->GetZ(),elm->GetN(),
                                    cutEnergy,maxEnergy);
}

References G4VEmModel::ComputeCrossSectionPerAtom(), G4Element::GetN(), G4Element::GetZ(), and G4VEmModel::SetCurrentElement().

◆ ComputeCrossSectionPerAtom() [2/2]

G4double G4VEmModel::ComputeCrossSectionPerAtom	(	const G4ParticleDefinition *	,
		G4double	kinEnergy,
		G4double	Z,
		G4double	A = `0.`,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

virtualinherited

Reimplemented in G4eDPWACoulombScatteringModel, G4eBremsstrahlungRelModel, G4LivermorePhotoElectricModel, G4eSingleCoulombScatteringModel, G4IonCoulombScatteringModel, G4PolarizedComptonModel, G4eCoulombScatteringModel, G4hCoulombScatteringModel, G4KleinNishinaCompton, G4KleinNishinaModel, G4PEEffectFluoModel, G4JAEAElasticScatteringModel, G4JAEAPolarizedElasticScatteringModel, G4LivermoreComptonModel, G4LivermoreIonisationModel, G4LivermoreNuclearGammaConversionModel, G4LivermorePolarizedComptonModel, G4LivermorePolarizedGammaConversionModel, G4LivermorePolarizedRayleighModel, G4LivermoreRayleighModel, G4LowEPComptonModel, G4LowEPPolarizedComptonModel, G4PenelopeAnnihilationModel, G4PenelopeGammaConversionModel, G4PenelopePhotoElectricModel, G4PenelopeRayleighModel, G4PenelopeRayleighModelMI, G4XrayRayleighModel, G4BoldyshevTripletModel, G4BetheHeitlerModel, G4PairProductionRelModel, G4eplusTo2GammaOKVIModel, G4eplusTo3GammaOKVIModel, G4eeToTwoGammaModel, G4EmMultiModel, G4LivermoreGammaConversion5DModel, G4LivermoreGammaConversionModel, G4WentzelVIModel, G4WentzelVIRelModel, G4mplIonisationWithDeltaModel, G4MuBetheBlochModel, G4MuBremsstrahlungModel, G4MuPairProductionModel, G4AtimaEnergyLossModel, G4BetheBlochModel, G4BraggIonModel, G4BraggModel, G4ICRU73QOModel, G4LindhardSorensenIonModel, G4MollerBhabhaModel, G4eeToHadronsModel, G4eeToHadronsMultiModel, G4eBremParametrizedModel, G4IonParametrisedLossModel, G4PenelopeComptonModel, G4PenelopeIonisationModel, G4UrbanAdjointMscModel, G4UrbanMscModel, and G4PenelopeBremsstrahlungModel.

Definition at line 341 of file G4VEmModel.cc.

{
  return 0.0;
}

Referenced by G4AdjointPhotoElectricModel::AdjointCrossSectionPerAtom(), G4VEmModel::ComputeCrossSectionPerAtom(), G4EmCalculator::ComputeCrossSectionPerAtom(), G4VEmProcess::ComputeCrossSectionPerAtom(), G4EmCalculator::ComputeCrossSectionPerShell(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4VEmModel::CrossSectionPerVolume(), G4AdjointComptonModel::DiffCrossSectionPerAtomPrimToScatPrim(), G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), and G4EmElementSelector::Initialise().

◆ ComputeCrossSectionPerShell()

G4double G4VEmModel::ComputeCrossSectionPerShell	(	const G4ParticleDefinition *	,
		G4int	Z,
		G4int	shellIdx,
		G4double	kinEnergy,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

virtualinherited

Definition at line 351 of file G4VEmModel.cc.

{
  return 0.0;
}

Referenced by G4EmCalculator::ComputeCrossSectionPerShell().

◆ ComputeDEDX()

G4double G4VEmModel::ComputeDEDX	(	const G4MaterialCutsCouple *	couple,
		const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		G4double	cutEnergy = `DBL_MAX`
	)

inlineinherited

Definition at line 528 of file G4VEmModel.hh.

{
  SetCurrentCouple(couple);
  return pFactor*ComputeDEDXPerVolume(pBaseMaterial,part,kinEnergy,cutEnergy);
}

References G4VEmModel::ComputeDEDXPerVolume(), G4VEmModel::pBaseMaterial, G4VEmModel::pFactor, and G4VEmModel::SetCurrentCouple().

◆ ComputeDEDXPerVolume()

G4double G4VEmModel::ComputeDEDXPerVolume	(	const G4Material *	,
		const G4ParticleDefinition *	,
		G4double	kineticEnergy,
		G4double	cutEnergy = `DBL_MAX`
	)

virtualinherited

Reimplemented in G4eBremsstrahlungRelModel, G4PAIModel, G4PAIPhotModel, G4EmMultiModel, G4BetheBlochNoDeltaModel, G4BraggNoDeltaModel, G4ICRU73NoDeltaModel, G4mplIonisationModel, G4mplIonisationWithDeltaModel, G4LivermoreIonisationModel, G4PenelopeBremsstrahlungModel, G4PenelopeIonisationModel, G4MuBetheBlochModel, G4MuBremsstrahlungModel, G4MuPairProductionModel, G4BetheBlochModel, G4BraggIonModel, G4BraggModel, G4eBremParametrizedModel, G4LindhardSorensenIonModel, G4MollerBhabhaModel, G4ICRU49NuclearStoppingModel, G4AtimaEnergyLossModel, G4ICRU73QOModel, and G4IonParametrisedLossModel.

Definition at line 228 of file G4VEmModel.cc.

{
  return 0.0;
}

Referenced by G4NuclearStopping::AlongStepDoIt(), G4EmCorrections::BuildCorrectionVector(), G4VEmModel::ComputeDEDX(), G4EmCalculator::ComputeDEDX(), G4NIELCalculator::ComputeNIEL(), and G4EmCalculator::ComputeNuclearDEDX().

◆ ComputeGeomLimit()

G4double G4VMscModel::ComputeGeomLimit	(	const G4Track &	track,
		G4double &	presafety,
		G4double	limit
	)

inlineinherited

Definition at line 290 of file G4VMscModel.hh.

{
  return safetyHelper->CheckNextStep(
          track.GetStep()->GetPreStepPoint()->GetPosition(),
      track.GetMomentumDirection(),
      limit, presafety);
}

References G4SafetyHelper::CheckNextStep(), G4Track::GetMomentumDirection(), G4StepPoint::GetPosition(), G4Step::GetPreStepPoint(), G4Track::GetStep(), and G4VMscModel::safetyHelper.

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4LowEWentzelVIModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), and G4WentzelVIModel::ComputeTruePathLengthLimit().

◆ ComputeGeomPathLength()

G4double G4GoudsmitSaundersonMscModel::ComputeGeomPathLength ( G4double truePathLength )

overridevirtual

Implements G4VMscModel.

Definition at line 781 of file G4GoudsmitSaundersonMscModel.cc.

                                                                     {
  // convert true ->geom
  // It is called from the step limitation ComputeTruePathLengthLimit if
  // !fIsEverythingWasDone but protect:
  par1 = -1.;
  par2 = par3 = 0.;
  // if fIsEverythingWasDone = TRUE  => fTheZPathLenght is already set
  // so return with the already known value
  // Otherwise:
  if (!fIsEverythingWasDone) {
    // this correction needed to run MSC with eIoni and eBrem inactivated
    // and makes no harm for a normal run
    fTheTrueStepLenght = std::min(fTheTrueStepLenght,currentRange);
    //  do the true -> geom transformation
    fTheZPathLenght = fTheTrueStepLenght;
    // z = t for very small true-path-length
    if (fTheTrueStepLenght<tlimitminfix2) {
      return fTheZPathLenght;
    }
    G4double tau = fTheTrueStepLenght/fLambda1;
    if (tau<=tausmall) {
      fTheZPathLenght = std::min(fTheTrueStepLenght, fLambda1);
    } else  if (fTheTrueStepLenght<currentRange*dtrl) {
      if (tau<taulim) fTheZPathLenght = fTheTrueStepLenght*(1.-0.5*tau) ;
      else            fTheZPathLenght = fLambda1*(1.-G4Exp(-tau));
    } else if (currentKinEnergy<mass || fTheTrueStepLenght==currentRange)  {
      par1 = 1./currentRange ;     // alpha =1/range_init for Ekin<mass
      par2 = 1./(par1*fLambda1) ;  // 1/(alphaxlambda01)
      par3 = 1.+par2 ;             // 1+1/
      if (fTheTrueStepLenght<currentRange) {
        fTheZPathLenght = 1./(par1*par3) * (1.-std::pow(1.-par1*fTheTrueStepLenght,par3));
      } else {
        fTheZPathLenght = 1./(par1*par3);
      }
    } else {
      G4double rfin    = std::max(currentRange-fTheTrueStepLenght, 0.01*currentRange);
      G4double T1      = GetEnergy(particle,rfin,currentCouple);
      G4double lambda1 = GetTransportMeanFreePathOnly(particle,T1);
      //
      par1 = (fLambda1-lambda1)/(fLambda1*fTheTrueStepLenght);  // alpha
      par2 = 1./(par1*fLambda1);
      par3 = 1.+par2 ;
      G4Pow *g4calc = G4Pow::GetInstance();
      fTheZPathLenght = 1./(par1*par3) * (1.-g4calc->powA(1.-par1*fTheTrueStepLenght,par3));
    }
  }
  fTheZPathLenght = std::min(fTheZPathLenght, fLambda1);
  //
  return fTheZPathLenght;
}

References currentCouple, currentKinEnergy, currentRange, G4VMscModel::dtrl, fIsEverythingWasDone, fLambda1, fTheTrueStepLenght, fTheZPathLenght, G4Exp(), G4VMscModel::GetEnergy(), G4Pow::GetInstance(), GetTransportMeanFreePathOnly(), mass, G4INCL::Math::max(), G4INCL::Math::min(), par1, par2, par3, particle, G4Pow::powA(), taulim, tausmall, and tlimitminfix2.

◆ ComputeMeanFreePath()

G4double G4VEmModel::ComputeMeanFreePath	(	const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		const G4Material *	material,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

inlineinherited

Definition at line 553 of file G4VEmModel.hh.

{
  G4double cross = CrossSectionPerVolume(material,part,ekin,emin,emax);
  return (cross > 0.0) ? 1./cross : DBL_MAX;
}

References G4VEmModel::CrossSectionPerVolume(), DBL_MAX, emax, and eplot::material.

◆ ComputeSafety()

G4double G4VMscModel::ComputeSafety	(	const G4ThreeVector &	position,
		G4double	limit = `DBL_MAX`
	)

inlineinherited

Definition at line 272 of file G4VMscModel.hh.

{
   return safetyHelper->ComputeSafety(position, limit);
}

References G4SafetyHelper::ComputeSafety(), and G4VMscModel::safetyHelper.

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4LowEWentzelVIModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), and G4WentzelVIModel::ComputeTruePathLengthLimit().

◆ ComputeTruePathLengthLimit()

G4double G4GoudsmitSaundersonMscModel::ComputeTruePathLengthLimit	(	const G4Track &	track,
		G4double &	currentMinimalStep
	)

overridevirtual

Implements G4VMscModel.

Definition at line 469 of file G4GoudsmitSaundersonMscModel.cc.

                                                                                                      {
  G4double skindepth = 0.;
  //
  const G4DynamicParticle* dp = track.GetDynamicParticle();
  G4StepPoint* sp             = track.GetStep()->GetPreStepPoint();
  G4StepStatus stepStatus     = sp->GetStepStatus();
  currentCouple               = track.GetMaterialCutsCouple();
  SetCurrentCouple(currentCouple);
  currentMaterialIndex        = currentCouple->GetMaterial()->GetIndex();
  currentKinEnergy            = dp->GetKineticEnergy();
  currentRange                = GetRange(particle,currentKinEnergy,currentCouple,
                                         dp->GetLogKineticEnergy());
  // elastic and first transport mfp, screening parameter and G1 are also set
  // (Mott-correction will be used if it was requested by the user)
  fLambda1 = GetTransportMeanFreePath(particle,currentKinEnergy);
  // Set initial values:
  //  : lengths are initialised to currentMinimalStep  which is the true, minimum
  //    step length from all other physics
  fTheTrueStepLenght    = currentMinimalStep;
  fTheTransportDistance = currentMinimalStep;
  fTheZPathLenght       = currentMinimalStep;  // will need to be converted
  fTheDisplacementVector.set(0.,0.,0.);
  fTheNewDirection.set(0.,0.,1.);
 
  // Can everything be done in the step limit phase ?
  fIsEverythingWasDone  = false;
  // Multiple scattering needs to be sample ?
  fIsMultipleSacettring = false;
  // Single scattering needs to be sample ?
  fIsSingleScattering   = false;
  // Was zero deflection in multiple scattering sampling ?
  fIsNoScatteringInMSC  = false;
  // Do not care about displacement in MSC sampling
  // ( used only in the case of gIsOptimizationOn = true)
  fIsNoDisplace = false;
  // get pre-step point safety
  presafety = sp->GetSafety();
  //
  fZeff = currentCouple->GetMaterial()->GetIonisation()->GetZeffective();
  // distance will take into account max-fluct.
  G4double distance = currentRange;
  distance *= (1.20-fZeff*(1.62e-2-9.22e-5*fZeff));
  //
  // Possible optimization : if the distance is samller than the safety -> the
  // particle will never leave this volume -> dispalcement
  // as the effect of multiple elastic scattering can be skipped
  // Important : this optimization can cause problems if one does scoring
  // in a bigger volume since MSC won't be done deep inside the volume when
  // distance < safety so don't use optimized-mode in such case.
  if (gIsOptimizationOn && (distance<presafety)) {
     // Indicate that we need to do MSC after transportation and no dispalcement.
     fIsMultipleSacettring = true;
     fIsNoDisplace = true;
  } else if (steppingAlgorithm==fUseDistanceToBoundary) {
    //Compute geomlimit (and presafety) :
    // - geomlimit will be:
    //    == the straight line distance to the boundary if currentRange is
    //       longer than that
    //    == a big value [geombig = 1.e50*mm] if currentRange is shorter than
    //       the straight line distance to the boundary
    // - presafety will be updated as well
    // So the particle can travell 'gemlimit' distance (along a straight
    // line!) in its current direction:
    //  (1) before reaching a boundary (geomlimit < geombig) OR
    //  (2) before reaching its current range (geomlimit == geombig)
    geomlimit = ComputeGeomLimit(track, presafety, currentRange);
    // Record that the particle is on a boundary
    if ( (stepStatus==fGeomBoundary) || (stepStatus==fUndefined && presafety==0.0)) {
      fIsWasOnBoundary = true;
    }
    // Set skin depth = skin x elastic_mean_free_path
    skindepth     = skin*fLambda0;
    // Init the flag that indicates that the particle are within a skindepth
    // distance from a boundary
    fIsInsideSkin = false;
    // Check if we can try Single Scattering because we are within skindepth
    // distance from/to a boundary OR the current minimum true-step-length is
    // shorter than skindepth. NOTICE: the latest has only efficieny reasons
    // because the MSC angular sampling is fine for any short steps but much
    // faster to try single scattering in case of short steps.
    if ((stepStatus==fGeomBoundary) || (presafety<skindepth) || (fTheTrueStepLenght<skindepth)) {
      // check if we are within skindepth distance from a boundary
      if ((stepStatus == fGeomBoundary) || (presafety < skindepth)) {
        fIsInsideSkin    = true;
        fIsWasOnBoundary = true;
      }
      //Try single scattering:
      // - sample distance to next single scattering interaction (sslimit)
      // - compare to current minimum length
      //      == if sslimit is the shorter:
      //          - set the step length to sslimit
      //          - indicate that single scattering needs to be done
      //      == else : nothing to do
      //- in both cases, the step length was very short so geometrical and
      //  true path length are the same
      G4double sslimit = -1.*fLambda0*G4Log(G4UniformRand());
      // compare to current minimum step length
      if (sslimit<fTheTrueStepLenght) {
        fTheTrueStepLenght  = sslimit;
        fIsSingleScattering = true;
      }
      // short step -> true step length equal to geometrical path length
      fTheZPathLenght       = fTheTrueStepLenght;
      // Set taht everything is done in step-limit phase so no MSC call
      // We will check if we need to perform the single-scattering angular
      // sampling i.e. if single elastic scattering was the winer!
      fIsEverythingWasDone  = true;
    } else {
      // After checking we know that we cannot try single scattering so we will
      // need to make an MSC step
      // Indicate that we need to make and MSC step. We do not check if we can
      // do it now i.e. if presafety>final_true_step_length so we let the
      // fIsEverythingWasDone = false which indicates that we will perform
      // MSC after transportation.
      fIsMultipleSacettring = true;
      // Init the first-real-step falg: it will indicate if we do the first
      // non-single scattering step in this volume with this particle
      fIsFirstRealStep      = false;
      // If previously the partcile was on boundary it was within skin as
      // well. When it is not within skin anymore it has just left the skin
      // so we make the first real MSC step with the particle.
      if (fIsWasOnBoundary && !fIsInsideSkin) {
        // reset the 'was on boundary' indicator flag
        fIsWasOnBoundary  = false;
        fIsFirstRealStep  = true;
      }
      // If this is the first-real msc step (the partcile has just left the
      // skin) or this is the first step with the particle (was born or
      // primary):
      //   - set the initial range that will be used later to limit its step
      //     (only in this volume, because after boundary crossing at the
      //     first-real MSC step we will reset)
      //  - don't let the partcile to cross the volume just in one step
      if (firstStep || fIsFirstRealStep || rangeinit>1.e+20) {
        rangeinit = currentRange;
        // If geomlimit < geombig than the particle might reach the boundary
        // along its initial direction before losing its energy (in this step)
        // Otherwise we can be sure that the particle will lose it energy
        // before reaching the boundary along a starigth line so there is no
        // geometrical limit appalied. [However, tgeom is set only in the
        // first or the first-real MSC step. After the first or first real
        // MSC step the direction will change tgeom won't guaranty anything!
        // But we will try to end up within skindepth from the boundary using
        // the actual value of geomlimit(See later at step reduction close to
        // boundary).]
        if (geomlimit<geombig) {
          // transfrom straight line distance to the boundary to real step
          // length based on the mean values (using the prestep point
          // first-transport mean free path i.e. no energy loss correction)
          if ((1.-geomlimit/fLambda1)> 0.) {
            geomlimit = -fLambda1*G4Log(1.-geomlimit/fLambda1);
          }
          // the 2-different case that could lead us here
          if (firstStep) {
            tgeom = 2.*geomlimit/facgeom;
          } else {
            tgeom = geomlimit/facgeom;
          }
        } else {
          tgeom = geombig;
        }
      }
      // True step length limit from range factor. Noteice, that the initial
      // range is used that was set at the first step or first-real MSC step
      // in this volume with this particle.
      tlimit = facrange*rangeinit;
      // Take the minimum of the true step length limits coming from
      // geometrical constraint or range-factor limitation
      tlimit = std::min(tlimit,tgeom);
      // Step reduction close to boundary: we try to end up within skindepth
      // from the boundary ( Notice: in case of mag. field it might not work
      // because geomlimit is the straigth line distance to the boundary in
      // the currect direction (if geomlimit<geombig) and mag. field can
      // change the initial direction. So te particle might hit some boundary
      // before in a different direction. However, here we restrict the true
      // path length to this (straight line) lenght so the corresponding
      // transport distance (straight line) will be even shorter than
      // geomlimit-0.999*skindepth after the change of true->geom.
      if (geomlimit<geombig) {
        tlimit = std::min(tlimit, geomlimit-0.999*skindepth);
      }
      // randomize 1st step or 1st 'normal' step in volume
      if (firstStep || fIsFirstRealStep) {
        fTheTrueStepLenght = std::min(fTheTrueStepLenght, Randomizetlimit());
      } else {
        fTheTrueStepLenght = std::min(fTheTrueStepLenght, tlimit);
      }
    }
  } else if (steppingAlgorithm==fUseSafetyPlus) { // THE ERROR_FREE stepping alg.
    presafety =  ComputeSafety(sp->GetPosition(),fTheTrueStepLenght);
    geomlimit = presafety;
    // Set skin depth = skin x elastic_mean_free_path
    skindepth = skin*fLambda0;
    // Check if we can try Single Scattering because we are within skindepth
    // distance from/to a boundary OR the current minimum true-step-length is
    // shorter than skindepth. NOTICE: the latest has only efficieny reasons
    // because the MSC angular sampling is fine for any short steps but much
    // faster to try single scattering in case of short steps.
    if ((stepStatus==fGeomBoundary) || (presafety<skindepth) || (fTheTrueStepLenght<skindepth)) {
      //Try single scattering:
      // - sample distance to next single scattering interaction (sslimit)
      // - compare to current minimum length
      //      == if sslimit is the shorter:
      //          - set the step length to sslimit
      //          - indicate that single scattering needs to be done
      //      == else : nothing to do
      //- in both cases, the step length was very short so geometrical and
      //  true path length are the same
      G4double sslimit = -1.*fLambda0*G4Log(G4UniformRand());
      // compare to current minimum step length
      if (sslimit<fTheTrueStepLenght) {
        fTheTrueStepLenght  = sslimit;
        fIsSingleScattering = true;
      }
      // short step -> true step length equal to geometrical path length
      fTheZPathLenght       = fTheTrueStepLenght;
      // Set taht everything is done in step-limit phase so no MSC call
      // We will check if we need to perform the single-scattering angular
      // sampling i.e. if single elastic scattering was the winer!
      fIsEverythingWasDone  = true;
    } else {
      // After checking we know that we cannot try single scattering so we will
      // need to make an MSC step
      // Indicate that we need to make and MSC step.
      fIsMultipleSacettring = true;
      fIsEverythingWasDone  = true;
      // limit from range factor
      fTheTrueStepLenght    = std::min(fTheTrueStepLenght, facrange*currentRange);
      // never let the particle go further than the safety if we are out of the skin
      // if we are here we are out of the skin, presafety > 0.
      if (fTheTrueStepLenght>presafety) {
        fTheTrueStepLenght = std::min(fTheTrueStepLenght, presafety);
      }
      // make sure that we are still within the aplicability of condensed histry model
      // i.e. true step length is not longer than first transport mean free path.
      // We schould take into account energy loss along 0.5x lambda_transport1
      // step length as well. So let it 0.5 x lambda_transport1
      fTheTrueStepLenght = std::min(fTheTrueStepLenght, fLambda1*0.5);
    }
  } else {
    // This is the default stepping algorithm: the fastest but the least
    // accurate that corresponds to fUseSafety in Urban model. Note, that GS
    // model can handle any short steps so we do not need the minimum limits
    //
    // NO single scattering in case of skin or short steps (by defult the MSC
    // model will be single or even no scattering in case of short steps
    // compared to the elastic mean free path.)
    //
    // indicate that MSC needs to be done (always and always after transportation)
    fIsMultipleSacettring = true;
    if (stepStatus!=fGeomBoundary) {
      presafety = ComputeSafety(sp->GetPosition(),fTheTrueStepLenght);
    }
    // Far from boundary-> in optimized mode do not sample dispalcement.
    if ((distance<presafety) && (gIsOptimizationOn)) {
      fIsNoDisplace = true;
    } else {
      // Urban like
      if (firstStep || (stepStatus==fGeomBoundary) || rangeinit>1.e+20) {
        rangeinit = currentRange;
        fr        = facrange;
// We don't use this: we won't converge to the single scattering results with
//                    decreasing range-factor.
//              rangeinit = std::max(rangeinit, fLambda1);
//              if(fLambda1 > lambdalimit) {
//                fr *= (0.75+0.25*fLambda1/lambdalimit);
//              }
 
      }
      //step limit
      tlimit = std::max(fr*rangeinit, facsafety*presafety);
      // first step randomization
      if (firstStep || stepStatus==fGeomBoundary) {
        fTheTrueStepLenght = std::min(fTheTrueStepLenght, Randomizetlimit());
      } else {
        fTheTrueStepLenght = std::min(fTheTrueStepLenght, tlimit);
      }
    }
  }
  //
  // unset first-step
  firstStep =false;
  // performe single scattering, multiple scattering if this later can be done safely here
  if (fIsEverythingWasDone) {
    if (fIsSingleScattering) {
      // sample single scattering
      //G4double ekin   = 0.5*(currentKinEnergy + GetEnergy(particle,currentRange-fTheTrueStepLenght,currentCouple));
      G4double lekin  = G4Log(currentKinEnergy);
      G4double pt2    = currentKinEnergy*(currentKinEnergy+2.0*CLHEP::electron_mass_c2);
      G4double beta2  = pt2/(pt2+CLHEP::electron_mass_c2*CLHEP::electron_mass_c2);
      G4double cost   = fGSTable->SingleScattering(1., fScrA, lekin, beta2, currentMaterialIndex);
      // protection
      if (cost<-1.) cost = -1.;
      if (cost> 1.) cost =  1.;
      // compute sint
      G4double dum    = 1.-cost;
      G4double sint   = std::sqrt(dum*(2.-dum));
      G4double phi    = CLHEP::twopi*G4UniformRand();
      G4double sinPhi = std::sin(phi);
      G4double cosPhi = std::cos(phi);
      fTheNewDirection.set(sint*cosPhi,sint*sinPhi,cost);
    } else if (fIsMultipleSacettring) {
      // sample multiple scattering
      SampleMSC(); // fTheZPathLenght, fTheDisplacementVector and fTheNewDirection will be set
    } // and if single scattering but it was longer => nothing to do
  } //else { do nothing here but after transportation
  //
  return ConvertTrueToGeom(fTheTrueStepLenght,currentMinimalStep);
}

References G4VMscModel::ComputeGeomLimit(), G4VMscModel::ComputeSafety(), G4VMscModel::ConvertTrueToGeom(), currentCouple, currentKinEnergy, currentMaterialIndex, currentRange, CLHEP::electron_mass_c2, G4VMscModel::facgeom, G4VMscModel::facrange, G4VMscModel::facsafety, fGeomBoundary, fGSTable, firstStep, fIsEverythingWasDone, fIsFirstRealStep, fIsInsideSkin, fIsMultipleSacettring, fIsNoDisplace, fIsNoScatteringInMSC, fIsSingleScattering, fIsWasOnBoundary, fLambda0, fLambda1, fr, fScrA, fTheDisplacementVector, fTheNewDirection, fTheTransportDistance, fTheTrueStepLenght, fTheZPathLenght, fUndefined, fUseDistanceToBoundary, fUseSafetyPlus, fZeff, G4Log(), G4UniformRand, geombig, geomlimit, G4Track::GetDynamicParticle(), G4Material::GetIndex(), G4Material::GetIonisation(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetLogKineticEnergy(), G4MaterialCutsCouple::GetMaterial(), G4Track::GetMaterialCutsCouple(), G4Step::GetPreStepPoint(), G4VMscModel::GetRange(), G4Track::GetStep(), GetTransportMeanFreePath(), G4IonisParamMat::GetZeffective(), gIsOptimizationOn, G4INCL::Math::max(), G4INCL::Math::min(), particle, presafety, Randomizetlimit(), rangeinit, SampleMSC(), CLHEP::Hep3Vector::set(), G4VEmModel::SetCurrentCouple(), G4GoudsmitSaundersonTable::SingleScattering(), G4VMscModel::skin, G4InuclParticleNames::sp, G4VMscModel::steppingAlgorithm, tgeom, tlimit, and CLHEP::twopi.

◆ ComputeTrueStepLength()

G4double G4GoudsmitSaundersonMscModel::ComputeTrueStepLength ( G4double geomStepLength )

overridevirtual

Implements G4VMscModel.

Definition at line 833 of file G4GoudsmitSaundersonMscModel.cc.

                                                                                    {
  // init
  fIsEndedUpOnBoundary = false;
  // step defined other than transportation
  if (geomStepLength==fTheZPathLenght) {
    return fTheTrueStepLenght;
  }
  // else ::
  // - set the flag that transportation was the winer so DoNothin in DOIT !!
  // - convert geom -> true by using the mean value
  fIsEndedUpOnBoundary = true; // OR LAST STEP
  fTheZPathLenght      = geomStepLength;
  // was a short single scattering step
  if (fIsEverythingWasDone && !fIsMultipleSacettring) {
    fTheTrueStepLenght = geomStepLength;
    return fTheTrueStepLenght;
  }
  // t = z for very small step
  if (geomStepLength<tlimitminfix2) {
    fTheTrueStepLenght = geomStepLength;
  // recalculation
  } else {
    G4double tlength = geomStepLength;
    if (geomStepLength>fLambda1*tausmall) {
      if (par1< 0.) {
        tlength = -fLambda1*G4Log(1.-geomStepLength/fLambda1) ;
      } else {
        if (par1*par3*geomStepLength<1.) {
          G4Pow *g4calc = G4Pow::GetInstance();
          tlength = (1.-g4calc->powA( 1.-par1*par3*geomStepLength,1./par3))/par1;
        } else {
          tlength = currentRange;
        }
      }
      if (tlength<geomStepLength || tlength>fTheTrueStepLenght) {
        tlength = geomStepLength;
      }
    }
    fTheTrueStepLenght = tlength;
  }
  //
  return fTheTrueStepLenght;
}

References currentRange, fIsEndedUpOnBoundary, fIsEverythingWasDone, fIsMultipleSacettring, fLambda1, fTheTrueStepLenght, fTheZPathLenght, G4Log(), G4Pow::GetInstance(), par1, par3, G4Pow::powA(), tausmall, and tlimitminfix2.

◆ ConvertTrueToGeom()

G4double G4VMscModel::ConvertTrueToGeom	(	G4double &	tLength,
		G4double &	gLength
	)

inlineprotectedinherited

Definition at line 280 of file G4VMscModel.hh.

{
  glength = ComputeGeomPathLength(tlength);
  // should return true length 
  return tlength;
}

References G4VMscModel::ComputeGeomPathLength().

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4LowEWentzelVIModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), and G4WentzelVIModel::ComputeTruePathLengthLimit().

◆ CorrectionsAlongStep()

void G4VEmModel::CorrectionsAlongStep	(	const G4MaterialCutsCouple *	,
		const G4DynamicParticle *	,
		const G4double &	length,
		G4double &	eloss
	)

virtualinherited

Reimplemented in G4IonParametrisedLossModel, G4AtimaEnergyLossModel, G4BraggIonModel, G4ICRU73QOModel, G4BetheBlochModel, and G4LindhardSorensenIonModel.

Definition at line 399 of file G4VEmModel.cc.

402{}

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepDoIt(), G4EmCalculator::ComputeDEDX(), and G4EmCalculator::GetDEDX().

◆ CrossSection()

G4double G4VEmModel::CrossSection	(	const G4MaterialCutsCouple *	couple,
		const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

inlineinherited

Definition at line 539 of file G4VEmModel.hh.

{
  SetCurrentCouple(couple);
  return pFactor*CrossSectionPerVolume(pBaseMaterial,part,kinEnergy,
                                       cutEnergy,maxEnergy);
}

References G4VEmModel::CrossSectionPerVolume(), G4VEmModel::pBaseMaterial, G4VEmModel::pFactor, and G4VEmModel::SetCurrentCouple().

Referenced by G4PolarizedAnnihilation::ComputeAsymmetry(), G4PolarizedIonisation::ComputeAsymmetry(), G4PolarizedCompton::ComputeAsymmetry(), G4EmModelManager::FillLambdaVector(), and G4EmMultiModel::SampleSecondaries().

◆ CrossSectionPerVolume()

G4double G4GoudsmitSaundersonMscModel::CrossSectionPerVolume	(	const G4Material *	mat,
		const G4ParticleDefinition *	,
		G4double	kineticEnergy,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

overridevirtual

Reimplemented from G4VEmModel.

Definition at line 309 of file G4GoudsmitSaundersonMscModel.cc.

                                                   {
  G4double xsecTr1  = 0.; // cross section per volume i.e. macroscopic 1st transport cross section
  // 
  fLambda0 = 0.0; // elastic mean free path
  fLambda1 = 0.0; // first transport mean free path
  fScrA    = 0.0; // screening parameter
  fG1      = 0.0; // first transport coef.
  // use Moliere's screening (with Mott-corretion if it was requested)
  G4double efEnergy = std::max(kineticEnergy, 10.*CLHEP::eV);
  // total mometum square
  G4double pt2     = efEnergy*(efEnergy+2.0*electron_mass_c2);
  // beta square
  G4double beta2   = pt2/(pt2+electron_mass_c2*electron_mass_c2);
  // current material index
  G4int    matindx = mat->GetIndex();
  // Moliere's b_c
  G4double bc      = fGSTable->GetMoliereBc(matindx);
  // get the Mott-correcton factors if Mott-correcton was requested by the user
  fMCtoScrA       = 1.0;
  fMCtoQ1         = 1.0;
  fMCtoG2PerG1    = 1.0;
  G4double scpCor = 1.0;
  if (fIsUseMottCorrection) {
    fGSTable->GetMottCorrectionFactors(G4Log(efEnergy), beta2, matindx, fMCtoScrA, fMCtoQ1, fMCtoG2PerG1);
    // ! no scattering power correction since the current couple is not set before this interface method is called
    // scpCor = fGSTable->ComputeScatteringPowerCorrection(currentCouple, efEnergy);
  } else if (fIsUsePWACorrection) {
    fPWACorrection->GetPWACorrectionFactors(G4Log(efEnergy), beta2, matindx, fMCtoScrA, fMCtoQ1, fMCtoG2PerG1);
    // scpCor = fGSTable->ComputeScatteringPowerCorrection(currentCouple, efEnergy);
  }
  // screening parameter:
  // - if Mott-corretioncorrection: the Screened-Rutherford times Mott-corretion DCS with this
  //   screening parameter gives back the (elsepa) PWA first transport cross section
  // - if PWA correction: he Screened-Rutherford DCS with this screening parameter
  //   gives back the (elsepa) PWA first transport cross section
  fScrA    = fGSTable->GetMoliereXc2(matindx)/(4.0*pt2*bc)*fMCtoScrA;
  // elastic mean free path in Geant4 internal lenght units: the neglected (1+screening parameter) term is corrected
  // (if Mott-corretion: the corrected screening parameter is used for this (1+A) correction + Moliere b_c is also
  // corrected with the screening parameter correction)
  fLambda0 = beta2*(1.+fScrA)*fMCtoScrA/bc/scpCor;
  // first transport coefficient (if Mott-corretion: the corrected screening parameter is used (it will be fully
  // consistent with the one used during the pre-computation of the Mott-correted GS angular distributions))
  fG1      = 2.0*fScrA*((1.0+fScrA)*G4Log(1.0/fScrA+1.0)-1.0);
  // first transport mean free path
  fLambda1 = fLambda0/fG1;
  xsecTr1  = 1./fLambda1;
  return xsecTr1;
}

References source.hepunit::electron_mass_c2, CLHEP::eV, fG1, fGSTable, fIsUseMottCorrection, fIsUsePWACorrection, fLambda0, fLambda1, fMCtoG2PerG1, fMCtoQ1, fMCtoScrA, fPWACorrection, fScrA, G4Log(), G4Material::GetIndex(), G4GoudsmitSaundersonTable::GetMoliereBc(), G4GoudsmitSaundersonTable::GetMoliereXc2(), G4GoudsmitSaundersonTable::GetMottCorrectionFactors(), G4GSPWACorrections::GetPWACorrectionFactors(), and G4INCL::Math::max().

◆ CurrentCouple()

const G4MaterialCutsCouple * G4VEmModel::CurrentCouple ( ) const

inlineprotectedinherited

Definition at line 490 of file G4VEmModel.hh.

{
  return fCurrentCouple;
}

References G4VEmModel::fCurrentCouple.

◆ DeexcitationFlag()

G4bool G4VEmModel::DeexcitationFlag ( ) const

inlineinherited

Definition at line 704 of file G4VEmModel.hh.

{
  return flagDeexcitation;
}

References G4VEmModel::flagDeexcitation.

Referenced by G4EmModelManager::DumpModelList().

◆ DefineForRegion()

void G4VEmModel::DefineForRegion ( const G4Region * )

virtualinherited

Reimplemented in G4PAIModel, and G4PAIPhotModel.

Definition at line 360 of file G4VEmModel.cc.

361{}

Referenced by G4EmModelManager::AddEmModel().

◆ DumpParameters()

void G4VMscModel::DumpParameters ( std::ostream & out ) const

inherited

Definition at line 137 of file G4VMscModel.cc.

{
  G4String alg = "UseSafety";
  if (steppingAlgorithm == fUseDistanceToBoundary) alg = "DistanceToBoundary";
  else if (steppingAlgorithm == fMinimal) alg = "Minimal";
  else if (steppingAlgorithm == fUseSafetyPlus) alg = "SafetyPlus";
 
  out << std::setw(18) << "StepLim=" << alg << " Rfact=" << facrange 
      << " Gfact=" << facgeom << " Sfact=" << facsafety << " DispFlag:" << latDisplasment
      << " Skin=" << skin << " Llim=" << lambdalimit/CLHEP::mm << " mm" << G4endl;
}

References G4VMscModel::facgeom, G4VMscModel::facrange, G4VMscModel::facsafety, fMinimal, fUseDistanceToBoundary, fUseSafetyPlus, G4endl, G4VMscModel::lambdalimit, G4VMscModel::latDisplasment, CLHEP::mm, G4VMscModel::skin, and G4VMscModel::steppingAlgorithm.

Referenced by G4EmModelManager::DumpModelList().

◆ FillNumberOfSecondaries()

void G4VEmModel::FillNumberOfSecondaries	(	G4int &	numberOfTriplets,
		G4int &	numberOfRecoil
	)

virtualinherited

Definition at line 365 of file G4VEmModel.cc.

{
  numberOfTriplets = 0;
  numberOfRecoil = 0;
}

Referenced by G4VEmProcess::PostStepDoIt(), and G4VEnergyLossProcess::PostStepDoIt().

◆ ForceBuildTableFlag()

G4bool G4VEmModel::ForceBuildTableFlag ( ) const

inlineinherited

Definition at line 711 of file G4VEmModel.hh.

{
  return flagForceBuildTable;
}

References G4VEmModel::flagForceBuildTable.

Referenced by G4VMscModel::GetParticleChangeForMSC().

◆ GetAngularDistribution()

G4VEmAngularDistribution * G4VEmModel::GetAngularDistribution ( )

inlineinherited

Definition at line 621 of file G4VEmModel.hh.

{
  return anglModel;
}

References G4VEmModel::anglModel.

◆ GetChargeSquareRatio()

G4double G4VEmModel::GetChargeSquareRatio	(	const G4ParticleDefinition *	p,
		const G4Material *	,
		G4double	kineticEnergy
	)

virtualinherited

Reimplemented in G4BraggIonModel, G4BraggModel, G4IonParametrisedLossModel, G4AtimaEnergyLossModel, G4BetheBlochModel, and G4LindhardSorensenIonModel.

Definition at line 382 of file G4VEmModel.cc.

{
  const G4double q = p->GetPDGCharge()*inveplus;
  return q*q;
}

References G4ParticleDefinition::GetPDGCharge(), and G4VEmModel::inveplus.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4AdjointCSManager::BuildTotalSigmaTables(), G4VEmModel::ChargeSquareRatio(), G4EmCalculator::ComputeDEDX(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4ContinuousGainOfEnergy::GetContinuousStepLimit(), and G4EmCalculator::GetDEDX().

◆ GetCrossSectionTable()

G4PhysicsTable * G4VEmModel::GetCrossSectionTable ( )

inlineinherited

Definition at line 870 of file G4VEmModel.hh.

{
  return xSectionTable;
}

References G4VEmModel::xSectionTable.

Referenced by G4VMultipleScattering::BuildPhysicsTable(), G4EmModelManager::DumpModelList(), G4EmCalculator::FindLambdaTable(), G4WentzelVIModel::Initialise(), and G4VMultipleScattering::StorePhysicsTable().

◆ GetCurrentElement()

const G4Element * G4VEmModel::GetCurrentElement ( ) const

inlineinherited

Definition at line 505 of file G4VEmModel.hh.

{
  return fCurrentElement;
}

References G4VEmModel::fCurrentElement.

Referenced by G4VEmProcess::GetCurrentElement(), G4VEnergyLossProcess::GetCurrentElement(), G4VEmProcess::GetTargetElement(), G4PolarizedBremsstrahlungModel::SampleSecondaries(), G4PolarizedGammaConversionModel::SampleSecondaries(), G4PolarizedPhotoElectricModel::SampleSecondaries(), G4PolarizedBremsstrahlungModel::SelectedAtom(), G4PolarizedGammaConversionModel::SelectedAtom(), and G4eBremParametrizedModel::SetCurrentElement().

◆ GetCurrentIsotope()

const G4Isotope * G4VEmModel::GetCurrentIsotope ( ) const

inlineinherited

Definition at line 512 of file G4VEmModel.hh.

{
  return fCurrentIsotope;
}

References G4VEmModel::fCurrentIsotope.

Referenced by G4VEmProcess::GetTargetIsotope().

◆ GetDEDX() [1/2]

G4double G4VMscModel::GetDEDX	(	const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

inherited

Definition at line 159 of file G4VMscModel.cc.

{
  G4double x;
  if (nullptr != ionisation) {
    x = ionisation->GetDEDX(kinEnergy, couple);
  } else {
    const G4double q = part->GetPDGCharge()*inveplus;
    x = dedx*q*q;
  }
  return x;
}                                                                                                                                                                                                                 

References G4VMscModel::dedx, G4VEnergyLossProcess::GetDEDX(), G4ParticleDefinition::GetPDGCharge(), G4VEmModel::inveplus, and G4VMscModel::ionisation.

Referenced by G4UrbanAdjointMscModel::SampleScattering(), and G4UrbanMscModel::SampleScattering().

◆ GetDEDX() [2/2]

G4double G4VMscModel::GetDEDX	(	const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple,
		G4double	logKineticEnergy
	)

inherited

Definition at line 174 of file G4VMscModel.cc.

{
  G4double x;
  if (nullptr != ionisation) {
    x = ionisation->GetDEDX(kinEnergy, couple, logKinEnergy);
  } else {
    const G4double q = part->GetPDGCharge()*inveplus;
    x = dedx*q*q;
  }
  return x;
}

References G4VMscModel::dedx, G4VEnergyLossProcess::GetDEDX(), G4ParticleDefinition::GetPDGCharge(), G4VEmModel::inveplus, and G4VMscModel::ionisation.

◆ GetElementData()

G4ElementData * G4VEmModel::GetElementData ( )

inlineinherited

Definition at line 863 of file G4VEmModel.hh.

{
  return fElementData;
}

References G4VEmModel::fElementData.

Referenced by G4MuPairProductionModel::InitialiseLocal(), G4ePairProduction::StreamProcessInfo(), and G4MuPairProduction::StreamProcessInfo().

◆ GetElementSelectors()

std::vector< G4EmElementSelector * > * G4VEmModel::GetElementSelectors ( )

inlineinherited

Definition at line 844 of file G4VEmModel.hh.

{
  return elmSelectors;
}

References G4VEmModel::elmSelectors.

◆ GetEnergy()

G4double G4VMscModel::GetEnergy	(	const G4ParticleDefinition *	part,
		G4double	range,
		const G4MaterialCutsCouple *	couple
	)

inherited

Definition at line 224 of file G4VMscModel.cc.

{
  G4double e;
  //G4cout << "G4VMscModel::GetEnergy R(mm)= " << range << "  " << ionisation
  //     << "  Rlocal(mm)= " << localrange << "  Elocal(MeV)= " << localtkin << G4endl;
  if(nullptr != ionisation) { e = ionisation->GetKineticEnergy(range, couple); }
  else {
    e = localtkin;
    if(localrange > range) {
      G4double q = part->GetPDGCharge()*inveplus;
      e -= (localrange - range)*dedx*q*q*couple->GetMaterial()->GetDensity();
    }
  }
  return e;
}

References G4VMscModel::dedx, G4Material::GetDensity(), G4VEnergyLossProcess::GetKineticEnergy(), G4MaterialCutsCouple::GetMaterial(), G4ParticleDefinition::GetPDGCharge(), G4VEmModel::inveplus, G4VMscModel::ionisation, G4VMscModel::localrange, and G4VMscModel::localtkin.

Referenced by G4UrbanAdjointMscModel::ComputeGeomPathLength(), ComputeGeomPathLength(), G4UrbanMscModel::ComputeGeomPathLength(), G4WentzelVIModel::ComputeGeomPathLength(), G4WentzelVIModel::ComputeTrueStepLength(), SampleMSC(), G4UrbanAdjointMscModel::SampleScattering(), and G4UrbanMscModel::SampleScattering().

◆ GetGSTable()

G4GoudsmitSaundersonTable * G4GoudsmitSaundersonMscModel::GetGSTable ( )

inline

Definition at line 176 of file G4GoudsmitSaundersonMscModel.hh.

176{ return fGSTable; }

References fGSTable.

Referenced by InitialiseLocal().

◆ GetIonisation()

G4VEnergyLossProcess * G4VMscModel::GetIonisation ( ) const

inlineinherited

Definition at line 302 of file G4VMscModel.hh.

{
  return ionisation;
}

References G4VMscModel::ionisation.

◆ GetLambda()

G4double G4GoudsmitSaundersonMscModel::GetLambda ( G4double )

inlineprivate

◆ GetModelOfFluctuations()

G4VEmFluctuationModel * G4VEmModel::GetModelOfFluctuations ( )

inlineinherited

Definition at line 614 of file G4VEmModel.hh.

{
  return flucModel;
}

References G4VEmModel::flucModel.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepDoIt(), G4IonParametrisedLossModel::CorrectionsAlongStep(), G4AtimaEnergyLossModel::CorrectionsAlongStep(), G4BraggIonModel::CorrectionsAlongStep(), G4BetheBlochModel::CorrectionsAlongStep(), G4LindhardSorensenIonModel::CorrectionsAlongStep(), G4BraggModel::GetChargeSquareRatio(), G4VEnergyLossProcess::GetDEDXDispersion(), and G4EmMultiModel::Initialise().

◆ GetName()

const G4String & G4VEmModel::GetName ( ) const

inlineinherited

Definition at line 837 of file G4VEmModel.hh.

{
  return name;
}

References G4VEmModel::name.

Referenced by G4NIELCalculator::AddEmModel(), G4VLEPTSModel::BuildMeanFreePathTable(), G4VLEPTSModel::BuildPhysicsTable(), G4EmCalculator::ComputeDEDX(), G4MuPairProductionModel::DataCorrupted(), G4EmElementSelector::Dump(), G4EmModelManager::DumpModelList(), G4EmCalculator::FindEmModel(), G4NIELCalculator::G4NIELCalculator(), G4EmMultiModel::Initialise(), G4IonParametrisedLossModel::Initialise(), G4EmModelManager::Initialise(), G4IonParametrisedLossModel::PrintDEDXTable(), G4DNAAttachment::PrintInfo(), G4DNAChargeDecrease::PrintInfo(), G4DNAChargeIncrease::PrintInfo(), G4DNADissociation::PrintInfo(), G4DNAElastic::PrintInfo(), G4DNAExcitation::PrintInfo(), G4DNAIonisation::PrintInfo(), G4DNAPlasmonExcitation::PrintInfo(), G4DNAPositronium::PrintInfo(), G4DNARotExcitation::PrintInfo(), G4DNAVibExcitation::PrintInfo(), G4VLEPTSModel::ReadIXS(), G4LossTableManager::Register(), G4DNAModelInterface::RegisterModel(), G4IonParametrisedLossModel::RemoveDEDXTable(), G4VLEPTSModel::SampleEnergyLoss(), G4EmConfigurator::SetExtraEmModel(), G4EmConfigurator::SetModelForRegion(), and G4EmConfigurator::UpdateModelEnergyRange().

◆ GetOptionMottCorrection()

G4bool G4GoudsmitSaundersonMscModel::GetOptionMottCorrection ( ) const

inline

Definition at line 174 of file G4GoudsmitSaundersonMscModel.hh.

174{ return fIsUseMottCorrection; }

References fIsUseMottCorrection.

Referenced by InitialiseLocal().

◆ GetOptionPWACorrection()

G4bool G4GoudsmitSaundersonMscModel::GetOptionPWACorrection ( ) const

inline

Definition at line 170 of file G4GoudsmitSaundersonMscModel.hh.

170{ return fIsUsePWACorrection; }

References fIsUsePWACorrection.

Referenced by InitialiseLocal().

◆ GetPartialCrossSection()

G4double G4VEmModel::GetPartialCrossSection	(	const G4Material *	,
		G4int	level,
		const G4ParticleDefinition *	,
		G4double	kineticEnergy
	)

virtualinherited

Reimplemented in G4DNABornExcitationModel1, G4DNABornExcitationModel2, G4DNABornIonisationModel1, G4DNABornIonisationModel2, G4DNAMillerGreenExcitationModel, and G4DNARelativisticIonisationModel.

Definition at line 261 of file G4VEmModel.cc.

{ 
  return 0.0;
}

◆ GetParticleChangeForGamma()

G4ParticleChangeForGamma * G4VEmModel::GetParticleChangeForGamma ( )

protectedinherited

Definition at line 123 of file G4VEmModel.cc.

{
  G4ParticleChangeForGamma* p = nullptr;
  if (pParticleChange != nullptr) {
    p = static_cast<G4ParticleChangeForGamma*>(pParticleChange);
  } else {
    p = new G4ParticleChangeForGamma();
    pParticleChange = p;
  }
  if(fTripletModel != nullptr) { fTripletModel->SetParticleChange(p); }
  return p;
}

References G4VEmModel::fTripletModel, G4VEmModel::pParticleChange, and G4VEmModel::SetParticleChange().

◆ GetParticleChangeForLoss()

G4ParticleChangeForLoss * G4VEmModel::GetParticleChangeForLoss ( )

protectedinherited

Definition at line 108 of file G4VEmModel.cc.

{
  G4ParticleChangeForLoss* p = nullptr;
  if (pParticleChange != nullptr) {
    p = static_cast<G4ParticleChangeForLoss*>(pParticleChange);
  } else {
    p = new G4ParticleChangeForLoss();
    pParticleChange = p;
  }
  if(fTripletModel != nullptr) { fTripletModel->SetParticleChange(p); }
  return p;
}

References G4VEmModel::fTripletModel, G4VEmModel::pParticleChange, and G4VEmModel::SetParticleChange().

◆ GetParticleChangeForMSC()

G4ParticleChangeForMSC * G4VMscModel::GetParticleChangeForMSC ( const G4ParticleDefinition * p = nullptr )

protectedinherited

Definition at line 78 of file G4VMscModel.cc.

{
  // recomputed for each new run
  if(nullptr == safetyHelper) {
    safetyHelper = G4TransportationManager::GetTransportationManager()
      ->GetSafetyHelper();
    safetyHelper->InitialiseHelper();
  }
  G4ParticleChangeForMSC* change = nullptr;
  if (nullptr != pParticleChange) {
    change = static_cast<G4ParticleChangeForMSC*>(pParticleChange);
  } else {
    change = new G4ParticleChangeForMSC();
  }
  if(IsMaster() && nullptr != p) {
 
    // table is always built for low mass particles 
    if(p->GetParticleName() != "GenericIon" &&
       (p->GetPDGMass() < CLHEP::GeV || ForceBuildTableFlag()) ) {
 
      G4EmParameters* param = G4EmParameters::Instance();
      G4LossTableBuilder* builder = 
    G4LossTableManager::Instance()->GetTableBuilder();
      G4double emin = std::max(LowEnergyLimit(), LowEnergyActivationLimit());
      G4double emax = std::min(HighEnergyLimit(), HighEnergyActivationLimit());
      emin = std::max(emin, param->MinKinEnergy());
      emax = std::min(emax, param->MaxKinEnergy());
      if(emin < emax) {
    xSectionTable = builder->BuildTableForModel(xSectionTable, this, p, 
                            emin, emax, true);
      }
    }
  }
  return change;
}

References G4LossTableBuilder::BuildTableForModel(), emax, G4VEmModel::ForceBuildTableFlag(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4TransportationManager::GetSafetyHelper(), G4LossTableManager::GetTableBuilder(), G4TransportationManager::GetTransportationManager(), CLHEP::GeV, G4VEmModel::HighEnergyActivationLimit(), G4VEmModel::HighEnergyLimit(), G4SafetyHelper::InitialiseHelper(), G4EmParameters::Instance(), G4LossTableManager::Instance(), G4VEmModel::IsMaster(), G4VEmModel::LowEnergyActivationLimit(), G4VEmModel::LowEnergyLimit(), G4INCL::Math::max(), G4EmParameters::MaxKinEnergy(), G4INCL::Math::min(), G4EmParameters::MinKinEnergy(), G4VEmModel::pParticleChange, G4VMscModel::safetyHelper, and G4VEmModel::xSectionTable.

Referenced by G4UrbanAdjointMscModel::Initialise(), Initialise(), G4UrbanMscModel::Initialise(), and G4WentzelVIModel::Initialise().

◆ GetParticleCharge()

G4double G4VEmModel::GetParticleCharge	(	const G4ParticleDefinition *	p,
		const G4Material *	,
		G4double	kineticEnergy
	)

virtualinherited

Reimplemented in G4IonParametrisedLossModel, G4BraggIonGasModel, G4BetheBlochIonGasModel, G4AtimaEnergyLossModel, G4BetheBlochModel, G4BraggIonModel, G4BraggModel, and G4LindhardSorensenIonModel.

Definition at line 391 of file G4VEmModel.cc.

{
  return p->GetPDGCharge();
}

References G4ParticleDefinition::GetPDGCharge().

Referenced by G4VEnergyLossProcess::AlongStepDoIt().

◆ GetPWACorrection()

G4GSPWACorrections * G4GoudsmitSaundersonMscModel::GetPWACorrection ( )

inline

Definition at line 178 of file G4GoudsmitSaundersonMscModel.hh.

178{ return fPWACorrection; }

References fPWACorrection.

Referenced by InitialiseLocal().

◆ GetRange() [1/2]

G4double G4VMscModel::GetRange	(	const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

inherited

Definition at line 189 of file G4VMscModel.cc.

{
  //  << ionisation << "  " << part->GetParticleName() << G4endl;
  localtkin = kinEnergy;
  if (nullptr != ionisation) {
    localrange = ionisation->GetRange(kinEnergy, couple);
  } else {
    const G4double q = part->GetPDGCharge()*inveplus;
    localrange = kinEnergy/(dedx*q*q*couple->GetMaterial()->GetDensity());
  }
  //G4cout << "R(mm)= " << localrange << "  "  << ionisation << G4endl;
  return localrange;
}                                                                                                                                                                                                                 

References G4VMscModel::dedx, G4Material::GetDensity(), G4MaterialCutsCouple::GetMaterial(), G4ParticleDefinition::GetPDGCharge(), G4VEnergyLossProcess::GetRange(), G4VEmModel::inveplus, G4VMscModel::ionisation, G4VMscModel::localrange, and G4VMscModel::localtkin.

Referenced by G4VMultipleScattering::AlongStepDoIt(), G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4LowEWentzelVIModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), and G4WentzelVIModel::ComputeTruePathLengthLimit().

◆ GetRange() [2/2]

G4double G4VMscModel::GetRange	(	const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple,
		G4double	logKineticEnergy
	)

inherited

Definition at line 206 of file G4VMscModel.cc.

{
  //G4cout << "G4VMscModel::GetRange E(MeV)= " << kinEnergy << "  "
  //  << ionisation << "  " << part->GetParticleName() << G4endl;
  localtkin = kinEnergy;
  if (nullptr != ionisation) {
    localrange = ionisation->GetRange(kinEnergy, couple, logKinEnergy);
  } else {
    const G4double q = part->GetPDGCharge()*inveplus;
    localrange = kinEnergy/(dedx*q*q*couple->GetMaterial()->GetDensity());
  }
  //G4cout << "R(mm)= " << localrange << "  "  << ionisation << G4endl;
  return localrange;
}                                                                                                                                                                                                                 

References G4VMscModel::dedx, G4Material::GetDensity(), G4MaterialCutsCouple::GetMaterial(), G4ParticleDefinition::GetPDGCharge(), G4VEnergyLossProcess::GetRange(), G4VEmModel::inveplus, G4VMscModel::ionisation, G4VMscModel::localrange, and G4VMscModel::localtkin.

◆ GetTransportMeanFreePath() [1/2]

G4double G4GoudsmitSaundersonMscModel::GetTransportMeanFreePath	(	const G4ParticleDefinition *	,
		G4double	kineticEnergy
	)

Definition at line 365 of file G4GoudsmitSaundersonMscModel.cc.

                                                                               {
  // kinetic energy is assumed to be in Geant4 internal energy unit which is MeV
  G4double efEnergy = kineticEnergy;
  //
  const G4Material*  mat = currentCouple->GetMaterial();
  //
  fLambda0 = 0.0; // elastic mean free path
  fLambda1 = 0.0; // first transport mean free path
  fScrA    = 0.0; // screening parameter
  fG1      = 0.0; // first transport coef.
 
  // use Moliere's screening (with Mott-corretion if it was requested)
  if  (efEnergy<10.*CLHEP::eV) efEnergy = 10.*CLHEP::eV;
  // total mometum square
  G4double pt2     = efEnergy*(efEnergy+2.0*electron_mass_c2);
  // beta square
  G4double beta2   = pt2/(pt2+electron_mass_c2*electron_mass_c2);
  // current material index
  G4int    matindx = mat->GetIndex();
  // Moliere's b_c
  G4double bc      = fGSTable->GetMoliereBc(matindx);
  // get the Mott-correcton factors if Mott-correcton was requested by the user
  fMCtoScrA       = 1.0;
  fMCtoQ1         = 1.0;
  fMCtoG2PerG1    = 1.0;
  G4double scpCor = 1.0;
  if (fIsUseMottCorrection) {
    fGSTable->GetMottCorrectionFactors(G4Log(efEnergy), beta2, matindx, fMCtoScrA, fMCtoQ1, fMCtoG2PerG1);
    scpCor = fGSTable->ComputeScatteringPowerCorrection(currentCouple, efEnergy);
  } else if (fIsUsePWACorrection) {
    fPWACorrection->GetPWACorrectionFactors(G4Log(efEnergy), beta2, matindx, fMCtoScrA, fMCtoQ1, fMCtoG2PerG1);
    // scpCor = fGSTable->ComputeScatteringPowerCorrection(currentCouple, efEnergy);
  }
  // screening parameter:
  // - if Mott-corretioncorrection: the Screened-Rutherford times Mott-corretion DCS with this
  //   screening parameter gives back the (elsepa) PWA first transport cross section
  // - if PWA correction: he Screened-Rutherford DCS with this screening parameter
  //   gives back the (elsepa) PWA first transport cross section
  fScrA    = fGSTable->GetMoliereXc2(matindx)/(4.0*pt2*bc)*fMCtoScrA;
  // elastic mean free path in Geant4 internal lenght units: the neglected (1+screening parameter) term is corrected
  // (if Mott-corretion: the corrected screening parameter is used for this (1+A) correction + Moliere b_c is also
  // corrected with the screening parameter correction)
  fLambda0 = beta2*(1.+fScrA)*fMCtoScrA/bc/scpCor;
  // first transport coefficient (if Mott-corretion: the corrected screening parameter is used (it will be fully
  // consistent with the one used during the pre-computation of the Mott-correted GS angular distributions))
  fG1      = 2.0*fScrA*((1.0+fScrA)*G4Log(1.0/fScrA+1.0)-1.0);
  // first transport mean free path
  fLambda1 = fLambda0/fG1;
 
  return fLambda1;
}

References G4GoudsmitSaundersonTable::ComputeScatteringPowerCorrection(), currentCouple, source.hepunit::electron_mass_c2, CLHEP::eV, fG1, fGSTable, fIsUseMottCorrection, fIsUsePWACorrection, fLambda0, fLambda1, fMCtoG2PerG1, fMCtoQ1, fMCtoScrA, fPWACorrection, fScrA, G4Log(), G4Material::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4GoudsmitSaundersonTable::GetMoliereBc(), G4GoudsmitSaundersonTable::GetMoliereXc2(), G4GoudsmitSaundersonTable::GetMottCorrectionFactors(), and G4GSPWACorrections::GetPWACorrectionFactors().

Referenced by ComputeTruePathLengthLimit(), and SampleMSC().

◆ GetTransportMeanFreePath() [2/2]

G4double G4VMscModel::GetTransportMeanFreePath	(	const G4ParticleDefinition *	part,
		G4double	kinEnergy,
		G4double	logKinEnergy
	)

inlineinherited

Definition at line 332 of file G4VMscModel.hh.

{
  G4double x;
  if (nullptr != xSectionTable) {
    x = pFactor*(*xSectionTable)[basedCoupleIndex]->LogVectorValue(ekin, logekin)/(ekin*ekin);
  } else { 
    x = pFactor*CrossSectionPerVolume(pBaseMaterial, part, ekin, 0.0, DBL_MAX);
  }
  return (x > 0.0) ? 1.0/x : DBL_MAX;
}

References G4VEmModel::basedCoupleIndex, G4VEmModel::CrossSectionPerVolume(), DBL_MAX, G4VEmModel::pBaseMaterial, G4VEmModel::pFactor, and G4VEmModel::xSectionTable.

◆ GetTransportMeanFreePathOnly()

G4double G4GoudsmitSaundersonMscModel::GetTransportMeanFreePathOnly	(	const G4ParticleDefinition *	,
		G4double	kineticEnergy
	)

private

Definition at line 420 of file G4GoudsmitSaundersonMscModel.cc.

                                                                               {
  // kinetic energy is assumed to be in Geant4 internal energy unit which is MeV
  G4double efEnergy = kineticEnergy;
  //
  const G4Material*  mat = currentCouple->GetMaterial();
  //
  G4double lambda0 = 0.0; // elastc mean free path
  G4double lambda1 = 0.0; // first transport mean free path
  G4double scrA    = 0.0; // screening parametr
  G4double g1      = 0.0; // first transport mean free path
 
  // use Moliere's screening (with Mott-corretion if it was requested)
  if  (efEnergy<10.*CLHEP::eV) efEnergy = 10.*CLHEP::eV;
  // total mometum square in Geant4 internal energy2 units which is MeV2
  G4double pt2     = efEnergy*(efEnergy+2.0*electron_mass_c2);
  G4double beta2   = pt2/(pt2+electron_mass_c2*electron_mass_c2);
  G4int    matindx = mat->GetIndex();
  G4double bc      = fGSTable->GetMoliereBc(matindx);
  // get the Mott-correcton factors if Mott-correcton was requested by the user
  G4double mctoScrA    = 1.0;
  G4double mctoQ1      = 1.0;
  G4double mctoG2PerG1 = 1.0;
  G4double scpCor      = 1.0;
  if (fIsUseMottCorrection) {
    fGSTable->GetMottCorrectionFactors(G4Log(efEnergy), beta2, matindx, mctoScrA, mctoQ1, mctoG2PerG1);
    scpCor = fGSTable->ComputeScatteringPowerCorrection(currentCouple, efEnergy);
  } else if (fIsUsePWACorrection) {
    fPWACorrection->GetPWACorrectionFactors(G4Log(efEnergy), beta2, matindx, mctoScrA, mctoQ1, mctoG2PerG1);
    // scpCor = fGSTable->ComputeScatteringPowerCorrection(currentCouple, efEnergy);
  }
  scrA    = fGSTable->GetMoliereXc2(matindx)/(4.0*pt2*bc)*mctoScrA;
  // total elastic mean free path in Geant4 internal lenght units
  lambda0 = beta2*(1.+scrA)*mctoScrA/bc/scpCor;
  g1      = 2.0*scrA*((1.0+scrA)*G4Log(1.0/scrA+1.0)-1.0);
  lambda1 = lambda0/g1;
 
  return lambda1;
}

References G4GoudsmitSaundersonTable::ComputeScatteringPowerCorrection(), currentCouple, source.hepunit::electron_mass_c2, CLHEP::eV, fGSTable, fIsUseMottCorrection, fIsUsePWACorrection, fPWACorrection, G4Log(), G4Material::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4GoudsmitSaundersonTable::GetMoliereBc(), G4GoudsmitSaundersonTable::GetMoliereXc2(), G4GoudsmitSaundersonTable::GetMottCorrectionFactors(), and G4GSPWACorrections::GetPWACorrectionFactors().

Referenced by ComputeGeomPathLength().

◆ GetTripletModel()

G4VEmModel * G4VEmModel::GetTripletModel ( )

inlineinherited

Definition at line 638 of file G4VEmModel.hh.

{
  return fTripletModel;
}

References G4VEmModel::fTripletModel.

Referenced by G4eBremsstrahlungRelModel::Initialise(), G4SeltzerBergerModel::Initialise(), and G4eBremsstrahlungRelModel::SampleSecondaries().

◆ HighEnergyActivationLimit()

G4double G4VEmModel::HighEnergyActivationLimit ( ) const

inlineinherited

Definition at line 669 of file G4VEmModel.hh.

{
  return eMaxActive;
}

References G4VEmModel::eMaxActive.

Referenced by G4EmModelManager::DumpModelList(), G4VMscModel::GetParticleChangeForMSC(), G4WentzelVIModel::Initialise(), and G4EmModelManager::Initialise().

◆ HighEnergyLimit()

G4double G4VEmModel::HighEnergyLimit ( ) const

inlineinherited

Definition at line 655 of file G4VEmModel.hh.

{
  return highLimit;
}

References G4VEmModel::highLimit.

◆ Initialise()

void G4GoudsmitSaundersonMscModel::Initialise	(	const G4ParticleDefinition *	p,
		const G4DataVector &
	)

overridevirtual

Implements G4VEmModel.

Definition at line 251 of file G4GoudsmitSaundersonMscModel.cc.

                                                                                                {
  SetParticle(p);
  InitialiseParameters(p);
  // -create GoudsmitSaundersonTable and init its Mott-correction member if
  //  Mott-correction was required
  if (IsMaster()) {
    // get the Mott-correction flag from EmParameters
    if (G4EmParameters::Instance()->UseMottCorrection()) {
      fIsUseMottCorrection = true;
    }
    // Mott-correction includes other way of PWA x-section corrections so deactivate it even if it was true
    // when Mott-correction is activated by the user
    if (fIsUseMottCorrection) {
      fIsUsePWACorrection = false;
    }
    // clear GS-table
    if (fGSTable) {
      delete fGSTable;
      fGSTable = nullptr;
    }
    // clear PWA corrections table if any
    if (fPWACorrection) {
      delete fPWACorrection;
      fPWACorrection = nullptr;
    }
    // create GS-table
    G4bool isElectron = true;
    if (p->GetPDGCharge()>0.) {
      isElectron = false;
    }
    fGSTable = new G4GoudsmitSaundersonTable(isElectron);
    // G4GSTable will be initialised:
    // - Screened-Rutherford DCS based GS angular distributions will be loaded only if they are not there yet
    // - Mott-correction will be initialised if Mott-correction was requested to be used
    fGSTable->SetOptionMottCorrection(fIsUseMottCorrection);
    // - set PWA correction (correction to integrated quantites from Dirac-PWA)
    fGSTable->SetOptionPWACorrection(fIsUsePWACorrection);
    // init
    fGSTable->Initialise(LowEnergyLimit(),HighEnergyLimit());
    // create PWA corrections table if it was requested (and not disactivated because active Mott-correction)
    if (fIsUsePWACorrection) {
      fPWACorrection = new G4GSPWACorrections(isElectron);
      fPWACorrection->Initialise();
    }
  }
  fParticleChange = GetParticleChangeForMSC(p);
}

References fGSTable, fIsUseMottCorrection, fIsUsePWACorrection, fParticleChange, fPWACorrection, G4VMscModel::GetParticleChangeForMSC(), G4ParticleDefinition::GetPDGCharge(), G4VEmModel::HighEnergyLimit(), G4GSPWACorrections::Initialise(), G4GoudsmitSaundersonTable::Initialise(), G4VMscModel::InitialiseParameters(), G4EmParameters::Instance(), G4InuclParticleNames::isElectron(), G4VEmModel::IsMaster(), G4VEmModel::LowEnergyLimit(), G4GoudsmitSaundersonTable::SetOptionMottCorrection(), G4GoudsmitSaundersonTable::SetOptionPWACorrection(), and SetParticle().

◆ InitialiseElementSelectors()

void G4VEmModel::InitialiseElementSelectors	(	const G4ParticleDefinition *	part,
		const G4DataVector &	cuts
	)

inherited

Definition at line 138 of file G4VEmModel.cc.

{
  // using spline for element selectors should be investigated in details
  // because small number of points may provide biased results
  // large number of points requires significant increase of memory
  G4bool spline = false;
  
  //G4cout << "IES: for " << GetName() << " Emin(MeV)= " << lowLimit/MeV 
  //         << " Emax(MeV)= " << highLimit/MeV << G4endl;
  
  // two times less bins because probability functon is normalized 
  // so correspondingly is more smooth
  if(highLimit <= lowLimit) { return; }
 
  G4int nbinsPerDec = G4EmParameters::Instance()->NumberOfBinsPerDecade();
 
  G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = theCoupleTable->GetTableSize();
 
  // prepare vector
  if(!elmSelectors) {
    elmSelectors = new std::vector<G4EmElementSelector*>;
  }
  if(numOfCouples > nSelectors) { 
    for(G4int i=nSelectors; i<numOfCouples; ++i) { 
      elmSelectors->push_back(nullptr); 
    }
    nSelectors = numOfCouples;
  }
 
  // initialise vector
  for(G4int i=0; i<numOfCouples; ++i) {
 
    // no need in element selectors for infinite cuts
    if(cuts[i] == DBL_MAX) { continue; }
   
    auto couple = theCoupleTable->GetMaterialCutsCouple(i); 
    auto material = couple->GetMaterial();
    SetCurrentCouple(couple);
 
    // selector already exist then delete
    delete (*elmSelectors)[i];
 
    G4double emin = std::max(lowLimit, MinPrimaryEnergy(material, part, cuts[i]));
    G4double emax = std::max(highLimit, 10*emin);
    static const G4double invlog106 = 1.0/(6*G4Log(10.));
    G4int nbins = (G4int)(nbinsPerDec*G4Log(emax/emin)*invlog106);
    nbins = std::max(nbins, 3);
 
    (*elmSelectors)[i] = new G4EmElementSelector(this,material,nbins,
                         emin,emax,spline);
    ((*elmSelectors)[i])->Initialise(part, cuts[i]);
    /*      
      G4cout << "G4VEmModel::InitialiseElmSelectors i= " << i 
             << "  "  << part->GetParticleName() 
             << " for " << GetName() << "  cut= " << cuts[i] 
             << "  " << (*elmSelectors)[i] << G4endl;      
      ((*elmSelectors)[i])->Dump(part);
    */
  } 
}

References DBL_MAX, G4VEmModel::elmSelectors, emax, G4Log(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4VEmModel::highLimit, G4VEmModel::Initialise(), G4EmParameters::Instance(), G4VEmModel::lowLimit, eplot::material, G4INCL::Math::max(), G4VEmModel::MinPrimaryEnergy(), G4VEmModel::nSelectors, G4EmParameters::NumberOfBinsPerDecade(), and G4VEmModel::SetCurrentCouple().

◆ InitialiseForElement()

void G4VEmModel::InitialiseForElement	(	const G4ParticleDefinition *	,
		G4int	Z
	)

virtualinherited

◆ InitialiseForMaterial()

void G4VEmModel::InitialiseForMaterial	(	const G4ParticleDefinition *	part,
		const G4Material *	material
	)

virtualinherited

Definition at line 209 of file G4VEmModel.cc.

{
  if(material != nullptr) {
    size_t n = material->GetNumberOfElements();
    for(size_t i=0; i<n; ++i) {
      G4int Z = material->GetElement(i)->GetZasInt();
      InitialiseForElement(part, Z);
    }
  }
}

References G4VEmModel::InitialiseForElement(), eplot::material, CLHEP::detail::n, and Z.

Referenced by G4EmCalculator::FindEmModel().

◆ InitialiseLocal()

void G4GoudsmitSaundersonMscModel::InitialiseLocal	(	const G4ParticleDefinition *	p,
		G4VEmModel *	masterModel
	)

overridevirtual

Reimplemented from G4VEmModel.

Definition at line 300 of file G4GoudsmitSaundersonMscModel.cc.

                                                                                                       {
   fGSTable               = static_cast<G4GoudsmitSaundersonMscModel*>(masterModel)->GetGSTable();
   fIsUseMottCorrection   = static_cast<G4GoudsmitSaundersonMscModel*>(masterModel)->GetOptionMottCorrection();
   fIsUsePWACorrection    = static_cast<G4GoudsmitSaundersonMscModel*>(masterModel)->GetOptionPWACorrection();
   fPWACorrection         = static_cast<G4GoudsmitSaundersonMscModel*>(masterModel)->GetPWACorrection();
}

References fGSTable, fIsUseMottCorrection, fIsUsePWACorrection, fPWACorrection, GetGSTable(), GetOptionMottCorrection(), GetOptionPWACorrection(), and GetPWACorrection().

◆ InitialiseParameters()

void G4VMscModel::InitialiseParameters ( const G4ParticleDefinition * part )

inherited

Definition at line 116 of file G4VMscModel.cc.

{
  if(IsLocked()) { return; }
  G4EmParameters* param = G4EmParameters::Instance();
  if(std::abs(part->GetPDGEncoding()) == 11) {
    steppingAlgorithm = param->MscStepLimitType(); 
    facrange = param->MscRangeFactor(); 
    latDisplasment = param->LateralDisplacement();
  } else {
    steppingAlgorithm = param->MscMuHadStepLimitType(); 
    facrange = param->MscMuHadRangeFactor(); 
    latDisplasment = param->MuHadLateralDisplacement();
  }
  skin = param->MscSkin();
  facgeom = param->MscGeomFactor();
  facsafety = param->MscSafetyFactor();
  lambdalimit = param->MscLambdaLimit();
}

Referenced by Initialise(), G4UrbanMscModel::Initialise(), and G4WentzelVIModel::Initialise().

◆ IsActive()

G4bool G4VEmModel::IsActive ( G4double kinEnergy ) const

inlineinherited

Definition at line 795 of file G4VEmModel.hh.

{
  return (kinEnergy >= eMinActive && kinEnergy <= eMaxActive);
}

References G4VEmModel::eMaxActive, and G4VEmModel::eMinActive.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4NuclearStopping::AlongStepDoIt(), G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), and G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ IsLocked()

G4bool G4VEmModel::IsLocked ( ) const

inlineinherited

Definition at line 877 of file G4VEmModel.hh.

{
  return isLocked;
}

References G4VEmModel::isLocked.

Referenced by G4VMscModel::InitialiseParameters(), G4VMscModel::SetGeomFactor(), G4VMscModel::SetLambdaLimit(), G4VMscModel::SetLateralDisplasmentFlag(), G4VMscModel::SetRangeFactor(), G4VMscModel::SetSafetyFactor(), G4VMscModel::SetSampleZ(), G4VMscModel::SetSkin(), and G4VMscModel::SetStepLimitType().

◆ IsMaster()

G4bool G4VEmModel::IsMaster ( ) const

inlineinherited

Definition at line 746 of file G4VEmModel.hh.

{
  return isMaster;
}

References G4VEmModel::isMaster.

◆ LowEnergyActivationLimit()

G4double G4VEmModel::LowEnergyActivationLimit ( ) const

inlineinherited

Definition at line 676 of file G4VEmModel.hh.

{
  return eMinActive;
}

References G4VEmModel::eMinActive.

Referenced by G4EmModelManager::DumpModelList(), G4VMscModel::GetParticleChangeForMSC(), G4WentzelVIModel::Initialise(), and G4EmModelManager::Initialise().

◆ LowEnergyLimit()

G4double G4VEmModel::LowEnergyLimit ( ) const

inlineinherited

Definition at line 662 of file G4VEmModel.hh.

{
  return lowLimit;
}

References G4VEmModel::lowLimit.

◆ LPMFlag()

G4bool G4VEmModel::LPMFlag ( ) const

inlineinherited

Definition at line 697 of file G4VEmModel.hh.

{
  return theLPMflag;
}

References G4VEmModel::theLPMflag.

Referenced by G4eBremsstrahlungRelModel::Initialise(), G4eBremsstrahlungRelModel::SetupForMaterial(), G4SeltzerBergerModel::SetupForMaterial(), and G4eBremsstrahlungRelModel::~G4eBremsstrahlungRelModel().

◆ MaxSecondaryEnergy()

G4double G4VEmModel::MaxSecondaryEnergy	(	const G4ParticleDefinition *	,
		G4double	kineticEnergy
	)

protectedvirtualinherited

Reimplemented in G4BraggIonModel, G4BraggModel, G4ICRU73QOModel, G4MollerBhabhaModel, G4PAIModel, G4PAIPhotModel, G4mplIonisationWithDeltaModel, G4MuBetheBlochModel, G4AtimaEnergyLossModel, G4BetheBlochModel, G4LindhardSorensenIonModel, and G4IonParametrisedLossModel.

Definition at line 432 of file G4VEmModel.cc.

{
  return kineticEnergy;
}

Referenced by G4VEmModel::MaxSecondaryKinEnergy().

◆ MaxSecondaryKinEnergy()

G4double G4VEmModel::MaxSecondaryKinEnergy ( const G4DynamicParticle * dynParticle )

inlineinherited

Definition at line 520 of file G4VEmModel.hh.

{
  return MaxSecondaryEnergy(dynPart->GetParticleDefinition(),
                            dynPart->GetKineticEnergy());
}

References G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetParticleDefinition(), and G4VEmModel::MaxSecondaryEnergy().

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::GetDEDXDispersion(), G4MuBetheBlochModel::SampleSecondaries(), G4PolarizedIonisationModel::SampleSecondaries(), G4BraggIonModel::SampleSecondaries(), G4BraggModel::SampleSecondaries(), G4ICRU73QOModel::SampleSecondaries(), and G4IonParametrisedLossModel::SampleSecondaries().

◆ MinEnergyCut()

G4double G4VEmModel::MinEnergyCut	(	const G4ParticleDefinition *	,
		const G4MaterialCutsCouple *
	)

virtualinherited

Reimplemented in G4IonParametrisedLossModel, G4PenelopeBremsstrahlungModel, G4PenelopeIonisationModel, G4MuBetheBlochModel, G4MuBremsstrahlungModel, G4eBremParametrizedModel, G4PAIModel, G4PAIPhotModel, G4mplIonisationWithDeltaModel, G4AtimaEnergyLossModel, G4BetheBlochModel, G4BraggIonModel, G4BraggModel, and G4LindhardSorensenIonModel.

Definition at line 424 of file G4VEmModel.cc.

{
  return 0.0;
}

Referenced by G4EmModelManager::Initialise().

◆ MinPrimaryEnergy()

G4double G4VEmModel::MinPrimaryEnergy	(	const G4Material *	,
		const G4ParticleDefinition *	,
		G4double	cut = `0.0`
	)

virtualinherited

Reimplemented in G4eBremsstrahlungRelModel, G4BoldyshevTripletModel, G4eCoulombScatteringModel, G4hCoulombScatteringModel, G4LivermoreNuclearGammaConversionModel, G4LivermorePolarizedGammaConversionModel, G4MuBremsstrahlungModel, G4MuPairProductionModel, and G4eDPWACoulombScatteringModel.

Definition at line 415 of file G4VEmModel.cc.

{
  return 0.0;
}

Referenced by G4LossTableBuilder::BuildTableForModel(), and G4VEmModel::InitialiseElementSelectors().

◆ ModelDescription()

void G4VEmModel::ModelDescription ( std::ostream & outFile ) const

virtualinherited

Reimplemented in G4eeToHadronsMultiModel.

Definition at line 469 of file G4VEmModel.cc.

{
  outFile << "The description for this model has not been written yet.\n";
}

◆ operator=()

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

delete

◆ PolarAngleLimit()

G4double G4VEmModel::PolarAngleLimit ( ) const

inlineinherited

Definition at line 683 of file G4VEmModel.hh.

{
  return polarAngleLimit;
}

References G4VEmModel::polarAngleLimit.

Referenced by G4eCoulombScatteringModel::Initialise(), G4eDPWACoulombScatteringModel::Initialise(), G4hCoulombScatteringModel::Initialise(), and G4WentzelVIModel::Initialise().

◆ Randomizetlimit()

G4double G4GoudsmitSaundersonMscModel::Randomizetlimit ( )

inlineprivate

Definition at line 278 of file G4GoudsmitSaundersonMscModel.hh.

{
  G4double temptlimit = tlimit;
    do {
         temptlimit = G4RandGauss::shoot(rndmEngineMod,tlimit,0.1*tlimit);
       } while ( (temptlimit<0.) || (temptlimit>2.*tlimit));
 
  return temptlimit;
}

References rndmEngineMod, G4INCL::DeJongSpin::shoot(), and tlimit.

Referenced by ComputeTruePathLengthLimit().

◆ SampleMSC()

void G4GoudsmitSaundersonMscModel::SampleMSC ( )

Definition at line 923 of file G4GoudsmitSaundersonMscModel.cc.

                                             {
  fIsNoScatteringInMSC = false;
  // kinetic energy is assumed to be in Geant4 internal energy unit which is MeV
  G4double kineticEnergy = currentKinEnergy;
  //
  // Energy loss correction: 2 version
  G4double eloss  = 0.0;
//  if (fTheTrueStepLenght > currentRange*dtrl) {
  eloss = kineticEnergy - GetEnergy(particle,currentRange-fTheTrueStepLenght,currentCouple);
//  } else {
//    eloss = fTheTrueStepLenght*GetDEDX(particle,kineticEnergy,currentCouple);
//  }
 
  G4double tau  = 0.;//    = kineticEnergy/electron_mass_c2; // where kinEnergy is the mean kinetic energy
  G4double tau2 = 0.;//   = tau*tau;
  G4double eps0 = 0.;//   = eloss/kineticEnergy0; // energy loss fraction to the begin step energy
  G4double epsm = 0.;//   = eloss/kineticEnergy;  // energy loss fraction to the mean step energy
 
  // - init.
  G4double efEnergy = kineticEnergy;
  G4double efStep   = fTheTrueStepLenght;
 
  G4double kineticEnergy0 = kineticEnergy;
  if (gIsUseAccurate) {    // - use accurate energy loss correction
    kineticEnergy  -= 0.5*eloss;  // mean energy along the full step
    // other parameters for energy loss corrections
    tau             = kineticEnergy/electron_mass_c2; // where kinEnergy is the mean kinetic energy
    tau2            = tau*tau;
    eps0            = eloss/kineticEnergy0; // energy loss fraction to the begin step energy
    epsm            = eloss/kineticEnergy;  // energy loss fraction to the mean step energy
 
    efEnergy        = kineticEnergy * (1.-epsm*epsm*(6.+10.*tau+5.*tau2)/(24.*tau2+48.*tau+72.));
    G4double dum    = 0.166666*(4.+tau*(6.+tau*(7.+tau*(4.+tau))))*(epsm/((tau+1.)*(tau+2.)))*(epsm/((tau+1.)*(tau+2.)));
    efStep          = fTheTrueStepLenght*(1.-dum);
  } else {                              // - take only mean energy
    kineticEnergy  -= 0.5*eloss;  // mean energy along the full step
    efEnergy        = kineticEnergy;
    G4double factor = 1./(1.+0.9784671*kineticEnergy); //0.9784671 = 1/(2*m_e)
    eps0            = eloss/kineticEnergy0;
    epsm            = eps0/(1.-0.5*eps0);
    G4double temp   = 0.3*(1 -factor*(1.-0.333333*factor))*eps0*eps0;
    efStep          = fTheTrueStepLenght*(1.+temp);
  }
  //
  // compute elastic mfp, first transport mfp, screening parameter, and G1 (with Mott-correction
  // if it was requested by the user)
  fLambda1 = GetTransportMeanFreePath(particle, efEnergy);
  // s/lambda_el
  G4double lambdan=0.;
  if (fLambda0>0.0) {
    lambdan=efStep/fLambda0;
  }
  if (lambdan<=1.0e-12) {
      if (fIsEverythingWasDone) {
        fTheZPathLenght = fTheTrueStepLenght;
      }
    fIsNoScatteringInMSC = true;
    return;
  }
  // first moment: 2.* lambdan *scrA*((1.+scrA)*log(1.+1./scrA)-1.);
  G4double Qn1 = lambdan *fG1;
  // sample scattering angles
  // new direction, relative to the orriginal one is in {uss,vss,wss}
  G4double cosTheta1 = 1.0, sinTheta1 = 0.0, cosTheta2 = 1.0, sinTheta2 = 0.0;
  G4double cosPhi1   = 1.0, sinPhi1   = 0.0, cosPhi2   = 1.0, sinPhi2   = 0.0;
  G4double uss       = 0.0, vss       = 0.0, wss       = 1.0;
  G4double x_coord   = 0.0, y_coord   = 0.0, z_coord   = 1.0;
  G4double u2 = 0.0, v2 = 0.0;
  // if we are above the upper grid limit with lambdaxG1=true-length/first-trans-mfp
  // => izotropic distribution: lambG1_max =7.992 but set it to 7
  if (0.5*Qn1 > 7.0){
    cosTheta1 = 1.-2.*G4UniformRand();
    sinTheta1 = std::sqrt((1.-cosTheta1)*(1.+cosTheta1));
    cosTheta2 = 1.-2.*G4UniformRand();
    sinTheta2 = std::sqrt((1.-cosTheta2)*(1.+cosTheta2));
  } else {
     // sample 2 scattering cost1, sint1, cost2 and sint2 for half path
     G4double lekin  = G4Log(efEnergy);
     G4double pt2    = efEnergy*(efEnergy+2.0*CLHEP::electron_mass_c2);
     G4double beta2  = pt2/(pt2+CLHEP::electron_mass_c2*CLHEP::electron_mass_c2);
     // backup GS angular dtr pointer (kinetic energy and delta index in case of Mott-correction)
     // if the first was an msc sampling (the same will be used if the second is also an msc step)
     G4GoudsmitSaundersonTable::GSMSCAngularDtr *gsDtr = nullptr;
     G4int mcEkinIdx    = -1;
     G4int mcDeltIdx    = -1;
     G4double transfPar = 0.;
     G4bool isMsc = fGSTable->Sampling(0.5*lambdan, 0.5*Qn1, fScrA, cosTheta1, sinTheta1, lekin, beta2,
                                       currentMaterialIndex, &gsDtr, mcEkinIdx, mcDeltIdx, transfPar,
                                       true);
     fGSTable->Sampling(0.5*lambdan, 0.5*Qn1, fScrA, cosTheta2, sinTheta2, lekin, beta2,
                        currentMaterialIndex, &gsDtr, mcEkinIdx, mcDeltIdx, transfPar, !isMsc);
     if (cosTheta1+cosTheta2==2.) { // no scattering happened
        if (fIsEverythingWasDone)
           fTheZPathLenght = fTheTrueStepLenght;
        fIsNoScatteringInMSC = true;
        return;
     }
  }
  // sample 2 azimuthal angles
  G4double phi1 = CLHEP::twopi*G4UniformRand();
  sinPhi1 = std::sin(phi1);
  cosPhi1 = std::cos(phi1);
  G4double phi2 = CLHEP::twopi*G4UniformRand();
  sinPhi2 = std::sin(phi2);
  cosPhi2 = std::cos(phi2);
 
  // compute final direction realtive to z-dir
  u2  = sinTheta2*cosPhi2;
  v2  = sinTheta2*sinPhi2;
  G4double u2p = cosTheta1*u2 + sinTheta1*cosTheta2;
  uss  = u2p*cosPhi1 - v2*sinPhi1;
  vss  = u2p*sinPhi1 + v2*cosPhi1;
  wss  = cosTheta1*cosTheta2 - sinTheta1*u2;
 
  // set new direction (is scattering frame)
  fTheNewDirection.set(uss,vss,wss);
 
  // set the fTheZPathLenght if we don't sample displacement and
  // we should do everything at the step-limit-phase before we return
  if(fIsNoDisplace && fIsEverythingWasDone)
    fTheZPathLenght = fTheTrueStepLenght;
 
  // in optimized-mode if the current-safety > current-range we do not use dispalcement
  if(fIsNoDisplace)
    return;
 
  // Compute final position
  Qn1 *=  fMCtoQ1;
  if (gIsUseAccurate) {
     // correction parameter
     G4double par =1.;
     if(Qn1<0.7) par = 1.;
     else if (Qn1<7.0) par = -0.031376*Qn1+1.01356;
     else par = 0.79;
 
     // Moments with energy loss correction
     // --first the uncorrected (for energy loss) values of gamma, eta, a1=a2=0.5*(1-eta), delta
     // gamma = G_2/G_1 based on G2 computed from A by using the Wentzel DCS form of G2
     G4double loga   = G4Log(1.0+1.0/fScrA);
     G4double gamma  = 6.0*fScrA*(1.0 + fScrA)*(loga*(1.0 + 2.0*fScrA) - 2.0)/fG1;
     gamma *= fMCtoG2PerG1;
     // sample eta from p(eta)=2*eta i.e. P(eta) = eta_square ;-> P(eta) = rand --> eta = sqrt(rand)
     G4double eta    = std::sqrt(G4UniformRand());
     G4double eta1   = 0.5*(1 - eta);  // used  more than once
     // 0.5 +sqrt(6)/6 = 0.9082483;
     // 1/(4*sqrt(6))  = 0.1020621;
     // (4-sqrt(6)/(24*sqrt(6))) = 0.026374715
     // delta = 0.9082483-(0.1020621-0.0263747*gamma)*Qn1 without energy loss cor.
     G4double delta  = 0.9082483-(0.1020621-0.0263747*gamma)*Qn1;
 
     // compute alpha1 and alpha2 for energy loss correction
     G4double temp1 = 2.0 + tau;
     G4double temp  = (2.0+tau*temp1)/((tau+1.0)*temp1);
     //Take logarithmic dependence
     temp = temp - (tau+1.0)/((tau+2.0)*(loga*(1.0+fScrA)-1.0));
     temp = temp * epsm;
     temp1 = 1.0 - temp;
     delta = delta + 0.40824829*(eps0*(tau+1.0)/((tau+2.0)*
             (loga*(1.0+fScrA)-1.0)*(loga*(1.0+2.0*fScrA)-2.0)) - 0.25*temp*temp);
     G4double b      = eta*delta;
     G4double c      = eta*(1.0-delta);
 
     //Calculate transport direction cosines:
     // ut,vt,wt is the final position divided by the true step length
     G4double w1v2 = cosTheta1*v2;
     G4double ut   = b*sinTheta1*cosPhi1 + c*(cosPhi1*u2 - sinPhi1*w1v2) + eta1*uss*temp1;
     G4double vt   = b*sinTheta1*sinPhi1 + c*(sinPhi1*u2 + cosPhi1*w1v2) + eta1*vss*temp1;
     G4double wt   = eta1*(1+temp) +       b*cosTheta1 +  c*cosTheta2    + eta1*wss*temp1;
 
     // long step correction
     ut *=par;
     vt *=par;
     wt *=par;
 
     // final position relative to the pre-step point in the scattering frame
     // ut = x_f/s so needs to multiply by s
     x_coord = ut*fTheTrueStepLenght;
     y_coord = vt*fTheTrueStepLenght;
     z_coord = wt*fTheTrueStepLenght;
 
     if(fIsEverythingWasDone){
       // We sample in the step limit so set fTheZPathLenght = transportDistance
       // and lateral displacement (x_coord,y_coord,z_coord-transportDistance)
       //Calculate transport distance
       G4double transportDistance  = std::sqrt(x_coord*x_coord+y_coord*y_coord+z_coord*z_coord);
       // protection
       if(transportDistance>fTheTrueStepLenght)
          transportDistance = fTheTrueStepLenght;
       fTheZPathLenght = transportDistance;
     }
     // else:: we sample in the DoIt so
     //       the fTheZPathLenght was already set and was taken as transport along zet
     fTheDisplacementVector.set(x_coord,y_coord,z_coord-fTheZPathLenght);
  } else {
     // compute zz = <z>/tPathLength
     // s -> true-path-length
     // z -> geom-path-length:: when PRESTA is used z =(def.) <z>
     // r -> lateral displacement = s/2 sin(theta)  => x_f = r cos(phi); y_f = r sin(phi)
     G4double zz = 0.0;
     if(fIsEverythingWasDone){
        // We sample in the step limit so set fTheZPathLenght = transportDistance
        // and lateral displacement (x_coord,y_coord,z_coord-transportDistance)
        if(Qn1<0.1) { // use 3-order Taylor approximation of (1-exp(-x))/x around x=0
          zz = 1.0 - Qn1*(0.5 - Qn1*(0.166666667 - 0.041666667*Qn1)); // 1/6 =0.166..7 ; 1/24=0.041..
        } else {
          zz = (1.-G4Exp(-Qn1))/Qn1;
        }
     } else {
        // we sample in the DoIt so
        // the fTheZPathLenght was already set and was taken as transport along zet
        zz = fTheZPathLenght/fTheTrueStepLenght;
     }
 
     G4double rr = (1.-zz*zz)/(1.-wss*wss); // s^2 >= <z>^2+r^2  :: where r^2 = s^2/4 sin^2(theta)
     if(rr >= 0.25) rr = 0.25;            // (1-<z>^2/s^2)/sin^2(theta) >= r^2/(s^2 sin^2(theta)) = 1/4 must hold
     G4double rperp = fTheTrueStepLenght*std::sqrt(rr);  // this is r/sint
     x_coord  = rperp*uss;
     y_coord  = rperp*vss;
     z_coord  = zz*fTheTrueStepLenght;
 
     if(fIsEverythingWasDone){
       G4double transportDistance = std::sqrt(x_coord*x_coord + y_coord*y_coord + z_coord*z_coord);
       fTheZPathLenght = transportDistance;
     }
 
     fTheDisplacementVector.set(x_coord,y_coord,z_coord- fTheZPathLenght);
   }
}

References currentCouple, currentKinEnergy, currentMaterialIndex, currentRange, source.hepunit::electron_mass_c2, CLHEP::electron_mass_c2, fG1, fGSTable, fIsEverythingWasDone, fIsNoDisplace, fIsNoScatteringInMSC, fLambda0, fLambda1, fMCtoG2PerG1, fMCtoQ1, fScrA, fTheDisplacementVector, fTheNewDirection, fTheTrueStepLenght, fTheZPathLenght, G4Exp(), G4Log(), G4UniformRand, G4VMscModel::GetEnergy(), GetTransportMeanFreePath(), gIsUseAccurate, particle, G4GoudsmitSaundersonTable::Sampling(), CLHEP::Hep3Vector::set(), and CLHEP::twopi.

Referenced by ComputeTruePathLengthLimit(), and SampleScattering().

◆ SampleScattering()

G4ThreeVector & G4GoudsmitSaundersonMscModel::SampleScattering	(	const G4ThreeVector &	oldDirection,
		G4double	safety
	)

overridevirtual

Implements G4VMscModel.

Definition at line 878 of file G4GoudsmitSaundersonMscModel.cc.

                                                                                          {
  if (steppingAlgorithm==fUseDistanceToBoundary && fIsEverythingWasDone && fIsSingleScattering) {
    // single scattering was and scattering happend
    fTheNewDirection.rotateUz(oldDirection);
    fParticleChange->ProposeMomentumDirection(fTheNewDirection);
    return fTheDisplacementVector;
  } else if (steppingAlgorithm==fUseSafetyPlus) {  // error-free stepping
    if (fIsEndedUpOnBoundary) { // do nothing on the boundary
      return fTheDisplacementVector;
    } else if (fIsEverythingWasDone) { // evrything is done if not optimizations case !!!
      // check single scattering and see if it happened
      if (fIsSingleScattering) {
        fTheNewDirection.rotateUz(oldDirection);
        fParticleChange->ProposeMomentumDirection(fTheNewDirection);
        return fTheDisplacementVector;
      }
      // check if multiple scattering happened and do things only if scattering was really happening
      if (fIsMultipleSacettring && !fIsNoScatteringInMSC) {
           fTheNewDirection.rotateUz(oldDirection);
           fTheDisplacementVector.rotateUz(oldDirection);
           fParticleChange->ProposeMomentumDirection(fTheNewDirection);
      }
      // The only thing that could happen if we are here (fUseSafety and fIsEverythingWasDone)
      // is that  single scattering was tried but did not win so scattering did not happen.
      // So no displacement and no scattering
      return fTheDisplacementVector;
    }
    //
    // The only thing that could still happen with fUseSafetyPlus is that we are in the
    // optimization branch: so sample MSC angle here (no displacement)
  }
  //else MSC needs to be done here
  SampleMSC();
  if (!fIsNoScatteringInMSC) {
    fTheNewDirection.rotateUz(oldDirection);
    fParticleChange->ProposeMomentumDirection(fTheNewDirection);
    if (!fIsNoDisplace) {
      fTheDisplacementVector.rotateUz(oldDirection);
    }
  }
  //
  return fTheDisplacementVector;
}

References fIsEndedUpOnBoundary, fIsEverythingWasDone, fIsMultipleSacettring, fIsNoDisplace, fIsNoScatteringInMSC, fIsSingleScattering, fParticleChange, fTheDisplacementVector, fTheNewDirection, fUseDistanceToBoundary, fUseSafetyPlus, G4ParticleChangeForMSC::ProposeMomentumDirection(), CLHEP::Hep3Vector::rotateUz(), SampleMSC(), and G4VMscModel::steppingAlgorithm.

◆ SampleSecondaries()

void G4VMscModel::SampleSecondaries	(	std::vector< G4DynamicParticle * > *	,
		const G4MaterialCutsCouple *	,
		const G4DynamicParticle *	,
		G4double	tmin,
		G4double	tmax
	)

overridevirtualinherited

Implements G4VEmModel.

Definition at line 151 of file G4VMscModel.cc.

155{}

◆ SecondaryThreshold()

G4double G4VEmModel::SecondaryThreshold ( ) const

inlineinherited

Definition at line 690 of file G4VEmModel.hh.

{
  return secondaryThreshold;
}

References G4VEmModel::secondaryThreshold.

Referenced by G4LivermoreBremsstrahlungModel::SampleSecondaries(), G4eBremParametrizedModel::SampleSecondaries(), G4eBremsstrahlungRelModel::SampleSecondaries(), G4SeltzerBergerModel::SampleSecondaries(), G4MuBremsstrahlungModel::SampleSecondaries(), and G4MuPairProductionModel::SampleSecondaries().

◆ SelectIsotopeNumber()

G4int G4VEmModel::SelectIsotopeNumber ( const G4Element * elm )

inherited

Definition at line 319 of file G4VEmModel.cc.

{
  SetCurrentElement(elm);
  const size_t ni = elm->GetNumberOfIsotopes();
  fCurrentIsotope = elm->GetIsotope(0);
  size_t idx = 0;
  if(ni > 1) {
    const G4double* ab = elm->GetRelativeAbundanceVector();
    G4double x = G4UniformRand();
    for(; idx<ni; ++idx) {
      x -= ab[idx];
      if (x <= 0.0) { 
    fCurrentIsotope = elm->GetIsotope(idx);
    break; 
      }
    }
  }
  return fCurrentIsotope->GetN();
}

References ab, G4VEmModel::fCurrentIsotope, G4UniformRand, G4Element::GetIsotope(), G4Isotope::GetN(), G4Element::GetNumberOfIsotopes(), G4Element::GetRelativeAbundanceVector(), and G4VEmModel::SetCurrentElement().

Referenced by G4eSingleCoulombScatteringModel::SampleSecondaries(), G4IonCoulombScatteringModel::SampleSecondaries(), G4eCoulombScatteringModel::SampleSecondaries(), G4hCoulombScatteringModel::SampleSecondaries(), and G4BetheHeitler5DModel::SampleSecondaries().

◆ SelectRandomAtom() [1/2]

const G4Element * G4VEmModel::SelectRandomAtom	(	const G4Material *	mat,
		const G4ParticleDefinition *	pd,
		G4double	kineticEnergy,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

inherited

Definition at line 275 of file G4VEmModel.cc.

{
  size_t n = mat->GetNumberOfElements();
  fCurrentElement = mat->GetElement(0);
  if (n > 1) {
    const G4double x = G4UniformRand()*
      G4VEmModel::CrossSectionPerVolume(mat,pd,kinEnergy,tcut,tmax);
    for(size_t i=0; i<n; ++i) {
      if (x <= xsec[i]) {
        fCurrentElement = mat->GetElement(i);
        break;
      }
    }
  }
  return fCurrentElement;
}

References G4VEmModel::CrossSectionPerVolume(), G4VEmModel::fCurrentElement, G4UniformRand, G4Material::GetElement(), G4Material::GetNumberOfElements(), CLHEP::detail::n, and G4VEmModel::xsec.

◆ SelectRandomAtom() [2/2]

const G4Element * G4VEmModel::SelectRandomAtom	(	const G4MaterialCutsCouple *	couple,
		const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

inlineinherited

Definition at line 580 of file G4VEmModel.hh.

{
  SetCurrentCouple(couple);
  fCurrentElement = (nSelectors > 0) ?
    ((*elmSelectors)[couple->GetIndex()])->SelectRandomAtom(kinEnergy) :
    SelectRandomAtom(pBaseMaterial,part,kinEnergy,cutEnergy,maxEnergy);
  fCurrentIsotope = nullptr;
  return fCurrentElement;
}

References G4VEmModel::elmSelectors, G4VEmModel::fCurrentElement, G4VEmModel::fCurrentIsotope, G4MaterialCutsCouple::GetIndex(), G4VEmModel::nSelectors, G4VEmModel::pBaseMaterial, G4VEmModel::SelectRandomAtom(), and G4VEmModel::SetCurrentCouple().

◆ SelectRandomAtomNumber()

G4int G4VEmModel::SelectRandomAtomNumber ( const G4Material * mat )

inherited

Definition at line 297 of file G4VEmModel.cc.

{
  // this algorith assumes that cross section is proportional to
  // number electrons multiplied by number of atoms
  const size_t nn = mat->GetNumberOfElements();
  fCurrentElement = mat->GetElement(0);
  if(1 < nn) {
    const G4double* at = mat->GetVecNbOfAtomsPerVolume();
    G4double tot = mat->GetTotNbOfAtomsPerVolume()*G4UniformRand();
    for(size_t i=0; i<nn; ++i) {
      tot -= at[i];
      if(tot <= 0.0) { 
    fCurrentElement = mat->GetElement(i);
    break; 
      }
    }
  }
  return fCurrentElement->GetZasInt();
}

References G4VEmModel::fCurrentElement, G4UniformRand, G4Material::GetElement(), G4Material::GetNumberOfElements(), G4Material::GetTotNbOfAtomsPerVolume(), G4Material::GetVecNbOfAtomsPerVolume(), G4Element::GetZasInt(), and G4InuclParticleNames::nn.

Referenced by G4AtimaEnergyLossModel::SampleSecondaries(), G4BetheBlochModel::SampleSecondaries(), G4BraggIonModel::SampleSecondaries(), G4BraggModel::SampleSecondaries(), G4ICRU73QOModel::SampleSecondaries(), G4LindhardSorensenIonModel::SampleSecondaries(), G4MollerBhabhaModel::SampleSecondaries(), and G4IonParametrisedLossModel::SampleSecondaries().

◆ SelectTargetAtom()

const G4Element * G4VEmModel::SelectTargetAtom	(	const G4MaterialCutsCouple *	couple,
		const G4ParticleDefinition *	part,
		G4double	kineticEnergy,
		G4double	logKineticEnergy,
		G4double	cutEnergy = `0.0`,
		G4double	maxEnergy = `DBL_MAX`
	)

inlineinherited

Definition at line 597 of file G4VEmModel.hh.

{
  SetCurrentCouple(couple);
  fCurrentElement = (nSelectors > 0)
   ? ((*elmSelectors)[couple->GetIndex()])->SelectRandomAtom(kinEnergy,logKinE)
   : SelectRandomAtom(pBaseMaterial,part,kinEnergy,cutEnergy,maxEnergy);
  fCurrentIsotope = nullptr;
  return fCurrentElement;
}

References G4VEmModel::elmSelectors, G4VEmModel::fCurrentElement, G4VEmModel::fCurrentIsotope, G4MaterialCutsCouple::GetIndex(), G4VEmModel::nSelectors, G4VEmModel::pBaseMaterial, G4VEmModel::SelectRandomAtom(), and G4VEmModel::SetCurrentCouple().

◆ SetActivationHighEnergyLimit()

void G4VEmModel::SetActivationHighEnergyLimit ( G4double val )

inlineinherited

Definition at line 781 of file G4VEmModel.hh.

{
  eMaxActive = val;
}

References G4VEmModel::eMaxActive.

Referenced by G4EmModelActivator::ActivateMicroElec(), G4EmDNAPhysics_option7::ConstructProcess(), G4EmDNAPhysics_option8::ConstructProcess(), G4NuclearStopping::InitialiseProcess(), and G4EmConfigurator::SetExtraEmModel().

◆ SetActivationLowEnergyLimit()

void G4VEmModel::SetActivationLowEnergyLimit ( G4double val )

inlineinherited

Definition at line 788 of file G4VEmModel.hh.

{
  eMinActive = val;
}

References G4VEmModel::eMinActive.

◆ SetAngularDistribution()

void G4VEmModel::SetAngularDistribution ( G4VEmAngularDistribution * p )

inlineinherited

Definition at line 628 of file G4VEmModel.hh.

{
  if(p != anglModel) {
    delete anglModel;
    anglModel = p;
  }
}

References G4VEmModel::anglModel.

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsSS::ConstructProcess(), G4BetheHeitlerModel::G4BetheHeitlerModel(), G4DNABornIonisationModel1::G4DNABornIonisationModel1(), G4DNABornIonisationModel2::G4DNABornIonisationModel2(), G4DNAEmfietzoglouIonisationModel::G4DNAEmfietzoglouIonisationModel(), G4DNARuddIonisationExtendedModel::G4DNARuddIonisationExtendedModel(), G4DNARuddIonisationModel::G4DNARuddIonisationModel(), G4eBremParametrizedModel::G4eBremParametrizedModel(), G4eBremsstrahlungRelModel::G4eBremsstrahlungRelModel(), G4IonParametrisedLossModel::G4IonParametrisedLossModel(), G4LivermoreBremsstrahlungModel::G4LivermoreBremsstrahlungModel(), G4LivermoreIonisationModel::G4LivermoreIonisationModel(), G4LivermorePhotoElectricModel::G4LivermorePhotoElectricModel(), G4LivermoreRayleighModel::G4LivermoreRayleighModel(), G4MicroElecInelasticModel::G4MicroElecInelasticModel(), G4MicroElecInelasticModel_new::G4MicroElecInelasticModel_new(), G4MuBremsstrahlungModel::G4MuBremsstrahlungModel(), G4MuPairProductionModel::G4MuPairProductionModel(), G4PAIModel::G4PAIModel(), G4PAIPhotModel::G4PAIPhotModel(), G4PairProductionRelModel::G4PairProductionRelModel(), G4PEEffectFluoModel::G4PEEffectFluoModel(), G4SeltzerBergerModel::G4SeltzerBergerModel(), G4AtimaEnergyLossModel::Initialise(), G4BetheBlochModel::Initialise(), G4BraggIonModel::Initialise(), G4BraggModel::Initialise(), G4ICRU73QOModel::Initialise(), G4LindhardSorensenIonModel::Initialise(), and G4MollerBhabhaModel::Initialise().

◆ SetAngularGeneratorFlag()

void G4VEmModel::SetAngularGeneratorFlag ( G4bool val )

inlineinherited

Definition at line 725 of file G4VEmModel.hh.

{
  useAngularGenerator = val;
}

References G4VEmModel::useAngularGenerator.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

◆ SetCrossSectionTable()

void G4VEmModel::SetCrossSectionTable	(	G4PhysicsTable *	p,
		G4bool	isLocal
	)

inherited

Definition at line 455 of file G4VEmModel.cc.

{
  if(p != xSectionTable) {
    if(xSectionTable != nullptr && localTable) { 
      xSectionTable->clearAndDestroy(); 
      delete xSectionTable;
    }
    xSectionTable = p;
  }
  localTable = isLocal;
}

References G4PhysicsTable::clearAndDestroy(), G4VEmModel::localTable, and G4VEmModel::xSectionTable.

Referenced by G4VMultipleScattering::BuildPhysicsTable().

◆ SetCurrentCouple()

void G4VEmModel::SetCurrentCouple ( const G4MaterialCutsCouple * ptr )

inlineinherited

Definition at line 472 of file G4VEmModel.hh.

{
  if(fCurrentCouple != ptr) {
    fCurrentCouple = ptr;
    basedCoupleIndex = currentCoupleIndex = ptr->GetIndex();
    pBaseMaterial = ptr->GetMaterial();
    pFactor = 1.0;
    if(useBaseMaterials) {
      basedCoupleIndex = (*theDensityIdx)[currentCoupleIndex];
      if(nullptr != pBaseMaterial->GetBaseMaterial()) 
    pBaseMaterial = pBaseMaterial->GetBaseMaterial();
      pFactor = (*theDensityFactor)[currentCoupleIndex];
    }
  }
}

References G4VEmModel::basedCoupleIndex, G4VEmModel::currentCoupleIndex, G4VEmModel::fCurrentCouple, G4Material::GetBaseMaterial(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4VEmModel::pBaseMaterial, G4VEmModel::pFactor, and G4VEmModel::useBaseMaterials.

Referenced by G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), G4EmMultiModel::ComputeCrossSectionPerAtom(), G4VEmModel::ComputeDEDX(), G4TablesForExtrapolator::ComputeTrasportXS(), G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), G4VEmModel::CrossSection(), G4AdjointPhotoElectricModel::DefineCurrentMaterialAndElectronEnergy(), G4WentzelVIModel::DefineMaterial(), G4WentzelVIRelModel::DefineMaterial(), G4EmCalculator::GetCrossSectionPerVolume(), G4LivermoreGammaConversion5DModel::Initialise(), G4VEmModel::InitialiseElementSelectors(), G4PEEffectFluoModel::SampleSecondaries(), G4EmMultiModel::SampleSecondaries(), G4VEnergyLossProcess::SelectModel(), G4VEmProcess::SelectModel(), G4VEmModel::SelectRandomAtom(), G4VEmModel::SelectTargetAtom(), and G4VEmModel::Value().

◆ SetCurrentElement()

void G4VEmModel::SetCurrentElement ( const G4Element * elm )

inlineprotectedinherited

Definition at line 497 of file G4VEmModel.hh.

{
  fCurrentElement = elm;
  fCurrentIsotope = nullptr;
}

References G4VEmModel::fCurrentElement, and G4VEmModel::fCurrentIsotope.

Referenced by G4VEmModel::ComputeCrossSectionPerAtom(), G4eBremsstrahlungRelModel::ComputeDEDXPerVolume(), G4eBremParametrizedModel::ComputeDEDXPerVolume(), and G4VEmModel::SelectIsotopeNumber().

◆ SetDeexcitationFlag()

void G4VEmModel::SetDeexcitationFlag ( G4bool val )

inlineinherited

Definition at line 823 of file G4VEmModel.hh.

{
  flagDeexcitation = val;
}

References G4VEmModel::flagDeexcitation.

Referenced by G4DNABornIonisationModel1::G4DNABornIonisationModel1(), G4DNABornIonisationModel2::G4DNABornIonisationModel2(), G4DNACPA100IonisationModel::G4DNACPA100IonisationModel(), G4DNAEmfietzoglouIonisationModel::G4DNAEmfietzoglouIonisationModel(), G4DNARelativisticIonisationModel::G4DNARelativisticIonisationModel(), G4DNARuddIonisationExtendedModel::G4DNARuddIonisationExtendedModel(), G4DNARuddIonisationModel::G4DNARuddIonisationModel(), G4KleinNishinaModel::G4KleinNishinaModel(), G4LEPTSIonisationModel::G4LEPTSIonisationModel(), G4LivermoreComptonModel::G4LivermoreComptonModel(), G4LivermorePhotoElectricModel::G4LivermorePhotoElectricModel(), G4LivermorePolarizedComptonModel::G4LivermorePolarizedComptonModel(), G4LowEPComptonModel::G4LowEPComptonModel(), G4LowEPPolarizedComptonModel::G4LowEPPolarizedComptonModel(), G4MicroElecInelasticModel::G4MicroElecInelasticModel(), G4MicroElecInelasticModel_new::G4MicroElecInelasticModel_new(), G4PEEffectFluoModel::G4PEEffectFluoModel(), G4PenelopeBremsstrahlungModel::G4PenelopeBremsstrahlungModel(), G4PenelopeComptonModel::G4PenelopeComptonModel(), G4PenelopeIonisationModel::G4PenelopeIonisationModel(), G4PenelopePhotoElectricModel::G4PenelopePhotoElectricModel(), G4AtimaEnergyLossModel::Initialise(), G4BetheBlochModel::Initialise(), G4BraggIonModel::Initialise(), G4BraggModel::Initialise(), G4ICRU73QOModel::Initialise(), and G4LindhardSorensenIonModel::Initialise().

◆ SetElementSelectors()

void G4VEmModel::SetElementSelectors ( std::vector< G4EmElementSelector * > * p )

inlineinherited

Definition at line 852 of file G4VEmModel.hh.

{
  if(p != elmSelectors) {
    elmSelectors = p;
    nSelectors = (nullptr != elmSelectors) ? G4int(elmSelectors->size()) : 0;
    localElmSelectors = false;
  }
}

References G4VEmModel::elmSelectors, G4VEmModel::localElmSelectors, and G4VEmModel::nSelectors.

◆ SetFluctuationFlag()

void G4VEmModel::SetFluctuationFlag ( G4bool val )

inlineinherited

Definition at line 732 of file G4VEmModel.hh.

{
  lossFlucFlag = val;
}

References G4VEmModel::lossFlucFlag.

Referenced by G4EmCalculator::ComputeNuclearDEDX().

◆ SetForceBuildTable()

void G4VEmModel::SetForceBuildTable ( G4bool val )

inlineinherited

Definition at line 830 of file G4VEmModel.hh.

{
  flagForceBuildTable = val;
}

References G4VEmModel::flagForceBuildTable.

◆ SetGeomFactor()

void G4VMscModel::SetGeomFactor ( G4double val )

inlineinherited

Definition at line 237 of file G4VMscModel.hh.

{
  if(!IsLocked()) { facgeom = val; }
}

References G4VMscModel::facgeom, and G4VEmModel::IsLocked().

◆ SetHighEnergyLimit()

void G4VEmModel::SetHighEnergyLimit ( G4double val )

inlineinherited

Definition at line 767 of file G4VEmModel.hh.

{
  highLimit = val;
}

References G4VEmModel::highLimit.

◆ SetIonisation()

void G4VMscModel::SetIonisation	(	G4VEnergyLossProcess *	p,
		const G4ParticleDefinition *	part
	)

inlineinherited

Definition at line 309 of file G4VMscModel.hh.

{
  ionisation = p;
  currentPart = part;
}

References G4VMscModel::currentPart, and G4VMscModel::ionisation.

Referenced by G4VMultipleScattering::PreparePhysicsTable(), and G4VMultipleScattering::StartTracking().

◆ SetLambdaLimit()

void G4VMscModel::SetLambdaLimit ( G4double val )

inlineinherited

Definition at line 244 of file G4VMscModel.hh.

{
  if(!IsLocked()) { lambdalimit = val; }
}

References G4VEmModel::IsLocked(), and G4VMscModel::lambdalimit.

◆ SetLateralDisplasmentFlag()

void G4VMscModel::SetLateralDisplasmentFlag ( G4bool val )

inlineinherited

Definition at line 216 of file G4VMscModel.hh.

{
  if(!IsLocked()) { latDisplasment = val; }
}

References G4VEmModel::IsLocked(), and G4VMscModel::latDisplasment.

Referenced by G4EmModelActivator::SetMscParameters().

◆ SetLocked()

void G4VEmModel::SetLocked ( G4bool val )

inlineinherited

Definition at line 884 of file G4VEmModel.hh.

{
  isLocked = val;
}

References G4VEmModel::isLocked.

Referenced by G4EmModelActivator::ActivateEmOptions(), G4EmModelActivator::AddStandardScattering(), and G4EmModelActivator::SetMscParameters().

◆ SetLowEnergyLimit()

void G4VEmModel::SetLowEnergyLimit ( G4double val )

inlineinherited

Definition at line 774 of file G4VEmModel.hh.

{
  lowLimit = val;
}

References G4VEmModel::lowLimit.

◆ SetLPMFlag()

void G4VEmModel::SetLPMFlag ( G4bool val )

inlineinherited

Definition at line 816 of file G4VEmModel.hh.

{
  theLPMflag = val;
}

References G4VEmModel::theLPMflag.

Referenced by G4eBremsstrahlungRelModel::G4eBremsstrahlungRelModel(), G4LivermoreBremsstrahlungModel::G4LivermoreBremsstrahlungModel(), G4SeltzerBergerModel::G4SeltzerBergerModel(), and G4eBremsstrahlung::InitialiseEnergyLossProcess().

◆ SetMasterThread()

void G4VEmModel::SetMasterThread ( G4bool val )

inlineinherited

Definition at line 739 of file G4VEmModel.hh.

{
  isMaster = val;
}

References G4VEmModel::isMaster.

Referenced by G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VMultipleScattering::PreparePhysicsTable().

◆ SetOptionMottCorrection()

void G4GoudsmitSaundersonMscModel::SetOptionMottCorrection ( G4bool opt )

inline

Definition at line 172 of file G4GoudsmitSaundersonMscModel.hh.

172{ fIsUseMottCorrection = opt; }

References fIsUseMottCorrection.

◆ SetOptionPWACorrection()

void G4GoudsmitSaundersonMscModel::SetOptionPWACorrection ( G4bool opt )

inline

Definition at line 168 of file G4GoudsmitSaundersonMscModel.hh.

168{ fIsUsePWACorrection = opt; }

References fIsUsePWACorrection.

◆ SetParticle()

void G4GoudsmitSaundersonMscModel::SetParticle ( const G4ParticleDefinition * p )

inlineprivate

Definition at line 266 of file G4GoudsmitSaundersonMscModel.hh.

{
  if (p != particle) {
    particle = p;
    charge = (G4int)(p->GetPDGCharge()/CLHEP::eplus);
    mass = p->GetPDGMass();
  }
}

References charge, CLHEP::eplus, G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), mass, and particle.

Referenced by Initialise(), and StartTracking().

◆ SetParticleChange()

void G4VEmModel::SetParticleChange	(	G4VParticleChange *	p,
		G4VEmFluctuationModel *	f = `nullptr`
	)

inherited

Definition at line 447 of file G4VEmModel.cc.

{
  if(p != nullptr && pParticleChange != p) { pParticleChange = p; }
  if(flucModel != f) { flucModel = f; }
}

References G4VEmModel::flucModel, and G4VEmModel::pParticleChange.

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4VEmModel::GetParticleChangeForGamma(), G4VEmModel::GetParticleChangeForLoss(), G4EmMultiModel::Initialise(), G4IonParametrisedLossModel::Initialise(), G4DNADummyModel::Initialise(), and G4NuclearStopping::InitialiseProcess().

◆ SetPolarAngleLimit()

void G4VEmModel::SetPolarAngleLimit ( G4double val )

inlineinherited

Definition at line 802 of file G4VEmModel.hh.

{
  if(!isLocked) { polarAngleLimit = val; }
}

References G4VEmModel::isLocked, and G4VEmModel::polarAngleLimit.

Referenced by G4EmModelActivator::ActivateEmOptions(), G4TablesForExtrapolator::ComputeTrasportXS(), G4CoulombScattering::InitialiseProcess(), G4VEmProcess::PreparePhysicsTable(), and G4VMultipleScattering::PreparePhysicsTable().

◆ SetRangeFactor()

void G4VMscModel::SetRangeFactor ( G4double val )

inlineinherited

Definition at line 230 of file G4VMscModel.hh.

{
  if(!IsLocked()) { facrange = val; }
}

References G4VMscModel::facrange, and G4VEmModel::IsLocked().

Referenced by G4EmModelActivator::SetMscParameters().

◆ SetSafetyFactor()

void G4VMscModel::SetSafetyFactor ( G4double val )

inlineinherited

Definition at line 251 of file G4VMscModel.hh.

{
  if(!IsLocked()) { facsafety = val; }
}

References G4VMscModel::facsafety, and G4VEmModel::IsLocked().

◆ SetSampleZ()

void G4VMscModel::SetSampleZ ( G4bool val )

inlineinherited

Definition at line 265 of file G4VMscModel.hh.

{
  if(!IsLocked()) { samplez = val; }
}

References G4VEmModel::IsLocked(), and G4VMscModel::samplez.

◆ SetSecondaryThreshold()

void G4VEmModel::SetSecondaryThreshold ( G4double val )

inlineinherited

Definition at line 809 of file G4VEmModel.hh.

{
  secondaryThreshold = val;
}

References G4VEmModel::secondaryThreshold.

Referenced by G4MuBremsstrahlung::InitialiseEnergyLossProcess(), G4MuPairProduction::InitialiseEnergyLossProcess(), and G4eBremsstrahlung::InitialiseEnergyLossProcess().

◆ SetSkin()

void G4VMscModel::SetSkin ( G4double val )

inlineinherited

Definition at line 223 of file G4VMscModel.hh.

{
  if(!IsLocked()) { skin = val; }
}

References G4VEmModel::IsLocked(), and G4VMscModel::skin.

Referenced by G4EmModelActivator::SetMscParameters().

◆ SetStepLimitType()

void G4VMscModel::SetStepLimitType ( G4MscStepLimitType val )

inlineinherited

Definition at line 258 of file G4VMscModel.hh.

{
  if(!IsLocked()) { steppingAlgorithm = val; }
}

References G4VEmModel::IsLocked(), and G4VMscModel::steppingAlgorithm.

Referenced by G4EmModelActivator::SetMscParameters().

◆ SetTripletModel()

void G4VEmModel::SetTripletModel ( G4VEmModel * p )

inlineinherited

Definition at line 645 of file G4VEmModel.hh.

{
  if(p != fTripletModel) {
    delete fTripletModel;
    fTripletModel = p;
  }
}

References G4VEmModel::fTripletModel.

Referenced by G4eplusTo2GammaOKVIModel::G4eplusTo2GammaOKVIModel().

◆ SetupForMaterial()

void G4VEmModel::SetupForMaterial	(	const G4ParticleDefinition *	,
		const G4Material *	,
		G4double	kineticEnergy
	)

virtualinherited

Reimplemented in G4eBremParametrizedModel, G4eBremsstrahlungRelModel, G4PairProductionRelModel, and G4SeltzerBergerModel.

Definition at line 440 of file G4VEmModel.cc.

442{}

Referenced by G4VEmModel::CrossSectionPerVolume(), G4PenelopeComptonModel::CrossSectionPerVolume(), G4PenelopeBremsstrahlungModel::CrossSectionPerVolume(), G4PenelopeIonisationModel::CrossSectionPerVolume(), G4EmCalculator::FindEmModel(), and G4EmElementSelector::Initialise().

◆ SetUseBaseMaterials()

void G4VEmModel::SetUseBaseMaterials ( G4bool val )

inlineinherited

Definition at line 753 of file G4VEmModel.hh.

{
  useBaseMaterials = val;
}

References G4VEmModel::useBaseMaterials.

Referenced by G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4TablesForExtrapolator::ComputeElectronDEDX(), G4TablesForExtrapolator::ComputeMuonDEDX(), G4TablesForExtrapolator::ComputeProtonDEDX(), G4TablesForExtrapolator::ComputeTrasportXS(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VMultipleScattering::PreparePhysicsTable().

◆ StartTracking()

void G4GoudsmitSaundersonMscModel::StartTracking ( G4Track * track )

overridevirtual

Reimplemented from G4VEmModel.

Definition at line 461 of file G4GoudsmitSaundersonMscModel.cc.

                                                               {
  SetParticle(track->GetDynamicParticle()->GetDefinition());
  firstStep = true;
  tlimit    = tgeom = rangeinit = geombig;
  rangeinit = 1.e+21;
}

References firstStep, geombig, G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), rangeinit, SetParticle(), tgeom, and tlimit.

◆ UseAngularGeneratorFlag()

G4bool G4VEmModel::UseAngularGeneratorFlag ( ) const

inlineinherited

Definition at line 718 of file G4VEmModel.hh.

{
  return useAngularGenerator;
}

References G4VEmModel::useAngularGenerator.

Referenced by G4AtimaEnergyLossModel::Initialise(), G4BetheBlochModel::Initialise(), G4BraggIonModel::Initialise(), G4BraggModel::Initialise(), G4ICRU73QOModel::Initialise(), G4LindhardSorensenIonModel::Initialise(), G4MollerBhabhaModel::Initialise(), G4AtimaEnergyLossModel::SampleSecondaries(), G4BetheBlochModel::SampleSecondaries(), G4BraggIonModel::SampleSecondaries(), G4BraggModel::SampleSecondaries(), G4ICRU73QOModel::SampleSecondaries(), G4LindhardSorensenIonModel::SampleSecondaries(), and G4MollerBhabhaModel::SampleSecondaries().

◆ UseBaseMaterials()

G4bool G4VEmModel::UseBaseMaterials ( ) const

inlineinherited

Definition at line 760 of file G4VEmModel.hh.

{
  return useBaseMaterials;
}

References G4VEmModel::useBaseMaterials.

◆ Value()

G4double G4VEmModel::Value	(	const G4MaterialCutsCouple *	couple,
		const G4ParticleDefinition *	p,
		G4double	kineticEnergy
	)

virtualinherited

Definition at line 406 of file G4VEmModel.cc.

{
  SetCurrentCouple(couple);
  return pFactor*e*e*CrossSectionPerVolume(pBaseMaterial,p,e,0.0,DBL_MAX);
}

References G4VEmModel::CrossSectionPerVolume(), DBL_MAX, G4VEmModel::pBaseMaterial, G4VEmModel::pFactor, and G4VEmModel::SetCurrentCouple().

Referenced by G4IonParametrisedLossModel::BuildRangeVector(), G4LossTableBuilder::BuildTableForModel(), G4LivermorePhotoElectricModel::ComputeCrossSectionPerAtom(), G4IonParametrisedLossModel::ComputeLossForStep(), G4VLEPTSModel::GetMeanFreePath(), G4DNABornExcitationModel2::GetPartialCrossSection(), G4DNABornExcitationModel2::Initialise(), G4DNABornExcitationModel2::RandomSelect(), G4SeltzerBergerModel::SampleEnergyTransfer(), G4LivermoreBremsstrahlungModel::SampleSecondaries(), and G4LivermorePhotoElectricModel::SampleSecondaries().

Field Documentation

◆ anglModel

G4VEmAngularDistribution* G4VEmModel::anglModel = nullptr

privateinherited

Definition at line 414 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetAngularDistribution(), G4VEmModel::SetAngularDistribution(), and G4VEmModel::~G4VEmModel().

◆ basedCoupleIndex

size_t G4VEmModel::basedCoupleIndex = 0

protectedinherited

Definition at line 449 of file G4VEmModel.hh.

Referenced by G4VMscModel::GetTransportMeanFreePath(), and G4VEmModel::SetCurrentCouple().

◆ charge

G4int G4GoudsmitSaundersonMscModel::charge

private

Definition at line 218 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by G4GoudsmitSaundersonMscModel(), and SetParticle().

◆ currentCouple

const G4MaterialCutsCouple* G4GoudsmitSaundersonMscModel::currentCouple

private

Definition at line 226 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), GetTransportMeanFreePath(), GetTransportMeanFreePathOnly(), and SampleMSC().

◆ currentCoupleIndex

size_t G4VEmModel::currentCoupleIndex = 0

protectedinherited

Definition at line 448 of file G4VEmModel.hh.

Referenced by G4VEmModel::SetCurrentCouple().

◆ currentKinEnergy

G4double G4GoudsmitSaundersonMscModel::currentKinEnergy

private

Definition at line 196 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), and SampleMSC().

◆ currentMaterialIndex

G4int G4GoudsmitSaundersonMscModel::currentMaterialIndex

private

Definition at line 219 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), and SampleMSC().

◆ currentPart

const G4ParticleDefinition* G4VMscModel::currentPart = nullptr

privateinherited

Definition at line 188 of file G4VMscModel.hh.

Referenced by G4VMscModel::SetIonisation().

◆ currentRange

G4double G4GoudsmitSaundersonMscModel::currentRange

private

Definition at line 197 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTruePathLengthLimit(), ComputeTrueStepLength(), G4GoudsmitSaundersonMscModel(), and SampleMSC().

◆ dedx

G4double G4VMscModel::dedx = 0.0

privateinherited

Definition at line 190 of file G4VMscModel.hh.

Referenced by G4VMscModel::G4VMscModel(), G4VMscModel::GetDEDX(), G4VMscModel::GetEnergy(), and G4VMscModel::GetRange().

◆ dtrl

G4double G4VMscModel::dtrl = 0.05

protectedinherited

Definition at line 200 of file G4VMscModel.hh.

Referenced by G4UrbanAdjointMscModel::ComputeGeomPathLength(), ComputeGeomPathLength(), G4UrbanMscModel::ComputeGeomPathLength(), G4UrbanAdjointMscModel::SampleScattering(), and G4UrbanMscModel::SampleScattering().

◆ elmSelectors

std::vector<G4EmElementSelector*>* G4VEmModel::elmSelectors = nullptr

privateinherited

Definition at line 419 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetElementSelectors(), G4VEmModel::InitialiseElementSelectors(), G4VEmModel::SelectRandomAtom(), G4VEmModel::SelectTargetAtom(), G4VEmModel::SetElementSelectors(), and G4VEmModel::~G4VEmModel().

◆ eMaxActive

G4double G4VEmModel::eMaxActive = DBL_MAX

privateinherited

Definition at line 439 of file G4VEmModel.hh.

Referenced by G4VEmModel::HighEnergyActivationLimit(), G4VEmModel::IsActive(), and G4VEmModel::SetActivationHighEnergyLimit().

◆ eMinActive

G4double G4VEmModel::eMinActive = 0.0

privateinherited

Definition at line 438 of file G4VEmModel.hh.

Referenced by G4VEmModel::IsActive(), G4VEmModel::LowEnergyActivationLimit(), and G4VEmModel::SetActivationLowEnergyLimit().

◆ facgeom

G4double G4VMscModel::facgeom = 2.5

protectedinherited

Definition at line 197 of file G4VMscModel.hh.

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4LowEWentzelVIModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), G4WentzelVIModel::ComputeTruePathLengthLimit(), G4VMscModel::DumpParameters(), G4VMscModel::InitialiseParameters(), and G4VMscModel::SetGeomFactor().

◆ facrange

G4double G4VMscModel::facrange = 0.04

protectedinherited

Definition at line 196 of file G4VMscModel.hh.

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4LowEWentzelVIModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), G4WentzelVIModel::ComputeTruePathLengthLimit(), G4VMscModel::DumpParameters(), G4VMscModel::InitialiseParameters(), G4VMscModel::SetRangeFactor(), G4UrbanAdjointMscModel::StartTracking(), and G4UrbanMscModel::StartTracking().

◆ facsafety

G4double G4VMscModel::facsafety = 0.6

protectedinherited

Definition at line 198 of file G4VMscModel.hh.

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4LowEWentzelVIModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), G4WentzelVIModel::ComputeTruePathLengthLimit(), G4VMscModel::DumpParameters(), G4UrbanAdjointMscModel::G4UrbanAdjointMscModel(), G4VMscModel::InitialiseParameters(), and G4VMscModel::SetSafetyFactor().

◆ fCurrentCouple

const G4MaterialCutsCouple* G4VEmModel::fCurrentCouple = nullptr

privateinherited

Definition at line 416 of file G4VEmModel.hh.

Referenced by G4VEmModel::CurrentCouple(), and G4VEmModel::SetCurrentCouple().

◆ fCurrentElement

const G4Element* G4VEmModel::fCurrentElement = nullptr

privateinherited

Definition at line 417 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetCurrentElement(), G4VEmModel::SelectRandomAtom(), G4VEmModel::SelectRandomAtomNumber(), G4VEmModel::SelectTargetAtom(), and G4VEmModel::SetCurrentElement().

◆ fCurrentIsotope

const G4Isotope* G4VEmModel::fCurrentIsotope = nullptr

privateinherited

Definition at line 418 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetCurrentIsotope(), G4VEmModel::SelectIsotopeNumber(), G4VEmModel::SelectRandomAtom(), G4VEmModel::SelectTargetAtom(), and G4VEmModel::SetCurrentElement().

◆ fDisplacement

G4ThreeVector G4VMscModel::fDisplacement

protectedinherited

Definition at line 208 of file G4VMscModel.hh.

Referenced by G4UrbanAdjointMscModel::SampleDisplacement(), G4UrbanMscModel::SampleDisplacement(), G4UrbanAdjointMscModel::SampleDisplacementNew(), G4UrbanMscModel::SampleDisplacementNew(), G4UrbanAdjointMscModel::SampleScattering(), G4UrbanMscModel::SampleScattering(), G4WentzelVIModel::SampleScattering(), and G4DummyModel::SampleScattering().

◆ fElementData

G4ElementData* G4VEmModel::fElementData = nullptr

protectedinherited

Definition at line 424 of file G4VEmModel.hh.

Referenced by G4MuPairProductionModel::FindScaledEnergy(), G4VEmModel::GetElementData(), G4MuPairProductionModel::Initialise(), G4MuPairProductionModel::InitialiseLocal(), G4MuPairProductionModel::MakeSamplingTables(), G4MuPairProductionModel::RetrieveTables(), G4MuPairProductionModel::StoreTables(), and G4VEmModel::~G4VEmModel().

◆ fEmManager

G4LossTableManager* G4VEmModel::fEmManager

privateinherited

Definition at line 420 of file G4VEmModel.hh.

Referenced by G4VEmModel::G4VEmModel(), and G4VEmModel::~G4VEmModel().

◆ fG1

G4double G4GoudsmitSaundersonMscModel::fG1

private

Definition at line 237 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetTransportMeanFreePath(), and SampleMSC().

◆ fGSTable

G4GoudsmitSaundersonTable* G4GoudsmitSaundersonMscModel::fGSTable

private

Definition at line 228 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetGSTable(), GetTransportMeanFreePath(), GetTransportMeanFreePathOnly(), Initialise(), InitialiseLocal(), SampleMSC(), and ~G4GoudsmitSaundersonMscModel().

◆ firstStep

G4bool G4GoudsmitSaundersonMscModel::firstStep

private

Definition at line 221 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), and StartTracking().

◆ fIsEndedUpOnBoundary

G4bool G4GoudsmitSaundersonMscModel::fIsEndedUpOnBoundary

private

Definition at line 250 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTrueStepLength(), G4GoudsmitSaundersonMscModel(), and SampleScattering().

◆ fIsEverythingWasDone

G4bool G4GoudsmitSaundersonMscModel::fIsEverythingWasDone

private

Definition at line 253 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTruePathLengthLimit(), ComputeTrueStepLength(), G4GoudsmitSaundersonMscModel(), SampleMSC(), and SampleScattering().

◆ fIsFirstRealStep

G4bool G4GoudsmitSaundersonMscModel::fIsFirstRealStep

private

Definition at line 258 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), and G4GoudsmitSaundersonMscModel().

◆ fIsInsideSkin

G4bool G4GoudsmitSaundersonMscModel::fIsInsideSkin

private

Definition at line 256 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), and G4GoudsmitSaundersonMscModel().

◆ fIsMultipleSacettring

G4bool G4GoudsmitSaundersonMscModel::fIsMultipleSacettring

private

Definition at line 251 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), ComputeTrueStepLength(), G4GoudsmitSaundersonMscModel(), and SampleScattering().

◆ fIsNoDisplace

G4bool G4GoudsmitSaundersonMscModel::fIsNoDisplace

private

Definition at line 255 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), SampleMSC(), and SampleScattering().

◆ fIsNoScatteringInMSC

G4bool G4GoudsmitSaundersonMscModel::fIsNoScatteringInMSC

private

Definition at line 254 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), SampleMSC(), and SampleScattering().

◆ fIsSingleScattering

G4bool G4GoudsmitSaundersonMscModel::fIsSingleScattering

private

Definition at line 252 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), and SampleScattering().

◆ fIsUseMottCorrection

G4bool G4GoudsmitSaundersonMscModel::fIsUseMottCorrection

private

Definition at line 232 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetOptionMottCorrection(), GetTransportMeanFreePath(), GetTransportMeanFreePathOnly(), Initialise(), InitialiseLocal(), and SetOptionMottCorrection().

◆ fIsUsePWACorrection

G4bool G4GoudsmitSaundersonMscModel::fIsUsePWACorrection

private

Definition at line 231 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetOptionPWACorrection(), GetTransportMeanFreePath(), GetTransportMeanFreePathOnly(), Initialise(), InitialiseLocal(), and SetOptionPWACorrection().

◆ fIsWasOnBoundary

G4bool G4GoudsmitSaundersonMscModel::fIsWasOnBoundary

private

Definition at line 257 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), and G4GoudsmitSaundersonMscModel().

◆ flagDeexcitation

G4bool G4VEmModel::flagDeexcitation = false

privateinherited

Definition at line 455 of file G4VEmModel.hh.

Referenced by G4VEmModel::DeexcitationFlag(), and G4VEmModel::SetDeexcitationFlag().

◆ flagForceBuildTable

G4bool G4VEmModel::flagForceBuildTable = false

privateinherited

Definition at line 456 of file G4VEmModel.hh.

Referenced by G4VEmModel::ForceBuildTableFlag(), and G4VEmModel::SetForceBuildTable().

◆ fLambda0

G4double G4GoudsmitSaundersonMscModel::fLambda0

private

Definition at line 234 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetTransportMeanFreePath(), and SampleMSC().

◆ fLambda1

G4double G4GoudsmitSaundersonMscModel::fLambda1

private

Definition at line 235 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTruePathLengthLimit(), ComputeTrueStepLength(), CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetTransportMeanFreePath(), and SampleMSC().

◆ flucModel

G4VEmFluctuationModel* G4VEmModel::flucModel = nullptr

privateinherited

Definition at line 413 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetModelOfFluctuations(), and G4VEmModel::SetParticleChange().

◆ fMCtoG2PerG1

G4double G4GoudsmitSaundersonMscModel::fMCtoG2PerG1

private

Definition at line 241 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetTransportMeanFreePath(), and SampleMSC().

◆ fMCtoQ1

G4double G4GoudsmitSaundersonMscModel::fMCtoQ1

private

Definition at line 240 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetTransportMeanFreePath(), and SampleMSC().

◆ fMCtoScrA

G4double G4GoudsmitSaundersonMscModel::fMCtoScrA

private

Definition at line 239 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), and GetTransportMeanFreePath().

◆ fParticleChange

G4ParticleChangeForMSC* G4GoudsmitSaundersonMscModel::fParticleChange

private

Definition at line 225 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by G4GoudsmitSaundersonMscModel(), Initialise(), and SampleScattering().

◆ fPWACorrection

G4GSPWACorrections* G4GoudsmitSaundersonMscModel::fPWACorrection

private

Definition at line 229 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetPWACorrection(), GetTransportMeanFreePath(), GetTransportMeanFreePathOnly(), Initialise(), InitialiseLocal(), and ~G4GoudsmitSaundersonMscModel().

◆ fr

G4double G4GoudsmitSaundersonMscModel::fr

private

Definition at line 199 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), and G4GoudsmitSaundersonMscModel().

◆ fScrA

G4double G4GoudsmitSaundersonMscModel::fScrA

private

Definition at line 236 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), CrossSectionPerVolume(), G4GoudsmitSaundersonMscModel(), GetTransportMeanFreePath(), and SampleMSC().

◆ fTheDisplacementVector

G4ThreeVector G4GoudsmitSaundersonMscModel::fTheDisplacementVector

private

Definition at line 247 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), SampleMSC(), and SampleScattering().

◆ fTheNewDirection

G4ThreeVector G4GoudsmitSaundersonMscModel::fTheNewDirection

private

Definition at line 248 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), SampleMSC(), and SampleScattering().

◆ fTheTransportDistance

G4double G4GoudsmitSaundersonMscModel::fTheTransportDistance

private

Definition at line 244 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), and G4GoudsmitSaundersonMscModel().

◆ fTheTrueStepLenght

G4double G4GoudsmitSaundersonMscModel::fTheTrueStepLenght

private

Definition at line 243 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTruePathLengthLimit(), ComputeTrueStepLength(), G4GoudsmitSaundersonMscModel(), and SampleMSC().

◆ fTheZPathLenght

G4double G4GoudsmitSaundersonMscModel::fTheZPathLenght

private

Definition at line 245 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTruePathLengthLimit(), ComputeTrueStepLength(), G4GoudsmitSaundersonMscModel(), and SampleMSC().

◆ fTripletModel

G4VEmModel* G4VEmModel::fTripletModel = nullptr

privateinherited

Definition at line 415 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetParticleChangeForGamma(), G4VEmModel::GetParticleChangeForLoss(), G4VEmModel::GetTripletModel(), and G4VEmModel::SetTripletModel().

◆ fZeff

G4double G4GoudsmitSaundersonMscModel::fZeff

private

Definition at line 216 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), and G4GoudsmitSaundersonMscModel().

◆ geombig

G4double G4GoudsmitSaundersonMscModel::geombig

private

Definition at line 201 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), and StartTracking().

◆ geomlimit

G4double G4GoudsmitSaundersonMscModel::geomlimit

private

Definition at line 202 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), and G4GoudsmitSaundersonMscModel().

◆ geomMax

G4double G4VMscModel::geomMax

protectedinherited

Definition at line 203 of file G4VMscModel.hh.

◆ geomMin

G4double G4VMscModel::geomMin

protectedinherited

Definition at line 202 of file G4VMscModel.hh.

◆ gIsOptimizationOn

G4bool G4GoudsmitSaundersonMscModel::gIsOptimizationOn = true

staticprivate

Definition at line 261 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit().

◆ gIsUseAccurate

G4bool G4GoudsmitSaundersonMscModel::gIsUseAccurate = true

staticprivate

Definition at line 260 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by SampleMSC().

◆ highLimit

G4double G4VEmModel::highLimit

privateinherited

Definition at line 437 of file G4VEmModel.hh.

Referenced by G4VEmModel::HighEnergyLimit(), G4VEmModel::InitialiseElementSelectors(), and G4VEmModel::SetHighEnergyLimit().

◆ inveplus

G4double G4VEmModel::inveplus

protectedinherited

Definition at line 431 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetChargeSquareRatio(), G4VMscModel::GetDEDX(), G4VMscModel::GetEnergy(), G4VMscModel::GetRange(), G4LindhardSorensenIonModel::SetupParameters(), and G4BetheBlochModel::SetupParameters().

◆ ionisation

G4VEnergyLossProcess* G4VMscModel::ionisation = nullptr

privateinherited

Definition at line 187 of file G4VMscModel.hh.

Referenced by G4VMscModel::GetDEDX(), G4VMscModel::GetEnergy(), G4VMscModel::GetIonisation(), G4VMscModel::GetRange(), and G4VMscModel::SetIonisation().

◆ isLocked

G4bool G4VEmModel::isLocked = false

privateinherited

Definition at line 463 of file G4VEmModel.hh.

Referenced by G4VEmModel::IsLocked(), G4VEmModel::SetLocked(), and G4VEmModel::SetPolarAngleLimit().

◆ isMaster

G4bool G4VEmModel::isMaster = true

privateinherited

Definition at line 457 of file G4VEmModel.hh.

Referenced by G4VEmModel::IsMaster(), G4VEmModel::SetMasterThread(), and G4VEmModel::~G4VEmModel().

◆ lambdalimit

G4double G4VMscModel::lambdalimit

protectedinherited

Definition at line 201 of file G4VMscModel.hh.

Referenced by G4UrbanMscModel::ComputeTruePathLengthLimit(), G4VMscModel::DumpParameters(), G4VMscModel::InitialiseParameters(), G4UrbanMscModel::SampleCosineTheta(), and G4VMscModel::SetLambdaLimit().

◆ latDisplasment

G4bool G4VMscModel::latDisplasment = true

protectedinherited

Definition at line 206 of file G4VMscModel.hh.

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), G4VMscModel::DumpParameters(), G4UrbanAdjointMscModel::Initialise(), G4UrbanMscModel::Initialise(), G4VMscModel::InitialiseParameters(), G4UrbanAdjointMscModel::SampleScattering(), G4UrbanMscModel::SampleScattering(), G4WentzelVIModel::SampleScattering(), and G4VMscModel::SetLateralDisplasmentFlag().

◆ localElmSelectors

G4bool G4VEmModel::localElmSelectors = true

privateinherited

Definition at line 460 of file G4VEmModel.hh.

Referenced by G4VEmModel::SetElementSelectors(), and G4VEmModel::~G4VEmModel().

◆ localrange

G4double G4VMscModel::localrange = DBL_MAX

privateinherited

Definition at line 192 of file G4VMscModel.hh.

Referenced by G4VMscModel::GetEnergy(), and G4VMscModel::GetRange().

◆ localTable

G4bool G4VEmModel::localTable = true

privateinherited

Definition at line 459 of file G4VEmModel.hh.

Referenced by G4VEmModel::SetCrossSectionTable(), and G4VEmModel::~G4VEmModel().

◆ localtkin

G4double G4VMscModel::localtkin = 0.0

privateinherited

Definition at line 191 of file G4VMscModel.hh.

Referenced by G4VMscModel::GetEnergy(), and G4VMscModel::GetRange().

◆ lossFlucFlag

G4bool G4VEmModel::lossFlucFlag = true

protectedinherited

Definition at line 450 of file G4VEmModel.hh.

Referenced by G4ICRU49NuclearStoppingModel::NuclearStoppingPower(), and G4VEmModel::SetFluctuationFlag().

◆ lowLimit

G4double G4VEmModel::lowLimit

privateinherited

Definition at line 436 of file G4VEmModel.hh.

Referenced by G4VEmModel::InitialiseElementSelectors(), G4VEmModel::LowEnergyLimit(), and G4VEmModel::SetLowEnergyLimit().

◆ mass

G4double G4GoudsmitSaundersonMscModel::mass

private

Definition at line 211 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), G4GoudsmitSaundersonMscModel(), and SetParticle().

◆ name

const G4String G4VEmModel::name

privateinherited

Definition at line 465 of file G4VEmModel.hh.

Referenced by source.g4viscp.G4Scene::create_scene(), G4VEmModel::GetName(), mcscore.MCParticle::printout(), and source.g4viscp.G4Scene::update_scene().

◆ nsec

G4int G4VEmModel::nsec = 5

privateinherited

Definition at line 444 of file G4VEmModel.hh.

Referenced by G4VEmModel::CrossSectionPerVolume(), and G4VEmModel::G4VEmModel().

◆ nSelectors

G4int G4VEmModel::nSelectors = 0

privateinherited

Definition at line 443 of file G4VEmModel.hh.

Referenced by G4VEmModel::InitialiseElementSelectors(), G4VEmModel::SelectRandomAtom(), G4VEmModel::SelectTargetAtom(), G4VEmModel::SetElementSelectors(), and G4VEmModel::~G4VEmModel().

◆ par1

G4double G4GoudsmitSaundersonMscModel::par1

private

Definition at line 206 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTrueStepLength(), and G4GoudsmitSaundersonMscModel().

◆ par2

G4double G4GoudsmitSaundersonMscModel::par2

private

Definition at line 207 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), and G4GoudsmitSaundersonMscModel().

◆ par3

G4double G4GoudsmitSaundersonMscModel::par3

private

Definition at line 208 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTrueStepLength(), and G4GoudsmitSaundersonMscModel().

◆ particle

const G4ParticleDefinition* G4GoudsmitSaundersonMscModel::particle

private

Definition at line 224 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by emcalc_gui.MainWindow::cb_select_particle(), emcalc_gui.MainWindow::cb_show_plot(), ComputeGeomPathLength(), ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), SampleMSC(), and SetParticle().

◆ pBaseMaterial

const G4Material* G4VEmModel::pBaseMaterial = nullptr

protectedinherited

Definition at line 427 of file G4VEmModel.hh.

Referenced by G4VEmModel::ComputeDEDX(), G4VEmModel::CrossSection(), G4VMscModel::GetTransportMeanFreePath(), G4VEmModel::SelectRandomAtom(), G4VEmModel::SelectTargetAtom(), G4VEmModel::SetCurrentCouple(), and G4VEmModel::Value().

◆ pFactor

G4double G4VEmModel::pFactor = 1.0

protectedinherited

Definition at line 432 of file G4VEmModel.hh.

Referenced by G4VEmModel::ComputeDEDX(), G4VEmModel::CrossSection(), G4VMscModel::GetTransportMeanFreePath(), G4VEmModel::SetCurrentCouple(), and G4VEmModel::Value().

◆ polarAngleLimit

G4double G4VEmModel::polarAngleLimit

privateinherited

Definition at line 441 of file G4VEmModel.hh.

Referenced by G4VEmModel::PolarAngleLimit(), and G4VEmModel::SetPolarAngleLimit().

◆ pParticleChange

G4VParticleChange* G4VEmModel::pParticleChange = nullptr

protectedinherited

Definition at line 425 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetParticleChangeForGamma(), G4VEmModel::GetParticleChangeForLoss(), G4VMscModel::GetParticleChangeForMSC(), G4EmMultiModel::Initialise(), and G4VEmModel::SetParticleChange().

◆ presafety

G4double G4GoudsmitSaundersonMscModel::presafety

private

Definition at line 215 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), and G4GoudsmitSaundersonMscModel().

◆ rangeinit

G4double G4GoudsmitSaundersonMscModel::rangeinit

private

Definition at line 200 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), and StartTracking().

◆ rndmEngineMod

CLHEP::HepRandomEngine* G4GoudsmitSaundersonMscModel::rndmEngineMod

private

Definition at line 194 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by G4GoudsmitSaundersonMscModel(), and Randomizetlimit().

◆ safetyHelper

G4SafetyHelper* G4VMscModel::safetyHelper = nullptr

privateinherited

Definition at line 186 of file G4VMscModel.hh.

Referenced by G4VMscModel::ComputeGeomLimit(), G4VMscModel::ComputeSafety(), and G4VMscModel::GetParticleChangeForMSC().

◆ samplez

G4bool G4VMscModel::samplez = false

protectedinherited

Definition at line 205 of file G4VMscModel.hh.

Referenced by G4VMscModel::SetSampleZ().

◆ secondaryThreshold

G4double G4VEmModel::secondaryThreshold = DBL_MAX

privateinherited

Definition at line 440 of file G4VEmModel.hh.

Referenced by G4VEmModel::SecondaryThreshold(), and G4VEmModel::SetSecondaryThreshold().

◆ skin

G4double G4VMscModel::skin = 1.0

protectedinherited

Definition at line 199 of file G4VMscModel.hh.

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), G4VMscModel::DumpParameters(), G4UrbanAdjointMscModel::G4UrbanAdjointMscModel(), G4UrbanMscModel::G4UrbanMscModel(), G4VMscModel::InitialiseParameters(), and G4VMscModel::SetSkin().

◆ steppingAlgorithm

G4MscStepLimitType G4VMscModel::steppingAlgorithm

protectedinherited

Definition at line 209 of file G4VMscModel.hh.

Referenced by G4UrbanAdjointMscModel::ComputeTruePathLengthLimit(), G4LowEWentzelVIModel::ComputeTruePathLengthLimit(), ComputeTruePathLengthLimit(), G4UrbanMscModel::ComputeTruePathLengthLimit(), G4WentzelVIModel::ComputeTruePathLengthLimit(), G4VMscModel::DumpParameters(), G4VMscModel::InitialiseParameters(), SampleScattering(), and G4VMscModel::SetStepLimitType().

◆ taulim

G4double G4GoudsmitSaundersonMscModel::taulim

private

Definition at line 212 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), and G4GoudsmitSaundersonMscModel().

◆ tausmall

G4double G4GoudsmitSaundersonMscModel::tausmall

private

Definition at line 210 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTrueStepLength(), and G4GoudsmitSaundersonMscModel().

◆ tgeom

G4double G4GoudsmitSaundersonMscModel::tgeom

private

Definition at line 204 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), and StartTracking().

◆ theDensityFactor

const std::vector<G4double>* G4VEmModel::theDensityFactor = nullptr

protectedinherited

Definition at line 428 of file G4VEmModel.hh.

Referenced by G4VEmModel::G4VEmModel().

◆ theDensityIdx

const std::vector<G4int>* G4VEmModel::theDensityIdx = nullptr

protectedinherited

Definition at line 429 of file G4VEmModel.hh.

Referenced by G4VEmModel::G4VEmModel().

◆ theLPMflag

G4bool G4VEmModel::theLPMflag = false

privateinherited

Definition at line 454 of file G4VEmModel.hh.

Referenced by G4VEmModel::LPMFlag(), and G4VEmModel::SetLPMFlag().

◆ theManager

G4LossTableManager* G4GoudsmitSaundersonMscModel::theManager

private

Definition at line 223 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by G4GoudsmitSaundersonMscModel().

◆ tlimit

G4double G4GoudsmitSaundersonMscModel::tlimit

private

Definition at line 203 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeTruePathLengthLimit(), G4GoudsmitSaundersonMscModel(), Randomizetlimit(), and StartTracking().

◆ tlimitminfix2

G4double G4GoudsmitSaundersonMscModel::tlimitminfix2

private

Definition at line 209 of file G4GoudsmitSaundersonMscModel.hh.

Referenced by ComputeGeomPathLength(), ComputeTrueStepLength(), and G4GoudsmitSaundersonMscModel().

◆ useAngularGenerator

G4bool G4VEmModel::useAngularGenerator = false

privateinherited

Definition at line 461 of file G4VEmModel.hh.

Referenced by G4VEmModel::SetAngularGeneratorFlag(), and G4VEmModel::UseAngularGeneratorFlag().

◆ useBaseMaterials

G4bool G4VEmModel::useBaseMaterials = false

privateinherited

Definition at line 462 of file G4VEmModel.hh.

Referenced by G4VEmModel::SetCurrentCouple(), G4VEmModel::SetUseBaseMaterials(), and G4VEmModel::UseBaseMaterials().

◆ xsec

std::vector<G4double> G4VEmModel::xsec

privateinherited

Definition at line 466 of file G4VEmModel.hh.

Referenced by G4VEmModel::CrossSectionPerVolume(), G4VEmModel::G4VEmModel(), and G4VEmModel::SelectRandomAtom().

◆ xSectionTable

G4PhysicsTable* G4VEmModel::xSectionTable = nullptr

protectedinherited

Definition at line 426 of file G4VEmModel.hh.

Referenced by G4VEmModel::GetCrossSectionTable(), G4VMscModel::GetParticleChangeForMSC(), G4VMscModel::GetTransportMeanFreePath(), G4VEmModel::SetCrossSectionTable(), and G4VEmModel::~G4VEmModel().

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

source/processes/electromagnetic/standard/include/G4GoudsmitSaundersonMscModel.hh
source/processes/electromagnetic/standard/src/G4GoudsmitSaundersonMscModel.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4GoudsmitSaundersonMscModel() [1/2]

◆ ~G4GoudsmitSaundersonMscModel()

◆ G4GoudsmitSaundersonMscModel() [2/2]

Member Function Documentation

◆ ChargeSquareRatio()

◆ ComputeCrossSectionPerAtom() [1/2]

◆ ComputeCrossSectionPerAtom() [2/2]

◆ ComputeCrossSectionPerShell()

◆ ComputeDEDX()

◆ ComputeDEDXPerVolume()

◆ ComputeGeomLimit()

◆ ComputeGeomPathLength()

◆ ComputeMeanFreePath()

◆ ComputeSafety()

◆ ComputeTruePathLengthLimit()

◆ ComputeTrueStepLength()

◆ ConvertTrueToGeom()

◆ CorrectionsAlongStep()

◆ CrossSection()

◆ CrossSectionPerVolume()

◆ CurrentCouple()

◆ DeexcitationFlag()

◆ DefineForRegion()

◆ DumpParameters()

◆ FillNumberOfSecondaries()

◆ ForceBuildTableFlag()

◆ GetAngularDistribution()

◆ GetChargeSquareRatio()

◆ GetCrossSectionTable()

◆ GetCurrentElement()

◆ GetCurrentIsotope()

◆ GetDEDX() [1/2]

◆ GetDEDX() [2/2]

◆ GetElementData()

◆ GetElementSelectors()

◆ GetEnergy()

◆ GetGSTable()

◆ GetIonisation()

◆ GetLambda()

◆ GetModelOfFluctuations()

◆ GetName()

◆ GetOptionMottCorrection()

◆ GetOptionPWACorrection()

◆ GetPartialCrossSection()

◆ GetParticleChangeForGamma()

◆ GetParticleChangeForLoss()

◆ GetParticleChangeForMSC()

◆ GetParticleCharge()

◆ GetPWACorrection()

◆ GetRange() [1/2]

◆ GetRange() [2/2]

◆ GetTransportMeanFreePath() [1/2]

◆ GetTransportMeanFreePath() [2/2]

◆ GetTransportMeanFreePathOnly()

◆ GetTripletModel()

◆ HighEnergyActivationLimit()

◆ HighEnergyLimit()

◆ Initialise()

◆ InitialiseElementSelectors()

◆ InitialiseForElement()

◆ InitialiseForMaterial()

◆ InitialiseLocal()

◆ InitialiseParameters()

◆ IsActive()

◆ IsLocked()

◆ IsMaster()

◆ LowEnergyActivationLimit()

◆ LowEnergyLimit()

◆ LPMFlag()

◆ MaxSecondaryEnergy()

◆ MaxSecondaryKinEnergy()

◆ MinEnergyCut()