G4EmCalculator Class Reference

#include <G4EmCalculator.hh>

Public Member Functions
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	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	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	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	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	ComputeEnergyCutFromRangeCut (G4double range, const G4ParticleDefinition *, const G4Material *)
G4double	ComputeEnergyCutFromRangeCut (G4double range, const G4String &, const G4String &)
G4double	ComputeGammaAttenuationLength (G4double kinEnergy, const G4Material *)
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	ComputeNuclearDEDX (G4double kinEnergy, const G4ParticleDefinition *, const G4Material *)
G4double	ComputeNuclearDEDX (G4double kinEnergy, const G4String &part, const G4String &mat)
G4double	ComputeShellIonisationCrossSectionPerAtom (const G4String &part, G4int Z, G4AtomicShellEnumerator shell, G4double kinEnergy, const G4Material *mat=nullptr)
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)
const G4MaterialCutsCouple *	FindCouple (const G4Material *, const G4Region *r=nullptr)
const G4ParticleDefinition *	FindIon (G4int Z, G4int A)
const G4Material *	FindMaterial (const G4String &)
const G4ParticleDefinition *	FindParticle (const G4String &)
G4VProcess *	FindProcess (const G4ParticleDefinition *part, const G4String &processName)
const G4Region *	FindRegion (const G4String &)
	G4EmCalculator ()
	G4EmCalculator (const G4EmCalculator &)=delete
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	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	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	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	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")
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	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	GetShellIonisationCrossSectionPerAtom (const G4String &part, G4int Z, G4AtomicShellEnumerator shell, G4double kinEnergy)
G4EmCalculator &	operator= (const G4EmCalculator &right)=delete
void	PrintDEDXTable (const G4ParticleDefinition *)
void	PrintInverseRangeTable (const G4ParticleDefinition *)
void	PrintRangeTable (const G4ParticleDefinition *)
void	SetupMaterial (const G4Material *)
void	SetupMaterial (const G4String &)
void	SetVerbose (G4int val)
	~G4EmCalculator ()

Private Member Functions
G4bool	ActiveForParticle (const G4ParticleDefinition *part, G4VProcess *proc)
void	CheckMaterial (G4int Z)
G4VEmProcess *	FindDiscreteProcess (const G4ParticleDefinition *, const G4String &processName)
G4bool	FindEmModel (const G4ParticleDefinition *, const G4String &processName, G4double kinEnergy)
G4VEnergyLossProcess *	FindEnergyLossProcess (const G4ParticleDefinition *)
G4VEnergyLossProcess *	FindEnLossProcess (const G4ParticleDefinition *, const G4String &processName)
void	FindLambdaTable (const G4ParticleDefinition *, const G4String &processName, G4double kinEnergy, G4int &proctype)
G4VMultipleScattering *	FindMscProcess (const G4ParticleDefinition *, const G4String &processName)
G4bool	UpdateCouple (const G4Material *, G4double cut)
G4bool	UpdateParticle (const G4ParticleDefinition *, G4double kinEnergy)

Private Attributes
const G4ParticleDefinition *	baseParticle = nullptr
G4double	chargeSquare = 1.0
G4EmCorrections *	corr
G4VProcess *	curProcess = nullptr
const G4MaterialCutsCouple *	currentCouple = nullptr
G4int	currentCoupleIndex = 0
G4double	currentCut = DBL_MAX
const G4PhysicsTable *	currentLambda = nullptr
const G4Material *	currentMaterial = nullptr
G4String	currentMaterialName = ""
G4VEmModel *	currentModel = nullptr
G4String	currentName = ""
const G4ParticleDefinition *	currentParticle = nullptr
G4String	currentParticleName = ""
G4VEnergyLossProcess *	currentProcess = nullptr
G4String	currentProcessName = ""
G4double	cutenergy [3]
const G4Material *	cutMaterial = nullptr
G4DynamicParticle *	dynParticle = nullptr
G4ionEffectiveCharge *	ionEffCharge
G4IonTable *	ionTable
G4bool	isApplicable = false
G4bool	isIon = false
G4String	lambdaName = ""
const G4ParticleDefinition *	lambdaParticle = nullptr
std::vector< const G4MaterialCutsCouple * >	localCouples
std::vector< G4double >	localCuts
std::vector< const G4Material * >	localMaterials
G4VEmModel *	loweModel = nullptr
G4LossTableManager *	manager
G4double	mass = 0
G4double	massRatio = 1.0
G4NistManager *	nist
G4int	nLocalMaterials = 0
const G4ParticleDefinition *	theGenericIon
G4EmParameters *	theParameters
G4int	verbose = 0

Detailed Description

Definition at line 79 of file G4EmCalculator.hh.

Constructor & Destructor Documentation

G4EmCalculator() [1/2]

G4EmCalculator::G4EmCalculator

(

)

Definition at line 75 of file G4EmCalculator.cc.

{
  manager = G4LossTableManager::Instance();
  nist    = G4NistManager::Instance();
  theParameters = G4EmParameters::Instance();
  corr    = manager->EmCorrections();
  cutenergy[0] = cutenergy[1] = cutenergy[2] = DBL_MAX;
  theGenericIon = G4GenericIon::GenericIon();
  ionEffCharge  = new G4ionEffectiveCharge();
  dynParticle   = new G4DynamicParticle();
  ionTable      = G4ParticleTable::GetParticleTable()->GetIonTable();
}

References corr, cutenergy, DBL_MAX, dynParticle, G4LossTableManager::EmCorrections(), G4GenericIon::GenericIon(), G4ParticleTable::GetIonTable(), G4ParticleTable::GetParticleTable(), G4NistManager::Instance(), G4EmParameters::Instance(), G4LossTableManager::Instance(), ionEffCharge, ionTable, manager, nist, theGenericIon, and theParameters.

~G4EmCalculator()

G4EmCalculator::~G4EmCalculator

(

)

Definition at line 90 of file G4EmCalculator.cc.

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

References dynParticle, ionEffCharge, localCouples, and nLocalMaterials.

G4EmCalculator() [2/2]

G4EmCalculator::G4EmCalculator ( const G4EmCalculator &  )

delete

Member Function Documentation

ActiveForParticle()

G4bool G4EmCalculator::ActiveForParticle ( const G4ParticleDefinition *  part, G4VProcess *  proc  )

private

Definition at line 1222 of file G4EmCalculator.cc.

