G4EmCalculator Class Reference

#include <G4EmCalculator.hh>

Inheritance diagram for G4EmCalculator:

Public Member Functions
	G4EmCalculator ()
	~G4EmCalculator ()
G4double	GetDEDX (G4double kinEnergy, const G4ParticleDefinition *, const G4Material *, const G4Region *r=0)
G4double	GetDEDX (G4double kinEnergy, const G4String &part, const G4String &mat, const G4String &s="world")
G4double	GetRangeFromRestricteDEDX (G4double kinEnergy, const G4ParticleDefinition *, const G4Material *, const G4Region *r=0)
G4double	GetRangeFromRestricteDEDX (G4double kinEnergy, const G4String &part, const G4String &mat, const G4String &s="world")
G4double	GetCSDARange (G4double kinEnergy, const G4ParticleDefinition *, const G4Material *, const G4Region *r=0)
G4double	GetCSDARange (G4double kinEnergy, const G4String &part, const G4String &mat, const G4String &s="world")
G4double	GetRange (G4double kinEnergy, const G4ParticleDefinition *, const G4Material *, const G4Region *r=0)
G4double	GetRange (G4double kinEnergy, const G4String &part, const G4String &mat, const G4String &s="world")
G4double	GetKinEnergy (G4double range, const G4ParticleDefinition *, const G4Material *, const G4Region *r=0)
G4double	GetKinEnergy (G4double range, const G4String &part, const G4String &mat, const G4String &s="world")
G4double	GetCrossSectionPerVolume (G4double kinEnergy, const G4ParticleDefinition *, const G4String &processName, const G4Material *, const G4Region *r=0)
G4double	GetCrossSectionPerVolume (G4double kinEnergy, const G4String &part, const G4String &proc, const G4String &mat, const G4String &s="world")
G4double	GetShellIonisationCrossSectionPerAtom (const G4String &part, G4int Z, G4AtomicShellEnumerator shell, G4double kinEnergy)
G4double	GetMeanFreePath (G4double kinEnergy, const G4ParticleDefinition *, const G4String &processName, const G4Material *, const G4Region *r=0)
G4double	GetMeanFreePath (G4double kinEnergy, const G4String &part, const G4String &proc, const G4String &mat, const G4String &s="world")
void	PrintDEDXTable (const G4ParticleDefinition *)
void	PrintRangeTable (const G4ParticleDefinition *)
void	PrintInverseRangeTable (const G4ParticleDefinition *)
G4double	ComputeDEDX (G4double kinEnergy, const G4ParticleDefinition *, const G4String &processName, const G4Material *, G4double cut=DBL_MAX)
G4double	ComputeDEDX (G4double kinEnergy, const G4String &part, const G4String &proc, const G4String &mat, G4double cut=DBL_MAX)
G4double	ComputeElectronicDEDX (G4double kinEnergy, const G4ParticleDefinition *, const G4Material *mat, G4double cut=DBL_MAX)
G4double	ComputeElectronicDEDX (G4double kinEnergy, const G4String &part, const G4String &mat, G4double cut=DBL_MAX)
G4double	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	ComputeGammaAttenuationLength (G4double kinEnergy, const G4Material *)
G4double	ComputeShellIonisationCrossSectionPerAtom (const G4String &part, G4int Z, G4AtomicShellEnumerator shell, G4double kinEnergy, const G4Material *mat=0)
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=0)
void	SetVerbose (G4int val)

Detailed Description

Definition at line 80 of file G4EmCalculator.hh.

Constructor & Destructor Documentation

G4EmCalculator::G4EmCalculator

(

)

Definition at line 89 of file G4EmCalculator.cc.

References G4LossTableManager::EmCorrections(), G4GenericIon::GenericIon(), G4ParticleTable::GetIonTable(), G4ParticleTable::GetParticleTable(), and G4LossTableManager::Instance().

