G4PixeCrossSectionHandler Class Reference

#include <G4PixeCrossSectionHandler.hh>

Public Member Functions
void	Clear ()
G4double	FindValue (G4int Z, G4double e) const
G4double	FindValue (G4int Z, G4double e, G4int shellIndex) const
	G4PixeCrossSectionHandler ()
	G4PixeCrossSectionHandler (G4IInterpolator *interpolation, const G4String &modelK="ecpssr", const G4String &modelL="ecpssr", const G4String &modelM="ecpssr", G4double minE=1 *CLHEP::keV, G4double maxE=0.1 *CLHEP::GeV, G4int nBins=200, G4double unitE=CLHEP::MeV, G4double unitData=CLHEP::barn, G4int minZ=6, G4int maxZ=92)
void	Initialise (G4IInterpolator *interpolation, const G4String &modelK="ecpssr", const G4String &modelL="ecpssr", const G4String &modelM="ecpssr", G4double minE=1 *CLHEP::keV, G4double maxE=0.1 *CLHEP::GeV, G4int nBins=200, G4double unitE=CLHEP::MeV, G4double unitData=CLHEP::barn, G4int minZ=6, G4int maxZ=92)
void	LoadShellData (const G4String &dataFile)
G4double	MicroscopicCrossSection (const G4ParticleDefinition *particleDef, G4double kineticEnergy, G4double Z, G4double deltaCut) const
void	PrintData () const
G4int	SelectRandomAtom (const G4Material *material, G4double e) const
G4int	SelectRandomShell (G4int Z, G4double e) const
G4double	ValueForMaterial (const G4Material *material, G4double e) const
virtual	~G4PixeCrossSectionHandler ()

Private Member Functions
void	ActiveElements ()
std::vector< G4IDataSet * > *	BuildCrossSectionsForMaterials (const G4DataVector &energyVector)
void	BuildForMaterials ()
G4IInterpolator *	CreateInterpolation ()
	G4PixeCrossSectionHandler (const G4PixeCrossSectionHandler &)
const G4IInterpolator *	GetInterpolation () const
G4int	NumberOfComponents (G4int Z) const
G4PixeCrossSectionHandler &	operator= (const G4PixeCrossSectionHandler &right)

Private Attributes
G4DataVector	activeZ
std::vector< G4String >	crossModel
std::vector< G4IDataSet * > *	crossSections
std::map< G4int, G4IDataSet *, std::less< G4int > >	dataMap
G4double	eMax
G4double	eMin
G4IInterpolator *	interpolation
G4int	nBins
G4double	unit1
G4double	unit2
G4int	zMax
G4int	zMin

Detailed Description

Definition at line 59 of file G4PixeCrossSectionHandler.hh.

Constructor & Destructor Documentation

G4PixeCrossSectionHandler() [1/3]

G4PixeCrossSectionHandler::G4PixeCrossSectionHandler

(

)

Definition at line 60 of file G4PixeCrossSectionHandler.cc.

{
  crossSections = 0;
  interpolation = 0;
  // Initialise with default values
  Initialise(0,"","","",1.*keV,0.1*GeV,200,MeV,barn,6,92);
  ActiveElements();
}

References ActiveElements(), barn, crossSections, GeV, Initialise(), interpolation, keV, and MeV.

G4PixeCrossSectionHandler() [2/3]

G4PixeCrossSectionHandler::G4PixeCrossSectionHandler	(	G4IInterpolator *	interpolation,
		const G4String &	modelK = "ecpssr",
		const G4String &	modelL = "ecpssr",
		const G4String &	modelM = "ecpssr",
		G4double	minE = 1*CLHEP::keV,
		G4double	maxE = 0.1*CLHEP::GeV,
		G4int	nBins = 200,
		G4double	unitE = CLHEP::MeV,
		G4double	unitData = CLHEP::barn,
		G4int	minZ = 6,
		G4int	maxZ = 92
	)

Definition at line 70 of file G4PixeCrossSectionHandler.cc.

  : interpolation(algorithm), eMin(minE), eMax(maxE), nBins(bins),
    unit1(unitE), unit2(unitData), zMin(minZ), zMax(maxZ)
{
  crossSections = 0;
 
  crossModel.push_back(modelK);
  crossModel.push_back(modelL);
  crossModel.push_back(modelM);
  
  //std::cout << "PixeCrossSectionHandler constructor - crossModel[0] = " 
  //    << crossModel[0]
  //    << std::endl;
 
  ActiveElements();
}

