G4AugerData Class Reference

#include <G4AugerData.hh>

Public Member Functions
size_t	AugerShellId (G4int Z, G4int vacancyIndex, G4int transId, G4int augerIndex) const
void	BuildAugerTransitionTable ()
	G4AugerData ()
G4AugerTransition *	GetAugerTransition (G4int Z, G4int vacancyShellIndex)
std::vector< G4AugerTransition > *	GetAugerTransitions (G4int Z)
	Given the atomic number returns a vector of possible AugerTransition objects. More...
std::vector< G4AugerTransition >	LoadData (G4int Z)
size_t	NumberOfAuger (G4int Z, G4int initIndex, G4int vacancyId) const
size_t	NumberOfTransitions (G4int Z, G4int vacancyIndex) const
size_t	NumberOfVacancies (G4int Z) const
void	PrintData (G4int Z)
G4double	StartShellEnergy (G4int Z, G4int vacancyIndex, G4int transitionId, G4int augerIndex) const
G4int	StartShellId (G4int Z, G4int initialVacancyIndex, G4int transitionShellIndex) const
G4double	StartShellProb (G4int Z, G4int vacancyIndex, G4int transitionId, G4int augerIndex) const
G4int	VacancyId (G4int Z, G4int vacancyIndex) const
	Given the index of the vacancy (and the atomic number Z) returns its identity. More...
	~G4AugerData ()

Private Types
typedef std::map< G4int, std::vector< G4AugerTransition >, std::less< G4int > >	trans_Table

Private Attributes
trans_Table	augerTransitionTable
std::vector< G4int >	nInitShells
std::vector< G4int >	numberOfVacancies

Detailed Description

Definition at line 50 of file G4AugerData.hh.

Member Typedef Documentation

trans_Table

typedef std::map<G4int,std::vector<G4AugerTransition>,std::less<G4int> > G4AugerData::trans_Table

private

Definition at line 101 of file G4AugerData.hh.

Constructor & Destructor Documentation

G4AugerData()

G4AugerData::G4AugerData ( )

explicit

Definition at line 51 of file G4AugerData.cc.

{
  G4int n = 0;
  numberOfVacancies.resize(100,n);
 
  BuildAugerTransitionTable(); 
}

References BuildAugerTransitionTable(), CLHEP::detail::n, and numberOfVacancies.

~G4AugerData()

G4AugerData::~G4AugerData

(

)

Definition at line 61 of file G4AugerData.cc.

{;}

Member Function Documentation

AugerShellId()

size_t G4AugerData::AugerShellId	(	G4int	Z,
		G4int	vacancyIndex,
		G4int	transId,
		G4int	augerIndex
	)		const

Given the atomic number, th index of the starting and the auger originating shell, and the transition shell Id, returns the ager originating shell Id

Definition at line 141 of file G4AugerData.cc.

{
  size_t n = 0;  
  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
    {
      G4Exception("G4AugerData::VacancyId()","de0002", FatalErrorInArgument,"");
      return 0;
    }
  else {
    trans_Table::const_iterator element = augerTransitionTable.find(Z);
    if (element == augerTransitionTable.end()) {
      G4Exception("G4AugerData::VacancyId()","de0004", FatalErrorInArgument,  "Check element");
      return 0;
    }
    std::vector<G4AugerTransition> dataSet = (*element).second;
    n = dataSet[vacancyIndex].AugerOriginatingShellId(augerIndex,transId);
  }
  return n;
}

References augerTransitionTable, FatalErrorInArgument, G4Exception(), CLHEP::detail::n, numberOfVacancies, and Z.

Referenced by PrintData().

BuildAugerTransitionTable()

void G4AugerData::BuildAugerTransitionTable

(

)

Definition at line 408 of file G4AugerData.cc.

{
  for (G4int element = 6; element < 100; ++element)
    {     
      augerTransitionTable.insert(trans_Table::value_type(element,LoadData(element)));
    }
}

References augerTransitionTable, and LoadData().

Referenced by G4AugerData().

GetAugerTransition()

G4AugerTransition * G4AugerData::GetAugerTransition	(	G4int	Z,
		G4int	vacancyShellIndex
	)

