G4AtomicTransitionManager Class Reference

#include <G4AtomicTransitionManager.hh>

Public Member Functions
	~G4AtomicTransitionManager ()
void	Initialise ()
	needs to be called once from other code before start of run
G4AtomicShell *	Shell (G4int Z, std::size_t shellIndex) const
const G4FluoTransition *	ReachableShell (G4int Z, std::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, std::size_t shellIndex) const
G4double	TotalNonRadiativeTransitionProbability (G4int Z, std::size_t shellIndex) const
void	SetVerboseLevel (G4int vl)
	Verbosity control.
G4int	GetVerboseLevel ()
G4AtomicTransitionManager &	operator= (const G4AtomicTransitionManager &right)=delete
	G4AtomicTransitionManager (const G4AtomicTransitionManager &)=delete

Static Public Member Functions
static G4AtomicTransitionManager *	Instance ()

Detailed Description

Definition at line 57 of file G4AtomicTransitionManager.hh.

Constructor & Destructor Documentation

~G4AtomicTransitionManager()

G4AtomicTransitionManager::~G4AtomicTransitionManager

(

)

Definition at line 66 of file G4AtomicTransitionManager.cc.

{ 
  delete augerData;
 
  for (auto const & pos : shellTable) {
    std::vector<G4AtomicShell*> vec = pos.second;
    for (auto const & p : vec) { delete p; }
  }
 
  for (auto const & ppos : transitionTable) {
    std::vector<G4FluoTransition*> vec = ppos.second;
    for (auto const & p : vec) { delete p; }
  }   
}

G4AtomicTransitionManager()

G4AtomicTransitionManager::G4AtomicTransitionManager ( const G4AtomicTransitionManager & )

delete

Referenced by G4AtomicTransitionManager(), Instance(), and operator=().

Member Function Documentation

GetVerboseLevel()

G4int G4AtomicTransitionManager::GetVerboseLevel ( )

inline

Definition at line 112 of file G4AtomicTransitionManager.hh.

{return verboseLevel;};

Initialise()

void G4AtomicTransitionManager::Initialise

(

)

needs to be called once from other code before start of run

Definition at line 271 of file G4AtomicTransitionManager.cc.