References ActiveElements(), crossModel, and crossSections.

~G4PixeCrossSectionHandler()

G4PixeCrossSectionHandler::~G4PixeCrossSectionHandler ( )

virtual

Definition at line 97 of file G4PixeCrossSectionHandler.cc.

{
  delete interpolation;
  interpolation = 0;
  std::map<G4int,G4IDataSet*,std::less<G4int> >::iterator pos;
 
  for (pos = dataMap.begin(); pos != dataMap.end(); ++pos)
    {
      // The following is a workaround for STL ObjectSpace implementation, 
      // which does not support the standard and does not accept 
      // the syntax pos->second
      // G4IDataSet* dataSet = pos->second;
      G4IDataSet* dataSet = (*pos).second;
      delete dataSet;
    }
 
  if (crossSections != 0)
    {
      size_t n = crossSections->size();
      for (size_t i=0; i<n; i++)
    {
      delete (*crossSections)[i];
    }
      delete crossSections;
      crossSections = 0;
    }
}

References crossSections, dataMap, interpolation, CLHEP::detail::n, and pos.

G4PixeCrossSectionHandler() [3/3]

G4PixeCrossSectionHandler::G4PixeCrossSectionHandler ( const G4PixeCrossSectionHandler &  )

private

Member Function Documentation

ActiveElements()

void G4PixeCrossSectionHandler::ActiveElements ( )

private

Definition at line 575 of file G4PixeCrossSectionHandler.cc.

{
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
  if (materialTable == 0)
    G4Exception("G4PixeCrossSectionHandler::ActiveElements",
                  "pii00000220",
                  FatalException,
                  "no MaterialTable found");
 
  G4int nMaterials = G4Material::GetNumberOfMaterials();
 
  for (G4int mat=0; mat<nMaterials; mat++)
    {
      const G4Material* material= (*materialTable)[mat];
      const G4ElementVector* elementVector = material->GetElementVector();
      const G4int nElements = material->GetNumberOfElements();
 
      for (G4int iEl=0; iEl<nElements; iEl++)
    {
      G4double Z = (*elementVector)[iEl]->GetZ();
      if (!(activeZ.contains(Z)) && Z >= zMin && Z <= zMax)
        {
          activeZ.push_back(Z);
        }
    }
    }
}

References activeZ, G4DataVector::contains(), FatalException, G4Exception(), G4Material::GetMaterialTable(), G4Material::GetNumberOfMaterials(), eplot::material, Z, zMax, and zMin.

Referenced by Clear(), and G4PixeCrossSectionHandler().

BuildCrossSectionsForMaterials()

std::vector< G4IDataSet * > * G4PixeCrossSectionHandler::BuildCrossSectionsForMaterials ( const G4DataVector &  energyVector )

private

Definition at line 631 of file G4PixeCrossSectionHandler.cc.

{
  G4DataVector* energies;
  G4DataVector* data;
 
  std::vector<G4IDataSet*>* matCrossSections = new std::vector<G4IDataSet*>;
 
  //const G4ProductionCutsTable* theCoupleTable=G4ProductionCutsTable::GetProductionCutsTable();
  //size_t numOfCouples = theCoupleTable->GetTableSize();
 
  size_t nOfBins = energyVector.size();
  const G4IInterpolator* interpolationAlgo = CreateInterpolation();
 
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
  if (materialTable == 0)
    G4Exception("G4PixeCrossSectionHandler::BuildCrossSectionsForMaterials",
        "pii00000230",
        FatalException,
        "no MaterialTable found");
 
  G4int nMaterials = G4Material::GetNumberOfMaterials();
 
  for (G4int mat=0; mat<nMaterials; mat++)
    {
      const G4Material* material = (*materialTable)[mat];
      G4int nElements = material->GetNumberOfElements();
      const G4ElementVector* elementVector = material->GetElementVector();
      const G4double* nAtomsPerVolume = material->GetAtomicNumDensityVector();
 
      G4IInterpolator* algo = interpolationAlgo->Clone();
 
      G4IDataSet* setForMat = new G4CompositeDataSet(algo,1.,1.);
 
      for (G4int i=0; i<nElements; i++) {
 
        G4int Z = (G4int) (*elementVector)[i]->GetZ();
        G4double density = nAtomsPerVolume[i];
 
        energies = new G4DataVector;
        data = new G4DataVector;
 
 
        for (size_t bin=0; bin<nOfBins; bin++)
      {
        G4double e = energyVector[bin];
        energies->push_back(e);
            G4double cross = 0.;
        if (Z >= zMin && Z <= zMax) cross = density*FindValue(Z,e);
        data->push_back(cross);
      }
 
        G4IInterpolator* algo1 = interpolationAlgo->Clone();
        G4IDataSet* elSet = new G4DataSet(i,energies,data,algo1,1.,1.);
        setForMat->AddComponent(elSet);
      }
 
      matCrossSections->push_back(setForMat);
    }
  return matCrossSections;
}

