#include <G4DNAPlasmonExcitation.hh>

Inheritance diagram for G4DNAPlasmonExcitation:

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)

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

	G4DNAPlasmonExcitation (const G4String &processName="DNAPlasmonExcitation", G4ProcessType type=fElectromagnetic)

const G4Element *	GetCurrentElement () const

G4double	GetCurrentInteractionLength () const

const G4VEmModel *	GetCurrentModel () const

virtual G4VEmProcess *	GetEmProcess (const G4String &name)

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

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4int	GetVerboseLevel () const

G4bool	isAlongStepDoItIsEnabled () const

virtual G4bool	IsApplicable (const G4ParticleDefinition &)

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

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

virtual void	PrintInfo ()

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

virtual	~G4DNAPlasmonExcitation ()

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

Protected Member Functions
G4bool	ApplyCuts () const

void	ClearNumberOfInteractionLengthLeft ()

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

const G4Element *	GetTargetElement () const

const G4Isotope *	GetTargetIsotope () const

virtual void	InitialiseProcess (const G4ParticleDefinition *)

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)

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)

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

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	preStepLogKinEnergy = LOG_EKIN_MIN

G4int	secID = _EM

std::vector< G4DynamicParticle * >	secParticles

std::vector< G4double > *	theEnergyOfCrossSectionMax = 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)

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

G4bool	isInitialised

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	minKinEnergy

G4double	minKinEnergyPrim = DBL_MAX

G4EmModelManager *	modelManager = nullptr

G4int	nLambdaBins = 84

G4int	numberOfModels = 0

const G4ParticleDefinition *	particle = nullptr

const G4ParticleDefinition *	secondaryParticle = nullptr

G4bool	splineFlag = true

G4bool	startFromNull = false

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

const G4ParticleDefinition *	thePositron = nullptr

G4bool	weightFlag = false

Detailed Description

Definition at line 42 of file G4DNAPlasmonExcitation.hh.

Constructor & Destructor Documentation

◆ G4DNAPlasmonExcitation()

G4DNAPlasmonExcitation::G4DNAPlasmonExcitation	(	const G4String &	processName = `"DNAPlasmonExcitation"`,
		G4ProcessType	type = `fElectromagnetic`
	)

Definition at line 41 of file G4DNAPlasmonExcitation.cc.

                     :G4VEmProcess (processName, type),
  isInitialised(false)
{
  //SetProcessSubType(fLowEnergyChargeDecrease); //dousatsu temp
}

◆ ~G4DNAPlasmonExcitation()

G4DNAPlasmonExcitation::~G4DNAPlasmonExcitation ( )

virtual

Definition at line 50 of file G4DNAPlasmonExcitation.cc.

51{}

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

◆ AlongStepDoIt()

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

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 90 of file G4VDiscreteProcess.hh.

