G4NuclearDecayChannel Class Reference

#include <G4NuclearDecayChannel.hh>

Inheritance diagram for G4NuclearDecayChannel:

Public Member Functions
	G4NuclearDecayChannel (const G4RadioactiveDecayMode &theMode, 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 theFFN, G4bool betaS, G4RandGeneral *randBeta, G4double theQtransition, G4int A, G4int Z, G4double theDaughterExcitation, const G4String theDaughterName1, const G4String theDaughterName2)
virtual	~G4NuclearDecayChannel ()
G4DecayProducts *	DecayIt (G4double)
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)
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
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
const G4RadioactiveDecayMode	decayMode
G4double	daughterExcitation
G4int	daughterA
G4int	daughterZ
G4ParticleDefinition *	daughterNucleus
const G4double	Qtransition
G4double	halflifethreshold
G4bool	applyICM
G4bool	applyARM
G4RandGeneral *	RandomEnergy
Protected Attributes inherited from G4VDecayChannel
G4String	kinematics_name
G4double	rbranch
G4int	numberOfDaughters
G4String *	parent_name
G4String **	daughters_name
G4ParticleTable *	particletable
G4int	verboseLevel
G4ParticleDefinition *	G4MT_parent
G4ParticleDefinition **	G4MT_daughters
G4double	G4MT_parent_mass
G4double *	G4MT_daughters_mass

Static Protected Attributes
static const G4double	pTolerance = 0.001
static const G4double	levelTolerance = 2.0*keV
static G4ThreadLocal G4DynamicParticle *	dynamicDaughter = 0
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
void	ClearDaughtersName ()
void	FillDaughters ()
void	FillParent ()
	G4VDecayChannel ()
	G4VDecayChannel (const G4VDecayChannel &)
G4VDecayChannel &	operator= (const G4VDecayChannel &)

Detailed Description

Definition at line 41 of file G4NuclearDecayChannel.hh.

Constructor & Destructor Documentation

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

inline

Definition at line 54 of file G4NuclearDecayChannel.hh.

    : G4GeneralPhaseSpaceDecay(Verbose), decayMode(theMode),Qtransition(0) {;}

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

Definition at line 98 of file G4NuclearDecayChannel.cc.

References applyARM, applyICM, G4VDecayChannel::FillDaughters(), G4VDecayChannel::FillParent(), G4cout, G4endl, G4VDecayChannel::G4MT_parent_mass, G4ParticleDefinition::GetPDGMass(), G4VDecayChannel::GetVerboseLevel(), halflifethreshold, python.hepunit::nanosecond, G4VDecayChannel::SetBR(), G4VDecayChannel::SetNumberOfDaughters(), and G4VDecayChannel::SetParent().

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

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 130 of file G4NuclearDecayChannel.cc.

References applyARM, applyICM, G4VDecayChannel::FillDaughters(), G4VDecayChannel::FillParent(), G4cout, G4endl, G4VDecayChannel::G4MT_parent_mass, G4ParticleDefinition::GetPDGMass(), G4VDecayChannel::GetVerboseLevel(), halflifethreshold, python.hepunit::nanosecond, G4VDecayChannel::SetBR(), G4VDecayChannel::SetDaughter(), G4VDecayChannel::SetNumberOfDaughters(), and G4VDecayChannel::SetParent().

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

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

Definition at line 164 of file G4NuclearDecayChannel.cc.

References applyARM, applyICM, G4VDecayChannel::FillDaughters(), G4VDecayChannel::FillParent(), G4cout, G4endl, G4VDecayChannel::G4MT_parent_mass, G4ParticleDefinition::GetPDGMass(), G4VDecayChannel::GetVerboseLevel(), halflifethreshold, python.hepunit::nanosecond, RandomEnergy, G4VDecayChannel::SetBR(), G4VDecayChannel::SetDaughter(), G4VDecayChannel::SetNumberOfDaughters(), and G4VDecayChannel::SetParent().

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

  halflifethreshold = nanosecond;
  applyICM = true;
  applyARM = true;
  FillDaughters();
}

G4NuclearDecayChannel::~G4NuclearDecayChannel ( )

virtual

Definition at line 202 of file G4NuclearDecayChannel.cc.

{} 

Member Function Documentation

G4DecayProducts * G4NuclearDecayChannel::DecayIt ( G4double  )

virtual

Reimplemented from G4GeneralPhaseSpaceDecay.

Definition at line 238 of file G4NuclearDecayChannel.cc.

