G4ElectroNuclearCrossSection Class Reference

#include <G4ElectroNuclearCrossSection.hh>

Inheritance diagram for G4ElectroNuclearCrossSection:

Public Member Functions
	G4ElectroNuclearCrossSection (const G4String &name="ElectroNuclearXS")
virtual	~G4ElectroNuclearCrossSection ()
virtual void	CrossSectionDescription (std::ostream &) const
virtual G4bool	IsIsoApplicable (const G4DynamicParticle *aParticle, G4int, G4int, const G4Element *, const G4Material *)
virtual G4double	GetIsoCrossSection (const G4DynamicParticle *aParticle, G4int, G4int, const G4Isotope *, const G4Element *, const G4Material *)
G4double	GetEquivalentPhotonEnergy ()
G4double	GetVirtualFactor (G4double nu, G4double Q2)
G4double	GetEquivalentPhotonQ2 (G4double nu)
Public Member Functions inherited from G4VCrossSectionDataSet
	G4VCrossSectionDataSet (const G4String &nam="")
virtual	~G4VCrossSectionDataSet ()
virtual G4bool	IsElementApplicable (const G4DynamicParticle *, G4int Z, const G4Material *mat=0)
virtual G4bool	IsIsoApplicable (const G4DynamicParticle *, G4int Z, G4int A, const G4Element *elm=0, const G4Material *mat=0)
G4double	GetCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *mat=0)
G4double	ComputeCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *mat=0)
virtual G4double	GetElementCrossSection (const G4DynamicParticle *, G4int Z, const G4Material *mat=0)
virtual G4double	GetIsoCrossSection (const G4DynamicParticle *, G4int Z, G4int A, const G4Isotope *iso=0, const G4Element *elm=0, const G4Material *mat=0)
virtual G4Isotope *	SelectIsotope (const G4Element *, G4double kinEnergy)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	DumpPhysicsTable (const G4ParticleDefinition &)
virtual void	CrossSectionDescription (std::ostream &) const
void	SetVerboseLevel (G4int value)
G4double	GetMinKinEnergy () const
void	SetMinKinEnergy (G4double value)
G4double	GetMaxKinEnergy () const
void	SetMaxKinEnergy (G4double value)
const G4String &	GetName () const

Additional Inherited Members
Protected Member Functions inherited from G4VCrossSectionDataSet
void	SetName (const G4String &)
Protected Attributes inherited from G4VCrossSectionDataSet
G4int	verboseLevel

Detailed Description

Definition at line 45 of file G4ElectroNuclearCrossSection.hh.

Constructor & Destructor Documentation

G4ElectroNuclearCrossSection()

G4ElectroNuclearCrossSection::G4ElectroNuclearCrossSection

(

const G4String &

name = "ElectroNuclearXS"

)

Definition at line 75 of file G4ElectroNuclearCrossSection.cc.

 : G4VCrossSectionDataSet(nam)
{}

~G4ElectroNuclearCrossSection()

G4ElectroNuclearCrossSection::~G4ElectroNuclearCrossSection ( )

virtual

Definition at line 79 of file G4ElectroNuclearCrossSection.cc.

{
  std::vector<G4double*>::iterator pos;
  for(pos=J1.begin(); pos<J1.end(); pos++)
  { delete [] *pos; }
  J1.clear();
  for(pos=J2.begin(); pos<J2.end(); pos++)
  { delete [] *pos; }
  J2.clear();
  for(pos=J3.begin(); pos<J3.end(); pos++)
  { delete [] *pos; }
  J3.clear();
}

Member Function Documentation

CrossSectionDescription()

void G4ElectroNuclearCrossSection::CrossSectionDescription ( std::ostream &  outFile ) const

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 94 of file G4ElectroNuclearCrossSection.cc.

{
  outFile << "G4ElectroNuclearCrossSection provides the total inelastic\n"
          << "cross section for e- and e+ interactions with nuclei.  The\n"
          << "cross sections are retrieved from a table which is\n"
          << "generated using the equivalent photon approximation.  In\n"
          << "this approximation real gammas are produced from the virtual\n"
          << "ones generated at the electromagnetic vertex.  This cross\n"
          << "section set is valid for incident electrons and positrons at\n"
          << "all energies.\n";
}

GetEquivalentPhotonEnergy()

G4double G4ElectroNuclearCrossSection::GetEquivalentPhotonEnergy

(

)

Definition at line 2394 of file G4ElectroNuclearCrossSection.cc.

