G4RDAtomicDeexcitation Class Reference

#include <G4RDAtomicDeexcitation.hh>

Collaboration diagram for G4RDAtomicDeexcitation:

Public Member Functions
	G4RDAtomicDeexcitation ()
	~G4RDAtomicDeexcitation ()
std::vector< G4DynamicParticle * > *	GenerateParticles (G4int Z, G4int shellId)
void	SetCutForSecondaryPhotons (G4double cut)
void	SetCutForAugerElectrons (G4double cut)
void	ActivateAugerElectronProduction (G4bool val)

Private Member Functions
G4int	SelectTypeOfTransition (G4int Z, G4int shellId)
G4DynamicParticle *	GenerateFluorescence (G4int Z, G4int shellId, G4int provShellId)
G4DynamicParticle *	GenerateAuger (G4int Z, G4int shellId)

Private Attributes
G4int	newShellId
G4double	minGammaEnergy
G4double	minElectronEnergy
G4bool	fAuger
G4int	augerVacancyId

Detailed Description

Definition at line 53 of file G4RDAtomicDeexcitation.hh.

Constructor & Destructor Documentation

G4RDAtomicDeexcitation()

G4RDAtomicDeexcitation::G4RDAtomicDeexcitation

(

)

Definition at line 50 of file G4RDAtomicDeexcitation.cc.

                                              :
  minGammaEnergy(100.*eV),
  minElectronEnergy(100.*eV),
  fAuger(false)
{}

~G4RDAtomicDeexcitation()

G4RDAtomicDeexcitation::~G4RDAtomicDeexcitation

(

)

Definition at line 56 of file G4RDAtomicDeexcitation.cc.

{}

Member Function Documentation

ActivateAugerElectronProduction()

void G4RDAtomicDeexcitation::ActivateAugerElectronProduction

(

G4bool

val

)

Definition at line 507 of file G4RDAtomicDeexcitation.cc.

{
  fAuger = val;
}

Here is the caller graph for this function:

GenerateAuger()

G4DynamicParticle * G4RDAtomicDeexcitation::GenerateAuger ( G4int  Z, G4int  shellId  )

private

Definition at line 277 of file G4RDAtomicDeexcitation.cc.

