G4AtomicTransitionManager Class Reference

#include <G4AtomicTransitionManager.hh>

Public Member Functions
G4AtomicShell *	Shell (G4int Z, size_t shellIndex) const
const G4FluoTransition *	ReachableShell (G4int Z, size_t shellIndex) const
const G4AugerTransition *	ReachableAugerShell (G4int Z, G4int shellIndex) const
G4int	NumberOfShells (G4int Z) const
G4int	NumberOfReachableShells (G4int Z) const
G4int	NumberOfReachableAugerShells (G4int Z) const
G4double	TotalRadiativeTransitionProbability (G4int Z, size_t shellIndex)
G4double	TotalNonRadiativeTransitionProbability (G4int Z, size_t shellIndex)

Static Public Member Functions
static G4AtomicTransitionManager *	Instance ()

Protected Member Functions
	G4AtomicTransitionManager (G4int minZ=1, G4int maxZ=100, G4int limitInfTable=6, G4int limitSupTable=100)
	~G4AtomicTransitionManager ()

Detailed Description

Definition at line 60 of file G4AtomicTransitionManager.hh.

Constructor & Destructor Documentation

G4AtomicTransitionManager::G4AtomicTransitionManager ( G4int  minZ = 1, G4int  maxZ = 100, G4int  limitInfTable = 6, G4int  limitSupTable = 100  )

protected

Definition at line 40 of file G4AtomicTransitionManager.cc.

References G4InuclSpecialFunctions::bindingEnergy(), G4ShellData::BindingEnergy(), G4ShellData::LoadData(), G4FluoData::LoadData(), G4ShellData::NumberOfShells(), G4FluoData::NumberOfTransitions(), G4ShellData::ShellId(), G4FluoData::StartShellEnergy(), G4FluoData::StartShellId(), G4FluoData::StartShellProb(), and G4FluoData::VacancyId().

Referenced by Instance().

  :zMin(minZ), 
  zMax(maxZ),
  infTableLimit(limitInfTable),
  supTableLimit(limitSupTable)
{
  // infTableLimit is initialized to 6 because EADL lacks data for Z<=5
  G4ShellData* shellManager = new G4ShellData;

  // initialization of the data for auger effect
  
  augerData = new G4AugerData;

  shellManager->LoadData("/fluor/binding");
  
  // Fills shellTable with the data from EADL, identities and binding 
  // energies of shells
  for (G4int Z = zMin; Z<= zMax; Z++)
    {
      std::vector<G4AtomicShell*> vectorOfShells;  
      size_t shellIndex = 0; 

      size_t numberOfShells=shellManager->NumberOfShells(Z);
      for (shellIndex = 0; shellIndex<numberOfShells; shellIndex++) 
    { 
      G4int shellId = shellManager->ShellId(Z,shellIndex);
      G4double bindingEnergy = shellManager->BindingEnergy(Z,shellIndex);
     
      G4AtomicShell * shell = new G4AtomicShell(shellId,bindingEnergy);
    
      vectorOfShells.push_back(shell);
    }
    
      //     shellTable.insert(std::make_pair(Z, vectorOfShells));
      shellTable[Z] = vectorOfShells;
    }
  
  // Fills transitionTable with the data from EADL, identities, transition 
  // energies and transition probabilities
  for (G4int Znum= infTableLimit; Znum<=supTableLimit; Znum++)
    {  G4FluoData* fluoManager = new G4FluoData;
    std::vector<G4FluoTransition*> vectorOfTransitions;
    fluoManager->LoadData(Znum);
    
    size_t numberOfVacancies = fluoManager-> NumberOfVacancies();
    
    for (size_t vacancyIndex = 0; vacancyIndex<numberOfVacancies;  vacancyIndex++)
      
      {
    std::vector<G4int>  vectorOfIds;
    G4DataVector vectorOfEnergies;
    G4DataVector vectorOfProbabilities;
    
    G4int finalShell = fluoManager->VacancyId(vacancyIndex);
    size_t numberOfTransitions = fluoManager->NumberOfTransitions(vacancyIndex);
    for (size_t origShellIndex = 0; origShellIndex < numberOfTransitions;
         origShellIndex++)
        
      {
        
        G4int originatingShellId = fluoManager->StartShellId(origShellIndex,vacancyIndex);
        
        vectorOfIds.push_back(originatingShellId);
        
        G4double transitionEnergy = fluoManager->StartShellEnergy(origShellIndex,vacancyIndex);
        vectorOfEnergies.push_back(transitionEnergy);
        G4double transitionProbability = fluoManager->StartShellProb(origShellIndex,vacancyIndex);
        vectorOfProbabilities.push_back(transitionProbability);
      }
      G4FluoTransition * transition = new G4FluoTransition (finalShell,vectorOfIds,
                                    vectorOfEnergies,vectorOfProbabilities);
      vectorOfTransitions.push_back(transition); 
      }
    //      transitionTable.insert(std::make_pair(Znum, vectorOfTransitions));
    transitionTable[Znum] = vectorOfTransitions;
      
      delete fluoManager;
    }
  delete shellManager;
}

