G4ElectroNuclearCrossSection Class Reference

#include <G4ElectroNuclearCrossSection.hh>

Inheritance diagram for G4ElectroNuclearCrossSection:

Collaboration 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	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	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 G4int	GetVerboseLevel () const
virtual void	SetVerboseLevel (G4int value)
G4double	GetMinKinEnergy () const
void	SetMinKinEnergy (G4double value)
G4double	GetMaxKinEnergy () const
void	SetMaxKinEnergy (G4double value)
const G4String &	GetName () const

Static Public Member Functions
static const char *	Default_Name ()

Private Member Functions
G4int	GetFunctions (G4double a, G4double *x, G4double *y, G4double *z)
G4double	ThresholdEnergy (G4int Z, G4int N)
G4double	SolveTheEquation (G4double f)
G4double	Fun (G4double x)
G4double	DFun (G4double x)
G4double	HighEnergyJ1 (G4double lE)
G4double	HighEnergyJ2 (G4double lE, G4double E)
G4double	HighEnergyJ3 (G4double lE, G4double E2)

Private Attributes
G4int	currentN
G4int	currentZ
G4int	lastZ
std::vector< cacheEl_t * >	cache
cacheEl_t *	lastUsedCacheEl
G4NistManager *	nistmngr
G4double	lastE
G4double	lastSig
G4double	lastG
G4int	lastL
const G4double	mNeut
const G4double	mProt

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(G4NucleiProperties::GetNuclearMass(1,0)), mProt(G4NucleiProperties::GetNuclearMass(1,1))
{
    //Initialize caches
    lastUsedCacheEl = new cacheEl_t;
    nistmngr = G4NistManager::Instance();
    
    for (G4int i=0;i<120;i++)
    {
        cache.push_back(0);
    }
    
}

Here is the call graph for this function:

~G4ElectroNuclearCrossSection()

G4ElectroNuclearCrossSection::~G4ElectroNuclearCrossSection ( )

virtual

Definition at line 2195 of file G4ElectroNuclearCrossSection.cc.

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

Member Function Documentation

CrossSectionDescription()

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

virtual

Reimplemented from G4VCrossSectionDataSet.

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

Here is the caller graph for this function:

DFun()

G4double G4ElectroNuclearCrossSection::DFun ( G4double  x )

private

Definition at line 2226 of file G4ElectroNuclearCrossSection.cc.

