G4GammaGeneralProcess Class Reference

#include <G4GammaGeneralProcess.hh>

Inheritance diagram for G4GammaGeneralProcess:

Public Member Functions
void	ActivateForcedInteraction (G4double length=0.0, const G4String &r="", G4bool flag=true)
void	ActivateSecondaryBiasing (const G4String &region, G4double factor, G4double energyLimit)
void	AddEmModel (G4int, G4VEmModel *, const G4Region *region=nullptr)
void	AddEmProcess (G4VEmProcess *)
void	AddHadProcess (G4HadronicProcess *)
void	AddMMProcess (G4GammaConversionToMuons *)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
void	BuildPhysicsTable (const G4ParticleDefinition &) override
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
G4double	ComputeCrossSectionPerAtom (G4double kineticEnergy, G4double Z, G4double A=0., G4double cut=0.0)
G4double	CrossSectionBiasingFactor () const
G4double	CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple, G4double logKinEnergy=DBL_MAX)
void	CurrentSetup (const G4MaterialCutsCouple *, G4double energy)
virtual void	DumpInfo () const
G4VEmModel *	EmModel (size_t index=0) const
virtual void	EndTracking ()
std::vector< G4double > *	EnergyOfCrossSectionMax () const
std::vector< G4double > *	FindLambdaMax ()
	G4GammaGeneralProcess (const G4String &pname="GammaGeneralProc")
	G4GammaGeneralProcess (G4GammaGeneralProcess &)=delete
const G4Element *	GetCurrentElement () const
G4double	GetCurrentInteractionLength () const
const G4VEmModel *	GetCurrentModel () const
G4VEmProcess *	GetEmProcess (const G4String &name) override
G4double	GetLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)
G4double	GetLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple, G4double logKinEnergy)
const G4VProcess *	GetMasterProcess () const
G4VEmModel *	GetModelByIndex (G4int idx=0, G4bool ver=false) const
G4double	GetNumberOfInteractionLengthLeft () const
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
G4double	GetPILfactor () const
virtual const G4ProcessManager *	GetProcessManager ()
const G4String &	GetProcessName () const
G4int	GetProcessSubType () const
G4ProcessType	GetProcessType () const
const G4VProcess *	GetSelectedProcess () const
const G4String &	GetSubProcessName () const
G4int	GetSubProcessSubType () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4int	GetVerboseLevel () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	IsApplicable (const G4ParticleDefinition &) override
G4bool	isAtRestDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
G4PhysicsTable *	LambdaTable () const
G4PhysicsTable *	LambdaTablePrim () const
G4double	MeanFreePath (const G4Track &track)
G4int	NumberOfModels () const
G4bool	operator!= (const G4VProcess &right) const
G4GammaGeneralProcess &	operator= (const G4GammaGeneralProcess &right)=delete
G4bool	operator== (const G4VProcess &right) const
const G4ParticleDefinition *	Particle () const
G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &) override
G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
void	PreparePhysicsTable (const G4ParticleDefinition &) override
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)
void	ProcessDescription (std::ostream &outFile) const override
virtual void	ResetNumberOfInteractionLengthLeft ()
G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii) override
const G4ParticleDefinition *	SecondaryParticle () const
G4VEmModel *	SelectModelForMaterial (G4double kinEnergy, size_t idxCouple) const
void	SetBuildTableFlag (G4bool val)
void	SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)
void	SetCrossSectionType (G4CrossSectionType val)
void	SetEmMasterProcess (const G4VEmProcess *)
void	SetEmModel (G4VEmModel *, G4int index=0)
void	SetEnergyOfCrossSectionMax (std::vector< G4double > *)
void	SetLambdaBinning (G4int nbins)
virtual void	SetMasterProcess (G4VProcess *masterP)
void	SetMaxKinEnergy (G4double e)
void	SetMinKinEnergy (G4double e)
void	SetMinKinEnergyPrim (G4double e)
void	SetPILfactor (G4double value)
virtual void	SetProcessManager (const G4ProcessManager *)
void	SetProcessSubType (G4int)
void	SetProcessType (G4ProcessType)
void	SetVerboseLevel (G4int value)
void	StartTracking (G4Track *) override
G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false) override
G4bool	UseBaseMaterial () const
	~G4GammaGeneralProcess () override

Static Public Member Functions
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions
G4bool	ApplyCuts () const
void	ClearNumberOfInteractionLengthLeft ()
G4double	ComputeGeneralLambda (size_t idxe, size_t idxt)
G4CrossSectionType	CrossSectionType () const
size_t	CurrentMaterialCutsCoupleIndex () const
void	DefineMaterial (const G4MaterialCutsCouple *couple)
G4double	DensityFactor (G4int idx) const
G4int	DensityIndex (G4int idx) const
G4double	GetElectronEnergyCut ()
G4double	GetGammaEnergyCut ()
G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
G4ParticleChangeForGamma *	GetParticleChange ()
G4double	GetProbability (size_t idxt)
const G4Element *	GetTargetElement () const
const G4Isotope *	GetTargetIsotope () const
void	InitialiseProcess (const G4ParticleDefinition *) override
G4int	LambdaBinning () const
G4PhysicsVector *	LambdaPhysicsVector (const G4MaterialCutsCouple *)
const G4MaterialCutsCouple *	MaterialCutsCouple () const
G4double	MaxKinEnergy () const
G4double	MinKinEnergy () const
virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition *, const G4Material *)
G4double	PolarAngleLimit () const
G4double	RecalculateLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)
void	SelectedProcess (const G4Step &step, G4VProcess *ptr)
void	SelectEmProcess (const G4Step &, G4VEmProcess *)
void	SelectHadProcess (const G4Track &, const G4Step &, G4HadronicProcess *)
G4VEmModel *	SelectModel (G4double kinEnergy, size_t)
void	SetParticle (const G4ParticleDefinition *p)
void	SetSecondaryParticle (const G4ParticleDefinition *p)
void	SetSplineFlag (G4bool val)
void	SetStartFromNullFlag (G4bool val)
virtual void	StreamProcessInfo (std::ostream &) const
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
G4double	TotalCrossSectionPerVolume ()

Protected Attributes
G4ParticleChange	aParticleChange
const G4ProcessManager *	aProcessManager = nullptr
G4int	augerID = _AugerElectron
size_t	basedCoupleIndex = 0
G4bool	baseMat = false
G4int	biasID = _EM
G4EmBiasingManager *	biasManager = nullptr
size_t	coupleIdxLambda = 0
const G4MaterialCutsCouple *	currentCouple = nullptr
size_t	currentCoupleIndex = 0
G4double	currentInteractionLength = -1.0
const G4Material *	currentMaterial = nullptr
G4bool	enableAlongStepDoIt = true
G4bool	enableAtRestDoIt = true
G4bool	enablePostStepDoIt = true
G4double	factor = 1.0
G4int	fluoID = _Fluorescence
G4ParticleChangeForGamma	fParticleChange
size_t	idxLambda = 0
G4bool	isTheMaster = true
G4int	mainSecondaries = 1
G4double	mfpKinEnergy = DBL_MAX
G4VParticleChange *	pParticleChange = nullptr
G4double	preStepKinEnergy = 0.0
G4double	preStepLambda = 0.0
G4double	preStepLogE = 1.0
G4double	preStepLogKinEnergy = LOG_EKIN_MIN
G4int	secID = _EM
std::vector< G4DynamicParticle * >	secParticles
G4VProcess *	selectedProc = nullptr
std::vector< G4double > *	theEnergyOfCrossSectionMax = nullptr
G4HadronicProcess *	theGammaNuclear = nullptr
G4double	theInitialNumberOfInteractionLength = -1.0
G4double	theNumberOfInteractionLengthLeft = -1.0
G4String	thePhysicsTableFileName
G4double	thePILfactor = 1.0
G4String	theProcessName
G4int	theProcessSubType = -1
G4ProcessType	theProcessType = fNotDefined
G4int	tripletID = _TripletElectron
G4int	verboseLevel = 0

Private Member Functions
void	BuildLambdaTable ()
void	Clear ()
G4double	ComputeCurrentLambda (G4double kinEnergy)
void	ComputeIntegralLambda (G4double kinEnergy, G4double logKinEnergy)
G4double	GetCurrentLambda (G4double kinEnergy)
G4double	GetCurrentLambda (G4double kinEnergy, G4double logKinEnergy)
G4double	GetLambdaFromTable (G4double kinEnergy)
G4double	GetLambdaFromTable (G4double kinEnergy, G4double logKinEnergy)
G4double	GetLambdaFromTablePrim (G4double kinEnergy)
G4double	GetLambdaFromTablePrim (G4double kinEnergy, G4double logKinEnergy)
void	PrintWarning (G4String tit, G4double val)
G4bool	RetrieveTable (G4VEmProcess *, const G4String &directory, G4bool ascii)
void	StreamInfo (std::ostream &outFile, const G4ParticleDefinition &, G4bool rst=false) const

Private Attributes
G4bool	actBinning = false
G4bool	actMaxKinEnergy = false
G4bool	actMinKinEnergy = false
G4bool	applyCuts = false
const G4Material *	baseMaterial = nullptr
G4double	biasFactor = 1.0
G4bool	biasFlag = false
G4bool	buildLambdaTable = true
G4VEmModel *	currentModel = nullptr
const G4ParticleDefinition *	currentParticle = nullptr
std::vector< G4VEmModel * >	emModels
G4double	fFactor = 1.0
G4double	fLambda = 0.0
G4double	fLambdaEnergy = 0.0
G4ProcessTable *	fProcessTable = nullptr
G4CrossSectionType	fXSType = fEmNoIntegral
size_t	idxEnergy = 0
G4bool	isIon = false
G4double	lambdaFactor = 0.8
G4LossTableManager *	lManager = nullptr
G4double	logLambdaFactor
G4double	massRatio = 1.0
const G4VEmProcess *	masterProc = nullptr
G4VProcess *	masterProcessShadow = nullptr
G4double	maxKinEnergy
G4double	minEEEnergy
G4double	minKinEnergy
G4double	minKinEnergyPrim = DBL_MAX
G4double	minMMEnergy
G4double	minPEEnergy
G4EmModelManager *	modelManager = nullptr
size_t	nHighE = 50
G4int	nLambdaBins = 84
size_t	nLowE = 40
G4int	numberOfModels = 0
const G4ParticleDefinition *	particle = nullptr
G4double	peLambda = 0.0
const G4ParticleDefinition *	secondaryParticle = nullptr
G4bool	splineFlag = false
G4bool	startFromNull = false
G4VEmProcess *	theCompton = nullptr
G4VEmProcess *	theConversionEE = nullptr
G4GammaConversionToMuons *	theConversionMM = nullptr
const std::vector< G4double > *	theCuts = nullptr
const std::vector< G4double > *	theCutsElectron = nullptr
const std::vector< G4double > *	theCutsGamma = nullptr
const std::vector< G4double > *	theCutsPositron = nullptr
G4EmDataHandler *	theData = nullptr
const std::vector< G4double > *	theDensityFactor = nullptr
const std::vector< G4int > *	theDensityIdx = nullptr
const G4ParticleDefinition *	theElectron = nullptr
const G4ParticleDefinition *	theGamma = nullptr
G4PhysicsTable *	theLambdaTable = nullptr
G4PhysicsTable *	theLambdaTablePrim = nullptr
G4EmParameters *	theParameters = nullptr
G4VEmProcess *	thePhotoElectric = nullptr
const G4ParticleDefinition *	thePositron = nullptr
G4VEmProcess *	theRayleigh = nullptr
G4bool	weightFlag = false

Static Private Attributes
static G4String	nameT [nTables]
static const size_t	nTables = 15
static G4EmDataHandler *	theHandler = nullptr
static G4bool	theT [nTables]

Detailed Description

Definition at line 64 of file G4GammaGeneralProcess.hh.

Constructor & Destructor Documentation

G4GammaGeneralProcess() [1/2]

G4GammaGeneralProcess::G4GammaGeneralProcess ( const G4String &  pname = "GammaGeneralProc" )

explicit

Definition at line 86 of file G4GammaGeneralProcess.cc.

                                                                 :
  G4VEmProcess(pname, fElectromagnetic),
  minPEEnergy(150*CLHEP::keV),
  minEEEnergy(2*CLHEP::electron_mass_c2),
  minMMEnergy(100*CLHEP::MeV)
{
  SetVerboseLevel(1);
  SetParticle(G4Gamma::Gamma());
  SetProcessSubType(fGammaGeneralProcess);
}

References fGammaGeneralProcess, G4Gamma::Gamma(), G4VEmProcess::SetParticle(), G4VProcess::SetProcessSubType(), and G4VProcess::SetVerboseLevel().

~G4GammaGeneralProcess()

G4GammaGeneralProcess::~G4GammaGeneralProcess ( )

override

Definition at line 99 of file G4GammaGeneralProcess.cc.

{
  if(isTheMaster) {
    delete theHandler;
    theHandler = nullptr;
  }
}

References G4VEmProcess::isTheMaster, and theHandler.

G4GammaGeneralProcess() [2/2]

G4GammaGeneralProcess::G4GammaGeneralProcess ( G4GammaGeneralProcess &  )

delete

Member Function Documentation

ActivateForcedInteraction()

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

inherited

Definition at line 1129 of file G4VEmProcess.cc.

{
  if(nullptr == 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);
}

References G4EmBiasingManager::ActivateForcedInteraction(), G4VEmProcess::biasManager, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), mm, G4VEmProcess::particle, G4VProcess::verboseLevel, and G4VEmProcess::weightFlag.

Referenced by G4EmExtraParameters::DefineRegParamForEM().

ActivateSecondaryBiasing()

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

inherited

Definition at line 1149 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;
    }
  }
}

References G4EmBiasingManager::ActivateSecondaryBiasing(), G4VEmProcess::biasManager, G4Electron::Electron(), G4cout, G4endl, G4VProcess::GetProcessName(), MeV, G4VEmProcess::secondaryParticle, and G4VProcess::verboseLevel.

Referenced by G4EmExtraParameters::DefineRegParamForEM().

AddEmModel()

void G4VEmProcess::AddEmModel ( G4int  order, G4VEmModel *  ptr, const G4Region *  region = nullptr  )

inherited

Definition at line 146 of file G4VEmProcess.cc.

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

References G4EmModelManager::AddEmModel(), G4VEmProcess::modelManager, G4VProcess::pParticleChange, and G4VEmModel::SetParticleChange().

Referenced by LBE::ConstructEM(), G4EmDNAPhysics_option7::ConstructProcess(), G4EmDNAPhysics_option8::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4DNAAttachment::InitialiseProcess(), G4DNAChargeDecrease::InitialiseProcess(), G4DNAChargeIncrease::InitialiseProcess(), G4DNADissociation::InitialiseProcess(), G4DNAElastic::InitialiseProcess(), G4DNAElectronSolvation::InitialiseProcess(), G4DNAExcitation::InitialiseProcess(), G4DNAIonisation::InitialiseProcess(), G4DNAPlasmonExcitation::InitialiseProcess(), G4DNAPositronium::InitialiseProcess(), G4DNARotExcitation::InitialiseProcess(), G4DNAVibExcitation::InitialiseProcess(), G4NuclearStopping::InitialiseProcess(), G4eeToHadrons::InitialiseProcess(), G4JAEAElasticScattering::InitialiseProcess(), G4MicroElecElastic::InitialiseProcess(), G4MicroElecInelastic::InitialiseProcess(), G4MicroElecLOPhononScattering::InitialiseProcess(), G4RayleighScattering::InitialiseProcess(), G4PolarizedCompton::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), G4PolarizedPhotoElectric::InitialiseProcess(), G4ComptonScattering::InitialiseProcess(), G4CoulombScattering::InitialiseProcess(), G4eplusAnnihilation::InitialiseProcess(), G4GammaConversion::InitialiseProcess(), G4PhotoElectricEffect::InitialiseProcess(), G4EmConfigurator::PrepareModels(), and G4EmConfigurator::SetModelForRegion().

