G4PenelopeIonisationXSHandler Class Reference

#include <G4PenelopeIonisationXSHandler.hh>

Public Member Functions
	G4PenelopeIonisationXSHandler (size_t nBins=200)
virtual	~G4PenelopeIonisationXSHandler ()
	Destructor. Clean all tables.
G4double	GetDensityCorrection (const G4Material *, G4double energy)
	Returns the density coeection for the material at the given energy.
G4PenelopeCrossSection *	GetCrossSectionTableForCouple (const G4ParticleDefinition *, const G4Material *, G4double cut)
void	SetVerboseLevel (G4int vl)
	Setter for the verbosity level.

Detailed Description

Definition at line 60 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 47 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 70 of file G4PenelopeIonisationXSHandler.cc.

{
  std::map< std::pair<const G4Material*,G4double>, G4PenelopeCrossSection*>::iterator i;
  if (XSTableElectron)
    {
      for (i=XSTableElectron->begin(); i != XSTableElectron->end(); i++)
    {
      G4PenelopeCrossSection* tab = i->second;
      delete tab;
    }
      delete XSTableElectron;
      XSTableElectron = 0;
    }
 
  if (XSTablePositron)
    {
      for (i=XSTablePositron->begin(); i != XSTablePositron->end(); i++)
    {
      G4PenelopeCrossSection* tab = i->second;
      delete tab;
    }
      delete XSTablePositron;
      XSTablePositron = 0;
    }
 
  std::map<const G4Material*,G4PhysicsFreeVector*>::iterator k;
  if (theDeltaTable)
    {
      for (k=theDeltaTable->begin();k!=theDeltaTable->end();k++)    
    delete k->second;
      delete theDeltaTable;
      theDeltaTable = 0;
    }
    
  if (energyGrid)
    delete energyGrid;
 
  if (verboseLevel > 2)
    G4cout << "G4PenelopeIonisationXSHandler. Tables have been cleared" 
       << G4endl;
}

Member Function Documentation

GetCrossSectionTableForCouple()

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

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

Definition at line 115 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 NULL;
    }
 
  if (part == G4Electron::Electron())
    {
      if (!XSTableElectron)
    {
      G4Exception("G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple()",
              "em0028",FatalException,  
              "The Cross Section Table for e- was not initialized correctly!");
      return NULL;
    }
      std::pair<const G4Material*,G4double> theKey = std::make_pair(mat,cut);
      if (XSTableElectron->count(theKey)) //table already built 
    return XSTableElectron->find(theKey)->second;
      else
    {
      BuildXSTable(mat,cut,part);
      if (XSTableElectron->count(theKey)) //now it should be ok!
        return XSTableElectron->find(theKey)->second;
      else
        {
          G4ExceptionDescription ed;
          ed << "Unable to build e- table for " << mat->GetName() << G4endl;
          G4Exception("G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple()",
              "em0029",FatalException,ed);     
        }
    }
    }
 
  if (part == G4Positron::Positron())
    {
      if (!XSTablePositron)
    {
      G4Exception("G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple()",
              "em0028",FatalException,  
              "The Cross Section Table for e+ was not initialized correctly!");
      return NULL;
    }
      std::pair<const G4Material*,G4double> theKey = std::make_pair(mat,cut);
      if (XSTablePositron->count(theKey)) //table already built 
    return XSTablePositron->find(theKey)->second;
      else
    {
      BuildXSTable(mat,cut,part);
      if (XSTablePositron->count(theKey)) //now it should be ok!
        return XSTablePositron->find(theKey)->second;
      else
        {
          G4ExceptionDescription ed;
          ed << "Unable to build e+ table for " << mat->GetName() << G4endl;
          G4Exception("G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple()",
              "em0029",FatalException,ed);         
        }
    }
    }
  return NULL;
}

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

GetDensityCorrection()

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

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

Definition at line 286 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 = std::log(energy);
 
  //check if the material has been built
  if (!(theDeltaTable->count(mat)))
    BuildDeltaTable(mat);
 
  if (theDeltaTable->count(mat))
    {
      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;
}

SetVerboseLevel()

void G4PenelopeIonisationXSHandler::SetVerboseLevel ( G4int  vl )

inline

Setter for the verbosity level.

Definition at line 80 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