Given the atomic number and the vacancy initial shell index returns the AugerTransition object related to that shell

Definition at line 450 of file G4AugerData.cc.

{
  std::vector<G4AugerTransition>* dataSet = &augerTransitionTable[Z];
  std::vector<G4AugerTransition>::iterator vectorIndex = dataSet->begin() + vacancyShellIndex;
  
  G4AugerTransition* augerTransition = &(*vectorIndex);
  return augerTransition;
}

References augerTransitionTable, and Z.

Referenced by G4AtomicTransitionManager::ReachableAugerShell().

GetAugerTransitions()

std::vector< G4AugerTransition > * G4AugerData::GetAugerTransitions

(

G4int

Z

)

Given the atomic number returns a vector of possible AugerTransition objects.

Definition at line 461 of file G4AugerData.cc.

{
  std::vector<G4AugerTransition>* dataSet = &augerTransitionTable[Z];
  return dataSet;
}

References augerTransitionTable, and Z.

LoadData()

std::vector< G4AugerTransition > G4AugerData::LoadData

(

G4int

Z

)

Definition at line 233 of file G4AugerData.cc.

{ 
  // Build the complete string identifying the file with the data set
  std::ostringstream ost;
  if(Z != 0){
    ost << "au-tr-pr-"<< Z << ".dat";
  }
  else{
    ost << "au-tr-pr-"<<".dat"; 
  }
  G4String name(ost.str());
  
  char* path = std::getenv("G4LEDATA");
  if (!path)
    { 
      G4String excep = "G4AugerData::LoadData";
      G4Exception(excep,"em0006", FatalException,"" );
      std::vector<G4AugerTransition> a;
      return a;
    }
  
  G4String pathString(path);
  G4String dirFile = pathString + "/auger/" + name;
  std::ifstream file(dirFile);
  std::filebuf* lsdp = file.rdbuf();
  
  if (! (lsdp->is_open()) )
    {
      G4String excep = "G4AugerData::LoadData";
      G4String msg = "Missing" + dirFile;
      G4Exception(excep,"em0003", FatalException, msg);
    }
 
  G4double a = 0;
  G4int k = 1;
  G4int sLocal = 0;
  
  G4int vacId = 0;
  std::vector<G4int>* initIds = new std::vector<G4int>;
  std::vector<G4int>* newIds = new std::vector<G4int>;
  G4DataVector* transEnergies = new G4DataVector;
  G4DataVector* transProbabilities = new G4DataVector;
  std::vector<G4AugerTransition> augerTransitionVector;
  std::map<G4int,std::vector<G4int>,std::less<G4int> >* newIdMap = 
    new std::map<G4int,std::vector<G4int>,std::less<G4int> >;
  std::map<G4int,G4DataVector,std::less<G4int> >* newEnergyMap =
    new std::map<G4int,G4DataVector,std::less<G4int> >;
  std::map<G4int,G4DataVector,std::less<G4int> >* newProbabilityMap = 
    new std::map<G4int,G4DataVector,std::less<G4int> >;
  
  do {
    file >> a;
    G4int nColumns = 4;
    if (a == -1)
      {
    if (sLocal == 0)
      {
        // End of a shell data set
        std::vector<G4int>::iterator vectorIndex = initIds->begin();
        
        vacId = *vectorIndex;
        std::vector<G4int> identifiers;
        for (vectorIndex = initIds->begin()+1 ; vectorIndex != initIds->end(); ++vectorIndex){
        identifiers.push_back(*vectorIndex);
        }
        vectorIndex = (initIds->end())-1;
        G4int augerShellId = *(vectorIndex);
                
        (*newIdMap)[augerShellId] = *newIds;
        (*newEnergyMap)[augerShellId] = *transEnergies;
        (*newProbabilityMap)[augerShellId] = *transProbabilities;
        
        augerTransitionVector.push_back(G4AugerTransition(vacId, identifiers, 
                                  newIdMap, newEnergyMap, newProbabilityMap));
        // Now deleting all the variables I used, and creating new ones for the next shell
        delete newIdMap;
        delete newEnergyMap;
        delete newProbabilityMap;
        
        G4int n = initIds->size();      
        nInitShells.push_back(n);
        numberOfVacancies[Z]++;
        delete initIds;
        delete newIds;
        delete transEnergies;       
        delete transProbabilities;
        initIds = new std::vector<G4int>;
        newIds = new std::vector<G4int>;
        transEnergies = new G4DataVector;
        transProbabilities = new G4DataVector;
        newIdMap = new std::map<G4int,std::vector<G4int>,std::less<G4int> >;
        newEnergyMap = new std::map<G4int,G4DataVector,std::less<G4int> >;
        newProbabilityMap = new std::map<G4int,G4DataVector,std::less<G4int> >; 
      }      
    sLocal++;
    if (sLocal == nColumns)
      {
        sLocal = 0;
      }
      }
    else
      {
    
    if (k%nColumns == 3){
      // 3rd column is the transition probabilities
      transProbabilities->push_back(a);   
      k++;
    }
    else if(k%nColumns == 2){    
      // 2nd column is new auger vacancy      
      G4int l = (G4int)a;
      newIds->push_back(l);
      k++;
    }
    else if (k%nColumns == 1)
      {
        // 1st column is shell id
        if(initIds->size() == 0) {
          // 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
          initIds->push_back((G4int)a);
          // first line of initIds is the original shell of the vacancy
          file >> a;
          file >> a;
          file >> a;
          k = k+3;
        }
        else {        
          if((G4int)a != initIds->back()){
        if((initIds->size()) == 1) { 
          initIds->push_back((G4int)a);
        }  
        else {
          
          
          G4int augerShellId = 0;
          augerShellId = initIds->back();
          
          (*newIdMap)[augerShellId] = *newIds;
          (*newEnergyMap)[augerShellId] = *transEnergies;
          (*newProbabilityMap)[augerShellId] = *transProbabilities;
          delete newIds;
          delete transEnergies;
          delete transProbabilities;
          newIds = new std::vector<G4int>;
          transEnergies = new G4DataVector;
          transProbabilities = new G4DataVector;
          initIds->push_back((G4int)a);
        }
          }
        }
        k++;    
      }
    else if (k%nColumns == 0)
      {//fourth column is transition energies
        G4double e = a * MeV; 
        transEnergies->push_back(e);
        k=1;
      }
      }
  }
  while (a != -2); // end of file
  file.close();
  delete initIds;
  delete newIds;
  delete transEnergies;
  delete transProbabilities;
  delete newIdMap ;
  delete newEnergyMap;
  delete newProbabilityMap;
  return augerTransitionVector; 
}

