#include <G4VEmProcess.hh>

Inheritance diagram for G4VEmProcess:

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

virtual	~G4VEmProcess ()

virtual G4bool	IsApplicable (const G4ParticleDefinition &p)=0

virtual void	PrintInfo ()=0

void	PreparePhysicsTable (const G4ParticleDefinition &)

void	BuildPhysicsTable (const G4ParticleDefinition &)

void	PrintInfoDefinition ()

void	StartTracking (G4Track *)

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

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

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

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

G4double	CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple)

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

G4double	MeanFreePath (const G4Track &track)

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

void	SetLambdaBinning (G4int nbins)

G4int	LambdaBinning () const

void	SetMinKinEnergy (G4double e)

G4double	MinKinEnergy () const

void	SetMaxKinEnergy (G4double e)

G4double	MaxKinEnergy () const

void	SetMinKinEnergyPrim (G4double e)

const G4PhysicsTable *	LambdaTable () const

const G4ParticleDefinition *	Particle () const

const G4ParticleDefinition *	SecondaryParticle () const

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

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

void	SetModel (G4VEmModel *, G4int index=1)

G4VEmModel *	Model (G4int index=1)

G4VEmModel *	EmModel (G4int index=1)

void	SetEmModel (G4VEmModel *, G4int index=1)

void	UpdateEmModel (const G4String &, G4double, G4double)

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

const G4Element *	GetCurrentElement () const

void	SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)

G4double	CrossSectionBiasingFactor () const

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

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

void	SetPolarAngleLimit (G4double a)

G4double	PolarAngleLimit () const

void	SetLambdaFactor (G4double val)

void	SetIntegral (G4bool val)

G4bool	IsIntegral () const

void	SetApplyCuts (G4bool val)

void	SetBuildTableFlag (G4bool val)

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

	G4VDiscreteProcess (G4VDiscreteProcess &)

virtual	~G4VDiscreteProcess ()

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

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

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0

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

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

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

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

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

virtual G4bool	IsApplicable (const G4ParticleDefinition &)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

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

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

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

virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition , const G4Material )

G4VEmModel *	SelectModel (G4double &kinEnergy, size_t index)

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

G4PhysicsVector *	LambdaPhysicsVector (const G4MaterialCutsCouple *)

G4double	RecalculateLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)

G4ParticleChangeForGamma *	GetParticleChange ()

void	SetParticle (const G4ParticleDefinition *p)

void	SetSecondaryParticle (const G4ParticleDefinition *p)

size_t	CurrentMaterialCutsCoupleIndex () const

G4double	GetGammaEnergyCut ()

G4double	GetElectronEnergyCut ()

void	SetStartFromNullFlag (G4bool val)

void	SetSplineFlag (G4bool val)

virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)=0

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

void	ClearNumberOfInteractionLengthLeft ()

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

Detailed Description

Definition at line 91 of file G4VEmProcess.hh.

Constructor & Destructor Documentation

◆ G4VEmProcess()

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

Definition at line 89 of file G4VEmProcess.cc.

                                                                  :
  G4VDiscreteProcess(name, type),
  secondaryParticle(0),
  buildLambdaTable(true),
  numberOfModels(0),
  theLambdaTable(0),
  theLambdaTablePrim(0),
  theDensityFactor(0),
  theDensityIdx(0),
  integral(false),
  applyCuts(false),
  startFromNull(false),
  splineFlag(true),
  currentModel(0),
  particle(0),
  currentParticle(0),
  currentCouple(0)
{
  SetVerboseLevel(1);
 
  // Size of tables assuming spline
  minKinEnergy = 0.1*keV;
  maxKinEnergy = 10.0*TeV;
  nLambdaBins  = 77;
  minKinEnergyPrim = DBL_MAX;
 
  // default lambda factor
  lambdaFactor  = 0.8;
 
  // default limit on polar angle
  polarAngleLimit = 0.0;
  biasFactor = 1.0;
 
  // particle types
  theGamma     = G4Gamma::Gamma();
  theElectron  = G4Electron::Electron();
  thePositron  = G4Positron::Positron();
 
  pParticleChange = &fParticleChange;
  secParticles.reserve(5);
 
  preStepLambda = 0.0;
  mfpKinEnergy  = DBL_MAX;
 
  modelManager = new G4EmModelManager();
  biasManager  = 0;
  biasFlag     = false; 
  weightFlag   = false;
  (G4LossTableManager::Instance())->Register(this);
  warn = 0;
}