{
  G4ProcessManager* pm = part->GetProcessManager();
  G4ProcessVector* pv = pm->GetProcessList();
  G4int n = pv->size();
  G4bool res = false;
  for(G4int i=0; i<n; ++i) {
    if((*pv)[i] == proc) {
      if(pm->GetProcessActivation(i)) { res = true; }
      break;
    }
  }
  return res;
}

References G4ProcessManager::GetProcessActivation(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), CLHEP::detail::n, and G4ProcessVector::size().

Referenced by ComputeDEDXForCutInRange(), ComputeElectronicDEDX(), FindDiscreteProcess(), FindEnLossProcess(), and FindMscProcess().

CheckMaterial()

void G4EmCalculator::CheckMaterial ( G4int  Z )

private

Definition at line 1260 of file G4EmCalculator.cc.

{
  G4bool isFound = false;
  if(currentMaterial) {
    size_t nn = currentMaterial->GetNumberOfElements();
    for(size_t i=0; i<nn; ++i) { 
      if(Z == currentMaterial->GetElement(i)->GetZasInt()) {
        isFound = true;
        break;
      }
    }
  }
  if(!isFound) {
    SetupMaterial(nist->FindOrBuildSimpleMaterial(Z));
  }
}

References currentMaterial, G4NistManager::FindOrBuildSimpleMaterial(), G4Material::GetElement(), G4Material::GetNumberOfElements(), G4Element::GetZasInt(), nist, G4InuclParticleNames::nn, SetupMaterial(), and Z.

Referenced by ComputeCrossSectionPerAtom(), and ComputeCrossSectionPerShell().

ComputeCrossSectionPerAtom() [1/2]

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

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

References A, barn, baseParticle, chargeSquare, CheckMaterial(), G4VEmModel::ComputeCrossSectionPerAtom(), currentModel, FindEmModel(), g, G4cout, G4endl, G4lrint(), G4ParticleDefinition::GetParticleName(), G4VEmModel::InitialiseForElement(), keV, G4EmParameters::LowestElectronEnergy(), massRatio, G4INCL::Math::max(), MeV, mole, theParameters, UpdateParticle(), verbose, and Z.

Referenced by RunAction::BeginOfRunAction(), and ComputeCrossSectionPerAtom().

ComputeCrossSectionPerAtom() [2/2]

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

inline

Definition at line 507 of file G4EmCalculator.hh.

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

References ComputeCrossSectionPerAtom(), FindParticle(), G4Element::GetN(), and G4Element::GetZ().

ComputeCrossSectionPerShell() [1/2]

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

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