93 { 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.

76 { 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.

88 { 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.

81 { 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 G4VEmProcess::BuildPhysicsTable ( const G4ParticleDefinition & part )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 307 of file G4VEmProcess.cc.

{
  if(nullptr == masterProc) {
    if(isTheMaster) { masterProc = this; }
    else { masterProc = static_cast<const G4VEmProcess*>(GetMasterProcess());}
  }
 
  G4String num = part.GetParticleName();
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::BuildPhysicsTable() for "
           << GetProcessName()
           << " and particle " << num
           << " buildLambdaTable= " << buildLambdaTable
           << " isTheMaster= " << isTheMaster 
           << "  " << masterProc 
           << G4endl;
  }
 
  if(particle == &part) { 
 
    // worker initialisation
    if(!isTheMaster) {
      theLambdaTable = masterProc->LambdaTable();
      theLambdaTablePrim = masterProc->LambdaTablePrim();
      if(fXSType == fEmOnePeak) {
    SetEnergyOfCrossSectionMax(masterProc->EnergyOfCrossSectionMax());
      }
      baseMat = masterProc->UseBaseMaterial();
 
      // local initialisation of models
      G4bool printing = true;
      for(G4int i=0; i<numberOfModels; ++i) {
        G4VEmModel* mod = GetModelByIndex(i, printing);
        G4VEmModel* mod0= masterProc->GetModelByIndex(i, printing);
        //G4cout << i << ".  " << mod << "   " << mod0 << "  " 
        //     << particle->GetParticleName() << G4endl;
        mod->SetUseBaseMaterials(baseMat);
        mod->InitialiseLocal(particle, mod0);
      }
    // master thread
    } else {
      if(buildLambdaTable || minKinEnergyPrim < maxKinEnergy) {
        BuildLambdaTable();
      }
      if(fXSType == fEmOnePeak) { 
    delete theEnergyOfCrossSectionMax;
    theEnergyOfCrossSectionMax = nullptr;
    SetEnergyOfCrossSectionMax(FindLambdaMax());
      }
    }
  }
  // protection against double printout
  if(theParameters->IsPrintLocked()) { return; }
 
  // explicitly defined printout by particle name
  if(1 < verboseLevel || 
     (0 < verboseLevel && (num == "gamma" || num == "e-" || 
                           num == "e+"    || num == "mu+" || 
                           num == "mu-"   || num == "proton"|| 
                           num == "pi+"   || num == "pi-" || 
                           num == "kaon+" || num == "kaon-" || 
                           num == "alpha" || num == "anti_proton" || 
                           num == "GenericIon"|| num == "alpha++" ||
                           num == "alpha+" || num == "helium" ||
                           num == "hydrogen")))
    { 
      StreamInfo(G4cout, part);
    }
 
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::BuildPhysicsTable() done for "
           << GetProcessName()
           << " and particle " << num
           << " baseMat=" << baseMat
           << G4endl;
  }
}

References G4VEmProcess::baseMat, G4VEmProcess::BuildLambdaTable(), G4VEmProcess::buildLambdaTable, G4VEmProcess::EnergyOfCrossSectionMax(), fEmOnePeak, G4VEmProcess::FindLambdaMax(), G4VEmProcess::fXSType, G4cout, G4endl, G4VProcess::GetMasterProcess(), G4VEmProcess::GetModelByIndex(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VEmModel::InitialiseLocal(), G4EmParameters::IsPrintLocked(), G4VEmProcess::isTheMaster, G4VEmProcess::LambdaTable(), G4VEmProcess::LambdaTablePrim(), G4VEmProcess::masterProc, G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::numberOfModels, G4VEmProcess::particle, G4VEmProcess::SetEnergyOfCrossSectionMax(), G4VEmModel::SetUseBaseMaterials(), G4VEmProcess::StreamInfo(), G4VEmProcess::theEnergyOfCrossSectionMax, G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, G4VEmProcess::theParameters, G4VEmProcess::UseBaseMaterial(), and G4VProcess::verboseLevel.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), G4PolarizedAnnihilation::BuildPhysicsTable(), and G4PolarizedCompton::BuildPhysicsTable().

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

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

◆ 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 G4GammaGeneralProcess::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 G4GammaGeneralProcess::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 G4GammaGeneralProcess::BuildPhysicsTable(), and G4GammaGeneralProcess::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.

◆ 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 * G4VEmProcess::GetEmProcess ( const G4String & name )

virtualinherited

Reimplemented in G4GammaGeneralProcess.

Definition at line 1220 of file G4VEmProcess.cc.

{
  return (nam == GetProcessName()) ? this : nullptr;
}

References G4VProcess::GetProcessName().

Referenced by G4EmCalculator::FindDiscreteProcess().

◆ 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 G4GammaGeneralProcess::BuildPhysicsTable(), G4AdjointComptonModel::RapidSampleSecondaries(), and G4GammaGeneralProcess::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 G4VEmProcess::GetMeanFreePath	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

overrideprotectedvirtualinherited

Implements G4VDiscreteProcess.

Definition at line 988 of file G4VEmProcess.cc.

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

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

Referenced by G4PolarizedCompton::GetMeanFreePath(), and G4PolarizedAnnihilation::GetMeanFreePath().

◆ 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(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::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().

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

◆ GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::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;  
}

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

◆ 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 G4DNAPlasmonExcitation::InitialiseProcess ( const G4ParticleDefinition * p )

protectedvirtual

Implements G4VEmProcess.

Definition at line 62 of file G4DNAPlasmonExcitation.cc.

{
  if(!isInitialised) 
  {
    isInitialised = true;
    SetBuildTableFlag(false);
    
    G4String name = p->GetParticleName();
 
    if(name == "e-" )
    { 
      if(!EmModel())
      {
        SetEmModel(new G4DNAQuinnPlasmonExcitationModel);
        EmModel()->SetLowEnergyLimit (10*eV);
        EmModel()->SetHighEnergyLimit(1*GeV);
      }
      else{
        EmModel()->SetLowEnergyLimit (10*eV);
        EmModel()->SetHighEnergyLimit(1*GeV);
      }
      AddEmModel(1, EmModel());
    }
  } 
}

References G4VEmProcess::AddEmModel(), G4VEmProcess::EmModel(), eV, G4ParticleDefinition::GetParticleName(), GeV, isInitialised, G4InuclParticleNames::name(), G4VEmProcess::SetBuildTableFlag(), G4VEmProcess::SetEmModel(), G4VEmModel::SetHighEnergyLimit(), and G4VEmModel::SetLowEnergyLimit().

◆ 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 G4DNAPlasmonExcitation::IsApplicable ( const G4ParticleDefinition & p )

virtual

Implements G4VEmProcess.

Definition at line 55 of file G4DNAPlasmonExcitation.cc.

{
  return (&p == G4Electron::Electron());
}

References G4Electron::Electron().

◆ 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 G4GammaGeneralProcess::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==()

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 * G4VEmProcess::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

overridevirtualinherited

Reimplemented from G4VDiscreteProcess.

Definition at line 675 of file G4VEmProcess.cc.

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

◆ PostStepGetPhysicalInteractionLength()

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

overridevirtualinherited

Reimplemented from G4VDiscreteProcess.

Definition at line 570 of file G4VEmProcess.cc.

{
  *condition = NotForced;
  G4double x = DBL_MAX;
 
  DefineMaterial(track.GetMaterialCutsCouple());
  preStepKinEnergy    = track.GetKineticEnergy();
  preStepLogKinEnergy = track.GetDynamicParticle()->GetLogKineticEnergy();
  const G4double scaledEnergy = preStepKinEnergy*massRatio;
  SelectModel(scaledEnergy, currentCoupleIndex);
  /*
  G4cout << "PostStepGetPhysicalInteractionLength: idx= " << currentCoupleIndex
         << "  couple: " << currentCouple << G4endl;
  */
  if(!currentModel->IsActive(scaledEnergy)) { 
    theNumberOfInteractionLengthLeft = -1.0;
    currentInteractionLength = DBL_MAX;
    return x; 
  }
 
  // forced biasing only for primary particles
  if(biasManager) {
    if(0 == track.GetParentID()) {
      if(biasFlag && 
         biasManager->ForcedInteractionRegion(currentCoupleIndex)) {
        return biasManager->GetStepLimit(currentCoupleIndex, previousStepSize);
      }
    }
  }
 
  // compute mean free path
  ComputeIntegralLambda(preStepKinEnergy, preStepLogKinEnergy);
 
  // zero cross section
  if(preStepLambda <= 0.0) { 
    theNumberOfInteractionLengthLeft = -1.0;
    currentInteractionLength = DBL_MAX;
 
  } else {
 
    // non-zero cross section
    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;
  }
  return x;
}

References G4VEmProcess::biasFlag, G4VEmProcess::biasManager, G4VEmProcess::ComputeIntegralLambda(), condition(), G4VEmProcess::currentCoupleIndex, G4VProcess::currentInteractionLength, G4VEmProcess::currentModel, DBL_MAX, G4VEmProcess::DefineMaterial(), G4EmBiasingManager::ForcedInteractionRegion(), G4Log(), G4UniformRand, G4Track::GetDynamicParticle(), G4Track::GetKineticEnergy(), G4DynamicParticle::GetLogKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4Track::GetParentID(), G4EmBiasingManager::GetStepLimit(), G4VEmModel::IsActive(), G4VEmProcess::massRatio, G4INCL::Math::max(), NotForced, G4VEmProcess::preStepKinEnergy, G4VEmProcess::preStepLambda, G4VEmProcess::preStepLogKinEnergy, G4VEmProcess::SelectModel(), G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), and G4PolarizedCompton::PostStepGetPhysicalInteractionLength().

◆ 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 G4VEmProcess::PreparePhysicsTable ( const G4ParticleDefinition & part )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 175 of file G4VEmProcess.cc.

{
  isTheMaster = lManager->IsMaster();
  if(nullptr == particle) { SetParticle(&part); }
 
  if(part.GetParticleType() == "nucleus" && 
     part.GetParticleSubType() == "generic") {
 
    G4String pname = part.GetParticleName();
    if(pname != "deuteron" && pname != "triton" &&
       pname != "alpha" && pname != "He3" &&
       pname != "alpha+"   && pname != "helium" &&
       pname != "hydrogen") {
 
      particle = G4GenericIon::GenericIon();
      isIon = true;
    }
  }
 
  if(1 < verboseLevel) {
    G4cout << "G4VEmProcess::PreparePhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << " local particle " << particle->GetParticleName() 
           << G4endl;
  }
 
  if(particle != &part) { return; }
 
  lManager->PreparePhysicsTable(&part, this, isTheMaster);
 
  Clear();
  InitialiseProcess(particle);
 
  G4LossTableBuilder* bld = lManager->GetTableBuilder();
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
 
  // initialisation of the process  
  if(!actMinKinEnergy) { minKinEnergy = theParameters->MinKinEnergy(); }
  if(!actMaxKinEnergy) { maxKinEnergy = theParameters->MaxKinEnergy(); }
 
  if(isTheMaster) { 
    SetVerboseLevel(theParameters->Verbose());
    if(nullptr == theData) { theData = new G4EmDataHandler(2); }
    if(fEmOnePeak == fXSType) { 
      if(nullptr == theEnergyOfCrossSectionMax) {
        theEnergyOfCrossSectionMax = new std::vector<G4double>;
      }
      size_t n = theCoupleTable->GetTableSize();
      theEnergyOfCrossSectionMax->resize(n, DBL_MAX);
    }
  } else {  
    SetVerboseLevel(theParameters->WorkerVerbose()); 
  }
  applyCuts       = theParameters->ApplyCuts();
  lambdaFactor    = theParameters->LambdaFactor();
  logLambdaFactor = G4Log(lambdaFactor);
  theParameters->DefineRegParamForEM(this);
 
  // integral option may be disabled
  if(!theParameters->Integral()) { fXSType = fEmNoIntegral; }
 
  // prepare tables
  if(buildLambdaTable && isTheMaster){
    theLambdaTable = theData->MakeTable(0);
    bld->InitialiseBaseMaterials(theLambdaTable);
  }
  // high energy table
  if(isTheMaster && minKinEnergyPrim < maxKinEnergy){
    theLambdaTablePrim = theData->MakeTable(1);
    bld->InitialiseBaseMaterials(theLambdaTablePrim);
  }
  baseMat = bld->GetBaseMaterialFlag();
 
  // initialisation of models
  numberOfModels = modelManager->NumberOfModels();
  for(G4int i=0; i<numberOfModels; ++i) {
    G4VEmModel* mod = modelManager->GetModel(i);
    if(nullptr == mod) { continue; }
    if(nullptr == currentModel) { currentModel = mod; }
    mod->SetPolarAngleLimit(theParameters->MscThetaLimit());
    mod->SetMasterThread(isTheMaster);
    if(mod->HighEnergyLimit() > maxKinEnergy) {
      mod->SetHighEnergyLimit(maxKinEnergy);
    }
    SetEmModel(mod);
    mod->SetUseBaseMaterials(baseMat);
  }
 
  if(nullptr != lManager->AtomDeexcitation()) { 
    modelManager->SetFluoFlag(true); 
  }
  fLambdaEnergy = 0.0;
 
  theCuts = 
    modelManager->Initialise(particle,secondaryParticle,1.0,verboseLevel);
  theCutsGamma    = theCoupleTable->GetEnergyCutsVector(idxG4GammaCut);
  theCutsElectron = theCoupleTable->GetEnergyCutsVector(idxG4ElectronCut);
  theCutsPositron = theCoupleTable->GetEnergyCutsVector(idxG4PositronCut);
 
  // forced biasing
  if(biasManager) { 
    biasManager->Initialise(part,GetProcessName(),verboseLevel); 
    biasFlag = false;
  }
 
  // defined ID of secondary particles
  G4int stype = GetProcessSubType();
  if(stype == fAnnihilation) {
    secID = _Annihilation;
    tripletID = _TripletGamma;
  } else if(stype == fGammaConversion) {
    secID = _PairProduction;
    mainSecondaries = 2;
  } else if(stype == fPhotoElectricEffect) {
    secID = _PhotoElectron;
  } else if(stype == fComptonScattering) {
    secID = _ComptonElectron;
  } else if(stype >= fLowEnergyElastic) {
    secID = fDNAUnknownModel;
  }  
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::PreparePhysicsTable() done for " 
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << "  baseMat=" << baseMat << G4endl;
  }
}

