G4ElectroNuclearCrossSection Class Reference

#include <G4ElectroNuclearCrossSection.hh>

Inheritance diagram for G4ElectroNuclearCrossSection:

Public Member Functions
	G4ElectroNuclearCrossSection ()
virtual	~G4ElectroNuclearCrossSection ()
virtual void	CrossSectionDescription (std::ostream &) const
virtual G4bool	IsElementApplicable (const G4DynamicParticle *, G4int Z, const G4Material *)
virtual G4double	GetElementCrossSection (const G4DynamicParticle *, G4int Z, const G4Material *mat)
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=nullptr)
virtual G4bool	IsIsoApplicable (const G4DynamicParticle *, G4int Z, G4int A, const G4Element *elm=nullptr, const G4Material *mat=nullptr)
G4double	GetCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *mat=nullptr)
G4double	ComputeCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *mat=nullptr)
virtual G4double	GetElementCrossSection (const G4DynamicParticle *, G4int Z, const G4Material *mat=nullptr)
virtual G4double	GetIsoCrossSection (const G4DynamicParticle *, G4int Z, G4int A, const G4Isotope *iso=nullptr, const G4Element *elm=nullptr, const G4Material *mat=nullptr)
virtual const G4Isotope *	SelectIsotope (const G4Element *, G4double kinEnergy, G4double logE)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	DumpPhysicsTable (const G4ParticleDefinition &)
virtual void	CrossSectionDescription (std::ostream &) const
virtual G4int	GetVerboseLevel () const
virtual void	SetVerboseLevel (G4int value)
G4double	GetMinKinEnergy () const
void	SetMinKinEnergy (G4double value)
G4double	GetMaxKinEnergy () const
void	SetMaxKinEnergy (G4double value)
bool	ForAllAtomsAndEnergies () const
void	SetForAllAtomsAndEnergies (G4bool val)
const G4String &	GetName () const

Static Public Member Functions
static const char *	Default_Name ()

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 58 of file G4ElectroNuclearCrossSection.hh.

Constructor & Destructor Documentation

G4ElectroNuclearCrossSection()

G4ElectroNuclearCrossSection::G4ElectroNuclearCrossSection

(

)

Definition at line 2180 of file G4ElectroNuclearCrossSection.cc.

                                                          :G4VCrossSectionDataSet(Default_Name()),
currentN(0), currentZ(0), lastZ(0),lastE(0), lastSig(0), lastG(0), lastL(0), 
mNeut(neutron_mass_c2), mProt(proton_mass_c2)
{
    SetForAllAtomsAndEnergies(true);
    //Initialize caches
    lastUsedCacheEl = new cacheEl_t();
    nistmngr = G4NistManager::Instance();
    
    for (G4int i=0;i<120;i++)
    {
        cache.push_back(nullptr);
    }
    
}

~G4ElectroNuclearCrossSection()

G4ElectroNuclearCrossSection::~G4ElectroNuclearCrossSection ( )

virtual

Definition at line 2196 of file G4ElectroNuclearCrossSection.cc.

{
     std::vector<cacheEl_t*>::iterator it = cache.begin();
     while ( it != cache.end() )  /* Loop checking, 08.01.2016, W. Pokorski */
     {
         if ( *it ) {
             delete[] (*it)->J1; (*it)->J1 = 0;
             delete[] (*it)->J2; (*it)->J2 = 0;
             delete[] (*it)->J3; (*it)->J3 = 0;
             delete *it;
         }
     ++it;
     }
     cache.clear();
     delete lastUsedCacheEl;
}

Member Function Documentation

CrossSectionDescription()

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

virtual

Reimplemented from G4VCrossSectionDataSet.

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

Default_Name()

static const char * G4ElectroNuclearCrossSection::Default_Name ( )

inlinestatic

Definition at line 65 of file G4ElectroNuclearCrossSection.hh.

{return "ElectroNuclearXS";}

Referenced by G4ElectroVDNuclearModel::G4ElectroVDNuclearModel().

GetElementCrossSection()

G4double G4ElectroNuclearCrossSection::GetElementCrossSection ( const G4DynamicParticle *  aPart, G4int  Z, const G4Material *  mat  )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 2263 of file G4ElectroNuclearCrossSection.cc.