References barn, baseParticle, chargeSquare, CheckMaterial(), G4VEmModel::ComputeCrossSectionPerAtom(), G4VEmModel::ComputeCrossSectionPerShell(), currentModel, FindEmModel(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VEmModel::InitialiseForElement(), keV, G4EmParameters::LowestElectronEnergy(), massRatio, G4INCL::Math::max(), MeV, theParameters, UpdateParticle(), verbose, and Z.

Referenced by ComputeCrossSectionPerShell().

ComputeCrossSectionPerShell() [2/2]

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

inline

Definition at line 520 of file G4EmCalculator.hh.

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

References ComputeCrossSectionPerShell(), FindParticle(), and G4Element::GetZasInt().

ComputeCrossSectionPerVolume() [1/2]

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

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

References baseParticle, chargeSquare, cm, G4VEmModel::CrossSectionPerVolume(), currentModel, FindEmModel(), G4cout, G4endl, G4Material::GetName(), G4ParticleDefinition::GetParticleName(), keV, G4EmParameters::LowestElectronEnergy(), massRatio, G4INCL::Math::max(), MeV, SetupMaterial(), theParameters, UpdateParticle(), and verbose.

Referenced by RunAction::BeginOfRunAction(), ComputeCrossSectionPerVolume(), ComputeGammaAttenuationLength(), ComputeMeanFreePath(), and GetCrossSectionPerVolume().

ComputeCrossSectionPerVolume() [2/2]

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

inline

Definition at line 492 of file G4EmCalculator.hh.

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

References ComputeCrossSectionPerVolume(), FindMaterial(), FindParticle(), and eplot::material.

ComputeDEDX() [1/2]

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

Definition at line 351 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
      const G4String& mname = currentModel->GetName();  
      if(mname  == "ParamICRU73" || mname == "LinhardSorensen" || mname == "Atima") {
        res = currentModel->ComputeDEDXPerVolume(mat, p, kinEnergy, cut);
        if(verbose > 1) { 
      G4cout << mname << " 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;
          dynParticle->SetKineticEnergy(kinEnergy);
          currentModel->GetChargeSquareRatio(p, mat, kinEnergy);
          currentModel->CorrectionsAlongStep(couple,dynParticle,length,eloss);
          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;
}

References baseParticle, chargeSquare, cm2, G4VEmModel::ComputeDEDXPerVolume(), G4VEmModel::CorrectionsAlongStep(), currentMaterialName, currentModel, dynParticle, FindCouple(), FindEmModel(), G4cout, G4endl, G4VEmModel::GetChargeSquareRatio(), G4Material::GetDensity(), G4VEmModel::GetName(), G4ParticleDefinition::GetParticleName(), gram, isIon, loweModel, G4VEmModel::LowEnergyLimit(), massRatio, MeV, mm, CLHEP::nm, G4DynamicParticle::SetKineticEnergy(), SetupMaterial(), UpdateParticle(), and verbose.

Referenced by RunAction::BeginOfRunAction(), ComputeDEDX(), ComputeDEDXForCutInRange(), ComputeElectronicDEDX(), and RunAction::CriticalEnergy().

ComputeDEDX() [2/2]

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

inline

Definition at line 468 of file G4EmCalculator.hh.

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

References ComputeDEDX(), FindMaterial(), FindParticle(), and eplot::material.

ComputeDEDXForCutInRange() [1/2]

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

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

References ActiveForParticle(), ComputeDEDX(), ComputeEnergyCutFromRangeCut(), cutenergy, cutMaterial, G4Electron::Electron(), G4Gamma::Gamma(), G4LossTableManager::GetEnergyLossProcessVector(), G4LossTableManager::Instance(), CLHEP::detail::n, G4Positron::Positron(), SetupMaterial(), and UpdateParticle().

Referenced by ComputeDEDXForCutInRange().

ComputeDEDXForCutInRange() [2/2]

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

inline

Definition at line 445 of file G4EmCalculator.hh.

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

References ComputeDEDXForCutInRange(), FindMaterial(), and FindParticle().

ComputeElectronicDEDX() [1/2]

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

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

References ActiveForParticle(), ComputeDEDX(), G4LossTableManager::GetEnergyLossProcessVector(), G4LossTableManager::Instance(), CLHEP::detail::n, SetupMaterial(), and UpdateParticle().

Referenced by ComputeElectronicDEDX(), and ComputeTotalDEDX().

ComputeElectronicDEDX() [2/2]

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

inline

Definition at line 435 of file G4EmCalculator.hh.

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

References ComputeElectronicDEDX(), FindMaterial(), and FindParticle().

ComputeEnergyCutFromRangeCut() [1/2]

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

Definition at line 748 of file G4EmCalculator.cc.

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

References G4ProductionCutsTable::GetProductionCutsTable().

Referenced by ComputeDEDXForCutInRange(), and ComputeEnergyCutFromRangeCut().

ComputeEnergyCutFromRangeCut() [2/2]

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

inline

Definition at line 533 of file G4EmCalculator.hh.

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

References ComputeEnergyCutFromRangeCut(), FindMaterial(), FindParticle(), and eplot::material.

ComputeGammaAttenuationLength()

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

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

References ComputeCrossSectionPerVolume(), and G4Gamma::Gamma().

ComputeMeanFreePath() [1/2]

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

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

References ComputeCrossSectionPerVolume(), DBL_MAX, G4cout, G4endl, G4Material::GetName(), G4ParticleDefinition::GetParticleName(), MeV, mm, and verbose.

Referenced by ComputeMeanFreePath().

ComputeMeanFreePath() [2/2]

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

inline

Definition at line 545 of file G4EmCalculator.hh.

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

References ComputeMeanFreePath(), FindMaterial(), FindParticle(), and eplot::material.

ComputeNuclearDEDX() [1/2]

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

Definition at line 557 of file G4EmCalculator.cc.

{
  G4double res = 0.0;
  G4VEmProcess* nucst = FindDiscreteProcess(p, "nuclearStopping");
  if(nucst) {
    G4VEmModel* mod = nucst->EmModel();
    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;
}

References cm2, G4VEmModel::ComputeDEDXPerVolume(), G4VEmProcess::EmModel(), FindDiscreteProcess(), G4cout, G4endl, G4Material::GetDensity(), G4ParticleDefinition::GetParticleName(), gram, MeV, mm, G4VEmModel::SetFluctuationFlag(), and verbose.

Referenced by ComputeNuclearDEDX(), and ComputeTotalDEDX().

ComputeNuclearDEDX() [2/2]

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

inline

Definition at line 481 of file G4EmCalculator.hh.

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

References ComputeNuclearDEDX(), FindMaterial(), FindParticle(), and eplot::material.

ComputeShellIonisationCrossSectionPerAtom()

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

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

References G4LossTableManager::AtomDeexcitation(), G4VAtomDeexcitation::ComputeShellIonisationCrossSectionPerAtom(), FindParticle(), manager, and Z.

ComputeTotalDEDX() [1/2]

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

Definition at line 545 of file G4EmCalculator.cc.

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

References ComputeElectronicDEDX(), ComputeNuclearDEDX(), mass, and MeV.

Referenced by ComputeTotalDEDX().

ComputeTotalDEDX() [2/2]

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

inline

Definition at line 457 of file G4EmCalculator.hh.

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

References ComputeTotalDEDX(), FindMaterial(), and FindParticle().

FindCouple()

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

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

References currentMaterial, currentMaterialName, FatalException, G4Exception(), G4RegionStore::GetInstance(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4Region::GetName(), G4Region::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), eplot::material, and SetupMaterial().

Referenced by ComputeDEDX(), export_G4EmCalculator(), GetCrossSectionPerVolume(), GetCSDARange(), GetDEDX(), GetKinEnergy(), and GetRangeFromRestricteDEDX().

FindDiscreteProcess()

G4VEmProcess * G4EmCalculator::FindDiscreteProcess ( const G4ParticleDefinition *  part, const G4String &  processName  )

private

Definition at line 1158 of file G4EmCalculator.cc.

{
  G4VEmProcess* proc = nullptr;
  auto v = manager->GetEmProcessVector();
  G4int n = v.size();
  for(G4int i=0; i<n; ++i) {
    auto pName = v[i]->GetProcessName();
    if(pName == "GammaGeneralProc") {
      proc = v[i]->GetEmProcess(processName);
      break;
    } else if(pName == processName) {
      G4VProcess* p = reinterpret_cast<G4VProcess*>(v[i]);
      if(ActiveForParticle(part, p)) {
        proc = v[i];
        break;
      }
    }
  }
  return proc;
}

References ActiveForParticle(), G4VEmProcess::GetEmProcess(), G4LossTableManager::GetEmProcessVector(), manager, and CLHEP::detail::n.

Referenced by ComputeNuclearDEDX(), FindEmModel(), FindLambdaTable(), and GetCrossSectionPerVolume().

FindEmModel()

G4bool G4EmCalculator::FindEmModel ( const G4ParticleDefinition *  p, const G4String &  processName, G4double  kinEnergy  )

private

Definition at line 1012 of file G4EmCalculator.cc.

{
  isApplicable = false;
  if(!p || !currentMaterial) {
    G4cout << "G4EmCalculator::FindEmModel WARNING: no particle" 
           << " or materail defined; particle: " << p << G4endl;
    return isApplicable;
  }
  G4String partname =  p->GetParticleName();
  const G4ParticleDefinition* part = p;
  G4double scaledEnergy = kinEnergy*massRatio;
  if(isIon) { part = theGenericIon; } 
 
  if(verbose > 1) {
    G4cout << "## G4EmCalculator::FindEmModel for " << partname
           << " (type= " << p->GetParticleType()
           << ") and " << processName << " at E(MeV)= " << scaledEnergy 
           << G4endl;
    if(p != part) { G4cout << "  GenericIon is the base particle" << G4endl; }
  }
 
  // Search for energy loss process
  currentName = processName;
  currentModel = nullptr;
  loweModel = nullptr;
  size_t idx   = 0;
 
  G4VEnergyLossProcess* elproc = FindEnLossProcess(part, processName);
  if(elproc) {
    currentModel = elproc->SelectModelForMaterial(scaledEnergy, idx);
    currentModel->InitialiseForMaterial(part, currentMaterial);
    currentModel->SetupForMaterial(part, currentMaterial, scaledEnergy);
    G4double eth = currentModel->LowEnergyLimit();
    if(eth > 0.0) {
      loweModel = elproc->SelectModelForMaterial(eth - CLHEP::eV, idx);
      if(loweModel == currentModel) { loweModel = nullptr; }
      else { 
        loweModel->InitialiseForMaterial(part, currentMaterial);
        loweModel->SetupForMaterial(part, currentMaterial, eth - CLHEP::eV); 
      }
    }
  }
 
  // Search for discrete process 
  if(!currentModel) {
    G4VEmProcess* proc = FindDiscreteProcess(part, processName);
    if(proc) {
      currentModel = proc->SelectModelForMaterial(kinEnergy, idx);
      currentModel->InitialiseForMaterial(part, currentMaterial);
      currentModel->SetupForMaterial(part, currentMaterial, kinEnergy);
      G4double eth = currentModel->LowEnergyLimit();
      if(eth > 0.0) {
        loweModel = proc->SelectModelForMaterial(eth - CLHEP::eV, idx);
        if(loweModel == currentModel) { loweModel = nullptr; }
        else { 
          loweModel->InitialiseForMaterial(part, currentMaterial);
          loweModel->SetupForMaterial(part, currentMaterial, eth - CLHEP::eV); 
        }
      }
    }
  }
 
  // Search for msc process
  if(!currentModel) {
    G4VMultipleScattering* proc = FindMscProcess(part, processName);
    if(proc) {
      currentModel = proc->SelectModel(kinEnergy, idx);
      loweModel = nullptr;
    }
  }
  if(currentModel) {
    if(loweModel == currentModel) { loweModel = nullptr; }
    isApplicable = true;
    currentModel->InitialiseForMaterial(part, currentMaterial);
    if(loweModel) {
      loweModel->InitialiseForMaterial(part, currentMaterial);
    }
    if(verbose > 1) {
      G4cout << "   Model <" << currentModel->GetName() 
             << "> Emin(MeV)= " << currentModel->LowEnergyLimit()/MeV
             << " for " << part->GetParticleName();
      if(elproc) { 
        G4cout << " and " << elproc->GetProcessName() << "  " << elproc 
               << G4endl;
      }
      if(loweModel) { 
        G4cout << " LowEnergy model <" << loweModel->GetName() << ">"; 
      }
      G4cout << G4endl;
    } 
  }
  return isApplicable;
}

References currentMaterial, currentModel, currentName, CLHEP::eV, FindDiscreteProcess(), FindEnLossProcess(), FindMscProcess(), G4cout, G4endl, G4VEmModel::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), G4VProcess::GetProcessName(), G4VEmModel::InitialiseForMaterial(), isApplicable, isIon, loweModel, G4VEmModel::LowEnergyLimit(), massRatio, MeV, G4VMultipleScattering::SelectModel(), G4VEnergyLossProcess::SelectModelForMaterial(), G4VEmProcess::SelectModelForMaterial(), G4VEmModel::SetupForMaterial(), theGenericIon, and verbose.

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), ComputeDEDX(), GetCrossSectionPerVolume(), and GetDEDX().

FindEnergyLossProcess()

G4VEnergyLossProcess * G4EmCalculator::FindEnergyLossProcess ( const G4ParticleDefinition *  p )

private

Definition at line 1110 of file G4EmCalculator.cc.

{
  G4VEnergyLossProcess* elp = nullptr;
  G4String partname =  p->GetParticleName();
  const G4ParticleDefinition* part = p;
  
  if(p->GetParticleType() == "nucleus" 
     && currentParticleName != "deuteron"  
     && currentParticleName != "triton"
     && currentParticleName != "alpha"
     && currentParticleName != "alpha+"
     ) { part = theGenericIon; } 
 
  elp = manager->GetEnergyLossProcess(part);
  /*
  G4cout << "\n G4EmCalculator::FindEnergyLossProcess: for " << p->GetParticleName()
     << " found " << elp->GetProcessName() << " of " 
     << elp->Particle()->GetParticleName() << "  " << elp << G4endl;
  */
  return elp;
}

References currentParticleName, G4LossTableManager::GetEnergyLossProcess(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), manager, and theGenericIon.

Referenced by PrintDEDXTable(), PrintInverseRangeTable(), PrintRangeTable(), and UpdateParticle().

FindEnLossProcess()

G4VEnergyLossProcess * G4EmCalculator::FindEnLossProcess ( const G4ParticleDefinition *  part, const G4String &  processName  )

private

Definition at line 1136 of file G4EmCalculator.cc.

{
  G4VEnergyLossProcess* proc = 0;
  const std::vector<G4VEnergyLossProcess*> v = 
    manager->GetEnergyLossProcessVector();
  G4int n = v.size();
  for(G4int i=0; i<n; ++i) {
    if((v[i])->GetProcessName() == processName) {
      G4VProcess* p = reinterpret_cast<G4VProcess*>(v[i]);
      if(ActiveForParticle(part, p)) {
        proc = v[i];
        break;
      }
    }
  }
  return proc;
}

References ActiveForParticle(), G4LossTableManager::GetEnergyLossProcessVector(), manager, and CLHEP::detail::n.

Referenced by FindEmModel(), and FindLambdaTable().

FindIon()

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

Definition at line 843 of file G4EmCalculator.cc.

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

References A, G4IonTable::GetIon(), ionTable, and Z.

FindLambdaTable()

void G4EmCalculator::FindLambdaTable ( const G4ParticleDefinition *  p, const G4String &  processName, G4double  kinEnergy, G4int &  proctype  )

private

Definition at line 942 of file G4EmCalculator.cc.

{
  // Search for the process
  if (!currentLambda || p != lambdaParticle || processName != lambdaName) {
    lambdaName     = processName;
    currentLambda  = nullptr;
    lambdaParticle = p;
 
    const G4ParticleDefinition* part = p;
    if(isIon) { part = theGenericIon; }
 
    // Search for energy loss process
    currentName = processName;
    currentModel = nullptr;
    loweModel = nullptr;
 
    G4VEnergyLossProcess* elproc = FindEnLossProcess(part, processName);
    if(elproc) {
      currentLambda = elproc->LambdaTable();
      proctype      = 0;
      if(currentLambda) {
        isApplicable = true;
        if(verbose>1) { 
          G4cout << "G4VEnergyLossProcess is found out: " << currentName 
                 << G4endl;
        }
      }
      curProcess = elproc;
      return;
    }
 
    // Search for discrete process 
    G4VEmProcess* proc = FindDiscreteProcess(part, processName);
    if(proc) {
      currentLambda = proc->LambdaTable();
      proctype      = 1;
      if(currentLambda) {
        isApplicable = true;
        if(verbose>1) { 
          G4cout << "G4VEmProcess is found out: " << currentName << G4endl;
        }
      }
      curProcess = proc;
      return;
    }
 
    // Search for msc process
    G4VMultipleScattering* msc = FindMscProcess(part, processName);
    if(msc) {
      currentModel = msc->SelectModel(kinEnergy,0);
      proctype     = 2;
      if(currentModel) {
        currentLambda = currentModel->GetCrossSectionTable();
        if(currentLambda) {
          isApplicable = true;
          if(verbose>1) { 
            G4cout << "G4VMultipleScattering is found out: " << currentName 
                   << G4endl;
          }
        }
      }
      curProcess = msc;
    }
  }
}

References curProcess, currentLambda, currentModel, currentName, FindDiscreteProcess(), FindEnLossProcess(), FindMscProcess(), G4cout, G4endl, G4VEmModel::GetCrossSectionTable(), isApplicable, isIon, lambdaName, lambdaParticle, G4VEmProcess::LambdaTable(), G4VEnergyLossProcess::LambdaTable(), loweModel, G4VMultipleScattering::SelectModel(), theGenericIon, and verbose.

Referenced by GetCrossSectionPerVolume().

FindMaterial()

const G4Material * G4EmCalculator::FindMaterial

(

const G4String &

name

)

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

References currentMaterial, currentMaterialName, G4cout, G4endl, G4Material::GetMaterial(), G4InuclParticleNames::name(), and SetupMaterial().

Referenced by ComputeCrossSectionPerVolume(), ComputeDEDX(), ComputeDEDXForCutInRange(), ComputeElectronicDEDX(), ComputeEnergyCutFromRangeCut(), ComputeMeanFreePath(), ComputeNuclearDEDX(), ComputeTotalDEDX(), export_G4EmCalculator(), GetCrossSectionPerVolume(), GetCSDARange(), GetDEDX(), GetKinEnergy(), GetMeanFreePath(), GetRange(), and GetRangeFromRestricteDEDX().

FindMscProcess()

G4VMultipleScattering * G4EmCalculator::FindMscProcess ( const G4ParticleDefinition *  part, const G4String &  processName  )

private

Definition at line 1183 of file G4EmCalculator.cc.

{
  G4VMultipleScattering* proc = 0;
  const std::vector<G4VMultipleScattering*> v = 
    manager->GetMultipleScatteringVector();
  G4int n = v.size();
  for(G4int i=0; i<n; ++i) {
    if((v[i])->GetProcessName() == processName) {
      G4VProcess* p = reinterpret_cast<G4VProcess*>(v[i]);
      if(ActiveForParticle(part, p)) {
        proc = v[i];
        break;
      }
    }
  }
  return proc;
}

References ActiveForParticle(), G4LossTableManager::GetMultipleScatteringVector(), manager, and CLHEP::detail::n.

Referenced by FindEmModel(), and FindLambdaTable().

FindParticle()

const G4ParticleDefinition * G4EmCalculator::FindParticle

(

const G4String &

name

)

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

References currentParticle, currentParticleName, G4ParticleTable::FindParticle(), G4cout, G4endl, G4ParticleTable::GetParticleTable(), and G4InuclParticleNames::name().

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), ComputeDEDX(), ComputeDEDXForCutInRange(), ComputeElectronicDEDX(), ComputeEnergyCutFromRangeCut(), ComputeMeanFreePath(), ComputeNuclearDEDX(), ComputeShellIonisationCrossSectionPerAtom(), ComputeTotalDEDX(), export_G4EmCalculator(), GetCrossSectionPerVolume(), GetCSDARange(), GetDEDX(), GetKinEnergy(), GetMeanFreePath(), GetRange(), GetRangeFromRestricteDEDX(), and GetShellIonisationCrossSectionPerAtom().

