G4RDFluoData Class Reference

#include <G4RDFluoData.hh>

Collaboration diagram for G4RDFluoData:

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 ()

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

Private Attributes
std::map< G4int, G4DataVector *, std::less< G4int > >	idMap
std::map< G4int, G4DataVector *, std::less< G4int > >	energyMap
std::map< G4int, G4DataVector *, std::less< G4int > >	probabilityMap
std::vector< G4int >	nInitShells
G4int	numberOfVacancies
std::map< G4int, std::vector< G4RDFluoTransition * >, std::less< G4int > >	fluoTransitionTable

Detailed Description

Definition at line 52 of file G4RDFluoData.hh.

Constructor & Destructor Documentation

G4RDFluoData() [1/2]

G4RDFluoData::G4RDFluoData

(

)

Definition at line 44 of file G4RDFluoData.cc.

{
  numberOfVacancies=0; 
}

~G4RDFluoData()

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

G4RDFluoData() [2/2]

G4RDFluoData::G4RDFluoData ( const G4RDFluoData &  )

private

Member Function Documentation

LoadData()

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:

NumberOfTransitions()

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:

NumberOfVacancies()

size_t G4RDFluoData::NumberOfVacancies

(

)

const

Definition at line 70 of file G4RDFluoData.cc.

{
  return numberOfVacancies;
}

operator=()

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

private

PrintData()

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:

StartShellEnergy()

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:

StartShellId()

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:

StartShellProb()

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:

VacancyId()

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:

Member Data Documentation

energyMap

std::map<G4int,G4DataVector*,std::less<G4int> > G4RDFluoData::energyMap

private

Definition at line 99 of file G4RDFluoData.hh.

fluoTransitionTable

std::map<G4int,std::vector<G4RDFluoTransition*>,std::less<G4int> > G4RDFluoData::fluoTransitionTable

private

Definition at line 103 of file G4RDFluoData.hh.

idMap

std::map<G4int,G4DataVector*,std::less<G4int> > G4RDFluoData::idMap

private

Definition at line 98 of file G4RDFluoData.hh.

nInitShells

std::vector<G4int> G4RDFluoData::nInitShells

private

Definition at line 101 of file G4RDFluoData.hh.

numberOfVacancies

G4int G4RDFluoData::numberOfVacancies

private

Definition at line 102 of file G4RDFluoData.hh.

probabilityMap

std::map<G4int,G4DataVector*,std::less<G4int> > G4RDFluoData::probabilityMap

private

Definition at line 100 of file G4RDFluoData.hh.

---

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

• G4RDFluoData.hh
• G4RDFluoData.cc