References G4IDataSet::AddComponent(), G4IInterpolator::Clone(), CreateInterpolation(), FatalException, FindValue(), G4Exception(), G4Material::GetMaterialTable(), G4Material::GetNumberOfMaterials(), eplot::material, Z, zMax, and zMin.

Referenced by BuildForMaterials().

BuildForMaterials()

void G4PixeCrossSectionHandler::BuildForMaterials ( )

private

Definition at line 405 of file G4PixeCrossSectionHandler.cc.

{
  // Builds a CompositeDataSet containing the mean free path for each material
  // in the material table
 
  G4DataVector energyVector;
  G4double dBin = std::log10(eMax/eMin) / nBins;
 
  for (G4int i=0; i<nBins+1; i++)
    {
      energyVector.push_back(std::pow(10., std::log10(eMin)+i*dBin));
    }
 
  if (crossSections != 0)
    {  // Reset the list of cross sections
      std::vector<G4IDataSet*>::iterator mat;
      if (! crossSections->empty())
    {
      for (mat = crossSections->begin(); mat!= crossSections->end(); ++mat)
        {
          G4IDataSet* set = *mat;
          delete set;
          set = 0;
        }
      crossSections->clear();
      delete crossSections;
      crossSections = 0;
    }
    }
 
  crossSections = BuildCrossSectionsForMaterials(energyVector);
 
  if (crossSections == 0)
    G4Exception("G4PixeCrossSectionHandler::BuildForMaterials",
        "pii00000210",
        FatalException,
        ", crossSections = 0");
 
  return;
}

References BuildCrossSectionsForMaterials(), crossSections, eMax, eMin, FatalException, G4Exception(), and nBins.

Referenced by LoadShellData().

Clear()

void G4PixeCrossSectionHandler::Clear

(

)

Definition at line 209 of file G4PixeCrossSectionHandler.cc.

{
  // Reset the map of data sets: remove the data sets from the map 
  std::map<G4int,G4IDataSet*,std::less<G4int> >::iterator pos;
 
  if(! dataMap.empty())
    {
      for (pos = dataMap.begin(); pos != dataMap.end(); ++pos)
    {
      // The following is a workaround for STL ObjectSpace implementation, 
      // which does not support the standard and does not accept
      // the syntax pos->first or pos->second
      // G4IDataSet* dataSet = pos->second;
      G4IDataSet* dataSet = (*pos).second;
      delete dataSet;
      dataSet = 0;
      G4int i = (*pos).first;
      dataMap[i] = 0;
    }
      dataMap.clear();
    }
 
  activeZ.clear();
  ActiveElements();
}

References ActiveElements(), activeZ, dataMap, and pos.

CreateInterpolation()

G4IInterpolator * G4PixeCrossSectionHandler::CreateInterpolation ( )

private

Definition at line 603 of file G4PixeCrossSectionHandler.cc.

{
  G4IInterpolator* algorithm = new G4LogLogInterpolator;
  return algorithm;
}

Referenced by BuildCrossSectionsForMaterials(), and Initialise().

FindValue() [1/2]

G4double G4PixeCrossSectionHandler::FindValue	(	G4int	Z,
		G4double	e
	)		const

