G4RDVCrossSectionHandler Class Reference

#include <G4RDVCrossSectionHandler.hh>

Inheritance diagram for G4RDVCrossSectionHandler:

Collaboration diagram for G4RDVCrossSectionHandler:

Public Member Functions
	G4RDVCrossSectionHandler ()
	G4RDVCrossSectionHandler (G4RDVDataSetAlgorithm *interpolation, G4double minE=250 *CLHEP::eV, G4double maxE=100 *CLHEP::GeV, G4int nBins=200, G4double unitE=CLHEP::MeV, G4double unitData=CLHEP::barn, G4int minZ=1, G4int maxZ=99)
virtual	~G4RDVCrossSectionHandler ()
void	Initialise (G4RDVDataSetAlgorithm *interpolation=0, 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)
G4int	SelectRandomAtom (const G4MaterialCutsCouple *couple, G4double e) const
const G4Element *	SelectRandomElement (const G4MaterialCutsCouple *material, G4double e) const
G4int	SelectRandomShell (G4int Z, G4double e) const
G4RDVEMDataSet *	BuildMeanFreePathForMaterials (const G4DataVector *energyCuts=0)
G4double	FindValue (G4int Z, G4double e) const
G4double	FindValue (G4int Z, G4double e, G4int shellIndex) const
G4double	ValueForMaterial (const G4Material *material, G4double e) const
void	LoadData (const G4String &dataFile)
void	LoadShellData (const G4String &dataFile)
void	PrintData () const
void	Clear ()

Protected Member Functions
G4int	NumberOfComponents (G4int Z) const
void	ActiveElements ()
virtual std::vector< G4RDVEMDataSet * > *	BuildCrossSectionsForMaterials (const G4DataVector &energyVector, const G4DataVector *energyCuts=0)=0
virtual G4RDVDataSetAlgorithm *	CreateInterpolation ()
const G4RDVDataSetAlgorithm *	GetInterpolation () const

Private Member Functions
	G4RDVCrossSectionHandler (const G4RDVCrossSectionHandler &)
G4RDVCrossSectionHandler &	operator= (const G4RDVCrossSectionHandler &right)

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

Detailed Description

Definition at line 64 of file G4RDVCrossSectionHandler.hh.

Constructor & Destructor Documentation

G4RDVCrossSectionHandler() [1/3]

G4RDVCrossSectionHandler::G4RDVCrossSectionHandler

(

)

Definition at line 59 of file G4RDVCrossSectionHandler.cc.

{
  crossSections = 0;
  interpolation = 0;
  Initialise();
  ActiveElements();
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4RDVCrossSectionHandler() [2/3]

G4RDVCrossSectionHandler::G4RDVCrossSectionHandler	(	G4RDVDataSetAlgorithm *	interpolation,
		G4double	minE = 250*CLHEP::eV,
		G4double	maxE = 100*CLHEP::GeV,
		G4int	nBins = 200,
		G4double	unitE = CLHEP::MeV,
		G4double	unitData = CLHEP::barn,
		G4int	minZ = 1,
		G4int	maxZ = 99
	)

Definition at line 68 of file G4RDVCrossSectionHandler.cc.

  : interpolation(algorithm), eMin(minE), eMax(maxE), nBins(bins),
    unit1(unitE), unit2(unitData), zMin(minZ), zMax(maxZ)
{
  crossSections = 0;
  ActiveElements();
}

Here is the call graph for this function:

~G4RDVCrossSectionHandler()

G4RDVCrossSectionHandler::~G4RDVCrossSectionHandler ( )

virtual

Definition at line 83 of file G4RDVCrossSectionHandler.cc.

{
  delete interpolation;
  interpolation = 0;
  std::map<G4int,G4RDVEMDataSet*,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
      // G4RDVEMDataSet* dataSet = pos->second;
      G4RDVEMDataSet* 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;
    }
}

G4RDVCrossSectionHandler() [3/3]

G4RDVCrossSectionHandler::G4RDVCrossSectionHandler ( const G4RDVCrossSectionHandler &  )

private

Member Function Documentation

ActiveElements()

void G4RDVCrossSectionHandler::ActiveElements ( )

protected

Definition at line 624 of file G4RDVCrossSectionHandler.cc.