AddEmProcess()

void G4GammaGeneralProcess::AddEmProcess

(

G4VEmProcess *

ptr

)

Definition at line 116 of file G4GammaGeneralProcess.cc.

{
  if(nullptr == ptr) { return; }
  G4int stype = ptr->GetProcessSubType();
  if(stype == fRayleigh)                 { theRayleigh = ptr; }
  else if(stype == fPhotoElectricEffect) { thePhotoElectric = ptr; }
  else if(stype == fComptonScattering)   { theCompton = ptr; }
  else if(stype == fGammaConversion)     { theConversionEE = ptr; }
}

References fComptonScattering, fGammaConversion, fPhotoElectricEffect, fRayleigh, G4VProcess::GetProcessSubType(), theCompton, theConversionEE, thePhotoElectric, and theRayleigh.

AddHadProcess()

void G4GammaGeneralProcess::AddHadProcess

(

G4HadronicProcess *

ptr

)

Definition at line 135 of file G4GammaGeneralProcess.cc.

{
  theGammaNuclear = ptr;
}

References theGammaNuclear.

Referenced by G4EmExtraPhysics::ConstructGammaElectroNuclear().

AddMMProcess()

void G4GammaGeneralProcess::AddMMProcess

(

G4GammaConversionToMuons *

ptr

)

Definition at line 128 of file G4GammaGeneralProcess.cc.

{
  theConversionMM = ptr;
}

References theConversionMM.

AlongStepDoIt()

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

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 90 of file G4VDiscreteProcess.hh.

                              { return 0; }

AlongStepGetPhysicalInteractionLength()

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

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 70 of file G4VDiscreteProcess.hh.

                              { return -1.0; }

AlongStepGPIL()

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

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

ApplyCuts()

G4bool G4VEmProcess::ApplyCuts ( ) const

inlineprotectedinherited

Definition at line 459 of file G4VEmProcess.hh.

{
  return applyCuts;
}

References G4VEmProcess::applyCuts.

Referenced by G4eplusAnnihilation::AtRestDoIt().

AtRestDoIt()

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

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4eplusAnnihilation.

Definition at line 85 of file G4VDiscreteProcess.hh.

                              { return 0; }

AtRestGetPhysicalInteractionLength()

virtual G4double G4VDiscreteProcess::AtRestGetPhysicalInteractionLength ( const G4Track &  , G4ForceCondition *    )

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4eplusAnnihilation.

Definition at line 78 of file G4VDiscreteProcess.hh.

                              { return -1.0; }

AtRestGPIL()

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

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

BuildLambdaTable()

void G4VEmProcess::BuildLambdaTable ( )

privateinherited

Definition at line 387 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 = theParameters->MaxKinEnergy()/theParameters->MinKinEnergy();
  G4int nbin = 
    theParameters->NumberOfBinsPerDecade()*G4lrint(std::log10(scale));
  scale = G4Log(scale);
  if(actBinning) { nbin = std::max(nbin, nLambdaBins); }
  G4double emax1 = std::min(maxKinEnergy, minKinEnergyPrim);
    
  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, 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 and always use spline
        if(!bVectorPrim) {
          G4int bin = G4lrint(nbin*G4Log(maxKinEnergy/minKinEnergyPrim)/scale);
          if(bin < 3) { bin = 3; }
          aVectorPrim = 
            new G4PhysicsLogVector(minKinEnergyPrim, maxKinEnergy, bin, true);
          bVectorPrim = aVectorPrim;
        } else {
          aVectorPrim = new G4PhysicsLogVector(*bVectorPrim);
        }
        modelManager->FillLambdaVector(aVectorPrim, couple, false, 
                                       fIsCrossSectionPrim);
        aVectorPrim->FillSecondDerivatives();
        G4PhysicsTableHelper::SetPhysicsVector(theLambdaTablePrim, i, 
                                               aVectorPrim);
      }
    }
  }
 
  if(1 < verboseLevel) {
    G4cout << "Lambda table is built for "
           << particle->GetParticleName()
           << G4endl;
  }
}

References G4VEmProcess::actBinning, G4VEmProcess::buildLambdaTable, emax, G4EmModelManager::FillLambdaVector(), G4PhysicsVector::FillSecondDerivatives(), fIsCrossSectionPrim, G4cout, G4endl, G4Log(), G4lrint(), G4LossTableBuilder::GetFlag(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4VEmProcess::lManager, G4INCL::Math::max(), G4EmParameters::MaxKinEnergy(), G4VEmProcess::maxKinEnergy, G4INCL::Math::min(), G4EmParameters::MinKinEnergy(), G4VEmProcess::minKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::MinPrimaryEnergy(), G4VEmProcess::modelManager, G4VEmProcess::nLambdaBins, G4EmParameters::NumberOfBinsPerDecade(), G4VEmProcess::particle, G4PhysicsTableHelper::SetPhysicsVector(), G4VEmProcess::splineFlag, G4VEmProcess::startFromNull, G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, G4VEmProcess::theParameters, and G4VProcess::verboseLevel.

Referenced by G4VEmProcess::BuildPhysicsTable().

BuildPhysicsTable()

void G4GammaGeneralProcess::BuildPhysicsTable ( const G4ParticleDefinition &  part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 252 of file G4GammaGeneralProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::BuildPhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << G4endl;
  }
  if(!isTheMaster) {
    thePhotoElectric->SetEmMasterProcess(theHandler->GetMasterProcess(0));
    baseMat = theHandler->GetMasterProcess(0)->UseBaseMaterial();
  }
  thePhotoElectric->BuildPhysicsTable(part);
 
  if(!isTheMaster) {
    theCompton->SetEmMasterProcess(theHandler->GetMasterProcess(1));
  }
  theCompton->BuildPhysicsTable(part);
 
  if(!isTheMaster) {
    theConversionEE->SetEmMasterProcess(theHandler->GetMasterProcess(2));
  }
  theConversionEE->BuildPhysicsTable(part);
 
  if(theRayleigh != nullptr) {
    if(!isTheMaster) {
      theRayleigh->SetEmMasterProcess(theHandler->GetMasterProcess(3));
    }
    theRayleigh->BuildPhysicsTable(part);
  }
  if(theGammaNuclear != nullptr)  { theGammaNuclear->BuildPhysicsTable(part); }
  if(theConversionMM != nullptr)  { theConversionMM->BuildPhysicsTable(part); }
 
  if(isTheMaster) {
    const G4ProductionCutsTable* theCoupleTable=
      G4ProductionCutsTable::GetProductionCutsTable();
    size_t numOfCouples = theCoupleTable->GetTableSize();
 
    G4LossTableBuilder* bld = G4LossTableManager::Instance()->GetTableBuilder();
    const std::vector<G4PhysicsTable*>& tables = theHandler->GetTables();
 
    G4CrossSectionDataStore* gn = (nullptr != theGammaNuclear)
      ? theGammaNuclear->GetCrossSectionDataStore() : nullptr;
    G4DynamicParticle* dynParticle =
      new G4DynamicParticle(G4Gamma::Gamma(),G4ThreeVector(1,0,0),1.0);
 
    G4double sigComp(0.), sigPE(0.), sigConv(0.), sigR(0.),
      sigN(0.), sigM(0.), val(0.);
 
    for(size_t i=0; i<numOfCouples; ++i) {
 
      if (bld->GetFlag(i)) {
 
        G4int idx = (!baseMat) ? i : DensityIndex(i);
    const G4MaterialCutsCouple* couple =
      theCoupleTable->GetMaterialCutsCouple(i);
    const G4Material* material = couple->GetMaterial();
 
    // energy interval 0
        size_t nn = (*(tables[0]))[idx]->GetVectorLength();
    if(1 < verboseLevel) {
          G4cout << "======= Zone 0 ======= N= " << nn
         << " for " << material->GetName() << G4endl;
    }
        for(size_t j=0; j<nn; ++j) {
          G4double e = (*(tables[0]))[idx]->Energy(j);
          G4double loge = G4Log(e);
          sigComp = theCompton->GetLambda(e, couple, loge);
          sigR = (nullptr != theRayleigh) ?
            theRayleigh->GetLambda(e, couple, loge) : 0.0;
          G4double sum = sigComp + sigR;
      if(1 < verboseLevel) {
        G4cout << j << ". E= " << e << " xs= " << sum
           << " compt= " << sigComp << " Rayl= " << sigR << G4endl;
      }
          (*(tables[0]))[idx]->PutValue(j, sum);
      if(theT[1]) {
            val = sigR/sum;
        (*(tables[1]))[idx]->PutValue(j, val);
      }
    }
 
    // energy interval 1
        nn = (*(tables[2]))[idx]->GetVectorLength();
    if(1 < verboseLevel) {
      G4cout << "======= Zone 1 ======= N= " << nn << G4endl;
    }
        for(size_t j=0; j<nn; ++j) {
          G4double e = (*(tables[2]))[idx]->Energy(j);
          G4double loge = G4Log(e);
          sigComp = theCompton->GetLambda(e, couple, loge);
          sigR = (nullptr != theRayleigh) ?
            theRayleigh->GetLambda(e, couple, loge) : 0.0;
          sigPE = thePhotoElectric->GetLambda(e, couple, loge);
          G4double sum = sigComp + sigR + sigPE;
      if(1 < verboseLevel) {
        G4cout << j << ". E= " << e << " xs= " << sum
           << " compt= " << sigComp << " conv= " << sigConv
           << " PE= " << sigPE << " Rayl= " << sigR
           << " GN= " << sigN << G4endl;
      }
          (*(tables[2]))[idx]->PutValue(j, sum);
 
          val = sigPE/sum;
      (*(tables[3]))[idx]->PutValue(j, val);
 
      val = (sigR > 0.0) ? (sigComp + sigPE)/sum : 1.0;
      (*(tables[4]))[idx]->PutValue(j, val);
    }
 
    // energy interval 2
        nn = (*(tables[6]))[idx]->GetVectorLength();
    if(1 < verboseLevel) {
      G4cout << "======= Zone 2 ======= N= " << nn << G4endl;
    }
        for(size_t j=0; j<nn; ++j) {
          G4double e = (*(tables[6]))[idx]->Energy(j);
          G4double loge = G4Log(e);
          sigComp = theCompton->GetLambda(e, couple, loge);
          sigConv = theConversionEE->GetLambda(e, couple, loge);
          sigPE = thePhotoElectric->GetLambda(e, couple, loge);
          sigN = 0.0;
          if(nullptr != gn) {
        dynParticle->SetKineticEnergy(e);
        sigN = gn->ComputeCrossSection(dynParticle, material);
      }
          G4double sum = sigComp + sigConv + sigPE + sigN;
      if(1 < verboseLevel) {
        G4cout << j << ". E= " << e << " xs= " << sum
           << " compt= " << sigComp << " conv= " << sigConv
           << " PE= " << sigPE
           << " GN= " << sigN << G4endl;
      }
          (*(tables[6]))[idx]->PutValue(j, sum);
 
          val = sigConv/sum;
      (*(tables[7]))[idx]->PutValue(j, val);
 
          val = (sigConv + sigComp)/sum;
      (*(tables[8]))[idx]->PutValue(j, val);
 
      val = (sigN > 0.0) ? (sigConv + sigComp + sigPE)/sum : 1.0;
      (*(tables[9]))[idx]->PutValue(j, val);
    }
 
    // energy interval 3
        nn = (*(tables[10]))[idx]->GetVectorLength();
    if(1 < verboseLevel) {
      G4cout << "======= Zone 3 ======= N= " << nn
         << " for " << material->GetName() << G4endl;
    }
        for(size_t j=0; j<nn; ++j) {
          G4double e = (*(tables[10]))[idx]->Energy(j);
          G4double loge = G4Log(e);
          sigComp = theCompton->GetLambda(e, couple, loge);
          sigConv = theConversionEE->GetLambda(e, couple, loge);
          sigPE = thePhotoElectric->GetLambda(e, couple, loge);
          sigN = 0.0;
          if(nullptr != gn) {
        dynParticle->SetKineticEnergy(e);
        sigN = gn->ComputeCrossSection(dynParticle, material);
      }
          sigM = 0.0;
          if(nullptr != theConversionMM) {
        val = theConversionMM->ComputeMeanFreePath(e, material);
        sigM = (val < DBL_MAX) ? 1./val : 0.0;
      }
          G4double sum = sigComp + sigConv + sigPE + sigN + sigM;
      if(1 < verboseLevel) {
        G4cout << j << ". E= " << e << " xs= " << sum
           << " compt= " << sigComp << " conv= " << sigConv
           << " PE= " << sigPE
           << " GN= " << sigN << G4endl;
      }
          (*(tables[10]))[idx]->PutValue(j, sum);
 
          val = (sigComp + sigPE + sigN + sigM)/sum;
      (*(tables[11]))[idx]->PutValue(j, val);
 
          val = (sigPE + sigN + sigM)/sum;
      (*(tables[12]))[idx]->PutValue(j, val);
 
      val = (sigN + sigM)/sum;
      (*(tables[13]))[idx]->PutValue(j, val);
 
      val = sigN/sum;
      (*(tables[14]))[idx]->PutValue(j, val);
    }
    for(size_t k=0; k<nTables; ++k) {
      if(splineFlag) {
        (*(tables[k]))[idx]->FillSecondDerivatives();
      }
    }
      }
    }
    delete dynParticle;
  }
 
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::BuildPhysicsTable() done for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << G4endl;
  }
}

