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(), and G4NistManager::Instance().

00078 {
00079   particle   = 0;
00080   curParticle= 0;
00081   material   = 0;
00082   curMaterial= 0;
00083   curVector  = 0;
00084   kinEnergy  = 0.0;
00085   ionLEModel = 0;
00086   ionHEModel = 0;
00087   nIons      = 0;
00088   verbose    = 1;
00089   ncouples   = 0;
00090   massFactor = 1.0;
00091   eth        = 2.0*MeV;
00092   nbinCorr   = 20;
00093   eCorrMin   = 25.*keV;
00094   eCorrMax   = 250.*MeV;
00095   nist = G4NistManager::Instance();
00096   ionTable = G4ParticleTable::GetParticleTable()->GetIonTable();
00097   BarkasCorr = ThetaK = ThetaL = 0;
00098   Initialise();
00099 }

G4EmCorrections::~G4EmCorrections (  )  [virtual]

Definition at line 103 of file G4EmCorrections.cc.

00104 {
00105   for(G4int i=0; i<nIons; ++i) {delete stopData[i];}
00106   delete BarkasCorr;
00107   delete ThetaK;
00108   delete ThetaL;
00109 }

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().

00794 {
00795   G4int i = 0;
00796   for(; i<nIons; ++i) {
00797     if(Z == Zion[i] && A == Aion[i] && mname == materialName[i]) break;
00798   }
00799   if(i == nIons) {
00800     Zion.push_back(Z);
00801     Aion.push_back(A);
00802     materialName.push_back(mname);
00803     materialList.push_back(0);
00804     ionList.push_back(0);
00805     stopData.push_back(dVector);
00806     nIons++;
00807     if(verbose>1) {
00808       G4cout << "AddStoppingData Z= " << Z << " A= " << A << " " << mname
00809              << "  idx= " << i << G4endl;
00810     }
00811   }
00812 }

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

Definition at line 575 of file G4EmCorrections.cc.

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

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

00578 {
00579   // . Z^3 Barkas effect in the stopping power of matter for charged particles
00580   //   J.C Ashley and R.H.Ritchie
00581   //   Physical review B Vol.5 No.7 1 April 1972 pp. 2393-2397
00582   //   valid for kineticEnergy > 0.5 MeV
00583 
00584   SetupKinematics(p, mat, e);
00585   G4double BarkasTerm = 0.0;
00586 
00587   for (G4int i = 0; i<numberOfElements; ++i) {
00588 
00589     G4double Z = (*theElementVector)[i]->GetZ();
00590     G4int iz = G4int(Z);
00591     if(iz == 47) {
00592       BarkasTerm += atomDensity[i]*0.006812*std::pow(beta,-0.9);
00593     } else if(iz >= 64) {
00594       BarkasTerm += atomDensity[i]*0.002833*std::pow(beta,-1.2);
00595     } else {    
00596 
00597       G4double X = ba2 / Z;
00598       G4double b = 1.3;
00599       if(1 == iz) {
00600         if(material->GetName() == "G4_lH2") { b = 0.6; }
00601         else                                { b = 1.8; }
00602       }
00603       else if(2 == iz)  { b = 0.6; }
00604       else if(10 >= iz) { b = 1.8; }
00605       else if(17 >= iz) { b = 1.4; }
00606       else if(18 == iz) { b = 1.8; }
00607       else if(25 >= iz) { b = 1.4; }
00608       else if(50 >= iz) { b = 1.35;}
00609 
00610       G4double W = b/std::sqrt(X);
00611 
00612       G4double val = BarkasCorr->Value(W);
00613       if(W > BarkasCorr->Energy(46)) { 
00614         val *= BarkasCorr->Energy(46)/W; 
00615       } 
00616       //    G4cout << "i= " << i << " b= " << b << " W= " << W 
00617       // << " Z= " << Z << " X= " << X << " val= " << val<< G4endl;
00618       BarkasTerm += val*atomDensity[i] / (std::sqrt(Z*X)*X);
00619     }
00620   }
00621 
00622   BarkasTerm *= 1.29*charge/material->GetTotNbOfAtomsPerVolume();
00623 
00624   // temporary protection
00625   //if(charge < -7.0 ) { BarkasTerm *= (-7.0/charge); }
00626 
00627   return BarkasTerm;
00628 }

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

Definition at line 249 of file G4EmCorrections.cc.

