#include <G4VEmProcess.hh>

Inheritance diagram for G4VEmProcess:

Collaboration diagram for G4VEmProcess:

Public Member Functions
	G4VEmProcess (const G4String &name, G4ProcessType type=fElectromagnetic)

virtual	~G4VEmProcess ()

virtual G4bool	IsApplicable (const G4ParticleDefinition &p)=0

virtual void	PrintInfo ()=0

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

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	StartTracking (G4Track *)

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

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

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

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

G4double	CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple)

G4double	ComputeCrossSectionPerAtom (G4double kineticEnergy, G4double Z, G4double A=0., G4double cut=0.0)

G4double	MeanFreePath (const G4Track &track)

G4double	GetLambda (G4double &kinEnergy, const G4MaterialCutsCouple *couple)

void	SetLambdaBinning (G4int nbins)

void	SetMinKinEnergy (G4double e)

void	SetMinKinEnergyPrim (G4double e)

void	SetMaxKinEnergy (G4double e)

G4PhysicsTable *	LambdaTable () const

G4PhysicsTable *	LambdaTablePrim () const

const G4ParticleDefinition *	Particle () const

const G4ParticleDefinition *	SecondaryParticle () const

G4VEmModel *	SelectModelForMaterial (G4double kinEnergy, size_t &idxRegion) const

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

G4VEmModel *	EmModel (G4int index=1) const

void	SetEmModel (G4VEmModel *, G4int index=1)

void	UpdateEmModel (const G4String &, G4double, G4double)

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

const G4Element *	GetCurrentElement () const

const G4VEmModel *	GetCurrentModel () const

void	SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)

G4double	CrossSectionBiasingFactor () const

void	ActivateForcedInteraction (G4double length=0.0, const G4String &r="", G4bool flag=true)

void	ActivateSecondaryBiasing (const G4String &region, G4double factor, G4double energyLimit)

void	SetIntegral (G4bool val)

void	SetBuildTableFlag (G4bool val)

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

	G4VDiscreteProcess (G4VDiscreteProcess &)

virtual	~G4VDiscreteProcess ()

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

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

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

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

virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition , const G4Material )

G4VEmModel *	SelectModel (G4double &kinEnergy, size_t index)

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

G4PhysicsVector *	LambdaPhysicsVector (const G4MaterialCutsCouple *)

G4int	LambdaBinning () const

G4double	MinKinEnergy () const

G4double	MaxKinEnergy () const

G4double	PolarAngleLimit () const

G4bool	IsIntegral () const

G4double	RecalculateLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)

G4ParticleChangeForGamma *	GetParticleChange ()

void	SetParticle (const G4ParticleDefinition *p)

void	SetSecondaryParticle (const G4ParticleDefinition *p)

size_t	CurrentMaterialCutsCoupleIndex () const

G4double	GetGammaEnergyCut ()

G4double	GetElectronEnergyCut ()

void	SetStartFromNullFlag (G4bool val)

void	SetSplineFlag (G4bool val)

const G4Element *	GetTargetElement () const

const G4Isotope *	GetTargetIsotope () const

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

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4ParticleChangeForGamma	fParticleChange

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Private Member Functions
void	Clear ()

void	BuildLambdaTable ()

void	PrintInfoProcess (const G4ParticleDefinition &)

void	FindLambdaMax ()

void	PrintWarning (G4String tit, G4double val)

void	DefineMaterial (const G4MaterialCutsCouple *couple)

void	ComputeIntegralLambda (G4double kinEnergy)

G4double	GetLambdaFromTable (G4double kinEnergy)

G4double	GetLambdaFromTablePrim (G4double kinEnergy)

G4double	GetCurrentLambda (G4double kinEnergy)

G4double	ComputeCurrentLambda (G4double kinEnergy)

	G4VEmProcess (G4VEmProcess &)

G4VEmProcess &	operator= (const G4VEmProcess &right)

Private Attributes
G4LossTableManager *	lManager

G4EmParameters *	theParameters

G4EmModelManager *	modelManager

G4EmBiasingManager *	biasManager

const G4ParticleDefinition *	theGamma

const G4ParticleDefinition *	theElectron

const G4ParticleDefinition *	thePositron

const G4ParticleDefinition *	secondaryParticle

G4bool	buildLambdaTable

std::vector< G4VEmModel * >	emModels

G4int	numberOfModels

G4PhysicsTable *	theLambdaTable

G4PhysicsTable *	theLambdaTablePrim

std::vector< G4double >	theEnergyOfCrossSectionMax

std::vector< G4double >	theCrossSectionMax

size_t	idxLambda

size_t	idxLambdaPrim

const std::vector< G4double > *	theCuts

const std::vector< G4double > *	theCutsGamma

const std::vector< G4double > *	theCutsElectron

const std::vector< G4double > *	theCutsPositron

const std::vector< G4double > *	theDensityFactor

const std::vector< G4int > *	theDensityIdx

G4int	nLambdaBins

G4double	minKinEnergy

G4double	minKinEnergyPrim

G4double	maxKinEnergy

G4double	lambdaFactor

G4double	biasFactor

G4bool	integral

G4bool	applyCuts

G4bool	startFromNull

G4bool	splineFlag

G4bool	actMinKinEnergy

G4bool	actMaxKinEnergy

G4bool	actBinning

G4bool	actSpline

std::vector< G4DynamicParticle * >	secParticles

G4VEmModel *	currentModel

const G4ParticleDefinition *	particle

const G4ParticleDefinition *	currentParticle

const G4Material *	baseMaterial

const G4Material *	currentMaterial

const G4MaterialCutsCouple *	currentCouple

size_t	currentCoupleIndex

size_t	basedCoupleIndex

G4double	mfpKinEnergy

G4double	preStepKinEnergy

G4double	preStepLambda

G4double	fFactor

G4bool	biasFlag

G4bool	weightFlag

G4int	mainSecondaries

G4int	secID

G4int	fluoID

G4int	augerID

G4int	biasID

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

Detailed Description

Definition at line 93 of file G4VEmProcess.hh.

Constructor & Destructor Documentation

◆ G4VEmProcess() [1/2]

G4VEmProcess::G4VEmProcess	(	const G4String &	name,
		G4ProcessType	type = `fElectromagnetic`
	)

Definition at line 91 of file G4VEmProcess.cc.

                                                                   :
   G4VDiscreteProcess(name, type),
   secondaryParticle(nullptr),
   buildLambdaTable(true),
   numberOfModels(0),
   theLambdaTable(nullptr),
   theLambdaTablePrim(nullptr),
   theDensityFactor(nullptr),
   theDensityIdx(nullptr),
   integral(false),
   applyCuts(false),
   startFromNull(false),
   splineFlag(true),
   currentModel(nullptr),
   particle(nullptr),
   currentParticle(nullptr),
   currentCouple(nullptr)
 {
   theParameters = G4EmParameters::Instance();
   SetVerboseLevel(1);
 
   // Size of tables assuming spline
   minKinEnergy = 0.1*keV;
   maxKinEnergy = 10.0*TeV;
   nLambdaBins  = 77;
   minKinEnergyPrim = DBL_MAX;
   actBinning = false;
   actSpline = false;
   actMinKinEnergy = false;
   actMaxKinEnergy = false;
 
   // default lambda factor
   lambdaFactor  = 0.8;
 
   // default limit on polar angle
   biasFactor = fFactor = 1.0;
 
   // particle types
   theGamma     = G4Gamma::Gamma();
   theElectron  = G4Electron::Electron();
   thePositron  = G4Positron::Positron();
 
   theCuts = theCutsGamma = theCutsElectron = theCutsPositron = nullptr;
 
   pParticleChange = &fParticleChange;
   fParticleChange.SetSecondaryWeightByProcess(true);
   secParticles.reserve(5);
 
   baseMaterial = currentMaterial = nullptr;
 
   preStepLambda = preStepKinEnergy = 0.0;
   mfpKinEnergy  = DBL_MAX;
 
   idxLambda = idxLambdaPrim = currentCoupleIndex 
     = basedCoupleIndex = 0;
 
   modelManager = new G4EmModelManager();
   biasManager  = nullptr;
   biasFlag     = false; 
   weightFlag   = false;
   lManager = G4LossTableManager::Instance();
   lManager->Register(this);
   secID = fluoID = augerID = biasID = -1;
   mainSecondaries = 100;
   if("phot" == GetProcessName() || "compt" == GetProcessName()) { 
     mainSecondaries = 1; 
   }
 }

Here is the call graph for this function:

◆ ~G4VEmProcess()

G4VEmProcess::~G4VEmProcess ( )

virtual