References FatalException, geant4_check_module_cycles::file, G4Exception(), MeV, CLHEP::detail::n, G4InuclParticleNames::name(), nInitShells, numberOfVacancies, and Z.

Referenced by BuildAugerTransitionTable().

NumberOfAuger()

size_t G4AugerData::NumberOfAuger	(	G4int	Z,
		G4int	initIndex,
		G4int	vacancyId
	)		const

Given the atomic number, the index of the starting vacancy shell and the transition shell Id, returns the number of shells wich an auger electron can come from.

Definition at line 118 of file G4AugerData.cc.

{
  size_t n = 0;
  if (initIndex<0 || initIndex>=numberOfVacancies[Z])
    {
      G4Exception("G4AugerData::VacancyId()","de0002", FatalErrorInArgument,"");
      return 0;
    }
  else {
    trans_Table::const_iterator element = augerTransitionTable.find(Z);
    if (element == augerTransitionTable.end()) {
      G4Exception("G4AugerData::VacancyId()","de0004", FatalErrorInArgument,  "Check element");
      return 0;
    }
    std::vector<G4AugerTransition> dataSet = (*element).second;
    const std::vector<G4int>* temp =  dataSet[initIndex].AugerOriginatingShellIds(vacancyId);
    n = temp->size();
  }
  return n;
}

References augerTransitionTable, FatalErrorInArgument, G4Exception(), CLHEP::detail::n, numberOfVacancies, and Z.

Referenced by PrintData().

NumberOfTransitions()

size_t G4AugerData::NumberOfTransitions	(	G4int	Z,
		G4int	vacancyIndex
	)		const