FindProcess()

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

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

References G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), and G4ProcessVector::size().

FindRegion()

const G4Region * G4EmCalculator::FindRegion

(

const G4String &

reg

)

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

References G4RegionStore::GetInstance(), G4RegionStore::GetRegion(), and reg.

Referenced by export_G4EmCalculator(), GetCrossSectionPerVolume(), GetCSDARange(), GetDEDX(), GetKinEnergy(), GetMeanFreePath(), GetRange(), and GetRangeFromRestricteDEDX().

GetCrossSectionPerVolume() [1/2]

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

Definition at line 233 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();
      G4int procType = -1;
      FindLambdaTable(p, processName, kinEnergy, procType);
 
      G4VEmProcess* emproc = FindDiscreteProcess(p, processName);
      if(emproc) {
    res = emproc->CrossSectionPerVolume(kinEnergy, couple);
      } else if(currentLambda) {
        // special tables are built for Msc models (procType is set in FindLambdaTable
        if(procType==2) {
          G4VMscModel* mscM = static_cast<G4VMscModel*>(currentModel);
          mscM->SetCurrentCouple(couple);
          G4double tr1Mfp   = mscM->GetTransportMeanFreePath(p, kinEnergy);
          if (tr1Mfp<DBL_MAX) {
            res = 1./tr1Mfp;
          }
        } else {  
          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;
}

References chargeSquare, cm, ComputeCrossSectionPerVolume(), G4VEmProcess::CrossSectionPerVolume(), currentLambda, currentModel, DBL_MAX, FindCouple(), FindDiscreteProcess(), FindEmModel(), FindLambdaTable(), G4cout, G4endl, G4MaterialCutsCouple::GetIndex(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4VMscModel::GetTransportMeanFreePath(), massRatio, MeV, G4VEmModel::SetCurrentCouple(), UpdateParticle(), and verbose.

Referenced by RunAction::BeginOfRunAction(), GetCrossSectionPerVolume(), and GetMeanFreePath().

GetCrossSectionPerVolume() [2/2]

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

inline

Definition at line 409 of file G4EmCalculator.hh.

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

References FindMaterial(), FindParticle(), FindRegion(), GetCrossSectionPerVolume(), eplot::material, and reg.

GetCSDARange() [1/2]

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

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

References G4EmParameters::BuildCSDARange(), FindCouple(), G4cout, G4endl, G4Exception(), G4LossTableManager::GetCSDARange(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), JustWarning, manager, MeV, mm, theParameters, UpdateParticle(), and verbose.

Referenced by RunAction::BeginOfRunAction(), GetCSDARange(), and GetRange().

GetCSDARange() [2/2]

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

inline

Definition at line 375 of file G4EmCalculator.hh.

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

References FindMaterial(), FindParticle(), FindRegion(), GetCSDARange(), eplot::material, and reg.

GetDEDX() [1/2]

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

Definition at line 101 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;; 
        dynParticle->SetKineticEnergy(kinEnergy);
        currentModel->GetChargeSquareRatio(p, mat, kinEnergy);
        currentModel->CorrectionsAlongStep(couple,dynParticle,length,eloss);
        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;
}

References cm2, G4VEmModel::CorrectionsAlongStep(), currentModel, currentProcessName, dynParticle, FindCouple(), FindEmModel(), G4cout, G4endl, G4VEmModel::GetChargeSquareRatio(), G4LossTableManager::GetDEDX(), G4Material::GetDensity(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), gram, isIon, manager, MeV, mm, CLHEP::nm, G4DynamicParticle::SetKineticEnergy(), UpdateParticle(), and verbose.

Referenced by RunAction::BeginOfRunAction(), GetDEDX(), and G4EnergySplitter::SplitEnergyInVolumes().

GetDEDX() [2/2]

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

inline

Definition at line 353 of file G4EmCalculator.hh.

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

References FindMaterial(), FindParticle(), FindRegion(), GetDEDX(), eplot::material, and reg.

GetKinEnergy() [1/2]

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

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

References FindCouple(), G4cout, G4endl, G4LossTableManager::GetEnergy(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), GeV, manager, MeV, mm, UpdateParticle(), and verbose.

Referenced by GetKinEnergy().

GetKinEnergy() [2/2]

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

inline

Definition at line 399 of file G4EmCalculator.hh.

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

References FindMaterial(), FindParticle(), FindRegion(), GetKinEnergy(), eplot::material, and reg.

GetMeanFreePath() [1/2]

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

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

References DBL_MAX, G4cout, G4endl, GetCrossSectionPerVolume(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), MeV, mm, and verbose.

Referenced by RunAction::BeginOfRunAction(), and GetMeanFreePath().

GetMeanFreePath() [2/2]

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

inline

Definition at line 422 of file G4EmCalculator.hh.

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

References FindMaterial(), FindParticle(), FindRegion(), GetMeanFreePath(), eplot::material, and reg.

GetRange() [1/2]

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

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

References G4EmParameters::BuildCSDARange(), GetCSDARange(), GetRangeFromRestricteDEDX(), and theParameters.

Referenced by GetRange().

GetRange() [2/2]

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

inline

Definition at line 387 of file G4EmCalculator.hh.

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

References FindMaterial(), FindParticle(), FindRegion(), GetRange(), eplot::material, and reg.

GetRangeFromRestricteDEDX() [1/2]

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

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

References FindCouple(), G4cout, G4endl, G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4LossTableManager::GetRangeFromRestricteDEDX(), manager, MeV, mm, UpdateParticle(), and verbose.

Referenced by RunAction::BeginOfRunAction(), GetRange(), and GetRangeFromRestricteDEDX().

GetRangeFromRestricteDEDX() [2/2]

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

inline

Definition at line 363 of file G4EmCalculator.hh.

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

References FindMaterial(), FindParticle(), FindRegion(), GetRangeFromRestricteDEDX(), eplot::material, and reg.

GetShellIonisationCrossSectionPerAtom()

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

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

References G4LossTableManager::AtomDeexcitation(), FindParticle(), G4VAtomDeexcitation::GetShellIonisationCrossSectionPerAtom(), manager, and Z.

operator=()

G4EmCalculator & G4EmCalculator::operator= ( const G4EmCalculator &  right )

delete

PrintDEDXTable()

void G4EmCalculator::PrintDEDXTable

(

const G4ParticleDefinition *

p

)

Definition at line 323 of file G4EmCalculator.cc.

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

References G4VEnergyLossProcess::DEDXTable(), FindEnergyLossProcess(), G4cout, G4endl, and G4ParticleDefinition::GetParticleName().

Referenced by export_G4EmCalculator().

PrintInverseRangeTable()

void G4EmCalculator::PrintInverseRangeTable

(

const G4ParticleDefinition *

p

)

Definition at line 341 of file G4EmCalculator.cc.

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

References FindEnergyLossProcess(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), and G4VEnergyLossProcess::InverseRangeTable().

Referenced by export_G4EmCalculator().

PrintRangeTable()

void G4EmCalculator::PrintRangeTable

(

const G4ParticleDefinition *

p

)

Definition at line 332 of file G4EmCalculator.cc.

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

References FindEnergyLossProcess(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), and G4VEnergyLossProcess::RangeTableForLoss().

Referenced by export_G4EmCalculator().

SetupMaterial() [1/2]

void G4EmCalculator::SetupMaterial

(

const G4Material *

mat

)

Definition at line 1240 of file G4EmCalculator.cc.

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

References currentMaterial, currentMaterialName, and G4Material::GetName().

Referenced by CheckMaterial(), ComputeCrossSectionPerVolume(), ComputeDEDX(), ComputeDEDXForCutInRange(), ComputeElectronicDEDX(), FindCouple(), FindMaterial(), SetupMaterial(), and UpdateCouple().

SetupMaterial() [2/2]

void G4EmCalculator::SetupMaterial

(

const G4String &

mname

)

Definition at line 1253 of file G4EmCalculator.cc.

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

References G4NistManager::FindOrBuildMaterial(), nist, and SetupMaterial().

SetVerbose()

void G4EmCalculator::SetVerbose

(

G4int

val

)

Definition at line 1279 of file G4EmCalculator.cc.

{
  verbose = verb;
}

References verbose.

Referenced by export_G4EmCalculator().

UpdateCouple()

G4bool G4EmCalculator::UpdateCouple ( const G4Material *  material, G4double  cut  )

private

Definition at line 917 of file G4EmCalculator.cc.

{
  SetupMaterial(material);
  if(!currentMaterial) { return false; }
  for (G4int i=0; i<nLocalMaterials; ++i) {
    if(material == localMaterials[i] && cut == localCuts[i]) {
      currentCouple = localCouples[i];
      currentCoupleIndex = currentCouple->GetIndex();
      currentCut = cut;
      return true;
    }
  }
  const G4MaterialCutsCouple* cc = new G4MaterialCutsCouple(material);
  localMaterials.push_back(material);
  localCouples.push_back(cc);
  localCuts.push_back(cut);
  nLocalMaterials++;
  currentCouple = cc;
  currentCoupleIndex = currentCouple->GetIndex();
  currentCut = cut;
  return true;
}

References currentCouple, currentCoupleIndex, currentCut, currentMaterial, G4MaterialCutsCouple::GetIndex(), localCouples, localCuts, localMaterials, eplot::material, nLocalMaterials, and SetupMaterial().

UpdateParticle()

G4bool G4EmCalculator::UpdateParticle ( const G4ParticleDefinition *  p, G4double  kinEnergy  )

private

Definition at line 759 of file G4EmCalculator.cc.

{
  if(p != currentParticle) {
 
    // new particle
    currentParticle = p;
    dynParticle->SetDefinition(const_cast<G4ParticleDefinition*>(p));
    dynParticle->SetKineticEnergy(kinEnergy);
    baseParticle    = 0;
    currentParticleName = p->GetParticleName();
    massRatio       = 1.0;
    mass            = p->GetPDGMass();
    chargeSquare    = 1.0;
    currentProcess  = FindEnergyLossProcess(p);
    currentProcessName = "";
    isIon = false;
 
    // ionisation process exist
    if(currentProcess) {
      currentProcessName = currentProcess->GetProcessName();
      baseParticle = currentProcess->BaseParticle();
 
      // base particle is used
      if(baseParticle) {
        massRatio = baseParticle->GetPDGMass()/p->GetPDGMass();
        G4double q = p->GetPDGCharge()/baseParticle->GetPDGCharge();
        chargeSquare = q*q;
      } 
 
      if(p->GetParticleType()   == "nucleus" 
         && currentParticleName != "deuteron"  
         && currentParticleName != "triton"
         && currentParticleName != "alpha+"
         && currentParticleName != "alpha"
         ) {
        isIon = true;
        massRatio = theGenericIon->GetPDGMass()/p->GetPDGMass();
        baseParticle = theGenericIon;
    if(verbose>1) {
          G4cout << "\n G4EmCalculator::UpdateParticle: isIon 1 "
         << p->GetParticleName()
         << " in " << currentMaterial->GetName()
         << "  e= " << kinEnergy << G4endl;
    }
      }
    }
  }
 
  // Effective charge for ions
  if(isIon) {
    chargeSquare =
      corr->EffectiveChargeSquareRatio(p, currentMaterial, kinEnergy)
      * corr->EffectiveChargeCorrection(p,currentMaterial,kinEnergy);
    if(currentProcess) {
      currentProcess->SetDynamicMassCharge(massRatio,chargeSquare);
      if(verbose>1) {
    G4cout <<"\n NewIon: massR= "<< massRatio << "   q2= " 
           << chargeSquare << "  " << currentProcess << G4endl;
      }
    }
  }
  return true;
}

References baseParticle, G4VEnergyLossProcess::BaseParticle(), chargeSquare, corr, currentMaterial, currentParticle, currentParticleName, currentProcess, currentProcessName, dynParticle, G4EmCorrections::EffectiveChargeCorrection(), G4EmCorrections::EffectiveChargeSquareRatio(), FindEnergyLossProcess(), G4cout, G4endl, G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4VProcess::GetProcessName(), isIon, mass, massRatio, G4DynamicParticle::SetDefinition(), G4VEnergyLossProcess::SetDynamicMassCharge(), G4DynamicParticle::SetKineticEnergy(), theGenericIon, and verbose.

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), ComputeDEDX(), ComputeDEDXForCutInRange(), ComputeElectronicDEDX(), GetCrossSectionPerVolume(), GetCSDARange(), GetDEDX(), GetKinEnergy(), and GetRangeFromRestricteDEDX().

