G4NuclearDecayChannel Class Reference

#include <G4NuclearDecayChannel.hh>

Inheritance diagram for G4NuclearDecayChannel:

Public Member Functions
	G4NuclearDecayChannel (const G4RadioactiveDecayMode &, G4int Verbose)
	G4NuclearDecayChannel (const G4RadioactiveDecayMode &theMode, G4int Verbose, const G4ParticleDefinition *theParentNucleus, G4double theBR, G4double theQtransition, G4int A, G4int Z, G4double theDaughterExcitation)
	G4NuclearDecayChannel (const G4RadioactiveDecayMode &theMode, G4int Verbose, const G4ParticleDefinition *theParentNucleus, G4double theBR, G4double theQtransition, G4int A, G4int Z, G4double theDaughterExcitation, const G4String theDaughterName1)
	G4NuclearDecayChannel (const G4RadioactiveDecayMode &theMode, G4int Verbose, const G4ParticleDefinition *theParentNucleus, G4double theBR, G4double, G4bool, CLHEP::RandGeneral *randBeta, G4double theQtransition, G4int A, G4int Z, G4double theDaughterExcitation, const G4String theDaughterName1, const G4String theDaughterName2)
	~G4NuclearDecayChannel ()
G4DecayProducts *	DecayIt (G4double theParentMass)
void	SetHLThreshold (G4double hl)
void	SetICM (G4bool icm)
void	SetARM (G4bool arm)
G4RadioactiveDecayMode	GetDecayMode ()
G4double	GetDaughterExcitation ()
G4ParticleDefinition *	GetDaughterNucleus ()
Public Member Functions inherited from G4GeneralPhaseSpaceDecay
	G4GeneralPhaseSpaceDecay (G4int Verbose=1)
	G4GeneralPhaseSpaceDecay (const G4String &theParentName, G4double theBR, G4int theNumberOfDaughters, const G4String &theDaughterName1, const G4String &theDaughterName2="", const G4String &theDaughterName3="")
	G4GeneralPhaseSpaceDecay (const G4String &theParentName, G4double theParentMass, G4double theBR, G4int theNumberOfDaughters, const G4String &theDaughterName1, const G4String &theDaughterName2="", const G4String &theDaughterName3="")
	G4GeneralPhaseSpaceDecay (const G4String &theParentName, G4double theParentMass, G4double theBR, G4int theNumberOfDaughters, const G4String &theDaughterName1, const G4String &theDaughterName2, const G4String &theDaughterName3, const G4double *masses)
virtual	~G4GeneralPhaseSpaceDecay ()
G4double	GetParentMass () const
void	SetParentMass (const G4double aParentMass)
virtual G4DecayProducts *	DecayIt (G4double mass=0.0)
Public Member Functions inherited from G4VDecayChannel
	G4VDecayChannel (const G4String &aName, G4int Verbose=1)
	G4VDecayChannel (const G4String &aName, const G4String &theParentName, G4double theBR, G4int theNumberOfDaughters, const G4String &theDaughterName1, const G4String &theDaughterName2="", const G4String &theDaughterName3="", const G4String &theDaughterName4="")
virtual	~G4VDecayChannel ()
G4int	operator== (const G4VDecayChannel &right) const
G4int	operator!= (const G4VDecayChannel &right) const
G4int	operator< (const G4VDecayChannel &right) const
virtual G4DecayProducts *	DecayIt (G4double parentMass=-1.0)=0
const G4String &	GetKinematicsName () const
G4double	GetBR () const
G4int	GetNumberOfDaughters () const
G4ParticleDefinition *	GetParent ()
G4ParticleDefinition *	GetDaughter (G4int anIndex)
G4int	GetAngularMomentum ()
const G4String &	GetParentName () const
const G4String &	GetDaughterName (G4int anIndex) const
G4double	GetParentMass () const
G4double	GetDaughterMass (G4int anIndex) const
void	SetParent (const G4ParticleDefinition *particle_type)
void	SetParent (const G4String &particle_name)
void	SetBR (G4double value)
void	SetNumberOfDaughters (G4int value)
void	SetDaughter (G4int anIndex, const G4ParticleDefinition *particle_type)
void	SetDaughter (G4int anIndex, const G4String &particle_name)
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
void	DumpInfo ()

