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.

Detailed Description

Definition at line 59 of file G4PenelopeIonisationXSHandler.hh.

Constructor & Destructor Documentation

G4PenelopeIonisationXSHandler()

G4PenelopeIonisationXSHandler::G4PenelopeIonisationXSHandler

(

size_t

nBins = 200

)

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.

  :XSTableElectron(0),XSTablePositron(0),
   theDeltaTable(0),energyGrid(0)
{
  nBins = nb;
  G4double LowEnergyLimit = 100.0*eV;
  G4double HighEnergyLimit = 100.0*GeV;
  oscManager = G4PenelopeOscillatorManager::GetOscillatorManager();
  XSTableElectron = new 
    std::map< std::pair<const G4Material*,G4double>, G4PenelopeCrossSection*>;
  XSTablePositron = new 
    std::map< std::pair<const G4Material*,G4double>, G4PenelopeCrossSection*>;
 
  theDeltaTable = new std::map<const G4Material*,G4PhysicsFreeVector*>;
  energyGrid = new G4PhysicsLogVector(LowEnergyLimit,
                      HighEnergyLimit, 
                      nBins-1); //one hidden bin is added
 
  verboseLevel = 0;
}

~G4PenelopeIonisationXSHandler()

G4PenelopeIonisationXSHandler::~G4PenelopeIonisationXSHandler ( )

virtual

Destructor. Clean all tables.

Definition at line 69 of file G4PenelopeIonisationXSHandler.cc.

{
  if (XSTableElectron)
    {
      for (auto& item : (*XSTableElectron))
    {     
      //G4PenelopeCrossSection* tab = i->second;
      delete item.second;
    }
      delete XSTableElectron;
      XSTableElectron = nullptr;
    }
 
  if (XSTablePositron)
    {
      for (auto& item : (*XSTablePositron))
    {
      //G4PenelopeCrossSection* tab = i->second;
      delete item.second;
    }
      delete XSTablePositron;
      XSTablePositron = nullptr;
    }
  if (theDeltaTable)
    {      
      for (auto& item : (*theDeltaTable))
    delete item.second;     
      delete theDeltaTable;
      theDeltaTable = nullptr;
    } 
  if (energyGrid)
    delete energyGrid;
  
  if (verboseLevel > 2)
    G4cout << "G4PenelopeIonisationXSHandler. Tables have been cleared" 
       << G4endl;
}

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 159 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 (verboseLevel > 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 (XSTableElectron->count(theKey)) //table already built 
    return;
    }
  if (part == G4Positron::Positron())
    {
      if (XSTablePositron->count(theKey)) //table already built 
    return;
    }
  
  //check if the material has been built
  if (!(theDeltaTable->count(mat)))
    BuildDeltaTable(mat);
 
 
  //Tables have been already created (checked by GetCrossSectionTableForCouple)
  G4PenelopeOscillatorTable* theTable = oscManager->GetOscillatorTableIonisation(mat);
  size_t numberOfOscillators = theTable->size();
 
  if (energyGrid->GetVectorLength() != nBins) 
    {
      G4ExceptionDescription ed;
      ed << "Energy Grid looks not initialized" << G4endl;
      ed << nBins << " " << energyGrid->GetVectorLength() << G4endl;
      G4Exception("G4PenelopeIonisationXSHandler::BuildXSTable()",
          "em2030",FatalException,ed);
    }
 
  G4PenelopeCrossSection* XSEntry = new G4PenelopeCrossSection(nBins,numberOfOscillators);
 
  //loop on the energy grid
  for (size_t bin=0;bin<nBins;bin++)
    {
       G4double energy = energyGrid->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 = 0;
 
       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 = 0;
         }
     }       
       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())      
    XSTableElectron->insert(std::make_pair(theKey,XSEntry));
  else if (part == G4Positron::Positron())
    XSTablePositron->insert(std::make_pair(theKey,XSEntry));
  else
    delete XSEntry;
  
  return;
}

Referenced by G4PenelopeIonisationModel::ComputeDEDXPerVolume(), G4PenelopeIonisationCrossSection::CrossSection(), G4PenelopeIonisationModel::CrossSectionPerVolume(), and G4PenelopeIonisationModel::Initialise().

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 110 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 (!XSTableElectron)
    {
      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 (XSTableElectron->count(theKey)) //table already built 
    return XSTableElectron->find(theKey)->second;
      else   
        return nullptr;  
    }
  
  if (part == G4Positron::Positron())
    {
      if (!XSTablePositron)
    {
      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 (XSTablePositron->count(theKey)) //table already built 
    return XSTablePositron->find(theKey)->second;
      else
        return nullptr;  
   }
  return nullptr;
}

Referenced by G4PenelopeIonisationModel::ComputeDEDXPerVolume(), G4PenelopeIonisationCrossSection::CrossSection(), and G4PenelopeIonisationModel::CrossSectionPerVolume().

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 285 of file G4PenelopeIonisationXSHandler.cc.

{
  G4double result = 0;
  if (!theDeltaTable)
    {
      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 (theDeltaTable->count(mat))
    {
      const G4PhysicsFreeVector* vec = theDeltaTable->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().

SetVerboseLevel()

void G4PenelopeIonisationXSHandler::SetVerboseLevel ( G4int  vl )

inline

Setter for the verbosity level.

Definition at line 78 of file G4PenelopeIonisationXSHandler.hh.

{verboseLevel = vl;};

Referenced by G4PenelopeIonisationModel::Initialise().

---

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

• G4PenelopeIonisationXSHandler.hh
• G4PenelopeIonisationXSHandler.cc