#include <G4EmCalculator.hh>

Inheritance diagram for G4EmCalculator:

Public Member Functions
	G4EmCalculator ()

	~G4EmCalculator ()

G4double	GetDEDX (G4double kinEnergy, const G4ParticleDefinition , const G4Material , const G4Region *r=nullptr)

G4double	GetDEDX (G4double kinEnergy, const G4String &part, const G4String &mat, const G4String &s="world")

G4double	GetRangeFromRestricteDEDX (G4double kinEnergy, const G4ParticleDefinition , const G4Material , const G4Region *r=nullptr)

G4double	GetRangeFromRestricteDEDX (G4double kinEnergy, const G4String &part, const G4String &mat, const G4String &s="world")

G4double	GetCSDARange (G4double kinEnergy, const G4ParticleDefinition , const G4Material , const G4Region *r=nullptr)

G4double	GetCSDARange (G4double kinEnergy, const G4String &part, const G4String &mat, const G4String &s="world")

G4double	GetRange (G4double kinEnergy, const G4ParticleDefinition , const G4Material , const G4Region *r=nullptr)

G4double	GetRange (G4double kinEnergy, const G4String &part, const G4String &mat, const G4String &s="world")

G4double	GetKinEnergy (G4double range, const G4ParticleDefinition , const G4Material , const G4Region *r=nullptr)

G4double	GetKinEnergy (G4double range, const G4String &part, const G4String &mat, const G4String &s="world")

G4double	GetCrossSectionPerVolume (G4double kinEnergy, const G4ParticleDefinition , const G4String &processName, const G4Material , const G4Region *r=nullptr)

G4double	GetCrossSectionPerVolume (G4double kinEnergy, const G4String &part, const G4String &proc, const G4String &mat, const G4String &s="world")

G4double	GetShellIonisationCrossSectionPerAtom (const G4String &part, G4int Z, G4AtomicShellEnumerator shell, G4double kinEnergy)

G4double	GetMeanFreePath (G4double kinEnergy, const G4ParticleDefinition , const G4String &processName, const G4Material , const G4Region *r=nullptr)

G4double	GetMeanFreePath (G4double kinEnergy, const G4String &part, const G4String &proc, const G4String &mat, const G4String &s="world")

void	PrintDEDXTable (const G4ParticleDefinition *)

void	PrintRangeTable (const G4ParticleDefinition *)

void	PrintInverseRangeTable (const G4ParticleDefinition *)

G4double	ComputeDEDX (G4double kinEnergy, const G4ParticleDefinition , const G4String &processName, const G4Material , G4double cut=DBL_MAX)

G4double	ComputeDEDX (G4double kinEnergy, const G4String &part, const G4String &proc, const G4String &mat, G4double cut=DBL_MAX)

G4double	ComputeElectronicDEDX (G4double kinEnergy, const G4ParticleDefinition , const G4Material mat, G4double cut=DBL_MAX)

G4double	ComputeElectronicDEDX (G4double kinEnergy, const G4String &part, const G4String &mat, G4double cut=DBL_MAX)

G4double	ComputeDEDXForCutInRange (G4double kinEnergy, const G4ParticleDefinition , const G4Material mat, G4double rangecut=DBL_MAX)

G4double	ComputeDEDXForCutInRange (G4double kinEnergy, const G4String &part, const G4String &mat, G4double rangecut=DBL_MAX)

G4double	ComputeNuclearDEDX (G4double kinEnergy, const G4ParticleDefinition , const G4Material )

G4double	ComputeNuclearDEDX (G4double kinEnergy, const G4String &part, const G4String &mat)

G4double	ComputeTotalDEDX (G4double kinEnergy, const G4ParticleDefinition , const G4Material , G4double cut=DBL_MAX)

G4double	ComputeTotalDEDX (G4double kinEnergy, const G4String &part, const G4String &mat, G4double cut=DBL_MAX)

G4double	ComputeCrossSectionPerVolume (G4double kinEnergy, const G4ParticleDefinition , const G4String &processName, const G4Material , G4double cut=0.0)

G4double	ComputeCrossSectionPerVolume (G4double kinEnergy, const G4String &part, const G4String &proc, const G4String &mat, G4double cut=0.0)

G4double	ComputeCrossSectionPerAtom (G4double kinEnergy, const G4ParticleDefinition *, const G4String &processName, G4double Z, G4double A, G4double cut=0.0)

G4double	ComputeCrossSectionPerAtom (G4double kinEnergy, const G4String &part, const G4String &processName, const G4Element *, G4double cut=0.0)

G4double	ComputeCrossSectionPerShell (G4double kinEnergy, const G4ParticleDefinition *, const G4String &processName, G4int Z, G4int shellIdx, G4double cut=0.0)

G4double	ComputeCrossSectionPerShell (G4double kinEnergy, const G4String &part, const G4String &processName, const G4Element *, G4int shellIdx, G4double cut=0.0)

G4double	ComputeGammaAttenuationLength (G4double kinEnergy, const G4Material *)

G4double	ComputeShellIonisationCrossSectionPerAtom (const G4String &part, G4int Z, G4AtomicShellEnumerator shell, G4double kinEnergy, const G4Material *mat=nullptr)