G4AtomicTransitionManager::~G4AtomicTransitionManager ( )

protected

Definition at line 122 of file G4AtomicTransitionManager.cc.

{ 

  delete augerData;

std::map<G4int,std::vector<G4AtomicShell*>,std::less<G4int> >::iterator pos;
 
 for (pos = shellTable.begin(); pos != shellTable.end(); pos++){
   
   std::vector< G4AtomicShell*>vec = (*pos).second;
   
   G4int vecSize=vec.size();
   
   for (G4int i=0; i< vecSize; i++){
     G4AtomicShell* shell = vec[i];
     delete shell;     
   }
   
 }
 
 std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::iterator ppos;
 
 for (ppos = transitionTable.begin(); ppos != transitionTable.end(); ppos++){
   
   std::vector<G4FluoTransition*>vec = (*ppos).second;
   
   G4int vecSize=vec.size();
   
   for (G4int i=0; i< vecSize; i++){
     G4FluoTransition* transition = vec[i];
     delete transition;      
   }
   
 }   
 
}

Member Function Documentation

G4AtomicTransitionManager * G4AtomicTransitionManager::Instance ( void  )

static

Definition at line 162 of file G4AtomicTransitionManager.cc.

References G4AtomicTransitionManager().

Referenced by G4eIonisationSpectrum::AverageEnergy(), G4ecpssrBaseKxsModel::CalculateCrossSection(), G4ecpssrBaseLixsModel::CalculateL1CrossSection(), G4ecpssrBaseLixsModel::CalculateL2CrossSection(), G4ecpssrBaseLixsModel::CalculateL3CrossSection(), G4ecpssrBaseLixsModel::CalculateVelocity(), G4LivermoreIonisationCrossSection::G4LivermoreIonisationCrossSection(), G4LivermoreIonisationModel::G4LivermoreIonisationModel(), G4OrlicLiXsModel::G4OrlicLiXsModel(), G4PenelopeComptonModel::G4PenelopeComptonModel(), G4PenelopeIonisationCrossSection::G4PenelopeIonisationCrossSection(), G4PenelopePhotoElectricModel::G4PenelopePhotoElectricModel(), G4UAtomicDeexcitation::InitialiseForNewRun(), G4hImpactIonisation::PostStepDoIt(), G4eIonisationSpectrum::Probability(), G4eIonisationSpectrum::SampleEnergy(), G4PenelopePhotoElectricModel::SampleSecondaries(), and G4PenelopeIonisationModel::SampleSecondaries().

{
  if (instance == 0)
    {
      instance = new G4AtomicTransitionManager;
     
    }
  return instance;
}

G4int G4AtomicTransitionManager::NumberOfReachableAugerShells

(

G4int

Z

)

const

Definition at line 309 of file G4AtomicTransitionManager.cc.

References n, and G4AugerData::NumberOfVacancies().

{
  G4int n = augerData->NumberOfVacancies(Z);
  return n;
}

G4int G4AtomicTransitionManager::NumberOfReachableShells

(

G4int

Z

)

const

Definition at line 280 of file G4AtomicTransitionManager.cc.

References G4Exception(), JustWarning, and test::v.

{
std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::const_iterator pos;

  pos = transitionTable.find(Z);

  if (pos!= transitionTable.end())
    {
      std::vector<G4FluoTransition*> v = (*pos).second;
      return v.size();
    }
  else
    {
      //      G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
      //      G4cout << "Absorbed enrgy deposited locally" << G4endl;
      
      G4String msg = "No deexcitation for Z=" + (G4String(Z))+ ". Energy Deposited Locally.";

      G4Exception("G4AtomicTransitionManager::NumberOfReachebleShells()","de0001",JustWarning,msg);

      //"No deexcitation for Z=" + (G4String(Z))+". Energy Deposited Locally.");

      return 0;
    } 
}