{
    G4double y=G4Exp(x-lastG-lmel);             // y for the x
    G4double flux=lastG*(2.-y*(2.-y))-1.;          // flux factor
    return (poc*(x-pos)+shd*G4Exp(-reg*x))*flux;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Fun()

G4double G4ElectroNuclearCrossSection::Fun ( G4double  x )

private

Definition at line 2233 of file G4ElectroNuclearCrossSection.cc.

{
    // Integrated PhoNuc cross section
    G4double dlg1=lastG+lastG-1.;
    G4double lgoe=lastG/lastE;
    G4double HE2=HighEnergyJ2(x, G4Exp(x));
    return dlg1*HighEnergyJ1(x)-lgoe*(HE2+HE2-HighEnergyJ3(x, G4Exp(2*x))/lastE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetElementCrossSection()

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

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 2261 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<int>(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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetEquivalentPhotonEnergy()

G4double G4ElectroNuclearCrossSection::GetEquivalentPhotonEnergy

(

)

Definition at line 2428 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
            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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetEquivalentPhotonQ2()

G4double G4ElectroNuclearCrossSection::GetEquivalentPhotonQ2

(

G4double

nu

)

Definition at line 2507 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.
    {
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetFunctions()

G4int G4ElectroNuclearCrossSection::GetFunctions ( G4double  a, G4double *  x, G4double *  y, G4double *  z  )

private

Definition at line 2379 of file G4ElectroNuclearCrossSection.cc.

{
    // --------------------------------
    G4int r=-1;                             // Low channel for J-functions
    if(a<=.9999 || a>238.49)                // Plutonium 244 is forbidden
    {
        G4cout<<"***G4ElectroNuclearCrossSection::GetFunctions: A="<<a<<"(?). No CS returned!"<<G4endl;
        return r;
    }
    G4int iA=static_cast<G4int>(a+.499);    // Make the round integer of the atomic number
    G4double ai=iA;
    if(a!=ai) a=ai;
    for(G4int i=0; i<nN; i++)
    {
        if(std::abs(a-A[i])<.0005)                 // A coincide with one of the basic A's -> get from Tab
        {
            for(G4int k=0; k<nE; k++)
            {
                xx[k]=P0[i][k];                    // J0
                yy[k]=P1[i][k];                    // J1
                zz[k]=P2[i][k];                    // J2
            }
            r=LL[i];                             // Low channel for the J-functions
        }
        if(r<0)                               // Not the basic A-value -> must be calculated
        {
            G4int k=0;                          // !! To be good for different compilers !!
            for(k=1; k<nN; k++)if(a<A[k]) break;// Find the top basic A-value
            if(k<1) k=1;                        // Extrapolation from the first bin (D)
            if(k>=nN) k=nN-1;                   // Extrapolation from the last bin (U)
            G4int     k1=k-1;
            G4double  xi=A[k1];
            G4double   b=(a-xi)/(A[k]-xi);
            for(G4int q=0; q<nE; q++)
            {
                xi=P0[k1][q];
                xx[q]=xi+(P0[k][q]-xi)*b;
                G4double yi=P1[k1][q];
                yy[q]=yi+(P1[k][q]-yi)*b;
                G4double zi=P2[k1][q];
                zz[q]=zi+(P2[k][q]-zi)*b;
            }
            r=LL[k];
            if(LL[k1]<r) r=LL[k1];
        }
    }
    return r;
}

Here is the caller graph for this function:

GetVirtualFactor()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

HighEnergyJ1()

G4double G4ElectroNuclearCrossSection::HighEnergyJ1 ( G4double  lE )

private

Definition at line 2211 of file G4ElectroNuclearCrossSection.cc.

{
    return ha*(lE*lE-lEMa2)-ab*(lE-lEMa)-cd*(G4Exp(-reg*lE)-ele);
}

Here is the call graph for this function:

Here is the caller graph for this function:

HighEnergyJ2()

G4double G4ElectroNuclearCrossSection::HighEnergyJ2 ( G4double  lE, G4double  E  )

private

Definition at line 2216 of file G4ElectroNuclearCrossSection.cc.

{
    return poc*((lE-1.)*E-le1)-ab*(E-EMa)+cd1*(G4Exp(d1*lE)-ele1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

HighEnergyJ3()

G4double G4ElectroNuclearCrossSection::HighEnergyJ3 ( G4double  lE, G4double  E2  )

private

Definition at line 2221 of file G4ElectroNuclearCrossSection.cc.

{
    return ha*((lE-.5)*E2-leh)-hab*(E2-EMa2)+cd2*(G4Exp(d2*lE)-ele2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsElementApplicable()

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

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 2255 of file G4ElectroNuclearCrossSection.cc.

{
    return true;
}

SolveTheEquation()

G4double G4ElectroNuclearCrossSection::SolveTheEquation ( G4double  f )

private

Definition at line 2481 of file G4ElectroNuclearCrossSection.cc.

{
    G4double lastLE=lastG+lmel;                          // recover G4Log(eE) from the gamma (lastG)
    G4double topLim=lastLE-.001;                         // maximum G4Log(phE) for equivalent photons
    G4double rE=EMa/G4Exp(lastLE);                         // r=EMa/Eel to make the firs guess
    G4double x=lEMa+f/phte/(lastG*(2.-rE*(2.-rE))-1.);         // First guess (the first step from the edge)
    if(x>topLim) x=topLim;
    for(G4int i=0; i<imax; i++)
    {
        G4double fx=Fun(x);
        G4double df=DFun(x);
        G4double d=(f-fx)/df;
        x=x+d;
        if(x>=lastLE)
        {
            G4cerr<<"*G4ElNCS::SolveTheEq:*Correction*"<<i<<",d="<<d<<",x="<<x<<">lE="<<lastLE<<",f="<<f
            <<",fx="<<fx<<",df="<<df<<",A(Z="<<currentZ<<",N="<<currentN<<")"<<G4endl;
            x=topLim;
        }
        if(std::abs(d)<eps) break;
        if(i+1>=imax) G4cerr<<"*G4ElNucCS::SolveTheEq:"<<i+2<<">"<<imax<<"->Use bigger max. ln(eE)="
            <<lastLE<<",Z="<<currentZ<<", N="<<currentN<<G4endl;
    }
    return x;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ThresholdEnergy()

G4double G4ElectroNuclearCrossSection::ThresholdEnergy ( G4int  Z, G4int  N  )

private

Definition at line 2350 of file G4ElectroNuclearCrossSection.cc.

{
    // ---------
    
    G4int Aa=Z+N;
    if(Aa<1) return infEn;
    else if(Aa==1) return 134.9766; // Pi0 threshold for the nucleon
    
    G4double mT= 0.;
    if(G4NucleiProperties::IsInStableTable(Aa,Z)) mT = G4NucleiProperties::GetNuclearMass(Aa,Z);
    // If it is not in the Table of Stable Nuclei, then the Threshold=inf
    else return infEn;
    // ---------
    G4double mP= infEn;
    //if(Z) mP= G4QPDGCode(111).GetNuclMass(Z-1,N,0);
    if(Z&&G4NucleiProperties::IsInStableTable(Aa-1,Z-1)) mP = G4NucleiProperties::GetNuclearMass(Aa-1,Z-1);
    else return infEn;
    G4double mN= infEn;
    //if(N) mN= G4QPDGCode(111).GetNuclMass(Z,N-1,0);
    if(N&&G4NucleiProperties::IsInStableTable(Aa-1,Z)) mN = G4NucleiProperties::GetNuclearMass(Aa-1,Z);
    else return infEn;
    G4double dP= mP+mProt-mT;
    G4double dN= mN+mNeut-mT;
    if(dP<dN)dN=dP;
    return dN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cache

std::vector<cacheEl_t*> G4ElectroNuclearCrossSection::cache

private

Definition at line 99 of file G4ElectroNuclearCrossSection.hh.

currentN

G4int G4ElectroNuclearCrossSection::currentN

private

Definition at line 94 of file G4ElectroNuclearCrossSection.hh.

currentZ

G4int G4ElectroNuclearCrossSection::currentZ

private

Definition at line 95 of file G4ElectroNuclearCrossSection.hh.

lastE

G4double G4ElectroNuclearCrossSection::lastE

private

Definition at line 104 of file G4ElectroNuclearCrossSection.hh.

lastG

G4double G4ElectroNuclearCrossSection::lastG

private

Definition at line 106 of file G4ElectroNuclearCrossSection.hh.

lastL

G4int G4ElectroNuclearCrossSection::lastL

private

Definition at line 107 of file G4ElectroNuclearCrossSection.hh.

lastSig

G4double G4ElectroNuclearCrossSection::lastSig

private

Definition at line 105 of file G4ElectroNuclearCrossSection.hh.

lastUsedCacheEl

cacheEl_t* G4ElectroNuclearCrossSection::lastUsedCacheEl

private

Definition at line 100 of file G4ElectroNuclearCrossSection.hh.

lastZ

G4int G4ElectroNuclearCrossSection::lastZ

private

Definition at line 98 of file G4ElectroNuclearCrossSection.hh.

mNeut

const G4double G4ElectroNuclearCrossSection::mNeut

private

Definition at line 109 of file G4ElectroNuclearCrossSection.hh.

mProt

const G4double G4ElectroNuclearCrossSection::mProt

private

Definition at line 110 of file G4ElectroNuclearCrossSection.hh.

nistmngr

G4NistManager* G4ElectroNuclearCrossSection::nistmngr

private

Definition at line 101 of file G4ElectroNuclearCrossSection.hh.

---

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

• G4ElectroNuclearCrossSection.hh
• G4ElectroNuclearCrossSection.cc