{
  if(lastSig <= 0.0) { return 0.0; }  // VI
 
  // All constants are the copy of that from GetCrossSection funct.
  //  => Make them general.
  static const G4int nE=336; // !!  If you change this, change it in 
                             //     GetFunctions() (*.hh) !!
  static const G4int mL=nE-1;
  static const G4double EMi=2.0612;          // Minimum Energy
  static const G4double EMa=50000.;          // Maximum Energy
  static const G4double lEMi=std::log(EMi);  // Minimum logarithmic Energy
  static const G4double lEMa=std::log(EMa);  // Maximum logarithmic Energy
  static const G4double dlnE=(lEMa-lEMi)/mL; // Logarithmic step in Energy
  static const G4double mel=0.5109989;       // Mass of electron in MeV
  static const G4double lmel=std::log(mel);  // Log of electron mass
  G4double phLE=0.;                   // Prototype of the std::log(nu=E_gamma)
  G4double Y[nE];                     // Prepare the array for randomization
 
#ifdef debug
  G4cout << "G4ElectroNuclearCrossSection::GetEguPhotE:B="
         << lastF<<",l=" << lastL << ",J1=" << lastJ1[lastL]
         << ",J2=" << lastJ2[lastL] << ",J3=" << lastJ3[lastL] << ",S="
         << lastSig << ",E=" << lastE << G4endl;
#endif
 
  G4double lastLE=lastG+lmel;   // recover std::log(eE) from the gamma (lastG)
  G4double dlg1=lastG+lastG-1.;
  G4double lgoe=lastG/lastE;
  for (G4int i=lastF;i<=lastL;i++) {
    Y[i] = dlg1*lastJ1[i]-lgoe*(lastJ2[i]+lastJ2[i]-lastJ3[i]/lastE);
    if(Y[i] < 0.0) { Y[i] = 0.0; }
  }
  // Tempory IF of H.P.: delete it if the *HP* err message does not 
  // show up M.K.
  if(lastSig>0.99*Y[lastL] && lastL<mL && Y[lastL]<1.E-30)
  {
    G4cerr << "*HP*G4ElNucCS::GetEqPhotE:S=" << lastSig <<">" << Y[lastL]
           << ",l=" << lastL << ">" << mL << G4endl;
    if(lastSig <= 0.0) { return 0.0; }  // VI
 
    //return 3.0*MeV; // quick and dirty workaround @@@ HP.
                    // (now can be not necessary M.K.)
  }
  G4double ris=lastSig*G4UniformRand(); // Sig can be > Y[lastL=mL], then it
                                        // is in the funct. region
#ifdef debug
  G4cout<<"G4ElectroNuclearCrossSection::GetEquivalentPhotonEnergy: "<<ris<<",Y="<<Y[lastL]<<G4endl;
#endif
  if(ris<Y[lastL])                      // Search in the table
  {
    G4int j=lastF;
    G4double Yj=Y[j];                   // It mast be 0 (some times just very small)
    while (ris>Yj && j<lastL)           // Associative search
    {
      j++;
      Yj=Y[j];                          // High value
    }
    G4int j1=j-1;
    G4double Yi=Y[j1];                  // Low value
    phLE=lEMi+(j1+(ris-Yi)/(Yj-Yi))*dlnE;
#ifdef debug
    G4cout<<"G4EleNucCS::E="<<phLE<<",l="<<lEMi<<",j="<<j<<",ris="<<ris<<",Yi="<<Yi<<",Y="<<Yj<<G4endl;
#endif
  }
  else                                  // Search with the function
  {
    if(lastL<mL)G4cerr<<"**G4EleNucCS::GetEfPhE:L="<<lastL<<",S="<<lastSig<<",Y="<<Y[lastL]<<G4endl;
    G4double f=(ris-Y[lastL])/lastH;    // The scaled residual value of the cross-section integral
#ifdef pdebug
    G4cout<<"G4EleNucCS::GetEfPhE:HighEnergy f="<<f<<",ris="<<ris<<",lastH="<<lastH<<G4endl;
#endif
    phLE=SolveTheEquation(f);           // Solve the equation to find theLog(phE) (compare with lastLE)
#ifdef pdebug
    G4cout<<"G4EleNucCS::GetEfPhE:HighEnergy lphE="<<phLE<<G4endl;
#endif
  }
  if(phLE>lastLE)
  {
    G4cerr<<"***G4ElectroNuclearCS::GetEquPhotE:N="<<lastN<<",Z="<<lastZ<<", lpE"<<phLE<<">leE"<<lastLE
          <<",Sig="<<lastSig<<",rndSig="<<ris<<",Beg="<<lastF<<",End="<<lastL<<",Y="<<Y[lastL]<<G4endl;
    if(lastLE<7.2) phLE=std::log(std::exp(lastLE)-.511);
    else phLE=7.;
  }
  return std::exp(phLE);
}

