#include <G4AtomicTransitionManager.hh>

Public Member Functions
G4int	GetVerboseLevel ()

void	Initialise ()
	needs to be called once from other code before start of run More...

G4int	NumberOfReachableAugerShells (G4int Z) const

G4int	NumberOfReachableShells (G4int Z) const

G4int	NumberOfShells (G4int Z) const

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

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

void	SetVerboseLevel (G4int vl)
	Verbosity control. More...

G4AtomicShell *	Shell (G4int Z, size_t shellIndex) const

G4double	TotalNonRadiativeTransitionProbability (G4int Z, size_t shellIndex) const

G4double	TotalRadiativeTransitionProbability (G4int Z, size_t shellIndex) const

Static Public Member Functions
static G4AtomicTransitionManager *	Instance ()

Private Member Functions
	G4AtomicTransitionManager ()

	G4AtomicTransitionManager (const G4AtomicTransitionManager &)

G4AtomicTransitionManager &	operator= (const G4AtomicTransitionManager &right)

	~G4AtomicTransitionManager ()

Private Attributes
G4AugerData *	augerData

G4int	infTableLimit = 6

G4bool	isInitialized

std::map< G4int, std::vector< G4AtomicShell * >, std::less< G4int > >	shellTable

G4int	supTableLimit = 100

std::map< G4int, std::vector< G4FluoTransition * >, std::less< G4int > >	transitionTable

G4int	verboseLevel

G4int	zMax = 100

G4int	zMin = 1

Static Private Attributes
static G4AtomicTransitionManager *	instance = nullptr

Detailed Description

Definition at line 57 of file G4AtomicTransitionManager.hh.

Constructor & Destructor Documentation

◆ G4AtomicTransitionManager() [1/2]

G4AtomicTransitionManager::G4AtomicTransitionManager ( )

explicitprivate

Definition at line 57 of file G4AtomicTransitionManager.cc.

 : augerData(nullptr),
   verboseLevel(0),
   isInitialized(false)
{}

Referenced by Instance().

◆ ~G4AtomicTransitionManager()

G4AtomicTransitionManager::~G4AtomicTransitionManager ( )

private

Definition at line 64 of file G4AtomicTransitionManager.cc.

{ 
  delete augerData;
 
  for (auto& pos : shellTable){
    std::vector<G4AtomicShell*>vec = pos.second;
    G4int vecSize = vec.size();   
    for (G4int i=0; i< vecSize; ++i){
      G4AtomicShell* shell = vec[i];
      delete shell;     
    }
  }
 
  for (auto& ppos : transitionTable)
    {
      std::vector<G4FluoTransition*>vec = ppos.second;
      G4int vecSize=vec.size();
   
      for (G4int i=0; i< vecSize; ++i){
    G4FluoTransition* transition = vec[i];
    delete transition;      
      }
    }   
}

References augerData, pos, shellTable, and transitionTable.

◆ G4AtomicTransitionManager() [2/2]

G4AtomicTransitionManager::G4AtomicTransitionManager ( const G4AtomicTransitionManager & )

private

Member Function Documentation

◆ GetVerboseLevel()

G4int G4AtomicTransitionManager::GetVerboseLevel ( )

inline

Definition at line 110 of file G4AtomicTransitionManager.hh.

110{return verboseLevel;};

References verboseLevel.

◆ Initialise()

void G4AtomicTransitionManager::Initialise ( )

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

Definition at line 278 of file G4AtomicTransitionManager.cc.

{
  G4AutoLock l(&AtomicTransitionManagerMutex);
 
  if(isInitialized) { return; }
  isInitialized = true;
 
  // Selection of fluorescence files
  
  G4String fluoDirectory = "/fluor";
  
  fluoDirectory = (G4EmParameters::Instance()->BeardenFluoDir()?
                "/fluor_Bearden":"/fluor");
 
  // infTableLimit is initialized to 6 because EADL lacks data for Z<=5
  G4ShellData* shellManager = new G4ShellData;
  shellManager->LoadData(fluoDirectory+"/binding");
 
  // initialization of the data for auger effect
  augerData = new G4AugerData;
  
  if (G4EmParameters::Instance()->ANSTOFluoDir()) 
     {
      fluoDirectory = "/fluor_ANSTO";                                 
       G4cout << "The ANSTO fluorescence radiation yields substitute the EADL data libraries" << G4endl;
      }                                     
  // Fills shellTable with the data from EADL, identities and binding 
  // energies of shells
  for (G4int Z = zMin; Z<= zMax; ++Z) 
    {
    
    if ((Z > 92) && (G4EmParameters::Instance()->ANSTOFluoDir())) fluoDirectory ="/fluor";   
    
      std::vector<G4AtomicShell*> vectorOfShells;  
      size_t shellIndex = 0; 
 
      size_t numberOfShells = shellManager->NumberOfShells(Z);
      // G4cout << fluoDirectory <<"    For Z= " << Z << "  " << numberOfShells << " shells" << G4endl;
      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] = vectorOfShells;
    }
  
  // Fills transitionTable with the data from EADL, identities, transition 
  // energies and transition probabilities
   if (G4EmParameters::Instance()->ANSTOFluoDir()) fluoDirectory = "/fluor_ANSTO"; 
  
  
  for (G4int Znum= infTableLimit; Znum<=supTableLimit; ++Znum)
    {  
      if ((Znum > 92) && (G4EmParameters::Instance()->ANSTOFluoDir())) fluoDirectory ="/fluor";    
      G4FluoData* fluoManager = new G4FluoData(fluoDirectory);
      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[Znum] = vectorOfTransitions;
      delete fluoManager;
    }
  delete shellManager;
}

