G4DiscreteGammaTransition Class Reference

#include <G4DiscreteGammaTransition.hh>

Inheritance diagram for G4DiscreteGammaTransition:

Public Member Functions
	G4DiscreteGammaTransition (const G4NuclearLevel &level, G4int Z, G4int A)
virtual	~G4DiscreteGammaTransition ()
virtual void	SetEnergyFrom (G4double energy)
virtual G4double	GetGammaEnergy ()
virtual G4double	GetGammaCreationTime ()
virtual void	SelectGamma ()
void	SetICM (G4bool ic)
G4bool	GetICM () const
G4double	GetBondEnergy ()
G4int	GetOrbitNumber ()
G4bool	IsAGamma ()
Public Member Functions inherited from G4VGammaTransition
	G4VGammaTransition ()
virtual	~G4VGammaTransition ()
virtual void	SelectGamma ()=0
virtual G4double	GetGammaEnergy ()=0
virtual G4double	GetGammaCreationTime ()=0
virtual void	SetEnergyFrom (G4double energy)=0

Additional Inherited Members
Protected Attributes inherited from G4VGammaTransition
G4int	_verbose

Detailed Description

Definition at line 79 of file G4DiscreteGammaTransition.hh.

Constructor & Destructor Documentation

G4DiscreteGammaTransition()

G4DiscreteGammaTransition::G4DiscreteGammaTransition	(	const G4NuclearLevel &	level,
		G4int	Z,
		G4int	A
	)

Definition at line 75 of file G4DiscreteGammaTransition.cc.

                                                                                                 : 
  _nucleusZ(Z), _orbitE(-1), _bondE(0.), _aGamma(true), _icm(false), _gammaEnergy(0.), 
  _level(level), _excitation(0.),  _gammaCreationTime(0.),_A(A),_Z(Z)
{
  _levelManager = 0;
  _verbose = 0;
  //JMQ: added tolerence in the mismatch
  //VI:  increased tolerence 
  _tolerance = 10*CLHEP::keV;
}

~G4DiscreteGammaTransition()

G4DiscreteGammaTransition::~G4DiscreteGammaTransition ( )

virtual

Definition at line 86 of file G4DiscreteGammaTransition.cc.

{}

Member Function Documentation

GetBondEnergy()

G4double G4DiscreteGammaTransition::GetBondEnergy ( )

inline

Definition at line 100 of file G4DiscreteGammaTransition.hh.

{return _bondE;};

Referenced by G4VGammaDeexcitation::GenerateGamma().

GetGammaCreationTime()

G4double G4DiscreteGammaTransition::GetGammaCreationTime ( )

virtual

Implements G4VGammaTransition.

Definition at line 232 of file G4DiscreteGammaTransition.cc.

{
  return _gammaCreationTime;
}

GetGammaEnergy()

G4double G4DiscreteGammaTransition::GetGammaEnergy ( )

virtual

Implements G4VGammaTransition.

Definition at line 227 of file G4DiscreteGammaTransition.cc.

{
  return _gammaEnergy;
}

GetICM()

G4bool G4DiscreteGammaTransition::GetICM ( ) const

inline

Definition at line 99 of file G4DiscreteGammaTransition.hh.

{ return _icm;};

Referenced by G4VGammaDeexcitation::GenerateGamma().

GetOrbitNumber()

G4int G4DiscreteGammaTransition::GetOrbitNumber ( )

inline

Definition at line 101 of file G4DiscreteGammaTransition.hh.

{return _orbitE;};

Referenced by G4VGammaDeexcitation::GenerateGamma().

IsAGamma()

G4bool G4DiscreteGammaTransition::IsAGamma ( )

inline

Definition at line 102 of file G4DiscreteGammaTransition.hh.

{return _aGamma;};

Referenced by G4VGammaDeexcitation::GenerateGamma().

SelectGamma()

void G4DiscreteGammaTransition::SelectGamma ( )

virtual

Implements G4VGammaTransition.

Definition at line 89 of file G4DiscreteGammaTransition.cc.