Referenced by G4ElectroNuclearReaction::ApplyYourself(), and G4ElectroVDNuclearModel::ApplyYourself().

GetEquivalentPhotonQ2()

G4double G4ElectroNuclearCrossSection::GetEquivalentPhotonQ2

(

G4double

nu

)

Definition at line 2526 of file G4ElectroNuclearCrossSection.cc.

{
  if(lastG <= 0.0 || lastE <= 0.0) { return 0.; } // VI
  if(lastSig <= 0.0) { return 0.0; }  // VI
  static const G4double mel=0.5109989;    // Mass of electron in MeV
  static const G4double mel2=mel*mel;     // Squared Mass of electron in MeV
  G4double y=nu/lastE;                    // Part of energy carried by the equivalent pfoton
  if(y>=1.-1./(lastG+lastG)) return 0.;   // The region where the method does not work
  G4double y2=y*y;                        // Squared photonic part of energy
  G4double ye=1.-y;                       // Part of energy carried by the secondary electron
  G4double Qi2=mel2*y2/ye;                // Minimum Q2
  G4double Qa2=4*lastE*lastE*ye;          // Maximum Q2
  G4double iar=Qi2/Qa2;                   // Q2min/Q2max ratio
  G4double Dy=ye+.5*y2;                   // D(y) function
  G4double Py=ye/Dy;                      // P(y) function
  G4double ePy=1.-std::exp(Py);                // 1-std::exp(P(y)) part
  G4double Uy=Py*(1.-iar);                // U(y) function
  G4double Fy=(ye+ye)*(1.+ye)*iar/y2;     // F(y) function
  G4double fr=iar/(1.-ePy*iar);           // Q-fraction
  if(Fy<=-fr)
  {
#ifdef edebug
    G4cerr<<"***G4ElectroNucCrossSec::GetEquPhQ2:Fy="<<Fy<<"+fr="<<fr<<" <0"<<",iar="<<iar<<G4endl;
#endif
    return 0.;
  }    
  G4double LyQa2=std::log(Fy+fr);              // L(y,Q2max) function
  G4bool cond=true;
  G4int maxTry=3;
  G4int cntTry=0;
  G4double Q2=Qi2;
  while(cond&&cntTry<maxTry)             // The loop to avoid x>1.
  {
    G4double R=G4UniformRand();           // Random number (0,1)
    Q2=Qi2*(ePy+1./(std::exp(R*LyQa2-(1.-R)*Uy)-Fy));
    cntTry++;
    cond = Q2>1878.*nu;
  }
  if(Q2<Qi2)
  {
#ifdef edebug
    G4cerr<<"***G4ElectroNucCrossSec::GetEquPhQ2:Q2="<<Q2<<" < Q2min="<<Qi2<<G4endl;
#endif
    return Qi2;
  }  
  if(Q2>Qa2)
  {
#ifdef edebug
    G4cerr<<"***G4ElectroNucCrossSec::GetEquPhQ2:Q2="<<Q2<<" > Q2max="<<Qi2<<G4endl;
#endif
    return Qa2;
  }  
  return Q2;
}

Referenced by G4ElectroNuclearReaction::ApplyYourself(), and G4ElectroVDNuclearModel::ApplyYourself().

GetIsoCrossSection()

G4double G4ElectroNuclearCrossSection::GetIsoCrossSection ( const G4DynamicParticle *  aParticle, G4int  ZZ, G4int  AA, const G4Isotope *  , const G4Element *  , const G4Material *    )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 120 of file G4ElectroNuclearCrossSection.cc.

