G4GeneralPhaseSpaceDecay Class Reference

#include <G4GeneralPhaseSpaceDecay.hh>

Inheritance diagram for G4GeneralPhaseSpaceDecay:

Public Member Functions
virtual G4DecayProducts *	DecayIt (G4double mass=0.0)
void	DumpInfo ()
	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, const G4double *masses)
	G4GeneralPhaseSpaceDecay (const G4String &theParentName, G4double theParentMass, G4double theBR, G4int theNumberOfDaughters, const G4String &theDaughterName1, const G4String &theDaughterName2, const G4String &theDaughterName3, const G4String &theDaughterName4, const G4double *masses)
	G4GeneralPhaseSpaceDecay (const G4String &theParentName, G4double theParentMass, G4double theBR, G4int theNumberOfDaughters, const G4String &theDaughterName1, const G4String &theDaughterName2="", const G4String &theDaughterName3="")
	G4GeneralPhaseSpaceDecay (G4int Verbose=1)
G4int	GetAngularMomentum ()
G4double	GetBR () const
G4ParticleDefinition *	GetDaughter (G4int anIndex)
G4double	GetDaughterMass (G4int anIndex) const
const G4String &	GetDaughterName (G4int anIndex) const
const G4String &	GetKinematicsName () const
G4int	GetNumberOfDaughters () const
G4ParticleDefinition *	GetParent ()
G4double	GetParentMass () const
const G4String &	GetParentName () const
const G4ThreeVector &	GetPolarization () const
G4double	GetRangeMass () const
G4int	GetVerboseLevel () const
virtual G4bool	IsOKWithParentMass (G4double parentMass)
G4bool	operator!= (const G4VDecayChannel &r) const
G4bool	operator< (const G4VDecayChannel &right) const
G4bool	operator== (const G4VDecayChannel &r) const
void	SetBR (G4double value)
void	SetDaughter (G4int anIndex, const G4ParticleDefinition *particle_type)
void	SetDaughter (G4int anIndex, const G4String &particle_name)
void	SetNumberOfDaughters (G4int value)
void	SetParent (const G4ParticleDefinition *particle_type)
void	SetParent (const G4String &particle_name)
void	SetParentMass (const G4double aParentMass)
void	SetPolarization (const G4ThreeVector &)
void	SetRangeMass (G4double val)
void	SetVerboseLevel (G4int value)
virtual	~G4GeneralPhaseSpaceDecay ()

Static Public Member Functions
static G4double	Pmx (G4double e, G4double p1, G4double p2)

Protected Member Functions
void	CheckAndFillDaughters ()
void	CheckAndFillParent ()
void	ClearDaughtersName ()
G4double	DynamicalMass (G4double massPDG, G4double width, G4double maxDev=1.0) const
G4DecayProducts *	ManyBodyDecayIt ()
G4DecayProducts *	OneBodyDecayIt ()
G4DecayProducts *	ThreeBodyDecayIt ()
G4DecayProducts *	TwoBodyDecayIt ()

Protected Attributes
G4String **	daughters_name = nullptr
G4Mutex	daughtersMutex
G4ParticleDefinition **	G4MT_daughters = nullptr
G4double *	G4MT_daughters_mass = nullptr
G4double *	G4MT_daughters_width = nullptr
G4ParticleDefinition *	G4MT_parent = nullptr
G4double	G4MT_parent_mass = 0.0
G4String	kinematics_name = ""
G4int	numberOfDaughters = 0
G4String *	parent_name = nullptr
G4ThreeVector	parent_polarization
G4Mutex	parentMutex
G4ParticleTable *	particletable = nullptr
G4double	rangeMass = 2.5
G4double	rbranch = 0.0
G4int	verboseLevel = 1

Static Protected Attributes
static const G4String	noName = " "

Private Member Functions
void	FillDaughters ()
void	FillParent ()
const G4String &	GetNoName () const

Private Attributes
G4double	parentmass
const G4double *	theDaughterMasses

Detailed Description

Definition at line 44 of file G4GeneralPhaseSpaceDecay.hh.

Constructor & Destructor Documentation

G4GeneralPhaseSpaceDecay() [1/5]

G4GeneralPhaseSpaceDecay::G4GeneralPhaseSpaceDecay

(

G4int

Verbose = 1

)

Definition at line 48 of file G4GeneralPhaseSpaceDecay.cc.

                                                                : 
                          G4VDecayChannel("Phase Space", Verbose),
                          parentmass(0.), theDaughterMasses(0)
{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay:: constructor " << G4endl;
}

References G4cout, G4endl, and G4VDecayChannel::GetVerboseLevel().

G4GeneralPhaseSpaceDecay() [2/5]

G4GeneralPhaseSpaceDecay::G4GeneralPhaseSpaceDecay	(	const G4String &	theParentName,
		G4double	theBR,
		G4int	theNumberOfDaughters,
		const G4String &	theDaughterName1,
		const G4String &	theDaughterName2 = "",
		const G4String &	theDaughterName3 = ""
	)

Definition at line 55 of file G4GeneralPhaseSpaceDecay.cc.

                                                                         :
                                   G4VDecayChannel("Phase Space",
                               theParentName,theBR,
                               theNumberOfDaughters,
                               theDaughterName1,
                               theDaughterName2,
                               theDaughterName3),
                   theDaughterMasses(0)
{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay:: constructor " << G4endl;
  
  //   Set the parent particle (resonance) mass to the (default) PDG vale
  if (G4MT_parent != NULL)
  {
      parentmass = G4MT_parent->GetPDGMass();
  } else {
      parentmass=0.;
  }
 
}

References G4cout, G4endl, G4VDecayChannel::G4MT_parent, G4ParticleDefinition::GetPDGMass(), G4VDecayChannel::GetVerboseLevel(), and parentmass.

G4GeneralPhaseSpaceDecay() [3/5]

G4GeneralPhaseSpaceDecay::G4GeneralPhaseSpaceDecay	(	const G4String &	theParentName,
		G4double	theParentMass,
		G4double	theBR,
		G4int	theNumberOfDaughters,
		const G4String &	theDaughterName1,
		const G4String &	theDaughterName2 = "",
		const G4String &	theDaughterName3 = ""
	)

Definition at line 81 of file G4GeneralPhaseSpaceDecay.cc.

                                                                         :
                                   G4VDecayChannel("Phase Space",
                               theParentName,theBR,
                               theNumberOfDaughters,
                               theDaughterName1,
                               theDaughterName2,
                               theDaughterName3),
                       parentmass(theParentMass),
                   theDaughterMasses(0)
{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay:: constructor " << G4endl;
}

References G4cout, G4endl, and G4VDecayChannel::GetVerboseLevel().

G4GeneralPhaseSpaceDecay() [4/5]

G4GeneralPhaseSpaceDecay::G4GeneralPhaseSpaceDecay	(	const G4String &	theParentName,
		G4double	theParentMass,
		G4double	theBR,
		G4int	theNumberOfDaughters,
		const G4String &	theDaughterName1,
		const G4String &	theDaughterName2,
		const G4String &	theDaughterName3,
		const G4double *	masses
	)

Definition at line 100 of file G4GeneralPhaseSpaceDecay.cc.

                                                   :
                                   G4VDecayChannel("Phase Space",
                               theParentName,theBR,
                               theNumberOfDaughters,
                               theDaughterName1,
                               theDaughterName2,
                               theDaughterName3),
                       parentmass(theParentMass),
                   theDaughterMasses(masses)
{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay:: constructor " << G4endl;
}

References G4cout, G4endl, and G4VDecayChannel::GetVerboseLevel().

G4GeneralPhaseSpaceDecay() [5/5]

G4GeneralPhaseSpaceDecay::G4GeneralPhaseSpaceDecay	(	const G4String &	theParentName,
		G4double	theParentMass,
		G4double	theBR,
		G4int	theNumberOfDaughters,
		const G4String &	theDaughterName1,
		const G4String &	theDaughterName2,
		const G4String &	theDaughterName3,
		const G4String &	theDaughterName4,
		const G4double *	masses
	)

Definition at line 120 of file G4GeneralPhaseSpaceDecay.cc.

                                                   :
                                   G4VDecayChannel("Phase Space",
                               theParentName,theBR,
                               theNumberOfDaughters,
                               theDaughterName1,
                               theDaughterName2,
                               theDaughterName3,
                               theDaughterName4),
                       parentmass(theParentMass),
                   theDaughterMasses(masses)
{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay:: constructor " << G4endl;
}

References G4cout, G4endl, and G4VDecayChannel::GetVerboseLevel().

~G4GeneralPhaseSpaceDecay()

G4GeneralPhaseSpaceDecay::~G4GeneralPhaseSpaceDecay ( )

virtual

Definition at line 142 of file G4GeneralPhaseSpaceDecay.cc.

{
}

Member Function Documentation

CheckAndFillDaughters()

void G4VDecayChannel::CheckAndFillDaughters ( )

inlineprotectedinherited

Definition at line 337 of file G4VDecayChannel.hh.

{
  G4AutoLock l(&daughtersMutex);
  if ( G4MT_daughters == nullptr )
  {
    l.unlock();
    FillDaughters();
  }
}

References G4VDecayChannel::daughtersMutex, G4VDecayChannel::FillDaughters(), G4VDecayChannel::G4MT_daughters, and G4TemplateAutoLock< _Mutex_t >::unlock().