G4double	ComputeMeanFreePath (G4double kinEnergy, const G4ParticleDefinition , const G4String &processName, const G4Material , G4double cut=0.0)

G4double	ComputeMeanFreePath (G4double kinEnergy, const G4String &, const G4String &, const G4String &processName, G4double cut=0.0)

G4double	ComputeEnergyCutFromRangeCut (G4double range, const G4ParticleDefinition , const G4Material )

G4double	ComputeEnergyCutFromRangeCut (G4double range, const G4String &, const G4String &)

const G4ParticleDefinition *	FindParticle (const G4String &)

const G4ParticleDefinition *	FindIon (G4int Z, G4int A)

const G4Material *	FindMaterial (const G4String &)

const G4Region *	FindRegion (const G4String &)

const G4MaterialCutsCouple *	FindCouple (const G4Material , const G4Region r=nullptr)

G4VProcess *	FindProcess (const G4ParticleDefinition *part, const G4String &processName)

void	SetupMaterial (const G4Material *)

void	SetupMaterial (const G4String &)

void	SetVerbose (G4int val)

Detailed Description

Definition at line 82 of file G4EmCalculator.hh.

Constructor & Destructor Documentation

G4EmCalculator::G4EmCalculator ( )

Definition at line 93 of file G4EmCalculator.cc.

 {
   manager = G4LossTableManager::Instance();
   nist    = G4NistManager::Instance();
   theParameters = G4EmParameters::Instance();
   corr    = manager->EmCorrections();
   nLocalMaterials    = 0;
   verbose            = 0;
   currentCoupleIndex = 0;
   currentCouple      = nullptr;
   currentMaterial    = cutMaterial = nullptr;
   currentParticle    = nullptr;
   lambdaParticle     = nullptr;
   baseParticle       = nullptr;
   currentLambda      = nullptr;
   currentModel       = nullptr;
   currentProcess     = nullptr;
   curProcess         = nullptr;
   loweModel          = nullptr;
   chargeSquare       = 1.0;
   massRatio          = 1.0;
   mass               = 0.0;
   currentCut         = 0.0;
   cutenergy[0] = cutenergy[1] = cutenergy[2] = DBL_MAX;
   currentParticleName= "";
   currentMaterialName= "";
   currentName        = "";
   lambdaName         = "";
   theGenericIon      = G4GenericIon::GenericIon();
   ionEffCharge       = new G4ionEffectiveCharge();
   ionTable           = G4ParticleTable::GetParticleTable()->GetIonTable();
   isIon              = false;
   isApplicable       = false;
 }

Here is the call graph for this function:

G4EmCalculator::~G4EmCalculator ( )

Definition at line 130 of file G4EmCalculator.cc.

 {
   delete ionEffCharge;
   for (G4int i=0; i<nLocalMaterials; ++i) {
     delete localCouples[i];
   }
 }

Member Function Documentation

G4double G4EmCalculator::ComputeCrossSectionPerAtom	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4String &	processName,
		G4double	Z,
		G4double	A,
		G4double	cut = `0.0`
	)