{
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
  if (materialTable == 0)
    G4Exception("G4RDVCrossSectionHandler::ActiveElements",
                "InvalidSetup", FatalException, "No MaterialTable found!");

  G4int nMaterials = G4Material::GetNumberOfMaterials();

  for (G4int m=0; m<nMaterials; m++)
    {
      const G4Material* material= (*materialTable)[m];
      const G4ElementVector* elementVector = material->GetElementVector();
      const G4int nElements = material->GetNumberOfElements();

      for (G4int iEl=0; iEl<nElements; iEl++)
    {
      G4Element* element = (*elementVector)[iEl];
      G4double Z = element->GetZ();
      if (!(activeZ.contains(Z)) && Z >= zMin && Z <= zMax)
        {
          activeZ.push_back(Z);
        }
    }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildCrossSectionsForMaterials()

virtual std::vector<G4RDVEMDataSet*>* G4RDVCrossSectionHandler::BuildCrossSectionsForMaterials ( const G4DataVector &  energyVector, const G4DataVector *  energyCuts = 0  )

protectedpure virtual

Implemented in G4RDeIonisationCrossSectionHandler, G4RDBremsstrahlungCrossSectionHandler, and G4RDCrossSectionHandler.

Here is the caller graph for this function:

BuildMeanFreePathForMaterials()

G4RDVEMDataSet * G4RDVCrossSectionHandler::BuildMeanFreePathForMaterials

(

const G4DataVector *

energyCuts = 0

)

Definition at line 416 of file G4RDVCrossSectionHandler.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 != 0)
    {  // Reset the list of cross sections
      std::vector<G4RDVEMDataSet*>::iterator mat;
      if (! crossSections->empty())
    {
      for (mat = crossSections->begin(); mat!= crossSections->end(); ++mat)
        {
          G4RDVEMDataSet* set = *mat;
          delete set;
          set = 0;
        }
      crossSections->clear();
      delete crossSections;
      crossSections = 0;
    }
    }

  crossSections = BuildCrossSectionsForMaterials(energyVector,energyCuts);

  if (crossSections == 0)
    G4Exception("G4RDVCrossSectionHandler::BuildMeanFreePathForMaterials()",
                "InvalidCondition", FatalException, "CrossSections = 0!");

  G4RDVDataSetAlgorithm* algo = CreateInterpolation();
  G4RDVEMDataSet* materialSet = new G4RDCompositeEMDataSet(algo);

  G4DataVector* energies;
  G4DataVector* data;
  
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();


  for (size_t m=0; m<numOfCouples; m++)
    {
      energies = new G4DataVector;
      data = new G4DataVector;
      for (G4int bin=0; bin<nBins; bin++)
    {
      G4double energy = energyVector[bin];
      energies->push_back(energy);
      G4RDVEMDataSet* matCrossSet = (*crossSections)[m];
      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);
        }
      else
        {
          data->push_back(DBL_MAX);
        }
    }
      G4RDVDataSetAlgorithm* algo = CreateInterpolation();
      G4RDVEMDataSet* dataSet = new G4RDEMDataSet(m,energies,data,algo,1.,1.);
      materialSet->AddComponent(dataSet);
    }

  return materialSet;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Clear()

void G4RDVCrossSectionHandler::Clear

(

)

Definition at line 306 of file G4RDVCrossSectionHandler.cc.

{
  // Reset the map of data sets: remove the data sets from the map 
  std::map<G4int,G4RDVEMDataSet*,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
      // G4RDVEMDataSet* dataSet = pos->second;
      G4RDVEMDataSet* dataSet = (*pos).second;
      delete dataSet;
      dataSet = 0;
      G4int i = (*pos).first;
      dataMap[i] = 0;
    }
    dataMap.clear();
    }

  activeZ.clear();
  ActiveElements();
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateInterpolation()

G4RDVDataSetAlgorithm * G4RDVCrossSectionHandler::CreateInterpolation ( )

protectedvirtual

Definition at line 651 of file G4RDVCrossSectionHandler.cc.

{
  G4RDVDataSetAlgorithm* algorithm = new G4RDLogLogInterpolation;
  return algorithm;
}

Here is the caller graph for this function:

FindValue() [1/2]

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

Definition at line 332 of file G4RDVCrossSectionHandler.cc.

{
  G4double value = 0.;
  
  std::map<G4int,G4RDVEMDataSet*,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
      // G4RDVEMDataSet* dataSet = pos->second;
      G4RDVEMDataSet* dataSet = (*pos).second;
      value = dataSet->FindValue(energy);
    }
  else
    {
      G4cout << "WARNING: G4RDVCrossSectionHandler::FindValue did not find Z = "
         << Z << G4endl;
    }
  return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindValue() [2/2]

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

Definition at line 355 of file G4RDVCrossSectionHandler.cc.

