G4AtomicTransitionManager Class Reference

#include <G4AtomicTransitionManager.hh>

Collaboration diagram for G4AtomicTransitionManager:

Public Member Functions
void	Initialise ()
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) const
G4double	TotalNonRadiativeTransitionProbability (G4int Z, size_t shellIndex) const
void	SetVerboseLevel (G4int vl)
G4int	GetVerboseLevel ()

Static Public Member Functions
static G4AtomicTransitionManager *	Instance ()

Private Member Functions
	G4AtomicTransitionManager ()
	~G4AtomicTransitionManager ()
G4AtomicTransitionManager &	operator= (const G4AtomicTransitionManager &right)
	G4AtomicTransitionManager (const G4AtomicTransitionManager &)

Private Attributes
std::map< G4int, std::vector< G4AtomicShell * >, std::less< G4int > >	shellTable
std::map< G4int, std::vector< G4FluoTransition * >, std::less< G4int > >	transitionTable
G4AugerData *	augerData
G4int	zMin
G4int	zMax
G4int	infTableLimit
G4int	supTableLimit
G4bool	isInitialized
G4int	verboseLevel

Static Private Attributes
static G4AtomicTransitionManager *	instance = 0

Detailed Description

Definition at line 60 of file G4AtomicTransitionManager.hh.

Constructor & Destructor Documentation

G4AtomicTransitionManager() [1/2]

G4AtomicTransitionManager::G4AtomicTransitionManager ( )

private

Definition at line 53 of file G4AtomicTransitionManager.cc.

 : augerData(0),
   zMin(1), 
   zMax(100),
   infTableLimit(6),
   supTableLimit(100),
   isInitialized(false),
   verboseLevel(0)
{}

Here is the caller graph for this function:

~G4AtomicTransitionManager()

G4AtomicTransitionManager::~G4AtomicTransitionManager ( )

private

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

Here is the caller graph for this function:

G4AtomicTransitionManager() [2/2]

G4AtomicTransitionManager::G4AtomicTransitionManager ( const G4AtomicTransitionManager &  )

private

Member Function Documentation

GetVerboseLevel()

G4int G4AtomicTransitionManager::GetVerboseLevel ( )

inline

Definition at line 116 of file G4AtomicTransitionManager.hh.

{return verboseLevel;};

Here is the call graph for this function:

Initialise()

void G4AtomicTransitionManager::Initialise

(

)

Definition at line 286 of file G4AtomicTransitionManager.cc.

{
  G4AutoLock l(&AtomicTransitionManagerMutex);

  //G4cout << "!!! G4AtomicTransitionManager::Initialise " << isInitialized 
  // << G4endl;
  if(isInitialized) { return; }
  isInitialized = true;

  // Selection of fluorescence files
  G4String 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;
  
  // 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);
      // G4cout << "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.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(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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Instance()

G4AtomicTransitionManager * G4AtomicTransitionManager::Instance ( void  )

static

Definition at line 45 of file G4AtomicTransitionManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

NumberOfReachableAugerShells()

G4int G4AtomicTransitionManager::NumberOfReachableAugerShells

(

G4int

Z

)

const

Definition at line 217 of file G4AtomicTransitionManager.cc.

{
  return augerData->NumberOfVacancies(Z);
}

Here is the call graph for this function:

Here is the caller graph for this function:

NumberOfReachableShells()

G4int G4AtomicTransitionManager::NumberOfReachableShells

(

G4int

Z

)

const

Definition at line 193 of file G4AtomicTransitionManager.cc.

{
  std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::const_iterator pos;
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NumberOfShells()

G4int G4AtomicTransitionManager::NumberOfShells

(

G4int

Z

)

const

Definition at line 171 of file G4AtomicTransitionManager.cc.

{
  std::map<G4int,std::vector<G4AtomicShell*>,std::less<G4int> >::const_iterator pos;
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

Here is the caller graph for this function:

ReachableAugerShell()

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

Definition at line 165 of file G4AtomicTransitionManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ReachableShell()

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

Definition at line 136 of file G4AtomicTransitionManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetVerboseLevel()

void G4AtomicTransitionManager::SetVerboseLevel ( G4int  vl )

inline

Definition at line 115 of file G4AtomicTransitionManager.hh.

{verboseLevel = vl;};

Shell()

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

Definition at line 95 of file G4AtomicTransitionManager.cc.

{ 
  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();
      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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TotalNonRadiativeTransitionProbability()

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

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

Here is the call graph for this function:

TotalRadiativeTransitionProbability()

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

Definition at line 222 of file G4AtomicTransitionManager.cc.

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

  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) // AM -- corrected, it was 1
        {
          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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

augerData

G4AugerData* G4AtomicTransitionManager::augerData

private

Definition at line 140 of file G4AtomicTransitionManager.hh.

infTableLimit

G4int G4AtomicTransitionManager::infTableLimit

private

Definition at line 149 of file G4AtomicTransitionManager.hh.

instance

G4AtomicTransitionManager * G4AtomicTransitionManager::instance = 0

staticprivate

Definition at line 128 of file G4AtomicTransitionManager.hh.

isInitialized

G4bool G4AtomicTransitionManager::isInitialized

private

Definition at line 152 of file G4AtomicTransitionManager.hh.

shellTable

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

private

Definition at line 132 of file G4AtomicTransitionManager.hh.

supTableLimit

G4int G4AtomicTransitionManager::supTableLimit

private

Definition at line 150 of file G4AtomicTransitionManager.hh.

transitionTable

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

private

Definition at line 136 of file G4AtomicTransitionManager.hh.

verboseLevel

G4int G4AtomicTransitionManager::verboseLevel

private

Definition at line 154 of file G4AtomicTransitionManager.hh.

zMax

G4int G4AtomicTransitionManager::zMax

private

Definition at line 145 of file G4AtomicTransitionManager.hh.

zMin

G4int G4AtomicTransitionManager::zMin

private

Definition at line 144 of file G4AtomicTransitionManager.hh.

---

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

• G4AtomicTransitionManager.hh
• G4AtomicTransitionManager.cc