{
    const G4double Energy = aPart->GetKineticEnergy()/MeV; // Energy of the electron
 
    if (Energy<=EMi) return 0.;              // Energy is below the minimum energy in the table
    
    if(ZZ!=lastZ)      // This nucleus was not the last used element
    {
        lastE    = 0.;                       // New history in the electron Energy
        lastG    = 0.;                       // New history in the photon Energy
        lastZ = ZZ;
        
        //key to search in cache
        if(!cache[ZZ]){
            lastUsedCacheEl->J1 = new G4double[nE];  // Allocate memory for the new J1 function
            lastUsedCacheEl->J2 = new G4double[nE];  // Allocate memory for the new J2 function
            lastUsedCacheEl->J3 = new G4double[nE];  // Allocate memory for the new J3 function
            G4double Aa = nistmngr->GetAtomicMassAmu(ZZ); // average A
            G4int N = (G4int)Aa - ZZ;
            lastUsedCacheEl->F  = GetFunctions(Aa,lastUsedCacheEl->J1,lastUsedCacheEl->J2,lastUsedCacheEl->J3); // new ZeroPos and filling of J-functions
            lastUsedCacheEl->H  = alop*Aa*(1.-.072*G4Log(Aa));// corresponds to lastSP from G4PhotonuclearCrossSection
            lastUsedCacheEl->TH = ThresholdEnergy(ZZ, N); // The last Threshold Energy
            cacheEl_t* new_el = new cacheEl_t(*lastUsedCacheEl);
            cache[ZZ] = new_el;
        }
        else
        { //found in cache
            const cacheEl_t& el = *(cache[ZZ]);
            lastUsedCacheEl->F  = el.F;
            lastUsedCacheEl->TH = el.TH;
            lastUsedCacheEl->H  = el.H;
            lastUsedCacheEl->J1 = el.J1;
            lastUsedCacheEl->J2 = el.J2;
            lastUsedCacheEl->J3 = el.J3;
        }
    }
    else
    { //current isotope is the same as previous one
        if ( lastE == Energy ) return lastSig*millibarn; // Don't calc. same CS twice
    }
    //End of optimization: now lastUsedCacheEl structure contains the correct data for this isotope
 
    // ============================== NOW Calculate the Cross Section ==========================
    lastE=Energy;                          // lastE - the electron energy
    
    if ( Energy <= lastUsedCacheEl->TH ) // check that the eE is higher than the ThreshE
    {
        lastSig=0.;
        return 0.;
    }
    
    G4double lE=G4Log(Energy);               // G4Log(eE) (it is necessary at this point for the fit)
 
    lastG=lE-lmel;                         // Gamma of the electron (used to recover G4Log(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<G4int>(shift);
        if(blast<0)   blast=0;
        if(blast>=mLL) blast=mLL-1;
        shift-=blast;
        lastL=blast+1;
        G4double YNi=dlg1*lastUsedCacheEl->J1[blast]-lgoe*(lastUsedCacheEl->J2[blast]+lastUsedCacheEl->J2[blast]-lastUsedCacheEl->J3[blast]/lastE);
        G4double YNj=dlg1*lastUsedCacheEl->J1[lastL]-lgoe*(lastUsedCacheEl->J2[lastL]+lastUsedCacheEl->J2[lastL]-lastUsedCacheEl->J3[lastL]/lastE);
        lastSig= YNi+shift*(YNj-YNi);
        if(lastSig>YNj)lastSig=YNj;
    }
    else
    {
        lastL=mLL;
        
        G4double term1=lastUsedCacheEl->J1[mLL]+lastUsedCacheEl->H*HighEnergyJ1(lE);
        
        G4double term2=lastUsedCacheEl->J2[mLL]+lastUsedCacheEl->H*HighEnergyJ2(lE, Energy);
        
        G4double En2 = Energy*Energy;
        G4double term3=lastUsedCacheEl->J3[mLL]+lastUsedCacheEl->H*HighEnergyJ3(lE, En2);
 
        lastSig=dlg1*term1-lgoe*(term2+term2-term3/lastE);
    }
    
    if(lastSig<0.) lastSig = 0.;
 
    return lastSig*millibarn;
}

Referenced by G4ElectroVDNuclearModel::ApplyYourself().

GetEquivalentPhotonEnergy()

G4double G4ElectroNuclearCrossSection::GetEquivalentPhotonEnergy

(

)

Definition at line 2433 of file G4ElectroNuclearCrossSection.cc.