{
  G4double value = 0.;

  std::map<G4int,G4RDVEMDataSet*,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
      // G4RDVEMDataSet* dataSet = pos->second;
      G4RDVEMDataSet* dataSet = (*pos).second;
      if (shellIndex >= 0) 
    {
      G4int nComponents = dataSet->NumberOfComponents();
      if(shellIndex < nComponents)    
        // - MGP - Why doesn't it use G4RDVEMDataSet::FindValue directly?
        value = dataSet->GetComponent(shellIndex)->FindValue(energy);
      else 
        {
          G4cout << "WARNING: G4RDVCrossSectionHandler::FindValue did not find"
             << " shellIndex= " << shellIndex
             << " for  Z= "
             << Z << G4endl;
        }
    } else {
      value = dataSet->FindValue(energy);
    }
    }
  else
    {
      G4cout << "WARNING: G4RDVCrossSectionHandler::FindValue did not find Z = "
         << Z << G4endl;
    }
  return value;
}

Here is the call graph for this function:

GetInterpolation()

const G4RDVDataSetAlgorithm* G4RDVCrossSectionHandler::GetInterpolation ( ) const

inlineprotected

Definition at line 120 of file G4RDVCrossSectionHandler.hh.

{ return interpolation; }

Here is the call graph for this function:

Initialise()

void G4RDVCrossSectionHandler::Initialise	(	G4RDVDataSetAlgorithm *	interpolation = 0,
		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
	)

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

Here is the call graph for this function:

Here is the caller graph for this function:

LoadData()

void G4RDVCrossSectionHandler::LoadData

(

const G4String &

dataFile

)

Definition at line 157 of file G4RDVCrossSectionHandler.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 = getenv("G4LEDATA");
      if (!path)
    { 
      G4String excep = "G4LEDATA environment variable not set!";
      G4Exception("G4RDVCrossSectionHandler::LoadData()",
                      "InvalidSetup", FatalException, excep);
    }
      
      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("G4RDVCrossSectionHandler::LoadData()",
                      "DataNotFound", FatalException, excep);
    }
      G4double a = 0;
      G4int k = 1;
      G4DataVector* energies = new G4DataVector;
      G4DataVector* data = new G4DataVector;
      do
    {
      file >> a;
      G4int nColumns = 2;
      // The file is organized into two columns:
      // 1st column is the energy
      // 2nd column is the corresponding value
      // The file terminates with the pattern: -1   -1
      //                                       -2   -2
      if (a == -1 || a == -2)
        {
        }
      else
        {
          if (k%nColumns != 0)
        {   
          G4double e = a * unit1;
          energies->push_back(e);
          k++;
        }
          else if (k%nColumns == 0)
        {
          G4double value = a * unit2;
          data->push_back(value);
          k = 1;
        }
        }
    } while (a != -2); // end of file
      
      file.close();
      G4RDVDataSetAlgorithm* algo = interpolation->Clone();
      G4RDVEMDataSet* dataSet = new G4RDEMDataSet(Z,energies,data,algo);
      dataMap[Z] = dataSet;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

LoadShellData()

void G4RDVCrossSectionHandler::LoadShellData

(

const G4String &

dataFile

)

Definition at line 225 of file G4RDVCrossSectionHandler.cc.

