#include <G4PenelopeIonisationCrossSection.hh>

Inheritance diagram for G4PenelopeIonisationCrossSection:

Public Member Functions
G4double	CrossSection (G4int Z, G4AtomicShellEnumerator shell, G4double incidentEnergy, G4double mass, const G4Material *mat) override

	G4PenelopeIonisationCrossSection ()
	Constructor. More...

	G4PenelopeIonisationCrossSection (const G4PenelopeIonisationCrossSection &)=delete

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

const G4String &	GetName () const

G4int	GetVerbosityLevel ()

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

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

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

virtual void	SetTotalCS (G4double)

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

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

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

Private Attributes
G4PenelopeIonisationXSHandler *	fCrossSectionHandler

G4double	fHighEnergyLimit

G4double	fLowEnergyLimit

G4int	fNMaxLevels

G4PenelopeOscillatorManager *	fOscManager

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

const G4AtomicTransitionManager *	fTransitionManager

G4int	fVerboseLevel

G4String	name

Detailed Description

Definition at line 57 of file G4PenelopeIonisationCrossSection.hh.

Constructor & Destructor Documentation

◆ G4PenelopeIonisationCrossSection() [1/2]

G4PenelopeIonisationCrossSection::G4PenelopeIonisationCrossSection ( )

explicit

Constructor.

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

Definition at line 45 of file G4PenelopeIonisationCrossSection.cc.

                                                                   : 
  G4VhShellCrossSection("Penelope"),fShellIDTable(nullptr),
  fCrossSectionHandler(nullptr)
{ 
  fOscManager = G4PenelopeOscillatorManager::GetOscillatorManager();
  fNMaxLevels = 9;
 
  // Verbosity scale:
  // 0 = nothing
  // 1 = calculation of cross sections, file openings, sampling of atoms
  // 2 = entering in methods
  fVerboseLevel = 0;
 
  fLowEnergyLimit  = 10.0*eV;
  fHighEnergyLimit = 100.0*GeV;
 
  fTransitionManager = G4AtomicTransitionManager::Instance();
}

References eV, fHighEnergyLimit, fLowEnergyLimit, fNMaxLevels, fOscManager, fTransitionManager, fVerboseLevel, G4PenelopeOscillatorManager::GetOscillatorManager(), GeV, and G4AtomicTransitionManager::Instance().

◆ ~G4PenelopeIonisationCrossSection()

G4PenelopeIonisationCrossSection::~G4PenelopeIonisationCrossSection ( )

Destructor. Clean all tables.

Definition at line 66 of file G4PenelopeIonisationCrossSection.cc.

{
  if (fCrossSectionHandler)
    delete fCrossSectionHandler;
}

References fCrossSectionHandler.

◆ G4PenelopeIonisationCrossSection() [2/2]

G4PenelopeIonisationCrossSection::G4PenelopeIonisationCrossSection ( const G4PenelopeIonisationCrossSection & )

delete

Member Function Documentation

◆ CrossSection()

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

overridevirtual

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 74 of file G4PenelopeIonisationCrossSection.cc.