{
  if(!fAuger) return 0;
  

  const G4RDAtomicTransitionManager*  transitionManager = 
        G4RDAtomicTransitionManager::Instance();



  if (shellId <=0 ) 
    {
      G4Exception("G4RDAtomicDeexcitation::GenerateAuger()",
                  "InvalidCondition", FatalException,
                  "Zero or negative shellId!");
    }
  
  // G4int provShellId = -1;
  G4int maxNumOfShells = transitionManager->NumberOfReachableAugerShells(Z);  
  
  const G4RDAugerTransition* refAugerTransition = 
        transitionManager->ReachableAugerShell(Z,maxNumOfShells-1);


  // This loop gives to shellNum the value of the index of shellId
  // in the vector storing the list of the vacancies in the variuos shells 
  // that can originate a NON-radiative transition
  
  // ---- MGP ---- Next line commented out to remove compilation warning
  // G4int p = refAugerTransition->FinalShellId();

  G4int shellNum = 0;


  if ( shellId <= refAugerTransition->FinalShellId() ) 
    //"FinalShellId" is final from the point of view of the elctron who makes the transition, 
    // being the Id of the shell in which there is a vacancy
    {
      G4int pippo = transitionManager->ReachableAugerShell(Z,shellNum)->FinalShellId();
      if (shellId  != pippo ) {
    do { 
      shellNum++;
      if(shellNum == maxNumOfShells)
        {
//            G4cout << "G4RDAtomicDeexcitation warning: No Auger transition found" <<  G4endl;
//        G4cout << "Absorbed enrgy deposited locally" << G4endl;
          return 0;
//        //  G4Exception("G4RDAtomicDeexcitation: No Auger transition found");
        }
    }
    while (shellId != (transitionManager->ReachableAugerShell(Z,shellNum)->FinalShellId()) ) ;
      }
      /*    {

      if(shellNum == maxNumOfShells-1)
        {
          G4Exception("G4RDAtomicDeexcitation: No Auger tramsition found");
        }
      shellNum++;
      }*/
    



      // Now we have that shellnum is the shellIndex of the shell named ShellId

      //      G4cout << " the index of the shell is: "<<shellNum<<G4endl;

      // But we have now to select two shells: one for the transition, 
      // and another for the auger emission.

      G4int transitionLoopShellIndex = 0;      
      G4double partSum = 0;
      const G4RDAugerTransition* anAugerTransition = 
            transitionManager->ReachableAugerShell(Z,shellNum);

      //      G4cout << " corresponding to the ID: "<< anAugerTransition->FinalShellId() << G4endl;


      G4int transitionSize = 
            (anAugerTransition->TransitionOriginatingShellIds())->size();
      while (transitionLoopShellIndex < transitionSize) {

        std::vector<G4int>::const_iterator pos = 
               anAugerTransition->TransitionOriginatingShellIds()->begin();

        G4int transitionLoopShellId = *(pos+transitionLoopShellIndex);
        G4int numberOfPossibleAuger = 
              (anAugerTransition->AugerTransitionProbabilities(transitionLoopShellId))->size();
        G4int augerIndex = 0;
        //      G4int partSum2 = 0;


    if (augerIndex < numberOfPossibleAuger) {
      
      do 
        {
          G4double thisProb = anAugerTransition->AugerTransitionProbability(augerIndex, 
                                        transitionLoopShellId);
          partSum += thisProb;
          augerIndex++;
          
        } while (augerIndex < numberOfPossibleAuger);
        }
        transitionLoopShellIndex++;
      }
      


      // Now we have the entire probability of an auger transition for the vacancy 
      // located in shellNum (index of shellId) 

      // AM *********************** F I X E D **************************** AM
      // Here we duplicate the previous loop, this time looking to the sum of the probabilities 
      // to be under the random number shoot by G4 UniformRdandom. This could have been done in the 
      // previuos loop, while integrating the probabilities. There is a bug that will be fixed 
      // 5 minutes from now: a line:
      // G4int numberOfPossibleAuger = (anAugerTransition->
      // AugerTransitionProbabilities(transitionLoopShellId))->size();
      // to be inserted.
      // AM *********************** F I X E D **************************** AM

      // Remains to get the same result with a single loop.

      // AM *********************** F I X E D **************************** AM
      // Another Bug: in EADL Auger Transition are normalized to all the transitions deriving from 
      // a vacancy in one shell, but not all of these are present in data tables. So if a transition 
      // doesn't occur in the main one a local energy deposition must occur, instead of (like now) 
      // generating the last transition present in EADL data.
      // AM *********************** F I X E D **************************** AM


      G4double totalVacancyAugerProbability = partSum;


      //And now we start to select the right auger transition and emission
      G4int transitionRandomShellIndex = 0;
      G4int transitionRandomShellId = 1;
      G4int augerIndex = 0;
      partSum = 0; 
      G4double partialProb = G4UniformRand();
      // G4int augerOriginatingShellId = 0;
      
      G4int numberOfPossibleAuger = 
      (anAugerTransition->AugerTransitionProbabilities(transitionRandomShellId))->size();
      G4bool foundFlag = false;

      while (transitionRandomShellIndex < transitionSize) {

        std::vector<G4int>::const_iterator pos = 
               anAugerTransition->TransitionOriginatingShellIds()->begin();

        transitionRandomShellId = *(pos+transitionRandomShellIndex);
        
    augerIndex = 0;
    numberOfPossibleAuger = (anAugerTransition-> 
                 AugerTransitionProbabilities(transitionRandomShellId))->size();

        while (augerIndex < numberOfPossibleAuger) {
      G4double thisProb =anAugerTransition->AugerTransitionProbability(augerIndex, 
                                       transitionRandomShellId);

          partSum += thisProb;
          
          if (partSum >= (partialProb*totalVacancyAugerProbability) ) { // was /
        foundFlag = true;
        break;
      }
          augerIndex++;
        }
        if (partSum >= (partialProb*totalVacancyAugerProbability) ) {break;} // was /
        transitionRandomShellIndex++;
      }

      // Now we have the index of the shell from wich comes the auger electron (augerIndex), 
      // and the id of the shell, from which the transition e- come (transitionRandomShellid)
      // If no Transition has been found, 0 is returned.  

      if (!foundFlag) {return 0;}      
      
      // Isotropic angular distribution for the outcoming e-
      G4double newcosTh = 1.-2.*G4UniformRand();
      G4double  newsinTh = std::sqrt(1.-newcosTh*newcosTh);
      G4double newPhi = twopi*G4UniformRand();
      
      G4double xDir =  newsinTh*std::sin(newPhi);
      G4double yDir = newsinTh*std::cos(newPhi);
      G4double zDir = newcosTh;
      
      G4ThreeVector newElectronDirection(xDir,yDir,zDir);
      
      // energy of the auger electron emitted
      
      
      G4double transitionEnergy = anAugerTransition->AugerTransitionEnergy(augerIndex, transitionRandomShellId);
      /*
    G4cout << "AUger TransitionId " << anAugerTransition->FinalShellId() << G4endl;
    G4cout << "augerIndex: " << augerIndex << G4endl;
    G4cout << "transitionShellId: " << transitionRandomShellId << G4endl;
      */
      
      // This is the shell where the new vacancy is: it is the same
      // shell where the electron came from
      newShellId = transitionRandomShellId;
      
      
      G4DynamicParticle* newPart = new G4DynamicParticle(G4Electron::Electron(), 
                             newElectronDirection,
                             transitionEnergy);
      return newPart;

    }
  else 
    {
      //G4Exception("G4RDAtomicDeexcitation: no auger transition found");
      return 0;
    }
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateFluorescence()

G4DynamicParticle * G4RDAtomicDeexcitation::GenerateFluorescence ( G4int  Z, G4int  shellId, G4int  provShellId  )

private

Definition at line 211 of file G4RDAtomicDeexcitation.cc.

{ 


  const G4RDAtomicTransitionManager*  transitionManager = G4RDAtomicTransitionManager::Instance();
  //  G4int provenienceShell = provShellId;

  //isotropic angular distribution for the outcoming photon
  G4double newcosTh = 1.-2.*G4UniformRand();
  G4double  newsinTh = std::sqrt(1.-newcosTh*newcosTh);
  G4double newPhi = twopi*G4UniformRand();
  
  G4double xDir =  newsinTh*std::sin(newPhi);
  G4double yDir = newsinTh*std::cos(newPhi);
  G4double zDir = newcosTh;
  
  G4ThreeVector newGammaDirection(xDir,yDir,zDir);
  
  G4int shellNum = 0;
  G4int maxNumOfShells = transitionManager->NumberOfReachableShells(Z);
  
  // find the index of the shell named shellId
  while (shellId != transitionManager->
     ReachableShell(Z,shellNum)->FinalShellId())
    {
      if(shellNum == maxNumOfShells-1)
    {
      break;
    }
      shellNum++;
    }
  // number of shell from wich an electron can reach shellId
  size_t transitionSize = transitionManager->
    ReachableShell(Z,shellNum)->OriginatingShellIds().size();
  
  size_t index = 0;
  
  // find the index of the shell named provShellId in the vector
  // storing the shells from which shellId can be reached 
  while (provShellId != transitionManager->
     ReachableShell(Z,shellNum)->OriginatingShellId(index))
    {
      if(index ==  transitionSize-1)
    {
      break;
    }
      index++;
    }
  // energy of the gamma leaving provShellId for shellId
  G4double transitionEnergy = transitionManager->
    ReachableShell(Z,shellNum)->TransitionEnergy(index);
  
  // This is the shell where the new vacancy is: it is the same
  // shell where the electron came from
  newShellId = transitionManager->
    ReachableShell(Z,shellNum)->OriginatingShellId(index);
  
  
  G4DynamicParticle* newPart = new G4DynamicParticle(G4Gamma::Gamma(), 
                             newGammaDirection,
                             transitionEnergy);
  return newPart;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateParticles()

std::vector< G4DynamicParticle * > * G4RDAtomicDeexcitation::GenerateParticles	(	G4int	Z,
		G4int	shellId
	)

Definition at line 59 of file G4RDAtomicDeexcitation.cc.

{ 

  std::vector<G4DynamicParticle*>* vectorOfParticles;
  
  vectorOfParticles = new std::vector<G4DynamicParticle*>;
  G4DynamicParticle* aParticle;
  G4int provShellId = 0;
  G4int counter = 0;
  
  // The aim of this loop is to generate more than one fluorecence photon 
  // from the same ionizing event 
  do
    {
      if (counter == 0) 
    // First call to GenerateParticles(...):
    // givenShellId is given by the process
    {
      provShellId = SelectTypeOfTransition(Z, givenShellId);
      //std::cout << "AtomicDeexcitation::Generate counter 0 - provShellId = "
      //<< provShellId << std::endl;

      if  ( provShellId >0) 
        {
          aParticle = GenerateFluorescence(Z,givenShellId,provShellId);  
          //std::cout << "AtomicDeexcitation::Generate Fluo counter 0 " << std::endl;
        }
      else if ( provShellId == -1)
        {
          aParticle = GenerateAuger(Z, givenShellId);
          //std::cout << "AtomicDeexcitation::Generate Auger counter 0 " << std::endl;
        }
      else
        {
          G4Exception("G4RDAtomicDeexcitation::GenerateParticles()",
                          "InvalidSetup", FatalException,
                          "Starting shell uncorrect: check it!");
        }
    }
      else 
    // Following calls to GenerateParticles(...):
    // newShellId is given by GenerateFluorescence(...)
    {
      provShellId = SelectTypeOfTransition(Z,newShellId);
      //std::cout << "AtomicDeexcitation::Generate counter 0 - provShellId = "
      //<< provShellId << ", new ShellId = "<< newShellId
      //<< std::endl;


      if  (provShellId >0)
        {
          aParticle = GenerateFluorescence(Z,newShellId,provShellId);
          //std::cout << "AtomicDeexcitation::Generate Fluo " << std::endl;
        }
      else if ( provShellId == -1)
        {
          aParticle = GenerateAuger(Z, newShellId);
          //std::cout << "AtomicDeexcitation::Generate Auger " << std::endl;
        }
      else
        {
          G4Exception("G4RDAtomicDeexcitation::GenerateParticles()",
                          "InvalidSetup", FatalException,
                          "Starting shell uncorrect: check it!");
        }
    }
      counter++;
      if (aParticle != 0) {vectorOfParticles->push_back(aParticle);}
      else {provShellId = -2;}
    }
  
  // Look this in a particular way: only one auger emitted! //
  while (provShellId > -2); 
  
  return vectorOfParticles;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SelectTypeOfTransition()

G4int G4RDAtomicDeexcitation::SelectTypeOfTransition ( G4int  Z, G4int  shellId  )

private

Definition at line 136 of file G4RDAtomicDeexcitation.cc.

{
  if (shellId <=0 ) 
    {
      G4Exception("G4RDAtomicDeexcitation::SelectTypeOfTransition()",
                  "InvalidCondition", FatalException,
                  "Zero or negative shellId!");
    }

  const G4RDAtomicTransitionManager*  transitionManager = 
        G4RDAtomicTransitionManager::Instance();
  G4int provShellId = -1;
  G4int shellNum = 0;
  G4int maxNumOfShells = transitionManager->NumberOfReachableShells(Z);  
  
  //std::cout << "AtomicDeexcitation::SelectType -  NumberOfReachableShells = "
  //<< maxNumOfShells<< std::endl;

  const G4RDFluoTransition* refShell = transitionManager->ReachableShell(Z,maxNumOfShells-1);

  // This loop gives shellNum the value of the index of shellId
  // in the vector storing the list of the shells reachable through
  // a radiative transition
  if ( shellId <= refShell->FinalShellId())
    {
      while (shellId != transitionManager->ReachableShell(Z,shellNum)->FinalShellId())
    {
      if(shellNum ==maxNumOfShells-1)
        {
          break;
        }
      shellNum++;
    }
      G4int transProb = 0; //AM change 29/6/07 was 1
   
      G4double partialProb = G4UniformRand();      
      G4double partSum = 0;
      const G4RDFluoTransition* aShell = transitionManager->ReachableShell(Z,shellNum);      
      G4int trSize =  (aShell->TransitionProbabilities()).size();
    
      // Loop over the shells wich can provide an electron for a 
      // radiative transition towards shellId:
      // in every loop the partial sum of the first transProb shells
      // is calculated and compared with a random number [0,1].
      // If the partial sum is greater, the shell whose index is transProb
      // is chosen as the starting shell for a radiative transition
      // and its identity is returned
      // Else, terminateded the loop, -1 is returned
      while(transProb < trSize){
    
     partSum += aShell->TransitionProbability(transProb);

     if(partialProb <= partSum)
       {
         provShellId = aShell->OriginatingShellId(transProb);
         break;
       }
     transProb++;
      }

      // here provShellId is the right one or is -1.
      // if -1, the control is passed to the Auger generation part of the package 
    }



  else 
    {
 
     provShellId = -1;

    }
  return provShellId;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetCutForAugerElectrons()

void G4RDAtomicDeexcitation::SetCutForAugerElectrons

(

G4double

cut

)

Definition at line 502 of file G4RDAtomicDeexcitation.cc.

{
  minElectronEnergy = cut;
}

Here is the caller graph for this function:

SetCutForSecondaryPhotons()

void G4RDAtomicDeexcitation::SetCutForSecondaryPhotons

(

G4double

cut

)

Definition at line 497 of file G4RDAtomicDeexcitation.cc.

{
  minGammaEnergy = cut;
}

Here is the caller graph for this function:

Member Data Documentation

augerVacancyId

G4int G4RDAtomicDeexcitation::augerVacancyId

private

Definition at line 96 of file G4RDAtomicDeexcitation.hh.

fAuger

G4bool G4RDAtomicDeexcitation::fAuger

private

Definition at line 92 of file G4RDAtomicDeexcitation.hh.

minElectronEnergy

G4double G4RDAtomicDeexcitation::minElectronEnergy

private

Definition at line 91 of file G4RDAtomicDeexcitation.hh.

minGammaEnergy

G4double G4RDAtomicDeexcitation::minGammaEnergy

private

Definition at line 90 of file G4RDAtomicDeexcitation.hh.

newShellId

G4int G4RDAtomicDeexcitation::newShellId

private

Definition at line 88 of file G4RDAtomicDeexcitation.hh.

---

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

• G4RDAtomicDeexcitation.hh
• G4RDAtomicDeexcitation.cc