G4ScreenedCoulombCrossSection Class Reference

#include <G4ScreenedNuclearRecoil.hh>

Inheritance diagram for G4ScreenedCoulombCrossSection:

Public Types
enum	{ nMassMapElements =116 }
typedef std::map< G4int, G4ScreeningTables >	ScreeningMap
typedef std::map< G4int, class G4ParticleDefinition * >	ParticleCache

Public Member Functions
	G4ScreenedCoulombCrossSection ()
	G4ScreenedCoulombCrossSection (const G4ScreenedCoulombCrossSection &src)
virtual	~G4ScreenedCoulombCrossSection ()
virtual void	LoadData (G4String screeningKey, G4int z1, G4double m1, G4double recoilCutoff)=0
void	BuildMFPTables (void)
virtual G4ScreenedCoulombCrossSection *	create ()=0
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 ()

Protected Attributes
ScreeningMap	screeningData
ParticleCache	targetMap
G4int	verbosity
std::map< G4int, G4_c2_const_ptr >	sigmaMap
std::map< G4int, G4_c2_const_ptr >	MFPTables

Additional Inherited Members
Static Public Member Functions inherited from G4ScreenedCoulombCrossSectionInfo
static const char *	CVSHeaderVers ()
static const char *	CVSFileVers ()

Detailed Description

Definition at line 95 of file G4ScreenedNuclearRecoil.hh.

Member Typedef Documentation

typedef std::map<G4int, class G4ParticleDefinition *> G4ScreenedCoulombCrossSection::ParticleCache

Definition at line 107 of file G4ScreenedNuclearRecoil.hh.

typedef std::map<G4int, G4ScreeningTables> G4ScreenedCoulombCrossSection::ScreeningMap

Definition at line 104 of file G4ScreenedNuclearRecoil.hh.

Member Enumeration Documentation

anonymous enum

Enumerator
nMassMapElements

Definition at line 123 of file G4ScreenedNuclearRecoil.hh.

{ nMassMapElements=116 };

Constructor & Destructor Documentation

G4ScreenedCoulombCrossSection::G4ScreenedCoulombCrossSection ( )

inline

Definition at line 99 of file G4ScreenedNuclearRecoil.hh.

: verbosity(1) { }

G4ScreenedCoulombCrossSection::G4ScreenedCoulombCrossSection ( const G4ScreenedCoulombCrossSection &  src )

inline

Definition at line 100 of file G4ScreenedNuclearRecoil.hh.

                                                                                : 
                G4ScreenedCoulombCrossSectionInfo(),verbosity(src.verbosity) { }

G4ScreenedCoulombCrossSection::~G4ScreenedCoulombCrossSection ( )

virtual

Definition at line 125 of file G4ScreenedNuclearRecoil.cc.

References MFPTables, and screeningData.

{
        screeningData.clear();
        MFPTables.clear();        
}

Member Function Documentation

void G4ScreenedCoulombCrossSection::BuildMFPTables

(

void

)

Definition at line 224 of file G4ScreenedNuclearRecoil.cc.

References G4Material::GetElementVector(), G4Material::GetMaterialTable(), G4Material::GetNumberOfElements(), G4Material::GetNumberOfMaterials(), G4Material::GetVecNbOfAtomsPerVolume(), G4Element::GetZ(), c2_factory< float_type >::log_log_interpolating_function(), eplot::material, MFPTables, sigmaMap, c2_function< float_type >::xmax(), and c2_function< float_type >::xmin().

Referenced by G4ScreenedNuclearRecoil::GetMeanFreePath().