References applyARM, applyICM, G4LossTableManager::AtomDeexcitation(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), G4PhotonEvaporation::BreakUp(), daughterA, daughterExcitation, daughterZ, decayMode, G4VDecayChannel::DumpInfo(), dynamicDaughter, CLHEP::HepLorentzVector::e(), FatalException, G4endl, G4Exception(), G4VDecayChannel::G4MT_parent, G4UniformRand, G4VAtomDeexcitation::GenerateParticles(), G4DynamicParticle::Get4Momentum(), G4VAtomDeexcitation::GetAtomicShell(), G4IonTable::GetIon(), G4ParticleTable::GetIonTable(), G4AtomicShells::GetNumberOfShells(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), G4PhotonEvaporation::GetVacantShellNumber(), G4VDecayChannel::GetVerboseLevel(), G4LossTableManager::Instance(), G4VAtomDeexcitation::IsFluoActive(), JustWarning, python.hepunit::keV, KshellEC, LshellEC, MshellEC, G4VDecayChannel::numberOfDaughters, G4GeneralPhaseSpaceDecay::OneBodyDecayIt(), G4VDecayChannel::parent_name, G4DecayProducts::PopProducts(), G4DecayProducts::PushProducts(), RDM_ERROR, G4PhotonEvaporation::RDMForced(), G4DynamicParticle::Set4Momentum(), CLHEP::HepLorentzVector::setE(), G4PhotonEvaporation::SetICM(), G4GeneralPhaseSpaceDecay::SetParentMass(), G4PhotonEvaporation::SetVerboseLevel(), and G4GeneralPhaseSpaceDecay::TwoBodyDecayIt().