{
  manager = G4LossTableManager::Instance();
  corr    = manager->EmCorrections();
  nLocalMaterials    = 0;
  verbose            = 0;
  currentCoupleIndex = 0;
  currentCouple      = 0;
  currentMaterial    = 0;
  currentParticle    = 0;
  lambdaParticle     = 0;
  baseParticle       = 0;
  currentLambda      = 0;
  currentModel       = 0;
  currentProcess     = 0;
  loweModel          = 0;
  chargeSquare       = 1.0;
  massRatio          = 1.0;
  mass               = 0.0;
  currentCut         = 0.0;
  currentParticleName= "";
  currentMaterialName= "";
  currentName        = "";
  lambdaName         = "";
  theGenericIon      = G4GenericIon::GenericIon();
  ionEffCharge       = new G4ionEffectiveCharge();
  ionTable           = G4ParticleTable::GetParticleTable()->GetIonTable();
  isIon              = false;
  isApplicable       = false;
}

G4EmCalculator::~G4EmCalculator

(

)

Definition at line 122 of file G4EmCalculator.cc.

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

Member Function Documentation

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

Definition at line 705 of file G4EmCalculator.cc.

References python.hepunit::barn, G4VEmModel::ComputeCrossSectionPerAtom(), g(), G4cout, G4endl, G4lrint(), G4ParticleDefinition::GetParticleName(), G4VEmModel::InitialiseForElement(), python.hepunit::MeV, and python.hepunit::mole.

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

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

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

Definition at line 739 of file G4EmCalculator.cc.

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

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

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

Definition at line 656 of file G4EmCalculator.cc.

References python.hepunit::cm, G4VEmModel::CrossSectionPerVolume(), G4cout, G4endl, G4Material::GetName(), G4ParticleDefinition::GetParticleName(), python.hepunit::keV, and python.hepunit::MeV.

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

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

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

Definition at line 691 of file G4EmCalculator.cc.

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

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

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

Definition at line 448 of file G4EmCalculator.cc.

References python.hepunit::cm2, G4VEmModel::ComputeDEDXPerVolume(), G4VEmModel::CorrectionsAlongStep(), FindCouple(), G4cout, G4endl, G4VEmModel::GetChargeSquareRatio(), G4Material::GetDensity(), G4Material::GetName(), G4VEmModel::GetName(), G4ParticleDefinition::GetParticleName(), python.hepunit::gram, G4VEmModel::LowEnergyLimit(), python.hepunit::MeV, python.hepunit::mm, and G4DynamicParticle::SetKineticEnergy().

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