{
  // default gamma 
  _aGamma = true;    
  _gammaEnergy = 0.;
  
  G4int nGammas = _level.NumberOfGammas();
  if (nGammas > 0)
    {
      G4int iGamma = 0;
      if(1 < nGammas) {
    G4double random = G4UniformRand();
      
    //G4cout << "G4DiscreteGammaTransition::SelectGamma  N= " 
    //       << nGammas << " rand= " << random << G4endl;
    for(iGamma=0; iGamma<nGammas; ++iGamma)
      {
        //G4cout << iGamma << "  prob= " 
        //     << (_level.GammaCumulativeProbabilities())[iGamma] << G4endl;
        if(random <= (_level.GammaCumulativeProbabilities())[iGamma])
          { break; }
      }
      }
      /*     
      G4cout << "Elevel(MeV)= " << _level.Energy()/MeV
         << " Etran(MeV)= " << (_level.GammaEnergies())[iGamma]/MeV
         << " Eexc(MeV)= " << _excitation/MeV << G4endl;
      */
 
      // VI: do not apply correction here in order do not make 
      //     double correction
      //G4double eCorrection = _level.Energy() - _excitation;      
      //_gammaEnergy = (_level.GammaEnergies())[iGamma] - eCorrection;
      _gammaEnergy = (_level.GammaEnergies())[iGamma];
            
      //JMQ: 
      //1)If chosen gamma energy is close enough to excitation energy, 
      //  the later is used instead for gamma dacey to gs (it guarantees 
      //  energy conservation)
      //2)For energy conservation, level energy differences instead of  
      //  tabulated gamma energies must be used (origin of final fake photons)
      
      // VI: remove fake photons - applied only for the last transition
      //     do not applied on each transition
      if(std::fabs(_excitation - _gammaEnergy) < _tolerance) { 
    _gammaEnergy =_excitation;
      }
 
      //  JMQ: Warning: the following check is needed to avoid loops:
      //  Due essentially to missing nuclear levels in data files, it is
      //  possible that _gammaEnergy is so low as the nucleus doesn't change
      //  its level after the transition.
      //  When such case is found, force the full deexcitation of the nucleus.
      //
      //    NOTE: you should force the transition to the next lower level,
      //          but this change needs a more complex revision of actual 
      //          design.
      //          I leave this for a later revision.
 
      // VI: the check has no sence and we make this very simple
      if (_gammaEnergy < _tolerance) { 
    _gammaEnergy = _excitation; 
      }
 
      //G4cout << "G4DiscreteGammaTransition::SelectGamma: " << _gammaEnergy 
      //         << " _icm: " << _icm << G4endl;
 
      // now decide whether Internal Coversion electron should be emitted instead
      if (_icm) {
    G4double random = G4UniformRand();
    if ( random <= (_level.TotalConvertionProbabilities())[iGamma]
         *(_level.GammaWeights())[iGamma]
         /((_level.TotalConvertionProbabilities())[iGamma]*(_level.GammaWeights())[iGamma]
           +(_level.GammaWeights())[iGamma])) 
      {
        G4int iShell = 9;
        random = G4UniformRand() ;
        if ( random <= (_level.KConvertionProbabilities())[iGamma]) 
          { iShell = 0;}
        else if ( random <= (_level.L1ConvertionProbabilities())[iGamma]) 
          { iShell = 1;}
        else if ( random <= (_level.L2ConvertionProbabilities())[iGamma]) 
          { iShell = 2;}
        else if ( random <= (_level.L3ConvertionProbabilities())[iGamma]) 
          { iShell = 3;}    
        else if ( random <= (_level.M1ConvertionProbabilities())[iGamma]) 
          { iShell = 4;}
        else if ( random <= (_level.M2ConvertionProbabilities())[iGamma]) 
          { iShell = 5;}
        else if ( random <= (_level.M3ConvertionProbabilities())[iGamma]) 
          { iShell = 6;}
        else if ( random <= (_level.M4ConvertionProbabilities())[iGamma]) 
          { iShell = 7;}
        else if ( random <= (_level.M5ConvertionProbabilities())[iGamma]) 
          { iShell = 8;}
        // the following is needed to match the ishell to that used in  G4AtomicShells
        if ( iShell == 9) {
          if ( (_nucleusZ < 28) && (_nucleusZ > 20)) {
        iShell--;
          } else if ( _nucleusZ == 20 || _nucleusZ == 19 ) {
        iShell = iShell -2;
          }
        }
        //L.Desorgher 02/11/2011
        //Atomic shell information is available in Geant4 only up top Z=100
        //To extend the photo evaporation code to Z>100  the call 
        // to G4AtomicShells::GetBindingEnergy should be forbidden for Z>100
        _bondE = 0.;
        if (_nucleusZ <=100)
        _bondE = G4AtomicShells::GetBindingEnergy(_nucleusZ, iShell);
        if (_verbose > 0) {
          G4cout << "G4DiscreteGammaTransition: _nucleusZ = " <<_nucleusZ 
             << " , iShell = " << iShell  
             << " , Shell binding energy = " << _bondE/keV
             << " keV " << G4endl;
        }
 
        // 09.05.2010 VI : it is an error - cannot subtract bond energy from 
        //                 transition energy here
        //_gammaEnergy = _gammaEnergy - _bondE; 
        //G4cout << "_gammaEnergy = " << _gammaEnergy << G4endl;
 
        _orbitE = iShell;     
        _aGamma = false ;   // emitted is not a gamma now 
      }
      }
      
      G4double tau = _level.HalfLife() / G4Pow::GetInstance()->logZ(2);
 
      //09.05.2010 VI rewrite samling of decay time 
      //              assuming ordinary exponential low
      _gammaCreationTime = 0.;      
      if(tau > 0.0) {  _gammaCreationTime = -tau*std::log(G4UniformRand()); }
 
    }
  return;
}

SetEnergyFrom()

void G4DiscreteGammaTransition::SetEnergyFrom ( G4double  energy )

virtual

Implements G4VGammaTransition.

Definition at line 237 of file G4DiscreteGammaTransition.cc.

{
  _excitation = energy;
}

SetICM()

void G4DiscreteGammaTransition::SetICM ( G4bool  ic )

inline

Definition at line 98 of file G4DiscreteGammaTransition.hh.

{ _icm = ic; };

Referenced by G4DiscreteGammaDeexcitation::CreateTransition().

---

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

• G4DiscreteGammaTransition.hh
• G4DiscreteGammaTransition.cc