Protected Attributes
G4RadioactiveDecayMode	decayMode
G4double	daughterExcitation
G4int	daughterA
G4int	daughterZ
G4ParticleDefinition *	daughterNucleus
G4DynamicParticle *	dynamicDaughter
G4double	Qtransition
G4double	halflifethreshold
G4bool	applyICM
G4bool	applyARM
CLHEP::RandGeneral *	RandomEnergy
Protected Attributes inherited from G4VDecayChannel
G4String	kinematics_name
G4double	rbranch
G4int	numberOfDaughters
G4String *	parent_name
G4String **	daughters_name
G4ParticleTable *	particletable
G4ParticleDefinition *	parent
G4ParticleDefinition **	daughters
G4double	parent_mass
G4double *	daughters_mass
G4int	verboseLevel

Static Protected Attributes
static const G4double	pTolerance = 0.001
static const G4double	levelTolerance = 2.0*keV
Static Protected Attributes inherited from G4VDecayChannel
static const G4String	noName = " "

Additional Inherited Members
Static Public Member Functions inherited from G4GeneralPhaseSpaceDecay
static G4double	Pmx (G4double e, G4double p1, G4double p2)
Protected Member Functions inherited from G4GeneralPhaseSpaceDecay
G4DecayProducts *	OneBodyDecayIt ()
G4DecayProducts *	TwoBodyDecayIt ()
G4DecayProducts *	ThreeBodyDecayIt ()
G4DecayProducts *	ManyBodyDecayIt ()
Protected Member Functions inherited from G4VDecayChannel
	G4VDecayChannel ()
	G4VDecayChannel (const G4VDecayChannel &)
G4VDecayChannel &	operator= (const G4VDecayChannel &)
void	ClearDaughtersName ()
void	FillDaughters ()
void	FillParent ()

Detailed Description

Definition at line 42 of file G4NuclearDecayChannel.hh.

Constructor & Destructor Documentation

G4NuclearDecayChannel() [1/4]

G4NuclearDecayChannel::G4NuclearDecayChannel ( const G4RadioactiveDecayMode &  , G4int  Verbose  )

inline

Definition at line 55 of file G4NuclearDecayChannel.hh.

                                                                      :
    G4GeneralPhaseSpaceDecay(Verbose) {;}

G4NuclearDecayChannel() [2/4]

G4NuclearDecayChannel::G4NuclearDecayChannel	(	const G4RadioactiveDecayMode &	theMode,
		G4int	Verbose,
		const G4ParticleDefinition *	theParentNucleus,
		G4double	theBR,
		G4double	theQtransition,
		G4int	A,
		G4int	Z,
		G4double	theDaughterExcitation
	)

Definition at line 96 of file G4NuclearDecayChannel.cc.

 :G4GeneralPhaseSpaceDecay(Verbose), decayMode(theMode), dynamicDaughter(0),
  RandomEnergy(0)
{
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    {G4cout <<"G4NuclearDecayChannel constructor for " <<G4int(theMode) <<G4endl;}
#endif
  SetParent(theParentNucleus);
  FillParent();
  parent_mass = theParentNucleus->GetPDGMass();
  SetBR (theBR);
  SetNumberOfDaughters (1);
  FillDaughterNucleus (0, A, Z, theDaughterExcitation);
  Qtransition = theQtransition;
  halflifethreshold = -1.*second;
  applyICM = true;
  applyARM = true;
}

G4NuclearDecayChannel() [3/4]

G4NuclearDecayChannel::G4NuclearDecayChannel	(	const G4RadioactiveDecayMode &	theMode,
		G4int	Verbose,
		const G4ParticleDefinition *	theParentNucleus,
		G4double	theBR,
		G4double	theQtransition,
		G4int	A,
		G4int	Z,
		G4double	theDaughterExcitation,
		const G4String	theDaughterName1
	)

Definition at line 127 of file G4NuclearDecayChannel.cc.

 :G4GeneralPhaseSpaceDecay(Verbose), decayMode(theMode), dynamicDaughter(0),
  RandomEnergy(0)
{
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    {G4cout <<"G4NuclearDecayChannel constructor for " <<G4int(theMode) <<G4endl;}
#endif
  SetParent (theParentNucleus);
  FillParent();
  parent_mass = theParentNucleus->GetPDGMass();
  SetBR (theBR);
  SetNumberOfDaughters (2);
  SetDaughter(0, theDaughterName1);
  FillDaughterNucleus (1, A, Z, theDaughterExcitation);
  Qtransition = theQtransition;
  halflifethreshold = -1.*second;
  applyICM = true;
  applyARM = true;
}