{
    if(lastSig <= 0.0) { return 0.0; }  // VI
    G4double phLE = 0.;                        // Prototype of the G4Log(nu=E_gamma)
    G4double Y[nE] = {0.0};                    // Prepare the array for randomization
    
    G4double lastLE=lastG+lmel;   // recover G4Log(eE) from the gamma (lastG)
    G4double dlg1=lastG+lastG-1.;
    G4double lgoe=lastG/lastE;
    for (G4int i=lastUsedCacheEl->F;i<=lastL;i++) {
        Y[i] = dlg1*lastUsedCacheEl->J1[i]-lgoe*(lastUsedCacheEl->J2[i]+lastUsedCacheEl->J2[i]-lastUsedCacheEl->J3[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<mLL && Y[lastL]<1.E-30)
    {
        G4cerr << "*HP*G4ElNucCS::GetEqPhotE:S=" << lastSig <<">" << Y[lastL]
        << ",l=" << lastL << ">" << mLL << G4endl;
        if(lastSig <= 0.0) { return 0.0; }  // VI
    }
    G4double ris = lastSig*G4UniformRand(); // Sig can be > Y[lastL = mLL], then it
    // is in the funct. region
    
    if (ris < Y[lastL]) {               // Search the table
        G4int j = lastUsedCacheEl->F;
        G4double Yj = Y[j];               // It must be 0 (sometimes just very small)
        while (ris > Yj && j < lastL) {   // Associative search  /* Loop checking, 08.01.2016, W. Pokorski */
            j++;
            Yj = Y[j];                      // Yj is first value above ris
        }
        G4int j1 = j-1;
        G4double Yi = Y[j1];              // Previous value is below ris
        phLE = lEMi + (j1 + (ris-Yi)/(Yj-Yi) )*dlnE;
    } else {                            // Search with the function
        if (lastL < mLL) G4cerr << "**G4EleNucCS::GetEfPhE:L=" << lastL << ",S="
            << lastSig << ",Y=" << Y[lastL] << G4endl;
        G4double f = (ris-Y[lastL])/lastUsedCacheEl->H;    // The scaled residual value of the cross-section integral
        phLE=SolveTheEquation(f);           // Solve the equation to find theLog(phE) (compare with lastLE)
    }
    
    if (phLE>lastLE) {
        G4cerr << "***G4ElectroNuclearCS::GetEquPhotE:N=" << currentN << ",Z="
        << currentZ << ", lpE" << phLE << ">leE" << lastLE << ",Sig="
        << lastSig << ",rndSig=" << ris << ",Beg=" << lastUsedCacheEl->F << ",End="
        << lastL << ",Y=" << Y[lastL] << G4endl;
        if(lastLE<7.2) phLE=G4Log(G4Exp(lastLE)-.511);
        else phLE=7.;
    }
    return G4Exp(phLE);
}

Referenced by G4ElectroVDNuclearModel::ApplyYourself().

GetEquivalentPhotonQ2()

G4double G4ElectroNuclearCrossSection::GetEquivalentPhotonQ2

(

G4double

nu

)

Definition at line 2512 of file G4ElectroNuclearCrossSection.cc.

{
    if(lastG <= 0.0 || lastE <= 0.0) { return 0.; } // VI
    if(lastSig <= 0.0) { return 0.0; }  // VI
    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.-G4Exp(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)
    {
        return 0.;
    }
    G4double LyQa2=G4Log(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.  /* Loop checking, 08.01.2016, W. Pokorski */
    {
        G4double R=G4UniformRand();           // Random number (0,1)
        Q2=Qi2*(ePy+1./(G4Exp(R*LyQa2-(1.-R)*Uy)-Fy));
        cntTry++;
        cond = Q2>1878.*nu;
    }
    if(Q2<Qi2)
    {
        return Qi2;
    }
    if(Q2>Qa2)
    {
        return Qa2;
    }
    return Q2;
}

Referenced by G4ElectroVDNuclearModel::ApplyYourself().

GetVirtualFactor()

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

Definition at line 2556 of file G4ElectroNuclearCrossSection.cc.

{
    if(nu <= 0.0 || Q2 <= 0.0) { return 0.0; }
    //G4double x=Q2/dM/nu;                  // Direct x definition
    G4double K=nu-Q2/dM;                    // K=nu*(1-x)
    if(K <= 0.) // VI
    {
        return 0.;
    }
    G4double lK=G4Log(K);                     // ln(K)
    G4double x=1.-K/nu;                     // This definitin saves one div.
    G4double GD=1.+Q2/Q02;                  // Reversed nucleonic form-factor
    G4double b=G4Exp(bp*(lK-blK0));           // b-factor
    G4double c=G4Exp(cp*(lK-clK0));           // c-factor
    G4double r=.5*G4Log(Q2+nu*nu)-lK;         // r=.5*G4Log((Q^2+nu^2)/K^2)
    G4double ef=G4Exp(r*(b-c*r*r));           // exponential factor
    return (1.-x)*ef/GD/GD;
}

IsElementApplicable()

G4bool G4ElectroNuclearCrossSection::IsElementApplicable ( const G4DynamicParticle *  , G4int  Z, const G4Material *    )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 2257 of file G4ElectroNuclearCrossSection.cc.

{
  return (Z>0 && Z<120);
}

---

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

• G4ElectroNuclearCrossSection.hh
• G4ElectroNuclearCrossSection.cc