Referenced by DecayIt(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4NeutronBetaDecayChannel::DecayIt(), G4PhaseSpaceDecayChannel::DecayIt(), G4PionRadiativeDecayChannel::DecayIt(), G4TauLeptonicDecayChannel::DecayIt(), G4AlphaDecay::DecayIt(), G4BetaMinusDecay::DecayIt(), G4BetaPlusDecay::DecayIt(), G4ECDecay::DecayIt(), G4NeutronDecay::DecayIt(), G4ProtonDecay::DecayIt(), G4TritonDecay::DecayIt(), G4VDecayChannel::GetAngularMomentum(), G4VDecayChannel::GetDaughter(), G4PhaseSpaceDecayChannel::IsOKWithParentMass(), and G4VDecayChannel::IsOKWithParentMass().

CheckAndFillParent()

void G4VDecayChannel::CheckAndFillParent ( )

inlineprotectedinherited

Definition at line 348 of file G4VDecayChannel.hh.

{
  G4AutoLock l(&parentMutex);
  if ( G4MT_parent == nullptr )
  {
    l.unlock();
    FillParent();
  }
}

References G4VDecayChannel::FillParent(), G4VDecayChannel::G4MT_parent, G4VDecayChannel::parentMutex, and G4TemplateAutoLock< _Mutex_t >::unlock().

Referenced by DecayIt(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4NeutronBetaDecayChannel::DecayIt(), G4PhaseSpaceDecayChannel::DecayIt(), G4PionRadiativeDecayChannel::DecayIt(), G4TauLeptonicDecayChannel::DecayIt(), G4AlphaDecay::DecayIt(), G4BetaMinusDecay::DecayIt(), G4BetaPlusDecay::DecayIt(), G4ECDecay::DecayIt(), G4ITDecay::DecayIt(), G4NeutronDecay::DecayIt(), G4ProtonDecay::DecayIt(), G4SFDecay::DecayIt(), G4TritonDecay::DecayIt(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::GetParent(), G4PhaseSpaceDecayChannel::IsOKWithParentMass(), and G4VDecayChannel::IsOKWithParentMass().

ClearDaughtersName()

void G4VDecayChannel::ClearDaughtersName ( )

protectedinherited

Definition at line 183 of file G4VDecayChannel.cc.

{
  G4AutoLock l(&daughtersMutex);
  if ( daughters_name != nullptr)
  {
    if (numberOfDaughters>0)
    {
#ifdef G4VERBOSE
      if (verboseLevel>1)
      {
        G4cout << "G4VDecayChannel::ClearDaughtersName() "
               << " for " << *parent_name << G4endl;
      }
#endif
      for (G4int index=0; index<numberOfDaughters; ++index)
      { 
        delete daughters_name[index];
      }
    }
    delete [] daughters_name;
    daughters_name = nullptr;
  }
 
  delete [] G4MT_daughters;
  delete [] G4MT_daughters_mass;
  delete [] G4MT_daughters_width;
  G4MT_daughters_width = nullptr;
  G4MT_daughters = nullptr;
  G4MT_daughters_mass = nullptr;
 
  numberOfDaughters = 0;
}

References G4VDecayChannel::daughters_name, G4VDecayChannel::daughtersMutex, G4cout, G4endl, G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_daughters_mass, G4VDecayChannel::G4MT_daughters_width, G4VDecayChannel::numberOfDaughters, G4VDecayChannel::parent_name, and G4VDecayChannel::verboseLevel.

Referenced by G4DalitzDecayChannel::operator=(), G4KL3DecayChannel::operator=(), G4MuonDecayChannel::operator=(), G4MuonDecayChannelWithSpin::operator=(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), G4VDecayChannel::SetNumberOfDaughters(), and G4VDecayChannel::~G4VDecayChannel().

DecayIt()

G4DecayProducts * G4GeneralPhaseSpaceDecay::DecayIt ( G4double  mass = 0.0 )

virtual

Implements G4VDecayChannel.

Definition at line 146 of file G4GeneralPhaseSpaceDecay.cc.

{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay::DecayIt ";
  G4DecayProducts * products = NULL;
 
  CheckAndFillParent();
  CheckAndFillDaughters();
  
  switch (numberOfDaughters){
  case 0:
    if (GetVerboseLevel()>0) {
      G4cout << "G4GeneralPhaseSpaceDecay::DecayIt ";
      G4cout << " daughters not defined " <<G4endl;
    }
    break;
  case 1:
    products =  OneBodyDecayIt();
    break;
  case 2:
    products =  TwoBodyDecayIt();
    break;
  case 3:
    products =  ThreeBodyDecayIt();
    break;
  default:
    products =  ManyBodyDecayIt();
    break;
  }
  if ((products == NULL) && (GetVerboseLevel()>0)) {
    G4cout << "G4GeneralPhaseSpaceDecay::DecayIt ";
    G4cout << *parent_name << " can not decay " << G4endl;
    DumpInfo();
  }
  return products;
}

References G4VDecayChannel::CheckAndFillDaughters(), G4VDecayChannel::CheckAndFillParent(), G4VDecayChannel::DumpInfo(), G4cout, G4endl, G4VDecayChannel::GetVerboseLevel(), ManyBodyDecayIt(), G4VDecayChannel::numberOfDaughters, OneBodyDecayIt(), G4VDecayChannel::parent_name, ThreeBodyDecayIt(), and TwoBodyDecayIt().

Referenced by G4KineticTrack::Decay().

DumpInfo()

void G4VDecayChannel::DumpInfo ( )

inherited

Definition at line 560 of file G4VDecayChannel.cc.

{
  G4cout << " BR:  " << rbranch << "  [" << kinematics_name << "]";
  G4cout << "   :  " ;
  for (G4int index=0; index<numberOfDaughters; ++index)
  {
    if(daughters_name[index] != nullptr)
    {
      G4cout << " " << *(daughters_name[index]);
    }
    else
    {
      G4cout << " not defined ";
    }
  }
  G4cout << G4endl;
}

References G4VDecayChannel::daughters_name, G4cout, G4endl, G4VDecayChannel::kinematics_name, G4VDecayChannel::numberOfDaughters, and G4VDecayChannel::rbranch.

Referenced by DecayIt(), G4PhaseSpaceDecayChannel::DecayIt(), and G4KL3DecayChannel::G4KL3DecayChannel().

DynamicalMass()

G4double G4VDecayChannel::DynamicalMass ( G4double  massPDG, G4double  width, G4double  maxDev = 1.0  ) const

protectedinherited

Definition at line 585 of file G4VDecayChannel.cc.

{ 
  if (width<=0.0) return massPDG;
  if (maxDev >rangeMass) maxDev = rangeMass;
  if (maxDev <=-1.*rangeMass) return massPDG;  // cannot calculate
 
  G4double x = G4UniformRand()*(maxDev+rangeMass) - rangeMass;
  G4double y = G4UniformRand();
  const std::size_t MAX_LOOP=10000;
  for (std::size_t loop_counter=0; loop_counter <MAX_LOOP; ++loop_counter)
  {
    if ( y * (width*width*x*x + massPDG*massPDG*width*width)
       <= massPDG*massPDG*width*width  ) break;
    x = G4UniformRand()*(maxDev+rangeMass) - rangeMass;
    y = G4UniformRand();
  }
  G4double mass = massPDG + x*width;
  return mass;
}

References G4UniformRand, and G4VDecayChannel::rangeMass.

Referenced by G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), and G4PhaseSpaceDecayChannel::TwoBodyDecayIt().

FillDaughters()

void G4VDecayChannel::FillDaughters ( )

privateinherited

Definition at line 308 of file G4VDecayChannel.cc.

{
  G4AutoLock lock(&daughtersMutex);
 
  // Double check, check again if another thread has already filled this, in
  // case do not need to do anything
  if ( G4MT_daughters != nullptr ) return;
 
  G4int index;
  
#ifdef G4VERBOSE
  if (verboseLevel>1) G4cout << "G4VDecayChannel::FillDaughters()" << G4endl;
#endif
  if (G4MT_daughters != nullptr)
  {
    delete [] G4MT_daughters;
    G4MT_daughters = nullptr;
  }
 
  // parent mass
  CheckAndFillParent();
  G4double parentmass = G4MT_parent->GetPDGMass();
 
  //
  G4double sumofdaughtermass = 0.0;
  G4double sumofdaughterwidthsq = 0.0;
 
  if ((numberOfDaughters <=0) || (daughters_name == nullptr) )
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << "G4VDecayChannel::FillDaughters() - "
             << "[ " << G4MT_parent->GetParticleName() << " ]"
             << "numberOfDaughters is not defined yet";
    }
#endif
    G4MT_daughters = nullptr;
    G4Exception("G4VDecayChannel::FillDaughters()",
                "PART011", FatalException,
                "Cannot fill daughters: numberOfDaughters is not defined yet");
  } 
 
  // create and set the array of pointers to daughter particles
  G4MT_daughters = new G4ParticleDefinition*[numberOfDaughters];
  if (G4MT_daughters_mass != nullptr) delete [] G4MT_daughters_mass;
  if (G4MT_daughters_width != nullptr) delete [] G4MT_daughters_width;
  G4MT_daughters_mass = new G4double[numberOfDaughters];
  G4MT_daughters_width = new G4double[numberOfDaughters];
  // loop over all daughters
  for (index=0; index<numberOfDaughters; ++index)
  { 
    if (daughters_name[index] == nullptr)
    {
      // daughter name is not defined
#ifdef G4VERBOSE
      if (verboseLevel>0)
      {
        G4cout << "G4VDecayChannel::FillDaughters() - "
               << "[ " << G4MT_parent->GetParticleName() << " ]"
               << index << "-th daughter is not defined yet" << G4endl;
      }
#endif
      G4MT_daughters[index] = nullptr;
      G4Exception("G4VDecayChannel::FillDaughters()",
                  "PART011", FatalException,
                  "Cannot fill daughters: name of daughter is not defined yet");
    } 
    // search daughter particles in the particle table 
    G4MT_daughters[index] = particletable->FindParticle(*daughters_name[index]);
    if (G4MT_daughters[index] == nullptr )
    {
      // cannot find the daughter particle
#ifdef G4VERBOSE
      if (verboseLevel>0)
      {
        G4cout << "G4VDecayChannel::FillDaughters() - "
                << "[ " << G4MT_parent->GetParticleName() << " ]"
               << index << ":" << *daughters_name[index]
               << " is not defined !!" << G4endl;
        G4cout << " The BR of this decay mode is set to zero." << G4endl;
      }
#endif
      SetBR(0.0);
      return;
    }
#ifdef G4VERBOSE
    if (verboseLevel>1)
    {
      G4cout << index << ":" << *daughters_name[index];
      G4cout << ":" << G4MT_daughters[index] << G4endl;
    }
#endif
    G4MT_daughters_mass[index] = G4MT_daughters[index]->GetPDGMass();
    G4double d_width = G4MT_daughters[index]->GetPDGWidth();
    G4MT_daughters_width[index] = d_width;
    sumofdaughtermass += G4MT_daughters[index]->GetPDGMass();
    sumofdaughterwidthsq += d_width*d_width;
  }  // end loop over all daughters
 
  // check sum of daghter mass
  G4double widthMass = std::sqrt(G4MT_parent->GetPDGWidth()
                                *G4MT_parent->GetPDGWidth()
                                +sumofdaughterwidthsq);
  if ( (G4MT_parent->GetParticleType() != "nucleus")
    && (numberOfDaughters !=1)
    && (sumofdaughtermass > parentmass + rangeMass*widthMass) )
  {
    // !!! illegal mass  !!!
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4VDecayChannel::FillDaughters() - "
             << "[ " << G4MT_parent->GetParticleName() << " ]"
             << "    Energy/Momentum conserevation breaks " << G4endl;
     if (GetVerboseLevel()>1)
     {
       G4cout << "    parent:" << *parent_name
              << " mass:" << parentmass/GeV << "[GeV/c/c]" << G4endl;
       for (index=0; index<numberOfDaughters; ++index)
       {
         G4cout << "     daughter " << index << ":" << *daughters_name[index]
                << " mass:" << G4MT_daughters[index]->GetPDGMass()/GeV
                << "[GeV/c/c]" << G4endl;
       }
     }
   }
#endif
 }
}