G4int G4AtomicTransitionManager::NumberOfShells

(

G4int

Z

)

const

Definition at line 249 of file G4AtomicTransitionManager.cc.

References G4Exception(), JustWarning, and test::v.

Referenced by G4LivermoreIonisationModel::ComputeDEDXPerVolume(), G4LivermoreIonisationCrossSection::CrossSection(), G4PenelopeIonisationCrossSection::CrossSection(), G4PenelopeIonisationCrossSection::GetCrossSection(), G4LivermoreIonisationCrossSection::GetCrossSection(), and G4PenelopePhotoElectricModel::SampleSecondaries().

{

std::map<G4int,std::vector<G4AtomicShell*>,std::less<G4int> >::const_iterator pos;

  pos = shellTable.find(Z);

  if (pos!= shellTable.end()){

    std::vector<G4AtomicShell*> v = (*pos).second;

    return v.size();
  }

  else{
    //    G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
    //    G4cout << "Absorbed enrgy deposited locally" << G4endl;

    G4String msg = "No deexcitation for Z=" + (G4String(Z))+ ". Energy Deposited Locally.";

    G4Exception("G4AtomicTransitionManager::NumberOfShells()","de0001",JustWarning,msg);

    //"No deexcitation for Z=" + (G4String(Z))+". Energy Deposited Locally.");

    return 0;
  } 
}

const G4AugerTransition * G4AtomicTransitionManager::ReachableAugerShell	(	G4int	Z,
		G4int	shellIndex
	)		const

Definition at line 240 of file G4AtomicTransitionManager.cc.

References G4AugerData::GetAugerTransition().

{
  
  G4AugerTransition* augerTransition = augerData->GetAugerTransition(Z,vacancyShellIndex);
  return augerTransition;
}

const G4FluoTransition * G4AtomicTransitionManager::ReachableShell	(	G4int	Z,
		size_t	shellIndex
	)		const

Definition at line 213 of file G4AtomicTransitionManager.cc.

References G4Exception(), JustWarning, and test::v.

{
  std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::const_iterator pos;
  pos = transitionTable.find(Z);
  if (pos!= transitionTable.end())
    {
      std::vector<G4FluoTransition*> v = (*pos).second;      
      if (shellIndex < v.size()) return(v[shellIndex]);
      else {
    G4Exception("G4AtomicTransitionManager::ReachebleShell()","de0002", JustWarning,"Energy Deposited Locally.");
    return 0;
      }
  }
  else{
    //    G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
    //    G4cout << "Absorbed enrgy deposited locally" << G4endl;

    //    G4String pippo = (G4String(Z));

    G4String msg = "No deexcitation for Z=" + (G4String(Z))+ ". Energy Deposited Locally.";

    G4Exception("G4AtomicTransitionManager::ReachableShell()","de0001",JustWarning,msg);
    //"No deexcitation for Z=" + (G4String(Z))+". Energy Deposited Locally.");
    return 0;
  } 
}

G4AtomicShell * G4AtomicTransitionManager::Shell	(	G4int	Z,
		size_t	shellIndex
	)		const

Definition at line 173 of file G4AtomicTransitionManager.cc.

References FatalErrorInArgument, G4cout, G4endl, G4Exception(), and test::v.

Referenced by G4ecpssrBaseKxsModel::CalculateCrossSection(), G4ecpssrBaseLixsModel::CalculateL1CrossSection(), G4OrlicLiXsModel::CalculateL1CrossSection(), G4ecpssrBaseLixsModel::CalculateL2CrossSection(), G4OrlicLiXsModel::CalculateL2CrossSection(), G4ecpssrBaseLixsModel::CalculateL3CrossSection(), G4OrlicLiXsModel::CalculateL3CrossSection(), G4ecpssrBaseLixsModel::CalculateVelocity(), G4UAtomicDeexcitation::GetAtomicShell(), G4hImpactIonisation::PostStepDoIt(), G4LivermoreIonisationModel::SampleSecondaries(), G4PenelopePhotoElectricModel::SampleSecondaries(), G4PenelopeComptonModel::SampleSecondaries(), and G4PenelopeIonisationModel::SampleSecondaries().