References G4Material::GetIonisation(), and G4IonisParamMat::GetMeanExcitationEnergy().

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

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

Definition at line 632 of file G4EmCorrections.cc.

Referenced by ComputeIonCorrections(), and HighOrderCorrections().

00635 {
00636   SetupKinematics(p, mat, e);
00637 
00638   G4double y2 = q2/ba2;
00639 
00640   G4double term = 1.0/(1.0 + y2);
00641   G4double del;
00642   G4double j = 1.0;
00643   do {
00644     j += 1.0;
00645     del = 1.0/(j* (j*j + y2));
00646     term += del;
00647   } while (del > 0.01*term);
00648 
00649   G4double res = -y2*term;
00650   // temporary protection
00651   //if(q2 > 49. && res < -0.2) { res = -0.2; }
00652 
00653   return res;
00654 }

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

Definition at line 168 of file G4EmCorrections.cc.

References BarkasCorrection(), BlochCorrection(), G4cout, G4endl, G4Material::GetElectronDensity(), and MottCorrection().

Referenced by IonHighOrderCorrections().

00171 {
00172   // . Z^3 Barkas effect in the stopping power of matter for charged particles
00173   //   J.C Ashley and R.H.Ritchie
00174   //   Physical review B Vol.5 No.7 1 April 1972 pagg. 2393-2397
00175   //   and ICRU49 report
00176   //   valid for kineticEnergy < 0.5 MeV
00177   //   Other corrections from S.P.Ahlen Rev. Mod. Phys., Vol 52, No1, 1980
00178   SetupKinematics(p, mat, e);
00179   if(tau <= 0.0) { return 0.0; }
00180 
00181   G4double Barkas = BarkasCorrection (p, mat, e);
00182   G4double Bloch  = BlochCorrection (p, mat, e);
00183   G4double Mott   = MottCorrection (p, mat, e);
00184 
00185   G4double sum = 2.0*(Barkas*(charge - 1.0)/charge + Bloch) + Mott;
00186 
00187   if(verbose > 1) {
00188     G4cout << "EmCorrections: E(MeV)= " << e/MeV << " Barkas= " << Barkas
00189            << " Bloch= " << Bloch << " Mott= " << Mott 
00190            << " Sum= " << sum << G4endl; 
00191   }
00192   sum *= material->GetElectronDensity() * q2 *  twopi_mc2_rcl2 /beta2;
00193 
00194   if(verbose > 1) { G4cout << " Sum= " << sum << G4endl; } 
00195   return sum;
00196 }

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

Definition at line 548 of file G4EmCorrections.cc.

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

00551 {
00552   SetupKinematics(p, mat, e);
00553 
00554   G4double cden  = material->GetIonisation()->GetCdensity();
00555   G4double mden  = material->GetIonisation()->GetMdensity();
00556   G4double aden  = material->GetIonisation()->GetAdensity();
00557   G4double x0den = material->GetIonisation()->GetX0density();
00558   G4double x1den = material->GetIonisation()->GetX1density();
00559 
00560   G4double twoln10 = 2.0*std::log(10.0);
00561   G4double dedx = 0.0;
00562 
00563   // density correction
00564   G4double x = std::log(bg2)/twoln10;
00565   if ( x >= x0den ) {
00566     dedx = twoln10*x - cden ;
00567     if ( x < x1den ) dedx += aden*std::pow((x1den-x),mden) ;
00568   }
00569 
00570   return dedx;
00571 }

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

Definition at line 742 of file G4EmCorrections.cc.

References G4cout, G4endl, G4ParticleDefinition::GetAtomicNumber(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), and G4PhysicsVector::Value().

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