Field Documentation

baseParticle

const G4ParticleDefinition* G4EmCalculator::baseParticle = nullptr

private

Definition at line 313 of file G4EmCalculator.hh.

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), ComputeDEDX(), and UpdateParticle().

chargeSquare

G4double G4EmCalculator::chargeSquare = 1.0

private

Definition at line 326 of file G4EmCalculator.hh.

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), ComputeDEDX(), GetCrossSectionPerVolume(), and UpdateParticle().

corr

G4EmCorrections* G4EmCalculator::corr

private

Definition at line 305 of file G4EmCalculator.hh.

Referenced by G4EmCalculator(), and UpdateParticle().

curProcess

G4VProcess* G4EmCalculator::curProcess = nullptr

private

Definition at line 319 of file G4EmCalculator.hh.

Referenced by FindLambdaTable().

currentCouple

const G4MaterialCutsCouple* G4EmCalculator::currentCouple = nullptr

private

Definition at line 308 of file G4EmCalculator.hh.

Referenced by UpdateCouple().

currentCoupleIndex

G4int G4EmCalculator::currentCoupleIndex = 0

private

Definition at line 331 of file G4EmCalculator.hh.

Referenced by UpdateCouple().

currentCut

G4double G4EmCalculator::currentCut = DBL_MAX