{
  currentMaterial = mat;
  currentMaterialName = mat->GetName();
  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(baseParticle) {
        res = currentModel->ComputeDEDXPerVolume(
          mat, baseParticle, escaled, cut) * chargeSquare;
        if(verbose > 1) {
          G4cout <<  baseParticle->GetParticleName()
         << " Escaled(MeV)= " << escaled;
    }
      } else {
        res = currentModel->ComputeDEDXPerVolume(mat, p, kinEnergy, cut);
        if(verbose > 1) { G4cout <<  " no basePart E(MeV)= " << kinEnergy << " "; }
      }
      if(verbose > 1) {
    G4cout << currentModel->GetName() << ": DEDX(MeV/mm)= " << res*mm/MeV
           << " DEDX(MeV*cm^2/g)= "
           << res*gram/(MeV*cm2*mat->GetDensity())
           << G4endl;
      }

      // emulate smoothing procedure
      G4double eth = currentModel->LowEnergyLimit();
      // G4cout << "massRatio= " << massRatio << " eth= " << eth << G4endl;
      if(loweModel) {
        G4double res0 = 0.0;
        G4double res1 = 0.0;
        if(baseParticle) {
          res1 = currentModel->ComputeDEDXPerVolume(mat, baseParticle, eth, cut)
               * chargeSquare;
          res0 = loweModel->ComputeDEDXPerVolume(mat, baseParticle, eth, cut)
               * chargeSquare;
    } else {
      res1 = currentModel->ComputeDEDXPerVolume(mat, p, eth, cut);
      res0 = loweModel->ComputeDEDXPerVolume(mat, p, eth, cut);
    }
    if(verbose > 1) {
      G4cout << "At boundary energy(MeV)= " << eth/MeV
         << " DEDX(MeV/mm)= " << res1*mm/MeV
         << G4endl;
    }
    
        //G4cout << "eth= " << eth << " escaled= " << escaled
    //       << " res0= " << res0 << " res1= "
        //       << res1 <<  "  q2= " << chargeSquare << G4endl;
    
        if(res1 > 0.0 && escaled > 0.0) {
      res *= (1.0 + (res0/res1 - 1.0)*eth/escaled);
    }
      } 

      // low energy correction for ions
      if(isIon) {
        G4double length = CLHEP::nm;
    const G4Region* r = 0;
    const G4MaterialCutsCouple* couple = FindCouple(mat, r);
        G4double eloss = res*length;
        G4double niel  = 0.0;
        dynParticle.SetKineticEnergy(kinEnergy);
        currentModel->GetChargeSquareRatio(p, mat, kinEnergy);
        currentModel->CorrectionsAlongStep(couple,&dynParticle,eloss,niel,length);
        res = eloss/length; 
    
    if(verbose > 1) {
      G4cout << "After Corrections: DEDX(MeV/mm)= " << res*mm/MeV
         << " DEDX(MeV*cm^2/g)= " << res*gram/(MeV*cm2*mat->GetDensity())
         << G4endl;
    }
      }
    }
      
    if(verbose > 0) {
      G4cout << "Sum: E(MeV)= " << kinEnergy/MeV
         << " DEDX(MeV/mm)= " << res*mm/MeV
         << " DEDX(MeV*cm^2/g)= " << res*gram/(MeV*cm2*mat->GetDensity())
         << " cut(MeV)= " << cut/MeV
         << "  " <<  p->GetParticleName()
         << " in " <<  currentMaterialName
         << " Zi^2= " << chargeSquare
         << " isIon=" << isIon
         << G4endl;
    }
  }
  return res;
}

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

Definition at line 615 of file G4EmCalculator.cc.

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

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

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

Definition at line 551 of file G4EmCalculator.cc.

References ComputeDEDX(), G4LossTableManager::GetEnergyLossProcessVector(), G4Material::GetName(), G4LossTableManager::Instance(), and n.

Referenced by ComputeElectronicDEDX(), and ComputeTotalDEDX().

{
  currentMaterial = mat;
  currentMaterialName = mat->GetName();
  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;
}

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

Definition at line 585 of file G4EmCalculator.cc.

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

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

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

Definition at line 820 of file G4EmCalculator.cc.

References G4ProductionCutsTable::GetProductionCutsTable().

Referenced by ComputeEnergyCutFromRangeCut().

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

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

Definition at line 831 of file G4EmCalculator.cc.

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

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

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

Definition at line 753 of file G4EmCalculator.cc.

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

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

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

Definition at line 787 of file G4EmCalculator.cc.

References ComputeCrossSectionPerVolume(), DBL_MAX, G4cout, G4endl, G4Material::GetName(), G4ParticleDefinition::GetParticleName(), python.hepunit::MeV, python.hepunit::mm, and test::x.

Referenced by ComputeMeanFreePath().

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

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

Definition at line 808 of file G4EmCalculator.cc.

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

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

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

Definition at line 627 of file G4EmCalculator.cc.

References python.hepunit::cm2, G4cout, G4endl, G4Material::GetDensity(), G4ParticleDefinition::GetParticleName(), python.hepunit::gram, python.hepunit::MeV, python.hepunit::mm, and G4EmCorrections::NuclearDEDX().