00745 {
00746   G4double factor = 1.0;
00747   if(p->GetPDGCharge() <= 2.5*eplus || nIons <= 0) return factor;
00748   /*
00749   if(verbose > 1) {
00750     G4cout << "EffectiveChargeCorrection: " << p->GetParticleName() 
00751            << " in " << mat->GetName()
00752            << " ekin(MeV)= " << ekin/MeV << G4endl;
00753   }
00754   */
00755   if(p != curParticle || mat != curMaterial) {
00756     curParticle = p;
00757     curMaterial = mat;
00758     curVector   = 0;
00759     currentZ = p->GetAtomicNumber();
00760     if(verbose > 1) {
00761       G4cout << "G4EmCorrections::EffectiveChargeCorrection: Zion= " 
00762              << currentZ << " Aion= " << p->GetPDGMass()/amu_c2 << G4endl;
00763     }
00764     massFactor = proton_mass_c2/p->GetPDGMass();
00765     idx = -1;
00766 
00767     for(G4int i=0; i<nIons; ++i) {
00768       if(materialList[i] == mat && currentZ == Zion[i]) {
00769         idx = i;
00770         break;
00771       }
00772     }
00773     //    G4cout << " idx= " << idx << " dz= " << G4endl;
00774     if(idx >= 0) {
00775       if(!ionList[idx]) BuildCorrectionVector(); 
00776       if(ionList[idx])  curVector = stopData[idx];
00777     } else { return factor; }
00778   }
00779   if(curVector) {
00780     factor = curVector->Value(ekin*massFactor);
00781     if(verbose > 1) {
00782       G4cout << "E= " << ekin << " factor= " << factor << " massfactor= " 
00783              << massFactor << G4endl;
00784     }
00785   }
00786   return factor;
00787 }

G4double G4EmCorrections::EffectiveChargeSquareRatio ( const G4ParticleDefinition *  ,
const G4Material *  ,
G4double  kineticEnergy 
) [inline]

Definition at line 335 of file G4EmCorrections.hh.

References G4ionEffectiveCharge::EffectiveChargeSquareRatio().

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

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

G4int G4EmCorrections::GetNumberOfStoppingVectors (  )  [inline]

Definition at line 321 of file G4EmCorrections.hh.

Referenced by G4ionIonisation::PrintInfo().

00322 {
00323   return nIons;
00324 }

G4double G4EmCorrections::GetParticleCharge ( const G4ParticleDefinition *  ,
const G4Material *  ,
G4double  kineticEnergy 
) [inline]

Definition at line 327 of file G4EmCorrections.hh.

References G4ionEffectiveCharge::EffectiveCharge().

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

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

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

Definition at line 113 of file G4EmCorrections.cc.

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

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

00116 {
00117   // . Z^3 Barkas effect in the stopping power of matter for charged particles
00118   //   J.C Ashley and R.H.Ritchie
00119   //   Physical review B Vol.5 No.7 1 April 1972 pagg. 2393-2397
00120   //   and ICRU49 report
00121   //   valid for kineticEnergy < 0.5 MeV
00122   //   Other corrections from S.P.Ahlen Rev. Mod. Phys., Vol 52, No1, 1980
00123 
00124   SetupKinematics(p, mat, e);
00125   if(tau <= 0.0) { return 0.0; }
00126 
00127   G4double Barkas = BarkasCorrection (p, mat, e);
00128   G4double Bloch  = BlochCorrection (p, mat, e);
00129   G4double Mott   = MottCorrection (p, mat, e);
00130 
00131   G4double sum = (2.0*(Barkas + Bloch) + Mott);
00132 
00133   if(verbose > 1) {
00134     G4cout << "EmCorrections: E(MeV)= " << e/MeV << " Barkas= " << Barkas
00135            << " Bloch= " << Bloch << " Mott= " << Mott 
00136            << " Sum= " << sum << " q2= " << q2 << G4endl; 
00137     G4cout << " ShellCorrection: " << ShellCorrection(p, mat, e) 
00138            << " Kshell= " << KShellCorrection(p, mat, e)
00139            << " Lshell= " << LShellCorrection(p, mat, e)
00140            << "   " << mat->GetName() << G4endl;
00141   }
00142   sum *= material->GetElectronDensity() * q2 *  twopi_mc2_rcl2 /beta2;
00143   return sum;
00144 }

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().

00893 {
00894   G4ProductionCutsTable* tb = G4ProductionCutsTable::GetProductionCutsTable();
00895   ncouples = tb->GetTableSize();
00896   if(currmat.size() != ncouples) {
00897     currmat.resize(ncouples);
00898     for(std::map< G4int, std::vector<G4double> >::iterator it = 
00899         thcorr.begin(); it != thcorr.end(); ++it){
00900       (it->second).clear();
00901     }
00902     thcorr.clear();
00903     for(size_t i=0; i<ncouples; ++i) {
00904       currmat[i] = tb->GetMaterialCutsCouple(i)->GetMaterial();
00905       G4String nam = currmat[i]->GetName();
00906       for(G4int j=0; j<nIons; ++j) {
00907         if(nam == materialName[j]) { materialList[j] = currmat[i]; }
00908       }
00909     }
00910   }
00911 }

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