private

Definition at line 325 of file G4EmCalculator.hh.

Referenced by UpdateCouple().

currentLambda

const G4PhysicsTable* G4EmCalculator::currentLambda = nullptr

private

Definition at line 314 of file G4EmCalculator.hh.

Referenced by FindLambdaTable(), and GetCrossSectionPerVolume().

currentMaterial

const G4Material* G4EmCalculator::currentMaterial = nullptr

private

Definition at line 309 of file G4EmCalculator.hh.

Referenced by CheckMaterial(), FindCouple(), FindEmModel(), FindMaterial(), SetupMaterial(), UpdateCouple(), and UpdateParticle().

currentMaterialName

G4String G4EmCalculator::currentMaterialName = ""

private

Definition at line 345 of file G4EmCalculator.hh.

Referenced by ComputeDEDX(), FindCouple(), FindMaterial(), and SetupMaterial().

currentModel

G4VEmModel* G4EmCalculator::currentModel = nullptr

private

Definition at line 316 of file G4EmCalculator.hh.

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), ComputeDEDX(), FindEmModel(), FindLambdaTable(), GetCrossSectionPerVolume(), and GetDEDX().

currentName

G4String G4EmCalculator::currentName = ""

private

Definition at line 342 of file G4EmCalculator.hh.

Referenced by FindEmModel(), and FindLambdaTable().