{
        const G4int nmfpvals=200;

        std::vector<G4double> evals(nmfpvals), mfpvals(nmfpvals);

        // sum up inverse MFPs per element for each material        
        const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
        if (materialTable == 0) { return; }
        //G4Exception("G4ScreenedCoulombCrossSection::BuildMFPTables - no MaterialTable found)");
        
        G4int nMaterials = G4Material::GetNumberOfMaterials();

        for (G4int matidx=0; matidx < nMaterials; matidx++) {

                const G4Material* material= (*materialTable)[matidx];
                const G4ElementVector &elementVector = *(material->GetElementVector());
                const G4int nMatElements = material->GetNumberOfElements();

                const G4Element *element=0;
                const G4double *atomDensities=material->GetVecNbOfAtomsPerVolume();
                
                G4double emin=0, emax=0; // find innermost range of cross section functions
                for (G4int kel=0 ; kel < nMatElements ; kel++ )
        {
                        element=elementVector[kel];
                        G4int Z=(G4int)std::floor(element->GetZ()+0.5);
                        const G4_c2_function &ifunc=sigmaMap[Z];
                        if(!kel || ifunc.xmin() > emin) emin=ifunc.xmin();
                        if(!kel || ifunc.xmax() < emax) emax=ifunc.xmax();                        
        }
                
                G4double logint=std::log(emax/emin) / (nmfpvals-1) ; // logarithmic increment for tables
                
                // compute energy scale for interpolator.  Force exact values at both ends to avoid range errors
                for (G4int i=1; i<nmfpvals-1; i++) evals[i]=emin*std::exp(logint*i);
                evals.front()=emin;
                evals.back()=emax;
                
                // zero out the inverse mfp sums to start
                for (G4int eidx=0; eidx < nmfpvals; eidx++) mfpvals[eidx] = 0.0; 
                
                // sum inverse mfp for each element in this material and for each energy
                for (G4int kel=0 ; kel < nMatElements ; kel++ )
        {
                        element=elementVector[kel];
                        G4int Z=(G4int)std::floor(element->GetZ()+0.5);
                        const G4_c2_function &sigma=sigmaMap[Z];
                        G4double ndens = atomDensities[kel]; // compute atom fraction for this element in this material
                                                
                        for (G4int eidx=0; eidx < nmfpvals; eidx++) {
                                        mfpvals[eidx] += ndens*sigma(evals[eidx]);
                        }
        }
                
                // convert inverse mfp to regular mfp
                for (G4int eidx=0; eidx < nmfpvals; eidx++) {
                        mfpvals[eidx] = 1.0/mfpvals[eidx];
                }
                // and make a new interpolating function out of the sum
                MFPTables[matidx] = c2.log_log_interpolating_function().load(evals, mfpvals,true,0,true,0);
    }
}

virtual G4ScreenedCoulombCrossSection* G4ScreenedCoulombCrossSection::create ( )

pure virtual

Implemented in G4NativeScreenedCoulombCrossSection.

Referenced by G4ScreenedNuclearRecoil::GetNewCrossSectionHandler().

const G4ScreeningTables* G4ScreenedCoulombCrossSection::GetScreening ( G4int  Z )

inline

Definition at line 117 of file G4ScreenedNuclearRecoil.hh.

References screeningData.

Referenced by G4ScreenedCoulombClassicalKinematics::DoCollisionStep().

{ return &(screeningData[Z]); }

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

pure virtual

Implemented in G4NativeScreenedCoulombCrossSection.

Referenced by G4ScreenedNuclearRecoil::GetMeanFreePath().

const G4_c2_function* G4ScreenedCoulombCrossSection::operator[] ( G4int  materialIndex )

inline

Definition at line 128 of file G4ScreenedNuclearRecoil.hh.

References MFPTables.

                                                                 { 
                        return MFPTables.find(materialIndex)!=MFPTables.end() ? &(MFPTables[materialIndex].get()) : (G4_c2_function *)0;
                }

G4ParticleDefinition * G4ScreenedCoulombCrossSection::SelectRandomUnweightedTarget

(

const G4MaterialCutsCouple *

couple

)

Definition at line 148 of file G4ScreenedNuclearRecoil.cc.

References G4UniformRand, G4StableIsotopes::GetAbundance(), G4Material::GetElementVector(), G4StableIsotopes::GetFirstIsotope(), G4ParticleTable::GetIon(), G4StableIsotopes::GetIsotopeNucleonCount(), G4Element::GetIsotopeVector(), G4MaterialCutsCouple::GetMaterial(), G4Element::GetN(), G4Material::GetNumberOfElements(), G4StableIsotopes::GetNumberOfIsotopes(), G4Element::GetNumberOfIsotopes(), G4ParticleTable::GetParticleTable(), G4Element::GetRelativeAbundanceVector(), G4Material::GetTotNbOfAtomsPerVolume(), G4Material::GetVecNbOfAtomsPerVolume(), G4Element::GetZ(), eplot::material, N, and targetMap.

Referenced by G4ScreenedNuclearRecoil::PostStepDoIt().

