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

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

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

Definition at line 112 of file G4ScreenedNuclearRecoil.hh.

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

Definition at line 109 of file G4ScreenedNuclearRecoil.hh.

Member Enumeration Documentation

anonymous enum

Enumerator
nMassMapElements

Definition at line 134 of file G4ScreenedNuclearRecoil.hh.

{ nMassMapElements=116 };

Constructor & Destructor Documentation

G4ScreenedCoulombCrossSection::G4ScreenedCoulombCrossSection ( )

inline

Definition at line 104 of file G4ScreenedNuclearRecoil.hh.

: verbosity(1) { }

G4ScreenedCoulombCrossSection::G4ScreenedCoulombCrossSection ( const G4ScreenedCoulombCrossSection &  src )

inline

Definition at line 105 of file G4ScreenedNuclearRecoil.hh.

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

G4ScreenedCoulombCrossSection::~G4ScreenedCoulombCrossSection ( )

virtual

Definition at line 129 of file G4ScreenedNuclearRecoil.cc.

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

Member Function Documentation

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:

virtual G4ScreenedCoulombCrossSection* G4ScreenedCoulombCrossSection::create ( )

pure virtual

Implemented in G4NativeScreenedCoulombCrossSection.

Here is the caller graph for this function:

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:

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:

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

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:

void G4ScreenedCoulombCrossSection::SetVerbosity ( G4int  v )

inline

Definition at line 128 of file G4ScreenedNuclearRecoil.hh.

{ verbosity=v; }

Here is the caller graph for this function:

G4double G4ScreenedCoulombCrossSection::standardmass ( G4int  z1 )

inline

Definition at line 136 of file G4ScreenedNuclearRecoil.hh.

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

Here is the caller graph for this function:

Member Data Documentation

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

protected

Definition at line 151 of file G4ScreenedNuclearRecoil.hh.

ScreeningMap G4ScreenedCoulombCrossSection::screeningData

protected

Definition at line 146 of file G4ScreenedNuclearRecoil.hh.

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

protected

Definition at line 149 of file G4ScreenedNuclearRecoil.hh.

ParticleCache G4ScreenedCoulombCrossSection::targetMap

protected

Definition at line 147 of file G4ScreenedNuclearRecoil.hh.

G4int G4ScreenedCoulombCrossSection::verbosity

protected

Definition at line 148 of file G4ScreenedNuclearRecoil.hh.

---

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