currentParticle

const G4ParticleDefinition* G4EmCalculator::currentParticle = nullptr

private

Definition at line 311 of file G4EmCalculator.hh.

Referenced by FindParticle(), and UpdateParticle().

currentParticleName

G4String G4EmCalculator::currentParticleName = ""

private

Definition at line 344 of file G4EmCalculator.hh.

Referenced by FindEnergyLossProcess(), FindParticle(), and UpdateParticle().

currentProcess

G4VEnergyLossProcess* G4EmCalculator::currentProcess = nullptr

private

Definition at line 318 of file G4EmCalculator.hh.

Referenced by UpdateParticle().

currentProcessName

G4String G4EmCalculator::currentProcessName = ""

private

Definition at line 346 of file G4EmCalculator.hh.

Referenced by GetDEDX(), and UpdateParticle().

cutenergy

G4double G4EmCalculator::cutenergy[3]

private

Definition at line 329 of file G4EmCalculator.hh.

Referenced by ComputeDEDXForCutInRange(), and G4EmCalculator().

cutMaterial

const G4Material* G4EmCalculator::cutMaterial = nullptr

private

Definition at line 310 of file G4EmCalculator.hh.

Referenced by ComputeDEDXForCutInRange().

dynParticle

G4DynamicParticle* G4EmCalculator::dynParticle = nullptr