{
  static const G4int nE=336; // !!  If you change this, change it in GetFunctions() (*.hh) !!
  static const G4int mL=nE-1;
  static const G4double EMi=2.0612; // Minimum tabulated Energy of the Electron
  static const G4double EMa=50000.; // Maximum tabulated Energy of the Electron
  static const G4double lEMi=std::log(EMi);  // Minimum tabulated logarithmic Energy of the Electron
  static const G4double lEMa=std::log(EMa);  // Maximum tabulated logarithmic Energy of the Electron
  static const G4double dlnE=(lEMa-lEMi)/mL; // Logarithmic step in the table for the electron Energy
  static const G4double alop=1./137.036/3.14159265; //coef. for the calculated functions (Ee>50000.)
  static const G4double mel=0.5109989;       // Mass of the electron in MeV
  static const G4double lmel=std::log(mel);       // Log of the electron mass
  // *** Begin of the Associative memory for acceleration of the cross section calculations
  static std::vector <G4int> colN;       // Vector of N for calculated nucleus (isotop)
  static std::vector <G4int> colZ;       // Vector of Z for calculated nucleus (isotop)
  static std::vector <G4int> colF;       // Vector of Last StartPosition in the Ji-function tables
  static std::vector <G4double> colTH;   // Vector of the energy thresholds for the eA->eX reactions
  static std::vector <G4double> colH;    // Vector of HighEnergyCoefficients (functional calculations)
  // *** End of Static Definitions (Associative Memory) ***
 
  const G4double Energy = aPart->GetKineticEnergy()/MeV; // Energy of the electron
  const G4int targetAtomicNumber = AA;
  const G4int targZ = ZZ;
  const G4int targN = targetAtomicNumber-targZ; // @@ Get isotops (can change initial A)
  if (Energy<=EMi) return 0.;              // Energy is below the minimum energy in the table
 
  G4int PDG=aPart->GetDefinition()->GetPDGEncoding();
  if (PDG == 11 || PDG == -11)            // @@ Now only for electrons, but can be fo muons
  {
    G4double A = targN + targZ;           // New A (can differ from G4double targetAtomicNumber)
    if(targN!=lastN || targZ!=lastZ)      // This nucleus was not the last used isotop
    {
      lastE    = 0.;                       // New history in the electron Energy
      lastG    = 0.;                       // New history in the photon Energy
      lastN    = targN;                    // The last N of calculated nucleus
      lastZ    = targZ;                    // The last Z of calculated nucleus
      G4int n=colN.size();                 // Size of the Associative Memory DB in the heap
      G4bool in=false;                     // "Found in AMDB" flag
      if(n) for(G4int i=0; i<n; i++) if(colN[i]==targN && colZ[i]==targZ) // Calculated nuclei
      { // The nucleus is found in AMDB
        in=true;                           // Rais the "Found in AMDB" flag
        lastTH =colTH[i];                  // Last Energy threshold (A-dependent)
        lastF  =colF[i];                   // Last ZeroPosition in the J-functions
        lastH  =colH[i];                   // Last High Energy Coefficient (A-dependent)
        lastJ1 =J1[i];                     // Pointer to the prepared J1 function
        lastJ2 =J2[i];                     // Pointer to the prepared J2 function
        lastJ3 =J3[i];                     // Pointer to the prepared J3 function
      }
      if(!in)                              // This nucleus has not been calculated previously
      {
        lastJ1 = new G4double[nE];        // Allocate memory for the new J1 function
        lastJ2 = new G4double[nE];        // Allocate memory for the new J2 function
        lastJ3 = new G4double[nE];        // Allocate memory for the new J3 function
        lastF   = GetFunctions(A,lastJ1,lastJ2,lastJ3); // new ZeroPos and filling of J-functions
        lastH   = alop*A*(1.-.072*std::log(A));// corresponds to lastSP from G4PhotonuclearCrossSection 
        lastTH  = ThresholdEnergy(targZ, targN); // The last Threshold Energy
#ifdef pdebug
        G4cout<<"G4ElNucCS::GetCrossSection: lastH="<<lastH<<",A="<<A<<G4endl;
#endif
        colN.push_back(targN);
        colZ.push_back(targZ);
        colF.push_back(lastF);
        J1.push_back(lastJ1);
        J2.push_back(lastJ2);
        J3.push_back(lastJ3);
        colH.push_back(lastH);
        colTH.push_back(lastTH);
      } // End of creation of the new set of parameters
    } // End of parameters udate
 
    //    else if(std::abs((lastE-Energy)/Energy)<.001) return lastSig*millibarn; // Don't calc. same CS twice
    else if(lastE == Energy) return lastSig*millibarn; // Don't calc. same CS twice
    // ============================== NOW Calculate the Cross Section ==========================
    lastE=Energy;                          // lastE - the electron energy
    if (Energy<=lastTH)                    // Once more check that the eE is higher than the ThreshE
    {
      lastSig=0.;
      return 0.;
    }
    G4double lE=std::log(Energy);               // std::log(eE) (it is necessary at this point for the fit)
    lastG=lE-lmel;                         // Gamma of the electron (used to recover std::log(eE))
    G4double dlg1=lastG+lastG-1.;
    G4double lgoe=lastG/lastE;
    if(lE<lEMa) // Linear fit is made explicitly to fix the last bin for the randomization
    {
      G4double shift=(lE-lEMi)/dlnE;
      G4int    blast=static_cast<int>(shift);
      if(blast<0)   blast=0;
      if(blast>=mL) blast=mL-1;
      shift-=blast;
      lastL=blast+1;
      G4double YNi=dlg1*lastJ1[blast]-lgoe*(lastJ2[blast]+lastJ2[blast]-lastJ3[blast]/lastE);
      G4double YNj=dlg1*lastJ1[lastL]-lgoe*(lastJ2[lastL]+lastJ2[lastL]-lastJ3[lastL]/lastE);
      lastSig= YNi+shift*(YNj-YNi);
      if(lastSig>YNj)lastSig=YNj;
#ifdef pdebug
      G4cout<<"G4ElNucCS::GetCS:S="<<lastSig<<",E="<<lE<<",Yi="<<YNi<<",Yj="<<YNj<<",M="<<lEMa<<G4endl;
      G4cout<<"G4EN::GCS:s="<<shift<<",Jb="<<lastJ1[blast]<<",J="<<lastJ1[lastL]<<",b="<<blast<<G4endl;
#endif
    }
    else
    {
      lastL=mL;
      G4double term1=lastJ1[mL]+lastH*HighEnergyJ1(lE);
      G4double term2=lastJ2[mL]+lastH*HighEnergyJ2(lE);
      G4double term3=lastJ3[mL]+lastH*HighEnergyJ3(lE);
      lastSig=dlg1*term1-lgoe*(term2+term2-term3/lastE);
#ifdef pdebug
      G4cout<<"G4ElNucCS::GetCrossSec:S="<<lastSig<<",lE="<<lE<<",J1="<<lastH*HighEnergyJ1(lE)<<",Pm="
            <<lastJ1[mL]<<",Fm="<<lastJ2[mL]<<",Fh="<<lastH*HighEnergyJ2(lE)<<",EM="<<lEMa<<G4endl;
#endif
    }
  } // End of "sigma" calculation
  else return 0.;
  if(lastSig<0.) lastSig = 0.;
  lastE=Energy;
  return lastSig*millibarn;
}

