G4RDFluoData Class Reference

#include <G4RDFluoData.hh>

Public Member Functions
	G4RDFluoData ()
	~G4RDFluoData ()
size_t	NumberOfVacancies () const
G4int	VacancyId (G4int vacancyIndex) const
size_t	NumberOfTransitions (G4int vacancyIndex) const
G4int	StartShellId (G4int initIndex, G4int vacancyIndex) const
G4double	StartShellEnergy (G4int initIndex, G4int vacancyIndex) const
G4double	StartShellProb (G4int initIndex, G4int vacancyIndex) const
void	LoadData (G4int Z)
void	PrintData ()

Detailed Description

Definition at line 52 of file G4RDFluoData.hh.

Constructor & Destructor Documentation

G4RDFluoData::G4RDFluoData

(

)

Definition at line 44 of file G4RDFluoData.cc.

{
  numberOfVacancies=0; 
}

G4RDFluoData::~G4RDFluoData

(

)

Definition at line 49 of file G4RDFluoData.cc.

{ 
 std::map<G4int,G4DataVector*,std::less<G4int> >::iterator pos;

  for (pos = idMap.begin(); pos != idMap.end(); ++pos)
    {
      G4DataVector* dataSet = (*pos).second;
      delete dataSet;
    }
  for (pos = energyMap.begin(); pos != energyMap.end(); ++pos)
    {
      G4DataVector* dataSet = (*pos).second;
      delete dataSet;
    }
 for (pos = probabilityMap.begin(); pos != probabilityMap.end(); ++pos)
    {
      G4DataVector* dataSet = (*pos).second;
      delete dataSet;
    }
}

Member Function Documentation

void G4RDFluoData::LoadData

(

G4int

Z

)

Definition at line 186 of file G4RDFluoData.cc.