◆ ~G4VEmProcess()

G4VEmProcess::~G4VEmProcess ( )

virtual

Definition at line 143 of file G4VEmProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4VEmProcess destruct " << GetProcessName() 
       << "  " << this << "  " <<  theLambdaTable <<G4endl;
  }
  Clear();
  if(theLambdaTable) {
    theLambdaTable->clearAndDestroy();
    delete theLambdaTable;
  }
  if(theLambdaTablePrim) {
    theLambdaTablePrim->clearAndDestroy();
    delete theLambdaTablePrim;
  }
  delete modelManager;
  delete biasManager;
  (G4LossTableManager::Instance())->DeRegister(this);
}

Member Function Documentation

◆ ActivateForcedInteraction()

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

Definition at line 1046 of file G4VEmProcess.cc.

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

Referenced by G4EmProcessOptions::ActivateForcedInteraction().

◆ ActivateSecondaryBiasing()

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

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

Referenced by G4EmProcessOptions::ActivateSecondaryBiasingForGamma().

◆ AddEmModel()

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

Definition at line 182 of file G4VEmProcess.cc.

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

◆ BuildPhysicsTable()

void G4VEmProcess::BuildPhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Definition at line 336 of file G4VEmProcess.cc.

{
  G4String num = part.GetParticleName();
  if(1 < verboseLevel) {
    G4cout << "G4VEmProcess::BuildPhysicsTable() for "
           << GetProcessName()
           << " and particle " << num
       << " buildLambdaTable= " << buildLambdaTable
           << G4endl;
  }
 
  (G4LossTableManager::Instance())->BuildPhysicsTable(particle);
 
  if(buildLambdaTable || minKinEnergyPrim < maxKinEnergy) {
    BuildLambdaTable();
  }
 
  // explicitly defined printout by particle name
  if(1 < verboseLevel || 
     (0 < verboseLevel && (num == "gamma" || num == "e-" || 
               num == "e+"    || num == "mu+" || 
               num == "mu-"   || num == "proton"|| 
               num == "pi+"   || num == "pi-" || 
               num == "kaon+" || num == "kaon-" || 
               num == "alpha" || num == "anti_proton" || 
               num == "GenericIon")))
    { 
      particle = &part;
      PrintInfoDefinition(); 
    }
 
  if(1 < verboseLevel) {
    G4cout << "G4VEmProcess::BuildPhysicsTable() done for "
           << GetProcessName()
           << " and particle " << num
           << G4endl;
  }
}

Referenced by G4eplusPolarizedAnnihilation::BuildPhysicsTable(), G4PolarizedCompton::BuildPhysicsTable(), and BuildPhysicsTable().

◆ ComputeCrossSectionPerAtom()

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

Definition at line 942 of file G4VEmProcess.cc.

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

◆ CrossSectionBiasingFactor()

G4double G4VEmProcess::CrossSectionBiasingFactor ( ) const

inline

Definition at line 590 of file G4VEmProcess.hh.

{
  return biasFactor;
}

◆ CrossSectionPerVolume()

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

Definition at line 899 of file G4VEmProcess.cc.

{
  // Cross section per atom is calculated
  DefineMaterial(couple);
  G4double cross = 0.0;
  if(theLambdaTable) {
    cross = (*theDensityFactor)[currentCoupleIndex]*
      (((*theLambdaTable)[basedCoupleIndex])->Value(kineticEnergy));
  } else {
    SelectModel(kineticEnergy, currentCoupleIndex);
    cross = currentModel->CrossSectionPerVolume(currentMaterial,
                        currentParticle,kineticEnergy);
  }
 
  if(cross < 0.0) { cross = 0.0; }
  return cross;
}

◆ CurrentMaterialCutsCoupleIndex()