G4NuclearDecayChannel() [4/4]

G4NuclearDecayChannel::G4NuclearDecayChannel	(	const G4RadioactiveDecayMode &	theMode,
		G4int	Verbose,
		const G4ParticleDefinition *	theParentNucleus,
		G4double	theBR,
		G4double	,
		G4bool	,
		CLHEP::RandGeneral *	randBeta,
		G4double	theQtransition,
		G4int	A,
		G4int	Z,
		G4double	theDaughterExcitation,
		const G4String	theDaughterName1,
		const G4String	theDaughterName2
	)

Definition at line 160 of file G4NuclearDecayChannel.cc.

 :G4GeneralPhaseSpaceDecay(Verbose), decayMode(theMode), dynamicDaughter(0)
{
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    {G4cout <<"G4NuclearDecayChannel constructor for " <<G4int(theMode) <<G4endl;}
#endif
  SetParent (theParentNucleus);
  FillParent();
  parent_mass = theParentNucleus->GetPDGMass();
  SetBR (theBR);
  SetNumberOfDaughters (3);
  SetDaughter(0, theDaughterName1);
  SetDaughter(2, theDaughterName2);
  FillDaughterNucleus(1, A, Z, theDaughterExcitation);
  RandomEnergy = randBeta;
  Qtransition = theQtransition;
  halflifethreshold = -1*second;
  applyICM = true;
  applyARM = true;
}

~G4NuclearDecayChannel()

G4NuclearDecayChannel::~G4NuclearDecayChannel ( )

inline

Definition at line 83 of file G4NuclearDecayChannel.hh.

{;} 

Member Function Documentation

DecayIt()

G4DecayProducts * G4NuclearDecayChannel::DecayIt ( G4double  theParentMass )

virtual

Reimplemented from G4GeneralPhaseSpaceDecay.

Definition at line 235 of file G4NuclearDecayChannel.cc.

{
  // Load the details of the parent and daughter particles if they have not
  // been defined properly
 
  if (parent == 0) FillParent();
  if (daughters == 0) FillDaughters();
 
  // We want to ensure that the difference between the total
  // parent and daughter masses equals the energy liberated by the transition.
 
  theParentMass = 0.0;
  for( G4int index=0; index < numberOfDaughters; index++)
    {theParentMass += daughters[index]->GetPDGMass();}
  theParentMass += Qtransition  ;
  // bug fix for beta+ decay (flei 25/09/01)
  if (decayMode == 2) theParentMass -= 2*0.511 * MeV;
  //
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1) {
    G4cout << "G4NuclearDecayChannel::DecayIt "<< G4endl;
    G4cout << "the decay mass = " << theParentMass << G4endl;
  }