References G4VDecayChannel::CheckAndFillParent(), G4VDecayChannel::daughters_name, G4VDecayChannel::daughtersMutex, FatalException, G4ParticleTable::FindParticle(), G4cout, G4endl, G4Exception(), G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_daughters_mass, G4VDecayChannel::G4MT_daughters_width, G4VDecayChannel::G4MT_parent, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGWidth(), G4VDecayChannel::GetVerboseLevel(), GeV, G4VDecayChannel::numberOfDaughters, G4VDecayChannel::parent_name, G4VDecayChannel::particletable, G4VDecayChannel::rangeMass, G4VDecayChannel::SetBR(), and G4VDecayChannel::verboseLevel.

Referenced by G4VDecayChannel::CheckAndFillDaughters().

FillParent()

void G4VDecayChannel::FillParent ( )

privateinherited

Definition at line 440 of file G4VDecayChannel.cc.

{
  G4AutoLock lock(&parentMutex);
 
  // Double check, check again if another thread has already filled this, in
  // case do not need to do anything
  if ( G4MT_parent != nullptr ) return;
 
  if (parent_name == nullptr)
  {
    // parent name is not defined
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << "G4VDecayChannel::FillParent() - "
             << "parent name is not defined !!" << G4endl;
    }
#endif
    G4MT_parent = nullptr;
    G4Exception("G4VDecayChannel::FillParent()",
                "PART012", FatalException,
                "Cannot fill parent: parent name is not defined yet");    
    return;
  }
 
  // search parent particle in the particle table
  G4MT_parent = particletable->FindParticle(*parent_name);
  if (G4MT_parent == nullptr)
  {
    // parent particle does not exist
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << "G4VDecayChannel::FillParent() - "
             << *parent_name << " does not exist !!" << G4endl;
    }
#endif
    G4Exception("G4VDecayChannel::FillParent()",
                "PART012", FatalException,
                "Cannot fill parent: parent does not exist");
    return;
  }
  G4MT_parent_mass = G4MT_parent->GetPDGMass();
}

References FatalException, G4ParticleTable::FindParticle(), G4cout, G4endl, G4Exception(), G4VDecayChannel::G4MT_parent, G4VDecayChannel::G4MT_parent_mass, G4ParticleDefinition::GetPDGMass(), G4VDecayChannel::parent_name, G4VDecayChannel::parentMutex, G4VDecayChannel::particletable, and G4VDecayChannel::verboseLevel.

Referenced by G4VDecayChannel::CheckAndFillParent().

GetAngularMomentum()

G4int G4VDecayChannel::GetAngularMomentum ( )

inherited

Definition at line 492 of file G4VDecayChannel.cc.

{
  // determine angular momentum
 
  // fill pointers to daughter particles if not yet set  
  CheckAndFillDaughters();
 
  const G4int PiSpin = G4MT_parent->GetPDGiSpin();
  const G4int PParity = G4MT_parent->GetPDGiParity();
  if (2==numberOfDaughters) // up to now we can only handle two particle decays
  {
    const G4int D1iSpin  = G4MT_daughters[0]->GetPDGiSpin();
    const G4int D1Parity = G4MT_daughters[0]->GetPDGiParity();
    const G4int D2iSpin  = G4MT_daughters[1]->GetPDGiSpin();
    const G4int D2Parity = G4MT_daughters[1]->GetPDGiParity();
    const G4int MiniSpin = std::abs (D1iSpin - D2iSpin);
    const G4int MaxiSpin = D1iSpin + D2iSpin;
    const G4int lMax = (PiSpin+D1iSpin+D2iSpin)/2; // l is always int
    G4int lMin;
#ifdef G4VERBOSE
    if (verboseLevel>1)
    {
      G4cout << "iSpin: " << PiSpin << " -> " << D1iSpin
             << " + " << D2iSpin << G4endl;
      G4cout << "2*jmin, 2*jmax, lmax " << MiniSpin << " " << MaxiSpin
             << " " << lMax << G4endl;
    }
#endif
    for (G4int j=MiniSpin; j<=MaxiSpin; j+=2) // loop over all possible
    {                                         // spin couplings
      lMin = std::abs(PiSpin-j)/2;
#ifdef G4VERBOSE 
      if (verboseLevel>1)
        G4cout << "-> checking 2*j=" << j << G4endl;
#endif
      for (G4int l=lMin; l<=lMax; ++l)
      {
#ifdef G4VERBOSE
        if (verboseLevel>1)
          G4cout << " checking l=" << l << G4endl;
#endif
        if (l%2==0)
        {
          if (PParity == D1Parity*D2Parity)    // check parity for this l
            return l;
        }
        else
        {
          if (PParity == -1*D1Parity*D2Parity) // check parity for this l
            return l;
        }
      }
    }
  }
  else
  {
    G4Exception("G4VDecayChannel::GetAngularMomentum()",
                "PART111", JustWarning,
                "Sorry, can't handle 3 particle decays (up to now)");
    return 0;
  }
  G4Exception ("G4VDecayChannel::GetAngularMomentum()",
                "PART111", JustWarning,
                "Can't find angular momentum for this decay");
  return 0;
}

References G4VDecayChannel::CheckAndFillDaughters(), G4cout, G4endl, G4Exception(), G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_parent, G4ParticleDefinition::GetPDGiParity(), G4ParticleDefinition::GetPDGiSpin(), JustWarning, G4VDecayChannel::numberOfDaughters, and G4VDecayChannel::verboseLevel.

GetBR()

G4double G4VDecayChannel::GetBR ( ) const

inlineinherited

Definition at line 298 of file G4VDecayChannel.hh.

{
  return rbranch;
}

References G4VDecayChannel::rbranch.

Referenced by G4Radioactivation::CalculateChainsFromParent(), G4Decay::DecayIt(), G4Radioactivation::DecayIt(), G4MuonicAtomDecay::DecayIt(), G4AlphaDecay::DumpNuclearInfo(), G4BetaMinusDecay::DumpNuclearInfo(), G4BetaPlusDecay::DumpNuclearInfo(), G4ECDecay::DumpNuclearInfo(), G4ITDecay::DumpNuclearInfo(), G4NeutronDecay::DumpNuclearInfo(), G4ProtonDecay::DumpNuclearInfo(), G4SFDecay::DumpNuclearInfo(), G4TritonDecay::DumpNuclearInfo(), G4KineticTrack::G4KineticTrack(), G4HtmlPPReporter::GeneratePropertyTable(), G4TextPPReporter::GeneratePropertyTable(), G4DecayTableMessenger::GetCurrentValue(), G4SampleResonance::GetMinimumMass(), G4DecayTable::Insert(), and G4RadioactiveDecay::LoadDecayTable().

GetDaughter()

G4ParticleDefinition * G4VDecayChannel::GetDaughter ( G4int  anIndex )

inlineinherited

Definition at line 201 of file G4VDecayChannel.hh.

{ 
  // pointers to daughter particles are filled, if they are not set yet 
  CheckAndFillDaughters();
 
  // get the pointer to a daughter particle
  if ( (anIndex>=0) && (anIndex<numberOfDaughters) )
  {
    return G4MT_daughters[anIndex];
  }
  else
  {
    if (verboseLevel>0)
      G4cout << "G4VDecayChannel::GetDaughter  index out of range "
             << anIndex << G4endl;
    return nullptr;
  }
}

References G4VDecayChannel::CheckAndFillDaughters(), G4cout, G4endl, G4VDecayChannel::G4MT_daughters, G4VDecayChannel::numberOfDaughters, and G4VDecayChannel::verboseLevel.