size_t G4VEmProcess::CurrentMaterialCutsCoupleIndex ( ) const

inlineprotected

Definition at line 404 of file G4VEmProcess.hh.

{
  return currentCoupleIndex;
}

Referenced by G4PolarizedCompton::GetMeanFreePath(), G4eplusPolarizedAnnihilation::GetMeanFreePath(), G4eplusPolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), and G4PolarizedCompton::PostStepGetPhysicalInteractionLength().

◆ EmModel()

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

Definition at line 230 of file G4VEmProcess.cc.

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

◆ GetCurrentElement()

const G4Element * G4VEmProcess::GetCurrentElement ( ) const

Definition at line 1019 of file G4VEmProcess.cc.

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

◆ GetElectronEnergyCut()

G4double G4VEmProcess::GetElectronEnergyCut ( )

inlineprotected

Definition at line 418 of file G4VEmProcess.hh.

{
  return (*theCutsElectron)[currentCoupleIndex];
}

◆ GetGammaEnergyCut()

G4double G4VEmProcess::GetGammaEnergyCut ( )

inlineprotected

Definition at line 411 of file G4VEmProcess.hh.

{
  return (*theCutsGamma)[currentCoupleIndex];
}

◆ GetLambda()

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

inline

Definition at line 496 of file G4VEmProcess.hh.

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

Referenced by PostStepDoIt(), and G4AdjointComptonModel::RapidSampleSecondaries().

◆ GetMeanFreePath()

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

protectedvirtual

Implements G4VDiscreteProcess.

Definition at line 920 of file G4VEmProcess.cc.

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

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

◆ GetModelByIndex()

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

Definition at line 247 of file G4VEmProcess.cc.

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

◆ GetParticleChange()

G4ParticleChangeForGamma * G4VEmProcess::GetParticleChange ( )

inlineprotected

Definition at line 653 of file G4VEmProcess.hh.

{
  return &fParticleChange;
}

◆ InitialiseProcess()

virtual void G4VEmProcess::InitialiseProcess ( const G4ParticleDefinition * )

protectedpure virtual

◆ IsApplicable()

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

pure virtual

◆ IsIntegral()

G4bool G4VEmProcess::IsIntegral ( ) const

inline

Definition at line 632 of file G4VEmProcess.hh.

{
  return integral;
}

◆ LambdaBinning()

G4int G4VEmProcess::LambdaBinning ( ) const

inline

Definition at line 546 of file G4VEmProcess.hh.

{
  return nLambdaBins;
}

Referenced by G4eplusPolarizedAnnihilation::BuildAsymmetryTable(), and G4PolarizedCompton::BuildAsymmetryTable().

◆ LambdaPhysicsVector()

G4PhysicsVector * G4VEmProcess::LambdaPhysicsVector ( const G4MaterialCutsCouple * )

protected

Definition at line 1009 of file G4VEmProcess.cc.

{
  G4PhysicsVector* v = 
    new G4PhysicsLogVector(minKinEnergy, maxKinEnergy, nLambdaBins);
  v->SetSpline((G4LossTableManager::Instance())->SplineFlag());
  return v;
}

Referenced by G4eplusPolarizedAnnihilation::BuildAsymmetryTable(), and G4PolarizedCompton::BuildAsymmetryTable().

◆ LambdaTable()

const G4PhysicsTable * G4VEmProcess::LambdaTable ( ) const

inline

Definition at line 597 of file G4VEmProcess.hh.

{
  return theLambdaTable;
}

◆ MaxKinEnergy()

G4double G4VEmProcess::MaxKinEnergy ( ) const

inline

Definition at line 560 of file G4VEmProcess.hh.

{
  return maxKinEnergy;
}

Referenced by G4PolarizedCompton::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), G4PolarizedPhotoElectricEffect::InitialiseProcess(), G4ComptonScattering::InitialiseProcess(), G4CoulombScattering::InitialiseProcess(), G4eplusAnnihilation::InitialiseProcess(), G4GammaConversion::InitialiseProcess(), and G4PhotoElectricEffect::InitialiseProcess().

◆ MeanFreePath()

