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

G4PhysicsTable *	LambdaTable () const

G4PhysicsTable *	LambdaTablePrim () const

const G4ParticleDefinition *	Particle () const

const G4ParticleDefinition *	SecondaryParticle () const

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

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

G4VEmModel *	EmModel (G4int index=1) const

void	SetEmModel (G4VEmModel *, G4int index=1)

void	UpdateEmModel (const G4String &, G4double, G4double)

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

const G4Element *	GetCurrentElement () const

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	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

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

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

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

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

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

virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition , const G4Material )

G4VEmModel *	SelectModel (G4double &kinEnergy, size_t index)

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)

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 92 of file G4VEmProcess.hh.

Constructor & Destructor Documentation

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

Definition at line 90 of file G4VEmProcess.cc.

References DBL_MAX, G4Electron::Electron(), fParticleChange, G4Gamma::Gamma(), G4VProcess::GetProcessName(), G4LossTableManager::Instance(), python.hepunit::keV, G4Positron::Positron(), G4VProcess::pParticleChange, G4LossTableManager::Register(), G4VParticleChange::SetSecondaryWeightByProcess(), G4VProcess::SetVerboseLevel(), and python.hepunit::TeV.

                                                                   :
   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;
   fParticleChange.SetSecondaryWeightByProcess(true);
   secParticles.reserve(5);
 
   preStepLambda = 0.0;
   mfpKinEnergy  = DBL_MAX;
 
   idxLambda = idxLambdaPrim = 0;
 
   modelManager = new G4EmModelManager();
   biasManager  = 0;
   biasFlag     = false; 
   weightFlag   = false;
   lManager = G4LossTableManager::Instance();
   lManager->Register(this);
   secID = fluoID = augerID = biasID = -1;
   mainSecondaries = 100;
   if("phot" == GetProcessName() || "compt" == GetProcessName()) { 
     mainSecondaries = 1; 
   }
 }

G4VEmProcess::~G4VEmProcess ( )

virtual

Definition at line 152 of file G4VEmProcess.cc.

References G4LossTableManager::DeRegister(), G4cout, G4endl, G4VProcess::GetProcessName(), G4LossTableManager::IsMaster(), and G4VProcess::verboseLevel.

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

Member Function Documentation

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

Definition at line 1081 of file G4VEmProcess.cc.

References G4EmBiasingManager::ActivateForcedInteraction(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), python.hepunit::mm, and G4VProcess::verboseLevel.

Referenced by G4EmProcessOptions::ActivateForcedInteraction().

 {
   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);
 }

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

Definition at line 1101 of file G4VEmProcess.cc.

References G4EmBiasingManager::ActivateSecondaryBiasing(), G4Electron::Electron(), G4cout, G4endl, G4VProcess::GetProcessName(), python.hepunit::MeV, and G4VProcess::verboseLevel.

Referenced by G4EmProcessOptions::ActivateSecondaryBiasingForGamma().

 {
   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;
     }
   }
 }

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

Definition at line 188 of file G4VEmProcess.cc.

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

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

void G4VEmProcess::BuildPhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Definition at line 325 of file G4VEmProcess.cc.

