G4EmCorrections Class Reference

#include <G4EmCorrections.hh>

Public Member Functions
	G4EmCorrections ()
virtual	~G4EmCorrections ()
G4double	HighOrderCorrections (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy, G4double cutEnergy)
G4double	IonHighOrderCorrections (const G4ParticleDefinition *, const G4MaterialCutsCouple *, G4double kineticEnergy)
G4double	ComputeIonCorrections (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	IonBarkasCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	Bethe (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	SpinCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	KShellCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	LShellCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	ShellCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	ShellCorrectionSTD (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	DensityCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	BarkasCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	BlochCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	MottCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	NuclearDEDX (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy, G4bool fluct=true)
void	AddStoppingData (G4int Z, G4int A, const G4String &materialName, G4PhysicsVector *dVector)
void	InitialiseForNewRun ()
G4double	EffectiveChargeCorrection (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	GetParticleCharge (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
G4double	EffectiveChargeSquareRatio (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
void	SetIonisationModels (G4VEmModel *m1=0, G4VEmModel *m2=0)
G4int	GetNumberOfStoppingVectors ()

Detailed Description

Definition at line 71 of file G4EmCorrections.hh.

Constructor & Destructor Documentation

G4EmCorrections::G4EmCorrections

(

)

Definition at line 77 of file G4EmCorrections.cc.

References G4ParticleTable::GetIonTable(), G4ParticleTable::GetParticleTable(), G4NistManager::Instance(), python.hepunit::keV, and python.hepunit::MeV.

{
  particle   = 0;
  curParticle= 0;
  material   = 0;
  curMaterial= 0;
  curVector  = 0;
  kinEnergy  = 0.0;
  ionLEModel = 0;
  ionHEModel = 0;
  nIons      = 0;
  verbose    = 1;
  ncouples   = 0;
  massFactor = 1.0;
  eth        = 2.0*MeV;
  nbinCorr   = 20;
  eCorrMin   = 25.*keV;
  eCorrMax   = 250.*MeV;
  nist = G4NistManager::Instance();
  ionTable = G4ParticleTable::GetParticleTable()->GetIonTable();
  BarkasCorr = ThetaK = ThetaL = 0;
  Initialise();
}

G4EmCorrections::~G4EmCorrections ( )

virtual

Definition at line 103 of file G4EmCorrections.cc.

{
  //  for(G4int i=0; i<nIons; ++i) {delete stopData[i];}
  // delete BarkasCorr;
  // delete ThetaK;
  // delete ThetaL;
}

Member Function Documentation

void G4EmCorrections::AddStoppingData	(	G4int	Z,
		G4int	A,
		const G4String &	materialName,
		G4PhysicsVector *	dVector
	)

Definition at line 791 of file G4EmCorrections.cc.

References G4cout, and G4endl.

Referenced by G4ionIonisation::AddStoppingData().

{
  G4int i = 0;
  for(; i<nIons; ++i) {
    if(Z == Zion[i] && A == Aion[i] && mname == materialName[i]) break;
  }
  if(i == nIons) {
    Zion.push_back(Z);
    Aion.push_back(A);
    materialName.push_back(mname);
    materialList.push_back(0);
    ionList.push_back(0);
    stopData.push_back(dVector);
    nIons++;
    if(verbose>1) {
      G4cout << "AddStoppingData Z= " << Z << " A= " << A << " " << mname
         << "  idx= " << i << G4endl;
    }
  }
}

G4double G4EmCorrections::BarkasCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 575 of file G4EmCorrections.cc.

References test::b, G4PhysicsVector::Energy(), G4Material::GetName(), G4Material::GetTotNbOfAtomsPerVolume(), iz, and G4PhysicsVector::Value().

Referenced by ComputeIonCorrections(), HighOrderCorrections(), and IonBarkasCorrection().

{
  // . Z^3 Barkas effect in the stopping power of matter for charged particles
  //   J.C Ashley and R.H.Ritchie
  //   Physical review B Vol.5 No.7 1 April 1972 pp. 2393-2397
  //   valid for kineticEnergy > 0.5 MeV

  SetupKinematics(p, mat, e);
  G4double BarkasTerm = 0.0;

  for (G4int i = 0; i<numberOfElements; ++i) {

    G4double Z = (*theElementVector)[i]->GetZ();
    G4int iz = G4int(Z);
    if(iz == 47) {
      BarkasTerm += atomDensity[i]*0.006812*std::pow(beta,-0.9);
    } else if(iz >= 64) {
      BarkasTerm += atomDensity[i]*0.002833*std::pow(beta,-1.2);
    } else {    

      G4double X = ba2 / Z;
      G4double b = 1.3;
      if(1 == iz) {
    if(material->GetName() == "G4_lH2") { b = 0.6; }
    else                                { b = 1.8; }
      }
      else if(2 == iz)  { b = 0.6; }
      else if(10 >= iz) { b = 1.8; }
      else if(17 >= iz) { b = 1.4; }
      else if(18 == iz) { b = 1.8; }
      else if(25 >= iz) { b = 1.4; }
      else if(50 >= iz) { b = 1.35;}

      G4double W = b/std::sqrt(X);

      G4double val = BarkasCorr->Value(W);
      if(W > BarkasCorr->Energy(46)) { 
    val *= BarkasCorr->Energy(46)/W; 
      } 
      //    G4cout << "i= " << i << " b= " << b << " W= " << W 
      // << " Z= " << Z << " X= " << X << " val= " << val<< G4endl;
      BarkasTerm += val*atomDensity[i] / (std::sqrt(Z*X)*X);
    }
  }

  BarkasTerm *= 1.29*charge/material->GetTotNbOfAtomsPerVolume();

  // temporary protection
  //if(charge < -7.0 ) { BarkasTerm *= (-7.0/charge); }

  return BarkasTerm;
}

G4double G4EmCorrections::Bethe	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 249 of file G4EmCorrections.cc.

References python.hepunit::electron_mass_c2, G4Material::GetIonisation(), and G4IonisParamMat::GetMeanExcitationEnergy().

{
  SetupKinematics(p, mat, e);
  G4double eexc  = material->GetIonisation()->GetMeanExcitationEnergy();
  G4double eexc2 = eexc*eexc;
  G4double dedx = 0.5*std::log(2.0*electron_mass_c2*bg2*tmax/eexc2)-beta2;
  return dedx;
}

G4double G4EmCorrections::BlochCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 632 of file G4EmCorrections.cc.

Referenced by ComputeIonCorrections(), and HighOrderCorrections().

{
  SetupKinematics(p, mat, e);

  G4double y2 = q2/ba2;

  G4double term = 1.0/(1.0 + y2);
  G4double del;
  G4double j = 1.0;
  do {
    j += 1.0;
    del = 1.0/(j* (j*j + y2));
    term += del;
  } while (del > 0.01*term);

  G4double res = -y2*term;
  // temporary protection
  //if(q2 > 49. && res < -0.2) { res = -0.2; }

  return res;
}

G4double G4EmCorrections::ComputeIonCorrections	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 168 of file G4EmCorrections.cc.

References BarkasCorrection(), BlochCorrection(), G4cout, G4endl, G4Material::GetElectronDensity(), python.hepunit::MeV, MottCorrection(), and python.hepunit::twopi_mc2_rcl2.

Referenced by IonHighOrderCorrections().

{
  // . Z^3 Barkas effect in the stopping power of matter for charged particles
  //   J.C Ashley and R.H.Ritchie
  //   Physical review B Vol.5 No.7 1 April 1972 pagg. 2393-2397
  //   and ICRU49 report
  //   valid for kineticEnergy < 0.5 MeV
  //   Other corrections from S.P.Ahlen Rev. Mod. Phys., Vol 52, No1, 1980
  SetupKinematics(p, mat, e);
  if(tau <= 0.0) { return 0.0; }

  G4double Barkas = BarkasCorrection (p, mat, e);
  G4double Bloch  = BlochCorrection (p, mat, e);
  G4double Mott   = MottCorrection (p, mat, e);

  G4double sum = 2.0*(Barkas*(charge - 1.0)/charge + Bloch) + Mott;

  if(verbose > 1) {
    G4cout << "EmCorrections: E(MeV)= " << e/MeV << " Barkas= " << Barkas
       << " Bloch= " << Bloch << " Mott= " << Mott 
       << " Sum= " << sum << G4endl; 
  }
  sum *= material->GetElectronDensity() * q2 *  twopi_mc2_rcl2 /beta2;

  if(verbose > 1) { G4cout << " Sum= " << sum << G4endl; } 
  return sum;
}

G4double G4EmCorrections::DensityCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 548 of file G4EmCorrections.cc.

References G4IonisParamMat::GetAdensity(), G4IonisParamMat::GetCdensity(), G4Material::GetIonisation(), G4IonisParamMat::GetMdensity(), G4IonisParamMat::GetX0density(), and G4IonisParamMat::GetX1density().

{
  SetupKinematics(p, mat, e);

  G4double cden  = material->GetIonisation()->GetCdensity();
  G4double mden  = material->GetIonisation()->GetMdensity();
  G4double aden  = material->GetIonisation()->GetAdensity();
  G4double x0den = material->GetIonisation()->GetX0density();
  G4double x1den = material->GetIonisation()->GetX1density();

  G4double twoln10 = 2.0*std::log(10.0);
  G4double dedx = 0.0;

  // density correction
  G4double x = std::log(bg2)/twoln10;
  if ( x >= x0den ) {
    dedx = twoln10*x - cden ;
    if ( x < x1den ) dedx += aden*std::pow((x1den-x),mden) ;
  }

  return dedx;
}

G4double G4EmCorrections::EffectiveChargeCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 742 of file G4EmCorrections.cc.

References python.hepunit::amu_c2, python.hepunit::eplus, G4cout, G4endl, G4ParticleDefinition::GetAtomicNumber(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), python.hepunit::proton_mass_c2, and G4PhysicsVector::Value().

Referenced by G4BetheBlochModel::CorrectionsAlongStep(), G4BraggIonModel::CorrectionsAlongStep(), G4BetheBlochModel::GetChargeSquareRatio(), G4BraggIonModel::GetChargeSquareRatio(), and G4BraggModel::GetChargeSquareRatio().

{
  G4double factor = 1.0;
  if(p->GetPDGCharge() <= 2.5*eplus || nIons <= 0) return factor;
  /*
  if(verbose > 1) {
    G4cout << "EffectiveChargeCorrection: " << p->GetParticleName() 
       << " in " << mat->GetName()
           << " ekin(MeV)= " << ekin/MeV << G4endl;
  }
  */
  if(p != curParticle || mat != curMaterial) {
    curParticle = p;
    curMaterial = mat;
    curVector   = 0;
    currentZ = p->GetAtomicNumber();
    if(verbose > 1) {
      G4cout << "G4EmCorrections::EffectiveChargeCorrection: Zion= " 
         << currentZ << " Aion= " << p->GetPDGMass()/amu_c2 << G4endl;
    }
    massFactor = proton_mass_c2/p->GetPDGMass();
    idx = -1;

    for(G4int i=0; i<nIons; ++i) {
      if(materialList[i] == mat && currentZ == Zion[i]) {
        idx = i;
        break;
      }
    }
    //    G4cout << " idx= " << idx << " dz= " << G4endl;
    if(idx >= 0) {
      if(!ionList[idx]) BuildCorrectionVector(); 
      if(ionList[idx])  curVector = stopData[idx];
    } else { return factor; }
  }
  if(curVector) {
    factor = curVector->Value(ekin*massFactor);
    if(verbose > 1) {
      G4cout << "E= " << ekin << " factor= " << factor << " massfactor= " 
         << massFactor << G4endl;
    }
  }
  return factor;
}

G4double G4EmCorrections::EffectiveChargeSquareRatio ( const G4ParticleDefinition *  p, const G4Material *  mat, G4double  kineticEnergy  )

inline

Definition at line 335 of file G4EmCorrections.hh.

References G4ionEffectiveCharge::EffectiveChargeSquareRatio().

Referenced by G4BetheBlochModel::CorrectionsAlongStep(), G4BraggIonModel::CorrectionsAlongStep(), G4BetheBlochModel::GetChargeSquareRatio(), G4BraggModel::GetChargeSquareRatio(), G4BraggIonModel::GetChargeSquareRatio(), and G4UAtomicDeexcitation::GetShellIonisationCrossSectionPerAtom().

{
  return effCharge.EffectiveChargeSquareRatio(p,mat,kineticEnergy);
}

G4int G4EmCorrections::GetNumberOfStoppingVectors ( )

inline

Definition at line 321 of file G4EmCorrections.hh.

Referenced by G4ionIonisation::PrintInfo().

{
  return nIons;
}

G4double G4EmCorrections::GetParticleCharge ( const G4ParticleDefinition *  p, const G4Material *  mat, G4double  kineticEnergy  )

inline

Definition at line 327 of file G4EmCorrections.hh.

References G4ionEffectiveCharge::EffectiveCharge().

Referenced by G4BetheBlochModel::GetParticleCharge(), G4BraggModel::GetParticleCharge(), and G4BraggIonModel::GetParticleCharge().

{
  return effCharge.EffectiveCharge(p,mat,kineticEnergy);
}

G4double G4EmCorrections::HighOrderCorrections	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy,
		G4double	cutEnergy
	)

Definition at line 113 of file G4EmCorrections.cc.

References BarkasCorrection(), BlochCorrection(), G4cout, G4endl, G4Material::GetElectronDensity(), G4Material::GetName(), KShellCorrection(), LShellCorrection(), python.hepunit::MeV, MottCorrection(), ShellCorrection(), and python.hepunit::twopi_mc2_rcl2.

Referenced by G4MuBetheBlochModel::ComputeDEDXPerVolume(), and G4BetheBlochModel::ComputeDEDXPerVolume().

{
  // . Z^3 Barkas effect in the stopping power of matter for charged particles
  //   J.C Ashley and R.H.Ritchie
  //   Physical review B Vol.5 No.7 1 April 1972 pagg. 2393-2397
  //   and ICRU49 report
  //   valid for kineticEnergy < 0.5 MeV
  //   Other corrections from S.P.Ahlen Rev. Mod. Phys., Vol 52, No1, 1980

  SetupKinematics(p, mat, e);
  if(tau <= 0.0) { return 0.0; }

  G4double Barkas = BarkasCorrection (p, mat, e);
  G4double Bloch  = BlochCorrection (p, mat, e);
  G4double Mott   = MottCorrection (p, mat, e);

  G4double sum = (2.0*(Barkas + Bloch) + Mott);

  if(verbose > 1) {
    G4cout << "EmCorrections: E(MeV)= " << e/MeV << " Barkas= " << Barkas
       << " Bloch= " << Bloch << " Mott= " << Mott 
       << " Sum= " << sum << " q2= " << q2 << G4endl; 
    G4cout << " ShellCorrection: " << ShellCorrection(p, mat, e) 
       << " Kshell= " << KShellCorrection(p, mat, e)
       << " Lshell= " << LShellCorrection(p, mat, e)
       << "   " << mat->GetName() << G4endl;
  }
  sum *= material->GetElectronDensity() * q2 *  twopi_mc2_rcl2 /beta2;
  return sum;
}

void G4EmCorrections::InitialiseForNewRun

(

)

Definition at line 892 of file G4EmCorrections.cc.

References G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), and G4ProductionCutsTable::GetTableSize().

Referenced by G4ionIonisation::InitialiseEnergyLossProcess().

{
  G4ProductionCutsTable* tb = G4ProductionCutsTable::GetProductionCutsTable();
  ncouples = tb->GetTableSize();
  if(currmat.size() != ncouples) {
    currmat.resize(ncouples);
    for(std::map< G4int, std::vector<G4double> >::iterator it = 
        thcorr.begin(); it != thcorr.end(); ++it){
      (it->second).clear();
    }
    thcorr.clear();
    for(size_t i=0; i<ncouples; ++i) {
      currmat[i] = tb->GetMaterialCutsCouple(i)->GetMaterial();
      G4String nam = currmat[i]->GetName();
      for(G4int j=0; j<nIons; ++j) {
    if(nam == materialName[j]) { materialList[j] = currmat[i]; }
      }
    }
  }
}

G4double G4EmCorrections::IonBarkasCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 148 of file G4EmCorrections.cc.

References BarkasCorrection(), G4Material::GetElectronDensity(), and python.hepunit::twopi_mc2_rcl2.

Referenced by G4BetheBlochModel::ComputeDEDXPerVolume().

{
  // . Z^3 Barkas effect in the stopping power of matter for charged particles
  //   J.C Ashley and R.H.Ritchie
  //   Physical review B Vol.5 No.7 1 April 1972 pagg. 2393-2397
  //   and ICRU49 report
  //   valid for kineticEnergy < 0.5 MeV

  SetupKinematics(p, mat, e);
  G4double res = 0.0;
  if(tau > 0.0) 
    res = 2.0*BarkasCorrection(p, mat, e)*
      material->GetElectronDensity() * q2 *  twopi_mc2_rcl2 /beta2;
  return res;
}

G4double G4EmCorrections::IonHighOrderCorrections	(	const G4ParticleDefinition *	p,
		const G4MaterialCutsCouple *	couple,
		G4double	kineticEnergy
	)

Definition at line 200 of file G4EmCorrections.cc.

References ComputeIonCorrections(), python.hepunit::eplus, G4cout, G4endl, G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), python.hepunit::proton_mass_c2, and test::v.

Referenced by G4BetheBlochModel::CorrectionsAlongStep().

{
// . Z^3 Barkas effect in the stopping power of matter for charged particles
//   J.C Ashley and R.H.Ritchie
//   Physical review B Vol.5 No.7 1 April 1972 pagg. 2393-2397
//   and ICRU49 report
//   valid for kineticEnergy < 0.5 MeV
//   Other corrections from S.P.Ahlen Rev. Mod. Phys., Vol 52, No1, 1980

  G4double sum = 0.0;

  if(ionHEModel) {
    G4int Z = G4int(p->GetPDGCharge()/eplus + 0.5);
    if(Z >= 100)   Z = 99;
    else if(Z < 1) Z = 1;

    G4double ethscaled = eth*p->GetPDGMass()/proton_mass_c2;
    G4int ionPDG = p->GetPDGEncoding();
    if(thcorr.find(ionPDG)==thcorr.end()) {  // Not found: fill the map
      std::vector<G4double> v;
      for(size_t i=0; i<ncouples; ++i){
    v.push_back(ethscaled*ComputeIonCorrections(p,currmat[i],ethscaled));
      }
      thcorr.insert(std::pair< G4int, std::vector<G4double> >(ionPDG,v)); 
    }

    //G4cout << " map size=" << thcorr.size() << G4endl;
    //for(std::map< G4int, std::vector<G4double> >::iterator 
    //    it = thcorr.begin(); it != thcorr.end(); ++it){
    //  G4cout << "\t map element: first (key)=" << it->first  
    //         << "\t second (vector): vec size=" << (it->second).size() << G4endl;
    //  for(size_t i=0; i<(it->second).size(); ++i){
    //    G4cout << "\t \t vec element: [" << i << "]=" << (it->second)[i] << G4endl; 
    //  } 
    //}

    G4double rest = (thcorr.find(ionPDG)->second)[couple->GetIndex()];

    sum = ComputeIonCorrections(p,couple->GetMaterial(),e) - rest/e;

    if(verbose > 1) { G4cout << " Sum= " << sum << " dSum= " << rest/e << G4endl; } 
  }
  return sum;
}

G4double G4EmCorrections::KShellCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 273 of file G4EmCorrections.cc.

References G4Material::GetTotNbOfAtomsPerVolume(), iz, and G4PhysicsVector::Value().

Referenced by HighOrderCorrections().

{
  SetupKinematics(p, mat, e);
  G4double term = 0.0;
  for (G4int i = 0; i<numberOfElements; ++i) {

    G4double Z = (*theElementVector)[i]->GetZ();
    G4int   iz = G4int(Z);
    G4double f = 1.0;
    G4double Z2= (Z-0.3)*(Z-0.3);
    if(1 == iz) {
      f  = 0.5;
      Z2 = 1.0;
    }
    G4double eta = ba2/Z2;
    G4double tet = Z2*(1. + Z2*0.25*alpha2);
    if(11 < iz) { tet = ThetaK->Value(Z); }
    term += f*atomDensity[i]*KShell(tet,eta)/Z;
  }

  term /= material->GetTotNbOfAtomsPerVolume();

  return term;
}

G4double G4EmCorrections::LShellCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 302 of file G4EmCorrections.cc.

References G4AtomicShells::GetNumberOfElectrons(), G4AtomicShells::GetNumberOfShells(), G4Material::GetTotNbOfAtomsPerVolume(), iz, G4INCL::Math::min(), nmax, and G4PhysicsVector::Value().

Referenced by HighOrderCorrections().

{
  SetupKinematics(p, mat, e);
  G4double term = 0.0;
  for (G4int i = 0; i<numberOfElements; ++i) {

    G4double Z = (*theElementVector)[i]->GetZ();
    G4int   iz = G4int(Z);
    if(2 < iz) {
      G4double Zeff = Z - ZD[10];
      if(iz < 10) { Zeff = Z - ZD[iz]; }
      G4double Z2= Zeff*Zeff;
      G4double f = 0.125;
      G4double eta = ba2/Z2;
      G4double tet = ThetaL->Value(Z);
      G4int nmax = std::min(4,G4AtomicShells::GetNumberOfShells(iz));
      for(G4int j=1; j<nmax; ++j) {
        G4int ne = G4AtomicShells::GetNumberOfElectrons(iz,j);
    if(15 >= iz) {
      if(3 > j) { tet = 0.25*Z2*(1.0 + 5*Z2*alpha2/16.); }
      else      { tet = 0.25*Z2*(1.0 + Z2*alpha2/16.); }
    }
    //G4cout << " LShell: j= " << j << " ne= " << ne << " e(eV)= " << e/eV
    //       << " ThetaL= " << tet << G4endl;
        term += f*ne*atomDensity[i]*LShell(tet,eta)/Z;
      }
    }
  }

  term /= material->GetTotNbOfAtomsPerVolume();

  return term;
}

G4double G4EmCorrections::MottCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 658 of file G4EmCorrections.cc.

References python.hepunit::fine_structure_const.

Referenced by ComputeIonCorrections(), and HighOrderCorrections().

{
  SetupKinematics(p, mat, e);
  G4double mterm = CLHEP::pi*fine_structure_const*beta*charge;
  return mterm;
}

G4double G4EmCorrections::NuclearDEDX	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy,
		G4bool	fluct = true
	)

Definition at line 669 of file G4EmCorrections.cc.

References python.hepunit::amu_c2, python.hepunit::eplus, g(), G4Element::GetA(), G4ParticleDefinition::GetPDGCharge(), G4Element::GetZ(), and python.hepunit::mole.

Referenced by G4EmCalculator::ComputeNuclearDEDX().

{
  G4double nloss = 0.0;
  if(e <= 0.0) return nloss; 
  SetupKinematics(p, mat, e);

  lossFlucFlag = fluct;

  // Projectile nucleus
  G4double z1 = std::fabs(particle->GetPDGCharge()/eplus);
  G4double mass1 = mass/amu_c2;

  //  loop for the elements in the material
  for (G4int iel=0; iel<numberOfElements; iel++) {
    const G4Element* element = (*theElementVector)[iel] ;
    G4double z2 = element->GetZ();
    G4double mass2 = element->GetA()*mole/g ;
    nloss += (NuclearStoppingPower(kinEnergy, z1, z2, mass1, mass2))
           * atomDensity[iel] ;
  }
  nloss *= theZieglerFactor;
  return nloss;
}

void G4EmCorrections::SetIonisationModels ( G4VEmModel *  m1 = 0, G4VEmModel *  m2 = 0  )

inline

Definition at line 315 of file G4EmCorrections.hh.

Referenced by G4ionIonisation::InitialiseEnergyLossProcess().

{
  if(mod1) { ionLEModel = mod1; }
  if(mod2) { ionHEModel = mod2; }
}

G4double G4EmCorrections::ShellCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 459 of file G4EmCorrections.cc.

References G4AtomicShells::GetNumberOfElectrons(), G4AtomicShells::GetNumberOfShells(), G4Material::GetTotNbOfAtomsPerVolume(), iz, G4INCL::Math::min(), nmax, and G4PhysicsVector::Value().

Referenced by G4MuBetheBlochModel::ComputeDEDXPerVolume(), G4BetheBlochModel::ComputeDEDXPerVolume(), and HighOrderCorrections().

{
  SetupKinematics(p, mat, ekin);

  G4double term = 0.0;
  //G4cout << "### G4EmCorrections::ShellCorrection " << mat->GetName()
  //     << "   " << ekin/MeV << " MeV " << G4endl;
  for (G4int i = 0; i<numberOfElements; ++i) {

    G4double res = 0.0;
    G4double res0 = 0.0;
    G4double Z = (*theElementVector)[i]->GetZ();
    G4int   iz = G4int(Z);
    G4double Z2= (Z-0.3)*(Z-0.3);
    G4double f = 1.0;
    if(1 == iz) {
      f  = 0.5;
      Z2 = 1.0;
    }
    G4double eta = ba2/Z2;
    G4double tet = Z2*(1. + Z2*0.25*alpha2);
    if(11 < iz) { tet = ThetaK->Value(Z); }
    res0 = f*KShell(tet,eta);
    res += res0;
    //G4cout << " Z= " << iz << " Shell 0" << " tet= " << tet 
    //       << " eta= " << eta << "  resK= " << res0 << G4endl;
    if(2 < iz) {
      G4double Zeff = Z - ZD[10];
      if(iz < 10) { Zeff = Z - ZD[iz]; }
      Z2= Zeff*Zeff;
      eta = ba2/Z2;
      f = 0.125;
      tet = ThetaL->Value(Z);
      G4int ntot = G4AtomicShells::GetNumberOfShells(iz);
      G4int nmax = std::min(4, ntot);
      G4double norm   = 0.0;
      G4double eshell = 0.0;
      for(G4int j=1; j<nmax; ++j) {
        G4int ne = G4AtomicShells::GetNumberOfElectrons(iz,j);
    if(15 >= iz) {
      if(3 > j) { tet = 0.25*Z2*(1.0 + 5*Z2*alpha2/16.); }
      else      { tet = 0.25*Z2*(1.0 + Z2*alpha2/16.); }
    }
    norm   += ne;
    eshell += tet*ne;
        res0 = f*ne*LShell(tet,eta);
        res += res0;
    //G4cout << " Z= " << iz << " Shell " << j << " Ne= " << ne
    //       << " tet= " << tet << " eta= " << eta 
    //       << "  resL= " << res0 << G4endl;
      }
      if(ntot > nmax) {
    eshell /= norm;
    // Add M-shell
        if(28 > iz) {
          res += f*(iz - 10)*LShell(eshell,HM[iz-11]*eta);
    } else if(63 > iz) { 
          res += f*18*LShell(eshell,HM[iz-11]*eta);
    } else {
          res += f*18*LShell(eshell,HM[52]*eta);
    }
    // Add N-shell
        if(32 < iz) {
          if(60 > iz) {
        res += f*(iz - 28)*LShell(eshell,HN[iz-33]*eta);
      } else if(63 > iz) {
        res += 4*LShell(eshell,HN[iz-33]*eta);
      } else {
        res += 4*LShell(eshell,HN[30]*eta);
      }
      // Add O-P-shells
      if(60 < iz) {
        res += f*(iz - 60)*LShell(eshell,150*eta);
          }
    }
      }
    }
    term += res*atomDensity[i]/Z;
  }

  term /= material->GetTotNbOfAtomsPerVolume();
  //G4cout << "#     Shell Correction= " << term << G4endl;
  return term;
}

G4double G4EmCorrections::ShellCorrectionSTD	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 425 of file G4EmCorrections.cc.

References G4Material::GetIonisation(), G4IonisParamMat::GetShellCorrectionVector(), G4IonisParamMat::GetTaul(), python.hepunit::MeV, and test::x.

{
  SetupKinematics(p, mat, e);
  G4double taulim= 8.0*MeV/mass;
  G4double bg2lim= taulim * (taulim+2.0);

  G4double* shellCorrectionVector =
            material->GetIonisation()->GetShellCorrectionVector();
  G4double sh = 0.0;
  G4double x  = 1.0;
  G4double taul  = material->GetIonisation()->GetTaul();

  if ( bg2 >= bg2lim ) {
    for (G4int k=0; k<3; k++) {
        x *= bg2 ;
        sh += shellCorrectionVector[k]/x;
    }

  } else {
    for (G4int k=0; k<3; k++) {
        x *= bg2lim ;
        sh += shellCorrectionVector[k]/x;
    }
    sh *= std::log(tau/taul)/std::log(taulim/taul);
  }
  sh *= 0.5;
  return sh;
}

G4double G4EmCorrections::SpinCorrection	(	const G4ParticleDefinition *	p,
		const G4Material *	mat,
		G4double	kineticEnergy
	)

Definition at line 262 of file G4EmCorrections.cc.

{
  SetupKinematics(p, mat, e);
  G4double dedx  = 0.5*tmax/(kinEnergy + mass);
  return 0.5*dedx*dedx;
}

---

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

• G4EmCorrections.hh
• G4EmCorrections.cc