{ 
  std::map<G4int,std::vector<G4AtomicShell*>,std::less<G4int> >::const_iterator pos;
  
  pos = shellTable.find(Z);
  
  if (pos!= shellTable.end())
    {
      std::vector<G4AtomicShell*> v = (*pos).second;
      if (shellIndex<v.size())
    {
      return(v[shellIndex]);
    }
      else 
    {
      size_t lastShell = v.size();
      G4cout << "G4AtomicTransitionManager::Shell - Z = " 
         << Z << ", shellIndex = " << shellIndex 
         << " not found; number of shells = " << lastShell << G4endl;
      //  G4Exception("G4AtomicTransitionManager:shell not found");
      if (lastShell > 0)
        {
          return v[lastShell - 1];
        }
      else
        {       
          return 0;
        }
    }
    }
  else
    {
      G4Exception("G4AtomicTransitionManager::Shell()","de0001",FatalErrorInArgument,"Z not found");
      return 0;
    } 
}

G4double G4AtomicTransitionManager::TotalNonRadiativeTransitionProbability	(	G4int	Z,
		size_t	shellIndex
	)

Definition at line 363 of file G4AtomicTransitionManager.cc.

References FatalException, G4Exception(), JustWarning, G4FluoTransition::TransitionProbabilities(), and test::v.

{

  std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::iterator pos;
  
  pos = transitionTable.find(Z);
  
  if (pos!= transitionTable.end()){
    
    std::vector<G4FluoTransition*> v = (*pos).second;
  
    
    if (shellIndex<v.size()){

      G4FluoTransition* transition=v[shellIndex];
      G4DataVector transProb = transition->TransitionProbabilities();
      G4double totalRadTransProb = 0;
      
      for(size_t j = 0; j<transProb.size(); j++) // AM -- Corrected, was 1
    {
      totalRadTransProb = totalRadTransProb + transProb[j];
    }
      
      if (totalRadTransProb > 1) {
    G4Exception( "G4AtomicTransitionManager::TotalNonRadiativeTransitionProbability()","de0003",FatalException,"Total probability mismatch");
      return 0;
}
      G4double totalNonRadTransProb= (1 - totalRadTransProb);
      
      return totalNonRadTransProb;    }
    
    else {

G4Exception("G4AtomicTransitionManager::TotalNonRadiativeTransitionProbability()","de0002", JustWarning,"Energy Deposited Locally.");

      return 0;
    }
  }
  else{
    //    G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
    //    G4cout << "Absorbed enrgy deposited locally" << G4endl;

    G4String msg = "No deexcitation for Z=" + (G4String(Z))+ ". Energy Deposited Locally.";

    G4Exception("G4AtomicTransitionManager::TotalNonRadiativeTransitionProbability()","de0001",JustWarning,msg);

//"No deexcitation for Z=" + (G4String(Z))+ ". Energy Deposited Locally.");

    return 0;
  } 
}

G4double G4AtomicTransitionManager::TotalRadiativeTransitionProbability	(	G4int	Z,
		size_t	shellIndex
	)

Definition at line 317 of file G4AtomicTransitionManager.cc.

References G4Exception(), JustWarning, G4FluoTransition::TransitionProbabilities(), and test::v.

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

  pos = transitionTable.find(Z);

  if (pos!= transitionTable.end())
    {
      std::vector<G4FluoTransition*> v = (*pos).second;
      
    if (shellIndex < v.size())
      {
    G4FluoTransition* transition = v[shellIndex];
    G4DataVector transProb = transition->TransitionProbabilities();
    G4double totalRadTransProb = 0;
    
    for (size_t j = 0; j<transProb.size(); j++) // AM -- corrected, it was 1
    {
      totalRadTransProb = totalRadTransProb + transProb[j];
    }
      return totalRadTransProb;   
      
    }
    else {

      G4Exception("G4AtomicTransitionManager::TotalRadiativeTransitionProbability()","de0002", JustWarning,"Energy Deposited Locally.");
      return 0;
      
    }
  }
  else{
    //G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
    //G4cout << "Absorbed enrgy deposited locally" << G4endl;
    
    G4String msg = "No deexcitation for Z=" + (G4String(Z))+ ". Energy Deposited Locally.";

    G4Exception("G4AtomicTransitionManager::TotalRadiativeTransitionProbability()","de0001",JustWarning,msg);
    //"No deexcitation for Z=" + (G4String(Z))+". Energy Deposited Locally.");


    return 0;
  } 
}

---

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

• G4AtomicTransitionManager.hh
• G4AtomicTransitionManager.cc