{
  if (fVerboseLevel > 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 (!fCrossSectionHandler)
    fCrossSectionHandler = new G4PenelopeIonisationXSHandler();
 
  fCrossSectionHandler->BuildXSTable(material,0.,G4Electron::Electron());
 
  G4int nmax = std::min(fNMaxLevels,fTransitionManager->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 fShellID. 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 = 
    fCrossSectionHandler->GetCrossSectionTableForCouple(G4Electron::Electron(),
                                  material,
                                  0.);
 
      //Cross check that everything is fine:
      G4PenelopeOscillator* theOsc = fOscManager->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 = fOscManager->GetNumberOfZAtomsPerMolecule(material,Z);
      if (atomsPerMolec)
    cross = crossPerMolecule/atomsPerMolec;
     
      if (fVerboseLevel > 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 (fVerboseLevel > 2)
         {
           G4cout << "Cross section per molecule: " << crossPerMolecule/barn << " barn" << G4endl;
           G4cout << "Atoms " << Z << " per molecule: " << atomsPerMolec << G4endl;
         }
    }     
    }  
  
  return cross;
}

References barn, G4PenelopeIonisationXSHandler::BuildXSTable(), G4Electron::Electron(), eV, FatalException, fCrossSectionHandler, fHighEnergyLimit, FindShellIDIndex(), fLowEnergyLimit, fNMaxLevels, fOscManager, fTransitionManager, fVerboseLevel, G4cout, G4endl, G4Exception(), G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple(), G4PenelopeOscillator::GetIonisationEnergy(), G4PenelopeOscillatorManager::GetNumberOfZAtomsPerMolecule(), G4PenelopeOscillatorManager::GetOscillatorIonisation(), G4PenelopeOscillator::GetParentZ(), G4PenelopeOscillator::GetResonanceEnergy(), G4PenelopeCrossSection::GetShellCrossSection(), G4PenelopeOscillator::GetShellFlag(), JustWarning, keV, eplot::material, G4INCL::Math::min(), G4AtomicTransitionManager::NumberOfShells(), and Z.

Referenced by GetCrossSection().

◆ 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 199 of file G4PenelopeIonisationCrossSection.cc.

{
   if (fVerboseLevel > 1)    
     G4cout << "Entering in method G4PenelopeIonisationCrossSection::FindShellIDIndex()" << G4endl;
 
  if (!fShellIDTable)
    fShellIDTable = 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 (fShellIDTable->count(theKey)) //table already built, and containing the element
    {   
      if (fVerboseLevel > 2)
    G4cout << "FindShellIDIndex: Table already built for " << mat->GetName() << G4endl;
      G4DataVector* theVec = fShellIDTable->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 (fVerboseLevel > 2)
    G4cout << "FindShellIDIndex: Table to be built for " << mat->GetName() << G4endl;
      //Not contained: look for it
      G4PenelopeOscillatorTable* theTable = fOscManager->GetOscillatorTableIonisation(mat);
      size_t numberOfOscillators = theTable->size();
          
      //oscillator loop
      //initialize everything at -1
      G4DataVector* dat = new G4DataVector(fNMaxLevels,-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;
        }      
    }
      fShellIDTable->insert(std::make_pair(theKey,dat));
    }
 
  if (fVerboseLevel > 1)    
    G4cout << "Leaving method G4PenelopeIonisationCrossSection::FindShellIDIndex() with index = " 
       << result << G4endl;
 
  return result;  
}

References fNMaxLevels, fOscManager, fShellIDTable, fVerboseLevel, G4cout, G4endl, G4Exception(), G4Material::GetName(), G4PenelopeOscillatorManager::GetOscillatorTableIonisation(), G4PenelopeOscillator::GetParentZ(), G4PenelopeOscillator::GetShellFlag(), JustWarning, and Z.

Referenced by CrossSection().

◆ GetCrossSection()

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

overridevirtual

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 163 of file G4PenelopeIonisationCrossSection.cc.

{
  G4int nmax = std::min(fNMaxLevels,fTransitionManager->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;
}

References CrossSection(), fNMaxLevels, fTransitionManager, G4INCL::Math::min(), G4AtomicTransitionManager::NumberOfShells(), and Z.

Referenced by Probabilities().

◆ GetName()

const G4String & G4VhShellCrossSection::GetName ( ) const

inlineinherited

Definition at line 102 of file G4VhShellCrossSection.hh.

{
  return name;
} 

References G4VhShellCrossSection::name.

Referenced by G4UAtomicDeexcitation::InitialiseForNewRun().

◆ GetVerbosityLevel()

G4int G4PenelopeIonisationCrossSection::GetVerbosityLevel ( )

inline

Definition at line 94 of file G4PenelopeIonisationCrossSection.hh.

94{return fVerboseLevel;};

References fVerboseLevel.

◆ operator=()

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

delete

◆ Probabilities()

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

overridevirtual

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

References GetCrossSection(), CLHEP::detail::n, and Z.

◆ SelectRandomShell()

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

inherited

Definition at line 63 of file G4VhShellCrossSection.cc.

{
  std::vector<G4double> p = 
    Probabilities(Z,incidentEnergy,mass,deltaEnergy,mat);
  G4int shell = -1;
  size_t nShells = p.size();
  G4double q = G4UniformRand();
  for (size_t i=0; i<nShells; i++) {
    
    if (p[i] >= q) {
      shell = i;
      break;
    }
    q -= p[i];
  }
  return shell;
}