Definition at line 148 of file G4EmCorrections.cc.

References BarkasCorrection(), and G4Material::GetElectronDensity().

Referenced by G4BetheBlochModel::ComputeDEDXPerVolume().

00151 {
00152   // . Z^3 Barkas effect in the stopping power of matter for charged particles
00153   //   J.C Ashley and R.H.Ritchie
00154   //   Physical review B Vol.5 No.7 1 April 1972 pagg. 2393-2397
00155   //   and ICRU49 report
00156   //   valid for kineticEnergy < 0.5 MeV
00157 
00158   SetupKinematics(p, mat, e);
00159   G4double res = 0.0;
00160   if(tau > 0.0) 
00161     res = 2.0*BarkasCorrection(p, mat, e)*
00162       material->GetElectronDensity() * q2 *  twopi_mc2_rcl2 /beta2;
00163   return res;
00164 }

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

Definition at line 200 of file G4EmCorrections.cc.

References ComputeIonCorrections(), G4cout, G4endl, G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGEncoding(), and G4ParticleDefinition::GetPDGMass().

Referenced by G4BetheBlochModel::CorrectionsAlongStep().

00203 {
00204 // . Z^3 Barkas effect in the stopping power of matter for charged particles
00205 //   J.C Ashley and R.H.Ritchie
00206 //   Physical review B Vol.5 No.7 1 April 1972 pagg. 2393-2397
00207 //   and ICRU49 report
00208 //   valid for kineticEnergy < 0.5 MeV
00209 //   Other corrections from S.P.Ahlen Rev. Mod. Phys., Vol 52, No1, 1980
00210 
00211   G4double sum = 0.0;
00212 
00213   if(ionHEModel) {
00214     G4int Z = G4int(p->GetPDGCharge()/eplus + 0.5);
00215     if(Z >= 100)   Z = 99;
00216     else if(Z < 1) Z = 1;
00217 
00218     G4double ethscaled = eth*p->GetPDGMass()/proton_mass_c2;
00219     G4int ionPDG = p->GetPDGEncoding();
00220     if(thcorr.find(ionPDG)==thcorr.end()) {  // Not found: fill the map
00221       std::vector<G4double> v;
00222       for(size_t i=0; i<ncouples; ++i){
00223         v.push_back(ethscaled*ComputeIonCorrections(p,currmat[i],ethscaled));
00224       }
00225       thcorr.insert(std::pair< G4int, std::vector<G4double> >(ionPDG,v)); 
00226     }
00227 
00228     //G4cout << " map size=" << thcorr.size() << G4endl;
00229     //for(std::map< G4int, std::vector<G4double> >::iterator 
00230     //    it = thcorr.begin(); it != thcorr.end(); ++it){
00231     //  G4cout << "\t map element: first (key)=" << it->first  
00232     //         << "\t second (vector): vec size=" << (it->second).size() << G4endl;
00233     //  for(size_t i=0; i<(it->second).size(); ++i){
00234     //    G4cout << "\t \t vec element: [" << i << "]=" << (it->second)[i] << G4endl; 
00235     //  } 
00236     //}
00237 
00238     G4double rest = (thcorr.find(ionPDG)->second)[couple->GetIndex()];
00239 
00240     sum = ComputeIonCorrections(p,couple->GetMaterial(),e) - rest/e;
00241 
00242     if(verbose > 1) { G4cout << " Sum= " << sum << " dSum= " << rest/e << G4endl; } 
00243   }
00244   return sum;
00245 }

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

Definition at line 273 of file G4EmCorrections.cc.

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

Referenced by HighOrderCorrections().

00276 {
00277   SetupKinematics(p, mat, e);
00278   G4double term = 0.0;
00279   for (G4int i = 0; i<numberOfElements; ++i) {
00280 
00281     G4double Z = (*theElementVector)[i]->GetZ();
00282     G4int   iz = G4int(Z);
00283     G4double f = 1.0;
00284     G4double Z2= (Z-0.3)*(Z-0.3);
00285     if(1 == iz) {
00286       f  = 0.5;
00287       Z2 = 1.0;
00288     }
00289     G4double eta = ba2/Z2;
00290     G4double tet = Z2*(1. + Z2*0.25*alpha2);
00291     if(11 < iz) { tet = ThetaK->Value(Z); }
00292     term += f*atomDensity[i]*KShell(tet,eta)/Z;
00293   }
00294 
00295   term /= material->GetTotNbOfAtomsPerVolume();
00296 
00297   return term;
00298 }

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