Referenced by G4IonTable::CreateIon(), G4KineticTrack::Decay(), G4KineticTrack::G4KineticTrack(), G4HtmlPPReporter::GeneratePropertyTable(), G4TextPPReporter::GeneratePropertyTable(), G4NuclearDecay::GetDaughterNucleus(), G4MTRunManagerKernel::SetUpDecayChannels(), and G4TaskRunManagerKernel::SetUpDecayChannels().

GetDaughterMass()

G4double G4VDecayChannel::GetDaughterMass ( G4int  anIndex ) const

inlineinherited

Definition at line 239 of file G4VDecayChannel.hh.

{
  if ( (anIndex>=0) && (anIndex<numberOfDaughters) )
  {
    return G4MT_daughters_mass[anIndex];
  }
  else
  {
    if (verboseLevel>0)
    {
      G4cout << "G4VDecayChannel::GetDaughterMass ";
      G4cout << "index out of range " << anIndex << G4endl;
    }
    return 0.0;
  }
}

References G4cout, G4endl, G4VDecayChannel::G4MT_daughters_mass, G4VDecayChannel::numberOfDaughters, and G4VDecayChannel::verboseLevel.

GetDaughterName()

const G4String & G4VDecayChannel::GetDaughterName ( G4int  anIndex ) const

inlineinherited

Definition at line 221 of file G4VDecayChannel.hh.

{
  if ( (anIndex>=0) && (anIndex<numberOfDaughters) )
  {
    return *daughters_name[anIndex];
  }
  else
  {
    if (verboseLevel>0)
    {
      G4cout << "G4VDecayChannel::GetDaughterName ";
      G4cout << "index out of range " << anIndex << G4endl;
    }
    return GetNoName();
  }
}

References G4VDecayChannel::daughters_name, G4cout, G4endl, G4VDecayChannel::GetNoName(), G4VDecayChannel::numberOfDaughters, and G4VDecayChannel::verboseLevel.

Referenced by G4KineticTrack::Decay(), G4Decay::DecayIt(), G4MuonicAtomDecay::DecayIt(), G4AlphaDecay::DumpNuclearInfo(), G4BetaMinusDecay::DumpNuclearInfo(), G4BetaPlusDecay::DumpNuclearInfo(), G4ECDecay::DumpNuclearInfo(), G4ITDecay::DumpNuclearInfo(), G4NeutronDecay::DumpNuclearInfo(), G4ProtonDecay::DumpNuclearInfo(), and G4TritonDecay::DumpNuclearInfo().

GetKinematicsName()

const G4String & G4VDecayChannel::GetKinematicsName ( ) const

inlineinherited

Definition at line 292 of file G4VDecayChannel.hh.

{
  return kinematics_name;
}

References G4VDecayChannel::kinematics_name.

Referenced by G4HtmlPPReporter::GeneratePropertyTable(), and G4TextPPReporter::GeneratePropertyTable().

GetNoName()

const G4String & G4VDecayChannel::GetNoName ( ) const

privateinherited

Definition at line 579 of file G4VDecayChannel.cc.

{
  return noName;
}

References G4VDecayChannel::noName.

Referenced by G4VDecayChannel::GetDaughterName().

GetNumberOfDaughters()

G4int G4VDecayChannel::GetNumberOfDaughters ( ) const

inlineinherited

Definition at line 286 of file G4VDecayChannel.hh.

{ 
  return  numberOfDaughters;
}

References G4VDecayChannel::numberOfDaughters.

Referenced by G4KineticTrack::Decay(), G4Decay::DecayIt(), G4MuonicAtomDecay::DecayIt(), G4KineticTrack::G4KineticTrack(), G4HtmlPPReporter::GeneratePropertyTable(), G4TextPPReporter::GeneratePropertyTable(), G4SampleResonance::GetMinimumMass(), and G4TextPPRetriever::ModifyPropertyTable().

GetParent()

G4ParticleDefinition * G4VDecayChannel::GetParent ( )

inlineinherited

Definition at line 257 of file G4VDecayChannel.hh.

{ 
  // the pointer to the parent particle is filled, if it is not set yet 
  CheckAndFillParent();
  // get the pointer to the parent particle
  return G4MT_parent;
}

References G4VDecayChannel::CheckAndFillParent(), and G4VDecayChannel::G4MT_parent.

Referenced by G4DecayTable::Insert().

GetParentMass()

G4double G4GeneralPhaseSpaceDecay::GetParentMass ( ) const

inline

Definition at line 107 of file G4GeneralPhaseSpaceDecay.hh.

{
  return parentmass;
}

References parentmass.

GetParentName()

const G4String & G4VDecayChannel::GetParentName ( ) const

inlineinherited

Definition at line 266 of file G4VDecayChannel.hh.

{
  return *parent_name;
}

References G4VDecayChannel::parent_name.