{
  if(isInitialized) { return; }
  G4AutoLock l(&AtomicTransitionManagerMutex);
 
  if(isInitialized) { return; }
  isInitialized = true;
 
  // Selection of fluorescence files
  
  const G4String& defaultDirectory = "/fluor";
  G4String fluoDirectory = defaultDirectory;
  G4String bindingDirectory = defaultDirectory;
  G4EmFluoDirectory fdir = G4EmParameters::Instance()->FluoDirectory();
  G4int zLim = zMax + 1;
  if(fdir == fluoBearden) {
    zMax = 100;
    supTableLimit = 100;
    bindingDirectory = fluoDirectory = "/fluor_Bearden";
  } else if(fdir == fluoANSTO) {
    zLim = 93;
    fluoDirectory = "/fluor_ANSTO";
  } else if(fdir == fluoXDB_EADL) {
    zMax = 100;
    supTableLimit = 100;
    bindingDirectory = fluoDirectory = "/fluor_XDB_EADL";
  }
 
  // infTableLimit is initialized to 6 because EADL lacks data for Z<=5
  G4ShellData* shellManager = new G4ShellData(1, zMax, false);
  shellManager->LoadData(bindingDirectory + "/binding");
 
  // initialization of the data for auger effect
  augerData = new G4AugerData;
  
  // Fills shellTable with the data from EADL, identities and binding 
  // energies of shells
  for (G4int Z = zMin; Z <= zMax; ++Z)
    {    
      std::vector<G4AtomicShell*> vectorOfShells;  
      G4int shellIndex = 0; 
 
      G4int numberOfShells = (G4int)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[Z] = std::move(vectorOfShells);
    }
  
  // Fills transitionTable with the data on identities, transition 
  // energies and transition probabilities
  G4String dir = std::move(fluoDirectory);
  for (G4int Znum= infTableLimit; Znum<=supTableLimit; ++Znum)
    {  
      if (Znum == zLim) { dir = defaultDirectory; }
      G4FluoData* fluoManager = new G4FluoData(dir);
      std::vector<G4FluoTransition*> vectorOfTransitions;
      fluoManager->LoadData(Znum);
    
      G4int numberOfVacancies = (G4int)fluoManager->NumberOfVacancies();
      for(G4int vacancyIndex = 0; vacancyIndex<numberOfVacancies;  
      ++vacancyIndex)
    {
      std::vector<G4int> vectorOfIds;
      G4DataVector vectorOfEnergies;
      G4DataVector vectorOfProbabilities;
    
      G4int finalShell = fluoManager->VacancyId(vacancyIndex);
      G4int numberOfTransitions = (G4int)
                fluoManager->NumberOfTransitions(vacancyIndex);
      for (G4int 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[Znum] = std::move(vectorOfTransitions);
      delete fluoManager;
    }
  delete shellManager;
  l.unlock();
}

Instance()

G4AtomicTransitionManager * G4AtomicTransitionManager::Instance ( )

static

The only way to get an instance of this class is to call the function Instance()

Definition at line 49 of file G4AtomicTransitionManager.cc.

{
  if (instance == nullptr) {
    static G4AtomicTransitionManager man;
    instance = &man;
  }
  return instance;
}

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::G4UAtomicDeexcitation(), G4hImpactIonisation::PostStepDoIt(), G4eIonisationSpectrum::Probability(), G4eIonisationSpectrum::SampleEnergy(), G4PenelopeIonisationModel::SampleSecondaries(), and G4PenelopePhotoElectricModel::SampleSecondaries().

NumberOfReachableAugerShells()

G4int G4AtomicTransitionManager::NumberOfReachableAugerShells

(

G4int

Z

)

const

This function returns the number of possible NON-radiative transitions for the atom with atomic number Z i.e. the number of shell in wich a vacancy can be filled by a NON-radiative transition

Definition at line 204 of file G4AtomicTransitionManager.cc.

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

NumberOfReachableShells()

G4int G4AtomicTransitionManager::NumberOfReachableShells

(

G4int

Z

)

const

This function returns the number of those shells of the element whose atomic number is Z which are reachable through a radiative transition

Definition at line 181 of file G4AtomicTransitionManager.cc.

{
  auto pos = transitionTable.find(Z);
  std::size_t res = 0;
  if (pos!= transitionTable.cend())
    {
      res = ((*pos).second).size();
    }
  else
    {
      G4ExceptionDescription ed;
      ed << "No deexcitation for Z= " << Z
     << ", so energy deposited locally";
      G4Exception("G4AtomicTransitionManager::NumberOfReachebleShells()",
          "de0001",FatalException,ed,"");
    } 
  return (G4int)res;
}

NumberOfShells()

G4int G4AtomicTransitionManager::NumberOfShells

(

G4int

Z

)

const

This function returns the number of shells of the element whose atomic number is Z

Definition at line 159 of file G4AtomicTransitionManager.cc.

{
  auto pos = shellTable.find(Z);
 
  std::size_t res = 0;
  if (pos != shellTable.cend()){
 
    res = ((*pos).second).size();
 
  } else {
    G4ExceptionDescription ed;
    ed << "No deexcitation for Z= " << Z;
    G4Exception("G4AtomicTransitionManager::NumberOfShells()","de0001",
        FatalException, ed, "");
  } 
  return (G4int)res;
}

Referenced by G4PenelopePhotoElectricModel::SampleSecondaries().

operator=()

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

delete

ReachableAugerShell()

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

This function gives, upon Z and the Index of the initial shell where the vacancy is, the NON-radiative transition that can happen with originating shell for the transition, and the data for the possible auger electrons emitted (originating vacancy, energy amnd probability)

Definition at line 152 of file G4AtomicTransitionManager.cc.

{
  return augerData->GetAugerTransition(Z,vacancyShellIndex);
}

ReachableShell()

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

Z is the atomic number of the element, shellIndex is the index (in EADL) of the final shell for the transition This function gives, upon Z and the Index of the initial shell where the vacancy is, the radiative transition that can happen (originating shell, energy, probability)

Definition at line 123 of file G4AtomicTransitionManager.cc.

{
  auto pos = transitionTable.find(Z);
  if (pos!= transitionTable.end())
    {
      std::vector<G4FluoTransition*> v = (*pos).second;      
      if (shellIndex < v.size()) { return(v[shellIndex]); }
 
      else {
    G4ExceptionDescription ed;
    ed << "No fluo transition for Z= " << Z 
       << "  shellIndex= " << shellIndex;
    G4Exception("G4AtomicTransitionManager::ReachebleShell()","de0002", 
            FatalException,ed,"");
      }
    } 
  else 
    {
      G4ExceptionDescription ed;
      ed << "No transition table for Z= " << Z 
     << "  shellIndex= " << shellIndex;
      G4Exception("G4AtomicTransitionManager::ReachableShell()","de0001",
          FatalException,ed,"");
    } 
  return 0;
}

SetVerboseLevel()

void G4AtomicTransitionManager::SetVerboseLevel ( G4int vl )

inline

Verbosity control.

Definition at line 111 of file G4AtomicTransitionManager.hh.

{verboseLevel = vl;};

Shell()

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

Z is the atomic number of the element, shellIndex is the index (in EADL) of the shell

Definition at line 83 of file G4AtomicTransitionManager.cc.

{   
  auto pos = shellTable.find(Z);
  
  if (pos!= shellTable.end())
    {
      std::vector<G4AtomicShell*> v = (*pos).second;
      if (shellIndex < v.size()) { return v[shellIndex]; }
 
      else 
    {
      std::size_t lastShell = v.size();
      G4ExceptionDescription ed;
      ed << "No de-excitation for Z= " << Z 
         << "  shellIndex= " << shellIndex
         << ">=  numberOfShells= " << lastShell;
      if (verboseLevel > 0) 
              G4Exception("G4AtomicTransitionManager::Shell()","de0001",
        JustWarning,ed," AtomicShell not found");
      if (lastShell > 0) { return v[lastShell - 1]; }
    }
    }
  else
    {
      G4ExceptionDescription ed;
      ed << "No de-excitation for Z= " << Z 
     << "  shellIndex= " << shellIndex
     << ". AtomicShell not found - check if data are uploaded";
      G4Exception("G4AtomicTransitionManager::Shell()","de0001",
          FatalException,ed,"");
    } 
  return nullptr;
}

Referenced by G4ecpssrBaseKxsModel::CalculateCrossSection(), G4ecpssrBaseLixsModel::CalculateL1CrossSection(), G4ecpssrBaseLixsModel::CalculateL2CrossSection(), G4ecpssrBaseLixsModel::CalculateL3CrossSection(), G4ecpssrBaseLixsModel::CalculateVelocity(), G4hImpactIonisation::PostStepDoIt(), and G4PenelopeIonisationModel::SampleSecondaries().

TotalNonRadiativeTransitionProbability()

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

Gives the sum of the probabilities of non radiative transition from the shell whose index is shellIndex

Definition at line 253 of file G4AtomicTransitionManager.cc.

{
  G4double prob = 1.0 - TotalRadiativeTransitionProbability(Z, shellIndex);
  if(prob > 1.0 || prob < 0.0) {
    G4ExceptionDescription ed;
    ed << "Total probability mismatch Z= " << Z 
       << "  shellIndex= " << shellIndex
       << "  prob= " << prob;
    G4Exception( 
    "G4AtomicTransitionManager::TotalNonRadiativeTransitionProbability()",
    "de0003",FatalException,ed,"Cannot compute non-radiative probability");
    return 0.0;
  }
  return prob;    
}

TotalRadiativeTransitionProbability()

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

Gives the sum of the probabilities of radiative transition towards the shell whose index is shellIndex

Definition at line 210 of file G4AtomicTransitionManager.cc.

{
  auto pos = transitionTable.find(Z);
  G4double totalRadTransProb = 0.0;
 
  if (pos!= transitionTable.end())
    {
      std::vector<G4FluoTransition*> v = (*pos).second;
      
      if (shellIndex < v.size())
    {
      G4FluoTransition* transition = v[shellIndex];
      G4DataVector transProb = transition->TransitionProbabilities();
    
      for (std::size_t j=0; j<transProb.size(); ++j) 
        {
          totalRadTransProb += transProb[j];
        }
    }
      else 
    {
      G4ExceptionDescription ed;
      ed << "Zero transition probability for Z=" << Z 
         << "  shellIndex= " << shellIndex;
      G4Exception(
      "G4AtomicTransitionManager::TotalRadiativeTransitionProbability()",
      "de0002",FatalException,"Incorrect de-excitation");
    }
    }
  else
    {
      G4ExceptionDescription ed;
      ed << "No deexcitation for Z=" << Z 
     << "  shellIndex= " << shellIndex;
      G4Exception(
      "G4AtomicTransitionManager::TotalRadiativeTransitionProbability()",
      "de0001",FatalException,ed,"Cannot compute transition probability");
    } 
  return totalRadTransProb;
}

Referenced by TotalNonRadiativeTransitionProbability().

---

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

• G4AtomicTransitionManager.hh
• G4AtomicTransitionManager.cc