G4double G4VEmProcess::MeanFreePath ( const G4Track & track )

Definition at line 930 of file G4VEmProcess.cc.

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

Referenced by GetMeanFreePath().

◆ MinKinEnergy()

G4double G4VEmProcess::MinKinEnergy ( ) const

inline

Definition at line 553 of file G4VEmProcess.hh.

{
  return minKinEnergy;
}

Referenced by G4PolarizedCompton::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), G4PolarizedPhotoElectricEffect::InitialiseProcess(), G4ComptonScattering::InitialiseProcess(), G4CoulombScattering::InitialiseProcess(), G4eplusAnnihilation::InitialiseProcess(), G4GammaConversion::InitialiseProcess(), and G4PhotoElectricEffect::InitialiseProcess().

◆ MinPrimaryEnergy()

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

protectedvirtual

Reimplemented in G4CoulombScattering, and G4GammaConversion.

Definition at line 174 of file G4VEmProcess.cc.

{
  return 0.0;
}

◆ Model()

G4VEmModel * G4VEmProcess::Model ( G4int index = 1 )

Definition at line 207 of file G4VEmProcess.cc.

{
  if(warn < 10) { 
    G4cout << "### G4VEmProcess::Model is obsolete method and will be "
       << "removed for the next release." << G4endl;
    G4cout << "    Please, use EmModel" << G4endl;
  } 
  G4VEmModel* p = 0;
  if(index >= 0 && index <  G4int(emModels.size())) { p = emModels[index]; }
  return p;
}

Referenced by G4MuElecElastic::InitialiseProcess(), G4MuElecInelastic::InitialiseProcess(), G4MuElecElastic::PrintInfo(), and G4MuElecInelastic::PrintInfo().

◆ Particle()

const G4ParticleDefinition * G4VEmProcess::Particle ( ) const

inline

Definition at line 604 of file G4VEmProcess.hh.

{
  return particle;
}

◆ PolarAngleLimit()

G4double G4VEmProcess::PolarAngleLimit ( ) const

inline

Definition at line 583 of file G4VEmProcess.hh.

{
  return polarAngleLimit;
}

Referenced by G4CoulombScattering::InitialiseProcess(), G4CoulombScattering::MinPrimaryEnergy(), and G4CoulombScattering::PrintInfo().

◆ PostStepDoIt()

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 632 of file G4VEmProcess.cc.

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

◆ PostStepGetPhysicalInteractionLength()

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 557 of file G4VEmProcess.cc.

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

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

◆ PreparePhysicsTable()

void G4VEmProcess::PreparePhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Definition at line 254 of file G4VEmProcess.cc.

{
  if(!particle) { SetParticle(&part); }
 
  if(part.GetParticleType() == "nucleus" && 
     part.GetParticleSubType() == "generic") {
 
    G4String pname = part.GetParticleName();
    if(pname != "deuteron" && pname != "triton" &&
       pname != "alpha" && pname != "He3" &&
       pname != "alpha+"   && pname != "helium" &&
       pname != "hydrogen") {
 
      particle = G4GenericIon::GenericIon();
    }
  }
 
  if(1 < verboseLevel) {
    G4cout << "G4VEmProcess::PreparePhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
       << " local particle " << particle->GetParticleName() 
           << G4endl;
  }
 
  G4LossTableManager* man = G4LossTableManager::Instance();
  G4LossTableBuilder* bld = man->GetTableBuilder();
 
  man->PreparePhysicsTable(&part, this);
 
  if(particle == &part) {
    Clear();
    InitialiseProcess(particle);
 
    const G4ProductionCutsTable* theCoupleTable=
      G4ProductionCutsTable::GetProductionCutsTable();
    size_t n = theCoupleTable->GetTableSize();
 
    theEnergyOfCrossSectionMax.resize(n, 0.0);
    theCrossSectionMax.resize(n, DBL_MAX);
 
    // initialisation of models
    numberOfModels = modelManager->NumberOfModels();
    for(G4int i=0; i<numberOfModels; ++i) {
      G4VEmModel* mod = modelManager->GetModel(i);
      if(0 == i) { currentModel = mod; }
      mod->SetPolarAngleLimit(polarAngleLimit);
      if(mod->HighEnergyLimit() > maxKinEnergy) {
    mod->SetHighEnergyLimit(maxKinEnergy);
      }
    }
 
    if(man->AtomDeexcitation()) { modelManager->SetFluoFlag(true); }
    theCuts = modelManager->Initialise(particle,secondaryParticle,
                       2.,verboseLevel);
    theCutsGamma    = theCoupleTable->GetEnergyCutsVector(idxG4GammaCut);
    theCutsElectron = theCoupleTable->GetEnergyCutsVector(idxG4ElectronCut);
    theCutsPositron = theCoupleTable->GetEnergyCutsVector(idxG4PositronCut);
 
    // prepare tables
    if(buildLambdaTable){
      theLambdaTable = G4PhysicsTableHelper::PreparePhysicsTable(theLambdaTable);
      bld->InitialiseBaseMaterials(theLambdaTable);
    }
    // high energy table
    if(minKinEnergyPrim < maxKinEnergy){
      theLambdaTablePrim = 
    G4PhysicsTableHelper::PreparePhysicsTable(theLambdaTablePrim);
      bld->InitialiseBaseMaterials(theLambdaTablePrim);
    }
    // forced biasing
    if(biasManager) { 
      biasManager->Initialise(part,GetProcessName(),verboseLevel); 
      biasFlag = false; 
    }
  }
  theDensityFactor = bld->GetDensityFactors();
  theDensityIdx = bld->GetCoupleIndexes();
}