References G4VEmProcess::baseMat, G4GammaConversionToMuons::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4HadronicProcess::BuildPhysicsTable(), G4CrossSectionDataStore::ComputeCrossSection(), G4GammaConversionToMuons::ComputeMeanFreePath(), DBL_MAX, G4VEmProcess::DensityIndex(), G4cout, G4endl, G4Log(), G4Gamma::Gamma(), G4HadronicProcess::GetCrossSectionDataStore(), G4LossTableBuilder::GetFlag(), G4VEmProcess::GetLambda(), G4EmDataHandler::GetMasterProcess(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4EmDataHandler::GetTables(), G4ProductionCutsTable::GetTableSize(), G4LossTableManager::Instance(), G4VEmProcess::isTheMaster, eplot::material, G4InuclParticleNames::nn, nTables, G4VEmProcess::SetEmMasterProcess(), G4DynamicParticle::SetKineticEnergy(), splineFlag, theCompton, theConversionEE, theConversionMM, theGammaNuclear, theHandler, thePhotoElectric, theRayleigh, theT, G4VEmProcess::UseBaseMaterial(), and G4VProcess::verboseLevel.

BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

Clear()

void G4VEmProcess::Clear ( )

privateinherited

Definition at line 130 of file G4VEmProcess.cc.

{
  currentCouple = nullptr;
  preStepLambda = 0.0;
}

References G4VEmProcess::currentCouple, and G4VEmProcess::preStepLambda.

Referenced by G4VEmProcess::PreparePhysicsTable().

ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4RadioactiveDecay::DecayAnalog(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4Radioactivation::DecayIt(), G4RadioactiveDecay::DecayIt(), G4MuonicAtomDecay::DecayIt(), G4Decay::EndTracking(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4VAdjointReverseReaction::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

ComputeCrossSectionPerAtom()

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

inherited

Definition at line 1010 of file G4VEmProcess.cc.

{
  SelectModel(kinEnergy, currentCoupleIndex);
  return (currentModel) ? 
    currentModel->ComputeCrossSectionPerAtom(currentParticle, kinEnergy,
                                             Z, A, cut) : 0.0;
}

References A, G4VEmModel::ComputeCrossSectionPerAtom(), G4VEmProcess::currentCoupleIndex, G4VEmProcess::currentModel, G4VEmProcess::currentParticle, G4VEmProcess::SelectModel(), and Z.

ComputeCurrentLambda()

G4double G4VEmProcess::ComputeCurrentLambda ( G4double  kinEnergy )

inlineprivateinherited

Definition at line 562 of file G4VEmProcess.hh.

{
  return currentModel->CrossSectionPerVolume(baseMaterial, currentParticle, e);
}

References G4VEmProcess::baseMaterial, G4VEmModel::CrossSectionPerVolume(), G4VEmProcess::currentModel, and G4VEmProcess::currentParticle.

Referenced by G4VEmProcess::GetCurrentLambda(), and G4VEmProcess::RecalculateLambda().

ComputeGeneralLambda()

G4double G4GammaGeneralProcess::ComputeGeneralLambda ( size_t  idxe, size_t  idxt  )

inlineprotected

Definition at line 194 of file G4GammaGeneralProcess.hh.

{
  idxEnergy = idxe;
  return factor*theHandler->GetVector(idxt, basedCoupleIndex)
    ->LogVectorValue(preStepKinEnergy, preStepLogE);
}

References G4VEmProcess::basedCoupleIndex, factor, G4EmDataHandler::GetVector(), idxEnergy, G4PhysicsVector::LogVectorValue(), G4VEmProcess::preStepKinEnergy, preStepLogE, and theHandler.

Referenced by TotalCrossSectionPerVolume().

ComputeIntegralLambda()

void G4VEmProcess::ComputeIntegralLambda ( G4double  kinEnergy, G4double  logKinEnergy  )

privateinherited

Definition at line 637 of file G4VEmProcess.cc.

{
  if(fXSType == fEmNoIntegral) {
    preStepLambda = GetCurrentLambda(e, loge);
 
  } else if(fXSType == fEmIncreasing) {
    if(e/lambdaFactor < mfpKinEnergy) {
      mfpKinEnergy = e;
      preStepLambda = GetCurrentLambda(e, loge); 
    }
 
  } else if(fXSType == fEmDecreasing) {
    if(e < mfpKinEnergy) { 
      const G4double e1 = e*lambdaFactor;
      preStepLambda = GetCurrentLambda(e1); 
      mfpKinEnergy = e1;
    }
 
  } else if(fXSType == fEmOnePeak) {
    const G4double epeak = (*theEnergyOfCrossSectionMax)[currentCoupleIndex];
    if(e <= epeak) {
      if(e/lambdaFactor < mfpKinEnergy) {
        mfpKinEnergy = e;
        preStepLambda = GetCurrentLambda(e, loge); 
      }
    } else if(e < mfpKinEnergy) { 
      const G4double e1 = std::max(epeak, e*lambdaFactor);
      preStepLambda = GetCurrentLambda(e1); 
      mfpKinEnergy = e1;
    }
 
  } else {
    preStepLambda = GetCurrentLambda(e, loge); 
  }
}

References G4VEmProcess::currentCoupleIndex, e1, fEmDecreasing, fEmIncreasing, fEmNoIntegral, fEmOnePeak, G4VEmProcess::fXSType, G4VEmProcess::GetCurrentLambda(), G4VEmProcess::lambdaFactor, G4INCL::Math::max(), G4VEmProcess::mfpKinEnergy, and G4VEmProcess::preStepLambda.

Referenced by G4VEmProcess::PostStepGetPhysicalInteractionLength().

CrossSectionBiasingFactor()

G4double G4VEmProcess::CrossSectionBiasingFactor ( ) const

inlineinherited

Definition at line 650 of file G4VEmProcess.hh.

{
  return biasFactor;
}

References G4VEmProcess::biasFactor.

CrossSectionPerVolume()

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

inherited

Definition at line 978 of file G4VEmProcess.cc.

{
  G4double cross = RecalculateLambda(kinEnergy, couple);
  return std::max(cross, 0.0);
}

References G4INCL::Math::max(), and G4VEmProcess::RecalculateLambda().

Referenced by G4EmCalculator::GetCrossSectionPerVolume().

CrossSectionType()

G4CrossSectionType G4VEmProcess::CrossSectionType ( ) const

inlineprotectedinherited

Definition at line 699 of file G4VEmProcess.hh.

{
  return fXSType;
}

References G4VEmProcess::fXSType.

CurrentMaterialCutsCoupleIndex()

size_t G4VEmProcess::CurrentMaterialCutsCoupleIndex ( ) const

inlineprotectedinherited

Definition at line 466 of file G4VEmProcess.hh.

{
  return currentCoupleIndex;
}

References G4VEmProcess::currentCoupleIndex.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4PolarizedAnnihilation::ComputeSaturationFactor(), and G4PolarizedCompton::ComputeSaturationFactor().

CurrentSetup()

void G4VEmProcess::CurrentSetup ( const G4MaterialCutsCouple *  couple, G4double  energy  )

inlineinherited

Definition at line 600 of file G4VEmProcess.hh.

{
  DefineMaterial(couple);
  SelectModel(energy*massRatio, currentCoupleIndex);
}

References G4VEmProcess::currentCoupleIndex, G4VEmProcess::DefineMaterial(), G4INCL::KinematicsUtils::energy(), G4VEmProcess::massRatio, and G4VEmProcess::SelectModel().

Referenced by G4VEmProcess::GetLambda(), G4VEmProcess::MeanFreePath(), G4VEmProcess::RecalculateLambda(), and SelectEmProcess().

DefineMaterial()

void G4VEmProcess::DefineMaterial ( const G4MaterialCutsCouple *  couple )

inlineprotectedinherited

Definition at line 494 of file G4VEmProcess.hh.

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

References G4VEmProcess::basedCoupleIndex, G4VEmProcess::baseMat, G4VEmProcess::baseMaterial, G4VEmProcess::biasFactor, G4VEmProcess::currentCouple, G4VEmProcess::currentCoupleIndex, G4VEmProcess::currentMaterial, DBL_MAX, G4VEmProcess::fFactor, G4Material::GetBaseMaterial(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), and G4VEmProcess::mfpKinEnergy.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::CurrentSetup(), G4VEmProcess::LambdaPhysicsVector(), and G4VEmProcess::PostStepGetPhysicalInteractionLength().

DensityFactor()

G4double G4VEmProcess::DensityFactor ( G4int  idx ) const

inlineprotectedinherited

Definition at line 770 of file G4VEmProcess.hh.

{
  return (*theDensityFactor)[idx];  
}

References G4VEmProcess::theDensityFactor.

Referenced by PostStepGetPhysicalInteractionLength().

DensityIndex()

G4int G4VEmProcess::DensityIndex ( G4int  idx ) const

inlineprotectedinherited

Definition at line 763 of file G4VEmProcess.hh.

{
  return (*theDensityIdx)[idx];  
}

References G4VEmProcess::theDensityIdx.

Referenced by BuildPhysicsTable(), and PostStepGetPhysicalInteractionLength().

DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

{
  G4cout << "Process Name " << theProcessName ;
  G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
  G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
}

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

EmModel()

G4VEmModel * G4VEmProcess::EmModel ( size_t  index = 0 ) const

inlineinherited

Definition at line 805 of file G4VEmProcess.hh.

{
  return (index < emModels.size()) ? emModels[index] : nullptr;
}

References G4VEmProcess::emModels.

Referenced by G4EmCalculator::ComputeNuclearDEDX(), G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAPhysics_stationary_option2::ConstructProcess(), G4EmDNAPhysics_stationary_option4::ConstructProcess(), G4EmDNAPhysics_stationary_option6::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4DNAAttachment::InitialiseProcess(), G4DNAChargeDecrease::InitialiseProcess(), G4DNAChargeIncrease::InitialiseProcess(), G4DNADissociation::InitialiseProcess(), G4DNAElastic::InitialiseProcess(), G4DNAElectronSolvation::InitialiseProcess(), G4DNAExcitation::InitialiseProcess(), G4DNAIonisation::InitialiseProcess(), G4DNAPlasmonExcitation::InitialiseProcess(), G4DNAPositronium::InitialiseProcess(), G4DNARotExcitation::InitialiseProcess(), G4DNAVibExcitation::InitialiseProcess(), G4NuclearStopping::InitialiseProcess(), G4JAEAElasticScattering::InitialiseProcess(), G4MicroElecElastic::InitialiseProcess(), G4MicroElecInelastic::InitialiseProcess(), G4MicroElecLOPhononScattering::InitialiseProcess(), G4RayleighScattering::InitialiseProcess(), G4PolarizedCompton::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), G4PolarizedPhotoElectric::InitialiseProcess(), G4ComptonScattering::InitialiseProcess(), G4CoulombScattering::InitialiseProcess(), G4eplusAnnihilation::InitialiseProcess(), G4GammaConversion::InitialiseProcess(), G4PhotoElectricEffect::InitialiseProcess(), G4DNAAttachment::PrintInfo(), G4DNAChargeDecrease::PrintInfo(), G4DNAChargeIncrease::PrintInfo(), G4DNADissociation::PrintInfo(), G4DNAElastic::PrintInfo(), G4DNAExcitation::PrintInfo(), G4DNAIonisation::PrintInfo(), G4DNAPlasmonExcitation::PrintInfo(), G4DNAPositronium::PrintInfo(), G4DNARotExcitation::PrintInfo(), and G4DNAVibExcitation::PrintInfo().

EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

EnergyOfCrossSectionMax()

std::vector< G4double > * G4VEmProcess::EnergyOfCrossSectionMax ( ) const

inlineinherited

Definition at line 671 of file G4VEmProcess.hh.

{
  return theEnergyOfCrossSectionMax;
}

References G4VEmProcess::theEnergyOfCrossSectionMax.

Referenced by G4VEmProcess::BuildPhysicsTable().

FindLambdaMax()

std::vector< G4double > * G4VEmProcess::FindLambdaMax ( )

inherited

Definition at line 1021 of file G4VEmProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::FindLambdaMax: " 
           << particle->GetParticleName() 
           << " and process " << GetProcessName() << "  " << G4endl; 
  }
  std::vector<G4double>* ptr = nullptr;
  if(fXSType != fEmOnePeak) { return ptr; }
 
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  size_t n = theCoupleTable->GetTableSize();
  ptr = new std::vector<G4double>;
  ptr->resize(n, DBL_MAX);
 
  G4bool isPeak = false;
  const G4double g4log10 = G4Log(10.);
  const G4double scale = theParameters->NumberOfBinsPerDecade()/g4log10;
 
  for(size_t i=0; i<n; ++i) {
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
    G4double emin = std::max(minKinEnergy, MinPrimaryEnergy(particle, couple->GetMaterial()));
    G4double emax = std::max(maxKinEnergy, emin + emin);
    G4double ee = G4Log(emax/emin);
    G4int nbin = G4lrint(ee*scale);
    if(nbin < 4) { nbin = 4; }
    G4double x = G4Exp(ee/nbin);
    G4double sm = 0.0;
    G4double em = emin;
    G4double e = emin;
    for(G4int j=0; j<=nbin; ++j) {
      G4double sig = RecalculateLambda(e, couple);
      //G4cout << j << "  E=" << e << " Lambda=" << sig << G4endl;
      if(sig >= sm) {
    em = e;
    sm = sig;
    e *= x;
      } else {
    isPeak = true;
    (*ptr)[i] = em;
    break;
      }
    }
    if(1 < verboseLevel) {
      G4cout << "  " << i << ".  Epeak(GeV)=" << em/GeV
         << " SigmaMax(1/mm)=" << sm
         << " Emin(GeV)=" << emin/GeV << " Emax(GeV)=" << emax/GeV
         << "   " << couple->GetMaterial()->GetName() << G4endl;
    }
  }
  // there is no peak for any material
  if(!isPeak) {
    delete ptr;
    ptr = nullptr;
  }
  return ptr;
}