private

Definition at line 320 of file G4EmCalculator.hh.

Referenced by ComputeDEDX(), G4EmCalculator(), GetDEDX(), UpdateParticle(), and ~G4EmCalculator().

ionEffCharge

G4ionEffectiveCharge* G4EmCalculator::ionEffCharge

private

Definition at line 323 of file G4EmCalculator.hh.

Referenced by G4EmCalculator(), and ~G4EmCalculator().

ionTable

G4IonTable* G4EmCalculator::ionTable

private

Definition at line 304 of file G4EmCalculator.hh.

Referenced by FindIon(), and G4EmCalculator().

isApplicable

G4bool G4EmCalculator::isApplicable = false

private

Definition at line 336 of file G4EmCalculator.hh.

Referenced by FindEmModel(), and FindLambdaTable().

isIon

G4bool G4EmCalculator::isIon = false

private

Definition at line 335 of file G4EmCalculator.hh.

Referenced by ComputeDEDX(), FindEmModel(), FindLambdaTable(), GetDEDX(), and UpdateParticle().

lambdaName

G4String G4EmCalculator::lambdaName = ""

private

Definition at line 343 of file G4EmCalculator.hh.

Referenced by FindLambdaTable().

lambdaParticle

const G4ParticleDefinition* G4EmCalculator::lambdaParticle = nullptr

private

Definition at line 312 of file G4EmCalculator.hh.

Referenced by FindLambdaTable().

localCouples

std::vector<const G4MaterialCutsCouple*> G4EmCalculator::localCouples

private

Definition at line 339 of file G4EmCalculator.hh.

Referenced by UpdateCouple(), and ~G4EmCalculator().

localCuts

std::vector<G4double> G4EmCalculator::localCuts

private

Definition at line 340 of file G4EmCalculator.hh.

Referenced by UpdateCouple().

localMaterials

std::vector<const G4Material*> G4EmCalculator::localMaterials

private

Definition at line 338 of file G4EmCalculator.hh.

Referenced by UpdateCouple().

loweModel

G4VEmModel* G4EmCalculator::loweModel = nullptr

private

Definition at line 317 of file G4EmCalculator.hh.

Referenced by ComputeDEDX(), FindEmModel(), and FindLambdaTable().

manager

G4LossTableManager* G4EmCalculator::manager

private

Definition at line 302 of file G4EmCalculator.hh.

Referenced by ComputeShellIonisationCrossSectionPerAtom(), FindDiscreteProcess(), FindEnergyLossProcess(), FindEnLossProcess(), FindMscProcess(), G4EmCalculator(), GetCSDARange(), GetDEDX(), GetKinEnergy(), GetRangeFromRestricteDEDX(), and GetShellIonisationCrossSectionPerAtom().

mass

G4double G4EmCalculator::mass = 0

private

Definition at line 328 of file G4EmCalculator.hh.

Referenced by ComputeTotalDEDX(), and UpdateParticle().

massRatio

G4double G4EmCalculator::massRatio = 1.0

private

Definition at line 327 of file G4EmCalculator.hh.

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), ComputeDEDX(), FindEmModel(), GetCrossSectionPerVolume(), and UpdateParticle().

nist

G4NistManager* G4EmCalculator::nist

private

Definition at line 303 of file G4EmCalculator.hh.

Referenced by CheckMaterial(), G4EmCalculator(), and SetupMaterial().

nLocalMaterials

G4int G4EmCalculator::nLocalMaterials = 0

private

Definition at line 332 of file G4EmCalculator.hh.

Referenced by UpdateCouple(), and ~G4EmCalculator().

theGenericIon

const G4ParticleDefinition* G4EmCalculator::theGenericIon

private

Definition at line 322 of file G4EmCalculator.hh.

Referenced by FindEmModel(), FindEnergyLossProcess(), FindLambdaTable(), G4EmCalculator(), and UpdateParticle().

theParameters

G4EmParameters* G4EmCalculator::theParameters

private

Definition at line 301 of file G4EmCalculator.hh.

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), G4EmCalculator(), GetCSDARange(), and GetRange().

verbose

G4int G4EmCalculator::verbose = 0

private

Definition at line 333 of file G4EmCalculator.hh.

Referenced by ComputeCrossSectionPerAtom(), ComputeCrossSectionPerShell(), ComputeCrossSectionPerVolume(), ComputeDEDX(), ComputeMeanFreePath(), ComputeNuclearDEDX(), FindEmModel(), FindLambdaTable(), GetCrossSectionPerVolume(), GetCSDARange(), GetDEDX(), GetKinEnergy(), GetMeanFreePath(), GetRangeFromRestricteDEDX(), SetVerbose(), and UpdateParticle().

---

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

• source/processes/electromagnetic/utils/include/G4EmCalculator.hh
• source/processes/electromagnetic/utils/src/G4EmCalculator.cc