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

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

Definition at line 2180 of file G4ElectroNuclearCrossSection.cc.

References G4NistManager::Instance().

                                                           :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);
     }
     
 }

G4ElectroNuclearCrossSection::~G4ElectroNuclearCrossSection ( )

virtual

Definition at line 2195 of file G4ElectroNuclearCrossSection.cc.

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

Member Function Documentation

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

virtual

Reimplemented from G4VCrossSectionDataSet.

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

static const char* G4ElectroNuclearCrossSection::Default_Name ( )

inlinestatic

Definition at line 65 of file G4ElectroNuclearCrossSection.hh.

Referenced by G4ElectroVDNuclearModel::G4ElectroVDNuclearModel().

65 {return "ElectroNuclearXS";}

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

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 2260 of file G4ElectroNuclearCrossSection.cc.

References cacheEl_t::F, G4NistManager::GetAtomicMassAmu(), G4DynamicParticle::GetKineticEnergy(), cacheEl_t::H, cacheEl_t::J1, cacheEl_t::J2, cacheEl_t::J3, python.hepunit::MeV, python.hepunit::millibarn, N, and cacheEl_t::TH.

Referenced by G4ElectroVDNuclearModel::ApplyYourself().

 {
     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*std::log(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=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*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=mL;
         
         G4double term1=lastUsedCacheEl->J1[mL]+lastUsedCacheEl->H*HighEnergyJ1(lE);
         
         G4double term2=lastUsedCacheEl->J2[mL]+lastUsedCacheEl->H*HighEnergyJ2(lE, Energy);
         
         G4double En2 = Energy*Energy;
         G4double term3=lastUsedCacheEl->J3[mL]+lastUsedCacheEl->H*HighEnergyJ3(lE, En2);
 
         lastSig=dlg1*term1-lgoe*(term2+term2-term3/lastE);
     }
     
     if(lastSig<0.) lastSig = 0.;
 
     return lastSig*millibarn;
 }

G4double G4ElectroNuclearCrossSection::GetEquivalentPhotonEnergy ( )

Definition at line 2427 of file G4ElectroNuclearCrossSection.cc.

References cacheEl_t::F, G4cerr, G4endl, G4UniformRand, cacheEl_t::H, cacheEl_t::J1, cacheEl_t::J2, and cacheEl_t::J3.

Referenced by G4ElectroVDNuclearModel::ApplyYourself().

 {
     if(lastSig <= 0.0) { return 0.0; }  // VI
     G4double phLE = 0.;                        // Prototype of the std::log(nu=E_gamma)
     G4double Y[nE] = {0.0};                    // Prepare the array for randomization
     
     G4double lastLE=lastG+lmel;   // recover std::log(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<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
     }
     G4double ris = lastSig*G4UniformRand(); // Sig can be > Y[lastL = mL], 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 < mL) 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=std::log(std::exp(lastLE)-.511);
         else phLE=7.;
     }
     return std::exp(phLE);
 }

G4double G4ElectroNuclearCrossSection::GetEquivalentPhotonQ2 ( G4double nu )

Definition at line 2506 of file G4ElectroNuclearCrossSection.cc.

References G4UniformRand.

Referenced by G4ElectroVDNuclearModel::ApplyYourself().

 {
     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.-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)
     {
         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)
     {
         return Qi2;
     }
     if(Q2>Qa2)
     {
         return Qa2;
     }
     return Q2;
 }

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

Definition at line 2550 of file G4ElectroNuclearCrossSection.cc.

References test::c.

 {
     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=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;
 }

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

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 2254 of file G4ElectroNuclearCrossSection.cc.

 {
     return true;
 }

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

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation