G4PenelopeIonisationXSHandler Class Reference

#include <G4PenelopeIonisationXSHandler.hh>

Public Member Functions
	G4PenelopeIonisationXSHandler (size_t nBins=200)
virtual	~G4PenelopeIonisationXSHandler ()
	Destructor. Clean all tables.
G4double	GetDensityCorrection (const G4Material *, const G4double energy) const
	Returns the density coeection for the material at the given energy.
const G4PenelopeCrossSection *	GetCrossSectionTableForCouple (const G4ParticleDefinition *, const G4Material *, const G4double cut) const
void	SetVerboseLevel (G4int vl)
	Setter for the verbosity level.
void	BuildXSTable (const G4Material *, G4double cut, const G4ParticleDefinition *, G4bool isMaster=true)
	This can be inkoved only by the master.
G4PenelopeIonisationXSHandler &	operator= (const G4PenelopeIonisationXSHandler &right)=delete
	G4PenelopeIonisationXSHandler (const G4PenelopeIonisationXSHandler &)=delete

Detailed Description

Definition at line 59 of file G4PenelopeIonisationXSHandler.hh.

Constructor & Destructor Documentation

G4PenelopeIonisationXSHandler() [1/2]

G4PenelopeIonisationXSHandler::G4PenelopeIonisationXSHandler ( size_t nBins = 200 )

explicit

Constructor. nBins is the number of intervals in the energy grid. By default the energy grid goes from 100 eV to 100 GeV.

Definition at line 46 of file G4PenelopeIonisationXSHandler.cc.

  :fXSTableElectron(nullptr),fXSTablePositron(nullptr),
   fDeltaTable(nullptr),fEnergyGrid(nullptr)
{
  fNBins = nb;
  G4double LowEnergyLimit = 100.0*eV;
  G4double HighEnergyLimit = 100.0*GeV;
  fOscManager = G4PenelopeOscillatorManager::GetOscillatorManager();
  fXSTableElectron = new 
    std::map< std::pair<const G4Material*,G4double>, G4PenelopeCrossSection*>;
  fXSTablePositron = new 
    std::map< std::pair<const G4Material*,G4double>, G4PenelopeCrossSection*>;
 
  fDeltaTable = new std::map<const G4Material*,G4PhysicsFreeVector*>;
  fEnergyGrid = new G4PhysicsLogVector(LowEnergyLimit,
                      HighEnergyLimit, 
                      fNBins-1); //one hidden bin is added
  fVerboseLevel = 0;
}

Referenced by G4PenelopeIonisationXSHandler(), and operator=().

~G4PenelopeIonisationXSHandler()

G4PenelopeIonisationXSHandler::~G4PenelopeIonisationXSHandler ( )

virtual

Destructor. Clean all tables.

Definition at line 68 of file G4PenelopeIonisationXSHandler.cc.

{
  if (fXSTableElectron)
    {
      for (auto& item : (*fXSTableElectron))
    {     
      //G4PenelopeCrossSection* tab = i->second;
      delete item.second;
    }
      delete fXSTableElectron;
      fXSTableElectron = nullptr;
    }
 
  if (fXSTablePositron)
    {
      for (auto& item : (*fXSTablePositron))
    {
      //G4PenelopeCrossSection* tab = i->second;
      delete item.second;
    }
      delete fXSTablePositron;
      fXSTablePositron = nullptr;
    }
  if (fDeltaTable)
    {      
      for (auto& item : (*fDeltaTable))
    delete item.second;     
      delete fDeltaTable;
      fDeltaTable = nullptr;
    } 
  if (fEnergyGrid)
    delete fEnergyGrid;
  
  if (fVerboseLevel > 2)
    G4cout << "G4PenelopeIonisationXSHandler. Tables have been cleared" 
       << G4endl;
}

G4PenelopeIonisationXSHandler() [2/2]

G4PenelopeIonisationXSHandler::G4PenelopeIonisationXSHandler ( const G4PenelopeIonisationXSHandler & )

delete

Member Function Documentation

BuildXSTable()

void G4PenelopeIonisationXSHandler::BuildXSTable	(	const G4Material *	mat,
		G4double	cut,
		const G4ParticleDefinition *	part,
		G4bool	isMaster = true )