Definition at line 302 of file G4EmCorrections.cc.

References G4AtomicShells::GetNumberOfElectrons(), G4AtomicShells::GetNumberOfShells(), G4Material::GetTotNbOfAtomsPerVolume(), and G4PhysicsVector::Value().

Referenced by HighOrderCorrections().

00305 {
00306   SetupKinematics(p, mat, e);
00307   G4double term = 0.0;
00308   for (G4int i = 0; i<numberOfElements; ++i) {
00309 
00310     G4double Z = (*theElementVector)[i]->GetZ();
00311     G4int   iz = G4int(Z);
00312     if(2 < iz) {
00313       G4double Zeff = Z - ZD[10];
00314       if(iz < 10) { Zeff = Z - ZD[iz]; }
00315       G4double Z2= Zeff*Zeff;
00316       G4double f = 0.125;
00317       G4double eta = ba2/Z2;
00318       G4double tet = ThetaL->Value(Z);
00319       G4int nmax = std::min(4,G4AtomicShells::GetNumberOfShells(iz));
00320       for(G4int j=1; j<nmax; ++j) {
00321         G4int ne = G4AtomicShells::GetNumberOfElectrons(iz,j);
00322         if(15 >= iz) {
00323           if(3 > j) { tet = 0.25*Z2*(1.0 + 5*Z2*alpha2/16.); }
00324           else      { tet = 0.25*Z2*(1.0 + Z2*alpha2/16.); }
00325         }
00326         //G4cout << " LShell: j= " << j << " ne= " << ne << " e(eV)= " << e/eV
00327         //       << " ThetaL= " << tet << G4endl;
00328         term += f*ne*atomDensity[i]*LShell(tet,eta)/Z;
00329       }
00330     }
00331   }
00332 
00333   term /= material->GetTotNbOfAtomsPerVolume();
00334 
00335   return term;
00336 }

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

Definition at line 658 of file G4EmCorrections.cc.

References G4INCL::Math::pi.

Referenced by ComputeIonCorrections(), and HighOrderCorrections().

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

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

Definition at line 669 of file G4EmCorrections.cc.

References G4ParticleDefinition::GetPDGCharge().

Referenced by G4EmCalculator::ComputeNuclearDEDX().

00673 {
00674   G4double nloss = 0.0;
00675   if(e <= 0.0) return nloss; 
00676   SetupKinematics(p, mat, e);
00677 
00678   lossFlucFlag = fluct;
00679 
00680   // Projectile nucleus
00681   G4double z1 = std::fabs(particle->GetPDGCharge()/eplus);
00682   G4double mass1 = mass/amu_c2;
00683 
00684   //  loop for the elements in the material
00685   for (G4int iel=0; iel<numberOfElements; iel++) {
00686     const G4Element* element = (*theElementVector)[iel] ;
00687     G4double z2 = element->GetZ();
00688     G4double mass2 = element->GetA()*mole/g ;
00689     nloss += (NuclearStoppingPower(kinEnergy, z1, z2, mass1, mass2))
00690            * atomDensity[iel] ;
00691   }
00692   nloss *= theZieglerFactor;
00693   return nloss;
00694 }

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

Definition at line 315 of file G4EmCorrections.hh.

00316 {
00317   if(mod1) { ionLEModel = mod1; }
00318   if(mod2) { ionHEModel = mod2; }
00319 }

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

Definition at line 459 of file G4EmCorrections.cc.

References G4AtomicShells::GetNumberOfElectrons(), G4AtomicShells::GetNumberOfShells(), G4Material::GetTotNbOfAtomsPerVolume(), and G4PhysicsVector::Value().

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

