#include <G4eIonisationCrossSectionHandler.hh>

Inheritance diagram for G4eIonisationCrossSectionHandler:

Public Member Functions
G4VEMDataSet *	BuildMeanFreePathForMaterials (const G4DataVector *energyCuts=nullptr)

void	Clear ()

G4double	FindValue (G4int Z, G4double e) const

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

	G4eIonisationCrossSectionHandler (const G4eIonisationCrossSectionHandler &)=delete

	G4eIonisationCrossSectionHandler (const G4VEnergySpectrum spec, G4VDataSetAlgorithm alg, G4double emin, G4double emax, G4int nbin)

G4double	GetCrossSectionAboveThresholdForElement (G4double energy, G4double cutEnergy, G4int Z)

void	Initialise (G4VDataSetAlgorithm interpolation=nullptr, G4double minE=250 CLHEP::eV, G4double maxE=100 *CLHEP::GeV, G4int numberOfBins=200, G4double unitE=CLHEP::MeV, G4double unitData=CLHEP::barn, G4int minZ=1, G4int maxZ=99)

void	LoadData (const G4String &dataFile)

void	LoadNonLogData (const G4String &dataFile)

void	LoadShellData (const G4String &dataFile)

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

void	PrintData () const

G4int	SelectRandomAtom (const G4MaterialCutsCouple *couple, G4double e) const

const G4Element *	SelectRandomElement (const G4MaterialCutsCouple *material, G4double e) const

G4int	SelectRandomShell (G4int Z, G4double e) const

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

	~G4eIonisationCrossSectionHandler ()

Protected Member Functions
void	ActiveElements ()

std::vector< G4VEMDataSet * > *	BuildCrossSectionsForMaterials (const G4DataVector &energyVector, const G4DataVector *energyCuts) override

virtual G4VDataSetAlgorithm *	CreateInterpolation ()

const G4VDataSetAlgorithm *	GetInterpolation () const

G4int	NumberOfComponents (G4int Z) const

Private Attributes
G4DataVector	activeZ

std::vector< G4VEMDataSet * > *	crossSections

std::map< G4int, G4VEMDataSet *, std::less< G4int > >	dataMap

G4double	eMax

G4double	eMin

G4VDataSetAlgorithm *	interp

G4VDataSetAlgorithm *	interpolation

G4int	nBins

const G4VEnergySpectrum *	theParam

G4double	unit1

G4double	unit2

G4int	verbose

G4int	zMax

G4int	zMin

Detailed Description

Definition at line 59 of file G4eIonisationCrossSectionHandler.hh.

Constructor & Destructor Documentation

◆ G4eIonisationCrossSectionHandler() [1/2]

G4eIonisationCrossSectionHandler::G4eIonisationCrossSectionHandler	(	const G4VEnergySpectrum *	spec,
		G4VDataSetAlgorithm *	alg,
		G4double	emin,
		G4double	emax,
		G4int	nbin
	)

explicit

Definition at line 72 of file G4eIonisationCrossSectionHandler.cc.

 :  G4VCrossSectionHandler(),
    theParam(spec),verbose(0)
{
  G4VCrossSectionHandler::Initialise(alg, emin, emax, nbin);
  interp = new G4LinLogLogInterpolation();
}

References emax, G4VCrossSectionHandler::Initialise(), and interp.

◆ ~G4eIonisationCrossSectionHandler()

G4eIonisationCrossSectionHandler::~G4eIonisationCrossSectionHandler ( )

Definition at line 84 of file G4eIonisationCrossSectionHandler.cc.

{
  delete interp;
}

References interp.

◆ G4eIonisationCrossSectionHandler() [2/2]

G4eIonisationCrossSectionHandler::G4eIonisationCrossSectionHandler ( const G4eIonisationCrossSectionHandler & )

delete

Member Function Documentation

◆ ActiveElements()

void G4VCrossSectionHandler::ActiveElements ( )

protectedinherited

Definition at line 658 of file G4VCrossSectionHandler.cc.