Referenced by G4KineticTrack::Decay(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4AlphaDecay::DumpNuclearInfo(), G4BetaMinusDecay::DumpNuclearInfo(), G4BetaPlusDecay::DumpNuclearInfo(), G4ECDecay::DumpNuclearInfo(), G4ITDecay::DumpNuclearInfo(), G4NeutronDecay::DumpNuclearInfo(), G4ProtonDecay::DumpNuclearInfo(), G4SFDecay::DumpNuclearInfo(), and G4TritonDecay::DumpNuclearInfo().

GetPolarization()

const G4ThreeVector & G4VDecayChannel::GetPolarization ( ) const

inlineinherited

Definition at line 331 of file G4VDecayChannel.hh.

{
  return parent_polarization;
}

References G4VDecayChannel::parent_polarization.

GetRangeMass()

G4double G4VDecayChannel::GetRangeMass ( ) const

inlineinherited

Definition at line 316 of file G4VDecayChannel.hh.

{
  return rangeMass;
}

References G4VDecayChannel::rangeMass.

GetVerboseLevel()

G4int G4VDecayChannel::GetVerboseLevel ( ) const

inlineinherited

Definition at line 310 of file G4VDecayChannel.hh.

{
  return verboseLevel;
}

References G4VDecayChannel::verboseLevel.

Referenced by G4KL3DecayChannel::DalitzDensity(), G4Decay::DecayIt(), G4MuonicAtomDecay::DecayIt(), DecayIt(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4NeutronBetaDecayChannel::DecayIt(), G4PhaseSpaceDecayChannel::DecayIt(), G4PionRadiativeDecayChannel::DecayIt(), G4TauLeptonicDecayChannel::DecayIt(), G4VDecayChannel::FillDaughters(), G4GeneralPhaseSpaceDecay(), G4KL3DecayChannel::G4KL3DecayChannel(), G4MuonDecayChannel::G4MuonDecayChannel(), G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin(), G4NeutronBetaDecayChannel::G4NeutronBetaDecayChannel(), G4PionRadiativeDecayChannel::G4PionRadiativeDecayChannel(), G4TauLeptonicDecayChannel::G4TauLeptonicDecayChannel(), G4PhaseSpaceDecayChannel::ManyBodyDecayIt(), ManyBodyDecayIt(), G4PhaseSpaceDecayChannel::OneBodyDecayIt(), OneBodyDecayIt(), G4KL3DecayChannel::PhaseSpace(), G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), ThreeBodyDecayIt(), G4PhaseSpaceDecayChannel::TwoBodyDecayIt(), and TwoBodyDecayIt().

IsOKWithParentMass()

G4bool G4VDecayChannel::IsOKWithParentMass ( G4double  parentMass )

virtualinherited

Reimplemented in G4PhaseSpaceDecayChannel.

Definition at line 607 of file G4VDecayChannel.cc.

{
  G4double sumOfDaughterMassMin = 0.0;
  CheckAndFillParent();
  CheckAndFillDaughters();
  // skip one body decay
  if (numberOfDaughters==1) return true;
  
  for (G4int index=0; index<numberOfDaughters; ++index)
  { 
    sumOfDaughterMassMin += 
      G4MT_daughters_mass[index] - rangeMass*G4MT_daughters_width[index];
  }
  return (parentMass >= sumOfDaughterMassMin); 
}

References G4VDecayChannel::CheckAndFillDaughters(), G4VDecayChannel::CheckAndFillParent(), G4VDecayChannel::G4MT_daughters_mass, G4VDecayChannel::G4MT_daughters_width, G4VDecayChannel::numberOfDaughters, and G4VDecayChannel::rangeMass.

Referenced by G4Decay::DecayIt(), G4MuonicAtomDecay::DecayIt(), and G4PhaseSpaceDecayChannel::IsOKWithParentMass().

ManyBodyDecayIt()

G4DecayProducts * G4GeneralPhaseSpaceDecay::ManyBodyDecayIt ( )

protected

Definition at line 381 of file G4GeneralPhaseSpaceDecay.cc.

{
  //return value
  G4DecayProducts *products;
 
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay::ManyBodyDecayIt()"<<G4endl;
 
  //daughters'mass
  G4double *daughtermass = new G4double[numberOfDaughters]; 
  G4double sumofdaughtermass = 0.0;
  for (G4int index=0; index<numberOfDaughters; index++){
    daughtermass[index] = G4MT_daughters[index]->GetPDGMass();
    sumofdaughtermass += daughtermass[index];
  }
  
  //Calculate daughter momentum
  G4double *daughtermomentum = new G4double[numberOfDaughters];
  G4ParticleMomentum direction;  
  G4DynamicParticle **daughterparticle;
  G4double *sm = new G4double[numberOfDaughters];
  G4double tmas;
  G4double weight = 1.0;
  G4int    numberOfTry = 0; 
  G4int index1;
 
  do {
    //Generate rundom number in descending order 
    G4double temp;
    G4double *rd = new G4double[numberOfDaughters];
    rd[0] = 1.0;
    for(index1 =1; index1 < numberOfDaughters -1; index1++)
      rd[index1] = G4UniformRand(); 
    rd[ numberOfDaughters -1] = 0.0;
    for(index1 =1; index1 < numberOfDaughters -1; index1++) {
      for(G4int index2 = index1+1; index2 < numberOfDaughters; index2++) {
        if (rd[index1] < rd[index2]){
          temp         = rd[index1];
          rd[index1]   = rd[index2];
          rd[index2]   = temp;
        }
      }
    }
    
    //calcurate virtual mass 
    tmas = parentmass -  sumofdaughtermass;
    temp =  sumofdaughtermass; 
    for(index1 =0; index1 < numberOfDaughters; index1++) {
      sm[index1] = rd[index1]*tmas + temp;
      temp -= daughtermass[index1];
      if (GetVerboseLevel()>1) {
        G4cout << index1 << "  rundom number:" << rd[index1]; 
        G4cout << "   virtual mass:" << sm[index1]/GeV << "[GeV/c/c]" <<G4endl; 
      }
    }
    delete [] rd;
 
    //Calculate daughter momentum
    weight = 1.0;
    index1 =numberOfDaughters-1;
    daughtermomentum[index1]= Pmx( sm[index1-1],daughtermass[index1-1],sm[index1]);
    if (GetVerboseLevel()>1) {
      G4cout << "     daughter " << index1 << ":" << *daughters_name[index1];
      G4cout << " momentum:" << daughtermomentum[index1]/GeV << "[GeV/c]" <<G4endl;
    }
    for(index1 =numberOfDaughters-2; index1>=0; index1--) {
      // calculate 
      daughtermomentum[index1]= Pmx( sm[index1],daughtermass[index1], sm[index1 +1]);
      if(daughtermomentum[index1] < 0.0) {
        // !!! illegal momentum !!!
        if (GetVerboseLevel()>0) {
          G4cout << "G4GeneralPhaseSpaceDecay::ManyBodyDecayIt ";
          G4cout << "     can not calculate daughter momentum " <<G4endl;
          G4cout << "     parent:" << *parent_name;
          G4cout << " mass:" << parentmass/GeV << "[GeV/c/c]" <<G4endl;
          G4cout << "     daughter " << index1 << ":" << *daughters_name[index1];
          G4cout << " mass:" << daughtermass[index1]/GeV << "[GeV/c/c]" ;
          G4cout << " mass:" << daughtermomentum[index1]/GeV << "[GeV/c]" <<G4endl;
        }
    delete [] sm;
    delete [] daughtermass;
    delete [] daughtermomentum;
    return NULL;   // Error detection
 
      } else {
    // calculate weight of this events
        weight *=  daughtermomentum[index1]/sm[index1];
        if (GetVerboseLevel()>1) {
          G4cout << "     daughter " << index1 << ":" << *daughters_name[index1];
          G4cout << " momentum:" << daughtermomentum[index1]/GeV << "[GeV/c]" <<G4endl;
        }
      }
    }
    if (GetVerboseLevel()>1) {
      G4cout << "    weight: " << weight <<G4endl;
    }
    
    // exit if number of Try exceeds 100
    if (numberOfTry++ >100) {
      if (GetVerboseLevel()>0) {
        G4cout << "G4GeneralPhaseSpaceDecay::ManyBodyDecayIt: ";
    G4cout << " can not determine Decay Kinematics " << G4endl;
      }
      delete [] sm;
      delete [] daughtermass;
      delete [] daughtermomentum;
      return NULL;  // Error detection
    }
  } while ( weight > G4UniformRand());  /* Loop checking, 02.11.2015, A.Ribon */
  if (GetVerboseLevel()>1) {
      G4cout << "Start calculation of daughters momentum vector "<<G4endl;
  }
  
  G4double costheta, sintheta, phi;
  G4double beta;
  daughterparticle = new G4DynamicParticle*[numberOfDaughters];
 
  index1 = numberOfDaughters -2;
  costheta = 2.*G4UniformRand()-1.0;
  sintheta = std::sqrt((1.0-costheta)*(1.0+costheta));
  phi  = twopi*G4UniformRand()*rad;
  direction.setZ(costheta);
  direction.setY(sintheta*std::sin(phi));
  direction.setX(sintheta*std::cos(phi));
  daughterparticle[index1] = new G4DynamicParticle( G4MT_daughters[index1], direction*daughtermomentum[index1] );
  daughterparticle[index1+1] = new G4DynamicParticle( G4MT_daughters[index1+1], direction*(-1.0*daughtermomentum[index1]) );
 
  for (index1 = numberOfDaughters -3;  index1 >= 0; index1--) {
    //calculate momentum direction
    costheta = 2.*G4UniformRand()-1.0;
    sintheta = std::sqrt((1.0-costheta)*(1.0+costheta));
    phi  = twopi*G4UniformRand()*rad;
    direction.setZ(costheta);
    direction.setY(sintheta*std::sin(phi));
    direction.setX(sintheta*std::cos(phi));
 
    // boost already created particles 
    beta = daughtermomentum[index1];
    beta /= std::sqrt( daughtermomentum[index1]*daughtermomentum[index1] + sm[index1+1]*sm[index1+1] );
    for (G4int index2 = index1+1; index2<numberOfDaughters; index2++) {
      G4LorentzVector p4;
      // make G4LorentzVector for secondaries
      p4 = daughterparticle[index2]->Get4Momentum();
 
      // boost secondaries to  new frame 
      p4.boost( direction.x()*beta, direction.y()*beta, direction.z()*beta);
 
      // change energy/momentum
      daughterparticle[index2]->Set4Momentum(p4);
    }
    //create daughter G4DynamicParticle 
    daughterparticle[index1]= new G4DynamicParticle( G4MT_daughters[index1], direction*(-1.0*daughtermomentum[index1]));
  }
 
  //create G4Decayproducts
  G4DynamicParticle *parentparticle; 
  direction.setX(1.0);  direction.setY(0.0); direction.setZ(0.0);
  parentparticle = new G4DynamicParticle( G4MT_parent, direction, 0.0);
  products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
  for (index1 = 0; index1<numberOfDaughters; index1++) {
    products->PushProducts(daughterparticle[index1]);
  }
  if (GetVerboseLevel()>1) { 
    G4cout << "G4GeneralPhaseSpaceDecay::ManyBodyDecayIt ";
    G4cout << "  create decay products in rest frame " << G4endl;
    products->DumpInfo();
  }
 
  delete [] daughterparticle;
  delete [] daughtermomentum;
  delete [] daughtermass;
  delete [] sm;
  
  return products;
}

References anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, CLHEP::HepLorentzVector::boost(), G4VDecayChannel::daughters_name, G4DecayProducts::DumpInfo(), G4cout, G4endl, G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_parent, G4UniformRand, G4DynamicParticle::Get4Momentum(), G4ParticleDefinition::GetPDGMass(), G4VDecayChannel::GetVerboseLevel(), GeV, G4VDecayChannel::numberOfDaughters, G4VDecayChannel::parent_name, parentmass, Pmx(), G4DecayProducts::PushProducts(), rad, G4DynamicParticle::Set4Momentum(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), G4InuclParticleNames::sm, twopi, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DecayIt().

OneBodyDecayIt()

G4DecayProducts * G4GeneralPhaseSpaceDecay::OneBodyDecayIt ( )

protected

Definition at line 182 of file G4GeneralPhaseSpaceDecay.cc.

{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay::OneBodyDecayIt()"<<G4endl;
 
//  G4double daughtermass = daughters[0]->GetPDGMass();
 
  //create parent G4DynamicParticle at rest
  G4ParticleMomentum dummy;
  G4DynamicParticle * parentparticle = new G4DynamicParticle(G4MT_parent, dummy, 0.0);
 
  //create G4Decayproducts
  G4DecayProducts *products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
 
  //create daughter G4DynamicParticle at rest
  G4DynamicParticle * daughterparticle = new G4DynamicParticle(G4MT_daughters[0], dummy, 0.0);
  products->PushProducts(daughterparticle);
 
  if (GetVerboseLevel()>1) 
    {
     G4cout << "G4GeneralPhaseSpaceDecay::OneBodyDecayIt ";
     G4cout << "  create decay products in rest frame " <<G4endl;
     products->DumpInfo();
    }
  return products;
}

References G4DecayProducts::DumpInfo(), G4cout, G4endl, G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_parent, G4VDecayChannel::GetVerboseLevel(), and G4DecayProducts::PushProducts().

Referenced by DecayIt().

operator!=()

G4bool G4VDecayChannel::operator!= ( const G4VDecayChannel &  r ) const

inlineinherited

Definition at line 69 of file G4VDecayChannel.hh.

{ return (this != &r); }

operator<()

G4bool G4VDecayChannel::operator< ( const G4VDecayChannel &  right ) const

inlineinherited

Definition at line 195 of file G4VDecayChannel.hh.

{
  return (this->rbranch < right.rbranch);
}

References G4VDecayChannel::rbranch.

operator==()

G4bool G4VDecayChannel::operator== ( const G4VDecayChannel &  r ) const

inlineinherited

Definition at line 68 of file G4VDecayChannel.hh.

{ return (this == &r); }

Pmx()

G4double G4GeneralPhaseSpaceDecay::Pmx ( G4double  e, G4double  p1, G4double  p2  )

inlinestatic

Definition at line 120 of file G4GeneralPhaseSpaceDecay.hh.

{
   // calculate momentum of daughter particles in two-body decay
   if (e-p1-p2 < 0 )
   {  
     throw G4HadronicException(__FILE__, __LINE__, "G4GeneralPhaseSpaceDecay::Pmx energy in cms < mass1+mass2");    
   }
   G4double ppp = (e+p1+p2)*(e+p1-p2)*(e-p1+p2)*(e-p1-p2)/(4.0*e*e);
   if (ppp>0) return std::sqrt(ppp);
   else       return -1.;
}

Referenced by ManyBodyDecayIt(), and TwoBodyDecayIt().

SetBR()

void G4VDecayChannel::SetBR ( G4double  value )

inherited

Definition at line 624 of file G4VDecayChannel.cc.

{ 
  rbranch = value; 
  if      (rbranch <0.  ) rbranch = 0.0;
  else if (rbranch >1.0 ) rbranch = 1.0;
}

References G4VDecayChannel::rbranch.

Referenced by G4TauMinus::Definition(), G4TauPlus::Definition(), G4VDecayChannel::FillDaughters(), G4AlphaDecay::G4AlphaDecay(), G4BetaMinusDecay::G4BetaMinusDecay(), G4BetaPlusDecay::G4BetaPlusDecay(), G4DalitzDecayChannel::G4DalitzDecayChannel(), G4ECDecay::G4ECDecay(), G4ITDecay::G4ITDecay(), G4MuonDecayChannel::G4MuonDecayChannel(), G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin(), G4NeutronBetaDecayChannel::G4NeutronBetaDecayChannel(), G4NeutronDecay::G4NeutronDecay(), G4PionRadiativeDecayChannel::G4PionRadiativeDecayChannel(), G4ProtonDecay::G4ProtonDecay(), G4SFDecay::G4SFDecay(), G4TauLeptonicDecayChannel::G4TauLeptonicDecayChannel(), G4TritonDecay::G4TritonDecay(), G4RadioactiveDecay::LoadDecayTable(), G4TextPPRetriever::ModifyPropertyTable(), and G4DecayTableMessenger::SetNewValue().

SetDaughter() [1/2]

void G4VDecayChannel::SetDaughter ( G4int  anIndex, const G4ParticleDefinition *  particle_type  )

inherited

Definition at line 300 of file G4VDecayChannel.cc.

{
  if (parent_type != nullptr)
    SetDaughter(anIndex, parent_type->GetParticleName());
}

References G4ParticleDefinition::GetParticleName(), and G4VDecayChannel::SetDaughter().

Referenced by G4TauMinus::Definition(), G4TauPlus::Definition(), G4AlphaDecay::G4AlphaDecay(), G4BetaMinusDecay::G4BetaMinusDecay(), G4BetaPlusDecay::G4BetaPlusDecay(), G4DalitzDecayChannel::G4DalitzDecayChannel(), G4ECDecay::G4ECDecay(), G4ITDecay::G4ITDecay(), G4MuonDecayChannel::G4MuonDecayChannel(), G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin(), G4NeutronBetaDecayChannel::G4NeutronBetaDecayChannel(), G4NeutronDecay::G4NeutronDecay(), G4PionRadiativeDecayChannel::G4PionRadiativeDecayChannel(), G4ProtonDecay::G4ProtonDecay(), G4SFDecay::G4SFDecay(), G4TauLeptonicDecayChannel::G4TauLeptonicDecayChannel(), G4TritonDecay::G4TritonDecay(), and G4VDecayChannel::SetDaughter().

SetDaughter() [2/2]

void G4VDecayChannel::SetDaughter ( G4int  anIndex, const G4String &  particle_name  )

inherited

Definition at line 234 of file G4VDecayChannel.cc.

{
  // check numberOfDaughters is positive
  if (numberOfDaughters<=0)
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << "G4VDecayChannel::SetDaughter() - "
             << "Number of daughters is not defined" << G4endl;
    }
#endif
    return;
  }
 
  // An analysis of this code, shows that this method is called
  // only in the constructor of derived classes.
  // The general idea of this method is probably to support
  // the possibility to re-define daughters on the fly, however
  // this design is extremely problematic for MT mode, we thus
  // require (as practically happens) that the method is called only
  // at construction, i.e. when G4MT_daughters == 0
  // moreover this method can be called only after SetNumberOfDaugthers()
  // has been called (see previous if), in such a case daughters_name != nullptr
  //
  if ( daughters_name == nullptr )
  {
    G4Exception("G4VDecayChannel::SetDaughter()", "PART112", FatalException,
      "Trying to add a daughter without specifying number of secondaries!");
    return;
  }
  if ( G4MT_daughters != nullptr )
  {
    G4Exception("G4VDecayChannel::SetDaughter()", "PART111", FatalException,
                "Trying to modify a daughter of a decay channel, \
                 but decay channel already has daughters.");
    return;
  }
 
  // check an index    
  if ( (anIndex<0) || (anIndex>=numberOfDaughters) )
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << "G4VDecayChannel::SetDaughter() - "
             << "index out of range " << anIndex << G4endl;
    }