{ 
  // Build the complete string identifying the file with the data set
  
  std::ostringstream ost;
  if(Z != 0){
    ost << "fl-tr-pr-"<< Z << ".dat";
  }
  else{
    ost << "fl-tr-pr-"<<".dat"; 
  }
  G4String name(ost.str());
  
  char* path = getenv("G4LEDATA");
  if (!path)
    { 
      G4String excep("G4LEDATA environment variable not set!");
      G4Exception("G4RDEMDataSet::LoadData()", "InvalidSetup",
                  FatalException, excep);
    }
  
  G4String pathString(path);
  G4String fluor("/fluor/");
  G4String dirFile = pathString + fluor + name;
  std::ifstream file(dirFile);
  std::filebuf* lsdp = file.rdbuf();
  
  if (! (lsdp->is_open()) )
    {
      G4String excep = "Data file: " + dirFile + " not found";
      G4Exception("G4RDEMDataSet::LoadData()", "DataNotFound",
                  FatalException, excep);
    }
  
  G4double a = 0;
  G4int k = 1;
  G4int s = 0;
  
  G4int vacIndex = 0;
  G4DataVector* initIds = new G4DataVector;
  G4DataVector* transEnergies = new G4DataVector;
  G4DataVector* transProbabilities = new G4DataVector;
  
  do {
    file >> a;
    G4int nColumns = 3;
    if (a == -1)
      {
    if (s == 0)
      {
        // End of a shell data set
        idMap[vacIndex] = initIds;
            energyMap[vacIndex] = transEnergies;
        probabilityMap[vacIndex] = transProbabilities;
        //      G4double size=transProbabilities->size();
            G4int n = initIds->size();
        
        nInitShells.push_back(n);
        numberOfVacancies++;
        // Start of new shell data set
        initIds = new G4DataVector;
            transEnergies = new G4DataVector;
        transProbabilities = new G4DataVector;
            vacIndex++; 
      }      
    s++;
    if (s == nColumns)
      {
        s = 0;
      }
      }
    else if (a == -2)
      {
    // End of file; delete the empty vectors created 
    //when encountering the last -1 -1 row
    delete initIds;
    delete transEnergies;
    delete transProbabilities;
      } 
    else
      {
    
    if(k%nColumns == 2)
      {  
        // 2nd column is transition  probabilities

       if (a != -1) transProbabilities->push_back(a);
        
        k++;
      }
    else if (k%nColumns == 1)
      {
        // 1st column is shell id
        // if this is the first data of the shell, all the colums are equal 
        // to the shell Id; so we skip the next colums ang go to the next row
        if(initIds->size() == 0) {
          if (a != -1) initIds->push_back((G4int)a);
          file >> a;
          file >> a;
          k=k+2;
        } 
        else{ 
          if (a != -1) initIds->push_back(a);
        }
        k++;    
      }
    else if (k%nColumns == 0)

      {//third column is transition energies

        if (a != -1) 
          {G4double e = a * MeV;
          transEnergies->push_back(e);}
       
        k=1;
      }
      }
  } 
  while (a != -2); // end of file
  file.close();    
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t G4RDFluoData::NumberOfTransitions

(

G4int

vacancyIndex

)

const

Definition at line 94 of file G4RDFluoData.cc.

{
  G4int n = 0;
  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies)
    {G4Exception("G4RDFluoData::NumberOfTransitions()", "OutOfRange",
                 FatalException, "VacancyIndex outside boundaries!");}
  else
    {
      n = nInitShells[vacancyIndex]-1;
      //-1 is necessary because the elements of the vector nInitShells
      //include also the vacancy shell:
      // -1 subtracts this last one
  }
 return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t G4RDFluoData::NumberOfVacancies

(

)

const

Definition at line 70 of file G4RDFluoData.cc.

{
  return numberOfVacancies;
}

void G4RDFluoData::PrintData

(

void

)

Definition at line 308 of file G4RDFluoData.cc.

{
  
  for (G4int i = 0; i <numberOfVacancies; i++)
    {
      G4cout << "---- TransitionData for the vacancy nb "
         <<i
         <<" ----- "
         <<G4endl;
      
      for (size_t k = 0; k<NumberOfTransitions(i); k++)
    { 
      G4int id = StartShellId(k,i);
    // let's start from 1 because the first (index = 0) element of the vector
    // is the id of the intial vacancy
      G4double e = StartShellEnergy(k,i) /MeV;
      G4double p = StartShellProb(k,i); 
      G4cout << k <<") Shell id: " << id <<G4endl;
      G4cout << " - Transition energy = " << e << " MeV "<<G4endl;
      G4cout   << " - Transition probability = " << p <<G4endl;
      
    }
      G4cout << "-------------------------------------------------" 
         << G4endl;
    }
}

Here is the call graph for this function:

G4double G4RDFluoData::StartShellEnergy	(	G4int	initIndex,
		G4int	vacancyIndex
	)		const

Definition at line 136 of file G4RDFluoData.cc.

{
  G4double n = -1;
  
  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies)
    {G4Exception("G4RDFluoData::StartShellEnergy()", "OutOfRange",
                 FatalException, "VacancyIndex outside boundaries!");}
 else
   {
     std::map<G4int,G4DataVector*,std::less<G4int> >::const_iterator pos;
     
     pos = energyMap.find(vacancyIndex);
     
     G4DataVector dataSet = *((*pos).second);
     
     G4int nData = dataSet.size();
     if (initIndex >= 0 && initIndex < nData)
       {
     n =  dataSet[initIndex];
     
       }
   }
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4RDFluoData::StartShellId	(	G4int	initIndex,
		G4int	vacancyIndex
	)		const

Definition at line 109 of file G4RDFluoData.cc.

{
 G4int n = -1;

 if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies)
    {G4Exception("G4RDFluoData::StartShellId()", "OutOfRange",
                 FatalException, "VacancyIndex outside boundaries!");}
 else
   {
     std::map<G4int,G4DataVector*,std::less<G4int> >::const_iterator pos;
    
     pos = idMap.find(vacancyIndex);
     
     G4DataVector dataSet = *((*pos).second);
   
     G4int nData = dataSet.size();
     //The first Element of idMap's dataSets is the original shell of the vacancy, 
     //so we must start from the first element of dataSet
 if (initIndex >= 0 && initIndex < nData)
        {
          n =  (G4int) dataSet[initIndex+1];
        
        }
   }
 return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4RDFluoData::StartShellProb	(	G4int	initIndex,
		G4int	vacancyIndex
	)		const

Definition at line 161 of file G4RDFluoData.cc.

{
  G4double n = -1;

  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies)
    {G4Exception("G4RDFluoData::StartShellProb()", "OutOfRange",
                 FatalException, "VacancyIndex outside boundaries!");}
  else
    {
     std::map<G4int,G4DataVector*,std::less<G4int> >::const_iterator pos;
     
     pos = probabilityMap.find(vacancyIndex);
     
     G4DataVector dataSet = *((*pos).second);
     
     G4int nData = dataSet.size();
     if (initIndex >= 0 && initIndex < nData)
       {
     n =  dataSet[initIndex];
     
       }
    }
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4RDFluoData::VacancyId

(

G4int

vacancyIndex

)

const

Definition at line 75 of file G4RDFluoData.cc.

{
  G4int n = -1;
  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies)
    {G4Exception("G4RDFluoData::VacancyId()", "OutOfRange",
                 FatalException, "VacancyIndex outside boundaries!");}
  else
    {
      std::map<G4int,G4DataVector*,std::less<G4int> >::const_iterator pos;
      pos = idMap.find(vacancyIndex);
      if (pos!= idMap.end())
    { G4DataVector dataSet = (*(*pos).second);
    n = (G4int) dataSet[0];
    
    }
    }
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• source/geant4.10.03.p02/examples/advanced/eRosita/physics/include/G4RDFluoData.hh
• source/geant4.10.03.p02/examples/advanced/eRosita/physics/src/G4RDFluoData.cc