Given the index of a vacancy in the atom with the atomc number Z, returns the number of shells starting from wich an electron can fill the vacancy

Definition at line 95 of file G4AugerData.cc.

{
  G4int n = 0;
  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
    {
      G4Exception("G4AugerData::VacancyId()","de0002", JustWarning, "Energy deposited locally");
      return 0;
    }
  else {
    trans_Table::const_iterator element = augerTransitionTable.find(Z);
    if (element == augerTransitionTable.end()) 
      {
    G4Exception("G4AugerData::VacancyId()","de0004", FatalErrorInArgument,  "Check element");
    return 0;
      }
    std::vector<G4AugerTransition> dataSet = (*element).second;
    n = (G4int)dataSet[vacancyIndex].TransitionOriginatingShellIds()->size();
  }
 return  n;
}

References augerTransitionTable, FatalErrorInArgument, G4Exception(), JustWarning, CLHEP::detail::n, numberOfVacancies, and Z.

Referenced by PrintData().

NumberOfVacancies()

size_t G4AugerData::NumberOfVacancies

(

G4int

Z

)

const

The method returns the number of shells in wich a vacancy can be filled by a NON-radiative transition, given the atomic number

Definition at line 66 of file G4AugerData.cc.

{
  return numberOfVacancies[Z];
}

References numberOfVacancies, and Z.

Referenced by G4AtomicTransitionManager::NumberOfReachableAugerShells().

PrintData()

void G4AugerData::PrintData

(

G4int

Z

)

Definition at line 418 of file G4AugerData.cc.

{
  for (G4int i = 0; i < numberOfVacancies[Z]; ++i)
    {
      G4cout << "---- TransitionData for the vacancy nb "
         <<i
         <<" of the atomic number elemnt " 
         << Z
         <<"----- "
         <<G4endl;
      
      for (size_t k = 0; k<=NumberOfTransitions(Z,i); k++)
    { 
      G4int id = StartShellId(Z,i,k);
      
      for (size_t a = 0; a <= NumberOfAuger(Z,i,id); a++) {
        G4double e = StartShellEnergy(Z,i,id,a)/MeV;
        G4double p = StartShellProb(Z,i,id,a);
        G4int augerId = AugerShellId(Z, i, id, a);
        G4cout << k <<") Shell id: " << id <<G4endl;
        G4cout << "    Auger Originatig Shell Id :"<< augerId <<G4endl;
        G4cout << " - Transition energy = " << e << " MeV "<<G4endl;
        G4cout   << " - Transition probability = " << p <<G4endl;
      }
    }
      G4cout << "-------------------------------------------------" 
         << G4endl;
    }
}

References AugerShellId(), G4cout, G4endl, MeV, NumberOfAuger(), NumberOfTransitions(), numberOfVacancies, StartShellEnergy(), StartShellId(), StartShellProb(), and Z.

StartShellEnergy()

G4double G4AugerData::StartShellEnergy	(	G4int	Z,
		G4int	vacancyIndex,
		G4int	transitionId,
		G4int	augerIndex
	)		const

Given the atomic number , the indexes of the starting, the auger originating shell, and the transition shell Id, returns the transition energy

Definition at line 186 of file G4AugerData.cc.

{
  G4double energy = 0;
  
  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
    {
      G4Exception("G4AugerData::VacancyId()","de0002", FatalErrorInArgument,"");
      return 0;
    }
  else {
    trans_Table::const_iterator element = augerTransitionTable.find(Z);
    if (element == augerTransitionTable.end()) {
      G4Exception("G4AugerData::VacancyId()","de0004", FatalErrorInArgument,  "Check element");
      return 0;
    }
    std::vector<G4AugerTransition> dataSet = (*element).second;
    energy = dataSet[vacancyIndex].AugerTransitionEnergy(augerIndex,transitionId);
      
  }
  return energy;
}

References augerTransitionTable, G4INCL::KinematicsUtils::energy(), FatalErrorInArgument, G4Exception(), numberOfVacancies, and Z.

Referenced by PrintData().

StartShellId()

G4int G4AugerData::StartShellId	(	G4int	Z,
		G4int	initialVacancyIndex,
		G4int	transitionShellIndex
	)		const