Definition at line 162 of file G4VEmProcess.cc.

 {
   /*
   if(1 < verboseLevel) {
     G4cout << "G4VEmProcess destruct " << GetProcessName() 
            << "  " << this << "  " <<  theLambdaTable <<G4endl;
   }
   */
   if(lManager->IsMaster()) {
     if(theLambdaTable) {
       theLambdaTable->clearAndDestroy();
       delete theLambdaTable;
     }
     if(theLambdaTablePrim) {
       theLambdaTablePrim->clearAndDestroy();
       delete theLambdaTablePrim;
     }
   }
   delete modelManager;
   delete biasManager;
   lManager->DeRegister(this);
   //G4cout << "G4VEmProcess removed " << G4endl; 
 }

Here is the call graph for this function:

◆ G4VEmProcess() [2/2]

G4VEmProcess::G4VEmProcess ( G4VEmProcess & )

private

Member Function Documentation

◆ ActivateForcedInteraction()

void G4VEmProcess::ActivateForcedInteraction	(	G4double	length = `0.0`,
		const G4String &	r = `""`,
		G4bool	flag = `true`
	)

Definition at line 1128 of file G4VEmProcess.cc.

 {
   if(!biasManager) { biasManager = new G4EmBiasingManager(); }
   if(1 < verboseLevel) {
     G4cout << "### ActivateForcedInteraction: for " 
            << particle->GetParticleName() 
            << " and process " << GetProcessName()
            << " length(mm)= " << length/mm
            << " in G4Region <" << r 
            << "> weightFlag= " << flag 
            << G4endl; 
   }
   weightFlag = flag;
   biasManager->ActivateForcedInteraction(length, r);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ActivateSecondaryBiasing()

void G4VEmProcess::ActivateSecondaryBiasing	(	const G4String &	region,
		G4double	factor,
		G4double	energyLimit
	)

Definition at line 1148 of file G4VEmProcess.cc.

 {
   if (0.0 <= factor) {
 
     // Range cut can be applied only for e-
     if(0.0 == factor && secondaryParticle != G4Electron::Electron())
       { return; }
 
     if(!biasManager) { biasManager = new G4EmBiasingManager(); }
     biasManager->ActivateSecondaryBiasing(region, factor, energyLimit);
     if(1 < verboseLevel) {
       G4cout << "### ActivateSecondaryBiasing: for "
        << " process " << GetProcessName()
        << " factor= " << factor
        << " in G4Region <" << region
        << "> energyLimit(MeV)= " << energyLimit/MeV
        << G4endl;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddEmModel()

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

Definition at line 206 of file G4VEmProcess.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildLambdaTable()

void G4VEmProcess::BuildLambdaTable ( )

private

Definition at line 428 of file G4VEmProcess.cc.

 {
   if(1 < verboseLevel) {
     G4cout << "G4EmProcess::BuildLambdaTable() for process "
            << GetProcessName() << " and particle "
            << particle->GetParticleName() << "  " << this
            << G4endl;
   }
 
   // Access to materials
   const G4ProductionCutsTable* theCoupleTable=
         G4ProductionCutsTable::GetProductionCutsTable();
   size_t numOfCouples = theCoupleTable->GetTableSize();
 
   G4LossTableBuilder* bld = lManager->GetTableBuilder();
 
   G4PhysicsLogVector* aVector = nullptr;
   G4PhysicsLogVector* aVectorPrim = nullptr;
   G4PhysicsLogVector* bVectorPrim = nullptr;
 
   G4double scale = 
     G4Log(theParameters->MaxKinEnergy()/theParameters->MinKinEnergy()); 
   G4int nbin = theParameters->NumberOfBins();
   if(actBinning) { nbin = std::max(nbin, nLambdaBins); }
   G4double emax1 = std::min(maxKinEnergy, minKinEnergyPrim);
   if(!actSpline) { splineFlag = theParameters->Spline(); }
     
   for(size_t i=0; i<numOfCouples; ++i) {
 
     if (bld->GetFlag(i)) {
 
       // create physics vector and fill it
       const G4MaterialCutsCouple* couple = 
         theCoupleTable->GetMaterialCutsCouple(i);
 
       // build main table
       if(buildLambdaTable) {
         delete (*theLambdaTable)[i];
 
         // if start from zero then change the scale
         G4double emin = minKinEnergy;
         G4bool startNull = false;
         if(startFromNull) {
           G4double e = MinPrimaryEnergy(particle,couple->GetMaterial());
           if(e >= emin) {
             emin = e;
             startNull = true;
           }
         }
         G4double emax = emax1;
         if(emax <= emin) { emax = 2*emin; }
         G4int bin = G4lrint(nbin*G4Log(emax/emin)/scale);
         if(bin < 3) { bin = 3; }
         aVector = new G4PhysicsLogVector(emin, emax, bin);
         aVector->SetSpline(splineFlag);
         modelManager->FillLambdaVector(aVector, couple, startNull);
         if(splineFlag) { aVector->FillSecondDerivatives(); }
         G4PhysicsTableHelper::SetPhysicsVector(theLambdaTable, i, aVector);
       }
       // build high energy table 
       if(minKinEnergyPrim < maxKinEnergy) { 
         delete (*theLambdaTablePrim)[i];
 
         // start not from zero
         if(!bVectorPrim) {
           G4int bin = G4lrint(nbin*G4Log(maxKinEnergy/minKinEnergyPrim)/scale);
           if(bin < 3) { bin = 3; }
           aVectorPrim = 
             new G4PhysicsLogVector(minKinEnergyPrim, maxKinEnergy, bin);
           bVectorPrim = aVectorPrim;
         } else {
           aVectorPrim = new G4PhysicsLogVector(*bVectorPrim);
         }
         // always use spline
         aVectorPrim->SetSpline(splineFlag);
         modelManager->FillLambdaVector(aVectorPrim, couple, false, 
                                        fIsCrossSectionPrim);
         aVectorPrim->FillSecondDerivatives();
         G4PhysicsTableHelper::SetPhysicsVector(theLambdaTablePrim, i, 
                                                aVectorPrim);
       }
     }
   }
 
   if(buildLambdaTable) { FindLambdaMax(); }
 
   if(1 < verboseLevel) {
     G4cout << "Lambda table is built for "
            << particle->GetParticleName()
            << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildPhysicsTable()

void G4VEmProcess::BuildPhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Reimplemented in G4PolarizedCompton, and G4eplusPolarizedAnnihilation.

Definition at line 352 of file G4VEmProcess.cc.

 {
   G4bool isMaster = true;
   const G4VEmProcess* masterProc = 
     static_cast<const G4VEmProcess*>(GetMasterProcess());
   if(masterProc && masterProc != this) { isMaster = false; }
 
   G4String num = part.GetParticleName();
   if(1 < verboseLevel) {
     G4cout << "### G4VEmProcess::BuildPhysicsTable() for "
            << GetProcessName()
            << " and particle " << num
            << " buildLambdaTable= " << buildLambdaTable
            << " isMaster= " << isMaster 
            << G4endl;
   }
 
   if(particle == &part) { 
 
     G4LossTableBuilder* bld = lManager->GetTableBuilder();
 
     // worker initialisation
     if(!isMaster) {
       theLambdaTable = masterProc->LambdaTable();
       theLambdaTablePrim = masterProc->LambdaTablePrim();
 
       if(theLambdaTable) {
         bld->InitialiseBaseMaterials(theLambdaTable);
       } else if(theLambdaTablePrim) {
         bld->InitialiseBaseMaterials(theLambdaTablePrim);
       }
       theDensityFactor = bld->GetDensityFactors();
       theDensityIdx = bld->GetCoupleIndexes();
       if(theLambdaTable) { FindLambdaMax(); }
 
       // local initialisation of models
       G4bool printing = true;
       numberOfModels = modelManager->NumberOfModels();
       for(G4int i=0; i<numberOfModels; ++i) {
         G4VEmModel* mod = GetModelByIndex(i, printing);
         G4VEmModel* mod0= masterProc->GetModelByIndex(i, printing);
         mod->InitialiseLocal(particle, mod0);
       }
     // master thread
     } else {
       theDensityFactor = bld->GetDensityFactors();
       theDensityIdx = bld->GetCoupleIndexes();
       if(buildLambdaTable || minKinEnergyPrim < maxKinEnergy) {
         BuildLambdaTable();
       }
     }
   }
 
   // explicitly defined printout by particle name
   if(1 < verboseLevel || 
      (0 < verboseLevel && (num == "gamma" || num == "e-" || 
                            num == "e+"    || num == "mu+" || 
                            num == "mu-"   || num == "proton"|| 
                            num == "pi+"   || num == "pi-" || 
                            num == "kaon+" || num == "kaon-" || 
                            num == "alpha" || num == "anti_proton" || 
                            num == "GenericIon")))
     { 
       PrintInfoProcess(part); 
     }
 
   if(1 < verboseLevel) {
     G4cout << "### G4VEmProcess::BuildPhysicsTable() done for "
            << GetProcessName()
            << " and particle " << num
            << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clear()

void G4VEmProcess::Clear ( )

private

Definition at line 188 of file G4VEmProcess.cc.

 {
   currentCouple = nullptr;
   preStepLambda = 0.0;
   mfpKinEnergy  = DBL_MAX;
   idxLambda = idxLambdaPrim = 0;
 }

Here is the caller graph for this function:

◆ ComputeCrossSectionPerAtom()

G4double G4VEmProcess::ComputeCrossSectionPerAtom	(	G4double	kineticEnergy,
		G4double	Z,
		G4double	A = `0.`,
		G4double	cut = `0.0`
	)

Definition at line 1024 of file G4VEmProcess.cc.

 {
   SelectModel(kineticEnergy, currentCoupleIndex);
   G4double x = 0.0;
   if(currentModel) {
     x = currentModel->ComputeCrossSectionPerAtom(currentParticle,kineticEnergy,
                                                  Z,A,cut);
   }
   return x;
 }

Here is the call graph for this function:

◆ ComputeCurrentLambda()

G4double G4VEmProcess::ComputeCurrentLambda ( G4double kinEnergy )

inlineprivate

Definition at line 495 of file G4VEmProcess.hh.

 {
   return currentModel->CrossSectionPerVolume(
          baseMaterial,currentParticle, e,(*theCuts)[currentCoupleIndex]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeIntegralLambda()

void G4VEmProcess::ComputeIntegralLambda ( G4double kinEnergy )

inlineprivate

Definition at line 535 of file G4VEmProcess.hh.

 {
   mfpKinEnergy  = theEnergyOfCrossSectionMax[currentCoupleIndex];
   if (e <= mfpKinEnergy) {
     preStepLambda = GetCurrentLambda(e);
 
   } else {
     G4double e1 = e*lambdaFactor;
     if(e1 > mfpKinEnergy) {
       preStepLambda = GetCurrentLambda(e);
       G4double preStepLambda1 = GetCurrentLambda(e1);
       if(preStepLambda1 > preStepLambda) {
         mfpKinEnergy = e1;
         preStepLambda = preStepLambda1;
       }
     } else {
       preStepLambda = fFactor*theCrossSectionMax[currentCoupleIndex];
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CrossSectionBiasingFactor()

G4double G4VEmProcess::CrossSectionBiasingFactor ( ) const

inline

Definition at line 588 of file G4VEmProcess.hh.

 {
   return biasFactor;
 }

◆ CrossSectionPerVolume()

G4double G4VEmProcess::CrossSectionPerVolume	(	G4double	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

Definition at line 981 of file G4VEmProcess.cc.

 {
   // Cross section per atom is calculated
   DefineMaterial(couple);
   G4double cross = 0.0;
   if(buildLambdaTable && theLambdaTable) {
     cross = GetCurrentLambda(kineticEnergy);
   } else {
     SelectModel(kineticEnergy, currentCoupleIndex);
     cross = fFactor*currentModel->CrossSectionPerVolume(currentMaterial,
                                                         currentParticle,
                                                         kineticEnergy);
   }
 
   if(cross < 0.0) { cross = 0.0; }
   return cross;
 }

Here is the call graph for this function:

◆ CurrentMaterialCutsCoupleIndex()

size_t G4VEmProcess::CurrentMaterialCutsCoupleIndex ( ) const

inlineprotected

Definition at line 422 of file G4VEmProcess.hh.

 {
   return currentCoupleIndex;
 }

Here is the caller graph for this function:

◆ DefineMaterial()

void G4VEmProcess::DefineMaterial ( const G4MaterialCutsCouple * couple )

inlineprivate

Definition at line 443 of file G4VEmProcess.hh.

 {
   if(couple != currentCouple) {
     currentCouple   = couple;
     currentMaterial = couple->GetMaterial();
     baseMaterial = currentMaterial->GetBaseMaterial();
     currentCoupleIndex = couple->GetIndex();
     basedCoupleIndex   = (*theDensityIdx)[currentCoupleIndex];
     fFactor = biasFactor*(*theDensityFactor)[currentCoupleIndex];
     if(!baseMaterial) { baseMaterial = currentMaterial; }
     mfpKinEnergy = DBL_MAX;
     idxLambda = idxLambdaPrim = 0;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EmModel()

G4VEmModel * G4VEmProcess::EmModel ( G4int index = 1 ) const

Definition at line 225 of file G4VEmProcess.cc.

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

Here is the caller graph for this function:

◆ FindLambdaMax()

void G4VEmProcess::FindLambdaMax ( )

private

Definition at line 1038 of file G4VEmProcess.cc.

 {
   if(1 < verboseLevel) {
     G4cout << "### G4VEmProcess::FindLambdaMax: " 
            << particle->GetParticleName() 
            << " and process " << GetProcessName() << "  " << G4endl; 
   }
   size_t n = theLambdaTable->length();
   G4PhysicsVector* pv;
   G4double e, ss, emax, smax;
 
   size_t i;
 
   // first loop on existing vectors
   for (i=0; i<n; ++i) {
     pv = (*theLambdaTable)[i];
     if(pv) {
       size_t nb = pv->GetVectorLength();
       emax = DBL_MAX;
       smax = 0.0;
       if(nb > 0) {
         for (size_t j=0; j<nb; ++j) {
           e = pv->Energy(j);
           ss = (*pv)(j);
           if(ss > smax) {
             smax = ss;
             emax = e;
           }
         }
       }
       theEnergyOfCrossSectionMax[i] = emax;
       theCrossSectionMax[i] = smax;
       if(1 < verboseLevel) {
         G4cout << "For " << particle->GetParticleName() 
                << " Max CS at i= " << i << " emax(MeV)= " << emax/MeV
                << " lambda= " << smax << G4endl;
       }
     }
   }
   // second loop using base materials
   for (i=0; i<n; ++i) {
     pv = (*theLambdaTable)[i];
     if(!pv){
       G4int j = (*theDensityIdx)[i];
       theEnergyOfCrossSectionMax[i] = theEnergyOfCrossSectionMax[j];
       theCrossSectionMax[i] = (*theDensityFactor)[i]*theCrossSectionMax[j];
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCurrentElement()

const G4Element * G4VEmProcess::GetCurrentElement ( ) const

Definition at line 1101 of file G4VEmProcess.cc.

 {
   const G4Element* elm = nullptr;
   if(currentModel) {elm = currentModel->GetCurrentElement(); }
   return elm;
 }

Here is the call graph for this function:

◆ GetCurrentLambda()

G4double G4VEmProcess::GetCurrentLambda ( G4double kinEnergy )

inlineprivate

Definition at line 503 of file G4VEmProcess.hh.

 {
   G4double x;
   if(e >= minKinEnergyPrim) { x = GetLambdaFromTablePrim(e); }
   else if(theLambdaTable)   { x = GetLambdaFromTable(e); }
   else                      { x = ComputeCurrentLambda(e); }
   return fFactor*x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCurrentModel()

const G4VEmModel * G4VEmProcess::GetCurrentModel ( ) const

inline

Definition at line 695 of file G4VEmProcess.hh.

 {
   return currentModel;
 }

◆ GetElectronEnergyCut()

G4double G4VEmProcess::GetElectronEnergyCut ( )

inlineprotected

Definition at line 436 of file G4VEmProcess.hh.

 {
   return (*theCutsElectron)[currentCoupleIndex];
 }

◆ GetGammaEnergyCut()

G4double G4VEmProcess::GetGammaEnergyCut ( )

inlineprotected

Definition at line 429 of file G4VEmProcess.hh.

 {
   return (*theCutsGamma)[currentCoupleIndex];
 }

◆ GetLambda()

G4double G4VEmProcess::GetLambda	(	G4double &	kinEnergy,
		const G4MaterialCutsCouple *	couple
	)

inline

Definition at line 515 of file G4VEmProcess.hh.

 {
   DefineMaterial(couple);
   SelectModel(kinEnergy, currentCoupleIndex);
   return GetCurrentLambda(kinEnergy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLambdaFromTable()

G4double G4VEmProcess::GetLambdaFromTable ( G4double kinEnergy )

inlineprivate

Definition at line 481 of file G4VEmProcess.hh.

 {
   return ((*theLambdaTable)[basedCoupleIndex])->Value(e, idxLambda);
 }

Here is the caller graph for this function:

◆ GetLambdaFromTablePrim()

G4double G4VEmProcess::GetLambdaFromTablePrim ( G4double kinEnergy )

inlineprivate

Definition at line 488 of file G4VEmProcess.hh.

 {
   return ((*theLambdaTablePrim)[basedCoupleIndex])->Value(e, idxLambdaPrim)/e;
 }

Here is the caller graph for this function:

◆ GetMeanFreePath()

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

protectedvirtual

Implements G4VDiscreteProcess.

Reimplemented in G4PolarizedCompton, and G4eplusPolarizedAnnihilation.

Definition at line 1002 of file G4VEmProcess.cc.

 {
   *condition = NotForced;
   return G4VEmProcess::MeanFreePath(track);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetModelByIndex()

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

Definition at line 242 of file G4VEmProcess.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetParticleChange()

G4ParticleChangeForGamma * G4VEmProcess::GetParticleChange ( )

inlineprotected

Definition at line 644 of file G4VEmProcess.hh.

 {
   return &fParticleChange;
 }

◆ GetTargetElement()

const G4Element * G4VEmProcess::GetTargetElement ( ) const

inlineprotected

Definition at line 681 of file G4VEmProcess.hh.

 {
   return currentModel->GetCurrentElement();
 }

Here is the call graph for this function:

◆ GetTargetIsotope()

const G4Isotope * G4VEmProcess::GetTargetIsotope ( ) const

inlineprotected

Definition at line 688 of file G4VEmProcess.hh.

 {
   return currentModel->GetCurrentIsotope();
 }

Here is the call graph for this function:

◆ InitialiseProcess()

virtual void G4VEmProcess::InitialiseProcess ( const G4ParticleDefinition * )

protectedpure virtual

Implemented in G4PolarizedPhotoElectricEffect, G4PhotoElectricEffect, G4GammaConversion, G4NuclearStopping, G4PolarizedCompton, G4eplusAnnihilation, G4ComptonScattering, G4DNAElectronSolvatation, G4eeToHadrons, G4MicroElecInelastic, G4MuElecInelastic, G4CoulombScattering, G4RayleighScattering, G4MicroElecElastic, G4MuElecElastic, G4DNAVibExcitation, G4DNAIonisation, G4DNAElastic, G4DNAExcitation, G4DNAChargeDecrease, G4DNAAttachment, G4DNAChargeIncrease, G4DNADissociation, G4DNAPositronium, G4DNARotExcitation, and G4DiscreteScatteringProcess.

Here is the caller graph for this function:

◆ IsApplicable()

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

pure virtual

◆ IsIntegral()

G4bool G4VEmProcess::IsIntegral ( ) const

inlineprotected

Definition at line 630 of file G4VEmProcess.hh.

 {
   return integral;
 }

◆ LambdaBinning()

G4int G4VEmProcess::LambdaBinning ( ) const

inlineprotected

Definition at line 560 of file G4VEmProcess.hh.

 {
   return nLambdaBins;
 }

Here is the caller graph for this function:

◆ LambdaPhysicsVector()

G4PhysicsVector * G4VEmProcess::LambdaPhysicsVector ( const G4MaterialCutsCouple * )

protected

Definition at line 1091 of file G4VEmProcess.cc.

 {
   G4PhysicsVector* v = 
     new G4PhysicsLogVector(minKinEnergy, maxKinEnergy, nLambdaBins);
   v->SetSpline(theParameters->Spline());
   return v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LambdaTable()

G4PhysicsTable * G4VEmProcess::LambdaTable ( ) const

inline

Definition at line 595 of file G4VEmProcess.hh.

 {
   return theLambdaTable;
 }

Here is the caller graph for this function:

◆ LambdaTablePrim()

G4PhysicsTable * G4VEmProcess::LambdaTablePrim ( ) const

inline

Definition at line 602 of file G4VEmProcess.hh.

 {
   return theLambdaTablePrim;
 }

Here is the caller graph for this function:

◆ MaxKinEnergy()

G4double G4VEmProcess::MaxKinEnergy ( ) const

inlineprotected

Definition at line 574 of file G4VEmProcess.hh.

 {
   return maxKinEnergy;
 }

Here is the caller graph for this function:

◆ MeanFreePath()

G4double G4VEmProcess::MeanFreePath ( const G4Track & track )

Definition at line 1012 of file G4VEmProcess.cc.

 {
   DefineMaterial(track.GetMaterialCutsCouple());
   preStepLambda = GetCurrentLambda(track.GetKineticEnergy());
   G4double x = DBL_MAX;
   if(0.0 < preStepLambda) { x = 1.0/preStepLambda; }
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MinKinEnergy()

G4double G4VEmProcess::MinKinEnergy ( ) const

inlineprotected

Definition at line 567 of file G4VEmProcess.hh.

 {
   return minKinEnergy;
 }

Here is the caller graph for this function:

◆ MinPrimaryEnergy()

G4double G4VEmProcess::MinPrimaryEnergy	(	const G4ParticleDefinition *	,
		const G4Material *
	)

protectedvirtual

Reimplemented in G4GammaConversion, and G4CoulombScattering.

Definition at line 198 of file G4VEmProcess.cc.

 {
   return 0.0;
 }

Here is the caller graph for this function:

◆ operator=()

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

private

◆ Particle()

const G4ParticleDefinition * G4VEmProcess::Particle ( ) const

inline

Definition at line 609 of file G4VEmProcess.hh.

 {
   return particle;
 }

◆ PolarAngleLimit()

G4double G4VEmProcess::PolarAngleLimit ( ) const

inlineprotected

Definition at line 581 of file G4VEmProcess.hh.

 {
   return theParameters->MscThetaLimit();
 }

Here is the call graph for this function:

◆ PostStepDoIt()

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 697 of file G4VEmProcess.cc.

 {
   // In all cases clear number of interaction lengths
   theNumberOfInteractionLengthLeft = -1.0;
   mfpKinEnergy = DBL_MAX; 
 
   fParticleChange.InitializeForPostStep(track);
 
   // Do not make anything if particle is stopped, the annihilation then
   // should be performed by the AtRestDoIt!
   if (track.GetTrackStatus() == fStopButAlive) { return &fParticleChange; }
 
   G4double finalT = track.GetKineticEnergy();
 
   // forced process - should happen only once per track
   if(biasFlag) {
     if(biasManager->ForcedInteractionRegion(currentCoupleIndex)) {
       biasFlag = false;
     }
   }
 
   // Integral approach
   if (integral) {
     G4double lx = GetLambda(finalT, currentCouple);
     if(preStepLambda<lx && 1 < verboseLevel) {
       G4cout << "WARNING: for " << currentParticle->GetParticleName() 
              << " and " << GetProcessName()
              << " E(MeV)= " << finalT/MeV
              << " preLambda= " << preStepLambda << " < " 
              << lx << " (postLambda) "
              << G4endl;  
     }
 
     if(preStepLambda*G4UniformRand() > lx) {
       ClearNumberOfInteractionLengthLeft();
       return &fParticleChange;
     }
   }
 
   SelectModel(finalT, currentCoupleIndex);
   if(!currentModel->IsActive(finalT)) { return &fParticleChange; }
 
   // define new weight for primary and secondaries
   G4double weight = fParticleChange.GetParentWeight();
   if(weightFlag) { 
     weight /= biasFactor; 
     fParticleChange.ProposeWeight(weight);
   }
   
   /*  
   if(0 < verboseLevel) {
     G4cout << "G4VEmProcess::PostStepDoIt: Sample secondary; E= "
            << finalT/MeV
            << " MeV; model= (" << currentModel->LowEnergyLimit()
            << ", " <<  currentModel->HighEnergyLimit() << ")"
            << G4endl;
   }
   */
 
   // sample secondaries
   secParticles.clear();
   currentModel->SampleSecondaries(&secParticles, 
                                   currentCouple, 
                                   track.GetDynamicParticle(),
                                   (*theCuts)[currentCoupleIndex]);
 
   G4int num0 = secParticles.size();
 
   // splitting or Russian roulette
   if(biasManager) {
     if(biasManager->SecondaryBiasingRegion(currentCoupleIndex)) {
       G4double eloss = 0.0;
       weight *= biasManager->ApplySecondaryBiasing(
         secParticles, track, currentModel, &fParticleChange, eloss, 
         currentCoupleIndex, (*theCuts)[currentCoupleIndex],
         step.GetPostStepPoint()->GetSafety());
       if(eloss > 0.0) {
         eloss += fParticleChange.GetLocalEnergyDeposit();
         fParticleChange.ProposeLocalEnergyDeposit(eloss);
       }
     }
   }
 
   // save secondaries
   G4int num = secParticles.size();
   if(num > 0) {
 
     fParticleChange.SetNumberOfSecondaries(num);
     G4double edep = fParticleChange.GetLocalEnergyDeposit();
     G4double time = track.GetGlobalTime();
      
     for (G4int i=0; i<num; ++i) {
       if (secParticles[i]) {
         G4DynamicParticle* dp = secParticles[i];
         const G4ParticleDefinition* p = dp->GetParticleDefinition();
         G4double e = dp->GetKineticEnergy();
         G4bool good = true;
         if(applyCuts) {
           if (p == theGamma) {
             if (e < (*theCutsGamma)[currentCoupleIndex]) { good = false; }
 
           } else if (p == theElectron) {
             if (e < (*theCutsElectron)[currentCoupleIndex]) { good = false; }
 
           } else if (p == thePositron) {
             if (electron_mass_c2 < (*theCutsGamma)[currentCoupleIndex] &&
                 e < (*theCutsPositron)[currentCoupleIndex]) {
               good = false;
               e += 2.0*electron_mass_c2;
             }
           }
           // added secondary if it is good
         }
         if (good) { 
           G4Track* t = new G4Track(dp, time, track.GetPosition());
           t->SetTouchableHandle(track.GetTouchableHandle());
           t->SetWeight(weight);
           pParticleChange->AddSecondary(t);
 
           // define type of secondary
           if(i < mainSecondaries) { t->SetCreatorModelIndex(secID); }
           else if(i < num0) {
             if(p == theGamma) { 
               t->SetCreatorModelIndex(fluoID);
             } else {
               t->SetCreatorModelIndex(augerID);
             }
           } else {
             t->SetCreatorModelIndex(biasID);
           }
  
           //G4cout << "Secondary(post step) has weight " << t->GetWeight() 
           // << ", Ekin= " << t->GetKineticEnergy()/MeV << " MeV" <<G4endl;
         } else {
           delete dp;
           edep += e;
         }
       } 
     }
     fParticleChange.ProposeLocalEnergyDeposit(edep);
   }
 
   if(0.0 == fParticleChange.GetProposedKineticEnergy() &&
      fAlive == fParticleChange.GetTrackStatus()) {
     if(particle->GetProcessManager()->GetAtRestProcessVector()->size() > 0)
          { fParticleChange.ProposeTrackStatus(fStopButAlive); }
     else { fParticleChange.ProposeTrackStatus(fStopAndKill); }
   }
 
   return &fParticleChange;
 }

Here is the call graph for this function:

◆ PostStepGetPhysicalInteractionLength()

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

virtual

Reimplemented from G4VDiscreteProcess.

Reimplemented in G4PolarizedCompton, and G4eplusPolarizedAnnihilation.

Definition at line 615 of file G4VEmProcess.cc.

 {
   *condition = NotForced;
   G4double x = DBL_MAX;
 
   preStepKinEnergy = track.GetKineticEnergy();
   DefineMaterial(track.GetMaterialCutsCouple());
   SelectModel(preStepKinEnergy, currentCoupleIndex);
 
   if(!currentModel->IsActive(preStepKinEnergy)) { 
     theNumberOfInteractionLengthLeft = -1.0;
     currentInteractionLength = DBL_MAX;
     return x; 
   }
  
   // forced biasing only for primary particles
   if(biasManager) {
     if(0 == track.GetParentID()) {
       if(biasFlag && 
          biasManager->ForcedInteractionRegion(currentCoupleIndex)) {
         return biasManager->GetStepLimit(currentCoupleIndex, previousStepSize);
       }
     }
   }
 
   // compute mean free path
   if(preStepKinEnergy < mfpKinEnergy) {
     if (integral) { ComputeIntegralLambda(preStepKinEnergy); }
     else { preStepLambda = GetCurrentLambda(preStepKinEnergy); }
 
     // zero cross section
     if(preStepLambda <= 0.0) { 
       theNumberOfInteractionLengthLeft = -1.0;
       currentInteractionLength = DBL_MAX;
     }
   }
 
   // non-zero cross section
   if(preStepLambda > 0.0) { 
 
     if (theNumberOfInteractionLengthLeft < 0.0) {
 
       // beggining of tracking (or just after DoIt of this process)
       theNumberOfInteractionLengthLeft =  -G4Log( G4UniformRand() );
       theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
 
     } else if(currentInteractionLength < DBL_MAX) {
 
       // subtract NumberOfInteractionLengthLeft using previous step
       theNumberOfInteractionLengthLeft -= 
         previousStepSize/currentInteractionLength;
       //SubtractNumberOfInteractionLengthLeft(previousStepSize);
       theNumberOfInteractionLengthLeft = 
         std::max(theNumberOfInteractionLengthLeft, 0.0);
     }
 
     // new mean free path and step limit for the next step
     currentInteractionLength = 1.0/preStepLambda;
     x = theNumberOfInteractionLengthLeft * currentInteractionLength;
     /*
 #ifdef G4VERBOSE
     if (verboseLevel>2){
       G4cout << "G4VEmProcess::PostStepGetPhysicalInteractionLength ";
       G4cout << "[ " << GetProcessName() << "]" << G4endl; 
       G4cout << " for " << currentParticle->GetParticleName() 
              << " in Material  " <<  currentMaterial->GetName()
              << " Ekin(MeV)= " << preStepKinEnergy/MeV 
              <<G4endl;
       G4cout << " MeanFreePath = " << currentInteractionLength/cm << "[cm]" 
              << " InteractionLength= " << x/cm <<"[cm] " <<G4endl;
     }
 #endif
     */
   }
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PreparePhysicsTable()

void G4VEmProcess::PreparePhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Definition at line 249 of file G4VEmProcess.cc.

 {
   G4bool isMaster = true;
   const G4VEmProcess* masterProcess = 
     static_cast<const G4VEmProcess*>(GetMasterProcess());
   if(masterProcess && masterProcess != this) { isMaster = false; }
 
   if(!particle) { SetParticle(&part); }
 
   if(part.GetParticleType() == "nucleus" && 
      part.GetParticleSubType() == "generic") {
 
     G4String pname = part.GetParticleName();
     if(pname != "deuteron" && pname != "triton" &&
        pname != "alpha" && pname != "He3" &&
        pname != "alpha+"   && pname != "helium" &&
        pname != "hydrogen") {
 
       particle = G4GenericIon::GenericIon();
     }
   }
 
   if(1 < verboseLevel) {
     G4cout << "G4VEmProcess::PreparePhysicsTable() for "
            << GetProcessName()
            << " and particle " << part.GetParticleName()
            << " local particle " << particle->GetParticleName() 
            << G4endl;
   }
 
   if(particle != &part) { return; }
 
   G4LossTableBuilder* bld = lManager->GetTableBuilder();
 
   lManager->PreparePhysicsTable(&part, this, isMaster);
 
   Clear();
   InitialiseProcess(particle);
 
   const G4ProductionCutsTable* theCoupleTable=
     G4ProductionCutsTable::GetProductionCutsTable();
   size_t n = theCoupleTable->GetTableSize();
 
   theEnergyOfCrossSectionMax.resize(n, 0.0);
   theCrossSectionMax.resize(n, DBL_MAX);
 
   // initialisation of the process  
   if(!actMinKinEnergy) { minKinEnergy = theParameters->MinKinEnergy(); }
   if(!actMaxKinEnergy) { maxKinEnergy = theParameters->MaxKinEnergy(); }
   if(isMaster) { SetVerboseLevel(theParameters->Verbose()); }
   else {  SetVerboseLevel(theParameters->WorkerVerbose()); }
   applyCuts = theParameters->ApplyCuts();
   lambdaFactor = theParameters->LambdaFactor();
 
   // initialisation of models
   numberOfModels = modelManager->NumberOfModels();
   for(G4int i=0; i<numberOfModels; ++i) {
     G4VEmModel* mod = modelManager->GetModel(i);
     if(0 == i) { currentModel = mod; }
     mod->SetPolarAngleLimit(theParameters->MscThetaLimit());
     mod->SetMasterThread(isMaster);
     if(mod->HighEnergyLimit() > maxKinEnergy) {
       mod->SetHighEnergyLimit(maxKinEnergy);
     }
   }
 
   if(lManager->AtomDeexcitation()) { modelManager->SetFluoFlag(true); }
   theCuts = modelManager->Initialise(particle,secondaryParticle,
                                      2.,verboseLevel);
   theCutsGamma    = theCoupleTable->GetEnergyCutsVector(idxG4GammaCut);
   theCutsElectron = theCoupleTable->GetEnergyCutsVector(idxG4ElectronCut);
   theCutsPositron = theCoupleTable->GetEnergyCutsVector(idxG4PositronCut);
 
   // prepare tables
   if(buildLambdaTable && isMaster){
     theLambdaTable = 
       G4PhysicsTableHelper::PreparePhysicsTable(theLambdaTable);
     bld->InitialiseBaseMaterials(theLambdaTable);
   }
   // high energy table
   if(isMaster && minKinEnergyPrim < maxKinEnergy){
     theLambdaTablePrim = 
       G4PhysicsTableHelper::PreparePhysicsTable(theLambdaTablePrim);
     bld->InitialiseBaseMaterials(theLambdaTablePrim);
   }
   // forced biasing
   if(biasManager) { 
     biasManager->Initialise(part,GetProcessName(),verboseLevel); 
     biasFlag = false; 
   }
   // defined ID of secondary particles
   G4String nam1 = GetProcessName();
   G4String nam2 = nam1 + "_fluo" ;
   G4String nam3 = nam1 + "_auger";
   G4String nam4 = nam1 + "_split";
   secID   = G4PhysicsModelCatalog::Register(nam1); 
   fluoID  = G4PhysicsModelCatalog::Register(nam2); 
   augerID = G4PhysicsModelCatalog::Register(nam3); 
   biasID  = G4PhysicsModelCatalog::Register(nam4); 
 }

Here is the call graph for this function:

◆ PrintInfo()

virtual void G4VEmProcess::PrintInfo ( )

pure virtual

Implemented in G4PolarizedPhotoElectricEffect, G4PhotoElectricEffect, G4GammaConversion, G4NuclearStopping, G4PolarizedCompton, G4eplusAnnihilation, G4ComptonScattering, G4eplusPolarizedAnnihilation, G4eeToHadrons, G4MicroElecInelastic, G4MuElecInelastic, G4CoulombScattering, G4DNAElectronSolvatation, G4RayleighScattering, G4MicroElecElastic, G4MuElecElastic, G4DNAIonisation, G4DNAElastic, G4DNAExcitation, G4DNAChargeDecrease, G4DNAAttachment, G4DNAChargeIncrease, G4DNAVibExcitation, G4DNADissociation, G4DNAPositronium, G4DNARotExcitation, and G4DiscreteScatteringProcess.

Here is the caller graph for this function:

◆ PrintInfoProcess()

void G4VEmProcess::PrintInfoProcess ( const G4ParticleDefinition & part )

private

Definition at line 523 of file G4VEmProcess.cc.

 {
   if(verboseLevel > 0) {
     G4cout << std::setprecision(6);
     G4cout << G4endl << GetProcessName() << ":   for  "
            << part.GetParticleName();
     if(integral)  { G4cout << ", integral: 1 "; }
     if(applyCuts) { G4cout << ", applyCuts: 1 "; }
     G4cout << "    SubType= " << GetProcessSubType();;
     if(biasFactor != 1.0) { G4cout << "   BiasingFactor= " << biasFactor; }
     G4cout << "  BuildTable= " << buildLambdaTable;
     G4cout << G4endl;
     if(buildLambdaTable) {
       if(particle == &part) { 
         size_t length = theLambdaTable->length();
         for(size_t i=0; i<length; ++i) {
           G4PhysicsVector* v = (*theLambdaTable)[i];
           if(v) { 
             G4cout << "      Lambda table from ";
             G4double emin = v->Energy(0);
             G4double emax = v->GetMaxEnergy();
             G4int nbin = v->GetVectorLength() - 1;
             if(emin > minKinEnergy) { G4cout << "threshold "; }
             else { G4cout << G4BestUnit(emin,"Energy"); } 
             G4cout << " to "
                    << G4BestUnit(emax,"Energy")
                    << ", " << G4lrint(nbin/std::log10(emax/emin))
                    << " bins per decade, spline: " 
                    << splineFlag
                    << G4endl;
             break;
           }
         }
       } else {
         G4cout << "      Used Lambda table of " 
                << particle->GetParticleName() << G4endl;;
       }
     }
     if(minKinEnergyPrim < maxKinEnergy) {
       if(particle == &part) { 
         size_t length = theLambdaTablePrim->length();
         for(size_t i=0; i<length; ++i) {
           G4PhysicsVector* v = (*theLambdaTablePrim)[i];
           if(v) { 
             G4cout << "      LambdaPrime table from "
                    << G4BestUnit(v->Energy(0),"Energy") 
                    << " to "
                    << G4BestUnit(v->GetMaxEnergy(),"Energy")
                    << " in " << v->GetVectorLength()-1
                    << " bins " 
                    << G4endl;
             break;
           }
         }
       } else {
         G4cout << "      Used LambdaPrime table of " 
                << particle->GetParticleName() << G4endl;;
       }
     }
     PrintInfo();
     modelManager->DumpModelList(verboseLevel);
   }
 
   if(verboseLevel > 2 && buildLambdaTable) {
     G4cout << "      LambdaTable address= " << theLambdaTable << G4endl;
     if(theLambdaTable && particle == &part) { 
       G4cout << (*theLambdaTable) << G4endl; 
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintWarning()

void G4VEmProcess::PrintWarning	(	G4String	tit,
		G4double	val
	)

private

Definition at line 1219 of file G4VEmProcess.cc.

 {
   G4String ss = "G4VEmProcess::" + tit;
   G4ExceptionDescription ed;
   ed << "Parameter is out of range: " << val 
      << " it will have no effect!\n" << "  Process " 
      << GetProcessName() << "  nbins= " << theParameters->NumberOfBins()
      << " Emin(keV)= " << theParameters->MinKinEnergy()/keV 
      << " Emax(GeV)= " << theParameters->MaxKinEnergy()/GeV;
   G4Exception(ss, "em0044", JustWarning, ed);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessDescription()

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

virtual

Definition at line 1233 of file G4VEmProcess.cc.

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

Here is the call graph for this function:

◆ RecalculateLambda()

G4double G4VEmProcess::RecalculateLambda	(	G4double	kinEnergy,
		const G4MaterialCutsCouple *	couple
	)

inlineprotected

Definition at line 526 of file G4VEmProcess.hh.

 {
   DefineMaterial(couple);
   SelectModel(e, currentCoupleIndex);
   return fFactor*ComputeCurrentLambda(e);
 }

Here is the call graph for this function:

◆ RetrievePhysicsTable()

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

virtual

Reimplemented from G4VProcess.

Definition at line 903 of file G4VEmProcess.cc.

 {
   if(1 < verboseLevel) {
     G4cout << "G4VEmProcess::RetrievePhysicsTable() for "
            << part->GetParticleName() << " and process "
            << GetProcessName() << G4endl;
   }
   G4bool yes = true;
 
   if((!buildLambdaTable && minKinEnergyPrim > maxKinEnergy) 
      || particle != part) { return yes; }
 
   const G4String particleName = part->GetParticleName();
   G4String filename;
 
   if(buildLambdaTable) {
     filename = GetPhysicsTableFileName(part,directory,"Lambda",ascii);
     yes = G4PhysicsTableHelper::RetrievePhysicsTable(theLambdaTable,
                                                      filename,ascii);
     if ( yes ) {
       if (0 < verboseLevel) {
         G4cout << "Lambda table for " << particleName 
                << " is Retrieved from <"
                << filename << ">"
                << G4endl;
       }
       if(theParameters->Spline()) {
         size_t n = theLambdaTable->length();
         for(size_t i=0; i<n; ++i) {
           if((* theLambdaTable)[i]) {
             (* theLambdaTable)[i]->SetSpline(true);
           }
         }
       }
     } else {
       if (1 < verboseLevel) {
         G4cout << "Lambda table for " << particleName << " in file <"
                << filename << "> is not exist"
                << G4endl;
       }
     }
   }
   if(minKinEnergyPrim < maxKinEnergy) {
     filename = GetPhysicsTableFileName(part,directory,"LambdaPrim",ascii);
     yes = G4PhysicsTableHelper::RetrievePhysicsTable(theLambdaTablePrim,
                                                      filename,ascii);
     if ( yes ) {
       if (0 < verboseLevel) {
         G4cout << "Lambda table prim for " << particleName 
                << " is Retrieved from <"
                << filename << ">"
                << G4endl;
       }
       if(theParameters->Spline()) {
         size_t n = theLambdaTablePrim->length();
         for(size_t i=0; i<n; ++i) {
           if((* theLambdaTablePrim)[i]) {
             (* theLambdaTablePrim)[i]->SetSpline(true);
           }
         }
       }
     } else {
       if (1 < verboseLevel) {
         G4cout << "Lambda table prim for " << particleName << " in file <"
                << filename << "> is not exist"
                << G4endl;
       }
     }
   }
 
   return yes;
 }

Here is the call graph for this function:

◆ SecondaryParticle()

const G4ParticleDefinition * G4VEmProcess::SecondaryParticle ( ) const

inline

Definition at line 616 of file G4VEmProcess.hh.

 {
   return secondaryParticle;
 }

◆ SelectModel()

G4VEmModel * G4VEmProcess::SelectModel	(	G4double &	kinEnergy,
		size_t	index
	)

inlineprotected

Definition at line 461 of file G4VEmProcess.hh.

 {
   if(1 < numberOfModels) {
     currentModel = modelManager->SelectModel(kinEnergy, index);
   }
   currentModel->SetCurrentCouple(currentCouple);
   return currentModel;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SelectModelForMaterial()

G4VEmModel * G4VEmProcess::SelectModelForMaterial	(	G4double	kinEnergy,
		size_t &	idxRegion
	)		const

inline

Definition at line 473 of file G4VEmProcess.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetBuildTableFlag()

void G4VEmProcess::SetBuildTableFlag ( G4bool val )

inline

Definition at line 637 of file G4VEmProcess.hh.

 {
   buildLambdaTable = val;
 }

Here is the caller graph for this function:

◆ SetCrossSectionBiasingFactor()

void G4VEmProcess::SetCrossSectionBiasingFactor	(	G4double	f,
		G4bool	flag = `true`
	)

Definition at line 1110 of file G4VEmProcess.cc.

 {
   if(f > 0.0) { 
     biasFactor = f; 
     weightFlag = flag;
     if(1 < verboseLevel) {
       G4cout << "### SetCrossSectionBiasingFactor: for " 
              << particle->GetParticleName() 
              << " and process " << GetProcessName()
              << " biasFactor= " << f << " weightFlag= " << flag 
              << G4endl; 
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetEmModel()

void G4VEmProcess::SetEmModel	(	G4VEmModel *	p,
		G4int	index = `1`
	)

Definition at line 216 of file G4VEmProcess.cc.

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

◆ SetIntegral()

void G4VEmProcess::SetIntegral ( G4bool val )

inline

Definition at line 623 of file G4VEmProcess.hh.

 {
   integral = val; 
 }

Here is the caller graph for this function:

◆ SetLambdaBinning()

void G4VEmProcess::SetLambdaBinning ( G4int nbins )

Definition at line 1173 of file G4VEmProcess.cc.

 {
   if(5 < n && n < 10000000) {  
     nLambdaBins = n; 
     actBinning = true;
   } else { 
     G4double e = (G4double)n;
     PrintWarning("SetLambdaBinning", e); 
   } 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMaxKinEnergy()

void G4VEmProcess::SetMaxKinEnergy ( G4double e )

Definition at line 1198 of file G4VEmProcess.cc.

 {
   if(minKinEnergy < e && e < 1.e+6*TeV) { 
     nLambdaBins = G4lrint(nLambdaBins*G4Log(e/minKinEnergy)
                           /G4Log(maxKinEnergy/minKinEnergy));
     maxKinEnergy = e;
     actMaxKinEnergy = true;
   } else { PrintWarning("SetMaxKinEnergy", e); } 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMinKinEnergy()

void G4VEmProcess::SetMinKinEnergy ( G4double e )

Definition at line 1186 of file G4VEmProcess.cc.

 {
   if(1.e-3*eV < e && e < maxKinEnergy) { 
     nLambdaBins = G4lrint(nLambdaBins*G4Log(maxKinEnergy/e)
                           /G4Log(maxKinEnergy/minKinEnergy));
     minKinEnergy = e;
     actMinKinEnergy = true;
   } else { PrintWarning("SetMinKinEnergy", e); } 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMinKinEnergyPrim()

void G4VEmProcess::SetMinKinEnergyPrim ( G4double e )

Definition at line 1210 of file G4VEmProcess.cc.

 {
   if(theParameters->MinKinEnergy() <= e && 
      e <= theParameters->MaxKinEnergy()) { minKinEnergyPrim = e; } 
   else { PrintWarning("SetMinKinEnergyPrim", e); } 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetParticle()

void G4VEmProcess::SetParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 651 of file G4VEmProcess.hh.

 {
   particle = p;
   currentParticle = p;
 }

Here is the caller graph for this function:

◆ SetSecondaryParticle()

void G4VEmProcess::SetSecondaryParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 659 of file G4VEmProcess.hh.

 {
   secondaryParticle = p;
 }

Here is the caller graph for this function:

◆ SetSplineFlag()

void G4VEmProcess::SetSplineFlag ( G4bool val )

inlineprotected

Definition at line 673 of file G4VEmProcess.hh.

 {
   splineFlag = val;
   actSpline = true;
 }

Here is the caller graph for this function:

◆ SetStartFromNullFlag()

void G4VEmProcess::SetStartFromNullFlag ( G4bool val )

inlineprotected

Definition at line 666 of file G4VEmProcess.hh.

 {
   startFromNull = val;
 }

Here is the caller graph for this function:

◆ StartTracking()

void G4VEmProcess::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

Definition at line 596 of file G4VEmProcess.cc.

 {
   // reset parameters for the new track
   currentParticle = track->GetParticleDefinition();
   theNumberOfInteractionLengthLeft = -1.0;
   mfpKinEnergy = DBL_MAX; 
 
   // forced biasing only for primary particles
   if(biasManager) {
     if(0 == track->GetParentID()) {
       // primary particle
       biasFlag = true; 
       biasManager->ResetForcedInteraction(); 
     }
   }
 }

Here is the call graph for this function:

◆ StorePhysicsTable()

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

virtual

Reimplemented from G4VProcess.

Definition at line 852 of file G4VEmProcess.cc.

 {
   G4bool yes = true;
   const G4VEmProcess* masterProc = 
     static_cast<const G4VEmProcess*>(GetMasterProcess());
   if(masterProc && masterProc != this) { return yes; }
 
   if ( theLambdaTable && part == particle) {
     const G4String name = 
       GetPhysicsTableFileName(part,directory,"Lambda",ascii);
     yes = theLambdaTable->StorePhysicsTable(name,ascii);
 
     if ( yes ) {
       G4cout << "Physics table is stored for " << particle->GetParticleName()
              << " and process " << GetProcessName()
              << " in the directory <" << directory
              << "> " << G4endl;
     } else {
       G4cout << "Fail to store Physics Table for " 
              << particle->GetParticleName()
              << " and process " << GetProcessName()
              << " in the directory <" << directory
              << "> " << G4endl;
     }
   }
   if ( theLambdaTablePrim && part == particle) {
     const G4String name = 
       GetPhysicsTableFileName(part,directory,"LambdaPrim",ascii);
     yes = theLambdaTablePrim->StorePhysicsTable(name,ascii);
 
     if ( yes ) {
       G4cout << "Physics table prim is stored for " 
              << particle->GetParticleName()
              << " and process " << GetProcessName()
              << " in the directory <" << directory
              << "> " << G4endl;
     } else {
       G4cout << "Fail to store Physics Table Prim for " 
              << particle->GetParticleName()
              << " and process " << GetProcessName()
              << " in the directory <" << directory
              << "> " << G4endl;
     }
   }
   return yes;
 }

Here is the call graph for this function:

◆ UpdateEmModel()

void G4VEmProcess::UpdateEmModel	(	const G4String &	nam,
		G4double	emin,
		G4double	emax
	)

Definition at line 234 of file G4VEmProcess.cc.

 {
   modelManager->UpdateEmModel(nam, emin, emax);
 }

Here is the call graph for this function:

Member Data Documentation

◆ actBinning

G4bool G4VEmProcess::actBinning

private

Definition at line 381 of file G4VEmProcess.hh.

◆ actMaxKinEnergy

G4bool G4VEmProcess::actMaxKinEnergy

private

Definition at line 380 of file G4VEmProcess.hh.

◆ actMinKinEnergy

G4bool G4VEmProcess::actMinKinEnergy

private

Definition at line 379 of file G4VEmProcess.hh.

◆ actSpline

G4bool G4VEmProcess::actSpline

private

Definition at line 382 of file G4VEmProcess.hh.

◆ applyCuts

G4bool G4VEmProcess::applyCuts

private

Definition at line 376 of file G4VEmProcess.hh.

◆ augerID

G4int G4VEmProcess::augerID

private

Definition at line 416 of file G4VEmProcess.hh.

◆ basedCoupleIndex

size_t G4VEmProcess::basedCoupleIndex

private

Definition at line 404 of file G4VEmProcess.hh.

◆ baseMaterial

const G4Material* G4VEmProcess::baseMaterial

private

Definition at line 400 of file G4VEmProcess.hh.

◆ biasFactor

G4double G4VEmProcess::biasFactor

private

Definition at line 373 of file G4VEmProcess.hh.

◆ biasFlag

G4bool G4VEmProcess::biasFlag

private

Definition at line 410 of file G4VEmProcess.hh.

◆ biasID

G4int G4VEmProcess::biasID

private

Definition at line 417 of file G4VEmProcess.hh.

◆ biasManager

G4EmBiasingManager* G4VEmProcess::biasManager

private

Definition at line 338 of file G4VEmProcess.hh.

◆ buildLambdaTable

G4bool G4VEmProcess::buildLambdaTable

private

Definition at line 344 of file G4VEmProcess.hh.

◆ currentCouple

const G4MaterialCutsCouple* G4VEmProcess::currentCouple

private

Definition at line 402 of file G4VEmProcess.hh.

◆ currentCoupleIndex

size_t G4VEmProcess::currentCoupleIndex

private

Definition at line 403 of file G4VEmProcess.hh.

◆ currentMaterial

const G4Material* G4VEmProcess::currentMaterial

private

Definition at line 401 of file G4VEmProcess.hh.

◆ currentModel

G4VEmModel* G4VEmProcess::currentModel

private

Definition at line 394 of file G4VEmProcess.hh.

◆ currentParticle

const G4ParticleDefinition* G4VEmProcess::currentParticle

private

Definition at line 397 of file G4VEmProcess.hh.

◆ emModels

std::vector<G4VEmModel*> G4VEmProcess::emModels

private

Definition at line 348 of file G4VEmProcess.hh.

◆ fFactor

G4double G4VEmProcess::fFactor

private

Definition at line 409 of file G4VEmProcess.hh.

◆ fluoID

G4int G4VEmProcess::fluoID

private

Definition at line 415 of file G4VEmProcess.hh.

◆ fParticleChange

G4ParticleChangeForGamma G4VEmProcess::fParticleChange

protected

Definition at line 388 of file G4VEmProcess.hh.

◆ idxLambda

size_t G4VEmProcess::idxLambda

private

Definition at line 357 of file G4VEmProcess.hh.

◆ idxLambdaPrim

size_t G4VEmProcess::idxLambdaPrim

private

Definition at line 358 of file G4VEmProcess.hh.

◆ integral

G4bool G4VEmProcess::integral

private

Definition at line 375 of file G4VEmProcess.hh.

◆ lambdaFactor

G4double G4VEmProcess::lambdaFactor

private

Definition at line 372 of file G4VEmProcess.hh.

◆ lManager

G4LossTableManager* G4VEmProcess::lManager

private

Definition at line 335 of file G4VEmProcess.hh.

◆ mainSecondaries

G4int G4VEmProcess::mainSecondaries

private

Definition at line 413 of file G4VEmProcess.hh.

◆ maxKinEnergy

G4double G4VEmProcess::maxKinEnergy

private

Definition at line 371 of file G4VEmProcess.hh.

◆ mfpKinEnergy

G4double G4VEmProcess::mfpKinEnergy

private

Definition at line 406 of file G4VEmProcess.hh.

◆ minKinEnergy

G4double G4VEmProcess::minKinEnergy

private

Definition at line 369 of file G4VEmProcess.hh.

◆ minKinEnergyPrim

G4double G4VEmProcess::minKinEnergyPrim

private

Definition at line 370 of file G4VEmProcess.hh.

◆ modelManager

G4EmModelManager* G4VEmProcess::modelManager

private

Definition at line 337 of file G4VEmProcess.hh.

◆ nLambdaBins

G4int G4VEmProcess::nLambdaBins

private

Definition at line 367 of file G4VEmProcess.hh.

◆ numberOfModels

G4int G4VEmProcess::numberOfModels

private

Definition at line 349 of file G4VEmProcess.hh.

◆ particle

const G4ParticleDefinition* G4VEmProcess::particle

private

Definition at line 396 of file G4VEmProcess.hh.

◆ preStepKinEnergy

G4double G4VEmProcess::preStepKinEnergy

private

Definition at line 407 of file G4VEmProcess.hh.

◆ preStepLambda

G4double G4VEmProcess::preStepLambda

private

Definition at line 408 of file G4VEmProcess.hh.

◆ secID

G4int G4VEmProcess::secID

private

Definition at line 414 of file G4VEmProcess.hh.

◆ secondaryParticle

const G4ParticleDefinition* G4VEmProcess::secondaryParticle

private

Definition at line 342 of file G4VEmProcess.hh.

◆ secParticles

std::vector<G4DynamicParticle*> G4VEmProcess::secParticles

private

Definition at line 392 of file G4VEmProcess.hh.

◆ splineFlag

G4bool G4VEmProcess::splineFlag

private

Definition at line 378 of file G4VEmProcess.hh.

◆ startFromNull

G4bool G4VEmProcess::startFromNull

private

Definition at line 377 of file G4VEmProcess.hh.

◆ theCrossSectionMax

std::vector<G4double> G4VEmProcess::theCrossSectionMax

private

Definition at line 355 of file G4VEmProcess.hh.

◆ theCuts

const std::vector<G4double>* G4VEmProcess::theCuts

private

Definition at line 360 of file G4VEmProcess.hh.

◆ theCutsElectron

const std::vector<G4double>* G4VEmProcess::theCutsElectron

private

Definition at line 362 of file G4VEmProcess.hh.

◆ theCutsGamma

const std::vector<G4double>* G4VEmProcess::theCutsGamma

private

Definition at line 361 of file G4VEmProcess.hh.

◆ theCutsPositron

const std::vector<G4double>* G4VEmProcess::theCutsPositron

private

Definition at line 363 of file G4VEmProcess.hh.

◆ theDensityFactor

const std::vector<G4double>* G4VEmProcess::theDensityFactor

private

Definition at line 364 of file G4VEmProcess.hh.

◆ theDensityIdx

const std::vector<G4int>* G4VEmProcess::theDensityIdx

private

Definition at line 365 of file G4VEmProcess.hh.

◆ theElectron

const G4ParticleDefinition* G4VEmProcess::theElectron

private

Definition at line 340 of file G4VEmProcess.hh.

◆ theEnergyOfCrossSectionMax

std::vector<G4double> G4VEmProcess::theEnergyOfCrossSectionMax

private

Definition at line 354 of file G4VEmProcess.hh.

◆ theGamma

const G4ParticleDefinition* G4VEmProcess::theGamma

private

Definition at line 339 of file G4VEmProcess.hh.

◆ theLambdaTable

G4PhysicsTable* G4VEmProcess::theLambdaTable

private

Definition at line 352 of file G4VEmProcess.hh.

◆ theLambdaTablePrim

G4PhysicsTable* G4VEmProcess::theLambdaTablePrim

private

Definition at line 353 of file G4VEmProcess.hh.

◆ theParameters

G4EmParameters* G4VEmProcess::theParameters

private

Definition at line 336 of file G4VEmProcess.hh.

◆ thePositron

const G4ParticleDefinition* G4VEmProcess::thePositron

private

Definition at line 341 of file G4VEmProcess.hh.

◆ weightFlag

G4bool G4VEmProcess::weightFlag

private

Definition at line 411 of file G4VEmProcess.hh.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4VEmProcess() [1/2]

◆ ~G4VEmProcess()

◆ G4VEmProcess() [2/2]

Member Function Documentation

◆ ActivateForcedInteraction()

◆ ActivateSecondaryBiasing()

◆ AddEmModel()

◆ BuildLambdaTable()

◆ BuildPhysicsTable()

◆ Clear()

◆ ComputeCrossSectionPerAtom()

◆ ComputeCurrentLambda()

◆ ComputeIntegralLambda()

◆ CrossSectionBiasingFactor()

◆ CrossSectionPerVolume()

◆ CurrentMaterialCutsCoupleIndex()

◆ DefineMaterial()

◆ EmModel()

◆ FindLambdaMax()

◆ GetCurrentElement()

◆ GetCurrentLambda()

◆ GetCurrentModel()

◆ GetElectronEnergyCut()

◆ GetGammaEnergyCut()

◆ GetLambda()

◆ GetLambdaFromTable()

◆ GetLambdaFromTablePrim()

◆ GetMeanFreePath()

◆ GetModelByIndex()

◆ GetParticleChange()

◆ GetTargetElement()

◆ GetTargetIsotope()

◆ InitialiseProcess()

◆ IsApplicable()

◆ IsIntegral()

◆ LambdaBinning()

◆ LambdaPhysicsVector()

◆ LambdaTable()

◆ LambdaTablePrim()

◆ MaxKinEnergy()

◆ MeanFreePath()

◆ MinKinEnergy()

◆ MinPrimaryEnergy()

◆ operator=()

◆ Particle()

◆ PolarAngleLimit()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PreparePhysicsTable()

◆ PrintInfo()

◆ PrintInfoProcess()

◆ PrintWarning()

◆ ProcessDescription()

◆ RecalculateLambda()

◆ RetrievePhysicsTable()

◆ SecondaryParticle()

◆ SelectModel()

◆ SelectModelForMaterial()

◆ SetBuildTableFlag()

◆ SetCrossSectionBiasingFactor()

◆ SetEmModel()

◆ SetIntegral()

◆ SetLambdaBinning()

◆ SetMaxKinEnergy()

◆ SetMinKinEnergy()

◆ SetMinKinEnergyPrim()

◆ SetParticle()

◆ SetSecondaryParticle()

◆ SetSplineFlag()

◆ SetStartFromNullFlag()

◆ StartTracking()

◆ StorePhysicsTable()