Definition at line 648 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   if(UpdateParticle(p, kinEnergy)) {
     G4int iz = G4lrint(Z);
     CheckMaterial(iz);
     if(FindEmModel(p, processName, kinEnergy)) {
       G4double e = kinEnergy;
       G4double aCut = std::max(cut, theParameters->LowestElectronEnergy()); 
       if(baseParticle) {
         e *= kinEnergy*massRatio;
         currentModel->InitialiseForElement(baseParticle, iz);
         res = currentModel->ComputeCrossSectionPerAtom(
               baseParticle, e, Z, A, aCut) * chargeSquare;
       } else {
         currentModel->InitialiseForElement(p, iz);
         res = currentModel->ComputeCrossSectionPerAtom(p, e, Z, A, aCut);
       }
       if(verbose>0) {
         G4cout << "E(MeV)= " << kinEnergy/MeV
                << " cross(barn)= " << res/barn
                << "  " <<  p->GetParticleName()
                << " Z= " <<  Z << " A= " << A/(g/mole) << " g/mole"
                << " cut(keV)= " << aCut/keV
                << G4endl;
       }
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeCrossSectionPerAtom	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	processName,
		const G4Element *	elm,
		G4double	cut = `0.0`
	)

inline

Definition at line 513 of file G4EmCalculator.hh.

 {
   return ComputeCrossSectionPerAtom(kinEnergy,FindParticle(particle),
                     processName,
                                     elm->GetZ(),elm->GetN(),cut);
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeCrossSectionPerShell	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4String &	processName,
		G4int	Z,
		G4int	shellIdx,
		G4double	cut = `0.0`
	)

Definition at line 686 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   if(UpdateParticle(p, kinEnergy)) {
     CheckMaterial(Z);
     if(FindEmModel(p, processName, kinEnergy)) {
       G4double e = kinEnergy;
       G4double aCut = std::max(cut, theParameters->LowestElectronEnergy()); 
       if(baseParticle) {
         e *= kinEnergy*massRatio;
         currentModel->InitialiseForElement(baseParticle, Z);
         res = currentModel->ComputeCrossSectionPerShell(baseParticle, Z, shellIdx, 
                                                         e, aCut) * chargeSquare;
       } else {
         currentModel->InitialiseForElement(p, Z);
         res = currentModel->ComputeCrossSectionPerAtom(p, Z, shellIdx, e, aCut);
       }
       if(verbose>0) {
         G4cout << "E(MeV)= " << kinEnergy/MeV
                << " cross(barn)= " << res/barn
                << "  " <<  p->GetParticleName()
                << " Z= " <<  Z << " shellIdx= " << shellIdx 
                << " cut(keV)= " << aCut/keV
            << G4endl;
       }
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeCrossSectionPerShell	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	processName,
		const G4Element *	elm,
		G4int	shellIdx,
		G4double	cut = `0.0`
	)

inline

Definition at line 526 of file G4EmCalculator.hh.

 {
   return ComputeCrossSectionPerShell(kinEnergy, FindParticle(part), 
                      processName, elm->GetZasInt(), 
                      shellIdx, cut);
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeCrossSectionPerVolume	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4String &	processName,
		const G4Material *	mat,
		G4double	cut = `0.0`
	)

Definition at line 613 of file G4EmCalculator.cc.

 {
   SetupMaterial(mat);
   G4double res = 0.0;
   if(UpdateParticle(p, kinEnergy)) {
     if(FindEmModel(p, processName, kinEnergy)) {
       G4double e = kinEnergy;
       G4double aCut = std::max(cut, theParameters->LowestElectronEnergy()); 
       if(baseParticle) {
         e *= kinEnergy*massRatio;
         res = currentModel->CrossSectionPerVolume(
               mat, baseParticle, e, aCut, e) * chargeSquare;
       } else {
         res = currentModel->CrossSectionPerVolume(mat, p, e, aCut, e);
       }
       if(verbose>0) {
         G4cout << "G4EmCalculator::ComputeXSPerVolume: E(MeV)= " << kinEnergy/MeV
                << " cross(cm-1)= " << res*cm
                << " cut(keV)= " << aCut/keV
                << "  " <<  p->GetParticleName()
                << " in " <<  mat->GetName()
                << G4endl;
       }
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeCrossSectionPerVolume	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	proc,
		const G4String &	mat,
		G4double	cut = `0.0`
	)

inline

Definition at line 498 of file G4EmCalculator.hh.

 {
   return ComputeCrossSectionPerVolume(kinEnergy,FindParticle(particle),
                       processName,
                                       FindMaterial(material),cut);
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeDEDX	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4String &	processName,
		const G4Material *	mat,
		G4double	cut = `DBL_MAX`
	)

Definition at line 381 of file G4EmCalculator.cc.

 {
   SetupMaterial(mat);
   G4double res = 0.0;
   if(verbose > 1) {
     G4cout << "### G4EmCalculator::ComputeDEDX: " << p->GetParticleName()
            << " in " << currentMaterialName
            << " e(MeV)= " << kinEnergy/MeV << "  cut(MeV)= " << cut/MeV
            << G4endl;
   }
   if(UpdateParticle(p, kinEnergy)) {
     if(FindEmModel(p, processName, kinEnergy)) {
 
       // Special case of ICRU'73 model
       if(currentModel->GetName() == "ParamICRU73") {
         res = currentModel->ComputeDEDXPerVolume(mat, p, kinEnergy, cut);
         if(verbose > 1) { 
       G4cout <<  " ICRU73 ion E(MeV)= " << kinEnergy << " "; 
       G4cout << currentModel->GetName() << ": DEDX(MeV/mm)= " << res*mm/MeV
              << " DEDX(MeV*cm^2/g)= "
              << res*gram/(MeV*cm2*mat->GetDensity())
              << G4endl;
     }
       } else {
 
     G4double escaled = kinEnergy*massRatio;
     if(baseParticle) {
       res = currentModel->ComputeDEDXPerVolume(
                 mat, baseParticle, escaled, cut) * chargeSquare;
           if(verbose > 1) {
             G4cout <<  baseParticle->GetParticleName()
                    << " Escaled(MeV)= " << escaled;
           } 
         } else {
           res = currentModel->ComputeDEDXPerVolume(mat, p, kinEnergy, cut);
           if(verbose > 1) { G4cout <<  " no basePart E(MeV)= " << kinEnergy << " "; }
         }
         if(verbose > 1) {
       G4cout << currentModel->GetName() << ": DEDX(MeV/mm)= " << res*mm/MeV
              << " DEDX(MeV*cm^2/g)= "
              << res*gram/(MeV*cm2*mat->GetDensity())
              << G4endl;
         }  
 
         // emulate smoothing procedure
         G4double eth = currentModel->LowEnergyLimit();
         // G4cout << "massRatio= " << massRatio << " eth= " << eth << G4endl;
         if(loweModel) {
           G4double res0 = 0.0;
           G4double res1 = 0.0;
           if(baseParticle) {
             res1 = currentModel->ComputeDEDXPerVolume(mat, baseParticle, eth, cut)
                  * chargeSquare;
             res0 = loweModel->ComputeDEDXPerVolume(mat, baseParticle, eth, cut)
                  * chargeSquare;
           } else {
             res1 = currentModel->ComputeDEDXPerVolume(mat, p, eth, cut);
             res0 = loweModel->ComputeDEDXPerVolume(mat, p, eth, cut);
           }
           if(verbose > 1) {
             G4cout << "At boundary energy(MeV)= " << eth/MeV
                    << " DEDX(MeV/mm)= " << res1*mm/MeV
                    << G4endl;
           }
         
           //G4cout << "eth= " << eth << " escaled= " << escaled
           //       << " res0= " << res0 << " res1= "
           //       << res1 <<  "  q2= " << chargeSquare << G4endl;
         
           if(res1 > 0.0 && escaled > 0.0) {
             res *= (1.0 + (res0/res1 - 1.0)*eth/escaled);
           }  
         } 
 
         // low energy correction for ions
         if(isIon) {
           G4double length = CLHEP::nm;
           const G4Region* r = 0;
           const G4MaterialCutsCouple* couple = FindCouple(mat, r);
           G4double eloss = res*length;
           G4double niel  = 0.0;
           dynParticle.SetKineticEnergy(kinEnergy);
           currentModel->GetChargeSquareRatio(p, mat, kinEnergy);
           currentModel->CorrectionsAlongStep(couple,&dynParticle,eloss,niel,length);
           res = eloss/length; 
         
           if(verbose > 1) {
             G4cout << "After Corrections: DEDX(MeV/mm)= " << res*mm/MeV
                    << " DEDX(MeV*cm^2/g)= " << res*gram/(MeV*cm2*mat->GetDensity())
                    << G4endl;
           } 
         }
       }
     }
     if(verbose > 0) {
       G4cout << "Sum: E(MeV)= " << kinEnergy/MeV
              << " DEDX(MeV/mm)= " << res*mm/MeV
              << " DEDX(MeV*cm^2/g)= " << res*gram/(MeV*cm2*mat->GetDensity())
              << " cut(MeV)= " << cut/MeV
              << "  " <<  p->GetParticleName()
              << " in " <<  currentMaterialName
              << " Zi^2= " << chargeSquare
              << " isIon=" << isIon
              << G4endl;
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeDEDX	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	proc,
		const G4String &	mat,
		G4double	cut = `DBL_MAX`
	)

inline

Definition at line 474 of file G4EmCalculator.hh.

 {
   return ComputeDEDX(kinEnergy,FindParticle(particle),processName,
                      FindMaterial(material),cut);
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeDEDXForCutInRange	(	G4double	kinEnergy,
		const G4ParticleDefinition *	part,
		const G4Material *	mat,
		G4double	rangecut = `DBL_MAX`
	)

Definition at line 529 of file G4EmCalculator.cc.

 {
   SetupMaterial(mat);
   G4double dedx = 0.0;
   if(UpdateParticle(part, kinEnergy)) {
 
     G4LossTableManager* lManager = G4LossTableManager::Instance();
     const std::vector<G4VEnergyLossProcess*> vel =
       lManager->GetEnergyLossProcessVector();
     G4int n = vel.size();
 
     if(mat != cutMaterial) {
       cutMaterial = mat;
       cutenergy[0] = ComputeEnergyCutFromRangeCut(rangecut, G4Gamma::Gamma(), mat);
       cutenergy[1] = ComputeEnergyCutFromRangeCut(rangecut, G4Electron::Electron(), mat);
       cutenergy[2] = ComputeEnergyCutFromRangeCut(rangecut, G4Positron::Positron(), mat);
     }
 
     //G4cout << "ComputeElectronicDEDX for " << part->GetParticleName() 
     //           << " n= " << n << G4endl;
  
     for(G4int i=0; i<n; ++i) {
       if(vel[i]) {
         G4VProcess* p = reinterpret_cast<G4VProcess*>(vel[i]);
         if(ActiveForParticle(part, p)) {
           //G4cout << "idx= " << i << " " << (vel[i])->GetProcessName()
           //         << "  " << (vel[i])->Particle()->GetParticleName() << G4endl; 
           const G4ParticleDefinition* sec = (vel[i])->SecondaryParticle();
           G4int idx = 0;
           if(sec == G4Electron::Electron()) { idx = 1; }
           else if(sec == G4Positron::Positron()) { idx = 2; }
 
           dedx += ComputeDEDX(kinEnergy,part,(vel[i])->GetProcessName(),
                               mat,cutenergy[idx]);
         }
       }
     }
   }
   return dedx;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeDEDXForCutInRange	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	mat,
		G4double	rangecut = `DBL_MAX`
	)

inline

Definition at line 451 of file G4EmCalculator.hh.

 {
   return ComputeDEDXForCutInRange(kinEnergy,FindParticle(part),
                   FindMaterial(mat), rangecut);
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeElectronicDEDX	(	G4double	kinEnergy,
		const G4ParticleDefinition *	part,
		const G4Material *	mat,
		G4double	cut = `DBL_MAX`
	)

Definition at line 496 of file G4EmCalculator.cc.

 {
   SetupMaterial(mat);
   G4double dedx = 0.0;
   if(UpdateParticle(part, kinEnergy)) {
 
     G4LossTableManager* lManager = G4LossTableManager::Instance();
     const std::vector<G4VEnergyLossProcess*> vel =
       lManager->GetEnergyLossProcessVector();
     G4int n = vel.size();
 
     //G4cout << "ComputeElectronicDEDX for " << part->GetParticleName() 
     //           << " n= " << n << G4endl;
  
     for(G4int i=0; i<n; ++i) {
       if(vel[i]) {
         G4VProcess* p = reinterpret_cast<G4VProcess*>(vel[i]);
         if(ActiveForParticle(part, p)) {
           //G4cout << "idx= " << i << " " << (vel[i])->GetProcessName()
           //         << "  " << (vel[i])->Particle()->GetParticleName() << G4endl; 
           dedx += ComputeDEDX(kinEnergy,part,(vel[i])->GetProcessName(),mat,cut);
         }
       }
     }
   }
   return dedx;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeElectronicDEDX	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	mat,
		G4double	cut = `DBL_MAX`
	)

inline

Definition at line 441 of file G4EmCalculator.hh.

 {
   return 
     ComputeElectronicDEDX(kinEnergy,FindParticle(part),FindMaterial(mat),cut);
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeEnergyCutFromRangeCut	(	G4double	range,
		const G4ParticleDefinition *	part,
		const G4Material *	mat
	)

Definition at line 778 of file G4EmCalculator.cc.

 {
   return G4ProductionCutsTable::GetProductionCutsTable()->
     ConvertRangeToEnergy(part, mat, range);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeEnergyCutFromRangeCut	(	G4double	range,
		const G4String &	particle,
		const G4String &	material
	)

inline

Definition at line 539 of file G4EmCalculator.hh.

 {
   return ComputeEnergyCutFromRangeCut(range,FindParticle(particle),
                       FindMaterial(material));
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeGammaAttenuationLength	(	G4double	kinEnergy,
		const G4Material *	mat
	)

Definition at line 723 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   const G4ParticleDefinition* gamma = G4Gamma::Gamma();
   res += ComputeCrossSectionPerVolume(kinEnergy, gamma, "conv", mat, 0.0);
   res += ComputeCrossSectionPerVolume(kinEnergy, gamma, "compt", mat, 0.0);
   res += ComputeCrossSectionPerVolume(kinEnergy, gamma, "phot", mat, 0.0);
   res += ComputeCrossSectionPerVolume(kinEnergy, gamma, "Rayl", mat, 0.0);
   if(res > 0.0) { res = 1.0/res; }
   return res;
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeMeanFreePath	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4String &	processName,
		const G4Material *	mat,
		G4double	cut = `0.0`
	)

Definition at line 757 of file G4EmCalculator.cc.

 {
   G4double mfp = DBL_MAX;
   G4double x = ComputeCrossSectionPerVolume(kinEnergy, p, processName, mat, cut);
   if(x > 0.0) { mfp = 1.0/x; }
   if(verbose>1) {
     G4cout << "E(MeV)= " << kinEnergy/MeV
            << " MFP(mm)= " << mfp/mm
            << "  " <<  p->GetParticleName()
            << " in " <<  mat->GetName()
            << G4endl;
   }
   return mfp;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeMeanFreePath	(	G4double	kinEnergy,
		const G4String &	particle,
		const G4String &	processName,
		const G4String &	processName,
		G4double	cut = `0.0`
	)

inline

Definition at line 551 of file G4EmCalculator.hh.

 {
   return ComputeMeanFreePath(kinEnergy,FindParticle(particle),processName,
                              FindMaterial(material),cut);
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeNuclearDEDX	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4Material *	mat
	)

Definition at line 587 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   G4VEmProcess* nucst = FindDiscreteProcess(p, "nuclearStopping");
   if(nucst) {
     G4VEmModel* mod = nucst->GetModelByIndex();
     if(mod) {
       mod->SetFluctuationFlag(false);
       res = mod->ComputeDEDXPerVolume(mat, p, kinEnergy);
     }
   }  
 
   if(verbose > 1) {
     G4cout <<  p->GetParticleName() << " E(MeV)= " << kinEnergy/MeV
            << " NuclearDEDX(MeV/mm)= " << res*mm/MeV
            << " NuclearDEDX(MeV*cm^2/g)= "
            << res*gram/(MeV*cm2*mat->GetDensity())
            << G4endl;
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeNuclearDEDX	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	mat
	)

inline

Definition at line 487 of file G4EmCalculator.hh.

 {
   return ComputeNuclearDEDX(kinEnergy,FindParticle(particle),
                 FindMaterial(material));
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeShellIonisationCrossSectionPerAtom	(	const G4String &	part,
		G4int	Z,
		G4AtomicShellEnumerator	shell,
		G4double	kinEnergy,
		const G4Material *	mat = `nullptr`
	)

Definition at line 738 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   const G4ParticleDefinition* p = FindParticle(particle);
   G4VAtomDeexcitation* ad = manager->AtomDeexcitation();
   if(p && ad) { 
     res = ad->ComputeShellIonisationCrossSectionPerAtom(p, Z, shell, 
                                                         kinEnergy, mat); 
   }
   return res;
 }

Here is the call graph for this function:

G4double G4EmCalculator::ComputeTotalDEDX	(	G4double	kinEnergy,
		const G4ParticleDefinition *	part,
		const G4Material *	mat,
		G4double	cut = `DBL_MAX`
	)

Definition at line 575 of file G4EmCalculator.cc.

 {
   G4double dedx = ComputeElectronicDEDX(kinEnergy,part,mat,cut);
   if(mass > 700.*MeV) { dedx += ComputeNuclearDEDX(kinEnergy,part,mat); }
   return dedx;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::ComputeTotalDEDX	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	mat,
		G4double	cut = `DBL_MAX`
	)

inline

Definition at line 463 of file G4EmCalculator.hh.

 {
   return ComputeTotalDEDX(kinEnergy,FindParticle(part),FindMaterial(mat),cut);
 }

Here is the call graph for this function:

const G4MaterialCutsCouple * G4EmCalculator::FindCouple	(	const G4Material *	material,
		const G4Region *	r = `nullptr`
	)

Definition at line 909 of file G4EmCalculator.cc.

 {
   const G4MaterialCutsCouple* couple = nullptr;
   SetupMaterial(material);
   if(currentMaterial) {
     // Access to materials
     const G4ProductionCutsTable* theCoupleTable=
       G4ProductionCutsTable::GetProductionCutsTable();
     const G4Region* r = region;
     if(r) {
       couple = theCoupleTable->GetMaterialCutsCouple(material,
                                                      r->GetProductionCuts());
     } else {
       G4RegionStore* store = G4RegionStore::GetInstance();
       size_t nr = store->size();
       if(0 < nr) {
         for(size_t i=0; i<nr; ++i) {
           couple = theCoupleTable->GetMaterialCutsCouple(
             material, ((*store)[i])->GetProductionCuts());
           if(couple) { break; }
         }
       }
     }
   }
   if(!couple) {
     G4ExceptionDescription ed;
     ed << "G4EmCalculator::FindCouple: fail for material <" 
        << currentMaterialName << ">";
     if(region) { ed << " and region " << region->GetName(); }
     G4Exception("G4EmCalculator::FindCouple", "em0078",
                 FatalException, ed);
   }
   return couple;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const G4ParticleDefinition * G4EmCalculator::FindIon	(	G4int	Z,
		G4int	A
	)

Definition at line 874 of file G4EmCalculator.cc.

 {
   const G4ParticleDefinition* p = ionTable->GetIon(Z,A,0);
   return p;
 }

Here is the call graph for this function:

const G4Material * G4EmCalculator::FindMaterial ( const G4String & name )

Definition at line 882 of file G4EmCalculator.cc.

 {
   if(name != currentMaterialName) {
     SetupMaterial(G4Material::GetMaterial(name, false));
     if(!currentMaterial) {
       G4cout << "### WARNING: G4EmCalculator::FindMaterial fails to find " 
              << name << G4endl;
     }
   }
   return currentMaterial;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const G4ParticleDefinition * G4EmCalculator::FindParticle ( const G4String & name )

Definition at line 857 of file G4EmCalculator.cc.

 {
   const G4ParticleDefinition* p = 0;
   if(name != currentParticleName) {
     p = G4ParticleTable::GetParticleTable()->FindParticle(name);
     if(!p) {
       G4cout << "### WARNING: G4EmCalculator::FindParticle fails to find " 
              << name << G4endl;
     }
   } else {
     p = currentParticle;
   }
   return p;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4VProcess * G4EmCalculator::FindProcess	(	const G4ParticleDefinition *	part,
		const G4String &	processName
	)

Definition at line 1232 of file G4EmCalculator.cc.

 {
   G4VProcess* proc = 0;
   const G4ProcessManager* procman = part->GetProcessManager();
   G4ProcessVector* pv = procman->GetProcessList();
   G4int nproc = pv->size();
   for(G4int i=0; i<nproc; ++i) {
     if(processName == (*pv)[i]->GetProcessName()) {
       proc = (*pv)[i];
       break;
     }
   }
   return proc;
 }

Here is the call graph for this function:

const G4Region * G4EmCalculator::FindRegion ( const G4String & reg )

Definition at line 896 of file G4EmCalculator.cc.

 {
   const G4Region* r = 0;
   if(reg != "" && reg != "world") {
     r = G4RegionStore::GetInstance()->GetRegion(reg);
   } else {
     r = G4RegionStore::GetInstance()->GetRegion("DefaultRegionForTheWorld");
   }
   return r;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::GetCrossSectionPerVolume	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4String &	processName,
		const G4Material *	mat,
		const G4Region *	r = `nullptr`
	)

Definition at line 273 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   const G4MaterialCutsCouple* couple = FindCouple(mat,region);
 
   if(couple && UpdateParticle(p, kinEnergy)) {
     if(FindEmModel(p, processName, kinEnergy)) {
       G4int idx = couple->GetIndex();
       FindLambdaTable(p, processName, kinEnergy);
 
       G4VEmProcess* emproc = FindDiscreteProcess(p, processName);
       if(emproc) {
     res = emproc->CrossSectionPerVolume(kinEnergy, couple);
       } else if(currentLambda) {
     G4double e = kinEnergy*massRatio;
     res = (((*currentLambda)[idx])->Value(e))*chargeSquare;
       } else {
     res = ComputeCrossSectionPerVolume(kinEnergy, p, processName, mat, 
                                            kinEnergy);
       }
       if(verbose>0) {
     G4cout << "G4EmCalculator::GetXSPerVolume: E(MeV)= " << kinEnergy/MeV
            << " cross(cm-1)= " << res*cm
            << "  " <<  p->GetParticleName()
            << " in " <<  mat->GetName();
     if(verbose>1) 
       G4cout << "  idx= " << idx << "  Escaled((MeV)= " 
          << kinEnergy*massRatio 
          << "  q2= " << chargeSquare; 
     G4cout << G4endl;
       } 
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::GetCrossSectionPerVolume	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	proc,
		const G4String &	mat,
		const G4String &	s = `"world"`
	)

inline

Definition at line 415 of file G4EmCalculator.hh.

 {
   return GetCrossSectionPerVolume(kinEnergy,FindParticle(particle),processName,
                                   FindMaterial(material),FindRegion(reg));
 }

Here is the call graph for this function:

G4double G4EmCalculator::GetCSDARange	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4Material *	mat,
		const G4Region *	r = `nullptr`
	)

Definition at line 204 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   if(!theParameters->BuildCSDARange()) {
     G4ExceptionDescription ed;
     ed << "G4EmCalculator::GetCSDARange: CSDA table is not built; " 
        << " use UI command: /process/eLoss/CSDARange true";
     G4Exception("G4EmCalculator::GetCSDARange", "em0077",
                 JustWarning, ed);
     return res;
   }
 
   const G4MaterialCutsCouple* couple = FindCouple(mat,region);
   if(couple && UpdateParticle(p, kinEnergy)) {
     res = manager->GetCSDARange(p, kinEnergy, couple);
     if(verbose>1) {
       G4cout << " G4EmCalculator::GetCSDARange: E(MeV)= " << kinEnergy/MeV
              << " range(mm)= " << res/mm
              << "  " <<  p->GetParticleName()
              << " in " <<  mat->GetName()
              << G4endl;
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::GetCSDARange	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	mat,
		const G4String &	s = `"world"`
	)

inline

Definition at line 381 of file G4EmCalculator.hh.

 {
   return GetCSDARange(kinEnergy,FindParticle(particle),
           FindMaterial(material),FindRegion(reg));
 }

Here is the call graph for this function:

G4double G4EmCalculator::GetDEDX	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4Material *	mat,
		const G4Region *	r = `nullptr`
	)

Definition at line 140 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   const G4MaterialCutsCouple* couple = FindCouple(mat, region);
   if(couple && UpdateParticle(p, kinEnergy) ) {
     res = manager->GetDEDX(p, kinEnergy, couple);
     
     if(isIon) {
       if(FindEmModel(p, currentProcessName, kinEnergy)) {
         G4double length = CLHEP::nm;
         G4double eloss = res*length;
         //G4cout << "### GetDEDX: E= " << kinEnergy << " dedx0= " << res 
         //       << " de= " << eloss << G4endl;; 
         G4double niel  = 0.0;
         dynParticle.SetKineticEnergy(kinEnergy);
         currentModel->GetChargeSquareRatio(p, mat, kinEnergy);
         currentModel->CorrectionsAlongStep(couple,&dynParticle,eloss,niel,length);
         res = eloss/length; 
              //G4cout << " de1= " << eloss << " res1= " << res 
         //       << " " << p->GetParticleName() <<G4endl;;
       }
     } 
     
     if(verbose>0) {
       G4cout << "G4EmCalculator::GetDEDX: E(MeV)= " << kinEnergy/MeV
              << " DEDX(MeV/mm)= " << res*mm/MeV
              << " DEDX(MeV*cm^2/g)= " << res*gram/(MeV*cm2*mat->GetDensity())
              << "  " <<  p->GetParticleName()
              << " in " <<  mat->GetName()
              << " isIon= " << isIon
              << G4endl;
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::GetDEDX	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	mat,
		const G4String &	s = `"world"`
	)

inline

Definition at line 359 of file G4EmCalculator.hh.

 {
   return GetDEDX(kinEnergy,FindParticle(particle),
          FindMaterial(material),FindRegion(reg));
 }

Here is the call graph for this function:

G4double G4EmCalculator::GetKinEnergy	(	G4double	range,
		const G4ParticleDefinition *	p,
		const G4Material *	mat,
		const G4Region *	r = `nullptr`
	)

Definition at line 251 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   const G4MaterialCutsCouple* couple = FindCouple(mat,region);
   if(couple && UpdateParticle(p, 1.0*GeV)) {
     res = manager->GetEnergy(p, range, couple);
     if(verbose>0) {
       G4cout << "G4EmCalculator::GetKinEnergy: Range(mm)= " << range/mm
              << " KinE(MeV)= " << res/MeV
              << "  " <<  p->GetParticleName()
              << " in " <<  mat->GetName()
              << G4endl;
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::GetKinEnergy	(	G4double	range,
		const G4String &	part,
		const G4String &	mat,
		const G4String &	s = `"world"`
	)

inline

Definition at line 405 of file G4EmCalculator.hh.

 {
   return GetKinEnergy(range,FindParticle(particle),
               FindMaterial(material),FindRegion(reg));
 }

Here is the call graph for this function:

G4double G4EmCalculator::GetMeanFreePath	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4String &	processName,
		const G4Material *	mat,
		const G4Region *	r = `nullptr`
	)

Definition at line 332 of file G4EmCalculator.cc.

 {
   G4double res = DBL_MAX;
   G4double x = GetCrossSectionPerVolume(kinEnergy,p, processName, mat,region);
   if(x > 0.0) { res = 1.0/x; }
   if(verbose>1) {
     G4cout << "G4EmCalculator::GetMeanFreePath: E(MeV)= " << kinEnergy/MeV
            << " MFP(mm)= " << res/mm
            << "  " <<  p->GetParticleName()
            << " in " <<  mat->GetName()
            << G4endl;
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::GetMeanFreePath	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	proc,
		const G4String &	mat,
		const G4String &	s = `"world"`
	)

inline

Definition at line 428 of file G4EmCalculator.hh.

 {
   return GetMeanFreePath(kinEnergy,FindParticle(particle),processName,
                          FindMaterial(material),FindRegion(reg));
 }

Here is the call graph for this function:

G4double G4EmCalculator::GetRange	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4Material *	mat,
		const G4Region *	r = `nullptr`
	)

Definition at line 235 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   if(theParameters->BuildCSDARange()) {
     res = GetCSDARange(kinEnergy, p, mat, region);
   } else {
     res = GetRangeFromRestricteDEDX(kinEnergy, p, mat, region);
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::GetRange	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	mat,
		const G4String &	s = `"world"`
	)

inline

Definition at line 393 of file G4EmCalculator.hh.

 {
   return GetRange(kinEnergy,FindParticle(particle),
           FindMaterial(material),FindRegion(reg));
 }

Here is the call graph for this function:

G4double G4EmCalculator::GetRangeFromRestricteDEDX	(	G4double	kinEnergy,
		const G4ParticleDefinition *	p,
		const G4Material *	mat,
		const G4Region *	r = `nullptr`
	)

Definition at line 181 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   const G4MaterialCutsCouple* couple = FindCouple(mat,region);
   if(couple && UpdateParticle(p, kinEnergy)) {
     res = manager->GetRangeFromRestricteDEDX(p, kinEnergy, couple);
     if(verbose>1) {
       G4cout << " G4EmCalculator::GetRangeFromRestrictedDEDX: E(MeV)= " 
          << kinEnergy/MeV
              << " range(mm)= " << res/mm
              << "  " <<  p->GetParticleName()
              << " in " <<  mat->GetName()
              << G4endl;
     }
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EmCalculator::GetRangeFromRestricteDEDX	(	G4double	kinEnergy,
		const G4String &	part,
		const G4String &	mat,
		const G4String &	s = `"world"`
	)

inline

Definition at line 369 of file G4EmCalculator.hh.

 {
   return GetRangeFromRestricteDEDX(kinEnergy,FindParticle(particle),
                    FindMaterial(material),FindRegion(reg));
 }

Here is the call graph for this function:

G4double G4EmCalculator::GetShellIonisationCrossSectionPerAtom	(	const G4String &	part,
		G4int	Z,
		G4AtomicShellEnumerator	shell,
		G4double	kinEnergy
	)

Definition at line 315 of file G4EmCalculator.cc.

 {
   G4double res = 0.0;
   const G4ParticleDefinition* p = FindParticle(particle);
   G4VAtomDeexcitation* ad = manager->AtomDeexcitation();
   if(p && ad) { 
     res = ad->GetShellIonisationCrossSectionPerAtom(p, Z, shell, kinEnergy); 
   }
   return res;
 }

Here is the call graph for this function:

void G4EmCalculator::PrintDEDXTable ( const G4ParticleDefinition * p )

Definition at line 353 of file G4EmCalculator.cc.

 {
   const G4VEnergyLossProcess* elp = FindEnergyLossProcess(p);
   G4cout << "##### DEDX Table for " << p->GetParticleName() << G4endl;
   if(elp) G4cout << *(elp->DEDXTable()) << G4endl;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4EmCalculator::PrintInverseRangeTable ( const G4ParticleDefinition * p )

Definition at line 371 of file G4EmCalculator.cc.

 {
   const G4VEnergyLossProcess* elp = FindEnergyLossProcess(p);
   G4cout << "### G4EmCalculator: Inverse Range Table for " 
          << p->GetParticleName() << G4endl;
   if(elp) G4cout << *(elp->InverseRangeTable()) << G4endl;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4EmCalculator::PrintRangeTable ( const G4ParticleDefinition * p )

Definition at line 362 of file G4EmCalculator.cc.

 {
   const G4VEnergyLossProcess* elp = FindEnergyLossProcess(p);
   G4cout << "##### Range Table for " << p->GetParticleName() << G4endl;
   if(elp) G4cout << *(elp->RangeTableForLoss()) << G4endl;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4EmCalculator::SetupMaterial ( const G4Material * mat )

Definition at line 1269 of file G4EmCalculator.cc.

 {
   if(mat) {
     currentMaterial = mat;
     currentMaterialName = mat->GetName();
   } else {
     currentMaterial = 0;
     currentMaterialName = "";
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4EmCalculator::SetupMaterial ( const G4String & mname )

Definition at line 1282 of file G4EmCalculator.cc.

 {
   SetupMaterial(nist->FindOrBuildMaterial(mname));
 }

Here is the call graph for this function:

void G4EmCalculator::SetVerbose ( G4int val )

Definition at line 1308 of file G4EmCalculator.cc.

 {
   verbose = verb;
 }

Here is the caller graph for this function:

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

source/geant4.10.03.p02/source/processes/electromagnetic/utils/include/G4EmCalculator.hh
source/geant4.10.03.p02/source/processes/electromagnetic/utils/src/G4EmCalculator.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation