G4EmCalculator Class Reference

#include <G4EmCalculator.hh>

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 &regname="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 &regname="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 &regname="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 &regname="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 &regname="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 &regname="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 &regname="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)
void	SetApplySmoothing (G4int val)
G4EmCalculator &	operator= (const G4EmCalculator &right)=delete
	G4EmCalculator (const G4EmCalculator &)=delete

Detailed Description

Definition at line 79 of file G4EmCalculator.hh.

Constructor & Destructor Documentation

G4EmCalculator() [1/2]

G4EmCalculator::G4EmCalculator

(

)

Definition at line 76 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();
}

~G4EmCalculator()

G4EmCalculator::~G4EmCalculator

(

)

Definition at line 91 of file G4EmCalculator.cc.

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

G4EmCalculator() [2/2]

G4EmCalculator::G4EmCalculator ( const G4EmCalculator & )

delete

Member Function Documentation

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

Referenced by 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 508 of file G4EmCalculator.hh.

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

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 647 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(nullptr != 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;
}

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 521 of file G4EmCalculator.hh.

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

ComputeCrossSectionPerVolume() [1/2]

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

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

Referenced by 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 493 of file G4EmCalculator.hh.

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

ComputeDEDX() [1/2]

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

Definition at line 353 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)) {
      G4double escaled = kinEnergy*massRatio;
      if(nullptr != baseParticle) {
    res = currentModel->ComputeDEDXPerVolume(mat, baseParticle,
                                                 escaled, cut) * chargeSquare;
    if(verbose > 1) {
      G4cout << "Particle: " << p->GetParticleName()
         << " E(MeV)=" << kinEnergy
         << " Base particle: " << baseParticle->GetParticleName()
         << " Escaled(MeV)= " << escaled 
         << " q2=" << chargeSquare << G4endl;
    } 
      } else {
    res = currentModel->ComputeDEDXPerVolume(mat, p, kinEnergy, cut);
    if(verbose > 1) { 
      G4cout << "Particle: " << p->GetParticleName()
         << " E(MeV)=" << kinEnergy << G4endl;
    }
      }
      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
      if(applySmoothing && nullptr != loweModel) {
    G4double eth = currentModel->LowEnergyLimit();
    G4double res0 = 0.0;
    G4double res1 = 0.0;
    if(nullptr != baseParticle) {
      res1 = chargeSquare*
        currentModel->ComputeDEDXPerVolume(mat, baseParticle, eth, cut);
      res0 = chargeSquare*
        loweModel->ComputeDEDXPerVolume(mat, baseParticle, eth, cut);
    } else {
      res1 = currentModel->ComputeDEDXPerVolume(mat, p, eth, cut);
      res0 = loweModel->ComputeDEDXPerVolume(mat, p, eth, cut);
    }
    if(res1 > 0.0 && escaled > 0.0) {
      res *= (1.0 + (res0/res1 - 1.0)*eth/escaled);
    }  
    if(verbose > 1) {
      G4cout << "At boundary energy(MeV)= " << eth/MeV
         << " DEDX(MeV/mm)= " << res0*mm/MeV << "  " << res1*mm/MeV
         << " after correction DEDX(MeV/mm)=" << res*mm/MeV << G4endl;
    }
      } 
      // correction for ions
      if(isIon) {
    const G4double length = CLHEP::nm;
    if(UpdateCouple(mat, cut)) {
      G4double eloss = res*length;
      dynParticle->SetKineticEnergy(kinEnergy);
      currentModel->CorrectionsAlongStep(currentCouple,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 << "## 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;
}

Referenced by ComputeDEDX(), ComputeDEDXForCutInRange(), and ComputeElectronicDEDX().

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 469 of file G4EmCalculator.hh.

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

ComputeDEDXForCutInRange() [1/2]

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

Definition at line 485 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();
    std::size_t 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(std::size_t i=0; i<n; ++i) {
      if(vel[i]) {
        auto p = static_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();
          std::size_t 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;
}

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 446 of file G4EmCalculator.hh.

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

ComputeElectronicDEDX() [1/2]

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

Definition at line 451 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();
    std::size_t n = vel.size();
 
    //G4cout << "ComputeElectronicDEDX for " << part->GetParticleName() 
    //           << " n= " << n << G4endl;
 
    for(std::size_t i=0; i<n; ++i) {
      if(vel[i]) {
        auto p = static_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;
}

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 436 of file G4EmCalculator.hh.

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

ComputeEnergyCutFromRangeCut() [1/2]

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

Definition at line 741 of file G4EmCalculator.cc.

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

Referenced by ComputeDEDXForCutInRange(), and ComputeEnergyCutFromRangeCut().

ComputeEnergyCutFromRangeCut() [2/2]

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

inline

Definition at line 534 of file G4EmCalculator.hh.

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

ComputeGammaAttenuationLength()

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

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

ComputeMeanFreePath() [1/2]

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

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

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 546 of file G4EmCalculator.hh.

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

ComputeNuclearDEDX() [1/2]

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

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

Referenced by ComputeNuclearDEDX(), and ComputeTotalDEDX().

ComputeNuclearDEDX() [2/2]

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

inline

Definition at line 482 of file G4EmCalculator.hh.

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

ComputeShellIonisationCrossSectionPerAtom()

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

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

ComputeTotalDEDX() [1/2]

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

Definition at line 534 of file G4EmCalculator.cc.

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

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 458 of file G4EmCalculator.hh.

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

FindCouple()

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

Definition at line 848 of file G4EmCalculator.cc.

{
  const G4MaterialCutsCouple* couple = nullptr;
  SetupMaterial(material);
  if(nullptr != currentMaterial) {
    // Access to materials
    const G4ProductionCutsTable* theCoupleTable=
      G4ProductionCutsTable::GetProductionCutsTable();
    const G4Region* r = region;
    if(nullptr != r) {
      couple = theCoupleTable->GetMaterialCutsCouple(material,
                                                     r->GetProductionCuts());
    } else {
      G4RegionStore* store = G4RegionStore::GetInstance();
      std::size_t nr = store->size();
      if(0 < nr) {
        for(std::size_t i=0; i<nr; ++i) {
          couple = theCoupleTable->GetMaterialCutsCouple(
            material, ((*store)[i])->GetProductionCuts());
          if(nullptr != couple) { break; }
        }
      }
    }
  }
  if(nullptr == 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;
}

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

FindIon()

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

Definition at line 819 of file G4EmCalculator.cc.

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

FindMaterial()

const G4Material * G4EmCalculator::FindMaterial

(

const G4String &

name

)

Definition at line 827 of file G4EmCalculator.cc.

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

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

FindParticle()

const G4ParticleDefinition * G4EmCalculator::FindParticle

(

const G4String &

name

)

Definition at line 802 of file G4EmCalculator.cc.

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

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

FindProcess()

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

Definition at line 1148 of file G4EmCalculator.cc.

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

FindRegion()

const G4Region * G4EmCalculator::FindRegion

(

const G4String &

reg

)

Definition at line 841 of file G4EmCalculator.cc.

{
  return G4EmUtility::FindRegion(reg);
}

Referenced by 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 234 of file G4EmCalculator.cc.

{
  G4double res = 0.0;
  const G4MaterialCutsCouple* couple = FindCouple(mat,region);
 
  if(nullptr != 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(nullptr != emproc) {
    res = emproc->GetCrossSection(kinEnergy, couple);
      } else if(currentLambda) {
        // special tables are built for Msc models
    // procType is set in FindLambdaTable
        if(procType==2) {
          auto 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;
}

Referenced by GetCrossSectionPerVolume(), and GetMeanFreePath().

GetCrossSectionPerVolume() [2/2]

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

inline

Definition at line 410 of file G4EmCalculator.hh.

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

GetCSDARange() [1/2]

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

Definition at line 165 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(nullptr != 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;
}

Referenced by GetCSDARange(), and GetRange().

GetCSDARange() [2/2]

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

inline

Definition at line 376 of file G4EmCalculator.hh.

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

GetDEDX() [1/2]

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

Definition at line 102 of file G4EmCalculator.cc.

{
  G4double res = 0.0;
  const G4MaterialCutsCouple* couple = FindCouple(mat, region);
  if(nullptr != 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;
}

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

GetDEDX() [2/2]

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

inline

Definition at line 354 of file G4EmCalculator.hh.

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

GetKinEnergy() [1/2]

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

Definition at line 212 of file G4EmCalculator.cc.

{
  G4double res = 0.0;
  const G4MaterialCutsCouple* couple = FindCouple(mat,region);
  if(nullptr != 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;
}

Referenced by GetKinEnergy().

GetKinEnergy() [2/2]

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

inline

Definition at line 400 of file G4EmCalculator.hh.

{
  return GetKinEnergy(range,FindParticle(particle),
              FindMaterial(material),FindRegion(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 304 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;
}

Referenced by GetMeanFreePath().

GetMeanFreePath() [2/2]

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

inline

Definition at line 423 of file G4EmCalculator.hh.

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

GetRange() [1/2]

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

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

Referenced by GetRange().

GetRange() [2/2]

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

inline

Definition at line 388 of file G4EmCalculator.hh.

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

GetRangeFromRestricteDEDX() [1/2]

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

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

Referenced by GetRange(), and GetRangeFromRestricteDEDX().

GetRangeFromRestricteDEDX() [2/2]

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

inline

Definition at line 364 of file G4EmCalculator.hh.

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

GetShellIonisationCrossSectionPerAtom()

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

Definition at line 287 of file G4EmCalculator.cc.

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

operator=()

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

delete

PrintDEDXTable()

void G4EmCalculator::PrintDEDXTable

(

const G4ParticleDefinition *

p

)

Definition at line 325 of file G4EmCalculator.cc.

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

PrintInverseRangeTable()

void G4EmCalculator::PrintInverseRangeTable

(

const G4ParticleDefinition *

p

)

Definition at line 343 of file G4EmCalculator.cc.

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

PrintRangeTable()

void G4EmCalculator::PrintRangeTable

(

const G4ParticleDefinition *

p

)

Definition at line 334 of file G4EmCalculator.cc.

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

SetApplySmoothing()

void G4EmCalculator::SetApplySmoothing ( G4int val )

inline

Definition at line 558 of file G4EmCalculator.hh.

{
  applySmoothing = val;
}

SetupMaterial() [1/2]

void G4EmCalculator::SetupMaterial

(

const G4Material *

mat

)

Definition at line 1184 of file G4EmCalculator.cc.

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

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

SetupMaterial() [2/2]

void G4EmCalculator::SetupMaterial

(

const G4String &

mname

)

Definition at line 1197 of file G4EmCalculator.cc.

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

SetVerbose()

void G4EmCalculator::SetVerbose

(

G4int

val

)

Definition at line 1223 of file G4EmCalculator.cc.

{
  verbose = verb;
}

---

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

• G4EmCalculator.hh
• G4EmCalculator.cc