References _Annihilation, _ComptonElectron, _PairProduction, _PhotoElectron, _TripletGamma, G4VEmProcess::actMaxKinEnergy, G4VEmProcess::actMinKinEnergy, G4EmParameters::ApplyCuts(), G4VEmProcess::applyCuts, G4LossTableManager::AtomDeexcitation(), G4VEmProcess::baseMat, G4VEmProcess::biasFlag, G4VEmProcess::biasManager, G4VEmProcess::buildLambdaTable, G4VEmProcess::Clear(), G4VEmProcess::currentModel, DBL_MAX, G4EmParameters::DefineRegParamForEM(), fAnnihilation, fComptonScattering, fDNAUnknownModel, fEmNoIntegral, fEmOnePeak, fGammaConversion, G4VEmProcess::fLambdaEnergy, fLowEnergyElastic, fPhotoElectricEffect, G4VEmProcess::fXSType, G4cout, G4endl, G4Log(), G4GenericIon::GenericIon(), G4LossTableBuilder::GetBaseMaterialFlag(), G4ProductionCutsTable::GetEnergyCutsVector(), G4EmModelManager::GetModel(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetParticleType(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4VEmModel::HighEnergyLimit(), idxG4ElectronCut, idxG4GammaCut, idxG4PositronCut, G4EmBiasingManager::Initialise(), G4EmModelManager::Initialise(), G4LossTableBuilder::InitialiseBaseMaterials(), G4VEmProcess::InitialiseProcess(), G4EmParameters::Integral(), G4VEmProcess::isIon, G4LossTableManager::IsMaster(), G4VEmProcess::isTheMaster, G4EmParameters::LambdaFactor(), G4VEmProcess::lambdaFactor, G4VEmProcess::lManager, G4VEmProcess::logLambdaFactor, G4VEmProcess::mainSecondaries, G4EmDataHandler::MakeTable(), G4EmParameters::MaxKinEnergy(), G4VEmProcess::maxKinEnergy, G4EmParameters::MinKinEnergy(), G4VEmProcess::minKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::modelManager, G4EmParameters::MscThetaLimit(), CLHEP::detail::n, G4EmModelManager::NumberOfModels(), G4VEmProcess::numberOfModels, G4VEmProcess::particle, eplot::pname, G4LossTableManager::PreparePhysicsTable(), G4VEmProcess::secID, G4VEmProcess::secondaryParticle, G4VEmProcess::SetEmModel(), G4EmModelManager::SetFluoFlag(), G4VEmModel::SetHighEnergyLimit(), G4VEmModel::SetMasterThread(), G4VEmProcess::SetParticle(), G4VEmModel::SetPolarAngleLimit(), G4VEmModel::SetUseBaseMaterials(), G4VProcess::SetVerboseLevel(), G4VEmProcess::theCuts, G4VEmProcess::theCutsElectron, G4VEmProcess::theCutsGamma, G4VEmProcess::theCutsPositron, G4VEmProcess::theData, G4VEmProcess::theEnergyOfCrossSectionMax, G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, G4VEmProcess::theParameters, G4VEmProcess::tripletID, G4EmParameters::Verbose(), G4VProcess::verboseLevel, and G4EmParameters::WorkerVerbose().

Referenced by G4GammaGeneralProcess::PreparePhysicsTable().

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

◆ PrintInfo()

void G4DNAPlasmonExcitation::PrintInfo ( )

virtual

Definition at line 90 of file G4DNAPlasmonExcitation.cc.

{
     G4cout
      << " Total cross sections computed from " 
      << EmModel()->GetName() 
      << G4endl;
}

References G4VEmProcess::EmModel(), G4cout, G4endl, and G4VEmModel::GetName().

◆ 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 G4VEmProcess::ProcessDescription ( std::ostream & outFile ) const

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 1257 of file G4VEmProcess.cc.

{
  if(particle) {
    StreamInfo(out, *particle, true);
  }
}

References G4VEmProcess::particle, and G4VEmProcess::StreamInfo().

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

◆ RetrievePhysicsTable()

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

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 907 of file G4VEmProcess.cc.

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

References G4VEmProcess::buildLambdaTable, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::particle, G4PhysicsTableHelper::RetrievePhysicsTable(), G4VEmProcess::splineFlag, G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, and G4VProcess::verboseLevel.

Referenced by G4GammaGeneralProcess::RetrievePhysicsTable().

◆ SecondaryParticle()

const G4ParticleDefinition * G4VEmProcess::SecondaryParticle ( ) const

inlineinherited

Definition at line 685 of file G4VEmProcess.hh.

{
  return secondaryParticle;
}

References G4VEmProcess::secondaryParticle.

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

◆ 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 G4GammaGeneralProcess::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.

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

◆ 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::G4GammaGeneralProcess(), G4eeToHadrons::InitialiseProcess(), G4GammaGeneralProcess::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::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::G4GammaGeneralProcess(), G4hhIonisation::G4hhIonisation(), G4mplIonisation::G4mplIonisation(), G4Transportation::G4Transportation(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

◆ StartTracking()

void G4VEmProcess::StartTracking ( G4Track * track )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 549 of file G4VEmProcess.cc.

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

References G4VEmProcess::biasFlag, G4VEmProcess::biasManager, G4VEmProcess::currentParticle, DBL_MAX, G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetPDGMass(), G4VEmProcess::isIon, G4VEmProcess::massRatio, G4VEmProcess::mfpKinEnergy, source.hepunit::proton_mass_c2, G4EmBiasingManager::ResetForcedInteraction(), and G4VProcess::theNumberOfInteractionLengthLeft.

◆ StorePhysicsTable()

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

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 859 of file G4VEmProcess.cc.

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

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4VEmProcess::isTheMaster, G4InuclParticleNames::name(), G4VEmProcess::particle, G4PhysicsTable::StorePhysicsTable(), G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, and G4VProcess::verboseLevel.

Referenced by G4GammaGeneralProcess::StorePhysicsTable().

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

94{};

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

◆ UseBaseMaterial()

G4bool G4VEmProcess::UseBaseMaterial ( ) const

inlineinherited

Definition at line 777 of file G4VEmProcess.hh.

{
  return baseMat;
}

References G4VEmProcess::baseMat.

Referenced by G4GammaGeneralProcess::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.

◆ 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 G4GammaGeneralProcess::ComputeGeneralLambda(), G4VEmProcess::DefineMaterial(), G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::GetLambdaFromTablePrim(), G4GammaGeneralProcess::GetProbability(), and G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength().

◆ baseMat

G4bool G4VEmProcess::baseMat = false

protectedinherited

Definition at line 429 of file G4VEmProcess.hh.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::DefineMaterial(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::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(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PreparePhysicsTable(), G4GammaGeneralProcess::SelectEmProcess(), G4VEmProcess::SelectModel(), and G4GammaGeneralProcess::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(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), and G4VEmProcess::SelectModel().

◆ currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

◆ currentMaterial

const G4Material* G4VEmProcess::currentMaterial = nullptr

protectedinherited

Definition at line 380 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DefineMaterial(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), and G4GammaGeneralProcess::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().

◆ 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(), G4GammaGeneralProcess::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().

◆ idxLambda

size_t G4VEmProcess::idxLambda = 0

protectedinherited

Definition at line 426 of file G4VEmProcess.hh.

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

◆ isInitialised

G4bool G4DNAPlasmonExcitation::isInitialised

private

Definition at line 66 of file G4DNAPlasmonExcitation.hh.

Referenced by InitialiseProcess().

◆ 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 G4GammaGeneralProcess::BuildPhysicsTable(), G4PolarizedAnnihilation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4GammaGeneralProcess::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4GammaGeneralProcess::~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().

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

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

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

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

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

◆ preStepKinEnergy

G4double G4VEmProcess::preStepKinEnergy = 0.0

protectedinherited

Definition at line 404 of file G4VEmProcess.hh.

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

◆ preStepLambda

G4double G4VEmProcess::preStepLambda = 0.0

protectedinherited

Definition at line 406 of file G4VEmProcess.hh.

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

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

◆ splineFlag

G4bool G4VEmProcess::splineFlag = true

privateinherited

Definition at line 436 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::LambdaPhysicsVector(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetSplineFlag(), and G4VEmProcess::StreamInfo().

◆ startFromNull

G4bool G4VEmProcess::startFromNull = false

privateinherited

Definition at line 435 of file G4VEmProcess.hh.

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

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

◆ theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::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.

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

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

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

◆ 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/processes/electromagnetic/dna/processes/include/G4DNAPlasmonExcitation.hh
source/processes/electromagnetic/dna/processes/src/G4DNAPlasmonExcitation.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4DNAPlasmonExcitation()

◆ ~G4DNAPlasmonExcitation()

Member Function Documentation

◆ ActivateForcedInteraction()

◆ ActivateSecondaryBiasing()

◆ AddEmModel()

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AlongStepGPIL()

◆ ApplyCuts()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ AtRestGPIL()

◆ BuildLambdaTable()

◆ BuildPhysicsTable()

◆ BuildWorkerPhysicsTable()

◆ Clear()

◆ ClearNumberOfInteractionLengthLeft()

◆ ComputeCrossSectionPerAtom()

◆ ComputeCurrentLambda()

◆ ComputeIntegralLambda()

◆ CrossSectionBiasingFactor()

◆ CrossSectionPerVolume()

◆ CrossSectionType()

◆ CurrentMaterialCutsCoupleIndex()

◆ CurrentSetup()

◆ DefineMaterial()

◆ DensityFactor()

◆ DensityIndex()

◆ DumpInfo()

◆ EmModel()

◆ EndTracking()

◆ EnergyOfCrossSectionMax()

◆ FindLambdaMax()

◆ GetCurrentElement()

◆ GetCurrentInteractionLength()

◆ GetCurrentLambda() [1/2]

◆ GetCurrentLambda() [2/2]

◆ GetCurrentModel()

◆ GetElectronEnergyCut()

◆ GetEmProcess()

◆ GetGammaEnergyCut()

◆ GetLambda() [1/2]

◆ GetLambda() [2/2]

◆ GetLambdaFromTable() [1/2]

◆ GetLambdaFromTable() [2/2]

◆ GetLambdaFromTablePrim() [1/2]

◆ GetLambdaFromTablePrim() [2/2]

◆ GetMasterProcess()

◆ GetMeanFreePath()

◆ GetModelByIndex()

◆ GetNumberOfInteractionLengthLeft()

◆ GetParticleChange()

◆ GetPhysicsTableFileName()

◆ GetPILfactor()

◆ GetProcessManager()

◆ GetProcessName()

◆ GetProcessSubType()

◆ GetProcessType()

◆ GetProcessTypeName()

◆ GetTargetElement()

◆ GetTargetIsotope()

◆ GetTotalNumberOfInteractionLengthTraversed()

◆ GetVerboseLevel()

◆ InitialiseProcess()

◆ isAlongStepDoItIsEnabled()

◆ IsApplicable()

◆ isAtRestDoItIsEnabled()

◆ isPostStepDoItIsEnabled()

◆ LambdaBinning()

◆ LambdaPhysicsVector()

◆ LambdaTable()