#include <G4DNARotExcitation.hh>

Inheritance diagram for G4DNARotExcitation:

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

	G4DNARotExcitation (const G4String &processName="G4DNARotExcitation")

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

virtual void	InitialiseProcess (const G4ParticleDefinition *)

G4bool	isAlongStepDoItIsEnabled () const

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

	~G4DNARotExcitation ()

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

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 31 of file G4DNARotExcitation.hh.

Constructor & Destructor Documentation

◆ G4DNARotExcitation()

G4DNARotExcitation::G4DNARotExcitation ( const G4String & processName = "G4DNARotExcitation" )

Definition at line 31 of file G4DNARotExcitation.cc.

  : G4VEmProcess( processName ),isInitialised(false)
{
} // constructor

◆ ~G4DNARotExcitation()

G4DNARotExcitation::~G4DNARotExcitation ( )

Definition at line 38 of file G4DNARotExcitation.cc.

38 {

39}

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 G4DNARotExcitation::InitialiseProcess ( const G4ParticleDefinition * )

virtual

Implements G4VEmProcess.

Definition at line 50 of file G4DNARotExcitation.cc.

{
  if(!isInitialised) 
  {
    isInitialised = true;
    SetBuildTableFlag(false);
    if(!EmModel()) SetEmModel(new G4LEPTSRotExcitationModel);
    EmModel()->SetLowEnergyLimit(0.1*CLHEP::eV);
    EmModel()->SetHighEnergyLimit(15.*CLHEP::MeV);
    AddEmModel(1, EmModel());
 
  } 
}

References G4VEmProcess::AddEmModel(), G4VEmProcess::EmModel(), CLHEP::eV, isInitialised, CLHEP::MeV, 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 G4DNARotExcitation::IsApplicable ( const G4ParticleDefinition & particleDef )

virtual

Implements G4VEmProcess.

Definition at line 43 of file G4DNARotExcitation.cc.

                                                                               {
  return( &particleDef == G4Electron::Electron() ||
      &particleDef == G4Positron::Positron() );
}

References G4Electron::Electron(), and G4Positron::Positron().

◆ 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 G4DNARotExcitation::PrintInfo ( )

virtual

Definition at line 65 of file G4DNARotExcitation.cc.

{
  G4cout
    << " Total cross sections computed from " << EmModel()->GetName() << " model"
    << 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);
  }
}