G4ScreenedCoulombCrossSection Class Reference

#include <G4ScreenedNuclearRecoil.hh>

Inheritance diagram for G4ScreenedCoulombCrossSection:

Collaboration 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

Static Private Attributes
static const G4double	massmap [nMassMapElements+1]

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

Detailed Description

Definition at line 100 of file G4ScreenedNuclearRecoil.hh.

Member Typedef Documentation

ParticleCache

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

Definition at line 112 of file G4ScreenedNuclearRecoil.hh.

ScreeningMap

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

Definition at line 109 of file G4ScreenedNuclearRecoil.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
nMassMapElements

Definition at line 134 of file G4ScreenedNuclearRecoil.hh.

{ nMassMapElements=116 };

Constructor & Destructor Documentation

G4ScreenedCoulombCrossSection() [1/2]

G4ScreenedCoulombCrossSection::G4ScreenedCoulombCrossSection ( )

inline

Definition at line 104 of file G4ScreenedNuclearRecoil.hh.

: verbosity(1) { }

G4ScreenedCoulombCrossSection() [2/2]

G4ScreenedCoulombCrossSection::G4ScreenedCoulombCrossSection ( const G4ScreenedCoulombCrossSection &  src )

inline

Definition at line 105 of file G4ScreenedNuclearRecoil.hh.

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

~G4ScreenedCoulombCrossSection()

G4ScreenedCoulombCrossSection::~G4ScreenedCoulombCrossSection ( )

virtual

Definition at line 129 of file G4ScreenedNuclearRecoil.cc.

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

Member Function Documentation

BuildMFPTables()

void G4ScreenedCoulombCrossSection::BuildMFPTables

(

void

)

Definition at line 247 of file G4ScreenedNuclearRecoil.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

create()

virtual G4ScreenedCoulombCrossSection* G4ScreenedCoulombCrossSection::create ( )

pure virtual

Implemented in G4NativeScreenedCoulombCrossSection.

Here is the caller graph for this function:

GetScreening()

const G4ScreeningTables* G4ScreenedCoulombCrossSection::GetScreening ( G4int  Z )

inline

Definition at line 126 of file G4ScreenedNuclearRecoil.hh.

                     { return &(screeningData[Z]); }

Here is the caller graph for this function:

LoadData()

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

pure virtual

Implemented in G4NativeScreenedCoulombCrossSection.

Here is the caller graph for this function:

operator[]()

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

inline

Definition at line 140 of file G4ScreenedNuclearRecoil.hh.

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

SelectRandomUnweightedTarget()

G4ParticleDefinition * G4ScreenedCoulombCrossSection::SelectRandomUnweightedTarget

(

const G4MaterialCutsCouple *

couple

)

Definition at line 166 of file G4ScreenedNuclearRecoil.cc.

{
  // 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=G4IonTable::GetIonTable()->GetIon(Z, N, 0.0); 
                targetMap[Z*1000+N]=target;
        }
        return target;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetVerbosity()

void G4ScreenedCoulombCrossSection::SetVerbosity ( G4int  v )

inline

Definition at line 128 of file G4ScreenedNuclearRecoil.hh.

{ verbosity=v; }

Here is the caller graph for this function:

standardmass()

G4double G4ScreenedCoulombCrossSection::standardmass ( G4int  z1 )

inline

Definition at line 136 of file G4ScreenedNuclearRecoil.hh.

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

Member Data Documentation

massmap

const G4double G4ScreenedCoulombCrossSection::massmap

staticprivate

Initial value:

={
  0, 1.007940, 4.002602, 6.941000, 9.012182, 10.811000, 12.010700, 
  14.006700, 15.999400, 18.998403, 20.179700, 22.989770, 24.305000, 26.981538, 
  28.085500, 
  30.973761, 32.065000, 35.453000, 39.948000, 39.098300, 40.078000, 44.955910, 
  47.867000, 
  50.941500, 51.996100, 54.938049, 55.845000, 58.933200, 58.693400, 63.546000, 
  65.409000, 
  69.723000, 72.640000, 74.921600, 78.960000, 79.904000, 83.798000, 85.467800, 
  87.620000, 
  88.905850, 91.224000, 92.906380, 95.940000, 98.000000, 101.070000, 102.905500,
  106.420000, 
  107.868200, 112.411000, 114.818000, 118.710000, 121.760000, 127.600000, 
  126.904470, 131.293000, 
  132.905450, 137.327000, 138.905500, 140.116000, 140.907650, 144.240000, 
  145.000000, 150.360000, 
  151.964000, 157.250000, 158.925340, 162.500000, 164.930320, 167.259000, 
  168.934210, 173.040000, 
  174.967000, 178.490000, 180.947900, 183.840000, 186.207000, 190.230000, 
  192.217000, 195.078000, 
  196.966550, 200.590000, 204.383300, 207.200000, 208.980380, 209.000000, 
  210.000000, 222.000000, 
  223.000000, 226.000000, 227.000000, 232.038100, 231.035880, 238.028910, 
  237.000000, 244.000000, 
  243.000000, 247.000000, 247.000000, 251.000000, 252.000000, 257.000000, 
  258.000000, 259.000000, 
  262.000000, 261.000000, 262.000000, 266.000000, 264.000000, 277.000000, 
  268.000000, 281.000000, 
  272.000000, 285.000000, 282.500000, 289.000000, 287.500000, 292.000000}

Definition at line 154 of file G4ScreenedNuclearRecoil.hh.

MFPTables

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

protected

Definition at line 151 of file G4ScreenedNuclearRecoil.hh.

screeningData

ScreeningMap G4ScreenedCoulombCrossSection::screeningData

protected

Definition at line 146 of file G4ScreenedNuclearRecoil.hh.

sigmaMap

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

protected

Definition at line 149 of file G4ScreenedNuclearRecoil.hh.

targetMap

ParticleCache G4ScreenedCoulombCrossSection::targetMap

protected

Definition at line 147 of file G4ScreenedNuclearRecoil.hh.

verbosity

G4int G4ScreenedCoulombCrossSection::verbosity

protected

Definition at line 148 of file G4ScreenedNuclearRecoil.hh.

---

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

• G4ScreenedNuclearRecoil.hh
• G4ScreenedNuclearRecoil.cc