G4NativeScreenedCoulombCrossSection Class Reference

#include <G4ScreenedNuclearRecoil.hh>

Inheritance diagram for G4NativeScreenedCoulombCrossSection:

Collaboration diagram for G4NativeScreenedCoulombCrossSection:

Public Types
typedef G4_c2_function &(*	ScreeningFunc )(G4int z1, G4int z2, size_t nPoints, G4double rMax, G4double *au)
Public Types inherited from G4ScreenedCoulombCrossSection
enum	{ nMassMapElements =116 }
typedef std::map< G4int, G4ScreeningTables >	ScreeningMap
typedef std::map< G4int, class G4ParticleDefinition * >	ParticleCache

Public Member Functions
	G4NativeScreenedCoulombCrossSection ()
	G4NativeScreenedCoulombCrossSection (const G4NativeScreenedCoulombCrossSection &src)
	G4NativeScreenedCoulombCrossSection (const G4ScreenedCoulombCrossSection &src)
virtual	~G4NativeScreenedCoulombCrossSection ()
virtual void	LoadData (G4String screeningKey, G4int z1, G4double m1, G4double recoilCutoff)
virtual G4ScreenedCoulombCrossSection *	create ()
std::vector< G4String >	GetScreeningKeys () const
void	AddScreeningFunction (G4String name, ScreeningFunc fn)
Public Member Functions inherited from G4ScreenedCoulombCrossSection
	G4ScreenedCoulombCrossSection ()
	G4ScreenedCoulombCrossSection (const G4ScreenedCoulombCrossSection &src)
virtual	~G4ScreenedCoulombCrossSection ()
void	BuildMFPTables (void)
const G4ScreeningTables *	GetScreening (G4int Z)
void	SetVerbosity (G4int v)
G4ParticleDefinition *	SelectRandomUnweightedTarget (const G4MaterialCutsCouple *couple)
G4double	standardmass (G4int z1)
const G4_c2_function *	operator[] (G4int materialIndex)
Public Member Functions inherited from G4ScreenedCoulombCrossSectionInfo
	G4ScreenedCoulombCrossSectionInfo ()
	~G4ScreenedCoulombCrossSectionInfo ()

Additional Inherited Members
Static Public Member Functions inherited from G4ScreenedCoulombCrossSectionInfo
static const char *	CVSHeaderVers ()
static const char *	CVSFileVers ()
Protected Attributes inherited from G4ScreenedCoulombCrossSection
ScreeningMap	screeningData
ParticleCache	targetMap
G4int	verbosity
std::map< G4int, G4_c2_const_ptr >	sigmaMap
std::map< G4int, G4_c2_const_ptr >	MFPTables

Detailed Description

Definition at line 450 of file G4ScreenedNuclearRecoil.hh.

Member Typedef Documentation

typedef G4_c2_function&(* G4NativeScreenedCoulombCrossSection::ScreeningFunc)(G4int z1, G4int z2, size_t nPoints, G4double rMax, G4double *au)

Definition at line 474 of file G4ScreenedNuclearRecoil.hh.

Constructor & Destructor Documentation

G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection

(

)