References DBL_MAX, emax, fEmOnePeak, G4VEmProcess::fXSType, G4cout, G4endl, G4Exp(), G4Log(), G4lrint(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), GeV, G4INCL::Math::max(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::MinPrimaryEnergy(), CLHEP::detail::n, G4EmParameters::NumberOfBinsPerDecade(), G4VEmProcess::particle, G4VEmProcess::RecalculateLambda(), G4InuclParticleNames::sm, G4VEmProcess::theParameters, and G4VProcess::verboseLevel.

Referenced by G4VEmProcess::BuildPhysicsTable().

GetCurrentElement()

const G4Element * G4VEmProcess::GetCurrentElement ( ) const

inherited

Definition at line 1104 of file G4VEmProcess.cc.

{
  return (nullptr != currentModel) ? currentModel->GetCurrentElement() : nullptr; 
}

References G4VEmProcess::currentModel, and G4VEmModel::GetCurrentElement().

GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

GetCurrentLambda() [1/2]

G4double G4VEmProcess::GetCurrentLambda ( G4double  kinEnergy )

inlineprivateinherited

Definition at line 569 of file G4VEmProcess.hh.

{
  if(currentCoupleIndex != coupleIdxLambda || fLambdaEnergy != e) {
    coupleIdxLambda = currentCoupleIndex;
    fLambdaEnergy = e;
    if(e >= minKinEnergyPrim) { fLambda = GetLambdaFromTablePrim(e); }
    else if(nullptr != theLambdaTable) { fLambda = GetLambdaFromTable(e); }
    else { fLambda = ComputeCurrentLambda(e); }
    fLambda *= fFactor;
  }
  return fLambda;
}

References G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::coupleIdxLambda, G4VEmProcess::currentCoupleIndex, G4VEmProcess::fFactor, G4VEmProcess::fLambda, G4VEmProcess::fLambdaEnergy, G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::GetLambdaFromTablePrim(), G4VEmProcess::minKinEnergyPrim, and G4VEmProcess::theLambdaTable.

Referenced by G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::GetLambda(), G4VEmProcess::MeanFreePath(), and G4VEmProcess::PostStepDoIt().

GetCurrentLambda() [2/2]

G4double G4VEmProcess::GetCurrentLambda ( G4double  kinEnergy, G4double  logKinEnergy  )

inlineprivateinherited

Definition at line 584 of file G4VEmProcess.hh.

{
  if(currentCoupleIndex != coupleIdxLambda || fLambdaEnergy != e) {
    coupleIdxLambda = currentCoupleIndex;
    fLambdaEnergy = e;
    if(e >= minKinEnergyPrim) { fLambda = GetLambdaFromTablePrim(e, loge); }
    else if(nullptr != theLambdaTable) { fLambda = GetLambdaFromTable(e, loge); }
    else { fLambda = ComputeCurrentLambda(e); }
    fLambda *= fFactor;
  }
  return fLambda;
}

References G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::coupleIdxLambda, G4VEmProcess::currentCoupleIndex, G4VEmProcess::fFactor, G4VEmProcess::fLambda, G4VEmProcess::fLambdaEnergy, G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::GetLambdaFromTablePrim(), G4VEmProcess::minKinEnergyPrim, and G4VEmProcess::theLambdaTable.

GetCurrentModel()

const G4VEmModel * G4VEmProcess::GetCurrentModel ( ) const

inlineinherited

Definition at line 784 of file G4VEmProcess.hh.

{
  return currentModel;
}

References G4VEmProcess::currentModel.

GetElectronEnergyCut()

G4double G4VEmProcess::GetElectronEnergyCut ( )

inlineprotectedinherited

Definition at line 487 of file G4VEmProcess.hh.

{
  return (*theCutsElectron)[currentCoupleIndex];
}

References G4VEmProcess::currentCoupleIndex, and G4VEmProcess::theCutsElectron.

Referenced by G4eplusAnnihilation::AtRestDoIt().

GetEmProcess()

G4VEmProcess * G4GammaGeneralProcess::GetEmProcess ( const G4String &  name )

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 761 of file G4GammaGeneralProcess.cc.

{
  G4VEmProcess* proc = nullptr;
  if(name == thePhotoElectric->GetProcessName()) {
    proc = thePhotoElectric;
  } else if(name == theCompton->GetProcessName()) {
    proc = theCompton;
  } else if(name == theConversionEE->GetProcessName()) {
    proc = theConversionEE;
  } else if(theRayleigh != nullptr && name == theRayleigh->GetProcessName()) {
    proc = theRayleigh;
  }
  return proc;
}

References G4VProcess::GetProcessName(), G4InuclParticleNames::name(), theCompton, theConversionEE, thePhotoElectric, and theRayleigh.

GetGammaEnergyCut()

G4double G4VEmProcess::GetGammaEnergyCut ( )

inlineprotectedinherited

Definition at line 480 of file G4VEmProcess.hh.

{
  return (*theCutsGamma)[currentCoupleIndex];
}

References G4VEmProcess::currentCoupleIndex, and G4VEmProcess::theCutsGamma.

Referenced by G4eplusAnnihilation::AtRestDoIt().

GetLambda() [1/2]

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

inherited

Definition at line 1228 of file G4VEmProcess.cc.

{
  CurrentSetup(couple, kinEnergy);
  return GetCurrentLambda(kinEnergy, G4Log(kinEnergy));
}

References G4VEmProcess::CurrentSetup(), G4Log(), and G4VEmProcess::GetCurrentLambda().

Referenced by BuildPhysicsTable(), G4AdjointComptonModel::RapidSampleSecondaries(), and TotalCrossSectionPerVolume().

GetLambda() [2/2]

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

inlineinherited

Definition at line 609 of file G4VEmProcess.hh.

{
  CurrentSetup(couple, kinEnergy);
  return GetCurrentLambda(kinEnergy, logKinEnergy);
}

References G4VEmProcess::CurrentSetup(), and G4VEmProcess::GetCurrentLambda().

GetLambdaFromTable() [1/2]

G4double G4VEmProcess::GetLambdaFromTable ( G4double  kinEnergy )

inlineprivateinherited

Definition at line 534 of file G4VEmProcess.hh.

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

References G4VEmProcess::basedCoupleIndex, G4VEmProcess::idxLambda, and G4VEmProcess::theLambdaTable.

Referenced by G4VEmProcess::GetCurrentLambda().

GetLambdaFromTable() [2/2]

G4double G4VEmProcess::GetLambdaFromTable ( G4double  kinEnergy, G4double  logKinEnergy  )

inlineprivateinherited

Definition at line 541 of file G4VEmProcess.hh.

{
  return ((*theLambdaTable)[basedCoupleIndex])->LogVectorValue(e, loge);
}

References G4VEmProcess::basedCoupleIndex, and G4VEmProcess::theLambdaTable.

GetLambdaFromTablePrim() [1/2]

G4double G4VEmProcess::GetLambdaFromTablePrim ( G4double  kinEnergy )

inlineprivateinherited

Definition at line 548 of file G4VEmProcess.hh.

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

References G4VEmProcess::basedCoupleIndex, G4VEmProcess::idxLambda, and G4VEmProcess::theLambdaTablePrim.

Referenced by G4VEmProcess::GetCurrentLambda().

GetLambdaFromTablePrim() [2/2]

G4double G4VEmProcess::GetLambdaFromTablePrim ( G4double  kinEnergy, G4double  logKinEnergy  )

inlineprivateinherited

Definition at line 555 of file G4VEmProcess.hh.

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

References G4VEmProcess::basedCoupleIndex, and G4VEmProcess::theLambdaTablePrim.

GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

GetMeanFreePath()

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

overrideprotectedvirtual

Implements G4VDiscreteProcess.

Definition at line 723 of file G4GammaGeneralProcess.cc.

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

References condition(), G4VEmProcess::MeanFreePath(), and NotForced.

GetModelByIndex()

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

inherited

Definition at line 168 of file G4VEmProcess.cc.

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

References G4EmModelManager::GetModel(), and G4VEmProcess::modelManager.

Referenced by G4VEmProcess::BuildPhysicsTable().

GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

GetParticleChange()

G4ParticleChangeForGamma * G4VEmProcess::GetParticleChange ( )

inlineprotectedinherited

Definition at line 713 of file G4VEmProcess.hh.

{
  return &fParticleChange;
}

References G4VEmProcess::fParticleChange.

GetPhysicsTableFileName()

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

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

GetProbability()

G4double G4GammaGeneralProcess::GetProbability ( size_t  idxt )

inlineprotected

Definition at line 203 of file G4GammaGeneralProcess.hh.

{
  return theHandler->GetVector(idxt, basedCoupleIndex)
    ->LogVectorValue(preStepKinEnergy, preStepLogE);
}

References G4VEmProcess::basedCoupleIndex, G4EmDataHandler::GetVector(), G4PhysicsVector::LogVectorValue(), G4VEmProcess::preStepKinEnergy, preStepLogE, and theHandler.

Referenced by PostStepDoIt().

GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4ProcessManager::ActivateProcess(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4ProcessManager::AddProcess(), G4ProcessPlacer::AddProcessAs(), G4ITSteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), G4ITSteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4BOptnLeadingParticle::ApplyFinalStateBiasing(), G4ITSteppingVerbose::AtRestDoItInvoked(), G4SteppingVerbose::AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4ITSteppingVerbose::AtRestDoItOneByOne(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4HadronicProcess::BiasCrossSectionByFactor(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VEnergyLossProcess::BuildDEDXTable(), G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4VEmProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4DNABrownianTransportation::BuildPhysicsTable(), BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4ProcessManager::CheckOrderingParameters(), G4HadronicProcess::CheckResult(), G4StackChecker::ClassifyNewTrack(), G4BOptrForceCollision::ConfigureForWorker(), G4RunManagerKernel::ConfirmCoupledTransportation(), G4FastSimulationPhysics::ConstructProcess(), G4GenericBiasingPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4LossTableManager::CopyTables(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4VPhononProcess::CreateSecondary(), G4EmExtraParameters::DefineRegParamForEM(), G4EmExtraParameters::DefineRegParamForLoss(), G4HadronicProcessStore::DeRegisterExtraProcess(), G4ITSteppingVerbose::DPSLAlongStep(), G4SteppingVerbose::DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), G4ITSteppingVerbose::DPSLPostStep(), G4SteppingVerbose::DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), G4HadronicProcessStore::Dump(), G4HadronicProcess::DumpState(), G4MuonicAtomDecay::DumpState(), G4ExceptionHandler::DumpTrackInfo(), export_G4VProcess(), G4EmCalculator::FindEmModel(), G4VEmProcess::FindLambdaMax(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4HadronicProcess::GetElementCrossSection(), G4VEmProcess::GetEmProcess(), GetEmProcess(), G4WeightWindowProcess::GetName(), G4ProcessManager::GetProcess(), G4ProcessManager::GetProcessVectorIndex(), GetSubProcessName(), G4ProcessManager::InActivateProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4ProcessTable::Insert(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAtRestDoItProcs(), G4SteppingManager::InvokePSDIP(), G4LossTableManager::LocalPhysicsTables(), G4ErrorPropagator::MakeOneStep(), G4VEmProcess::PostStepDoIt(), G4ITSteppingVerbose::PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), G4ITSteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4ITSteppingVerbose::PostStepVerbose(), G4EmConfigurator::PrepareModels(), G4HadronStoppingProcess::PreparePhysicsTable(), PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4HadronicProcessStore::PrintHtml(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4hImpactIonisation::PrintInfoDefinition(), G4ProcessPlacer::PrintProcVec(), G4VEnergyLossProcess::PrintWarning(), G4VEmProcess::PrintWarning(), G4SynchrotronRadiation::ProcessDescription(), G4Decay::ProcessDescription(), G4DecayWithSpin::ProcessDescription(), G4PionDecayMakeSpin::ProcessDescription(), G4UnknownDecay::ProcessDescription(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), G4StackManager::PushOneTrack(), G4HadronicProcessStore::Register(), G4LossTableManager::Register(), G4LossTableManager::RegisterExtraParticle(), G4HadronicProcessStore::RegisterExtraProcess(), G4HadronicProcessStore::RegisterParticle(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTable::Remove(), G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(), G4ProcessManager::RemoveProcess(), G4ProcessPlacer::RemoveProcess(), RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::SetLambdaTable(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessManager::SetProcessOrderingToSecond(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4FastSimulationManagerProcess::SetWorldVolume(), G4ITSteppingVerbose::ShowStep(), G4SteppingVerbose::ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), G4ChannelingOptrChangeCrossSection::StartRun(), G4ITSteppingVerbose::StepInfo(), G4SteppingVerbose::StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), G4ITSteppingVerbose::StepInfoForLeadingTrack(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4EmCalculator::UpdateParticle(), G4ParallelWorldScoringProcess::Verbose(), G4ScoreSplittingProcess::Verbose(), G4ITSteppingVerbose::VerboseTrack(), G4SteppingVerbose::VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType  aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

References fDecay, fElectromagnetic, fGeneral, fHadronic, fNotDefined, fOptical, fParameterisation, fPhonon, fPhotolepton_hadron, fTransportation, fUserDefined, anonymous_namespace{G4VProcess.cc}::noType, anonymous_namespace{G4VProcess.cc}::typeDecay, anonymous_namespace{G4VProcess.cc}::typeElectromagnetic, anonymous_namespace{G4VProcess.cc}::typeGeneral, anonymous_namespace{G4VProcess.cc}::typeHadronic, anonymous_namespace{G4VProcess.cc}::typeNotDefined, anonymous_namespace{G4VProcess.cc}::typeOptical, anonymous_namespace{G4VProcess.cc}::typeParameterisation, anonymous_namespace{G4VProcess.cc}::typePhonon, anonymous_namespace{G4VProcess.cc}::typePhotolepton_hadron, anonymous_namespace{G4VProcess.cc}::typeTransportation, and anonymous_namespace{G4VProcess.cc}::typeUserDefined.

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

GetSelectedProcess()

const G4VProcess * G4GammaGeneralProcess::GetSelectedProcess ( ) const

inline

Definition at line 228 of file G4GammaGeneralProcess.hh.

{
  return selectedProc;
}

References selectedProc.

GetSubProcessName()

const G4String & G4GammaGeneralProcess::GetSubProcessName

(

)

const

Definition at line 745 of file G4GammaGeneralProcess.cc.

{
  return (selectedProc) ? selectedProc->GetProcessName()
    : G4VProcess::GetProcessName();
}

References G4VProcess::GetProcessName(), and selectedProc.

GetSubProcessSubType()

G4int G4GammaGeneralProcess::GetSubProcessSubType

(

)

const

Definition at line 753 of file G4GammaGeneralProcess.cc.

{
  return (selectedProc) ? selectedProc->GetProcessSubType()
    : fGammaGeneralProcess;
}

References fGammaGeneralProcess, G4VProcess::GetProcessSubType(), and selectedProc.

GetTargetElement()

const G4Element * G4VEmProcess::GetTargetElement ( ) const

inlineprotectedinherited

Definition at line 749 of file G4VEmProcess.hh.

{
  return currentModel->GetCurrentElement();
}

References G4VEmProcess::currentModel, and G4VEmModel::GetCurrentElement().

GetTargetIsotope()

const G4Isotope * G4VEmProcess::GetTargetIsotope ( ) const

inlineprotectedinherited

Definition at line 756 of file G4VEmProcess.hh.

{
  return currentModel->GetCurrentIsotope();
}

References G4VEmProcess::currentModel, and G4VEmModel::GetCurrentIsotope().

GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const

inlineinherited

Definition at line 418 of file G4VProcess.hh.

{
  return  verboseLevel;
}

References G4VProcess::verboseLevel.

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Decay::G4Decay(), G4UnknownDecay::G4UnknownDecay(), G4Decay::GetMeanFreePath(), G4Decay::GetMeanLifeTime(), and G4DecayWithSpin::Spin_Precession().

InitialiseProcess()

void G4GammaGeneralProcess::InitialiseProcess ( const G4ParticleDefinition *  )

overrideprotectedvirtual

Implements G4VEmProcess.

Definition at line 190 of file G4GammaGeneralProcess.cc.

{
  if(isTheMaster) {
 
    G4EmParameters* param = G4EmParameters::Instance();
    G4LossTableManager* man = G4LossTableManager::Instance();
 
    // tables are created and its size is defined only once
    if(nullptr == theHandler) {
      theHandler = new G4EmDataHandler(nTables);
      if(theRayleigh) { theT[1] = true; }
 
      theHandler->SetMasterProcess(thePhotoElectric);
      theHandler->SetMasterProcess(theCompton);
      theHandler->SetMasterProcess(theConversionEE);
      theHandler->SetMasterProcess(theRayleigh);
    }
    auto bld = man->GetTableBuilder();
 
    const G4ProductionCutsTable* theCoupleTable=
      G4ProductionCutsTable::GetProductionCutsTable();
    size_t numOfCouples = theCoupleTable->GetTableSize();
 
    G4double mine = param->MinKinEnergy();
    G4double maxe = param->MaxKinEnergy();
    G4int nd = param->NumberOfBinsPerDecade();
    size_t nbin1 = std::max(5, nd*G4lrint(std::log10(minPEEnergy/mine)));
    size_t nbin2 = std::max(5, nd*G4lrint(std::log10(maxe/minMMEnergy)));
 
    G4PhysicsVector* vec = nullptr;
    G4PhysicsLogVector aVector(mine,minPEEnergy,nbin1,splineFlag);
    G4PhysicsLogVector bVector(minPEEnergy,minEEEnergy,nLowE,splineFlag);
    G4PhysicsLogVector cVector(minEEEnergy,minMMEnergy,nHighE,splineFlag);
    G4PhysicsLogVector dVector(minMMEnergy,maxe,nbin2,splineFlag);
 
    for(size_t i=0; i<nTables; ++i) {
      if(!theT[i]) { continue; }
      //G4cout << "## PreparePhysTable " << i << "." << G4endl;
      G4PhysicsTable* table = theHandler->MakeTable(i);
      //G4cout << "   make table " << table << G4endl;
      for(size_t j=0; j<numOfCouples; ++j) {
    vec = (*table)[j];
    if (bld->GetFlag(j) && nullptr == vec) {
      //G4cout <<" i= "<<i<<" j= "<< j <<" make new vector"<< G4endl;
      if(i<=1) {
        vec = new G4PhysicsVector(aVector);
      } else if(i<=5) {
        vec = new G4PhysicsVector(bVector);
      } else if(i<=9) {
        vec = new G4PhysicsVector(cVector);
      } else {
        vec = new G4PhysicsVector(dVector);
      }
      G4PhysicsTableHelper::SetPhysicsVector(table, j, vec);
    }
      }
    }
  }
}

References G4lrint(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4EmParameters::Instance(), G4LossTableManager::Instance(), G4VEmProcess::isTheMaster, G4EmDataHandler::MakeTable(), G4INCL::Math::max(), G4EmParameters::MaxKinEnergy(), minEEEnergy, G4EmParameters::MinKinEnergy(), minMMEnergy, minPEEnergy, nHighE, nLowE, nTables, G4EmParameters::NumberOfBinsPerDecade(), G4EmDataHandler::SetMasterProcess(), G4PhysicsTableHelper::SetPhysicsVector(), splineFlag, theCompton, theConversionEE, theHandler, thePhotoElectric, theRayleigh, and theT.

Referenced by PreparePhysicsTable().

isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

IsApplicable()

G4bool G4GammaGeneralProcess::IsApplicable ( const G4ParticleDefinition &  )

overridevirtual

Implements G4VEmProcess.

Definition at line 109 of file G4GammaGeneralProcess.cc.

{
  return true;
}

isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

LambdaBinning()

G4int G4VEmProcess::LambdaBinning ( ) const

inlineprotectedinherited

Definition at line 629 of file G4VEmProcess.hh.

{
  return nLambdaBins;
}

References G4VEmProcess::nLambdaBins.

Referenced by G4PolarizedCompton::BuildAsymmetryTable().

LambdaPhysicsVector()

G4PhysicsVector * G4VEmProcess::LambdaPhysicsVector ( const G4MaterialCutsCouple *  couple )

protectedinherited

Definition at line 1094 of file G4VEmProcess.cc.

{
  DefineMaterial(couple);
  G4PhysicsVector* newv = new G4PhysicsLogVector(minKinEnergy, maxKinEnergy, 
                                                 nLambdaBins, splineFlag);
  return newv;
}

References G4VEmProcess::DefineMaterial(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::nLambdaBins, and G4VEmProcess::splineFlag.

Referenced by G4PolarizedAnnihilation::BuildAsymmetryTables().

LambdaTable()

G4PhysicsTable * G4VEmProcess::LambdaTable ( ) const

inlineinherited

Definition at line 657 of file G4VEmProcess.hh.

{
  return theLambdaTable;
}

References G4VEmProcess::theLambdaTable.

Referenced by G4VEmProcess::BuildPhysicsTable(), and G4EmCalculator::FindLambdaTable().

LambdaTablePrim()

G4PhysicsTable * G4VEmProcess::LambdaTablePrim ( ) const

inlineinherited

Definition at line 664 of file G4VEmProcess.hh.

{
  return theLambdaTablePrim;
}

References G4VEmProcess::theLambdaTablePrim.

Referenced by G4VEmProcess::BuildPhysicsTable().

MaterialCutsCouple()

const G4MaterialCutsCouple * G4VEmProcess::MaterialCutsCouple ( ) const

inlineprotectedinherited

Definition at line 473 of file G4VEmProcess.hh.

{
  return currentCouple;
}

References G4VEmProcess::currentCouple.

Referenced by G4eplusAnnihilation::AtRestDoIt().

MaxKinEnergy()

G4double G4VEmProcess::MaxKinEnergy ( ) const

inlineprotectedinherited

Definition at line 643 of file G4VEmProcess.hh.

{
  return maxKinEnergy;
}

References G4VEmProcess::maxKinEnergy.

Referenced by G4PolarizedCompton::BuildAsymmetryTable(), G4eplusAnnihilation::InitialiseProcess(), and G4VEmProcess::SetMinKinEnergyPrim().

MeanFreePath()

G4double G4VEmProcess::MeanFreePath ( const G4Track &  track )

inherited

Definition at line 998 of file G4VEmProcess.cc.

{
  const G4double kinEnergy = track.GetKineticEnergy();
  CurrentSetup(track.GetMaterialCutsCouple(), kinEnergy);
  const G4double xs = GetCurrentLambda(kinEnergy,
                             track.GetDynamicParticle()->GetLogKineticEnergy());
  return (0.0 < xs) ? 1.0/xs : DBL_MAX; 
}

References G4VEmProcess::CurrentSetup(), DBL_MAX, G4VEmProcess::GetCurrentLambda(), G4Track::GetDynamicParticle(), G4Track::GetKineticEnergy(), G4DynamicParticle::GetLogKineticEnergy(), and G4Track::GetMaterialCutsCouple().

Referenced by GetMeanFreePath(), and G4VEmProcess::GetMeanFreePath().

MinKinEnergy()

G4double G4VEmProcess::MinKinEnergy ( ) const

inlineprotectedinherited

Definition at line 636 of file G4VEmProcess.hh.

{
  return minKinEnergy;
}

References G4VEmProcess::minKinEnergy.

Referenced by G4PolarizedCompton::BuildAsymmetryTable(), and G4eplusAnnihilation::InitialiseProcess().

MinPrimaryEnergy()

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

protectedvirtualinherited

Reimplemented in G4CoulombScattering, and G4GammaConversion.

Definition at line 138 of file G4VEmProcess.cc.

{
  return 0.0;
}

Referenced by G4VEmProcess::BuildLambdaTable(), and G4VEmProcess::FindLambdaMax().

NumberOfModels()

G4int G4VEmProcess::NumberOfModels ( ) const

inlineinherited

Definition at line 798 of file G4VEmProcess.hh.

{
  return numberOfModels;
}

References G4VEmProcess::numberOfModels.

operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess &  right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

operator=()

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

delete

operator==()

G4bool G4VProcess::operator== ( const G4VProcess &  right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

Particle()

const G4ParticleDefinition * G4VEmProcess::Particle ( ) const

inlineinherited

Definition at line 678 of file G4VEmProcess.hh.

{
  return particle;
}

References G4VEmProcess::particle.

PolarAngleLimit()

G4double G4VEmProcess::PolarAngleLimit ( ) const

inlineprotectedinherited

Definition at line 1236 of file G4VEmProcess.cc.

{
  return theParameters->MscThetaLimit();
}

References G4EmParameters::MscThetaLimit(), and G4VEmProcess::theParameters.

PostStepDoIt()

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

overridevirtual

Reimplemented from G4VDiscreteProcess.

Definition at line 575 of file G4GammaGeneralProcess.cc.

{
  // In all cases clear number of interaction lengths
  theNumberOfInteractionLengthLeft = -1.0;
  selectedProc = nullptr;
  G4double q = G4UniformRand();
  /*
  G4cout << "PostStep: preStepLambda= " << preStepLambda
         << " PE= " << peLambda << " q= " << q << " idxE= " << idxEnergy
         << G4endl;
  */
  switch (idxEnergy) {
  case 0:
    if(preStepLambda*q <= peLambda) {
      SelectEmProcess(step, thePhotoElectric);
    } else {
      if(theT[1] && preStepLambda*q < preStepLambda*GetProbability(1) + peLambda) {
    SelectEmProcess(step, theRayleigh);
      } else {
    SelectEmProcess(step, theCompton);
      }
    }
    break;
 
  case 1:
    if(q <= GetProbability(3)) {
      SelectEmProcess(step, thePhotoElectric);
    } else if(q <= GetProbability(4)) {
      SelectEmProcess(step, theCompton);
    } else if(theRayleigh) {
      SelectEmProcess(step, theRayleigh);
    }
    break;
 
  case 2:
    if(q <= GetProbability(7)) {
      SelectEmProcess(step, theConversionEE);
    } else if(q <= GetProbability(8)) {
      SelectEmProcess(step, theCompton);
    } else if(q <= GetProbability(9)) {
      SelectEmProcess(step, thePhotoElectric);
    } else if(theGammaNuclear) {
      SelectHadProcess(track, step, theGammaNuclear);
    }
    break;
 
  case 3:
    if(q + GetProbability(11) <= 1.0) {
      SelectEmProcess(step, theConversionEE);
    } else if(q + GetProbability(12) <= 1.0) {
      SelectEmProcess(step, theCompton);
    } else if(q + GetProbability(13) <= 1.0) {
      SelectEmProcess(step, thePhotoElectric);
    } else if(theGammaNuclear && q + GetProbability(14) <= 1.0) {
      SelectHadProcess(track, step, theGammaNuclear);
    } else if(theConversionMM) {
      SelectedProcess(step, theConversionMM);
    }
    break;
  }
  // sample secondaries
  if(selectedProc != nullptr) {
    return selectedProc->PostStepDoIt(track, step);
  }
  // no interaction - exception case
  fParticleChange.InitializeForPostStep(track);
  return &fParticleChange;
}

References G4VEmProcess::fParticleChange, G4UniformRand, GetProbability(), idxEnergy, G4ParticleChangeForGamma::InitializeForPostStep(), peLambda, G4VProcess::PostStepDoIt(), G4VEmProcess::preStepLambda, selectedProc, SelectedProcess(), SelectEmProcess(), SelectHadProcess(), theCompton, theConversionEE, theConversionMM, theGammaNuclear, G4VProcess::theNumberOfInteractionLengthLeft, thePhotoElectric, theRayleigh, and theT.

PostStepGetPhysicalInteractionLength()

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

overridevirtual

Reimplemented from G4VDiscreteProcess.

Definition at line 467 of file G4GammaGeneralProcess.cc.

{
  *condition = NotForced;
  G4double x = DBL_MAX;
 
  G4double energy = track.GetKineticEnergy();
  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();
 
  // compute mean free path
  G4bool recompute = false;
  if(couple != currentCouple) {
    currentCouple = couple;
    basedCoupleIndex = currentCoupleIndex = couple->GetIndex();
    currentMaterial = couple->GetMaterial();
    factor = 1.0;
    if(baseMat) {
      basedCoupleIndex = DensityIndex(currentCoupleIndex);
      factor = DensityFactor(currentCoupleIndex);
    }
    recompute = true;
  }
  if(energy != preStepKinEnergy) {
    preStepKinEnergy = energy;
    preStepLogE = track.GetDynamicParticle()->GetLogKineticEnergy();
    recompute = true;
  }
  if(recompute) {
    preStepLambda = TotalCrossSectionPerVolume();
 
    // 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) {
 
      theNumberOfInteractionLengthLeft -=
        previousStepSize/currentInteractionLength;
      theNumberOfInteractionLengthLeft =
        std::max(theNumberOfInteractionLengthLeft, 0.0);
    }
 
    // new mean free path and step limit for the next step
    currentInteractionLength = 1.0/preStepLambda;
    x = theNumberOfInteractionLengthLeft * currentInteractionLength;
  }
  /*
  G4cout << "PostStepGetPhysicalInteractionLength: e= " << energy
     << " idxe= " << idxEnergy << "  xs= " << preStepLambda
     << " x= " << x << G4endl;
  */
  return x;
}

References G4VEmProcess::basedCoupleIndex, G4VEmProcess::baseMat, condition(), G4VEmProcess::currentCouple, G4VEmProcess::currentCoupleIndex, G4VProcess::currentInteractionLength, G4VEmProcess::currentMaterial, DBL_MAX, G4VEmProcess::DensityFactor(), G4VEmProcess::DensityIndex(), G4INCL::KinematicsUtils::energy(), factor, G4Log(), G4UniformRand, G4Track::GetDynamicParticle(), G4MaterialCutsCouple::GetIndex(), G4Track::GetKineticEnergy(), G4DynamicParticle::GetLogKineticEnergy(), G4MaterialCutsCouple::GetMaterial(), G4Track::GetMaterialCutsCouple(), G4INCL::Math::max(), NotForced, G4VEmProcess::preStepKinEnergy, G4VEmProcess::preStepLambda, preStepLogE, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, and TotalCrossSectionPerVolume().

PostStepGPIL()

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

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

PreparePhysicsTable()

void G4GammaGeneralProcess::PreparePhysicsTable ( const G4ParticleDefinition &  part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 142 of file G4GammaGeneralProcess.cc.

{
  SetParticle(&part);
  preStepLambda = 0.0;
  idxEnergy = 0;
  currentCouple = nullptr;
 
  G4EmParameters* param = G4EmParameters::Instance();
  G4LossTableManager* man = G4LossTableManager::Instance();
 
  isTheMaster = man->IsMaster();
  if(isTheMaster) { SetVerboseLevel(param->Verbose()); }
  else { SetVerboseLevel(param->WorkerVerbose()); }
 
  G4LossTableBuilder* bld = man->GetTableBuilder();
  baseMat = bld->GetBaseMaterialFlag();
 
  if(1 < verboseLevel) {
    G4cout << "G4GammaGeneralProcess::PreparePhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
       << " isMaster: " << isTheMaster << G4endl;
  }
 
  // 3 sub-processes must be always defined
  if(thePhotoElectric == nullptr || theCompton == nullptr ||
     theConversionEE == nullptr) {
    G4ExceptionDescription ed;
    ed << "### G4GeneralGammaProcess is initialized incorrectly"
       << "\n Photoelectric: " << thePhotoElectric
       << "\n Compton: " << theCompton
       << "\n Conversion: " << theConversionEE;
    G4Exception("G4GeneralGammaProcess","em0004",
        FatalException, ed,"");
  }
 
  if(thePhotoElectric) { thePhotoElectric->PreparePhysicsTable(part); }
  if(theCompton)       { theCompton->PreparePhysicsTable(part); }
  if(theConversionEE)  { theConversionEE->PreparePhysicsTable(part); }
  if(theRayleigh)      { theRayleigh->PreparePhysicsTable(part); }
  if(theGammaNuclear)  { theGammaNuclear->PreparePhysicsTable(part); }
  if(theConversionMM)  { theConversionMM->PreparePhysicsTable(part); }
 
  InitialiseProcess(&part);
}

References G4VEmProcess::baseMat, G4VEmProcess::currentCouple, FatalException, G4cout, G4endl, G4Exception(), G4LossTableBuilder::GetBaseMaterialFlag(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4LossTableManager::GetTableBuilder(), idxEnergy, InitialiseProcess(), G4EmParameters::Instance(), G4LossTableManager::Instance(), G4LossTableManager::IsMaster(), G4VEmProcess::isTheMaster, G4VProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4HadronicProcess::PreparePhysicsTable(), G4VEmProcess::preStepLambda, G4VEmProcess::SetParticle(), G4VProcess::SetVerboseLevel(), theCompton, theConversionEE, theConversionMM, theGammaNuclear, thePhotoElectric, theRayleigh, G4EmParameters::Verbose(), G4VProcess::verboseLevel, and G4EmParameters::WorkerVerbose().

PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

PrintWarning()

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

privateinherited

Definition at line 1243 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);
}

References G4Exception(), G4VProcess::GetProcessName(), GeV, JustWarning, keV, G4EmParameters::MaxKinEnergy(), G4EmParameters::MinKinEnergy(), G4EmParameters::NumberOfBins(), and G4VEmProcess::theParameters.

Referenced by G4VEmProcess::SetLambdaBinning(), G4VEmProcess::SetMaxKinEnergy(), G4VEmProcess::SetMinKinEnergy(), and G4VEmProcess::SetMinKinEnergyPrim().

ProcessDescription()

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

overridevirtual

Reimplemented from G4VProcess.

Definition at line 733 of file G4GammaGeneralProcess.cc.

{
  thePhotoElectric->ProcessDescription(out);
  theCompton->ProcessDescription(out);
  theConversionEE->ProcessDescription(out);
  if(theRayleigh)      { theRayleigh->ProcessDescription(out); }
  if(theGammaNuclear)  { theGammaNuclear->ProcessDescription(out); }
  if(theConversionMM)  { theConversionMM->ProcessDescription(out); }
}

References G4VProcess::ProcessDescription(), G4VEmProcess::ProcessDescription(), G4HadronicProcess::ProcessDescription(), theCompton, theConversionEE, theConversionMM, theGammaNuclear, thePhotoElectric, and theRayleigh.

RecalculateLambda()

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

inlineprotectedinherited

Definition at line 619 of file G4VEmProcess.hh.

{
  CurrentSetup(couple, e);
  return fFactor*ComputeCurrentLambda(e);
}

References G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::CurrentSetup(), and G4VEmProcess::fFactor.

Referenced by G4VEmProcess::CrossSectionPerVolume(), and G4VEmProcess::FindLambdaMax().

ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft(), G4WrapperProcess::ResetNumberOfInteractionLengthLeft(), G4AdjointProcessEquivalentToDirectProcess::ResetNumberOfInteractionLengthLeft(), and G4Decay::StartTracking().

RetrievePhysicsTable()

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

overridevirtual

Reimplemented from G4VProcess.

Definition at line 687 of file G4GammaGeneralProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4GammaGeneralProcess::RetrievePhysicsTable() for "
           << part->GetParticleName() << " and process "
           << GetProcessName() << G4endl;
  }
  G4bool yes = true;
  if(!thePhotoElectric->RetrievePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(!theCompton->RetrievePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(!theConversionEE->RetrievePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(theRayleigh != nullptr &&
     !theRayleigh->RetrievePhysicsTable(part, directory, ascii))
    { yes = false; }
 
  for(size_t i=0; i<nTables; ++i) {
    if(theT[i]) {
      G4String nam = (0==i || 2==i || 6==i || 10==i)
    ? "LambdaGeneral" + nameT[i] : "ProbGeneral" + nameT[i];
      G4String fnam =  GetPhysicsTableFileName(part,directory,nam,ascii);
      if(!theHandler->RetrievePhysicsTable(i, part, fnam, ascii, splineFlag))
    { yes = false; }
    }
  }
  if(yes) {
  }
  return yes;
}

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), nameT, nTables, G4VEmProcess::RetrievePhysicsTable(), G4EmDataHandler::RetrievePhysicsTable(), splineFlag, theCompton, theConversionEE, theHandler, thePhotoElectric, theRayleigh, theT, and G4VProcess::verboseLevel.

RetrieveTable()

G4bool G4GammaGeneralProcess::RetrieveTable ( G4VEmProcess *  , const G4String &  directory, G4bool  ascii  )

private

SecondaryParticle()

const G4ParticleDefinition * G4VEmProcess::SecondaryParticle ( ) const

inlineinherited

Definition at line 685 of file G4VEmProcess.hh.

{
  return secondaryParticle;
}

References G4VEmProcess::secondaryParticle.

SelectedProcess()

void G4GammaGeneralProcess::SelectedProcess ( const G4Step &  step, G4VProcess *  ptr  )

inlineprotected

Definition at line 212 of file G4GammaGeneralProcess.hh.

{
  selectedProc = ptr;
  step.GetPostStepPoint()->SetProcessDefinedStep(ptr);
}

References G4Step::GetPostStepPoint(), selectedProc, and G4StepPoint::SetProcessDefinedStep().

Referenced by PostStepDoIt(), SelectEmProcess(), and SelectHadProcess().

SelectEmProcess()

void G4GammaGeneralProcess::SelectEmProcess ( const G4Step &  step, G4VEmProcess *  proc  )

inlineprotected

Definition at line 220 of file G4GammaGeneralProcess.hh.

{
  proc->CurrentSetup(currentCouple, preStepKinEnergy);
  SelectedProcess(step, proc);
}

References G4VEmProcess::currentCouple, G4VEmProcess::CurrentSetup(), G4VEmProcess::preStepKinEnergy, and SelectedProcess().

Referenced by PostStepDoIt().

SelectHadProcess()

void G4GammaGeneralProcess::SelectHadProcess ( const G4Track &  track, const G4Step &  step, G4HadronicProcess *  proc  )

protected

Definition at line 647 of file G4GammaGeneralProcess.cc.

{
  SelectedProcess(step, proc);
  proc->GetCrossSectionDataStore()->ComputeCrossSection(track.GetDynamicParticle(),
                                                        currentMaterial);
}

References G4CrossSectionDataStore::ComputeCrossSection(), G4VEmProcess::currentMaterial, G4HadronicProcess::GetCrossSectionDataStore(), G4Track::GetDynamicParticle(), and SelectedProcess().

Referenced by PostStepDoIt().

SelectModel()

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

inlineprotectedinherited

Definition at line 514 of file G4VEmProcess.hh.

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

References G4VEmProcess::currentCouple, G4VEmProcess::currentCoupleIndex, G4VEmProcess::currentModel, G4VEmProcess::modelManager, G4VEmProcess::numberOfModels, G4EmModelManager::SelectModel(), and G4VEmModel::SetCurrentCouple().

Referenced by G4NuclearStopping::AlongStepDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::ComputeCrossSectionPerAtom(), G4VEmProcess::CurrentSetup(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PostStepGetPhysicalInteractionLength().

SelectModelForMaterial()

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

inlineinherited

Definition at line 526 of file G4VEmProcess.hh.

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

References G4VEmProcess::modelManager, and G4EmModelManager::SelectModel().

Referenced by G4EmCalculator::FindEmModel().

SetBuildTableFlag()

void G4VEmProcess::SetBuildTableFlag ( G4bool  val )

inlineinherited

Definition at line 706 of file G4VEmProcess.hh.

{
  buildLambdaTable = val;
}

References G4VEmProcess::buildLambdaTable.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4eeToHadrons::G4eeToHadrons(), G4eplusAnnihilation::G4eplusAnnihilation(), G4GammaConversion::G4GammaConversion(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4NuclearStopping::G4NuclearStopping(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RayleighScattering::G4RayleighScattering(), G4DNAAttachment::InitialiseProcess(), G4DNAChargeDecrease::InitialiseProcess(), G4DNAChargeIncrease::InitialiseProcess(), G4DNADissociation::InitialiseProcess(), G4DNAElastic::InitialiseProcess(), G4DNAElectronSolvation::InitialiseProcess(), G4DNAExcitation::InitialiseProcess(), G4DNAIonisation::InitialiseProcess(), G4DNAPlasmonExcitation::InitialiseProcess(), G4DNAPositronium::InitialiseProcess(), G4DNARotExcitation::InitialiseProcess(), G4DNAVibExcitation::InitialiseProcess(), G4MicroElecElastic::InitialiseProcess(), G4MicroElecInelastic::InitialiseProcess(), G4MicroElecLOPhononScattering::InitialiseProcess(), and G4CoulombScattering::InitialiseProcess().

SetCrossSectionBiasingFactor()

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

inherited

Definition at line 1111 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; 
    }
  }
}

References G4VEmProcess::biasFactor, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VEmProcess::particle, G4VProcess::verboseLevel, and G4VEmProcess::weightFlag.

Referenced by G4EmExtraParameters::DefineRegParamForEM().

SetCrossSectionType()

void G4VEmProcess::SetCrossSectionType ( G4CrossSectionType  val )

inlineinherited

Definition at line 692 of file G4VEmProcess.hh.

{
  fXSType = val; 
}

References G4VEmProcess::fXSType.

Referenced by G4CoulombScattering::G4CoulombScattering(), G4eeToHadrons::G4eeToHadrons(), G4eplusAnnihilation::G4eplusAnnihilation(), and G4CoulombScattering::InitialiseProcess().

SetEmMasterProcess()

void G4VEmProcess::SetEmMasterProcess ( const G4VEmProcess *  ptr )

inlineinherited

Definition at line 791 of file G4VEmProcess.hh.

{ 
  masterProc = ptr;
}

References G4VEmProcess::masterProc.

Referenced by BuildPhysicsTable().

SetEmModel()

void G4VEmProcess::SetEmModel ( G4VEmModel *  ptr, G4int  index = 0  )

inherited

Definition at line 157 of file G4VEmProcess.cc.

{
  if(nullptr == ptr) { return; }
  if(!emModels.empty()) {
    for(auto & em : emModels) { if(em == ptr) { return; } }
  }
  emModels.push_back(ptr);
}

References G4VEmProcess::emModels.

Referenced by G4EmDNAPhysics::ConstructGammaPositronProcesses(), G4EmDNAPhysics_option1::ConstructProcess(), G4EmDNAPhysics_option2::ConstructProcess(), G4EmDNAPhysics_option3::ConstructProcess(), G4EmDNAPhysics_option4::ConstructProcess(), G4EmDNAPhysics_option5::ConstructProcess(), G4EmDNAPhysics_option6::ConstructProcess(), G4EmDNAPhysics_option7::ConstructProcess(), G4EmDNAPhysics_option8::ConstructProcess(), G4EmDNAPhysics_stationary_option2::ConstructProcess(), G4EmDNAPhysics_stationary_option4::ConstructProcess(), G4EmDNAPhysics_stationary_option6::ConstructProcess(), G4EmDNAPhysics::ConstructProcess(), G4EmDNAPhysics_stationary::ConstructProcess(), G4EmDNAPhysicsActivator::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), G4EmStandardPhysicsSS::ConstructProcess(), G4EmStandardPhysicsWVI::ConstructProcess(), G4EmDNAPhysicsActivator::DeactivateNuclearStopping(), G4EmModelActivator::FindOrAddProcess(), G4PolarizedAnnihilation::G4PolarizedAnnihilation(), G4DNAAttachment::InitialiseProcess(), G4DNAChargeDecrease::InitialiseProcess(), G4DNAChargeIncrease::InitialiseProcess(), G4DNADissociation::InitialiseProcess(), G4DNAElastic::InitialiseProcess(), G4DNAElectronSolvation::InitialiseProcess(), G4DNAExcitation::InitialiseProcess(), G4DNAIonisation::InitialiseProcess(), G4DNAPlasmonExcitation::InitialiseProcess(), G4DNAPositronium::InitialiseProcess(), G4DNARotExcitation::InitialiseProcess(), G4DNAVibExcitation::InitialiseProcess(), G4NuclearStopping::InitialiseProcess(), G4eeToHadrons::InitialiseProcess(), G4JAEAElasticScattering::InitialiseProcess(), G4MicroElecElastic::InitialiseProcess(), G4MicroElecInelastic::InitialiseProcess(), G4MicroElecLOPhononScattering::InitialiseProcess(), G4RayleighScattering::InitialiseProcess(), G4PolarizedCompton::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), G4PolarizedPhotoElectric::InitialiseProcess(), G4ComptonScattering::InitialiseProcess(), G4CoulombScattering::InitialiseProcess(), G4eplusAnnihilation::InitialiseProcess(), G4GammaConversion::InitialiseProcess(), G4PhotoElectricEffect::InitialiseProcess(), and G4VEmProcess::PreparePhysicsTable().

SetEnergyOfCrossSectionMax()

void G4VEmProcess::SetEnergyOfCrossSectionMax ( std::vector< G4double > *  ptr )

inherited

Definition at line 1082 of file G4VEmProcess.cc.

{
  if(nullptr == ptr) {
    fXSType = fEmIncreasing;
  } else {
    theEnergyOfCrossSectionMax = ptr;
  }
}

References fEmIncreasing, G4VEmProcess::fXSType, and G4VEmProcess::theEnergyOfCrossSectionMax.

Referenced by G4VEmProcess::BuildPhysicsTable().

SetLambdaBinning()

void G4VEmProcess::SetLambdaBinning ( G4int  nbins )

inherited

Definition at line 1174 of file G4VEmProcess.cc.

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

References G4VEmProcess::actBinning, CLHEP::detail::n, G4VEmProcess::nLambdaBins, and G4VEmProcess::PrintWarning().

Referenced by G4GammaConversion::G4GammaConversion(), and G4PolarizedGammaConversion::G4PolarizedGammaConversion().

SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess *  masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

SetMaxKinEnergy()

void G4VEmProcess::SetMaxKinEnergy ( G4double  e )

inherited

Definition at line 1199 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); } 
}

References G4VEmProcess::actMaxKinEnergy, G4Log(), G4lrint(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::nLambdaBins, G4VEmProcess::PrintWarning(), and TeV.

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), and G4EmStandardPhysicsWVI::ConstructProcess().

SetMinKinEnergy()

void G4VEmProcess::SetMinKinEnergy ( G4double  e )

inherited

Definition at line 1187 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); } 
}

