#include <G4PenelopeIonisationCrossSection.hh>

Inheritance diagram for G4PenelopeIonisationCrossSection:

Collaboration diagram for G4PenelopeIonisationCrossSection:

Public Member Functions
	G4PenelopeIonisationCrossSection ()
	Constructor. More...

	~G4PenelopeIonisationCrossSection ()
	Destructor. Clean all tables. More...

std::vector< G4double >	GetCrossSection (G4int Z, G4double incidentEnergy, G4double mass, G4double deltaEnergy, const G4Material *mat)

G4double	CrossSection (G4int Z, G4AtomicShellEnumerator shell, G4double incidentEnergy, G4double mass, const G4Material *mat)

std::vector< G4double >	Probabilities (G4int Z, G4double incidentEnergy, G4double mass, G4double deltaEnergy, const G4Material *mat)

void	SetVerbosityLevel (G4int vl)
	Getter/setter for the verbosity level. More...

G4int	GetVerbosityLevel ()

Public Member Functions inherited from G4VhShellCrossSection
	G4VhShellCrossSection (const G4String &xname="")

virtual	~G4VhShellCrossSection ()

G4int	SelectRandomShell (G4int Z, G4double incidentEnergy, G4double mass, G4double deltaEnergy, const G4Material *mat)

virtual void	SetTotalCS (G4double)

const G4String &	GetName () const

Private Member Functions
G4PenelopeIonisationCrossSection &	operator= (const G4PenelopeIonisationCrossSection &right)

	G4PenelopeIonisationCrossSection (const G4PenelopeIonisationCrossSection &)

G4int	FindShellIDIndex (const G4Material *mat, G4int Z, G4AtomicShellEnumerator shell)

Private Attributes
G4PenelopeOscillatorManager *	oscManager

G4int	verboseLevel

std::map< std::pair< const G4Material , G4int >, G4DataVector > *	shellIDTable

G4int	nMaxLevels

G4double	fLowEnergyLimit

G4double	fHighEnergyLimit

G4PenelopeIonisationXSHandler *	theCrossSectionHandler

const G4AtomicTransitionManager *	transitionManager

Detailed Description

Definition at line 58 of file G4PenelopeIonisationCrossSection.hh.

Constructor & Destructor Documentation

◆ G4PenelopeIonisationCrossSection() [1/2]

G4PenelopeIonisationCrossSection::G4PenelopeIonisationCrossSection ( )

Constructor.

NOTICE: working only for e- at the moment (no interface available for e+)