Definition at line 962 of file G4ScreenedNuclearRecoil.cc.

                                                                         {
        AddScreeningFunction("zbl", ZBLScreening);
        AddScreeningFunction("lj", LJScreening);        
        AddScreeningFunction("mol", MoliereScreening);        
        AddScreeningFunction("ljzbl", LJZBLScreening);        
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection ( const G4NativeScreenedCoulombCrossSection &  src )

inline

Definition at line 455 of file G4ScreenedNuclearRecoil.hh.

          : G4ScreenedCoulombCrossSection(src), phiMap(src.phiMap) { }

G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection ( const G4ScreenedCoulombCrossSection &  src )

inline

Definition at line 459 of file G4ScreenedNuclearRecoil.hh.

          : G4ScreenedCoulombCrossSection(src)  { }

G4NativeScreenedCoulombCrossSection::~G4NativeScreenedCoulombCrossSection ( )

virtual

Definition at line 959 of file G4ScreenedNuclearRecoil.cc.

                                                                          {
}

Member Function Documentation

void G4NativeScreenedCoulombCrossSection::AddScreeningFunction ( G4String  name, ScreeningFunc  fn  )

inline

Definition at line 477 of file G4ScreenedNuclearRecoil.hh.

                                                                {
                           phiMap[name]=fn;
     }

Here is the caller graph for this function:

virtual G4ScreenedCoulombCrossSection* G4NativeScreenedCoulombCrossSection::create ( )

inlinevirtual

Implements G4ScreenedCoulombCrossSection.

Definition at line 468 of file G4ScreenedNuclearRecoil.hh.

                { return new G4NativeScreenedCoulombCrossSection(*this); } 

Here is the call graph for this function:

std::vector< G4String > G4NativeScreenedCoulombCrossSection::GetScreeningKeys

(

)

const

Definition at line 970 of file G4ScreenedNuclearRecoil.cc.

                                                            {
  std::vector<G4String> keys;
  // find the available screening keys
  std::map<std::string, ScreeningFunc>::const_iterator sfunciter=phiMap.begin();
  for(; sfunciter != phiMap.end(); sfunciter++) 
    keys.push_back((*sfunciter).first);
  return keys;
}

void G4NativeScreenedCoulombCrossSection::LoadData ( G4String  screeningKey, G4int  z1, G4double  m1, G4double  recoilCutoff  )

virtual

Implements G4ScreenedCoulombCrossSection.

Definition at line 997 of file G4ScreenedNuclearRecoil.cc.

{                        
        static const size_t sigLen=200; 
        // since sigma doesn't matter much, a very coarse table will do      
        G4DataVector energies(sigLen);
        G4DataVector data(sigLen);
        
        a1=standardmass(z1); 
        // use standardized values for mass for building tables
        
        const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
        if (materialTable == 0) { return; }
  //G4Exception("mhmNativeCrossSection::LoadData - no MaterialTable found)");
        
        G4int nMaterials = G4Material::GetNumberOfMaterials();
        
        for (G4int im=0; im<nMaterials; im++)
          {
            const G4Material* material= (*materialTable)[im];
            const G4ElementVector* elementVector = material->GetElementVector();
            const G4int nMatElements = material->GetNumberOfElements();
                
            for (G4int iEl=0; iEl<nMatElements; iEl++)
              {
                G4Element* element = (*elementVector)[iEl];
                G4int Z = (G4int) element->GetZ();
                G4double a2=element->GetA()*(mole/gram);
                        
                if(sigmaMap.find(Z)!=sigmaMap.end()) continue; 
                // we've already got this element
                        
                // find the screening function generator we need
                std::map<std::string, ScreeningFunc>::iterator sfunciter=
                  phiMap.find(screeningKey);
                if(sfunciter==phiMap.end()) {
                  G4ExceptionDescription ed;
                  ed << "No such screening key <" 
                     << screeningKey << ">"; 
                  G4Exception("G4NativeScreenedCoulombCrossSection::LoadData",
                              "em0003",FatalException,ed);
                }
                ScreeningFunc sfunc=(*sfunciter).second;
                        
                G4double au; 
                G4_c2_ptr screen=sfunc(z1, Z, 200, 50.0*angstrom, &au); 
                // generate the screening data
                G4ScreeningTables st;
        
                st.EMphiData=screen; //save our phi table
                st.z1=z1; st.m1=a1; st.z2=Z; st.m2=a2; st.emin=recoilCutoff;
                st.au=au;

                // now comes the hard part... build the total cross section
                // tables from the phi table                        
                // based on (pi-thetac) = pi*beta*alpha/x0, but noting that 
                // alpha is very nearly unity, always
                // so just solve it wth alpha=1, which makes the solution 
                // much easier
                // this function returns an approximation to 
                // (beta/x0)^2=phi(x0)/(eps*x0)-1 ~ ((pi-thetac)/pi)^2
                // Since we don't need exact sigma values, this is good enough 
                // (within a factor of 2 almost always)
                // this rearranges to phi(x0)/(x0*eps) = 
                // 2*theta/pi - theta^2/pi^2
                        
                c2_linear_p<G4double> &c2eps=c2.linear(0.0, 0.0, 1.0); 
                // will store an appropriate eps inside this in loop
                G4_c2_ptr phiau=screen(c2.linear(0.0, 0.0, au));
                G4_c2_ptr x0func(phiau/c2eps); 
                // this will be phi(x)/(x*eps) when c2eps is correctly set
                x0func->set_domain(1e-6*angstrom/au, 0.9999*screen->xmax()/au); 
                // needed for inverse function
                // use the c2_inverse_function interface for the root finder...
                // it is more efficient for an ordered 
                // computation of values.
                G4_c2_ptr x0_solution(c2.inverse_function(x0func));
                        
                G4double m1c2=a1*amu_c2;
                G4double escale=z1*Z*elm_coupling/au; 
                // energy at screening distance
                G4double emax=m1c2; 
                // model is doubtful in very relativistic range
                G4double eratkin=0.9999*(4*a1*a2)/((a1+a2)*(a1+a2)); 
                // #maximum kinematic ratio possible at 180 degrees
                G4double cmfact0=st.emin/cm_energy(a1, a2, st.emin);
                G4double l1=std::log(emax);
                G4double l0=std::log(st.emin*cmfact0/eratkin);

                if(verbosity >=1) 
                  G4cout << "Native Screening: " << screeningKey << " " 
                         << z1 << " " << a1 << " " << 
                    Z << " " << a2 << " " << recoilCutoff << G4endl;
                        
                for(size_t idx=0; idx<sigLen; idx++) {
                  G4double ee=std::exp(idx*((l1-l0)/sigLen)+l0);
                  G4double gamma=1.0+ee/m1c2;
                  G4double eratio=(cmfact0*st.emin)/ee; 
                  // factor by which ee needs to be reduced to get emin
                  G4double theta=thetac(gamma*a1, a2, eratio);
                        
                  G4double eps=cm_energy(a1, a2, ee)/escale; 
                  // #make sure lab energy is converted to CM for these 
                  // calculations
                  c2eps.reset(0.0, 0.0, eps); 
                  // set correct slope in this function
                                
                  G4double q=theta/pi;
                  // G4cout << ee << " " << m1c2 << " " << gamma << " " 
                  // << eps << " " << theta << " " << q << G4endl;
                  // old way using root finder
                  // G4double x0= x0func->find_root(1e-6*angstrom/au, 
                  // 0.9999*screen.xmax()/au, 1.0, 2*q-q*q);
                  // new way using c2_inverse_function which caches 
                  // useful information so should be a bit faster
                  // since we are scanning this in strict order.
                  G4double x0=0;
                  try {
                    x0=x0_solution(2*q-q*q);
                  } catch(c2_exception e) {
                    //G4Exception(G4String("G4ScreenedNuclearRecoil: failure 
                    //in inverse solution to generate MFP Tables: ")+e.what());
                  }
                  G4double betasquared=x0*x0 - x0*phiau(x0)/eps;        
                  G4double sigma=pi*betasquared*au*au;
                  energies[idx]=ee;
                  data[idx]=sigma;
                }
                screeningData[Z]=st;
                sigmaMap[Z] = 
                  c2.log_log_interpolating_function().load(energies, data, 
                                                           true,0,true,0);
              }
          }
}

Here is the call graph for this function:

---

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

• source/geant4.10.03.p03/examples/extended/electromagnetic/TestEm7/include/G4ScreenedNuclearRecoil.hh
• source/geant4.10.03.p03/examples/extended/electromagnetic/TestEm7/src/G4ScreenedNuclearRecoil.cc