{
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
  if (materialTable == nullptr)
      G4Exception("G4VCrossSectionHandler::ActiveElements",
            "em1001",FatalException,"no MaterialTable found");
 
  G4int nMaterials = G4Material::GetNumberOfMaterials();
 
  for (G4int mLocal2=0; mLocal2<nMaterials; mLocal2++)
    {
      const G4Material* material= (*materialTable)[mLocal2];
      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 G4VCrossSectionHandler::activeZ, G4DataVector::contains(), FatalException, G4Exception(), G4Material::GetMaterialTable(), G4Material::GetNumberOfMaterials(), eplot::material, Z, G4VCrossSectionHandler::zMax, and G4VCrossSectionHandler::zMin.

Referenced by G4VCrossSectionHandler::Clear(), and G4VCrossSectionHandler::G4VCrossSectionHandler().

◆ BuildCrossSectionsForMaterials()

std::vector< G4VEMDataSet * > * G4eIonisationCrossSectionHandler::BuildCrossSectionsForMaterials	(	const G4DataVector &	energyVector,
		const G4DataVector *	energyCuts
	)

overrideprotectedvirtual

Implements G4VCrossSectionHandler.

Definition at line 91 of file G4eIonisationCrossSectionHandler.cc.

{
  std::vector<G4VEMDataSet*>* set = new std::vector<G4VEMDataSet*>;
 
  G4DataVector* energies;
  G4DataVector* cs;
 
  G4DataVector* log_energies;
  G4DataVector* log_cs;
 
  G4int nOfBins = energyVector.size();
 
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  for (size_t mLocal=0; mLocal<numOfCouples; mLocal++) {
 
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(mLocal);
    const G4Material* material= couple->GetMaterial();
    const G4ElementVector* elementVector = material->GetElementVector();
    const G4double* nAtomsPerVolume = material->GetAtomicNumDensityVector();
    G4int nElements = material->GetNumberOfElements();
 
    if(verbose > 0) 
      {
    G4cout << "eIonisation CS for " << mLocal << "th material "
           << material->GetName()
           << "  eEl= " << nElements << G4endl;
      }
 
    G4double tcut  = (*energyCuts)[mLocal];
 
    G4VDataSetAlgorithm* algo = interp->Clone();
    G4VEMDataSet* setForMat = new G4CompositeEMDataSet(algo,1.,1.);
 
    for (G4int i=0; i<nElements; i++) {
 
      G4int Z = (G4int) (*elementVector)[i]->GetZ();
      G4int nShells = NumberOfComponents(Z);
 
      energies = new G4DataVector;
      cs       = new G4DataVector;
 
      log_energies = new G4DataVector;
      log_cs       = new G4DataVector;
 
      G4double density = nAtomsPerVolume[i];
 
      for (G4int bin=0; bin<nOfBins; bin++) {
 
        G4double e = energyVector[bin];
        energies->push_back(e);
        log_energies->push_back(std::log10(e));
        G4double value = 0.0;
        G4double log_value = -300;
 
        if(e > tcut) {
          for (G4int n=0; n<nShells; n++) {
            G4double cross = FindValue(Z, e, n);
            G4double p = theParam->Probability(Z, tcut, e, e, n);
            value += cross * p * density;
 
        if(verbose>0 && mLocal == 0 && e>=1. && e<=0.) 
        {
              G4cout << "G4eIonCrossSH: e(MeV)= " << e/MeV
                     << " n= " << n
                     << " cross= " << cross
                     << " p= " << p
                     << " value= " << value
                     << " tcut(MeV)= " << tcut/MeV
                     << " rho= " << density
                     << " Z= " << Z
                     << G4endl;
          }
      }
          if (value == 0.) value = 1e-300;
          log_value = std::log10(value);
    }
        cs->push_back(value);
        log_cs->push_back(log_value);
      }
      G4VDataSetAlgorithm* algoLocal = interp->Clone();
      G4VEMDataSet* elSet = new G4EMDataSet(i,energies,cs,log_energies,log_cs,algoLocal,1.,1.);
 
      setForMat->AddComponent(elSet);
    }
    set->push_back(setForMat);
  }
 
  return set;
}

References G4VEMDataSet::AddComponent(), G4VDataSetAlgorithm::Clone(), G4VCrossSectionHandler::FindValue(), G4cout, G4endl, G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), interp, eplot::material, MeV, CLHEP::detail::n, G4VCrossSectionHandler::NumberOfComponents(), G4VEnergySpectrum::Probability(), theParam, verbose, and Z.

◆ BuildMeanFreePathForMaterials()

G4VEMDataSet * G4VCrossSectionHandler::BuildMeanFreePathForMaterials ( const G4DataVector * energyCuts = nullptr )

inherited

Definition at line 441 of file G4VCrossSectionHandler.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));
    }
 
  // Factory method to build cross sections in derived classes,
  // related to the type of physics process
 
  if (crossSections != nullptr)
    {  // Reset the list of cross sections
      if (! crossSections->empty())
    {
      for (auto mat=crossSections->begin(); mat != crossSections->end(); ++mat)
        {
          G4VEMDataSet* set = *mat;
          delete set;
          set = nullptr;
        }
      crossSections->clear();
      delete crossSections;
      crossSections = nullptr;
    }
    }
 
  crossSections = BuildCrossSectionsForMaterials(energyVector,energyCuts);
 
  if (crossSections == nullptr)
    {
      G4Exception("G4VCrossSectionHandler::BuildMeanFreePathForMaterials",
            "em1010",FatalException,"crossSections = 0");
      return 0;
    }
 
  G4VDataSetAlgorithm* algo = CreateInterpolation();
  G4VEMDataSet* materialSet = new G4CompositeEMDataSet(algo);
 
  G4DataVector* energies;
  G4DataVector* data;
  G4DataVector* log_energies;
  G4DataVector* log_data;
  
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  for (size_t mLocal=0; mLocal<numOfCouples; mLocal++)
    {
      energies = new G4DataVector;
      data = new G4DataVector;
      log_energies = new G4DataVector;
      log_data = new G4DataVector;
      for (G4int bin=0; bin<nBins; bin++)
    {
      G4double energy = energyVector[bin];
      energies->push_back(energy);
          log_energies->push_back(std::log10(energy));
      G4VEMDataSet* matCrossSet = (*crossSections)[mLocal];
      G4double materialCrossSection = 0.0;
          G4int nElm = matCrossSet->NumberOfComponents();
          for(G4int j=0; j<nElm; j++) {
            materialCrossSection += matCrossSet->GetComponent(j)->FindValue(energy);
      }
 
      if (materialCrossSection > 0.)
        {
          data->push_back(1./materialCrossSection);
              log_data->push_back(std::log10(1./materialCrossSection));
        }
      else
        {
          data->push_back(DBL_MAX);
              log_data->push_back(std::log10(DBL_MAX));
        }
    }
      G4VDataSetAlgorithm* algoLocal = CreateInterpolation();
      G4VEMDataSet* dataSet = new G4EMDataSet(mLocal,energies,data,log_energies,log_data,algoLocal,1.,1.);
      materialSet->AddComponent(dataSet);
    }
  return materialSet;
}