Referenced by G4ElectroVDNuclearModel::ApplyYourself().

GetVirtualFactor()

G4double G4ElectroNuclearCrossSection::GetVirtualFactor	(	G4double	nu,
		G4double	Q2
	)

Definition at line 2581 of file G4ElectroNuclearCrossSection.cc.

{
  if(nu <= 0.0 || Q2 <= 0.0) { return 0.0; }
  static const G4double dM=938.27+939.57; // Mean double nucleon mass = m_n+m_p (@@ no binding)
  static const G4double Q0=843.;          // Coefficient of the dipole nucleonic form-factor
  static const G4double Q02=Q0*Q0;        // Squared coefficient of the dipole nucleonic form-factor
  static const G4double blK0=std::log(185.);   // Coefficient of the b-function
  static const G4double bp=0.85;          // Power of the b-function
  static const G4double clK0=std::log(1390.);  // Coefficient of the c-function
  static const G4double cp=3.;            // Power of the c-function
  //G4double x=Q2/dM/nu;                  // Direct x definition
  G4double K=nu-Q2/dM;                    // K=nu*(1-x)
  if(K <= 0.) // VI
  {
#ifdef edebug
    G4cerr<<"**G4ElectroNucCrossSec::GetVirtFact:K="<<K<<",nu="<<nu<<",Q2="<<Q2<<",dM="<<dM<<G4endl;
#endif
    return 0.;
  }
  G4double lK=std::log(K);                     // ln(K)
  G4double x=1.-K/nu;                     // This definitin saves one div.
  G4double GD=1.+Q2/Q02;                  // Reversed nucleonic form-factor
  G4double b=std::exp(bp*(lK-blK0));           // b-factor
  G4double c=std::exp(cp*(lK-clK0));           // c-factor
  G4double r=.5*std::log(Q2+nu*nu)-lK;         // r=.5*std::log((Q^2+nu^2)/K^2)
  G4double ef=std::exp(r*(b-c*r*r));           // exponential factor
  return (1.-x)*ef/GD/GD;
}

Referenced by G4ElectroNuclearReaction::ApplyYourself().

IsIsoApplicable()

G4bool G4ElectroNuclearCrossSection::IsIsoApplicable ( const G4DynamicParticle *  aParticle, G4int  , G4int  , const G4Element *  , const G4Material *    )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 107 of file G4ElectroNuclearCrossSection.cc.

{
  G4bool result = false;
  if (aParticle->GetDefinition() == G4Electron::ElectronDefinition())
    result = true;
  if (aParticle->GetDefinition() == G4Positron::PositronDefinition())
    result = true;
  return result;
}

---

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

• G4ElectroNuclearCrossSection.hh
• G4ElectroNuclearCrossSection.cc