G4NativeScreenedCoulombCrossSection Class Reference

#include <G4ScreenedNuclearRecoil.hh>

Inheritance 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 353 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 370 of file G4ScreenedNuclearRecoil.hh.

Constructor & Destructor Documentation

G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection

(

)

Definition at line 842 of file G4ScreenedNuclearRecoil.cc.

References AddScreeningFunction(), LJScreening(), LJZBLScreening(), MoliereScreening(), and ZBLScreening().

Referenced by create().

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

G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection ( const G4NativeScreenedCoulombCrossSection &  src )

inline

Definition at line 358 of file G4ScreenedNuclearRecoil.hh.

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

G4NativeScreenedCoulombCrossSection::G4NativeScreenedCoulombCrossSection ( const G4ScreenedCoulombCrossSection &  src )

inline

Definition at line 361 of file G4ScreenedNuclearRecoil.hh.

: G4ScreenedCoulombCrossSection(src)  { }

G4NativeScreenedCoulombCrossSection::~G4NativeScreenedCoulombCrossSection ( )

virtual

Definition at line 839 of file G4ScreenedNuclearRecoil.cc.

                                                                          {
}

Member Function Documentation

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

inline

Definition at line 372 of file G4ScreenedNuclearRecoil.hh.

Referenced by G4NativeScreenedCoulombCrossSection().

                                                                   {
                phiMap[name]=fn;
        }

virtual G4ScreenedCoulombCrossSection* G4NativeScreenedCoulombCrossSection::create ( )

inlinevirtual

Implements G4ScreenedCoulombCrossSection.

Definition at line 365 of file G4ScreenedNuclearRecoil.hh.

References G4NativeScreenedCoulombCrossSection().

                { return new G4NativeScreenedCoulombCrossSection(*this); } 

std::vector< G4String > G4NativeScreenedCoulombCrossSection::GetScreeningKeys

(

)

const

Definition at line 849 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 874 of file G4ScreenedNuclearRecoil.cc.

References python.hepunit::amu_c2, python.hepunit::angstrom, G4ScreeningTables::au, python.hepunit::elm_coupling, G4ScreeningTables::emin, G4ScreeningTables::EMphiData, G4cout, G4endl, G4Element::GetA(), G4Material::GetElementVector(), G4Material::GetMaterialTable(), G4Material::GetNumberOfElements(), G4Material::GetNumberOfMaterials(), G4Element::GetZ(), python.hepunit::gram, c2_factory< float_type >::inverse_function(), c2_factory< float_type >::linear(), c2_factory< float_type >::log_log_interpolating_function(), G4ScreeningTables::m1, G4ScreeningTables::m2, eplot::material, python.hepunit::mole, python.hepunit::pi, c2_linear_p< float_type >::reset(), G4ScreenedCoulombCrossSection::screeningData, G4ScreenedCoulombCrossSection::sigmaMap, G4ScreenedCoulombCrossSection::standardmass(), G4ScreenedCoulombCrossSection::verbosity, c2_function< float_type >::xmax(), G4ScreeningTables::z1, and G4ScreeningTables::z2.

{                        
        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()) {
                                G4cout << "no such screening key " << screeningKey << G4endl; // FIXME later
                                exit(1);
                        }
                        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);
                }
        }
}

---

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

• G4ScreenedNuclearRecoil.hh
• G4ScreenedNuclearRecoil.cc