#endif
 
  SetParentMass (theParentMass);
  
  // Define a product vector.
  G4DecayProducts* products = 0;
 
  // Depending upon the number of daughters, select the appropriate decay
  // kinematics scheme.
  switch (numberOfDaughters) {
    case 0:
      G4cerr << "G4NuclearDecayChannel::DecayIt ";
      G4cerr << " daughters not defined " <<G4endl;
      break;
    case 1:
      products = OneBodyDecayIt();
      break;
    case 2:
      products = TwoBodyDecayIt();
      break;
    case 3:
      products = BetaDecayIt();
      break;
    default:
      // G4cerr <<"Error in G4NuclearDecayChannel::DecayIt" <<G4endl;
      // G4cerr <<"Number of daughters in decay = " <<numberOfDaughters <<G4endl;
      // G4Exception(__FILE__, G4inttostring(__LINE__), FatalException,  "G4NuclearDecayChannel::DecayIt");
    {
      G4ExceptionDescription ed;
      ed << " More than 3 daughters in decay: N = " << numberOfDaughters
         << G4endl;
      G4Exception("G4NuclearDecayChannel::DecayIt()", "HAD_RDM_007",
                  FatalException, ed);
    }
  }
 
  if (products == 0) {
    G4ExceptionDescription ed;
    ed << " Parent nucleus " << *parent_name << " was not decayed " << G4endl;
    G4Exception("G4NuclearDecayChannel::DecayIt()", "HAD_RDM_008",
                JustWarning, ed);
    DumpInfo();
  } else {
 
    // If the decay is to an excited state of the daughter nuclide, we need
    // to apply the photo-evaporation process. This includes the IT decay mode itself.
 
    // Need to hold the shell idex after ICM
    G4int shellIndex = -1;
 
    if (daughterExcitation > 0.0) {
      // Pop the daughter nucleus off the product vector - we need to retain
      // the momentum of this particle.
 
      dynamicDaughter = products->PopProducts();
      G4LorentzVector daughterMomentum = dynamicDaughter->Get4Momentum();
      G4ThreeVector const daughterMomentum1(static_cast<const G4LorentzVector> (daughterMomentum));
 
      // Now define a G4Fragment with the correct A, Z and excitation,
      // and declare and initialise a G4PhotonEvaporation object    
      G4Fragment nucleus(daughterA, daughterZ, daughterMomentum);
      G4PhotonEvaporation* deexcitation = new G4PhotonEvaporation;
      deexcitation->SetVerboseLevel(GetVerboseLevel());
 
      // switch on/off internal electron conversion
      deexcitation->SetICM(applyICM);
 
      // Set the maximum life-time for a level that will be treated
      // Level with life-time longer than this will be outputed as meta-stable
      // isotope
      deexcitation->SetMaxHalfLife(halflifethreshold);
 
      // but in IT mode, we need to force the transition 
      if (decayMode == 0) {
        deexcitation->RDMForced(true);
      } else {
        deexcitation->RDMForced(false);
      }
 
      //////////////////////////////////////////////////////////////////////////
      //                                                                      //
      //  Now apply photo-evaporation                                         //
      //  Use BreakUp() so limit to one transition at a time, if ICM is       //
      //  requested.                                                          //
      //                                                                      //
      //////////////////////////////////////////////////////////////////////////
      //  this change is related to bug #1001  (F.Lei 07/05/2010)
 
      G4FragmentVector* gammas = 0; 
      if (applyICM) {
        gammas = deexcitation->BreakUp(nucleus);    
      } else {
        gammas = deexcitation->BreakItUp(nucleus);
      }
 
      // the returned G4FragmentVector contains the residual nuclide
      // as its last entry.
      G4int nGammas=gammas->size()-1;
 
      // Go through each gamma/e- and add it to the decay product.  The angular
      // distribution of the gammas is isotropic, and the residual nucleus is
      // assumed not to have suffered any recoil as a result of this de-excitation.
      for (G4int ig = 0; ig < nGammas; ig++) {
        G4DynamicParticle* theGammaRay =
          new G4DynamicParticle(gammas->operator[](ig)->GetParticleDefinition(),
                                gammas->operator[](ig)->GetMomentum());
        theGammaRay -> SetProperTime(gammas->operator[](ig)->GetCreationTime());
        products->PushProducts (theGammaRay);
      }
 
      // now the nucleus
      G4double finalDaughterExcitation = gammas->operator[](nGammas)->GetExcitationEnergy();
      // f.lei (03/01/03) this is needed to fix the crach in test18 
      if (finalDaughterExcitation <= 1.0*keV) finalDaughterExcitation = 0;
      
      if (dynamicDaughter) delete dynamicDaughter;
      
      G4IonTable* theIonTable =
          (G4IonTable*)(G4ParticleTable::GetParticleTable()->GetIonTable());      
      dynamicDaughter = new G4DynamicParticle(
                  theIonTable->GetIon(daughterZ,daughterA,finalDaughterExcitation),
                  daughterMomentum1);
      products->PushProducts (dynamicDaughter); 
      
      // retrive the ICM shell index
      shellIndex = deexcitation->GetVacantShellNumber();
      
      // Delete/reset variables associated with the gammas.
      while (!gammas->empty()) {
        delete *(gammas->end()-1);
        gammas->pop_back();
      }
      delete gammas;
      delete deexcitation;
    } // if daughter excitation > 0
 
    // Now take care of the EC products which have to go through the ARM
    G4int eShell = -1;
    if (decayMode == 3 || decayMode == 4 || decayMode == 5) {
      switch (decayMode)
        {
        case KshellEC:
      //
      {
            eShell = 0; // --> 0 from 1 (f.lei 30/4/2008)
          }
          break;
        case LshellEC:
      //
          {
            eShell = G4int(G4UniformRand()*3)+1;
          }
          break;
        case MshellEC:
      //
          {
            // limit the shell index to 6 as specified by the ARM (F.Lei 06/05/2010)
            // eShell = G4int(G4UniformRand()*5)+4;
            eShell = G4int(G4UniformRand()*3)+4;
          }
          break;
        case ERROR:
        default:
        G4Exception("G4NuclearDecayChannel::DecayIt()", "HAD_RDM_009",
                    FatalException, "Incorrect decay mode selection");
        }
    } else {
      // For other cases eShell comes from shellIndex resulting from  the photo decay
      // modeled by G4PhotonEvaporation* de-excitation (see above)
      eShell = shellIndex;
    }
 
    // now apply ARM if it is requested and there is a vaccancy
    if (applyARM && eShell != -1) {
      G4int aZ = daughterZ;
 
      // V.Ivanchenko migration to new interface to atomic deexcitation
      // no check on index of G4MaterialCutsCouple, simplified 
      // check on secondary energy Esec < 0.1 keV
      G4VAtomDeexcitation* atomDeex =
               G4LossTableManager::Instance()->AtomDeexcitation();
      if (atomDeex) {
        if(atomDeex->IsFluoActive() && aZ > 5 && aZ < 100) {  // only applies to 5< Z <100 
          if (eShell >= G4AtomicShells::GetNumberOfShells(aZ)){
            eShell = G4AtomicShells::GetNumberOfShells(aZ)-1;
          }
          G4AtomicShellEnumerator as = G4AtomicShellEnumerator(eShell);
          const G4AtomicShell* shell = atomDeex->GetAtomicShell(aZ, as);    
          std::vector<G4DynamicParticle*> armProducts;
          const G4double deexLimit = 0.1*keV;
          atomDeex->GenerateParticles(&armProducts, shell, aZ, deexLimit, deexLimit);
          size_t narm = armProducts.size();
          if (narm > 0) {
        // L.Desorgher: need to initialize dynamicDaughter in some decay
            // cases (for example Hg194)
        dynamicDaughter = products->PopProducts();
        G4ThreeVector bst = dynamicDaughter->Get4Momentum().boostVector();
            for (size_t i = 0; i<narm; ++i) {
              G4DynamicParticle* dp = armProducts[i];
              G4LorentzVector lv = dp->Get4Momentum().boost(bst);
              dp->Set4Momentum(lv);
              products->PushProducts(dp);
            }
            products->PushProducts(dynamicDaughter);
          }
        }
      }
    }
  } // Parent nucleus decayed
  /*
 
    if (atomDeex && aZ > 5 && aZ < 100) {  // only applies to 5< Z <100 
      // Retrieve the corresponding identifier and binding energy of the selected shell
      const G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
 
      //check that eShell is smaller than the max number of shells
      //this to avoid a warning from transitionManager(otherwise the output is the same)
      //Correction to Bug 1662. L Desorgher (04/02/2011)
      if (eShell >= transitionManager->NumberOfShells(aZ)){
          eShell=transitionManager->NumberOfShells(aZ)-1;
      }
 
      const G4AtomicShell* shell = transitionManager->Shell(aZ, eShell);
      G4double bindingEnergy = shell->BindingEnergy();
      G4int shellId = shell->ShellId();
 
      G4AtomicDeexcitation* atomDeex = new G4AtomicDeexcitation();  
      //the default is no Auger electron generation. 
      // Switch it on/off here! 
      atomDeex->ActivateAugerElectronProduction(true);
      std::vector<G4DynamicParticle*>* armProducts = atomDeex->GenerateParticles(aZ,shellId);
 
      // pop up the daughter before insertion; 
      // f.lei (30/04/2008) check if the total kinetic energy is less than 
      // the shell binding energy; if true add the difference to the daughter to conserve the energy 
      dynamicDaughter = products->PopProducts();
      G4double tARMEnergy = 0.0; 
      for (size_t i = 0;  i < armProducts->size(); i++) {
    products->PushProducts ((*armProducts)[i]);
    tARMEnergy += (*armProducts)[i]->GetKineticEnergy();
      }
      if ((bindingEnergy - tARMEnergy) > 0.1*keV){
    G4double dEnergy = dynamicDaughter->GetKineticEnergy() + (bindingEnergy - tARMEnergy);
    dynamicDaughter->SetKineticEnergy(dEnergy);
      }
      products->PushProducts(dynamicDaughter); 
 
#ifdef G4VERBOSE
      if (GetVerboseLevel()>0)
    {
          G4cout <<"G4NuclearDecayChannel::Selected shell number for ARM =  " <<shellId <<G4endl;
      G4cout <<"G4NuclearDecayChannel::ARM products =  " <<armProducts->size()<<G4endl;
      G4cout <<"                 The binding energy =  " << bindingEnergy << G4endl;              
      G4cout <<"  Total ARM particle kinetic energy =  " << tARMEnergy << G4endl;              
    }
#endif   
 
      delete armProducts;
      delete atomDeex;
    }
  }
  */
  return products;
}