This can be inkoved only by the master.

Definition at line 158 of file G4PenelopeIonisationXSHandler.cc.

{
  //Just to check
  if (!isMaster)
    G4Exception("G4PenelopeIonisationXSHandler::BuildXSTable()",
                "em0100",FatalException,"Worker thread in this method");
  
  //
  //This method fills the G4PenelopeCrossSection containers for electrons or positrons
  //and for the given material/cut couple. The calculation is done as sum over the 
  //individual shells.
  //Equivalent of subroutines EINaT and PINaT of Penelope
  //
  if (fVerboseLevel > 2)
    {
      G4cout << "G4PenelopeIonisationXSHandler: going to build cross section table " << G4endl;
      G4cout << "for " << part->GetParticleName() << " in " << mat->GetName() << G4endl;
      G4cout << "Cut= " << cut/keV << " keV" << G4endl;
    }
 
  std::pair<const G4Material*,G4double> theKey = std::make_pair(mat,cut);
  //Check if the table already exists
  if (part == G4Electron::Electron())
    {
      if (fXSTableElectron->count(theKey)) //table already built    
    return;
    }
  if (part == G4Positron::Positron())
    {
      if (fXSTablePositron->count(theKey)) //table already built    
    return;
    }
  
  //check if the material has been built
  if (!(fDeltaTable->count(mat)))
    BuildDeltaTable(mat);
 
 
  //Tables have been already created (checked by GetCrossSectionTableForCouple)
  G4PenelopeOscillatorTable* theTable = fOscManager->GetOscillatorTableIonisation(mat);
  size_t numberOfOscillators = theTable->size();
 
  if (fEnergyGrid->GetVectorLength() != fNBins) 
    {
      G4ExceptionDescription ed;
      ed << "Energy Grid looks not initialized" << G4endl;
      ed << fNBins << " " << fEnergyGrid->GetVectorLength() << G4endl;
      G4Exception("G4PenelopeIonisationXSHandler::BuildXSTable()",
          "em2030",FatalException,ed);
    }
 
  G4PenelopeCrossSection* XSEntry = new G4PenelopeCrossSection(fNBins,numberOfOscillators);
 
  //loop on the energy grid
  for (size_t bin=0;bin<fNBins;bin++)
    {
       G4double energy = fEnergyGrid->GetLowEdgeEnergy(bin);
       G4double XH0=0, XH1=0, XH2=0;
       G4double XS0=0, XS1=0, XS2=0;
   
       //oscillator loop
       for (size_t iosc=0;iosc<numberOfOscillators;iosc++)
     {
       G4DataVector* tempStorage = nullptr;
 
       G4PenelopeOscillator* theOsc = (*theTable)[iosc];
       G4double delta = GetDensityCorrection(mat,energy);
       if (part == G4Electron::Electron())       
         tempStorage = ComputeShellCrossSectionsElectron(theOsc,energy,cut,delta);
       else if (part == G4Positron::Positron())
         tempStorage = ComputeShellCrossSectionsPositron(theOsc,energy,cut,delta);
       //check results are all right
       if (!tempStorage)
         {
           G4ExceptionDescription ed;
           ed << "Problem in calculating the shell XS for shell # " 
          << iosc << G4endl;
           G4Exception("G4PenelopeIonisationXSHandler::BuildXSTable()",
               "em2031",FatalException,ed);              
           delete XSEntry;
           return;
         }
       if (tempStorage->size() != 6)
         {
           G4ExceptionDescription ed;
           ed << "Problem in calculating the shell XS " << G4endl;
           ed << "Result has dimension " << tempStorage->size() << " instead of 6" << G4endl;
           G4Exception("G4PenelopeIonisationXSHandler::BuildXSTable()",
               "em2031",FatalException,ed);   
         }
       G4double stre = theOsc->GetOscillatorStrength();
 
       XH0 += stre*(*tempStorage)[0];
       XH1 += stre*(*tempStorage)[1];
       XH2 += stre*(*tempStorage)[2];
       XS0 += stre*(*tempStorage)[3];
       XS1 += stre*(*tempStorage)[4];
       XS2 += stre*(*tempStorage)[5];
       XSEntry->AddShellCrossSectionPoint(bin,iosc,energy,stre*(*tempStorage)[0]);
       if (tempStorage)
         {
           delete tempStorage;
           tempStorage = nullptr;
         }
     }       
       XSEntry->AddCrossSectionPoint(bin,energy,XH0,XH1,XH2,XS0,XS1,XS2);
    }
  //Do (only once) the final normalization
  XSEntry->NormalizeShellCrossSections();
 
  //Insert in the appropriate table
  if (part == G4Electron::Electron())      
    fXSTableElectron->insert(std::make_pair(theKey,XSEntry));
  else if (part == G4Positron::Positron())
    fXSTablePositron->insert(std::make_pair(theKey,XSEntry));
  else
    delete XSEntry;
  
  return;
}