Referenced by G4eplusPolarizedAnnihilation::PreparePhysicsTable(), and G4PolarizedCompton::PreparePhysicsTable().

◆ PrintInfo()

virtual void G4VEmProcess::PrintInfo ( )

pure virtual

◆ PrintInfoDefinition()

void G4VEmProcess::PrintInfoDefinition ( )

Definition at line 481 of file G4VEmProcess.cc.

{
  if(verboseLevel > 0) {
    G4cout << G4endl << GetProcessName() << ":   for  "
           << particle->GetParticleName();
    if(integral)  { G4cout << ", integral: 1 "; }
    if(applyCuts) { G4cout << ", applyCuts: 1 "; }
    G4cout << "    SubType= " << GetProcessSubType();;
    if(biasFactor != 1.0) { G4cout << "   BiasingFactor= " << biasFactor; }
    G4cout << G4endl;
    if(buildLambdaTable) {
      size_t length = theLambdaTable->length();
      for(size_t i=0; i<length; ++i) {
        G4PhysicsVector* v = (*theLambdaTable)[i];
        if(v) { 
      G4cout << "      Lambda table from "
         << G4BestUnit(minKinEnergy,"Energy") 
         << " to "
         << G4BestUnit(v->GetMaxEnergy(),"Energy")
         << " in " << v->GetVectorLength()-1
         << " bins, spline: " 
         << splineFlag
         << G4endl;
      break;
    }
      }
    }
    if(minKinEnergyPrim < maxKinEnergy) {
      size_t length = theLambdaTablePrim->length();
      for(size_t i=0; i<length; ++i) {
        G4PhysicsVector* v = (*theLambdaTablePrim)[i];
        if(v) { 
      G4cout << "      LambdaPrime table from "
         << G4BestUnit(minKinEnergyPrim,"Energy") 
         << " to "
         << G4BestUnit(maxKinEnergy,"Energy")
         << " in " << v->GetVectorLength()-1
         << " bins " 
         << G4endl;
      break;
    }
      }
    }
    PrintInfo();
    modelManager->DumpModelList(verboseLevel);
  }
 
  if(verboseLevel > 2 && buildLambdaTable) {
    G4cout << "      LambdaTable address= " << theLambdaTable << G4endl;
    if(theLambdaTable) { G4cout << (*theLambdaTable) << G4endl; }
  }
}

Referenced by BuildPhysicsTable().

◆ RecalculateLambda()

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

inlineprotected

Definition at line 507 of file G4VEmProcess.hh.

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

◆ RetrievePhysicsTable()

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

virtual

Reimplemented from G4VProcess.