GetDaughterExcitation()

G4double G4NuclearDecayChannel::GetDaughterExcitation ( )

inline

Definition at line 102 of file G4NuclearDecayChannel.hh.

{return daughterExcitation;}

Referenced by G4RadioactiveDecay::AddDecayRateTable().

GetDaughterNucleus()

G4ParticleDefinition * G4NuclearDecayChannel::GetDaughterNucleus ( )

inline

Definition at line 105 of file G4NuclearDecayChannel.hh.

{return daughterNucleus;}

Referenced by G4RadioactiveDecay::AddDecayRateTable().

GetDecayMode()

G4RadioactiveDecayMode G4NuclearDecayChannel::GetDecayMode ( )

inline

Definition at line 99 of file G4NuclearDecayChannel.hh.

{return decayMode;}

Referenced by G4RadioactiveDecay::AddDecayRateTable(), and G4RadioactiveDecay::LoadDecayTable().

SetARM()

void G4NuclearDecayChannel::SetARM ( G4bool  arm )

inline

Definition at line 96 of file G4NuclearDecayChannel.hh.

{applyARM = arm;}

Referenced by G4RadioactiveDecay::LoadDecayTable().

SetHLThreshold()

void G4NuclearDecayChannel::SetHLThreshold ( G4double  hl )