References G4EmParameters::ANSTOFluoDir(), anonymous_namespace{G4AtomicTransitionManager.cc}::AtomicTransitionManagerMutex, augerData, G4EmParameters::BeardenFluoDir(), G4InuclSpecialFunctions::bindingEnergy(), G4ShellData::BindingEnergy(), G4cout, G4endl, infTableLimit, G4EmParameters::Instance(), isInitialized, G4ShellData::LoadData(), G4FluoData::LoadData(), G4ShellData::NumberOfShells(), G4FluoData::NumberOfTransitions(), G4ShellData::ShellId(), shellTable, G4FluoData::StartShellEnergy(), G4FluoData::StartShellId(), G4FluoData::StartShellProb(), supTableLimit, transitionTable, G4FluoData::VacancyId(), Z, zMax, and zMin.

Referenced by G4LivermoreIonisationModel::Initialise(), G4UAtomicDeexcitation::InitialiseForNewRun(), and G4PenelopeOscillatorManager::ReadElementData().

◆ Instance()

G4AtomicTransitionManager * G4AtomicTransitionManager::Instance ( void )

static

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

Definition at line 48 of file G4AtomicTransitionManager.cc.

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

References G4AtomicTransitionManager(), and 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(), G4AtomicDeexcitation::GenerateAuger(), G4AtomicDeexcitation::GenerateFluorescence(), G4hImpactIonisation::PostStepDoIt(), G4eIonisationSpectrum::Probability(), G4PenelopeOscillatorManager::ReadElementData(), G4eIonisationSpectrum::SampleEnergy(), G4PenelopeIonisationModel::SampleSecondaries(), G4PenelopePhotoElectricModel::SampleSecondaries(), and G4AtomicDeexcitation::SelectTypeOfTransition().

◆ 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 211 of file G4AtomicTransitionManager.cc.

{
  return augerData->NumberOfVacancies(Z);
}

References augerData, G4AugerData::NumberOfVacancies(), and Z.

Referenced by G4AtomicDeexcitation::GenerateAuger(), and G4UAtomicDeexcitation::GenerateAuger().

◆ 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 188 of file G4AtomicTransitionManager.cc.

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

References FatalException, G4Exception(), pos, transitionTable, and Z.

Referenced by G4AtomicDeexcitation::GenerateFluorescence(), G4UAtomicDeexcitation::GenerateFluorescence(), G4AtomicDeexcitation::SelectTypeOfTransition(), and G4UAtomicDeexcitation::SelectTypeOfTransition().

◆ 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 166 of file G4AtomicTransitionManager.cc.

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

References FatalException, G4Exception(), pos, shellTable, and Z.

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

◆ operator=()

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

private

◆ 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 159 of file G4AtomicTransitionManager.cc.

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

References augerData, G4AugerData::GetAugerTransition(), and Z.

Referenced by G4AtomicDeexcitation::GenerateAuger(), and G4UAtomicDeexcitation::GenerateAuger().

◆ ReachableShell()

const G4FluoTransition * G4AtomicTransitionManager::ReachableShell	(	G4int	Z,
		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 130 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;
}

References FatalException, G4Exception(), pos, transitionTable, and Z.

Referenced by G4AtomicDeexcitation::SelectTypeOfTransition(), and G4UAtomicDeexcitation::SelectTypeOfTransition().

◆ SetVerboseLevel()

void G4AtomicTransitionManager::SetVerboseLevel ( G4int vl )

inline

Verbosity control.

Definition at line 109 of file G4AtomicTransitionManager.hh.

109{verboseLevel = vl;};

References verboseLevel.

◆ Shell()

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

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

Definition at line 90 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 
    {
      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 0;
}

References FatalException, G4Exception(), JustWarning, pos, shellTable, verboseLevel, and Z.

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

◆ TotalNonRadiativeTransitionProbability()

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

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

Definition at line 260 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;    
}

References FatalException, G4Exception(), TotalRadiativeTransitionProbability(), and Z.

◆ TotalRadiativeTransitionProbability()

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

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

Definition at line 217 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 (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;
}

private

Definition at line 136 of file G4AtomicTransitionManager.hh.

Referenced by Initialise().

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

source/processes/electromagnetic/lowenergy/include/G4AtomicTransitionManager.hh
source/processes/electromagnetic/lowenergy/src/G4AtomicTransitionManager.cc

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4AtomicTransitionManager() [1/2]

◆ ~G4AtomicTransitionManager()

◆ G4AtomicTransitionManager() [2/2]

Member Function Documentation

◆ GetVerboseLevel()

◆ Initialise()

◆ Instance()

◆ NumberOfReachableAugerShells()

◆ NumberOfReachableShells()

◆ NumberOfShells()

◆ operator=()

◆ ReachableAugerShell()

◆ ReachableShell()

◆ SetVerboseLevel()

◆ Shell()

◆ TotalNonRadiativeTransitionProbability()

◆ TotalRadiativeTransitionProbability()

Field Documentation

◆ augerData

◆ infTableLimit

◆ instance

◆ isInitialized

◆ shellTable

◆ supTableLimit

◆ transitionTable

◆ verboseLevel

◆ zMax

◆ zMin