Definition at line 821 of file G4VEmProcess.cc.

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

◆ SecondaryParticle()

const G4ParticleDefinition * G4VEmProcess::SecondaryParticle ( ) const

inline

Definition at line 611 of file G4VEmProcess.hh.

{
  return secondaryParticle;
}

◆ SelectModel()

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

inlineprotected

Definition at line 442 of file G4VEmProcess.hh.

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

Referenced by G4NuclearStopping::AlongStepDoIt(), ComputeCrossSectionPerAtom(), CrossSectionPerVolume(), GetLambda(), PostStepDoIt(), PostStepGetPhysicalInteractionLength(), and RecalculateLambda().

◆ SelectModelForMaterial()

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

inline

Definition at line 454 of file G4VEmProcess.hh.

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

◆ SetApplyCuts()

void G4VEmProcess::SetApplyCuts ( G4bool val )

inline

Definition at line 639 of file G4VEmProcess.hh.

{
  applyCuts = val;
}

Referenced by G4EmProcessOptions::SetApplyCuts().

◆ SetBuildTableFlag()

void G4VEmProcess::SetBuildTableFlag ( G4bool val )

inline

Definition at line 646 of file G4VEmProcess.hh.

{
  buildLambdaTable = val;
}

◆ SetCrossSectionBiasingFactor()

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

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

Referenced by G4EmProcessOptions::SetProcessBiasingFactor().

◆ SetEmModel()

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

Definition at line 221 of file G4VEmProcess.cc.

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

◆ SetIntegral()

void G4VEmProcess::SetIntegral ( G4bool val )

inline

Definition at line 625 of file G4VEmProcess.hh.

{
  if(particle && particle != theGamma) { integral = val; }
}

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

◆ SetLambdaBinning()

void G4VEmProcess::SetLambdaBinning ( G4int nbins )

inline

Definition at line 539 of file G4VEmProcess.hh.

{
  nLambdaBins = nbins;
}

Referenced by G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), and G4eplusPolarizedAnnihilation::InitialiseProcess().

◆ SetLambdaFactor()

void G4VEmProcess::SetLambdaFactor ( G4double val )

inline

Definition at line 618 of file G4VEmProcess.hh.

{
  if(val > 0.0 && val <= 1.0) { lambdaFactor = val; }
}

◆ SetMaxKinEnergy()

void G4VEmProcess::SetMaxKinEnergy ( G4double e )

Definition at line 1100 of file G4VEmProcess.cc.

{
  nLambdaBins = G4lrint(nLambdaBins*std::log(e/minKinEnergy)
            /std::log(maxKinEnergy/minKinEnergy));
  maxKinEnergy = e;
}

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLivermorePolarizedPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4eeToHadrons::InitialiseProcess(), and G4eplusPolarizedAnnihilation::InitialiseProcess().

◆ SetMinKinEnergy()

void G4VEmProcess::SetMinKinEnergy ( G4double e )

Definition at line 1091 of file G4VEmProcess.cc.

{
  nLambdaBins = G4lrint(nLambdaBins*std::log(maxKinEnergy/e)
            /std::log(maxKinEnergy/minKinEnergy));
  minKinEnergy = e;
}

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLivermorePolarizedPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4GammaConversion::G4GammaConversion(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4eplusPolarizedAnnihilation::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), and G4GammaConversion::InitialiseProcess().

◆ SetMinKinEnergyPrim()

void G4VEmProcess::SetMinKinEnergyPrim ( G4double e )

inline

Definition at line 567 of file G4VEmProcess.hh.

{
  minKinEnergyPrim = e;
}

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

◆ SetModel()

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

Definition at line 192 of file G4VEmProcess.cc.

{
  ++warn;
  if(warn < 10) { 
    G4cout << "### G4VEmProcess::SetModel is obsolete method and will be "
       << "removed for the next release." << G4endl;
    G4cout << "    Please, use SetEmModel" << G4endl;
  } 
  G4int n = emModels.size();
  if(index >= n) { for(G4int i=n; i<=index; ++i) {emModels.push_back(0);} }
  emModels[index] = p;
}