References G4VEmProcess::actMinKinEnergy, eV, G4Log(), G4lrint(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::nLambdaBins, and G4VEmProcess::PrintWarning().

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), G4EmStandardPhysicsWVI::ConstructProcess(), G4GammaConversion::G4GammaConversion(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), and G4GammaConversion::InitialiseProcess().

SetMinKinEnergyPrim()

void G4VEmProcess::SetMinKinEnergyPrim ( G4double  e )

inherited

Definition at line 1211 of file G4VEmProcess.cc.

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

References G4VEmProcess::MaxKinEnergy(), G4EmParameters::MinKinEnergy(), G4VEmProcess::minKinEnergyPrim, G4VEmProcess::PrintWarning(), and G4VEmProcess::theParameters.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PolarizedCompton::G4PolarizedCompton(), and G4RayleighScattering::G4RayleighScattering().

SetParticle()

void G4VEmProcess::SetParticle ( const G4ParticleDefinition *  p )

inlineprotectedinherited

Definition at line 720 of file G4VEmProcess.hh.

{
  particle = p;
  currentParticle = p;
}

References G4VEmProcess::currentParticle, and G4VEmProcess::particle.

Referenced by G4GammaGeneralProcess(), G4eeToHadrons::InitialiseProcess(), PreparePhysicsTable(), and G4VEmProcess::PreparePhysicsTable().