Definition at line 46 of file G4PenelopeIonisationCrossSection.cc.

                                                                    : 
   G4VhShellCrossSection("Penelope"),shellIDTable(0),
   theCrossSectionHandler(0)
 { 
   oscManager = G4PenelopeOscillatorManager::GetOscillatorManager();
   nMaxLevels = 9;
 
   // Verbosity scale:
   // 0 = nothing
   // 1 = calculation of cross sections, file openings, sampling of atoms
   // 2 = entering in methods
   verboseLevel = 0;
 
   fLowEnergyLimit  = 10.0*eV;
   fHighEnergyLimit = 100.0*GeV;
 
   transitionManager = G4AtomicTransitionManager::Instance();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~G4PenelopeIonisationCrossSection()

G4PenelopeIonisationCrossSection::~G4PenelopeIonisationCrossSection ( )

Destructor. Clean all tables.

Definition at line 67 of file G4PenelopeIonisationCrossSection.cc.

 {
   if (theCrossSectionHandler)
     delete theCrossSectionHandler;
 }

◆ G4PenelopeIonisationCrossSection() [2/2]

G4PenelopeIonisationCrossSection::G4PenelopeIonisationCrossSection ( const G4PenelopeIonisationCrossSection & )

private

Member Function Documentation

◆ CrossSection()

G4double G4PenelopeIonisationCrossSection::CrossSection	(	G4int	Z,
		G4AtomicShellEnumerator	shell,
		G4double	incidentEnergy,
		G4double	mass,
		const G4Material *	mat
	)

virtual

Purely virtual method from the base interface. Returns the cross section for the given shell in the element Z of material mat at the specified energy

Implements G4VhShellCrossSection.

Definition at line 75 of file G4PenelopeIonisationCrossSection.cc.

 {
   if (verboseLevel > 1)    
     G4cout << "Entering in method G4PenelopeIonisationCrossSection::CrossSection()" << G4endl;
         
   G4double cross = 0.;
 
   //Material pointer is not available
   if (!material)
     {
       //CRASH!
       G4ExceptionDescription ed;
       ed << "The method has been called with a NULL G4Material pointer" << G4endl;
       G4Exception("G4PenelopeIonisationCrossSection::CrossSection()","em2042",
           FatalException,ed);
       return cross;
     }
 
   if (!theCrossSectionHandler)
     theCrossSectionHandler = new G4PenelopeIonisationXSHandler();
 
   theCrossSectionHandler->BuildXSTable(material,0.,G4Electron::Electron());
 
   G4int nmax = std::min(nMaxLevels,transitionManager->NumberOfShells(Z));
 
   if(G4int(shell) < nmax && 
      incidentEnergy >= fLowEnergyLimit && incidentEnergy <= fHighEnergyLimit) 
     {
       //The shells in Penelope are organized per *material*, rather than per 
       //element, so given a material one has to find the proper index for the 
       //given Z and shellID. An appropriate lookup table is used to avoid 
       //recalculation.
       G4int index = FindShellIDIndex(material,Z,shell);
 
       //Index is not available!
       if (index < 0)
     return cross;
 
       const G4PenelopeCrossSection*  theXS = 
     theCrossSectionHandler->GetCrossSectionTableForCouple(G4Electron::Electron(),
                                   material,
                                   0.);
 
       //Cross check that everything is fine:
       G4PenelopeOscillator* theOsc = oscManager->GetOscillatorIonisation(material,index);
       if (theOsc->GetParentZ() != Z || theOsc->GetShellFlag()-1 != G4int(shell))
     {
       //something went wrong!
       G4ExceptionDescription ed;
       ed << "There is something wrong here: it looks like the index is wrong" << G4endl;
       ed << "Requested: shell " << G4int(shell) << " and Z = " << Z << G4endl;
       ed << "Retrieved: " << theOsc->GetShellFlag()-1 << " and Z = " << theOsc->GetParentZ() << G4endl;   
       G4Exception("G4PenelopeIonisationCrossSection::CrossSection()","em2043",
               JustWarning,ed);
       return cross;
     }
 
 
       G4double crossPerMolecule = (theXS) ? theXS->GetShellCrossSection(index,incidentEnergy) : 0.;
 
       //Now it must be converted in cross section per atom. I need the number of 
       //atoms of the given Z per molecule.
       G4double atomsPerMolec = oscManager->GetNumberOfZAtomsPerMolecule(material,Z);
       if (atomsPerMolec)
     cross = crossPerMolecule/atomsPerMolec;
      
 
       if (verboseLevel > 0)
     {
       G4cout << "Cross section of shell " << G4int(shell) << " and Z= " << Z;
       G4cout << " of material: " << material->GetName() << " and energy = " << incidentEnergy/keV << " keV" << G4endl;
       G4cout << "--> " << cross/barn << " barn" << G4endl;
       G4cout << "Shell binding energy: " << theOsc->GetIonisationEnergy()/eV << " eV;" ;
       G4cout << " resonance energy: " << theOsc->GetResonanceEnergy()/eV << "eV" << G4endl;
        if (verboseLevel > 2)
          {
            G4cout << "Cross section per molecule: " << crossPerMolecule/barn << " barn" << G4endl;
            G4cout << "Atoms " << Z << " per molecule: " << atomsPerMolec << G4endl;
          }
     }     
     }  
   
   return cross;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindShellIDIndex()

G4int G4PenelopeIonisationCrossSection::FindShellIDIndex	(	const G4Material *	mat,
		G4int	Z,
		G4AtomicShellEnumerator	shell
	)

private

The shells in Penelope are organized per material, rather than per element, so given a material one has to find the proper index for the given Z and shellID. An appropriate look-up table is used to avoid recalculation.

Definition at line 202 of file G4PenelopeIonisationCrossSection.cc.

 {
    if (verboseLevel > 1)    
      G4cout << "Entering in method G4PenelopeIonisationCrossSection::FindShellIDIndex()" << G4endl;
 
   if (!shellIDTable)
     shellIDTable = new std::map< std::pair<const G4Material*,G4int>, G4DataVector*>;
  
   std::pair<const G4Material*,G4int> theKey = std::make_pair(mat,Z);
   G4int result = -1;
   G4int ishell = G4int(shell);
   
   if (shellIDTable->count(theKey)) //table already built, and containing the element
     {   
       if (verboseLevel > 2)
     G4cout << "FindShellIDIndex: Table already built for " << mat->GetName() << G4endl;
       G4DataVector* theVec = shellIDTable->find(theKey)->second;
          
       if (ishell>=0 && ishell < (G4int) theVec->size()) //check we are not off-boundary
     result = (G4int) (*theVec)[ishell];    
       else
     {
       G4ExceptionDescription ed;
       ed << "Shell ID: " << ishell << " not available for material " << mat->GetName() << " and Z = " << 
         Z << G4endl;
       G4Exception("G4PenelopeIonisationCrossSection::FindShellIDIndex()","em2041",JustWarning,
               ed);
       return -1;
     }          
     }
   else
     {
       if (verboseLevel > 2)
     G4cout << "FindShellIDIndex: Table to be built for " << mat->GetName() << G4endl;
       //Not contained: look for it
       G4PenelopeOscillatorTable* theTable = oscManager->GetOscillatorTableIonisation(mat);
       size_t numberOfOscillators = theTable->size();
           
       //oscillator loop
       //initialize everything at -1
       G4DataVector* dat = new G4DataVector(nMaxLevels,-1);
       for (size_t iosc=0;iosc<numberOfOscillators;iosc++)
     {      
       G4PenelopeOscillator* theOsc = (*theTable)[iosc];
       //level is found!
       if (theOsc->GetParentZ() == Z)
         {
           //individual shells relative to the given material        
           G4int shFlag = theOsc->GetShellFlag();      
           //Notice: GetShellFlag() starts from 1, the G4AtomicShellEnumerator from 0
           if (shFlag < 30)
         (*dat)[shFlag-1] = (G4double) iosc; //index of the given shell
           if ((shFlag-1) == ishell) // this is what we were looking for
         result = (G4int) iosc;
         }      
     }
       shellIDTable->insert(std::make_pair(theKey,dat));
     }
 
   if (verboseLevel > 1)    
     G4cout << "Leaving method G4PenelopeIonisationCrossSection::FindShellIDIndex() with index = " << result << G4endl;
 
   return result;
   
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCrossSection()

std::vector< G4double > G4PenelopeIonisationCrossSection::GetCrossSection	(	G4int	Z,
		G4double	incidentEnergy,
		G4double	mass,
		G4double	deltaEnergy,
		const G4Material *	mat
	)

virtual

Purely virtual method from the base interface. Returns the cross section for all levels of element Z in material mat at the given energy

Implements G4VhShellCrossSection.

Definition at line 166 of file G4PenelopeIonisationCrossSection.cc.

 {
   G4int nmax = std::min(nMaxLevels,transitionManager->NumberOfShells(Z));
   std::vector<G4double> vec(nmax,0.0); 
   for(G4int i=0; i<nmax; ++i) {
     vec[i] = CrossSection(Z, G4AtomicShellEnumerator(i), kinEnergy,0.,mat); 
   }
   return vec;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetVerbosityLevel()

G4int G4PenelopeIonisationCrossSection::GetVerbosityLevel ( )

inline

Definition at line 95 of file G4PenelopeIonisationCrossSection.hh.

95 {return verboseLevel;};

G4PenelopeIonisationCrossSection::verboseLevel

G4int verboseLevel

Definition: G4PenelopeIonisationCrossSection.hh:104

Here is the call graph for this function:

◆ operator=()

G4PenelopeIonisationCrossSection& G4PenelopeIonisationCrossSection::operator= ( const G4PenelopeIonisationCrossSection & right )

private

Here is the caller graph for this function:

◆ Probabilities()

std::vector< G4double > G4PenelopeIonisationCrossSection::Probabilities	(	G4int	Z,
		G4double	incidentEnergy,
		G4double	mass,
		G4double	deltaEnergy,
		const G4Material *	mat
	)

virtual

Purely virtual method from the base interface. Returns the shell ionisation probabilities for the given Z in the material mat at the specified energy.

Implements G4VhShellCrossSection.

Definition at line 182 of file G4PenelopeIonisationCrossSection.cc.

 {
   std::vector<G4double> vec = GetCrossSection(Z, kinEnergy,0,0,mat);
   size_t n = vec.size();
   size_t i=0;
   G4double sum = 0.0;
   for(i=0; i<n; ++i) { sum += vec[i]; }
   if(sum > 0.0) { 
     sum = 1.0/sum; 
     for(i=0; i<n; ++i) { vec[i] = vec[i]*sum; }
   }
   return vec;
 }