Given the atomic number Z, the Index of the initial vacancy shell and the index of the starting shell for the transition, returns the identity of the shell originating the electron transition

Definition at line 163 of file G4AugerData.cc.

{
  G4int n = 0; 
 
   if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z]) 
     {
       G4Exception("G4AugerData::VacancyId()","de0002", FatalErrorInArgument,"");
       return 0;
     }
  else {
    trans_Table::const_iterator element = augerTransitionTable.find(Z);
    if (element == augerTransitionTable.end()) {
      G4Exception("G4AugerData::VacancyId()","de0004", FatalErrorInArgument,  "Check element");
      return 0; 
    }
    std::vector<G4AugerTransition> dataSet = (*element).second;
    n = dataSet[vacancyIndex].TransitionOriginatingShellId(transitionShellIndex);
  } 
 return n;
}

References augerTransitionTable, FatalErrorInArgument, G4Exception(), CLHEP::detail::n, numberOfVacancies, and Z.

Referenced by PrintData().

StartShellProb()

G4double G4AugerData::StartShellProb	(	G4int	Z,
		G4int	vacancyIndex,
		G4int	transitionId,
		G4int	augerIndex
	)		const

Given the atomic number, the index of the starting shell, the auger originating shells, and the transition shell Id, returns the transition probability

Definition at line 210 of file G4AugerData.cc.

{
  G4double prob = 0;
    
  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z]) 
    {
      G4Exception("G4AugerData::VacancyId()","de0002", FatalErrorInArgument,"");
      return 0;
    }
  else {
    trans_Table::const_iterator element = augerTransitionTable.find(Z);
    if (element == augerTransitionTable.end()) {
      G4Exception("G4AugerData::VacancyId()","de0004", FatalErrorInArgument,  "Check element");
      return 0;
    }
    std::vector<G4AugerTransition> dataSet = (*element).second;
    prob = dataSet[vacancyIndex].AugerTransitionProbability(augerIndex, transitionId);
  }
  return prob;
}

References augerTransitionTable, FatalErrorInArgument, G4Exception(), numberOfVacancies, and Z.

Referenced by PrintData().

VacancyId()

G4int G4AugerData::VacancyId	(	G4int	Z,
		G4int	vacancyIndex
	)		const

Given the index of the vacancy (and the atomic number Z) returns its identity.

Definition at line 73 of file G4AugerData.cc.

{
  G4int n = 0;
  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
    {
      G4Exception("G4AugerData::VacancyId()","de0002", FatalErrorInArgument,"");
    }
  else {
    trans_Table::const_iterator element = augerTransitionTable.find(Z);
    if (element == augerTransitionTable.end()) {
      G4Exception("G4AugerData::VacancyId()","de0004", FatalErrorInArgument,  "Check element");
      return 0;
    }
    std::vector<G4AugerTransition> dataSet = (*element).second;
    n = (G4int) dataSet[vacancyIndex].FinalShellId();
  }  
  return n;
}

References augerTransitionTable, FatalErrorInArgument, G4Exception(), CLHEP::detail::n, numberOfVacancies, and Z.

Field Documentation

augerTransitionTable

trans_Table G4AugerData::augerTransitionTable

private

Definition at line 102 of file G4AugerData.hh.

Referenced by AugerShellId(), BuildAugerTransitionTable(), GetAugerTransition(), GetAugerTransitions(), NumberOfAuger(), NumberOfTransitions(), StartShellEnergy(), StartShellId(), StartShellProb(), and VacancyId().

nInitShells

std::vector<G4int> G4AugerData::nInitShells

private

Definition at line 104 of file G4AugerData.hh.

Referenced by LoadData().

numberOfVacancies

std::vector<G4int> G4AugerData::numberOfVacancies

private

Definition at line 105 of file G4AugerData.hh.

Referenced by AugerShellId(), G4AugerData(), LoadData(), NumberOfAuger(), NumberOfTransitions(), NumberOfVacancies(), PrintData(), StartShellEnergy(), StartShellId(), StartShellProb(), and VacancyId().

---

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

• source/processes/electromagnetic/lowenergy/include/G4AugerData.hh
• source/processes/electromagnetic/lowenergy/src/G4AugerData.cc