{
  size_t nZ = activeZ.size();
  for (size_t i=0; i<nZ; i++)
    {
      G4int Z = (G4int) activeZ[i];
      
      // Riccardo Capra <capra@ge.infn.it>: PLEASE CHECK THE FOLLOWING PIECE OF CODE
      // "energies" AND "data" G4DataVector ARE ALLOCATED, FILLED IN AND NEVER USED OR
      // DELETED. WHATSMORE LOADING FILE OPERATIONS WERE DONE BY G4RDShellEMDataSet
      // EVEN BEFORE THE CHANGES I DID ON THIS FILE. SO THE FOLLOWING CODE IN MY
      // OPINION SHOULD BE USELESS AND SHOULD PRODUCE A MEMORY LEAK. 

      // Build the complete string identifying the file with the data set
      
      char* path = getenv("G4LEDATA");
      if (!path)
    { 
      G4String excep = "G4LEDATA environment variable not set!";
      G4Exception("G4RDVCrossSectionHandler::LoadShellData()",
                      "InvalidSetup", FatalException, excep);
    }
      
      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("G4RDVCrossSectionHandler::LoadShellData()",
                      "DataNotFound", FatalException, excep);
    }
      G4double a = 0;
      G4int k = 1;
      G4DataVector* energies = new G4DataVector;
      G4DataVector* data = new G4DataVector;
      do
    {
      file >> a;
      G4int nColumns = 2;
      // The file is organized into two columns:
      // 1st column is the energy
      // 2nd column is the corresponding value
      // The file terminates with the pattern: -1   -1
      //                                       -2   -2
      if (a == -1 || a == -2)
        {
        }
      else
        {
          if (k%nColumns != 0)
        {   
          G4double e = a * unit1;
          energies->push_back(e);
          k++;
        }
          else if (k%nColumns == 0)
        {
          G4double value = a * unit2;
          data->push_back(value);
          k = 1;
        }
        }
    } while (a != -2); // end of file
      
      file.close();
      
      // Riccardo Capra <capra@ge.infn.it>: END OF CODE THAT IN MY OPINION SHOULD BE
      // REMOVED.
      
      G4RDVDataSetAlgorithm* algo = interpolation->Clone();
      G4RDVEMDataSet* dataSet = new G4RDShellEMDataSet(Z, algo);
      dataSet->LoadData(fileName);
      dataMap[Z] = dataSet;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

NumberOfComponents()

G4int G4RDVCrossSectionHandler::NumberOfComponents ( G4int  Z ) const

protected

Definition at line 657 of file G4RDVCrossSectionHandler.cc.

{
  G4int n = 0;

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

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

Here is the caller graph for this function:

PrintData()

void G4RDVCrossSectionHandler::PrintData

(

void

)

const

Definition at line 136 of file G4RDVCrossSectionHandler.cc.

{
  std::map<G4int,G4RDVEMDataSet*,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;
      // G4RDVEMDataSet* dataSet = pos->second;
      G4int z = (*pos).first;
      G4RDVEMDataSet* dataSet = (*pos).second;     
      G4cout << "---- Data set for Z = "
         << z
         << G4endl;
      dataSet->PrintData();
      G4cout << "--------------------------------------------------" << G4endl;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SelectRandomAtom()

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

Definition at line 498 of file G4RDVCrossSectionHandler.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();

  G4RDVEMDataSet* 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SelectRandomElement()

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

Definition at line 540 of file G4RDVCrossSectionHandler.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)
    {
      G4Element* element = (*elementVector)[0];
      return element;
    }
  else
    {
      // Composite material

      size_t materialIndex = couple->GetIndex();

      G4RDVEMDataSet* 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 << "G4RDVCrossSectionHandler::SelectRandomElement - no element found" << G4endl;
      return nullElement;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SelectRandomShell()

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

Definition at line 586 of file G4RDVCrossSectionHandler.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.;

  G4RDVEMDataSet* dataSet = 0;
  std::map<G4int,G4RDVEMDataSet*,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 G4RDVEMDataSet* 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ValueForMaterial()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

activeZ

G4DataVector G4RDVCrossSectionHandler::activeZ

private

Definition at line 141 of file G4RDVCrossSectionHandler.hh.

crossSections

std::vector<G4RDVEMDataSet*>* G4RDVCrossSectionHandler::crossSections

private

Definition at line 145 of file G4RDVCrossSectionHandler.hh.

dataMap

std::map<G4int,G4RDVEMDataSet*,std::less<G4int> > G4RDVCrossSectionHandler::dataMap

private

Definition at line 143 of file G4RDVCrossSectionHandler.hh.

eMax

G4double G4RDVCrossSectionHandler::eMax

private

Definition at line 132 of file G4RDVCrossSectionHandler.hh.

eMin

G4double G4RDVCrossSectionHandler::eMin

private

Definition at line 131 of file G4RDVCrossSectionHandler.hh.

interpolation

G4RDVDataSetAlgorithm* G4RDVCrossSectionHandler::interpolation

private

Definition at line 129 of file G4RDVCrossSectionHandler.hh.

nBins

G4int G4RDVCrossSectionHandler::nBins

private

Definition at line 133 of file G4RDVCrossSectionHandler.hh.

unit1

G4double G4RDVCrossSectionHandler::unit1

private

Definition at line 135 of file G4RDVCrossSectionHandler.hh.

unit2

G4double G4RDVCrossSectionHandler::unit2

private

Definition at line 136 of file G4RDVCrossSectionHandler.hh.

zMax

G4int G4RDVCrossSectionHandler::zMax

private

Definition at line 139 of file G4RDVCrossSectionHandler.hh.

zMin

G4int G4RDVCrossSectionHandler::zMin

private

Definition at line 138 of file G4RDVCrossSectionHandler.hh.

---

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

• G4RDVCrossSectionHandler.hh
• G4RDVCrossSectionHandler.cc