#endif
  }
  else
  {
    // fill the name
    daughters_name[anIndex] = new G4String(particle_name);
#ifdef G4VERBOSE
    if (verboseLevel>1)
    {
      G4cout << "G4VDecayChannel::SetDaughter[" << anIndex <<"] :";
      G4cout << daughters_name[anIndex] << ":"
             << *daughters_name[anIndex]<<G4endl;
    }
#endif
  }
}

References G4VDecayChannel::daughters_name, FatalException, G4cout, G4endl, G4Exception(), G4VDecayChannel::G4MT_daughters, G4VDecayChannel::numberOfDaughters, and G4VDecayChannel::verboseLevel.

SetNumberOfDaughters()

void G4VDecayChannel::SetNumberOfDaughters ( G4int  value )

inherited

Definition at line 217 of file G4VDecayChannel.cc.

{
  if (size >0)
  {
    // remove old contents
    ClearDaughtersName();
    // cleate array
    daughters_name = new G4String*[size];
    for (G4int index=0; index<size; ++index)
    {
      daughters_name[index] = nullptr;
    }
    numberOfDaughters = size;
  }
}

References G4VDecayChannel::ClearDaughtersName(), G4VDecayChannel::daughters_name, and G4VDecayChannel::numberOfDaughters.

Referenced by G4TauMinus::Definition(), G4TauPlus::Definition(), G4AlphaDecay::G4AlphaDecay(), G4BetaMinusDecay::G4BetaMinusDecay(), G4BetaPlusDecay::G4BetaPlusDecay(), G4DalitzDecayChannel::G4DalitzDecayChannel(), G4ECDecay::G4ECDecay(), G4ITDecay::G4ITDecay(), G4MuonDecayChannel::G4MuonDecayChannel(), G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin(), G4NeutronBetaDecayChannel::G4NeutronBetaDecayChannel(), G4NeutronDecay::G4NeutronDecay(), G4PionRadiativeDecayChannel::G4PionRadiativeDecayChannel(), G4ProtonDecay::G4ProtonDecay(), G4SFDecay::G4SFDecay(), G4TauLeptonicDecayChannel::G4TauLeptonicDecayChannel(), and G4TritonDecay::G4TritonDecay().

SetParent() [1/2]

void G4VDecayChannel::SetParent ( const G4ParticleDefinition *  particle_type )

inherited

Definition at line 486 of file G4VDecayChannel.cc.

{
  if (parent_type != nullptr) SetParent(parent_type->GetParticleName());
}

References G4ParticleDefinition::GetParticleName(), and G4VDecayChannel::SetParent().

Referenced by G4TauMinus::Definition(), G4TauPlus::Definition(), G4AlphaDecay::G4AlphaDecay(), G4BetaMinusDecay::G4BetaMinusDecay(), G4BetaPlusDecay::G4BetaPlusDecay(), G4DalitzDecayChannel::G4DalitzDecayChannel(), G4ECDecay::G4ECDecay(), G4ITDecay::G4ITDecay(), G4MuonDecayChannel::G4MuonDecayChannel(), G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin(), G4NeutronBetaDecayChannel::G4NeutronBetaDecayChannel(), G4NeutronDecay::G4NeutronDecay(), G4PionRadiativeDecayChannel::G4PionRadiativeDecayChannel(), G4ProtonDecay::G4ProtonDecay(), G4SFDecay::G4SFDecay(), G4TauLeptonicDecayChannel::G4TauLeptonicDecayChannel(), G4TritonDecay::G4TritonDecay(), and G4VDecayChannel::SetParent().

SetParent() [2/2]

void G4VDecayChannel::SetParent ( const G4String &  particle_name )

inlineinherited

Definition at line 278 of file G4VDecayChannel.hh.

{
  if (parent_name != nullptr) delete parent_name;
  parent_name = new G4String(particle_name);
  G4MT_parent = nullptr;
}

References G4VDecayChannel::G4MT_parent, and G4VDecayChannel::parent_name.

SetParentMass()

void G4GeneralPhaseSpaceDecay::SetParentMass ( const G4double  aParentMass )

inline

Definition at line 112 of file G4GeneralPhaseSpaceDecay.hh.

{
  parentmass = aParentMass;
}

References parentmass.

SetPolarization()

void G4VDecayChannel::SetPolarization ( const G4ThreeVector &  polar )

inlineinherited

Definition at line 325 of file G4VDecayChannel.hh.

{
  parent_polarization = polar;
}

References G4VDecayChannel::parent_polarization.

Referenced by G4DecayWithSpin::AtRestDoIt(), and G4DecayWithSpin::PostStepDoIt().

SetRangeMass()

void G4VDecayChannel::SetRangeMass ( G4double  val )

inlineinherited

Definition at line 322 of file G4VDecayChannel.hh.

{ if(val>=0.) rangeMass=val; }

References G4VDecayChannel::rangeMass.

SetVerboseLevel()

void G4VDecayChannel::SetVerboseLevel ( G4int  value )

inlineinherited

Definition at line 304 of file G4VDecayChannel.hh.

{
  verboseLevel = value;
}

References G4VDecayChannel::verboseLevel.