inline

Definition at line 90 of file G4NuclearDecayChannel.hh.

{halflifethreshold = hl;}

Referenced by G4RadioactiveDecay::LoadDecayTable().

SetICM()

void G4NuclearDecayChannel::SetICM ( G4bool  icm )

inline

Definition at line 93 of file G4NuclearDecayChannel.hh.

{applyICM = icm;}

Referenced by G4RadioactiveDecay::LoadDecayTable().

Member Data Documentation

applyARM

G4bool G4NuclearDecayChannel::applyARM

protected

Definition at line 147 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt(), G4NuclearDecayChannel(), and SetARM().

applyICM

G4bool G4NuclearDecayChannel::applyICM

protected

Definition at line 146 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt(), G4NuclearDecayChannel(), and SetICM().

daughterA

G4int G4NuclearDecayChannel::daughterA

protected

Definition at line 140 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt().

daughterExcitation

G4double G4NuclearDecayChannel::daughterExcitation

protected

Definition at line 139 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt(), and GetDaughterExcitation().

daughterNucleus

G4ParticleDefinition* G4NuclearDecayChannel::daughterNucleus

protected

Definition at line 142 of file G4NuclearDecayChannel.hh.

Referenced by GetDaughterNucleus().

daughterZ

G4int G4NuclearDecayChannel::daughterZ

protected

Definition at line 141 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt().

decayMode

G4RadioactiveDecayMode G4NuclearDecayChannel::decayMode

protected

Definition at line 136 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt(), and GetDecayMode().

dynamicDaughter

G4DynamicParticle* G4NuclearDecayChannel::dynamicDaughter

protected

Definition at line 143 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt().

halflifethreshold

G4double G4NuclearDecayChannel::halflifethreshold

protected

Definition at line 145 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt(), G4NuclearDecayChannel(), and SetHLThreshold().

levelTolerance

const G4double G4NuclearDecayChannel::levelTolerance = 2.0*keV

staticprotected

Definition at line 138 of file G4NuclearDecayChannel.hh.

pTolerance

const G4double G4NuclearDecayChannel::pTolerance = 0.001

staticprotected

Definition at line 137 of file G4NuclearDecayChannel.hh.

Qtransition

G4double G4NuclearDecayChannel::Qtransition

protected

Definition at line 144 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt(), and G4NuclearDecayChannel().

RandomEnergy

CLHEP::RandGeneral* G4NuclearDecayChannel::RandomEnergy

protected

Definition at line 148 of file G4NuclearDecayChannel.hh.

Referenced by G4NuclearDecayChannel().

---

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

• G4NuclearDecayChannel.hh
• G4NuclearDecayChannel.cc