{
  G4double deltaM;
  if (decayMode == 1) {                         // beta- decay
    deltaM = CLHEP::electron_mass_c2;
  } else if (decayMode == 2) {                  // beta+ decay
    deltaM = 2.*CLHEP::electron_mass_c2;
  } else if (decayMode < 6 && decayMode > 2) {  // EC
    deltaM = -CLHEP::electron_mass_c2;
  } else {                                      // all others
    deltaM = 0.0;
  }

  // Mass available for decay in rest frame of parent after correcting for
  // the appropriate number of electron masses and reserving the daughter
  // excitation energy to be applied later 
  G4double massOfParent = G4MT_parent->GetPDGMass();  // PDG mass includes excitation energy
  SetParentMass(massOfParent - deltaM - daughterExcitation);

  // Define a product vector.
  G4DecayProducts* products = 0;

  // Depending upon the number of daughters, select the appropriate decay
  // kinematics scheme.
  switch (numberOfDaughters) {
    case 0:
      {
      G4ExceptionDescription ed;
      ed << " No daughters defined " << G4endl;
      G4Exception("G4NuclearDecayChannel::DecayIt()", "HAD_RDM_005",
                  JustWarning, ed);
      }
      break;
    case 1:
      products = OneBodyDecayIt();
      break;
    case 2:
      products = TwoBodyDecayIt();
      break;
    case 3:
      products = BetaDecayIt();
      break;
    default:
    {
      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, the photon
    // evaporation process must be applied.

    // Need to hold the shell idex after ICM
    G4int shellIndex = -1;
    if (daughterExcitation > 0.0) {
      // Pop the daughter nucleus off the product vector to get its 4-momentum
      dynamicDaughter = products->PopProducts();
      G4LorentzVector daughterMomentum = dynamicDaughter->Get4Momentum();
      if (dynamicDaughter) delete dynamicDaughter;

      // Using daughter nucleus, set up a G4Fragment for photon evaporatation
      if (decayMode == 0) {
        G4double exe = ((const G4Ions*)(G4MT_parent))->GetExcitationEnergy();
        daughterMomentum.setE(daughterMomentum.e() + exe);
      }
      G4Fragment nucleus(daughterA, daughterZ, daughterMomentum);
      G4PhotonEvaporation* deexcitation = new G4PhotonEvaporation;
      deexcitation->SetVerboseLevel(GetVerboseLevel());

      // switch on/off internal electron conversion
      deexcitation->SetICM(applyICM);

      // In IT mode, we need to force the transition 
      if (decayMode == 0) {
        deexcitation->RDMForced(true);
        // at this point, de-excitation will occur even if IT state is long-lived (>1ns)
        // Why does it need to be forced? 
      } else {
        // Not forced, but decay will still happen if lifetime < 1 ns,
        // otherwise no gamma decay is performed
        deexcitation->RDMForced(false);
      }

      //////////////////////////////////////////////////////////////////////////
      //                                                                      //
      //  Apply photon evaporation if Isomeric Transition is indicated.       //
      //  Use G4PhotonEvaporation::BreakUp() which does only one transition.  //
      //  This allows IC to be done.                                          //
      //                                                                      //
      //////////////////////////////////////////////////////////////////////////

      G4IonTable* theIonTable =
              (G4IonTable*)(G4ParticleTable::GetParticleTable()->GetIonTable());
      G4ParticleDefinition* daughterIon = 0;

      if (decayMode != 0) {
        daughterIon = theIonTable->GetIon(daughterZ, daughterA, daughterExcitation);
      } else {
        // The fragment vector from photon evaporation contains the list of
        // evaporated gammas, some of which may have been replaced by conversion
        // electrons.  The last element is the residual nucleus.
        G4FragmentVector* gammas = deexcitation->BreakUp(nucleus);  // Evaporate only one photon
        G4int nGammas = gammas->size() - 1;
        G4double finalDaughterExcitation =
                             gammas->operator[](nGammas)->GetExcitationEnergy();
        // 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.
        G4double Egamma = 0.0;
        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);
          Egamma = (gammas->operator[](ig)->GetMomentum()).e();
        }
        if (finalDaughterExcitation <= 1.0*keV) finalDaughterExcitation = 0;

        // Get new ion with excitation energy reduced by emitted gamma energy
        daughterIon =
             theIonTable->GetIon(daughterZ, daughterA, finalDaughterExcitation);
        daughterMomentum.setE(daughterMomentum.e() - Egamma);

        // Delete/reset variables associated with the gammas.
        while (!gammas->empty() ) {
          delete *(gammas->end()-1);
          gammas->pop_back();
        }
        delete gammas;

      } // end if decayMode == 0

      G4ThreeVector const daughterMomentum1(static_cast<const G4LorentzVector> (daughterMomentum));
      dynamicDaughter = new G4DynamicParticle(daughterIon, daughterMomentum1);  
      products->PushProducts(dynamicDaughter);

      // retrieve the ICM shell index
      shellIndex = deexcitation->GetVacantShellNumber();
      
      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 RDM_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;
}

G4double G4NuclearDecayChannel::GetDaughterExcitation ( )

inline

Definition at line 98 of file G4NuclearDecayChannel.hh.

References daughterExcitation.

Referenced by G4RadioactiveDecay::AddDecayRateTable().

{return daughterExcitation;}

G4ParticleDefinition* G4NuclearDecayChannel::GetDaughterNucleus ( )

inline

Definition at line 101 of file G4NuclearDecayChannel.hh.

References daughterNucleus.

Referenced by G4RadioactiveDecay::AddDecayRateTable().

{return daughterNucleus;}

G4RadioactiveDecayMode G4NuclearDecayChannel::GetDecayMode ( )

inline

Definition at line 95 of file G4NuclearDecayChannel.hh.

References decayMode.

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

{return decayMode;}

void G4NuclearDecayChannel::SetARM ( G4bool  arm )

inline

Definition at line 93 of file G4NuclearDecayChannel.hh.

References applyARM.

Referenced by G4RadioactiveDecay::LoadDecayTable().

{applyARM = arm;}

void G4NuclearDecayChannel::SetHLThreshold ( G4double  hl )

inline

Definition at line 87 of file G4NuclearDecayChannel.hh.

References halflifethreshold.

Referenced by G4RadioactiveDecay::LoadDecayTable().

{halflifethreshold = hl;}

void G4NuclearDecayChannel::SetICM ( G4bool  icm )

inline

Definition at line 90 of file G4NuclearDecayChannel.hh.

References applyICM.

Referenced by G4RadioactiveDecay::LoadDecayTable().

{applyICM = icm;} 

Field Documentation

G4bool G4NuclearDecayChannel::applyARM

protected

Definition at line 150 of file G4NuclearDecayChannel.hh.

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

G4bool G4NuclearDecayChannel::applyICM

protected

Definition at line 149 of file G4NuclearDecayChannel.hh.

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

G4int G4NuclearDecayChannel::daughterA

protected

Definition at line 143 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt().

G4double G4NuclearDecayChannel::daughterExcitation

protected

Definition at line 142 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt(), and GetDaughterExcitation().

G4ParticleDefinition* G4NuclearDecayChannel::daughterNucleus

protected

Definition at line 145 of file G4NuclearDecayChannel.hh.

Referenced by GetDaughterNucleus().

G4int G4NuclearDecayChannel::daughterZ

protected

Definition at line 144 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt().

const G4RadioactiveDecayMode G4NuclearDecayChannel::decayMode

protected

Definition at line 139 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt(), and GetDecayMode().

G4ThreadLocal G4DynamicParticle * G4NuclearDecayChannel::dynamicDaughter = 0

staticprotected

Definition at line 146 of file G4NuclearDecayChannel.hh.

Referenced by DecayIt().

G4double G4NuclearDecayChannel::halflifethreshold

protected

Definition at line 148 of file G4NuclearDecayChannel.hh.

Referenced by G4NuclearDecayChannel(), and SetHLThreshold().

const G4double G4NuclearDecayChannel::levelTolerance = 2.0*keV

staticprotected

Definition at line 141 of file G4NuclearDecayChannel.hh.

const G4double G4NuclearDecayChannel::pTolerance = 0.001

staticprotected

Definition at line 140 of file G4NuclearDecayChannel.hh.

const G4double G4NuclearDecayChannel::Qtransition

protected

Definition at line 147 of file G4NuclearDecayChannel.hh.

G4RandGeneral* G4NuclearDecayChannel::RandomEnergy

protected

Definition at line 151 of file G4NuclearDecayChannel.hh.

Referenced by G4NuclearDecayChannel().

---

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

• G4NuclearDecayChannel.hh
• G4NuclearDecayChannel.cc