GetCrossSectionTableForCouple()

const G4PenelopeCrossSection * G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple	(	const G4ParticleDefinition *	part,
		const G4Material *	mat,
		const G4double	cut ) const

Returns the table of cross sections for the given particle, given material and given cut as a G4PenelopeCrossSection* pointer.

Definition at line 109 of file G4PenelopeIonisationXSHandler.cc.

{
  if (part != G4Electron::Electron() && part != G4Positron::Positron())
    {
      G4ExceptionDescription ed;
      ed << "Invalid particle: " << part->GetParticleName() << G4endl;
      G4Exception("G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple()",
          "em0001",FatalException,ed);
      return nullptr;
    }
 
  if (part == G4Electron::Electron())
    {
      if (!fXSTableElectron)
    {
      G4Exception("G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple()",
              "em0028",FatalException,  
              "The Cross Section Table for e- was not initialized correctly!");
      return nullptr;
    }
      std::pair<const G4Material*,G4double> theKey = std::make_pair(mat,cut);
      if (fXSTableElectron->count(theKey)) //table already built    
    return fXSTableElectron->find(theKey)->second;
      else   
        return nullptr;  
    }
  
  if (part == G4Positron::Positron())
    {
      if (!fXSTablePositron)
    {
      G4Exception("G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple()",
              "em0028",FatalException,  
              "The Cross Section Table for e+ was not initialized correctly!");
      return nullptr;
    }
      std::pair<const G4Material*,G4double> theKey = std::make_pair(mat,cut);
      if (fXSTablePositron->count(theKey)) //table already built    
    return fXSTablePositron->find(theKey)->second;
      else
        return nullptr;  
   }
  return nullptr;
}

GetDensityCorrection()

G4double G4PenelopeIonisationXSHandler::GetDensityCorrection	(	const G4Material *	mat,
		const G4double	energy ) const

Returns the density coeection for the material at the given energy.

Definition at line 284 of file G4PenelopeIonisationXSHandler.cc.

{
  G4double result = 0;
  if (!fDeltaTable)
    {
      G4Exception("G4PenelopeIonisationXSHandler::GetDensityCorrection()",
          "em2032",FatalException,
          "Delta Table not initialized. Was Initialise() run?");
      return 0;
    }
  if (energy <= 0*eV)
    {
      G4cout << "G4PenelopeIonisationXSHandler::GetDensityCorrection()" << G4endl;
      G4cout << "Invalid energy " << energy/eV << " eV " << G4endl;
      return 0;
    }
  G4double logene = G4Log(energy);
 
  if (fDeltaTable->count(mat))
    {
      const G4PhysicsFreeVector* vec = fDeltaTable->find(mat)->second;
      result = vec->Value(logene); //the table has delta vs. ln(E)      
    }
  else
    {
      G4ExceptionDescription ed;      
      ed << "Unable to build table for " << mat->GetName() << G4endl;
      G4Exception("G4PenelopeIonisationXSHandler::GetDensityCorrection()",
          "em2033",FatalException,ed);
    }
 
  return result;
}

Referenced by BuildXSTable().

operator=()

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

delete

SetVerboseLevel()

void G4PenelopeIonisationXSHandler::SetVerboseLevel ( G4int vl )

inline

Setter for the verbosity level.

Definition at line 77 of file G4PenelopeIonisationXSHandler.hh.

{fVerboseLevel = vl;};

---

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

• G4PenelopeIonisationXSHandler.hh
• G4PenelopeIonisationXSHandler.cc