References G4VEMDataSet::AddComponent(), G4VCrossSectionHandler::BuildCrossSectionsForMaterials(), G4VCrossSectionHandler::CreateInterpolation(), G4VCrossSectionHandler::crossSections, DBL_MAX, G4VCrossSectionHandler::eMax, G4VCrossSectionHandler::eMin, G4INCL::KinematicsUtils::energy(), FatalException, G4VEMDataSet::FindValue(), G4Exception(), G4VEMDataSet::GetComponent(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4VCrossSectionHandler::nBins, and G4VEMDataSet::NumberOfComponents().

Referenced by G4LivermoreIonisationModel::Initialise().

◆ Clear()

void G4VCrossSectionHandler::Clear ( )

inherited

Definition at line 345 of file G4VCrossSectionHandler.cc.

{
  // Reset the map of data sets: remove the data sets from the map 
  if(! dataMap.empty())
    {
      for (auto pos : dataMap)
    {
      G4VEMDataSet* dataSet = pos.second;
      delete dataSet;
      dataSet = nullptr;
      G4int i = pos.first;
      dataMap[i] = nullptr;
    }
    dataMap.clear();
    }
  activeZ.clear();
  ActiveElements();
}

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

Referenced by export_G4VCrossSectionHandler(), G4LivermoreIonisationCrossSection::Initialise(), and G4LivermoreIonisationModel::Initialise().

◆ CreateInterpolation()

G4VDataSetAlgorithm * G4VCrossSectionHandler::CreateInterpolation ( )

protectedvirtualinherited

Definition at line 686 of file G4VCrossSectionHandler.cc.

{
  G4VDataSetAlgorithm* algorithm = new G4LogLogInterpolation;
  return algorithm;
}

Referenced by G4CrossSectionHandler::BuildCrossSectionsForMaterials(), G4VCrossSectionHandler::BuildMeanFreePathForMaterials(), and G4VCrossSectionHandler::Initialise().

◆ FindValue() [1/2]

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

inherited

Definition at line 366 of file G4VCrossSectionHandler.cc.

{
  G4double value = 0.;
 
  auto pos = dataMap.find(Z);
  if (pos!= dataMap.end())
    {
      G4VEMDataSet* dataSet = (*pos).second;
      value = dataSet->FindValue(energy);
    }
  else
    {
      G4cout << "WARNING: G4VCrossSectionHandler::FindValue did not find Z = "
         << Z << G4endl;
    }
  return value;
}

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

Referenced by BuildCrossSectionsForMaterials(), G4CrossSectionHandler::BuildCrossSectionsForMaterials(), G4LivermoreIonisationModel::ComputeDEDXPerVolume(), G4LivermoreIonisationCrossSection::CrossSection(), GetCrossSectionAboveThresholdForElement(), G4VCrossSectionHandler::SelectRandomShell(), and G4VCrossSectionHandler::ValueForMaterial().

◆ FindValue() [2/2]

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

inherited

Definition at line 386 of file G4VCrossSectionHandler.cc.

{
  G4double value = 0.;
  auto pos = dataMap.find(Z);
  if (pos!= dataMap.end())
    {
      G4VEMDataSet* dataSet = (*pos).second;
      if (shellIndex >= 0) 
    {
      G4int nComponents = dataSet->NumberOfComponents();
      if(shellIndex < nComponents)    
        value = dataSet->GetComponent(shellIndex)->FindValue(energy);
      else 
        {
          G4cout << "WARNING: G4VCrossSectionHandler::FindValue did not find"
             << " shellIndex= " << shellIndex
             << " for  Z= "
             << Z << G4endl;
        }
    } else {
      value = dataSet->FindValue(energy);
    }
    }
  else
    {
      G4cout << "WARNING: G4VCrossSectionHandler::FindValue did not find Z = "
         << Z << G4endl;
    }
  return value;
}

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

◆ GetCrossSectionAboveThresholdForElement()

G4double G4eIonisationCrossSectionHandler::GetCrossSectionAboveThresholdForElement	(	G4double	energy,
		G4double	cutEnergy,
		G4int	Z
	)

Definition at line 188 of file G4eIonisationCrossSectionHandler.cc.

{
  G4int nShells = NumberOfComponents(Z);
  G4double value = 0.;
  if(energy > cutEnergy) 
    {
      for (G4int n=0; n<nShells; n++) {
    G4double cross = FindValue(Z, energy, n);
    G4double p = theParam->Probability(Z, cutEnergy, energy, energy, n);
    value += cross * p;
      }
    }
  return value;
}

References G4INCL::KinematicsUtils::energy(), G4VCrossSectionHandler::FindValue(), CLHEP::detail::n, G4VCrossSectionHandler::NumberOfComponents(), G4VEnergySpectrum::Probability(), theParam, and Z.

Referenced by G4LivermoreIonisationModel::ComputeCrossSectionPerAtom().

◆ GetInterpolation()

const G4VDataSetAlgorithm * G4VCrossSectionHandler::GetInterpolation ( ) const

inlineprotectedinherited

Definition at line 114 of file G4VCrossSectionHandler.hh.

114{ return interpolation; }

G4VCrossSectionHandler::interpolation

G4VDataSetAlgorithm * interpolation

Definition: G4VCrossSectionHandler.hh:117

References G4VCrossSectionHandler::interpolation.

◆ Initialise()

void G4VCrossSectionHandler::Initialise	(	G4VDataSetAlgorithm *	interpolation = `nullptr`,
		G4double	minE = `250*CLHEP::eV`,
		G4double	maxE = `100*CLHEP::GeV`,
		G4int	numberOfBins = `200`,
		G4double	unitE = `CLHEP::MeV`,
		G4double	unitData = `CLHEP::barn`,
		G4int	minZ = `1`,
		G4int	maxZ = `99`
	)

inherited

Definition at line 141 of file G4VCrossSectionHandler.cc.

{
  if (algorithm != nullptr) 
    {
      delete interpolation;
      interpolation = algorithm;
    }
  else
    {
      delete interpolation;
      interpolation = CreateInterpolation();
    }
 
  eMin = minE;
  eMax = maxE;
  nBins = numberOfBins;
  unit1 = unitE;
  unit2 = unitData;
  zMin = minZ;
  zMax = maxZ;
}

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

Referenced by export_G4VCrossSectionHandler(), G4eCrossSectionHandler::G4eCrossSectionHandler(), G4eIonisationCrossSectionHandler(), and G4VCrossSectionHandler::G4VCrossSectionHandler().

◆ LoadData()

void G4VCrossSectionHandler::LoadData ( const G4String & dataFile )

inherited

Definition at line 185 of file G4VCrossSectionHandler.cc.

{
  size_t nZ = activeZ.size();
  for (size_t i=0; i<nZ; i++)
    {
      G4int Z = G4int(activeZ[i]);
 
      // Build the complete string identifying the file with the data set      
      char* path = std::getenv("G4LEDATA");
      if (!path)
    { 
          G4Exception("G4VCrossSectionHandler::LoadData",
            "em0006",FatalException,"G4LEDATA environment variable not set");
      return;
    }
      
      std::ostringstream ost;
      ost << path << '/' << fileName << Z << ".dat";
      std::ifstream file(ost.str().c_str());
      std::filebuf* lsdp = file.rdbuf();
       
      if (! (lsdp->is_open()) )
    {
      G4String excep = "data file: " + ost.str() + " not found";
          G4Exception("G4VCrossSectionHandler::LoadData",
            "em0003",FatalException,excep);
    }
      G4double a = 0;
      G4int k = 0;
      G4int nColumns = 2;
 
      G4DataVector* orig_reg_energies = new G4DataVector;
      G4DataVector* orig_reg_data = new G4DataVector;
      G4DataVector* log_reg_energies = new G4DataVector;
      G4DataVector* log_reg_data = new G4DataVector;
 
      do
    {
      file >> a;
 
          if (a==0.) a=1e-300;
 
      // The file is organized into four columns:
      // 1st column contains the values of energy
      // 2nd column contains the corresponding data value
      // The file terminates with the pattern: -1   -1
      //                                       -2   -2
          //
      if (a != -1 && a != -2)
        {
          if (k%nColumns == 0)
                {
         orig_reg_energies->push_back(a*unit1);
                 log_reg_energies->push_back(std::log10(a)+std::log10(unit1));
                }
          else if (k%nColumns == 1)
                {
         orig_reg_data->push_back(a*unit2);
                 log_reg_data->push_back(std::log10(a)+std::log10(unit2));
                }
              k++;
        }
    } 
      while (a != -2); // End of File
      
      file.close();
      G4VDataSetAlgorithm* algo = interpolation->Clone();
      G4VEMDataSet* dataSet = new G4EMDataSet(Z,orig_reg_energies,orig_reg_data,
                          log_reg_energies,log_reg_data,algo);
      dataMap[Z] = dataSet;
    }
}

References G4VCrossSectionHandler::activeZ, G4VDataSetAlgorithm::Clone(), G4VCrossSectionHandler::dataMap, FatalException, geant4_check_module_cycles::file, G4Exception(), G4VCrossSectionHandler::interpolation, G4VCrossSectionHandler::unit1, G4VCrossSectionHandler::unit2, and Z.

Referenced by export_G4VCrossSectionHandler().

◆ LoadNonLogData()

void G4VCrossSectionHandler::LoadNonLogData ( const G4String & dataFile )

inherited

Definition at line 260 of file G4VCrossSectionHandler.cc.

{
  size_t nZ = activeZ.size();
  for (size_t i=0; i<nZ; i++)
    {
      G4int Z = G4int(activeZ[i]);
 
      // Build the complete string identifying the file with the data set      
      char* path = std::getenv("G4LEDATA");
      if (!path)
    { 
          G4Exception("G4VCrossSectionHandler::LoadNonLogData",
            "em0006",FatalException,"G4LEDATA environment variable not set");
      return;
    }
      
      std::ostringstream ost;
      ost << path << '/' << fileName << Z << ".dat";
      std::ifstream file(ost.str().c_str());
      std::filebuf* lsdp = file.rdbuf();
       
      if (! (lsdp->is_open()) )
    {
      G4String excep = "data file: " + ost.str() + " not found";
          G4Exception("G4VCrossSectionHandler::LoadNonLogData",
            "em0003",FatalException,excep);
    }
      G4double a = 0;
      G4int k = 0;
      G4int nColumns = 2;
 
      G4DataVector* orig_reg_energies = new G4DataVector;
      G4DataVector* orig_reg_data = new G4DataVector;
 
      do
    {
      file >> a;
 
      // The file is organized into four columns:
      // 1st column contains the values of energy
      // 2nd column contains the corresponding data value
      // The file terminates with the pattern: -1   -1
      //                                       -2   -2
          //
      if (a != -1 && a != -2)
        {
          if (k%nColumns == 0)
                {
         orig_reg_energies->push_back(a*unit1);
                }
          else if (k%nColumns == 1)
                {
         orig_reg_data->push_back(a*unit2);
                }
              k++;
        }
    } 
      while (a != -2); // End of File
      
      file.close();
      G4VDataSetAlgorithm* algo = interpolation->Clone();
 
      G4VEMDataSet* dataSet = new G4EMDataSet(Z,orig_reg_energies,orig_reg_data,algo);
      dataMap[Z] = dataSet;
    }
}

References G4VCrossSectionHandler::activeZ, G4VDataSetAlgorithm::Clone(), G4VCrossSectionHandler::dataMap, FatalException, geant4_check_module_cycles::file, G4Exception(), G4VCrossSectionHandler::interpolation, G4VCrossSectionHandler::unit1, G4VCrossSectionHandler::unit2, and Z.

◆ LoadShellData()

void G4VCrossSectionHandler::LoadShellData ( const G4String & dataFile )

inherited

Definition at line 329 of file G4VCrossSectionHandler.cc.

{
  size_t nZ = activeZ.size();
  for (size_t i=0; i<nZ; i++)
    {
      G4int Z = G4int(activeZ[i]);
      
      G4VDataSetAlgorithm* algo = interpolation->Clone();
      G4VEMDataSet* dataSet = new G4ShellEMDataSet(Z, algo);
      dataSet->LoadData(fileName);      
      dataMap[Z] = dataSet;
    }
}

References G4VCrossSectionHandler::activeZ, G4VDataSetAlgorithm::Clone(), G4VCrossSectionHandler::dataMap, G4VCrossSectionHandler::interpolation, G4VEMDataSet::LoadData(), and Z.

Referenced by export_G4VCrossSectionHandler(), G4LivermoreIonisationCrossSection::Initialise(), and G4LivermoreIonisationModel::Initialise().

◆ NumberOfComponents()

G4int G4VCrossSectionHandler::NumberOfComponents ( G4int Z ) const

protectedinherited

Definition at line 694 of file G4VCrossSectionHandler.cc.

{
  G4int n = 0;
 
  auto pos = dataMap.find(Z);
  if (pos!= dataMap.end())
    {
      G4VEMDataSet* dataSet = (*pos).second;
      n = dataSet->NumberOfComponents();
    }
  else
    {
      G4cout << "WARNING: G4VCrossSectionHandler::NumberOfComponents did not "
             << "find Z = "
             << Z << G4endl;
    }
  return n;
}

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

Referenced by BuildCrossSectionsForMaterials(), and GetCrossSectionAboveThresholdForElement().

◆ operator=()

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

delete

◆ PrintData()

void G4VCrossSectionHandler::PrintData ( void ) const

inherited

Definition at line 169 of file G4VCrossSectionHandler.cc.

{
  for (auto pos : dataMap) 
    {
      G4int z = pos.first;
      G4VEMDataSet* dataSet = pos.second;     
      G4cout << "---- Data set for Z = "
         << z
         << G4endl;
      dataSet->PrintData();
      G4cout << "--------------------------------------------------" << G4endl;
    }
}

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

Referenced by export_G4VCrossSectionHandler(), and G4LivermoreIonisationModel::Initialise().

◆ SelectRandomAtom()

G4int G4VCrossSectionHandler::SelectRandomAtom	(	const G4MaterialCutsCouple *	couple,
		G4double	e
	)		const

inherited

Definition at line 531 of file G4VCrossSectionHandler.cc.

{
  // Select randomly an element within the material, according to the weight
  // determined by the cross sections in the data set
  const G4Material* material = couple->GetMaterial();
  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 = couple->GetIndex();
 
  G4VEMDataSet* 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 G4VEMDataSet::FindValue(), G4UniformRand, G4VEMDataSet::GetComponent(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), eplot::material, and Z.

Referenced by G4LivermoreIonisationModel::SampleSecondaries().

◆ SelectRandomElement()

const G4Element * G4VCrossSectionHandler::SelectRandomElement	(	const G4MaterialCutsCouple *	material,
		G4double	e
	)		const

inherited

Definition at line 572 of file G4VCrossSectionHandler.cc.

{
  // Select randomly an element within the material, according to the weight determined
  // by the cross sections in the data set
  const G4Material* material = couple->GetMaterial();
  G4Element* nullElement = 0;
  G4int nElements = material->GetNumberOfElements();
  const G4ElementVector* elementVector = material->GetElementVector();
 
  // Special case: the material consists of one element
  if (nElements == 1)
    {
      return (*elementVector)[0];
    }
  else
    {
      // Composite material
 
      size_t materialIndex = couple->GetIndex();
 
      G4VEMDataSet* 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 (*elementVector)[k];
        }
      // It should never end up here
      G4cout << "G4VCrossSectionHandler::SelectRandomElement - no element found" << G4endl;
      return nullElement;
    }
}

References G4VEMDataSet::FindValue(), G4cout, G4endl, G4UniformRand, G4VEMDataSet::GetComponent(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), and eplot::material.

Referenced by export_G4VCrossSectionHandler().

◆ SelectRandomShell()

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

inherited

Definition at line 618 of file G4VCrossSectionHandler.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.;
 
  G4VEMDataSet* dataSet = nullptr;
  auto pos = dataMap.find(Z);
  if (pos != dataMap.end()) 
    dataSet = (*pos).second;
  else
    {
      G4Exception("G4VCrossSectionHandler::SelectRandomShell",
            "em1011",FatalException,"unable to load the dataSet");
      return 0;
    }
 
  size_t nShells = dataSet->NumberOfComponents();
  for (size_t i=0; i<nShells; i++)
    {
      const G4VEMDataSet* shellDataSet = dataSet->GetComponent(i);
      if (shellDataSet != nullptr)
    {
      G4double value = shellDataSet->FindValue(e);
      partialSum += value;
      if (random <= partialSum) return i;
    }
    }
  // It should never get here
  return shell;
}

References G4VCrossSectionHandler::dataMap, FatalException, G4VEMDataSet::FindValue(), G4VCrossSectionHandler::FindValue(), G4Exception(), G4UniformRand, G4VEMDataSet::GetComponent(), G4VEMDataSet::NumberOfComponents(), pos, and Z.

Referenced by export_G4VCrossSectionHandler(), and G4LivermoreIonisationModel::SampleSecondaries().

◆ ValueForMaterial()

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

inherited

Definition at line 420 of file G4VCrossSectionHandler.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;
}