SetPILfactor()

void G4VProcess::SetPILfactor ( G4double  value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager *  procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int  value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType  aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

SetSecondaryParticle()

void G4VEmProcess::SetSecondaryParticle ( const G4ParticleDefinition *  p )

inlineprotectedinherited

Definition at line 728 of file G4VEmProcess.hh.

{
  secondaryParticle = p;
}

References G4VEmProcess::secondaryParticle.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4eeToHadrons::G4eeToHadrons(), G4eplusAnnihilation::G4eplusAnnihilation(), G4GammaConversion::G4GammaConversion(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), and G4PolarizedPhotoElectric::G4PolarizedPhotoElectric().

SetSplineFlag()

void G4VEmProcess::SetSplineFlag ( G4bool  val )

inlineprotectedinherited

Definition at line 742 of file G4VEmProcess.hh.

{
  splineFlag = val;
}

References G4VEmProcess::splineFlag.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4PolarizedCompton::G4PolarizedCompton(), and G4RayleighScattering::G4RayleighScattering().

SetStartFromNullFlag()

void G4VEmProcess::SetStartFromNullFlag ( G4bool  val )

inlineprotectedinherited

Definition at line 735 of file G4VEmProcess.hh.

{
  startFromNull = val;
}

References G4VEmProcess::startFromNull.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4eplusAnnihilation::G4eplusAnnihilation(), G4GammaConversion::G4GammaConversion(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4PolarizedCompton::G4PolarizedCompton(), G4RayleighScattering::G4RayleighScattering(), and G4CoulombScattering::InitialiseProcess().

SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int  value )

inlineinherited

Definition at line 412 of file G4VProcess.hh.

{
  verboseLevel = value;
}

References G4VProcess::verboseLevel.

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4GammaGeneralProcess(), G4hhIonisation::G4hhIonisation(), G4mplIonisation::G4mplIonisation(), G4Transportation::G4Transportation(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

StartTracking()

void G4GammaGeneralProcess::StartTracking ( G4Track *  )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 460 of file G4GammaGeneralProcess.cc.

{
  theNumberOfInteractionLengthLeft = -1.0;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

StorePhysicsTable()

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

overridevirtual

Reimplemented from G4VProcess.

Definition at line 657 of file G4GammaGeneralProcess.cc.

{
  G4bool yes = true;
  if(!isTheMaster) { return yes; }
  if(!thePhotoElectric->StorePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(!theCompton->StorePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(!theConversionEE->StorePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(theRayleigh != nullptr &&
     !theRayleigh->StorePhysicsTable(part, directory, ascii))
    { yes = false; }
 
  for(size_t i=0; i<nTables; ++i) {
    if(theT[i]) {
      G4String nam = (0==i || 2==i || 6==i || 10==i)
    ? "LambdaGeneral" + nameT[i] : "ProbGeneral" + nameT[i];
      G4String fnam =  GetPhysicsTableFileName(part,directory,nam,ascii);
      if(!theHandler->StorePhysicsTable(i, part, fnam, ascii)) { yes = false; }
    }
  }
  return yes;
}

References G4VProcess::GetPhysicsTableFileName(), G4VEmProcess::isTheMaster, nameT, nTables, G4VEmProcess::StorePhysicsTable(), G4EmDataHandler::StorePhysicsTable(), theCompton, theConversionEE, theHandler, thePhotoElectric, theRayleigh, and theT.

StreamInfo()

void G4VEmProcess::StreamInfo ( std::ostream &  outFile, const G4ParticleDefinition &  part, G4bool  rst = false  ) const

privateinherited

Definition at line 477 of file G4VEmProcess.cc.

{
  G4String indent = (rst ? "  " : "");
  out << std::setprecision(6);
  out << G4endl << indent << GetProcessName() << ": ";
  if (!rst) {
    out << " for " << part.GetParticleName();
  }
  if(fXSType != fEmNoIntegral)  { out << " XStype:" << fXSType; }
  if(applyCuts) { out << " applyCuts:1 "; }
  out << " SubType=" << GetProcessSubType();
  if(biasFactor != 1.0) { out << "  BiasingFactor= " << biasFactor; }
  out << " BuildTable=" << buildLambdaTable << 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) {
          out << "      Lambda table from ";
          G4double emin = v->Energy(0);
          G4double emax = v->GetMaxEnergy();
          G4int nbin = v->GetVectorLength() - 1;
          if(emin > minKinEnergy) { out << "threshold "; }
          else { out << G4BestUnit(emin,"Energy"); } 
          out << " to "
              << G4BestUnit(emax,"Energy")
              << ", " << G4lrint(nbin/std::log10(emax/emin))
              << " bins/decade, spline: " 
              << splineFlag << G4endl;
          break;
        }
      }
    } else {
      out << "      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) { 
          out << "      LambdaPrime table from "
              << G4BestUnit(v->Energy(0),"Energy") 
              << " to "
              << G4BestUnit(v->GetMaxEnergy(),"Energy")
              << " in " << v->GetVectorLength()-1
              << " bins " << G4endl;
          break;
        }
      }
    } else {
      out << "      Used LambdaPrime table of " 
               << particle->GetParticleName() << G4endl;
    }
  }
  StreamProcessInfo(out);
  modelManager->DumpModelList(out, verboseLevel);
 
  if(verboseLevel > 2 && buildLambdaTable) {
    out << "      LambdaTable address= " << theLambdaTable << G4endl;
    if(theLambdaTable && particle == &part) { 
      out << (*theLambdaTable) << G4endl;
    }
  }
}