Referenced by G4EmDNAPhysicsChemistry::ConstructProcess(), G4MuElecElastic::InitialiseProcess(), and G4MuElecInelastic::InitialiseProcess().

◆ SetParticle()

void G4VEmProcess::SetParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 660 of file G4VEmProcess.hh.

{
  particle = p;
  currentParticle = p;
}

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

◆ SetPolarAngleLimit()

void G4VEmProcess::SetPolarAngleLimit ( G4double a )

inline

Definition at line 574 of file G4VEmProcess.hh.

{
  if(val < 0.0)            { polarAngleLimit = 0.0; }
  else if(val > CLHEP::pi) { polarAngleLimit = CLHEP::pi;  }
  else                     { polarAngleLimit = val; }
}

Referenced by G4EmProcessOptions::SetPolarAngleLimit().

◆ SetSecondaryParticle()

void G4VEmProcess::SetSecondaryParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 668 of file G4VEmProcess.hh.

{
  secondaryParticle = p;
}

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

◆ SetSplineFlag()

void G4VEmProcess::SetSplineFlag ( G4bool val )

inlineprotected

Definition at line 682 of file G4VEmProcess.hh.

{
  splineFlag = val;
}

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

◆ SetStartFromNullFlag()

void G4VEmProcess::SetStartFromNullFlag ( G4bool val )

inlineprotected

Definition at line 675 of file G4VEmProcess.hh.

{
  startFromNull = val;
}

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

◆ StartTracking()

void G4VEmProcess::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

Definition at line 536 of file G4VEmProcess.cc.

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

◆ StorePhysicsTable()

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

virtual

Reimplemented from G4VProcess.

Definition at line 774 of file G4VEmProcess.cc.

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

◆ UpdateEmModel()

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

Definition at line 239 of file G4VEmProcess.cc.

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

Member Data Documentation

◆ fParticleChange

G4ParticleChangeForGamma G4VEmProcess::fParticleChange

protected

Definition at line 374 of file G4VEmProcess.hh.

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

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

Protected Attributes
G4ParticleChangeForGamma	fParticleChange

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4VEmProcess()

◆ ~G4VEmProcess()

Member Function Documentation

◆ ActivateForcedInteraction()

◆ ActivateSecondaryBiasing()

◆ AddEmModel()

◆ BuildPhysicsTable()

◆ ComputeCrossSectionPerAtom()

◆ CrossSectionBiasingFactor()

◆ CrossSectionPerVolume()

◆ CurrentMaterialCutsCoupleIndex()

◆ EmModel()

◆ GetCurrentElement()

◆ GetElectronEnergyCut()

◆ GetGammaEnergyCut()

◆ GetLambda()

◆ GetMeanFreePath()

◆ GetModelByIndex()

◆ GetParticleChange()

◆ InitialiseProcess()

◆ IsApplicable()

◆ IsIntegral()

◆ LambdaBinning()

◆ LambdaPhysicsVector()

◆ LambdaTable()

◆ MaxKinEnergy()

◆ MeanFreePath()

◆ MinKinEnergy()

◆ MinPrimaryEnergy()

◆ Model()

◆ Particle()

◆ PolarAngleLimit()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PreparePhysicsTable()

◆ PrintInfo()

◆ PrintInfoDefinition()

◆ RecalculateLambda()

◆ RetrievePhysicsTable()

◆ SecondaryParticle()

◆ SelectModel()

◆ SelectModelForMaterial()

◆ SetApplyCuts()

◆ SetBuildTableFlag()

◆ SetCrossSectionBiasingFactor()

◆ SetEmModel()

◆ SetIntegral()

◆ SetLambdaBinning()

◆ SetLambdaFactor()

◆ SetMaxKinEnergy()

◆ SetMinKinEnergy()

◆ SetMinKinEnergyPrim()

◆ SetModel()

◆ SetParticle()

◆ SetPolarAngleLimit()

◆ SetSecondaryParticle()

◆ SetSplineFlag()

◆ SetStartFromNullFlag()

◆ StartTracking()

◆ StorePhysicsTable()

◆ UpdateEmModel()

Member Data Documentation

◆ fParticleChange