References G4cout, G4endl, G4LossTableBuilder::GetCoupleIndexes(), G4LossTableBuilder::GetDensityFactors(), G4VProcess::GetMasterProcess(), GetModelByIndex(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4LossTableManager::GetTableBuilder(), G4LossTableBuilder::InitialiseBaseMaterials(), G4VEmModel::InitialiseLocal(), LambdaTable(), LambdaTablePrim(), G4EmModelManager::NumberOfModels(), and G4VProcess::verboseLevel.

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

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

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

Definition at line 977 of file G4VEmProcess.cc.

References G4VEmModel::ComputeCrossSectionPerAtom(), SelectModel(), and test::x.

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

G4double G4VEmProcess::CrossSectionBiasingFactor ( ) const

inline

Definition at line 595 of file G4VEmProcess.hh.

 {
   return biasFactor;
 }

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

Definition at line 934 of file G4VEmProcess.cc.

References G4VEmModel::CrossSectionPerVolume(), and SelectModel().

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

size_t G4VEmProcess::CurrentMaterialCutsCoupleIndex ( ) const

inlineprotected

Definition at line 408 of file G4VEmProcess.hh.

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

 {
   return currentCoupleIndex;
 }

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

Definition at line 207 of file G4VEmProcess.cc.

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

const G4Element * G4VEmProcess::GetCurrentElement ( ) const

Definition at line 1054 of file G4VEmProcess.cc.

References G4VEmModel::GetCurrentElement().

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

G4double G4VEmProcess::GetElectronEnergyCut ( )

inlineprotected

Definition at line 422 of file G4VEmProcess.hh.

 {
   return (*theCutsElectron)[currentCoupleIndex];
 }

G4double G4VEmProcess::GetGammaEnergyCut ( )

inlineprotected

Definition at line 415 of file G4VEmProcess.hh.

 {
   return (*theCutsGamma)[currentCoupleIndex];
 }

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

inline

Definition at line 501 of file G4VEmProcess.hh.

References SelectModel().

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

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

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

protectedvirtual

Implements G4VDiscreteProcess.

Definition at line 955 of file G4VEmProcess.cc.

References MeanFreePath(), and NotForced.

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

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

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

Definition at line 224 of file G4VEmProcess.cc.

References G4EmModelManager::GetModel().

Referenced by BuildPhysicsTable().

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

G4ParticleChangeForGamma * G4VEmProcess::GetParticleChange ( )

inlineprotected

Definition at line 665 of file G4VEmProcess.hh.

References fParticleChange.

 {
   return &fParticleChange;
 }

virtual void G4VEmProcess::InitialiseProcess ( const G4ParticleDefinition * )

protectedpure virtual

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

pure virtual

G4bool G4VEmProcess::IsIntegral ( ) const

inline

Definition at line 644 of file G4VEmProcess.hh.

 {
   return integral;
 }

G4int G4VEmProcess::LambdaBinning ( ) const

inline

Definition at line 551 of file G4VEmProcess.hh.

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

 {
   return nLambdaBins;
 }

G4PhysicsVector * G4VEmProcess::LambdaPhysicsVector ( const G4MaterialCutsCouple * )

protected

Definition at line 1044 of file G4VEmProcess.cc.

References G4PhysicsVector::SetSpline(), G4LossTableManager::SplineFlag(), and test::v.

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

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

G4PhysicsTable * G4VEmProcess::LambdaTable ( ) const

inline

Definition at line 602 of file G4VEmProcess.hh.

Referenced by BuildPhysicsTable().

 {
   return theLambdaTable;
 }

G4PhysicsTable * G4VEmProcess::LambdaTablePrim ( ) const

inline

Definition at line 609 of file G4VEmProcess.hh.

Referenced by BuildPhysicsTable().

 {
   return theLambdaTablePrim;
 }

G4double G4VEmProcess::MaxKinEnergy ( ) const

inline

Definition at line 565 of file G4VEmProcess.hh.

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

 {
   return maxKinEnergy;
 }

G4double G4VEmProcess::MeanFreePath ( const G4Track & track )

Definition at line 965 of file G4VEmProcess.cc.

References DBL_MAX, G4Track::GetKineticEnergy(), G4Track::GetMaterialCutsCouple(), and test::x.

Referenced by GetMeanFreePath().

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

G4double G4VEmProcess::MinKinEnergy ( ) const

inline

Definition at line 558 of file G4VEmProcess.hh.

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

 {
   return minKinEnergy;
 }

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

protectedvirtual

Reimplemented in G4GammaConversion, and G4CoulombScattering.

Definition at line 180 of file G4VEmProcess.cc.

 {
   return 0.0;
 }

const G4ParticleDefinition * G4VEmProcess::Particle ( ) const

inline

Definition at line 616 of file G4VEmProcess.hh.

 {
   return particle;
 }

G4double G4VEmProcess::PolarAngleLimit ( ) const

inline

Definition at line 588 of file G4VEmProcess.hh.

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

 {
   return polarAngleLimit;
 }

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 652 of file G4VEmProcess.cc.

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

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 570 of file G4VEmProcess.cc.

References python.hepunit::cm, G4VProcess::currentInteractionLength, DBL_MAX, G4EmBiasingManager::ForcedInteractionRegion(), G4cout, G4endl, G4Log(), G4UniformRand, G4Track::GetKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4Material::GetName(), G4Track::GetParentID(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4EmBiasingManager::GetStepLimit(), G4VEmModel::IsActive(), python.hepunit::MeV, NotForced, SelectModel(), G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::verboseLevel, and test::x.

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

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

void G4VEmProcess::PreparePhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Definition at line 231 of file G4VEmProcess.cc.

References G4LossTableManager::AtomDeexcitation(), DBL_MAX, G4cout, G4endl, G4GenericIon::GenericIon(), G4ProductionCutsTable::GetEnergyCutsVector(), G4VProcess::GetMasterProcess(), G4EmModelManager::GetModel(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetParticleType(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4VEmModel::HighEnergyLimit(), idxG4ElectronCut, idxG4GammaCut, idxG4PositronCut, G4EmBiasingManager::Initialise(), G4EmModelManager::Initialise(), G4LossTableBuilder::InitialiseBaseMaterials(), InitialiseProcess(), n, G4EmModelManager::NumberOfModels(), eplot::pname, G4PhysicsTableHelper::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4PhysicsModelCatalog::Register(), G4EmModelManager::SetFluoFlag(), G4VEmModel::SetHighEnergyLimit(), G4VEmModel::SetMasterThread(), SetParticle(), G4VEmModel::SetPolarAngleLimit(), and G4VProcess::verboseLevel.

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

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

virtual void G4VEmProcess::PrintInfo ( )

pure virtual

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

inlineprotected

Definition at line 512 of file G4VEmProcess.hh.

References SelectModel().

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

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

virtual

Reimplemented from G4VProcess.

Definition at line 856 of file G4VEmProcess.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4PhysicsTable::length(), n, G4PhysicsTableHelper::RetrievePhysicsTable(), G4LossTableManager::SplineFlag(), and G4VProcess::verboseLevel.

 {
   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(lManager->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(lManager->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;
 }

const G4ParticleDefinition * G4VEmProcess::SecondaryParticle ( ) const

inline

Definition at line 623 of file G4VEmProcess.hh.

 {
   return secondaryParticle;
 }

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

inlineprotected

Definition at line 447 of file G4VEmProcess.hh.

References G4EmModelManager::SelectModel(), and G4VEmModel::SetCurrentCouple().

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

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

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

inline

Definition at line 459 of file G4VEmProcess.hh.

References G4EmModelManager::SelectModel().

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

void G4VEmProcess::SetApplyCuts ( G4bool val )

inline

Definition at line 651 of file G4VEmProcess.hh.

Referenced by G4EmProcessOptions::SetApplyCuts().

 {
   applyCuts = val;
 }

void G4VEmProcess::SetBuildTableFlag ( G4bool val )

inline

Definition at line 658 of file G4VEmProcess.hh.

 {
   buildLambdaTable = val;
 }

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

Definition at line 1063 of file G4VEmProcess.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), and G4VProcess::verboseLevel.

Referenced by G4EmProcessOptions::SetProcessBiasingFactor().

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

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

Definition at line 198 of file G4VEmProcess.cc.

References n.

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

void G4VEmProcess::SetIntegral ( G4bool val )

inline

Definition at line 637 of file G4VEmProcess.hh.

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

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

void G4VEmProcess::SetLambdaBinning ( G4int nbins )

inline

Definition at line 544 of file G4VEmProcess.hh.

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

 {
   nLambdaBins = nbins;
 }

void G4VEmProcess::SetLambdaFactor ( G4double val )

inline

Definition at line 630 of file G4VEmProcess.hh.

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

void G4VEmProcess::SetMaxKinEnergy ( G4double e )

Definition at line 1135 of file G4VEmProcess.cc.

References G4lrint().

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

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

void G4VEmProcess::SetMinKinEnergy ( G4double e )

Definition at line 1126 of file G4VEmProcess.cc.

References G4lrint().

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

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

void G4VEmProcess::SetMinKinEnergyPrim ( G4double e )

inline

Definition at line 572 of file G4VEmProcess.hh.

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

 {
   minKinEnergyPrim = e;
 }

void G4VEmProcess::SetParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 672 of file G4VEmProcess.hh.

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

 {
   particle = p;
   currentParticle = p;
 }

void G4VEmProcess::SetPolarAngleLimit ( G4double a )

inline

Definition at line 579 of file G4VEmProcess.hh.

Referenced by G4EmProcessOptions::SetPolarAngleLimit().

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

void G4VEmProcess::SetSecondaryParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 680 of file G4VEmProcess.hh.

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

 {
   secondaryParticle = p;
 }

void G4VEmProcess::SetSplineFlag ( G4bool val )

inlineprotected

Definition at line 694 of file G4VEmProcess.hh.

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

 {
   splineFlag = val;
 }

void G4VEmProcess::SetStartFromNullFlag ( G4bool val )

inlineprotected

Definition at line 687 of file G4VEmProcess.hh.

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

 {
   startFromNull = val;
 }

void G4VEmProcess::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

Definition at line 549 of file G4VEmProcess.cc.

References DBL_MAX, G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4EmBiasingManager::ResetForcedInteraction(), and G4VProcess::theNumberOfInteractionLengthLeft.

 {
   // 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(); 
     }
   }
 }

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

virtual

Reimplemented from G4VProcess.

Definition at line 808 of file G4VEmProcess.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), and G4PhysicsTable::StorePhysicsTable().

 {
   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;
 }

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

Definition at line 216 of file G4VEmProcess.cc.

References G4EmModelManager::UpdateEmModel().

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

Field Documentation

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

Member Function Documentation

Field Documentation