References G4VEmProcess::applyCuts, G4VEmProcess::biasFactor, G4VEmProcess::buildLambdaTable, G4EmModelManager::DumpModelList(), emax, G4PhysicsVector::Energy(), fEmNoIntegral, G4VEmProcess::fXSType, G4BestUnit, G4endl, G4lrint(), G4PhysicsVector::GetMaxEnergy(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4PhysicsVector::GetVectorLength(), G4PhysicsTable::length(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::modelManager, G4VEmProcess::particle, G4VEmProcess::splineFlag, G4VEmProcess::StreamProcessInfo(), G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, and G4VProcess::verboseLevel.

Referenced by G4VEmProcess::BuildPhysicsTable(), and G4VEmProcess::ProcessDescription().

StreamProcessInfo()

virtual void G4VEmProcess::StreamProcessInfo ( std::ostream &  ) const

inlineprotectedvirtualinherited

Reimplemented in G4eeToHadrons, G4CoulombScattering, and G4eplusAnnihilation.

Definition at line 94 of file G4VEmProcess.hh.

{};

Referenced by G4VEmProcess::StreamInfo().

SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double  prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

TotalCrossSectionPerVolume()

G4double G4GammaGeneralProcess::TotalCrossSectionPerVolume ( )

protected

Definition at line 537 of file G4GammaGeneralProcess.cc.

{
  G4double cross = 0.0;
  /*
  G4cout << "#Total: " << preStepKinEnergy << " " << minPEEnergy << " "
         << minEEEnergy << " " << minMMEnergy<< G4endl;
  G4cout << " idxE= " << idxEnergy
     << " idxC= " << currentCoupleIndex << G4endl;
  */
  if(preStepKinEnergy < minPEEnergy) {
    cross = ComputeGeneralLambda(0, 0);
    //G4cout << "XS1: " << cross << G4endl;
    peLambda = thePhotoElectric->GetLambda(preStepKinEnergy, currentCouple, preStepLogE);
    cross += peLambda;
    //G4cout << "XS2: " << cross << G4endl;
 
  } else if(preStepKinEnergy < minEEEnergy) {
    cross = ComputeGeneralLambda(1, 2);
    //G4cout << "XS3: " << cross << G4endl;
 
  } else if(preStepKinEnergy < minMMEnergy) {
    cross = ComputeGeneralLambda(2, 6);
    //G4cout << "XS4: " << cross << G4endl;
 
  } else {
    cross = ComputeGeneralLambda(3, 10);
    //G4cout << "XS5: " << cross << G4endl;
  }
  /*
  G4cout << "xs= " << cross << " idxE= " << idxEnergy
     << " idxC= " << currentCoupleIndex
     << " E= " << energy << G4endl;
  */
  return cross;
}

References ComputeGeneralLambda(), G4VEmProcess::currentCouple, G4VEmProcess::GetLambda(), minEEEnergy, minMMEnergy, minPEEnergy, peLambda, G4VEmProcess::preStepKinEnergy, preStepLogE, and thePhotoElectric.

Referenced by PostStepGetPhysicalInteractionLength().

UseBaseMaterial()

G4bool G4VEmProcess::UseBaseMaterial ( ) const

inlineinherited

Definition at line 777 of file G4VEmProcess.hh.

{
  return baseMat;
}

References G4VEmProcess::baseMat.

Referenced by BuildPhysicsTable(), and G4VEmProcess::BuildPhysicsTable().

Field Documentation

actBinning

G4bool G4VEmProcess::actBinning = false

privateinherited

Definition at line 439 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), and G4VEmProcess::SetLambdaBinning().

actMaxKinEnergy

G4bool G4VEmProcess::actMaxKinEnergy = false

privateinherited

Definition at line 438 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::SetMaxKinEnergy().

actMinKinEnergy

G4bool G4VEmProcess::actMinKinEnergy = false

privateinherited

Definition at line 437 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::SetMinKinEnergy().

aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4ErrorEnergyLoss::AlongStepDoIt(), G4hImpactIonisation::AlongStepDoIt(), G4DNAMolecularDissociation::DecayIt(), G4OpBoundaryProcess::DoAbsorption(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4VProcess::G4VProcess(), G4PhononDownconversion::MakeLTSecondaries(), G4PhononDownconversion::MakeTTSecondaries(), G4SpecialCuts::PostStepDoIt(), G4Channeling::PostStepDoIt(), G4PhononDownconversion::PostStepDoIt(), G4PhononReflection::PostStepDoIt(), G4PhononScattering::PostStepDoIt(), G4StepLimiter::PostStepDoIt(), G4UserSpecialCuts::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4AnnihiToMuPair::PostStepDoIt(), G4GammaConversionToMuons::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4ForwardXrayTR::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4hImpactIonisation::PostStepDoIt(), G4SynchrotronRadiation::PostStepDoIt(), and G4SynchrotronRadiationInMat::PostStepDoIt().

applyCuts

G4bool G4VEmProcess::applyCuts = false

privateinherited

Definition at line 434 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ApplyCuts(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::StreamInfo().

aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

augerID

G4int G4VEmProcess::augerID = _AugerElectron

protectedinherited

Definition at line 420 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), and G4VEmProcess::PostStepDoIt().

basedCoupleIndex

size_t G4VEmProcess::basedCoupleIndex = 0

protectedinherited

Definition at line 424 of file G4VEmProcess.hh.

Referenced by ComputeGeneralLambda(), G4VEmProcess::DefineMaterial(), G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::GetLambdaFromTablePrim(), GetProbability(), and PostStepGetPhysicalInteractionLength().

baseMat

G4bool G4VEmProcess::baseMat = false

protectedinherited

Definition at line 429 of file G4VEmProcess.hh.

Referenced by BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::DefineMaterial(), PostStepGetPhysicalInteractionLength(), PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::UseBaseMaterial().

baseMaterial

const G4Material* G4VEmProcess::baseMaterial = nullptr

privateinherited

Definition at line 364 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeCurrentLambda(), and G4VEmProcess::DefineMaterial().

biasFactor

G4double G4VEmProcess::biasFactor = 1.0

privateinherited

Definition at line 395 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::CrossSectionBiasingFactor(), G4VEmProcess::DefineMaterial(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::SetCrossSectionBiasingFactor(), and G4VEmProcess::StreamInfo().

biasFlag

G4bool G4VEmProcess::biasFlag = false

privateinherited

Definition at line 441 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::StartTracking().

biasID

G4int G4VEmProcess::biasID = _EM

protectedinherited

Definition at line 421 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt().

biasManager

G4EmBiasingManager* G4VEmProcess::biasManager = nullptr

protectedinherited

Definition at line 381 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateSecondaryBiasing(), G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::StartTracking(), and G4VEmProcess::~G4VEmProcess().

buildLambdaTable

G4bool G4VEmProcess::buildLambdaTable = true

privateinherited

Definition at line 433 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetBuildTableFlag(), and G4VEmProcess::StreamInfo().

coupleIdxLambda

size_t G4VEmProcess::coupleIdxLambda = 0

protectedinherited

Definition at line 425 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetCurrentLambda().

currentCouple

const G4MaterialCutsCouple* G4VEmProcess::currentCouple = nullptr

protectedinherited

Definition at line 379 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::Clear(), G4VEmProcess::DefineMaterial(), G4VEmProcess::MaterialCutsCouple(), G4VEmProcess::PostStepDoIt(), PostStepGetPhysicalInteractionLength(), PreparePhysicsTable(), SelectEmProcess(), G4VEmProcess::SelectModel(), and TotalCrossSectionPerVolume().

currentCoupleIndex

size_t G4VEmProcess::currentCoupleIndex = 0

protectedinherited

Definition at line 423 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeCrossSectionPerAtom(), G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::CurrentMaterialCutsCoupleIndex(), G4VEmProcess::CurrentSetup(), G4VEmProcess::DefineMaterial(), G4VEmProcess::GetCurrentLambda(), G4VEmProcess::GetElectronEnergyCut(), G4VEmProcess::GetGammaEnergyCut(), G4VEmProcess::PostStepDoIt(), PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), and G4VEmProcess::SelectModel().

currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

Referenced by G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VProcess::EndTracking(), G4Decay::EndTracking(), G4VProcess::GetCurrentInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::StartTracking(), G4Decay::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

currentMaterial

const G4Material* G4VEmProcess::currentMaterial = nullptr

protectedinherited

Definition at line 380 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DefineMaterial(), PostStepGetPhysicalInteractionLength(), and SelectHadProcess().

currentModel

G4VEmModel* G4VEmProcess::currentModel = nullptr

privateinherited

Definition at line 361 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeCrossSectionPerAtom(), G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::GetCurrentElement(), G4VEmProcess::GetCurrentModel(), G4VEmProcess::GetTargetElement(), G4VEmProcess::GetTargetIsotope(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::SelectModel().

currentParticle

const G4ParticleDefinition* G4VEmProcess::currentParticle = nullptr

privateinherited

Definition at line 354 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeCrossSectionPerAtom(), G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::SetParticle(), and G4VEmProcess::StartTracking().

emModels

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

privateinherited

Definition at line 453 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::EmModel(), and G4VEmProcess::SetEmModel().

enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

factor

G4double G4GammaGeneralProcess::factor = 1.0

protected

Definition at line 165 of file G4GammaGeneralProcess.hh.

Referenced by ComputeGeneralLambda(), and PostStepGetPhysicalInteractionLength().

fFactor

G4double G4VEmProcess::fFactor = 1.0

privateinherited

Definition at line 397 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DefineMaterial(), G4VEmProcess::GetCurrentLambda(), and G4VEmProcess::RecalculateLambda().

fLambda

G4double G4VEmProcess::fLambda = 0.0

privateinherited

Definition at line 398 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetCurrentLambda().

fLambdaEnergy

G4double G4VEmProcess::fLambdaEnergy = 0.0

privateinherited

Definition at line 399 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetCurrentLambda(), and G4VEmProcess::PreparePhysicsTable().

fluoID

G4int G4VEmProcess::fluoID = _Fluorescence

protectedinherited

Definition at line 419 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), and G4VEmProcess::PostStepDoIt().

fParticleChange

G4ParticleChangeForGamma G4VEmProcess::fParticleChange

protectedinherited

Definition at line 448 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::GetParticleChange(), PostStepDoIt(), and G4VEmProcess::PostStepDoIt().

fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

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

fXSType

G4CrossSectionType G4VEmProcess::fXSType = fEmNoIntegral

privateinherited

Definition at line 410 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::CrossSectionType(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SetCrossSectionType(), G4VEmProcess::SetEnergyOfCrossSectionMax(), and G4VEmProcess::StreamInfo().

idxEnergy

size_t G4GammaGeneralProcess::idxEnergy = 0

private

Definition at line 187 of file G4GammaGeneralProcess.hh.

Referenced by ComputeGeneralLambda(), PostStepDoIt(), and PreparePhysicsTable().

idxLambda

size_t G4VEmProcess::idxLambda = 0

protectedinherited

Definition at line 426 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetLambdaFromTable(), and G4VEmProcess::GetLambdaFromTablePrim().

isIon

G4bool G4VEmProcess::isIon = false

privateinherited

Definition at line 440 of file G4VEmProcess.hh.

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

isTheMaster

G4bool G4VEmProcess::isTheMaster = true

protectedinherited

Definition at line 428 of file G4VEmProcess.hh.

Referenced by BuildPhysicsTable(), G4PolarizedAnnihilation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), InitialiseProcess(), PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), ~G4GammaGeneralProcess(), and G4VEmProcess::~G4VEmProcess().

lambdaFactor

G4double G4VEmProcess::lambdaFactor = 0.8

privateinherited

Definition at line 393 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::G4VEmProcess(), and G4VEmProcess::PreparePhysicsTable().

lManager

G4LossTableManager* G4VEmProcess::lManager = nullptr

privateinherited

Definition at line 362 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::~G4VEmProcess().

logLambdaFactor

G4double G4VEmProcess::logLambdaFactor

privateinherited

Definition at line 394 of file G4VEmProcess.hh.

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

mainSecondaries

G4int G4VEmProcess::mainSecondaries = 1

protectedinherited

Definition at line 417 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4eplusAnnihilation::G4eplusAnnihilation(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

massRatio

G4double G4VEmProcess::massRatio = 1.0

privateinherited

Definition at line 396 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::CurrentSetup(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), and G4VEmProcess::StartTracking().

masterProc

const G4VEmProcess* G4VEmProcess::masterProc = nullptr

privateinherited

Definition at line 359 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildPhysicsTable(), and G4VEmProcess::SetEmMasterProcess().

masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

maxKinEnergy

G4double G4VEmProcess::maxKinEnergy

privateinherited

Definition at line 391 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::LambdaPhysicsVector(), G4VEmProcess::MaxKinEnergy(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetMaxKinEnergy(), G4VEmProcess::SetMinKinEnergy(), and G4VEmProcess::StreamInfo().

mfpKinEnergy

G4double G4VEmProcess::mfpKinEnergy = DBL_MAX

protectedinherited

Definition at line 403 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::DefineMaterial(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::StartTracking().

minEEEnergy

G4double G4GammaGeneralProcess::minEEEnergy

private

Definition at line 181 of file G4GammaGeneralProcess.hh.

Referenced by InitialiseProcess(), and TotalCrossSectionPerVolume().

minKinEnergy

G4double G4VEmProcess::minKinEnergy

privateinherited

Definition at line 390 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::LambdaPhysicsVector(), G4VEmProcess::MinKinEnergy(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SetMaxKinEnergy(), G4VEmProcess::SetMinKinEnergy(), and G4VEmProcess::StreamInfo().

minKinEnergyPrim

G4double G4VEmProcess::minKinEnergyPrim = DBL_MAX

privateinherited

Definition at line 392 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::GetCurrentLambda(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetMinKinEnergyPrim(), and G4VEmProcess::StreamInfo().

minMMEnergy

G4double G4GammaGeneralProcess::minMMEnergy

private

Definition at line 182 of file G4GammaGeneralProcess.hh.

Referenced by InitialiseProcess(), and TotalCrossSectionPerVolume().

minPEEnergy

G4double G4GammaGeneralProcess::minPEEnergy

private

Definition at line 180 of file G4GammaGeneralProcess.hh.

Referenced by InitialiseProcess(), and TotalCrossSectionPerVolume().

modelManager

G4EmModelManager* G4VEmProcess::modelManager = nullptr

privateinherited

Definition at line 352 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::AddEmModel(), G4VEmProcess::BuildLambdaTable(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::GetModelByIndex(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SelectModel(), G4VEmProcess::SelectModelForMaterial(), G4VEmProcess::StreamInfo(), and G4VEmProcess::~G4VEmProcess().

nameT

G4String G4GammaGeneralProcess::nameT

staticprivate

Initial value:

=
  {"0","1","2","3","4","5","6","7","8",
   "9","10","11","12","13","14"}

Definition at line 172 of file G4GammaGeneralProcess.hh.

Referenced by RetrievePhysicsTable(), and StorePhysicsTable().

nHighE

size_t G4GammaGeneralProcess::nHighE = 50

private

Definition at line 186 of file G4GammaGeneralProcess.hh.

Referenced by InitialiseProcess().

nLambdaBins

G4int G4VEmProcess::nLambdaBins = 84

privateinherited

Definition at line 413 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::LambdaBinning(), G4VEmProcess::LambdaPhysicsVector(), G4VEmProcess::SetLambdaBinning(), G4VEmProcess::SetMaxKinEnergy(), and G4VEmProcess::SetMinKinEnergy().

nLowE

size_t G4GammaGeneralProcess::nLowE = 40

private

Definition at line 185 of file G4GammaGeneralProcess.hh.

Referenced by InitialiseProcess().

nTables

const size_t G4GammaGeneralProcess::nTables = 15

staticprivate

Definition at line 170 of file G4GammaGeneralProcess.hh.

Referenced by BuildPhysicsTable(), InitialiseProcess(), RetrievePhysicsTable(), and StorePhysicsTable().

numberOfModels

G4int G4VEmProcess::numberOfModels = 0

privateinherited

Definition at line 412 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::NumberOfModels(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::SelectModel().

particle

const G4ParticleDefinition* G4VEmProcess::particle = nullptr

privateinherited

Definition at line 353 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), emcalc_gui.MainWindow::cb_select_particle(), emcalc_gui.MainWindow::cb_show_plot(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::Particle(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::ProcessDescription(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEmProcess::SetParticle(), G4VEmProcess::StorePhysicsTable(), and G4VEmProcess::StreamInfo().

peLambda

G4double G4GammaGeneralProcess::peLambda = 0.0

private

Definition at line 183 of file G4GammaGeneralProcess.hh.

Referenced by PostStepDoIt(), and TotalCrossSectionPerVolume().

pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4ImportanceProcess::AlongStepDoIt(), G4WeightCutOffProcess::AlongStepDoIt(), G4WeightWindowProcess::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VContinuousProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousProcess::AlongStepDoIt(), G4ParallelWorldProcess::AlongStepDoIt(), G4ParallelWorldScoringProcess::AlongStepDoIt(), G4VITRestProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4ScoreSplittingProcess::AtRestDoIt(), G4VITRestDiscreteProcess::AtRestDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4Decay::G4Decay(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4RadioactiveDecay::G4RadioactiveDecay(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4Transportation::G4Transportation(), G4UnknownDecay::G4UnknownDecay(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4VProcess::G4VProcess(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VITDiscreteProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4NeutronKiller::PostStepDoIt(), G4VITRestDiscreteProcess::PostStepDoIt(), G4LowECapture::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), and G4VTransitionRadiation::PostStepDoIt().

preStepKinEnergy

G4double G4VEmProcess::preStepKinEnergy = 0.0

protectedinherited

Definition at line 404 of file G4VEmProcess.hh.

Referenced by ComputeGeneralLambda(), GetProbability(), PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), SelectEmProcess(), and TotalCrossSectionPerVolume().

preStepLambda

G4double G4VEmProcess::preStepLambda = 0.0

protectedinherited

Definition at line 406 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::Clear(), G4VEmProcess::ComputeIntegralLambda(), PostStepDoIt(), G4VEmProcess::PostStepDoIt(), PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), and PreparePhysicsTable().

preStepLogE

G4double G4GammaGeneralProcess::preStepLogE = 1.0

protected

Definition at line 164 of file G4GammaGeneralProcess.hh.

Referenced by ComputeGeneralLambda(), GetProbability(), PostStepGetPhysicalInteractionLength(), and TotalCrossSectionPerVolume().

preStepLogKinEnergy

G4double G4VEmProcess::preStepLogKinEnergy = LOG_EKIN_MIN

protectedinherited

Definition at line 405 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PostStepGetPhysicalInteractionLength().

secID

G4int G4VEmProcess::secID = _EM

protectedinherited

Definition at line 418 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

secondaryParticle

const G4ParticleDefinition* G4VEmProcess::secondaryParticle = nullptr

privateinherited

Definition at line 358 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ActivateSecondaryBiasing(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SecondaryParticle(), and G4VEmProcess::SetSecondaryParticle().

secParticles

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

protectedinherited

Definition at line 447 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::G4VEmProcess(), and G4VEmProcess::PostStepDoIt().

selectedProc

G4VProcess* G4GammaGeneralProcess::selectedProc = nullptr

protected

Definition at line 162 of file G4GammaGeneralProcess.hh.

Referenced by GetSelectedProcess(), GetSubProcessName(), GetSubProcessSubType(), PostStepDoIt(), and SelectedProcess().

splineFlag

G4bool G4GammaGeneralProcess::splineFlag = false

private

Definition at line 188 of file G4GammaGeneralProcess.hh.

Referenced by BuildPhysicsTable(), InitialiseProcess(), and RetrievePhysicsTable().

startFromNull

G4bool G4VEmProcess::startFromNull = false

privateinherited

Definition at line 435 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), and G4VEmProcess::SetStartFromNullFlag().

theCompton

G4VEmProcess* G4GammaGeneralProcess::theCompton = nullptr

private

Definition at line 175 of file G4GammaGeneralProcess.hh.

Referenced by AddEmProcess(), BuildPhysicsTable(), GetEmProcess(), InitialiseProcess(), PostStepDoIt(), PreparePhysicsTable(), ProcessDescription(), RetrievePhysicsTable(), and StorePhysicsTable().

theConversionEE

G4VEmProcess* G4GammaGeneralProcess::theConversionEE = nullptr

private

Definition at line 176 of file G4GammaGeneralProcess.hh.

Referenced by AddEmProcess(), BuildPhysicsTable(), GetEmProcess(), InitialiseProcess(), PostStepDoIt(), PreparePhysicsTable(), ProcessDescription(), RetrievePhysicsTable(), and StorePhysicsTable().

theConversionMM

G4GammaConversionToMuons* G4GammaGeneralProcess::theConversionMM = nullptr

private

Definition at line 178 of file G4GammaGeneralProcess.hh.

Referenced by AddMMProcess(), BuildPhysicsTable(), PostStepDoIt(), PreparePhysicsTable(), and ProcessDescription().

theCuts

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

privateinherited

Definition at line 370 of file G4VEmProcess.hh.

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

theCutsElectron

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

privateinherited

Definition at line 372 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetElectronEnergyCut(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

theCutsGamma

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

privateinherited

Definition at line 371 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetGammaEnergyCut(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

theCutsPositron

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

privateinherited

Definition at line 373 of file G4VEmProcess.hh.

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

theData

G4EmDataHandler* G4VEmProcess::theData = nullptr

privateinherited

Definition at line 360 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::~G4VEmProcess().

theDensityFactor

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

privateinherited

Definition at line 386 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DensityFactor(), and G4VEmProcess::G4VEmProcess().

theDensityIdx

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

privateinherited

Definition at line 387 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DensityIndex(), and G4VEmProcess::G4VEmProcess().

theElectron

const G4ParticleDefinition* G4VEmProcess::theElectron = nullptr

privateinherited

Definition at line 356 of file G4VEmProcess.hh.

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

theEnergyOfCrossSectionMax

std::vector<G4double>* G4VEmProcess::theEnergyOfCrossSectionMax = nullptr

protectedinherited

Definition at line 382 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::EnergyOfCrossSectionMax(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SetEnergyOfCrossSectionMax(), and G4VEmProcess::~G4VEmProcess().

theGamma

const G4ParticleDefinition* G4VEmProcess::theGamma = nullptr

privateinherited

Definition at line 355 of file G4VEmProcess.hh.

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

theGammaNuclear

G4HadronicProcess* G4GammaGeneralProcess::theGammaNuclear = nullptr

protected

Definition at line 161 of file G4GammaGeneralProcess.hh.

Referenced by AddHadProcess(), BuildPhysicsTable(), PostStepDoIt(), PreparePhysicsTable(), and ProcessDescription().

theHandler

G4EmDataHandler * G4GammaGeneralProcess::theHandler = nullptr

staticprivate

Definition at line 169 of file G4GammaGeneralProcess.hh.

Referenced by BuildPhysicsTable(), ComputeGeneralLambda(), GetProbability(), InitialiseProcess(), RetrievePhysicsTable(), StorePhysicsTable(), and ~G4GammaGeneralProcess().

theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

theLambdaTable

G4PhysicsTable* G4VEmProcess::theLambdaTable = nullptr

privateinherited

Definition at line 367 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::GetCurrentLambda(), G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::LambdaTable(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::StorePhysicsTable(), and G4VEmProcess::StreamInfo().

theLambdaTablePrim

G4PhysicsTable* G4VEmProcess::theLambdaTablePrim = nullptr

privateinherited

Definition at line 368 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::GetLambdaFromTablePrim(), G4VEmProcess::LambdaTablePrim(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::StorePhysicsTable(), and G4VEmProcess::StreamInfo().

theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4VProcess::ClearNumberOfInteractionLengthLeft(), G4MuonicAtomDecay::DecayIt(), G4VProcess::EndTracking(), G4VProcess::GetNumberOfInteractionLengthLeft(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::StartTracking(), StartTracking(), G4VEmProcess::StartTracking(), G4VEnergyLossProcess::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

theParameters

G4EmParameters* G4VEmProcess::theParameters = nullptr

privateinherited

Definition at line 363 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::PolarAngleLimit(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::PrintWarning(), and G4VEmProcess::SetMinKinEnergyPrim().

thePhotoElectric

G4VEmProcess* G4GammaGeneralProcess::thePhotoElectric = nullptr

private

Definition at line 174 of file G4GammaGeneralProcess.hh.

Referenced by AddEmProcess(), BuildPhysicsTable(), GetEmProcess(), InitialiseProcess(), PostStepDoIt(), PreparePhysicsTable(), ProcessDescription(), RetrievePhysicsTable(), StorePhysicsTable(), and TotalCrossSectionPerVolume().

thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

thePositron

const G4ParticleDefinition* G4VEmProcess::thePositron = nullptr

privateinherited

Definition at line 357 of file G4VEmProcess.hh.

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

theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

theRayleigh

G4VEmProcess* G4GammaGeneralProcess::theRayleigh = nullptr

private

Definition at line 177 of file G4GammaGeneralProcess.hh.

Referenced by AddEmProcess(), BuildPhysicsTable(), GetEmProcess(), InitialiseProcess(), PostStepDoIt(), PreparePhysicsTable(), ProcessDescription(), RetrievePhysicsTable(), and StorePhysicsTable().

theT

G4bool G4GammaGeneralProcess::theT

staticprivate

Initial value:

=
  {true,false,true,true,true,false,true,true,true,
   true,true,true,true,true,true}

Definition at line 171 of file G4GammaGeneralProcess.hh.

Referenced by BuildPhysicsTable(), InitialiseProcess(), PostStepDoIt(), RetrievePhysicsTable(), and StorePhysicsTable().

tripletID

G4int G4VEmProcess::tripletID = _TripletElectron

protectedinherited

Definition at line 422 of file G4VEmProcess.hh.

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

verboseLevel

G4int G4VProcess::verboseLevel = 0

protectedinherited

Definition at line 356 of file G4VProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4LowECapture::AddRegion(), G4CoupledTransportation::AlongStepDoIt(), G4Transportation::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4hImpactIonisation::AntiProtonParametrisedDEDX(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VXTRenergyLoss::BuildAngleTable(), G4VEnergyLossProcess::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4VEmProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLossTable(), G4DNABrownianTransportation::BuildPhysicsTable(), BuildPhysicsTable(), G4LowECapture::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4SynchrotronRadiation::BuildPhysicsTable(), G4VXTRenergyLoss::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4OpRayleigh::CalculateRayleighMeanFreePaths(), G4PolarizedAnnihilation::ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VPhononProcess::CreateSecondary(), G4VProcess::EndTracking(), G4VEmProcess::FindLambdaMax(), G4Cerenkov::G4Cerenkov(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GaussXTRadiator::G4GaussXTRadiator(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PolarizedIonisation::G4PolarizedIonisation(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VXTRenergyLoss::GetAngleVector(), G4ChargeExchangeProcess::GetElementCrossSection(), G4VXTRenergyLoss::GetGasZmuProduct(), G4PhononDownconversion::GetMeanFreePath(), G4PhononScattering::GetMeanFreePath(), G4PolarizedCompton::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4UCNAbsorption::GetMeanFreePath(), G4PolarizedAnnihilation::GetMeanFreePath(), G4PolarizedIonisation::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4VXTRenergyLoss::GetNumberOfPhotons(), G4VXTRenergyLoss::GetPlateZmuProduct(), G4SynchrotronRadiation::GetRandomEnergySR(), G4VProcess::GetVerboseLevel(), G4hhIonisation::InitialiseEnergyLossProcess(), G4eeToHadrons::InitialiseProcess(), G4hImpactIonisation::InitializeMe(), G4UCNBoundaryProcess::MRreflect(), G4UCNBoundaryProcess::MRreflectHigh(), G4DNASecondOrderReaction::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4DNAScavengerProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4hImpactIonisation::ProtonParametrisedDEDX(), G4UCNBoundaryProcess::Reflect(), G4CoupledTransportation::ReportInexactEnergy(), G4CoupledTransportation::ReportMissingLogger(), RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4CoupledTransportation::SetHighLooperThresholds(), G4Transportation::SetHighLooperThresholds(), G4VEnergyLossProcess::SetInverseRangeTable(), G4LowECapture::SetKinEnergyLimit(), G4NeutronKiller::SetKinEnergyLimit(), G4VEnergyLossProcess::SetLambdaTable(), G4CoupledTransportation::SetLowLooperThresholds(), G4Transportation::SetLowLooperThresholds(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4NeutronKiller::SetTimeLimit(), G4VProcess::SetVerboseLevel(), G4Cerenkov::SetVerboseLevel(), G4Scintillation::SetVerboseLevel(), G4OpAbsorption::SetVerboseLevel(), G4OpBoundaryProcess::SetVerboseLevel(), G4OpMieHG::SetVerboseLevel(), G4OpRayleigh::SetVerboseLevel(), G4OpWLS::SetVerboseLevel(), G4OpWLS2::SetVerboseLevel(), G4FastSimulationManagerProcess::SetWorldVolume(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4VProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StoreTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

weightFlag

G4bool G4VEmProcess::weightFlag = false

privateinherited

Definition at line 442 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::SetCrossSectionBiasingFactor().

---

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

• source/physics_lists/constructors/electromagnetic/include/G4GammaGeneralProcess.hh
• source/physics_lists/constructors/electromagnetic/src/G4GammaGeneralProcess.cc