Definition at line 235 of file G4PixeCrossSectionHandler.cc.

{
  G4double value = 0.;
  
  std::map<G4int,G4IDataSet*,std::less<G4int> >::const_iterator pos;
  pos = dataMap.find(Z);
  if (pos!= dataMap.end())
    {
      // The following is a workaround for STL ObjectSpace implementation, 
      // which does not support the standard and does not accept 
      // the syntax pos->first or pos->second
      // G4IDataSet* dataSet = pos->second;
      G4IDataSet* dataSet = (*pos).second;
      value = dataSet->FindValue(energy);
    }
  else
    {
      G4cout << "WARNING: G4PixeCrossSectionHandler::FindValue(Z,e) did not find Z = "
         << Z << G4endl;
    }
  return value;
}

References dataMap, G4INCL::KinematicsUtils::energy(), G4IDataSet::FindValue(), G4cout, G4endl, pos, and Z.

Referenced by BuildCrossSectionsForMaterials(), SelectRandomShell(), and ValueForMaterial().

FindValue() [2/2]

G4double G4PixeCrossSectionHandler::FindValue	(	G4int	Z,
		G4double	e,
		G4int	shellIndex
	)		const

Definition at line 258 of file G4PixeCrossSectionHandler.cc.

{
  G4double value = 0.;
 
  std::map<G4int,G4IDataSet*,std::less<G4int> >::const_iterator pos;
  pos = dataMap.find(Z);
  if (pos!= dataMap.end())
    {
      // The following is a workaround for STL ObjectSpace implementation, 
      // which does not support the standard and does not accept 
      // the syntax pos->first or pos->second
      // G4IDataSet* dataSet = pos->second;
      G4IDataSet* dataSet = (*pos).second;
      if (shellIndex >= 0) 
    {
      G4int nComponents = dataSet->NumberOfComponents();
      if(shellIndex < nComponents)    
        // The value is the cross section for shell component at given energy
        value = dataSet->GetComponent(shellIndex)->FindValue(energy);
      else 
        {
          G4cout << "WARNING: G4PixeCrossSectionHandler::FindValue(Z,e,shell) did not find"
             << " shellIndex= " << shellIndex
             << " for  Z= "
             << Z << G4endl;
        }
    } else {
    value = dataSet->FindValue(energy);
      }
    }
  else
    {
      G4cout << "WARNING: G4PixeCrossSectionHandler::FindValue did not find Z = "
         << Z << G4endl;
    }
  return value;
}

References dataMap, G4INCL::KinematicsUtils::energy(), G4IDataSet::FindValue(), G4cout, G4endl, G4IDataSet::GetComponent(), G4IDataSet::NumberOfComponents(), pos, and Z.

GetInterpolation()

const G4IInterpolator * G4PixeCrossSectionHandler::GetInterpolation ( ) const

inlineprivate

Definition at line 130 of file G4PixeCrossSectionHandler.hh.

{ return interpolation; }

References interpolation.

Initialise()

void G4PixeCrossSectionHandler::Initialise	(	G4IInterpolator *	interpolation,
		const G4String &	modelK = "ecpssr",
		const G4String &	modelL = "ecpssr",
		const G4String &	modelM = "ecpssr",
		G4double	minE = 1*CLHEP::keV,
		G4double	maxE = 0.1*CLHEP::GeV,
		G4int	nBins = 200,
		G4double	unitE = CLHEP::MeV,
		G4double	unitData = CLHEP::barn,
		G4int	minZ = 6,
		G4int	maxZ = 92
	)

Definition at line 125 of file G4PixeCrossSectionHandler.cc.

{
  if (algorithm != 0) 
    {
      delete interpolation;
      interpolation = algorithm;
    }
  else
    {
      interpolation = CreateInterpolation();
    }
 
  eMin = minE;
  eMax = maxE;
  nBins = numberOfBins;
  unit1 = unitE;
  unit2 = unitData;
  zMin = minZ;
  zMax = maxZ;
 
  crossModel.push_back(modelK);
  crossModel.push_back(modelL);
  crossModel.push_back(modelM);
 
}

References CreateInterpolation(), crossModel, eMax, eMin, interpolation, maxZ, nBins, unit1, unit2, zMax, and zMin.