Referenced by G4Decay::DecayIt(), and G4MuonicAtomDecay::DecayIt().

ThreeBodyDecayIt()

G4DecayProducts * G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt ( )

protected

Definition at line 259 of file G4GeneralPhaseSpaceDecay.cc.

{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt()"<<G4endl;
 
  //daughters'mass
  G4double daughtermass[3]; 
  G4double sumofdaughtermass = 0.0;
  for (G4int index=0; index<3; index++)
    {
     if ( theDaughterMasses )
     { 
         daughtermass[index]= *(theDaughterMasses+index);
     } else {   
         daughtermass[index] = G4MT_daughters[index]->GetPDGMass();
     }   
     sumofdaughtermass += daughtermass[index];
    }
  
  //create parent G4DynamicParticle at rest
  G4ParticleMomentum dummy;
  G4DynamicParticle * parentparticle = new G4DynamicParticle( G4MT_parent, dummy, 0.0);
 
  //create G4Decayproducts
  G4DecayProducts *products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
 
  //calculate daughter momentum
  //  Generate two 
  G4double rd1, rd2, rd;
  G4double daughtermomentum[3];
  G4double momentummax=0.0, momentumsum = 0.0;
  G4double energy;
  const G4int maxNumberOfLoops = 10000;
  G4int loopCounter = 0;
 
  do 
    {
     rd1 = G4UniformRand();
     rd2 = G4UniformRand();
     if (rd2 > rd1) 
       {
        rd  = rd1;
        rd1 = rd2;
        rd2 = rd;
       } 
     momentummax = 0.0;
     momentumsum = 0.0;
     // daughter 0
 
     energy = rd2*(parentmass - sumofdaughtermass);
     daughtermomentum[0] = std::sqrt(energy*energy + 2.0*energy* daughtermass[0]);
     if ( daughtermomentum[0] >momentummax )momentummax =  daughtermomentum[0];
     momentumsum  +=  daughtermomentum[0];
 
     // daughter 1
     energy = (1.-rd1)*(parentmass - sumofdaughtermass);
     daughtermomentum[1] = std::sqrt(energy*energy + 2.0*energy* daughtermass[1]);
     if ( daughtermomentum[1] >momentummax )momentummax =  daughtermomentum[1];
     momentumsum  +=  daughtermomentum[1];
 
     // daughter 2
     energy = (rd1-rd2)*(parentmass - sumofdaughtermass);
     daughtermomentum[2] = std::sqrt(energy*energy + 2.0*energy* daughtermass[2]);
     if ( daughtermomentum[2] >momentummax )momentummax =  daughtermomentum[2];
     momentumsum  +=  daughtermomentum[2];
    } while ( ( momentummax >  momentumsum - momentummax ) &&  /* Loop checking, 02.11.2015, A.Ribon */ 
              ++loopCounter < maxNumberOfLoops );
    if ( loopCounter >= maxNumberOfLoops ) {
      G4ExceptionDescription ed;
      ed << " Failed sampling after maxNumberOfLoops attempts : forced exit" << G4endl;
      G4Exception( " G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt ", "HAD_PHASESPACE_001", FatalException, ed );
    }
 
  // output message
  if (GetVerboseLevel()>1) {
    G4cout << "     daughter 0:" << daughtermomentum[0]/GeV << "[GeV/c]" <<G4endl;
    G4cout << "     daughter 1:" << daughtermomentum[1]/GeV << "[GeV/c]" <<G4endl;
    G4cout << "     daughter 2:" << daughtermomentum[2]/GeV << "[GeV/c]" <<G4endl;
    G4cout << "   momentum sum:" << momentumsum/GeV << "[GeV/c]" <<G4endl;
  }
 
  //create daughter G4DynamicParticle 
  G4double costheta, sintheta, phi, sinphi, cosphi; 
  G4double costhetan, sinthetan, phin, sinphin, cosphin; 
  costheta = 2.*G4UniformRand()-1.0;
  sintheta = std::sqrt((1.0-costheta)*(1.0+costheta));
  phi  = twopi*G4UniformRand()*rad;
  sinphi = std::sin(phi);
  cosphi = std::cos(phi);
  G4ParticleMomentum direction0(sintheta*cosphi,sintheta*sinphi,costheta);
  G4double Etotal=std::sqrt( daughtermass[0]*daughtermass[0] + daughtermomentum[0]*daughtermomentum[0]);
  G4DynamicParticle * daughterparticle 
         = new G4DynamicParticle( G4MT_daughters[0], Etotal, direction0*daughtermomentum[0]);
  products->PushProducts(daughterparticle);
 
  costhetan = (daughtermomentum[1]*daughtermomentum[1]-daughtermomentum[2]*daughtermomentum[2]-daughtermomentum[0]*daughtermomentum[0])/(2.0*daughtermomentum[2]*daughtermomentum[0]);
  sinthetan = std::sqrt((1.0-costhetan)*(1.0+costhetan));
  phin  = twopi*G4UniformRand()*rad;
  sinphin = std::sin(phin);
  cosphin = std::cos(phin);
  G4ParticleMomentum direction2;
  direction2.setX( sinthetan*cosphin*costheta*cosphi - sinthetan*sinphin*sinphi + costhetan*sintheta*cosphi); 
  direction2.setY( sinthetan*cosphin*costheta*sinphi + sinthetan*sinphin*cosphi + costhetan*sintheta*sinphi); 
  direction2.setZ( -sinthetan*cosphin*sintheta + costhetan*costheta);
  Etotal=std::sqrt( daughtermass[2]*daughtermass[2] + daughtermomentum[2]*daughtermomentum[2]/direction2.mag2());
  daughterparticle = new G4DynamicParticle( G4MT_daughters[2],Etotal, direction2*(daughtermomentum[2]/direction2.mag()));
  products->PushProducts(daughterparticle);
  G4ThreeVector mom=(direction0*daughtermomentum[0] + direction2*(daughtermomentum[2]/direction2.mag()))*(-1.0);
  Etotal= std::sqrt( daughtermass[1]*daughtermass[1] + mom.mag2() );
  daughterparticle = 
       new G4DynamicParticle(G4MT_daughters[1], Etotal, mom);
  products->PushProducts(daughterparticle);
 
  if (GetVerboseLevel()>1) {
     G4cout << "G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt ";
     G4cout << "  create decay products in rest frame " <<G4endl;
     products->DumpInfo();
  }
  return products;
}

References G4DecayProducts::DumpInfo(), G4INCL::KinematicsUtils::energy(), FatalException, G4cout, G4endl, G4Exception(), G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_parent, G4UniformRand, G4ParticleDefinition::GetPDGMass(), G4VDecayChannel::GetVerboseLevel(), GeV, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), parentmass, G4DecayProducts::PushProducts(), rad, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), theDaughterMasses, and twopi.

Referenced by DecayIt().

TwoBodyDecayIt()

G4DecayProducts * G4GeneralPhaseSpaceDecay::TwoBodyDecayIt ( )

protected

Definition at line 209 of file G4GeneralPhaseSpaceDecay.cc.

{
  if (GetVerboseLevel()>1) G4cout << "G4GeneralPhaseSpaceDecay::TwoBodyDecayIt()"<<G4endl;
  
  //daughters'mass
  G4double daughtermass[2]; 
  G4double daughtermomentum;
  if ( theDaughterMasses )
  { 
     daughtermass[0]= *(theDaughterMasses);
     daughtermass[1] = *(theDaughterMasses+1);
  } else {   
     daughtermass[0] = G4MT_daughters[0]->GetPDGMass();
     daughtermass[1] = G4MT_daughters[1]->GetPDGMass();
  }
  
//  G4double sumofdaughtermass =  daughtermass[0] + daughtermass[1];
 
  //create parent G4DynamicParticle at rest
  G4ParticleMomentum dummy;
  G4DynamicParticle * parentparticle = new G4DynamicParticle( G4MT_parent, dummy, 0.0);
 
  //create G4Decayproducts  @@GF why dummy parentparticle?
  G4DecayProducts *products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
 
  //calculate daughter momentum
  daughtermomentum = Pmx(parentmass,daughtermass[0],daughtermass[1]);
  G4double costheta = 2.*G4UniformRand()-1.0;
  G4double sintheta = std::sqrt((1.0 - costheta)*(1.0 + costheta));
  G4double phi  = twopi*G4UniformRand()*rad;
  G4ParticleMomentum direction(sintheta*std::cos(phi),sintheta*std::sin(phi),costheta);
 
  //create daughter G4DynamicParticle
  G4double Etotal= std::sqrt(daughtermass[0]*daughtermass[0] + daughtermomentum*daughtermomentum); 
  G4DynamicParticle * daughterparticle = new G4DynamicParticle( G4MT_daughters[0],Etotal, direction*daughtermomentum);
  products->PushProducts(daughterparticle);
  Etotal= std::sqrt(daughtermass[1]*daughtermass[1] + daughtermomentum*daughtermomentum);
  daughterparticle = new G4DynamicParticle( G4MT_daughters[1],Etotal, direction*(-1.0*daughtermomentum));
  products->PushProducts(daughterparticle);
 
  if (GetVerboseLevel()>1) 
    {
     G4cout << "G4GeneralPhaseSpaceDecay::TwoBodyDecayIt ";
     G4cout << "  create decay products in rest frame " <<G4endl;
     products->DumpInfo();
    }
  return products;
}

References G4DecayProducts::DumpInfo(), G4cout, G4endl, G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_parent, G4UniformRand, G4ParticleDefinition::GetPDGMass(), G4VDecayChannel::GetVerboseLevel(), parentmass, Pmx(), G4DecayProducts::PushProducts(), rad, theDaughterMasses, and twopi.

Referenced by DecayIt().

Field Documentation

daughters_name

G4String** G4VDecayChannel::daughters_name = nullptr