{
        // Select randomly an element within the material, according to number density only        
        const G4Material* material = couple->GetMaterial();
        G4int nMatElements = material->GetNumberOfElements();
        const G4ElementVector* elementVector = material->GetElementVector();
        const G4Element *element=0;
        G4ParticleDefinition*target=0;
        
        // Special case: the material consists of one element
        if (nMatElements == 1)
    {
                element= (*elementVector)[0];
    }
        else
    {
                // Composite material
                G4double random = G4UniformRand() * material->GetTotNbOfAtomsPerVolume();
                G4double nsum=0.0;
                const G4double *atomDensities=material->GetVecNbOfAtomsPerVolume();
                
                for (G4int k=0 ; k < nMatElements ; k++ )
        {
                        nsum+=atomDensities[k];
                        element= (*elementVector)[k];
                        if (nsum >= random) break;
        }
    }

        G4int N=0;
        G4int Z=(G4int)std::floor(element->GetZ()+0.5);
        
        G4int nIsotopes=element->GetNumberOfIsotopes();
        if(!nIsotopes) {
                if(Z<=92) {
                        // we have no detailed material isotopic info available, 
                        // so use G4StableIsotopes table up to Z=92
                        static G4StableIsotopes theIso; // get a stable isotope table for default results
                        nIsotopes=theIso.GetNumberOfIsotopes(Z);
                        G4double random = 100.0*G4UniformRand(); // values are expressed as percent, sum is 100
                        G4int tablestart=theIso.GetFirstIsotope(Z);
                        G4double asum=0.0;
                        for(G4int i=0; i<nIsotopes; i++) {
                                asum+=theIso.GetAbundance(i+tablestart);
                                N=theIso.GetIsotopeNucleonCount(i+tablestart);
                                if(asum >= random) break;
                        }
                } else {
                        // too heavy for stable isotope table, just use mean mass
                        N=(G4int)std::floor(element->GetN()+0.5);
                }
        } else {
                G4int i;
                const G4IsotopeVector *isoV=element->GetIsotopeVector();
                G4double random = G4UniformRand();
                G4double *abundance=element->GetRelativeAbundanceVector();
                G4double asum=0.0;
                for(i=0; i<nIsotopes; i++) {
                        asum+=abundance[i];
                        N=(*isoV)[i]->GetN();
                        if(asum >= random) break;
                }
        }
        
        // get the official definition of this nucleus, to get the correct value of A
        // note that GetIon is very slow, so we will cache ones we have already found ourselves.
        ParticleCache::iterator p=targetMap.find(Z*1000+N);
        if (p != targetMap.end()) {
                target=(*p).second;
        } else{
                target=G4ParticleTable::GetParticleTable()->GetIon(Z, N, 0.0);        
                targetMap[Z*1000+N]=target;
        }
        return target;
}

void G4ScreenedCoulombCrossSection::SetVerbosity ( G4int  v )

inline

Definition at line 118 of file G4ScreenedNuclearRecoil.hh.

References test::v, and verbosity.

Referenced by G4ScreenedNuclearRecoil::GetNewCrossSectionHandler().

{ verbosity=v; }

G4double G4ScreenedCoulombCrossSection::standardmass ( G4int  z1 )

inline

Definition at line 125 of file G4ScreenedNuclearRecoil.hh.

References nMassMapElements.

Referenced by G4NativeScreenedCoulombCrossSection::LoadData().

{ return z1 <= nMassMapElements ? massmap[z1] : 2.5*z1; }

Field Documentation

std::map<G4int, G4_c2_const_ptr > G4ScreenedCoulombCrossSection::MFPTables

protected

Definition at line 137 of file G4ScreenedNuclearRecoil.hh.

Referenced by BuildMFPTables(), operator[](), and ~G4ScreenedCoulombCrossSection().

ScreeningMap G4ScreenedCoulombCrossSection::screeningData

protected

Definition at line 133 of file G4ScreenedNuclearRecoil.hh.

Referenced by GetScreening(), G4NativeScreenedCoulombCrossSection::LoadData(), and ~G4ScreenedCoulombCrossSection().

std::map<G4int, G4_c2_const_ptr > G4ScreenedCoulombCrossSection::sigmaMap

protected

Definition at line 136 of file G4ScreenedNuclearRecoil.hh.

Referenced by BuildMFPTables(), and G4NativeScreenedCoulombCrossSection::LoadData().

ParticleCache G4ScreenedCoulombCrossSection::targetMap

protected

Definition at line 134 of file G4ScreenedNuclearRecoil.hh.

Referenced by SelectRandomUnweightedTarget().

G4int G4ScreenedCoulombCrossSection::verbosity

protected

Definition at line 135 of file G4ScreenedNuclearRecoil.hh.

Referenced by G4NativeScreenedCoulombCrossSection::LoadData(), and SetVerbosity().

---

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

• G4ScreenedNuclearRecoil.hh
• G4ScreenedNuclearRecoil.cc