Referenced by ComputeNuclearDEDX(), and ComputeTotalDEDX().

{

  G4double res = corr->NuclearDEDX(p, mat, kinEnergy, false);

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

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

Definition at line 646 of file G4EmCalculator.cc.

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

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

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

Definition at line 768 of file G4EmCalculator.cc.

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

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

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

Definition at line 593 of file G4EmCalculator.cc.

References ComputeElectronicDEDX(), ComputeNuclearDEDX(), and python.hepunit::MeV.

Referenced by ComputeTotalDEDX(), RunAction::GetEnergyFromCSDARange(), HadrontherapyInteractionParameters::GetStopping(), IORTInteractionParameters::GetStopping(), HadrontherapyInteractionParameters::GetStoppingTable(), IORTInteractionParameters::GetStoppingTable(), and Run::PrintSummary().

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

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

Definition at line 605 of file G4EmCalculator.cc.

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

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

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

Definition at line 958 of file G4EmCalculator.cc.

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

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

{
  const G4MaterialCutsCouple* couple = 0;
  if(material) {
    currentMaterial = material;
    currentMaterialName = material->GetName();
    // 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 " << material
       << " <" << currentMaterialName << " > and region " << region;
    G4Exception("G4EmCalculator::FindCouple", "em0078",
        FatalException, ed);
  }
  return couple;
}

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

Definition at line 922 of file G4EmCalculator.cc.

References G4IonTable::GetIon().

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

const G4Material * G4EmCalculator::FindMaterial

(

const G4String &

name

)

Definition at line 930 of file G4EmCalculator.cc.

References G4cout, G4endl, and G4Material::GetMaterial().

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

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

const G4ParticleDefinition * G4EmCalculator::FindParticle

(

const G4String &

name

)

Definition at line 905 of file G4EmCalculator.cc.

References G4ParticleTable::FindParticle(), G4cout, G4endl, and G4ParticleTable::GetParticleTable().

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

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

const G4Region * G4EmCalculator::FindRegion

(

const G4String &

reg

)

Definition at line 945 of file G4EmCalculator.cc.

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

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

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

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

Definition at line 321 of file G4EmCalculator.cc.

References python.hepunit::cm, ComputeCrossSectionPerVolume(), FindCouple(), G4cout, G4endl, G4MaterialCutsCouple::GetIndex(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), and python.hepunit::MeV.

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

{
  G4double res = 0.0;
  const G4MaterialCutsCouple* couple = FindCouple(mat,region);

  if(couple && UpdateParticle(p, kinEnergy)) {
    G4int idx = couple->GetIndex();
    FindLambdaTable(p, processName, kinEnergy);

    if(currentLambda) {
      G4double e = kinEnergy*massRatio;
      res = (((*currentLambda)[idx])->Value(e))*chargeSquare;
    } else {
      res = ComputeCrossSectionPerVolume(kinEnergy, p, processName, mat, 
                     kinEnergy);
    }
    if(verbose>0) {
      G4cout << "G4EmCalculator::GetXSPerVolume: E(MeV)= " << kinEnergy/MeV
         << " cross(cm-1)= " << res*cm
         << "  " <<  p->GetParticleName()
         << " in " <<  mat->GetName();
      if(verbose>1) 
    G4cout << "  idx= " << idx << "  Escaled((MeV)= " 
           << kinEnergy*massRatio 
           << "  q2= " << chargeSquare; 
      G4cout << G4endl;
    } 
  }
  return res;
}

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

Definition at line 358 of file G4EmCalculator.cc.

References FindMaterial(), FindParticle(), FindRegion(), and GetCrossSectionPerVolume().

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

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

Definition at line 204 of file G4EmCalculator.cc.

References FindCouple(), G4cout, G4endl, G4Exception(), G4LossTableManager::GetCSDARange(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4LossTableManager::Instance(), JustWarning, python.hepunit::MeV, and python.hepunit::mm.

Referenced by RunAction::BeginOfRunAction(), Run::ComputeStatistics(), GetCSDARange(), and RunAction::GetEnergyFromCSDARange().

{
  G4double res = 0.0;
  if(!G4LossTableManager::Instance()->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>0) {
      G4cout << "G4EmCalculator::GetRange: E(MeV)= " << kinEnergy/MeV
         << " range(mm)= " << res/mm
         << "  " <<  p->GetParticleName()
         << " in " <<  mat->GetName()
         << G4endl;
    }
  }
  return res;
}

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

Definition at line 268 of file G4EmCalculator.cc.

References FindMaterial(), FindParticle(), FindRegion(), and GetCSDARange().

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

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

Definition at line 132 of file G4EmCalculator.cc.

References python.hepunit::cm2, G4VEmModel::CorrectionsAlongStep(), FindCouple(), G4cout, G4endl, G4VEmModel::GetChargeSquareRatio(), G4LossTableManager::GetDEDX(), G4Material::GetDensity(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), python.hepunit::gram, python.hepunit::MeV, python.hepunit::mm, and G4DynamicParticle::SetKineticEnergy().

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

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

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

Definition at line 173 of file G4EmCalculator.cc.

References FindMaterial(), FindParticle(), FindRegion(), and GetDEDX().

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

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

Definition at line 290 of file G4EmCalculator.cc.

References FindCouple(), G4cout, G4endl, G4LossTableManager::GetEnergy(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), python.hepunit::GeV, python.hepunit::MeV, and python.hepunit::mm.

Referenced by GetKinEnergy().

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

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

Definition at line 312 of file G4EmCalculator.cc.

References FindMaterial(), FindParticle(), FindRegion(), and GetKinEnergy().

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

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

Definition at line 387 of file G4EmCalculator.cc.

References DBL_MAX, G4cout, G4endl, GetCrossSectionPerVolume(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), python.hepunit::MeV, python.hepunit::mm, and test::x.

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

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

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

Definition at line 408 of file G4EmCalculator.cc.

References FindMaterial(), FindParticle(), FindRegion(), and GetMeanFreePath().

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

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

Definition at line 235 of file G4EmCalculator.cc.

References FindCouple(), G4cout, G4endl, G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4LossTableManager::GetRange(), python.hepunit::MeV, and python.hepunit::mm.

Referenced by GetRange().

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

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

Definition at line 279 of file G4EmCalculator.cc.

References FindMaterial(), FindParticle(), FindRegion(), and GetRange().

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

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

Definition at line 182 of file G4EmCalculator.cc.

References FindCouple(), G4cout, G4endl, G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4LossTableManager::GetRangeFromRestricteDEDX(), python.hepunit::MeV, and python.hepunit::mm.

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

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

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

Definition at line 257 of file G4EmCalculator.cc.

References FindMaterial(), FindParticle(), FindRegion(), and GetRangeFromRestricteDEDX().

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

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

Definition at line 370 of file G4EmCalculator.cc.

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

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

void G4EmCalculator::PrintDEDXTable

(

const G4ParticleDefinition *

p

)

Definition at line 420 of file G4EmCalculator.cc.

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

Referenced by export_G4EmCalculator().

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

void G4EmCalculator::PrintInverseRangeTable

(

const G4ParticleDefinition *

p

)

Definition at line 438 of file G4EmCalculator.cc.

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

Referenced by export_G4EmCalculator().

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

void G4EmCalculator::PrintRangeTable

(

const G4ParticleDefinition *

p

)

Definition at line 429 of file G4EmCalculator.cc.

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

Referenced by export_G4EmCalculator().

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

void G4EmCalculator::SetVerbose

(

G4int

val

)

Definition at line 1280 of file G4EmCalculator.cc.

Referenced by export_G4EmCalculator().

{
  verbose = verb;
}

---

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

• G4EmCalculator.hh
• G4EmCalculator.cc