Referenced by G4PixeCrossSectionHandler().

LoadShellData()

void G4PixeCrossSectionHandler::LoadShellData

(

const G4String &

dataFile

)

Definition at line 179 of file G4PixeCrossSectionHandler.cc.

{
  size_t nZ = activeZ.size();
  for (size_t i=0; i<nZ; i++)
    {
      G4int Z = (G4int) activeZ[i];     
      G4IInterpolator* algo = interpolation->Clone();
      G4IDataSet* dataSet = new G4PixeShellDataSet(Z, algo,crossModel[0],crossModel[1],crossModel[2]);
 
      // Degug printing
      //std::cout << "PixeCrossSectionHandler::Load - "
      //    << Z
      //    << ", modelK = "
      //    << crossModel[0]
      //    << " fileName = "
      //    << fileName
      //    << std::endl;
 
      dataSet->LoadData(fileName);
      dataMap[Z] = dataSet;
    }
 
  // Build cross sections for materials if not already built
  if (! crossSections)
    {
      BuildForMaterials();
    }
 
}

References activeZ, BuildForMaterials(), G4IInterpolator::Clone(), crossModel, crossSections, dataMap, interpolation, G4IDataSet::LoadData(), and Z.

Referenced by G4hImpactIonisation::PostStepDoIt().

MicroscopicCrossSection()

G4double G4PixeCrossSectionHandler::MicroscopicCrossSection	(	const G4ParticleDefinition *	particleDef,
		G4double	kineticEnergy,
		G4double	Z,
		G4double	deltaCut
	)		const

Definition at line 693 of file G4PixeCrossSectionHandler.cc.

{
  // Cross section formula is OK for spin=0, 1/2, 1 only !
  // Calculates the microscopic cross section in Geant4 internal units
  // Formula documented in Geant4 Phys. Ref. Manual
  // ( it is called for elements, AtomicNumber = z )
 
    G4double cross = 0.;
 
  // Particle mass and energy
    G4double particleMass = particleDef->GetPDGMass();
    G4double energy = kineticEnergy + particleMass;
 
  // Some kinematics
  G4double gamma = energy / particleMass;
  G4double beta2 = 1. - 1. / (gamma * gamma);
  G4double var = electron_mass_c2 / particleMass;
  G4double tMax = 2. * electron_mass_c2 * (gamma*gamma - 1.) / (1. + 2.*gamma*var + var*var);
 
  // Calculate the total cross section
 
  if ( tMax > deltaCut ) 
    {
      var = deltaCut / tMax;
      cross = (1. - var * (1. - beta2 * std::log(var))) / deltaCut;
      
      G4double spin = particleDef->GetPDGSpin() ;
      
      // +term for spin=1/2 particle
      if (spin == 0.5) 
    {
      cross +=  0.5 * (tMax - deltaCut) / (energy*energy);
    }
      // +term for spin=1 particle
      else if (spin > 0.9 )
    {
      cross += -std::log(var) / (3.*deltaCut) + (tMax-deltaCut) * 
        ((5.+1./var)*0.25 /(energy*energy) - beta2 / (tMax*deltaCut))/3.;
    }
      cross *= twopi_mc2_rcl2 * Z / beta2 ;
    }
 
  //std::cout << "Microscopic = " << cross/barn 
  //    << ", e = " << kineticEnergy/MeV <<std:: endl; 
 
  return cross;
}