00462 {
00463   SetupKinematics(p, mat, ekin);
00464 
00465   G4double term = 0.0;
00466   //G4cout << "### G4EmCorrections::ShellCorrection " << mat->GetName()
00467   //     << "   " << ekin/MeV << " MeV " << G4endl;
00468   for (G4int i = 0; i<numberOfElements; ++i) {
00469 
00470     G4double res = 0.0;
00471     G4double res0 = 0.0;
00472     G4double Z = (*theElementVector)[i]->GetZ();
00473     G4int   iz = G4int(Z);
00474     G4double Z2= (Z-0.3)*(Z-0.3);
00475     G4double f = 1.0;
00476     if(1 == iz) {
00477       f  = 0.5;
00478       Z2 = 1.0;
00479     }
00480     G4double eta = ba2/Z2;
00481     G4double tet = Z2*(1. + Z2*0.25*alpha2);
00482     if(11 < iz) { tet = ThetaK->Value(Z); }
00483     res0 = f*KShell(tet,eta);
00484     res += res0;
00485     //G4cout << " Z= " << iz << " Shell 0" << " tet= " << tet 
00486     //       << " eta= " << eta << "  resK= " << res0 << G4endl;
00487     if(2 < iz) {
00488       G4double Zeff = Z - ZD[10];
00489       if(iz < 10) { Zeff = Z - ZD[iz]; }
00490       Z2= Zeff*Zeff;
00491       eta = ba2/Z2;
00492       f = 0.125;
00493       tet = ThetaL->Value(Z);
00494       G4int ntot = G4AtomicShells::GetNumberOfShells(iz);
00495       G4int nmax = std::min(4, ntot);
00496       G4double norm   = 0.0;
00497       G4double eshell = 0.0;
00498       for(G4int j=1; j<nmax; ++j) {
00499         G4int ne = G4AtomicShells::GetNumberOfElectrons(iz,j);
00500         if(15 >= iz) {
00501           if(3 > j) { tet = 0.25*Z2*(1.0 + 5*Z2*alpha2/16.); }
00502           else      { tet = 0.25*Z2*(1.0 + Z2*alpha2/16.); }
00503         }
00504         norm   += ne;
00505         eshell += tet*ne;
00506         res0 = f*ne*LShell(tet,eta);
00507         res += res0;
00508         //G4cout << " Z= " << iz << " Shell " << j << " Ne= " << ne
00509         //       << " tet= " << tet << " eta= " << eta 
00510         //       << "  resL= " << res0 << G4endl;
00511       }
00512       if(ntot > nmax) {
00513         eshell /= norm;
00514         // Add M-shell
00515         if(28 > iz) {
00516           res += f*(iz - 10)*LShell(eshell,HM[iz-11]*eta);
00517         } else if(63 > iz) { 
00518           res += f*18*LShell(eshell,HM[iz-11]*eta);
00519         } else {
00520           res += f*18*LShell(eshell,HM[52]*eta);
00521         }
00522         // Add N-shell
00523         if(32 < iz) {
00524           if(60 > iz) {
00525             res += f*(iz - 28)*LShell(eshell,HN[iz-33]*eta);
00526           } else if(63 > iz) {
00527             res += 4*LShell(eshell,HN[iz-33]*eta);
00528           } else {
00529             res += 4*LShell(eshell,HN[30]*eta);
00530           }
00531           // Add O-P-shells
00532           if(60 < iz) {
00533             res += f*(iz - 60)*LShell(eshell,150*eta);
00534           }
00535         }
00536       }
00537     }
00538     term += res*atomDensity[i]/Z;
00539   }
00540 
00541   term /= material->GetTotNbOfAtomsPerVolume();
00542   //G4cout << "#     Shell Correction= " << term << G4endl;
00543   return term;
00544 }

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

Definition at line 425 of file G4EmCorrections.cc.

References G4Material::GetIonisation(), G4IonisParamMat::GetShellCorrectionVector(), and G4IonisParamMat::GetTaul().

00428 {
00429   SetupKinematics(p, mat, e);
00430   G4double taulim= 8.0*MeV/mass;
00431   G4double bg2lim= taulim * (taulim+2.0);
00432 
00433   G4double* shellCorrectionVector =
00434             material->GetIonisation()->GetShellCorrectionVector();
00435   G4double sh = 0.0;
00436   G4double x  = 1.0;
00437   G4double taul  = material->GetIonisation()->GetTaul();
00438 
00439   if ( bg2 >= bg2lim ) {
00440     for (G4int k=0; k<3; k++) {
00441         x *= bg2 ;
00442         sh += shellCorrectionVector[k]/x;
00443     }
00444 
00445   } else {
00446     for (G4int k=0; k<3; k++) {
00447         x *= bg2lim ;
00448         sh += shellCorrectionVector[k]/x;
00449     }
00450     sh *= std::log(tau/taul)/std::log(taulim/taul);
00451   }
00452   sh *= 0.5;
00453   return sh;
00454 }

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

Definition at line 262 of file G4EmCorrections.cc.

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

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:51:52 2013 for Geant4 by  doxygen 1.4.7