protectedinherited

Definition at line 158 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::ClearDaughtersName(), G4KL3DecayChannel::DecayIt(), G4VDecayChannel::DumpInfo(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetDaughterName(), G4PhaseSpaceDecayChannel::ManyBodyDecayIt(), ManyBodyDecayIt(), G4DalitzDecayChannel::operator=(), G4KL3DecayChannel::operator=(), G4MuonDecayChannel::operator=(), G4MuonDecayChannelWithSpin::operator=(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), G4VDecayChannel::SetDaughter(), and G4VDecayChannel::SetNumberOfDaughters().

daughtersMutex

G4Mutex G4VDecayChannel::daughtersMutex

protectedinherited

Definition at line 177 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::CheckAndFillDaughters(), G4VDecayChannel::ClearDaughtersName(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::operator=(), and G4VDecayChannel::~G4VDecayChannel().

G4MT_daughters

G4ParticleDefinition** G4VDecayChannel::G4MT_daughters = nullptr

protectedinherited

Definition at line 173 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::CheckAndFillDaughters(), G4VDecayChannel::ClearDaughtersName(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4NeutronBetaDecayChannel::DecayIt(), G4PionRadiativeDecayChannel::DecayIt(), G4TauLeptonicDecayChannel::DecayIt(), G4AlphaDecay::DecayIt(), G4BetaMinusDecay::DecayIt(), G4BetaPlusDecay::DecayIt(), G4ECDecay::DecayIt(), G4NeutronDecay::DecayIt(), G4ProtonDecay::DecayIt(), G4TritonDecay::DecayIt(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::GetAngularMomentum(), G4VDecayChannel::GetDaughter(), G4PhaseSpaceDecayChannel::ManyBodyDecayIt(), ManyBodyDecayIt(), G4PhaseSpaceDecayChannel::OneBodyDecayIt(), OneBodyDecayIt(), G4VDecayChannel::SetDaughter(), G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), ThreeBodyDecayIt(), G4PhaseSpaceDecayChannel::TwoBodyDecayIt(), and TwoBodyDecayIt().

G4MT_daughters_mass

G4double* G4VDecayChannel::G4MT_daughters_mass = nullptr

protectedinherited

Definition at line 175 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::ClearDaughtersName(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::GetDaughterMass(), G4VDecayChannel::IsOKWithParentMass(), G4PhaseSpaceDecayChannel::ManyBodyDecayIt(), G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), G4PhaseSpaceDecayChannel::TwoBodyDecayIt(), and G4VDecayChannel::~G4VDecayChannel().

G4MT_daughters_width

G4double* G4VDecayChannel::G4MT_daughters_width = nullptr

protectedinherited

Definition at line 176 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::ClearDaughtersName(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::IsOKWithParentMass(), G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), G4PhaseSpaceDecayChannel::TwoBodyDecayIt(), and G4VDecayChannel::~G4VDecayChannel().

G4MT_parent

G4ParticleDefinition* G4VDecayChannel::G4MT_parent = nullptr

protectedinherited

Definition at line 172 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::CheckAndFillParent(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4NeutronBetaDecayChannel::DecayIt(), G4PionRadiativeDecayChannel::DecayIt(), G4TauLeptonicDecayChannel::DecayIt(), G4AlphaDecay::DecayIt(), G4BetaMinusDecay::DecayIt(), G4BetaPlusDecay::DecayIt(), G4ECDecay::DecayIt(), G4ITDecay::DecayIt(), G4NeutronDecay::DecayIt(), G4ProtonDecay::DecayIt(), G4SFDecay::DecayIt(), G4TritonDecay::DecayIt(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::FillParent(), G4GeneralPhaseSpaceDecay(), G4VDecayChannel::GetAngularMomentum(), G4VDecayChannel::GetParent(), G4PhaseSpaceDecayChannel::ManyBodyDecayIt(), ManyBodyDecayIt(), G4PhaseSpaceDecayChannel::OneBodyDecayIt(), OneBodyDecayIt(), G4VDecayChannel::SetParent(), G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), ThreeBodyDecayIt(), G4PhaseSpaceDecayChannel::TwoBodyDecayIt(), and TwoBodyDecayIt().

G4MT_parent_mass

G4double G4VDecayChannel::G4MT_parent_mass = 0.0

protectedinherited

Definition at line 174 of file G4VDecayChannel.hh.

Referenced by G4PhaseSpaceDecayChannel::DecayIt(), G4VDecayChannel::FillParent(), and G4VDecayChannel::GetParentMass().

kinematics_name

G4String G4VDecayChannel::kinematics_name = ""

protectedinherited

Definition at line 152 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::DumpInfo(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetKinematicsName(), G4DalitzDecayChannel::operator=(), G4KL3DecayChannel::operator=(), G4MuonDecayChannel::operator=(), G4MuonDecayChannelWithSpin::operator=(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), and G4VDecayChannel::operator=().

noName

const G4String G4VDecayChannel::noName = " "

staticprotectedinherited

Definition at line 170 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::GetNoName().

numberOfDaughters

G4int G4VDecayChannel::numberOfDaughters = 0

protectedinherited

Definition at line 180 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::ClearDaughtersName(), DecayIt(), G4PhaseSpaceDecayChannel::DecayIt(), G4VDecayChannel::DumpInfo(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetAngularMomentum(), G4VDecayChannel::GetDaughter(), G4VDecayChannel::GetDaughterMass(), G4VDecayChannel::GetDaughterName(), G4VDecayChannel::GetNumberOfDaughters(), G4PhaseSpaceDecayChannel::IsOKWithParentMass(), G4VDecayChannel::IsOKWithParentMass(), G4PhaseSpaceDecayChannel::ManyBodyDecayIt(), ManyBodyDecayIt(), G4DalitzDecayChannel::operator=(), G4KL3DecayChannel::operator=(), G4MuonDecayChannel::operator=(), G4MuonDecayChannelWithSpin::operator=(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), G4VDecayChannel::SetDaughter(), G4PhaseSpaceDecayChannel::SetDaughterMasses(), and G4VDecayChannel::SetNumberOfDaughters().

parent_name

G4String* G4VDecayChannel::parent_name = nullptr

protectedinherited

Definition at line 156 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::ClearDaughtersName(), DecayIt(), G4PhaseSpaceDecayChannel::DecayIt(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::FillParent(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetParentName(), G4PhaseSpaceDecayChannel::ManyBodyDecayIt(), ManyBodyDecayIt(), G4DalitzDecayChannel::operator=(), G4KL3DecayChannel::operator=(), G4MuonDecayChannel::operator=(), G4MuonDecayChannelWithSpin::operator=(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), G4VDecayChannel::SetParent(), and G4VDecayChannel::~G4VDecayChannel().

parent_polarization

G4ThreeVector G4VDecayChannel::parent_polarization

protectedinherited

Definition at line 164 of file G4VDecayChannel.hh.

Referenced by G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetPolarization(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4VDecayChannel::operator=(), and G4VDecayChannel::SetPolarization().

parentmass

G4double G4GeneralPhaseSpaceDecay::parentmass

private

Definition at line 100 of file G4GeneralPhaseSpaceDecay.hh.

Referenced by G4GeneralPhaseSpaceDecay(), GetParentMass(), ManyBodyDecayIt(), SetParentMass(), ThreeBodyDecayIt(), and TwoBodyDecayIt().

parentMutex

G4Mutex G4VDecayChannel::parentMutex

protectedinherited

Definition at line 178 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::CheckAndFillParent(), G4VDecayChannel::FillParent(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::operator=(), and G4VDecayChannel::~G4VDecayChannel().

particletable

G4ParticleTable* G4VDecayChannel::particletable = nullptr

protectedinherited

Definition at line 167 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::FillDaughters(), G4VDecayChannel::FillParent(), G4VDecayChannel::G4VDecayChannel(), and G4VDecayChannel::operator=().

rangeMass

G4double G4VDecayChannel::rangeMass = 2.5

protectedinherited

Definition at line 161 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::DynamicalMass(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetRangeMass(), G4VDecayChannel::IsOKWithParentMass(), G4VDecayChannel::operator=(), G4VDecayChannel::SetRangeMass(), G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), and G4PhaseSpaceDecayChannel::TwoBodyDecayIt().

rbranch

G4double G4VDecayChannel::rbranch = 0.0

protectedinherited

Definition at line 154 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::DumpInfo(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetBR(), G4VDecayChannel::operator<(), G4DalitzDecayChannel::operator=(), G4KL3DecayChannel::operator=(), G4MuonDecayChannel::operator=(), G4MuonDecayChannelWithSpin::operator=(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), and G4VDecayChannel::SetBR().

theDaughterMasses

const G4double* G4GeneralPhaseSpaceDecay::theDaughterMasses

private

Definition at line 101 of file G4GeneralPhaseSpaceDecay.hh.

Referenced by ThreeBodyDecayIt(), and TwoBodyDecayIt().

verboseLevel

G4int G4VDecayChannel::verboseLevel = 1

protectedinherited

Definition at line 183 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::ClearDaughtersName(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::FillParent(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetAngularMomentum(), G4VDecayChannel::GetDaughter(), G4VDecayChannel::GetDaughterMass(), G4VDecayChannel::GetDaughterName(), G4VDecayChannel::GetVerboseLevel(), G4DalitzDecayChannel::operator=(), G4KL3DecayChannel::operator=(), G4MuonDecayChannel::operator=(), G4MuonDecayChannelWithSpin::operator=(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), G4VDecayChannel::SetDaughter(), and G4VDecayChannel::SetVerboseLevel().

---

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

• source/processes/hadronic/util/include/G4GeneralPhaseSpaceDecay.hh
• source/processes/hadronic/util/src/G4GeneralPhaseSpaceDecay.cc