References source.hepunit::electron_mass_c2, G4INCL::KinematicsUtils::energy(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGSpin(), source.hepunit::twopi_mc2_rcl2, and Z.

NumberOfComponents()

G4int G4PixeCrossSectionHandler::NumberOfComponents ( G4int  Z ) const

private

Definition at line 609 of file G4PixeCrossSectionHandler.cc.

{
  G4int n = 0;
 
  std::map<G4int,G4IDataSet*,std::less<G4int> >::const_iterator pos;
  pos = dataMap.find(Z);
  if (pos!= dataMap.end())
    {
      G4IDataSet* dataSet = (*pos).second;
      n = dataSet->NumberOfComponents();
    }
  else
    {
      G4cout << "WARNING: G4PixeCrossSectionHandler::NumberOfComponents did not "
             << "find Z = "
             << Z << G4endl;
    }
  return n;
}

References dataMap, G4cout, G4endl, CLHEP::detail::n, G4IDataSet::NumberOfComponents(), pos, and Z.

operator=()

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

private

PrintData()

void G4PixeCrossSectionHandler::PrintData

(

void

)

const

Definition at line 158 of file G4PixeCrossSectionHandler.cc.

{
  std::map<G4int,G4IDataSet*,std::less<G4int> >::const_iterator pos;
 
  for (pos = dataMap.begin(); pos != dataMap.end(); pos++)
    {
      // The following is a workaround for STL ObjectSpace implementation, 
      // which does not support the standard and does not accept 
      // the syntax pos->first or pos->second
      // G4int z = pos->first;
      // G4IDataSet* dataSet = pos->second;
      G4int z = (*pos).first;
      G4IDataSet* dataSet = (*pos).second;     
      G4cout << "---- Data set for Z = "
         << z
         << G4endl;
      dataSet->PrintData();
      G4cout << "--------------------------------------------------" << G4endl;
    }
}

References dataMap, G4cout, G4endl, pos, and G4IDataSet::PrintData().

SelectRandomAtom()

G4int G4PixeCrossSectionHandler::SelectRandomAtom	(	const G4Material *	material,
		G4double	e
	)		const

Definition at line 447 of file G4PixeCrossSectionHandler.cc.

{
  // Select randomly an element within the material, according to the weight
  // determined by the cross sections in the data set
 
  G4int nElements = material->GetNumberOfElements();
 
  // Special case: the material consists of one element
  if (nElements == 1)
    {
      G4int Z = (G4int) material->GetZ();
      return Z;
    }
 
  // Composite material
 
  const G4ElementVector* elementVector = material->GetElementVector();
  size_t materialIndex = material->GetIndex();
 
  G4IDataSet* materialSet = (*crossSections)[materialIndex];
  G4double materialCrossSection0 = 0.0;
  G4DataVector cross;
  cross.clear();
  for ( G4int i=0; i < nElements; i++ )
    {
      G4double cr = materialSet->GetComponent(i)->FindValue(e);
      materialCrossSection0 += cr;
      cross.push_back(materialCrossSection0);
    }
 
  G4double random = G4UniformRand() * materialCrossSection0;
 
  for (G4int k=0 ; k < nElements ; k++ )
    {
      if (random <= cross[k]) return (G4int) (*elementVector)[k]->GetZ();
    }
  // It should never get here
  return 0;
}

References G4IDataSet::FindValue(), G4UniformRand, G4IDataSet::GetComponent(), eplot::material, and Z.

Referenced by G4hImpactIonisation::PostStepDoIt().

SelectRandomShell()

G4int G4PixeCrossSectionHandler::SelectRandomShell	(	G4int	Z,
		G4double	e
	)		const

Definition at line 537 of file G4PixeCrossSectionHandler.cc.

{
  // Select randomly a shell, according to the weight determined by the cross sections
  // in the data set
 
  // Note for later improvement: it would be useful to add a cache mechanism for already
  // used shells to improve performance
 
  G4int shell = 0;
 
  G4double totCrossSection = FindValue(Z,e);
  G4double random = G4UniformRand() * totCrossSection;
  G4double partialSum = 0.;
 
  G4IDataSet* dataSet = 0;
  std::map<G4int,G4IDataSet*,std::less<G4int> >::const_iterator pos;
  pos = dataMap.find(Z);
  // The following is a workaround for STL ObjectSpace implementation,
  // which does not support the standard and does not accept
  // the syntax pos->first or pos->second
  // if (pos != dataMap.end()) dataSet = pos->second;
  if (pos != dataMap.end()) dataSet = (*pos).second;
 
  size_t nShells = dataSet->NumberOfComponents();
  for (size_t i=0; i<nShells; i++)
    {
      const G4IDataSet* shellDataSet = dataSet->GetComponent(i);
      if (shellDataSet != 0)
    {
      G4double value = shellDataSet->FindValue(e);
      partialSum += value;
      if (random <= partialSum) return i;
    }
    }
  // It should never get here
  return shell;
}

References dataMap, G4IDataSet::FindValue(), FindValue(), G4UniformRand, G4IDataSet::GetComponent(), G4IDataSet::NumberOfComponents(), pos, and Z.

Referenced by G4hImpactIonisation::PostStepDoIt().

ValueForMaterial()

G4double G4PixeCrossSectionHandler::ValueForMaterial	(	const G4Material *	material,
		G4double	e
	)		const

Definition at line 298 of file G4PixeCrossSectionHandler.cc.

{
  G4double value = 0.;
 
  const G4ElementVector* elementVector = material->GetElementVector();
  const G4double* nAtomsPerVolume = material->GetVecNbOfAtomsPerVolume();
  G4int nElements = material->GetNumberOfElements();
 
  for (G4int i=0 ; i<nElements ; i++)
    {
      G4int Z = (G4int) (*elementVector)[i]->GetZ();
      G4double elementValue = FindValue(Z,energy);
      G4double nAtomsVol = nAtomsPerVolume[i];
      value += nAtomsVol * elementValue;
    }
 
  return value;
}

References G4INCL::KinematicsUtils::energy(), FindValue(), eplot::material, and Z.

Field Documentation

activeZ

G4DataVector G4PixeCrossSectionHandler::activeZ

private

Definition at line 144 of file G4PixeCrossSectionHandler.hh.

Referenced by ActiveElements(), Clear(), and LoadShellData().

crossModel

std::vector<G4String> G4PixeCrossSectionHandler::crossModel

private

Definition at line 153 of file G4PixeCrossSectionHandler.hh.

Referenced by G4PixeCrossSectionHandler(), Initialise(), and LoadShellData().

crossSections

std::vector<G4IDataSet*>* G4PixeCrossSectionHandler::crossSections

private

Definition at line 151 of file G4PixeCrossSectionHandler.hh.

Referenced by BuildForMaterials(), G4PixeCrossSectionHandler(), LoadShellData(), and ~G4PixeCrossSectionHandler().

dataMap

std::map<G4int,G4IDataSet*,std::less<G4int> > G4PixeCrossSectionHandler::dataMap

private

Definition at line 147 of file G4PixeCrossSectionHandler.hh.

Referenced by Clear(), FindValue(), LoadShellData(), NumberOfComponents(), PrintData(), SelectRandomShell(), and ~G4PixeCrossSectionHandler().

eMax

G4double G4PixeCrossSectionHandler::eMax

private

Definition at line 135 of file G4PixeCrossSectionHandler.hh.

Referenced by BuildForMaterials(), and Initialise().

eMin

G4double G4PixeCrossSectionHandler::eMin

private

Definition at line 134 of file G4PixeCrossSectionHandler.hh.

Referenced by BuildForMaterials(), and Initialise().

interpolation

G4IInterpolator* G4PixeCrossSectionHandler::interpolation

private

Definition at line 132 of file G4PixeCrossSectionHandler.hh.

Referenced by G4PixeCrossSectionHandler(), GetInterpolation(), Initialise(), LoadShellData(), and ~G4PixeCrossSectionHandler().

nBins

G4int G4PixeCrossSectionHandler::nBins

private

Definition at line 136 of file G4PixeCrossSectionHandler.hh.

Referenced by BuildForMaterials(), and Initialise().

unit1

G4double G4PixeCrossSectionHandler::unit1

private

Definition at line 138 of file G4PixeCrossSectionHandler.hh.

Referenced by Initialise().

unit2

G4double G4PixeCrossSectionHandler::unit2

private

Definition at line 139 of file G4PixeCrossSectionHandler.hh.

Referenced by Initialise().

zMax

G4int G4PixeCrossSectionHandler::zMax

private

Definition at line 142 of file G4PixeCrossSectionHandler.hh.

Referenced by ActiveElements(), BuildCrossSectionsForMaterials(), and Initialise().

zMin

G4int G4PixeCrossSectionHandler::zMin

private

Definition at line 141 of file G4PixeCrossSectionHandler.hh.

Referenced by ActiveElements(), BuildCrossSectionsForMaterials(), and Initialise().

---

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

• source/processes/electromagnetic/pii/include/G4PixeCrossSectionHandler.hh
• source/processes/electromagnetic/pii/src/G4PixeCrossSectionHandler.cc