G4PhaseSpaceDecayChannel Class Reference

#include <G4PhaseSpaceDecayChannel.hh>

Inheritance diagram for G4PhaseSpaceDecayChannel:

Public Types
enum	{ MAX_N_DAUGHTERS =5 }

Public Member Functions
virtual G4DecayProducts *	DecayIt (G4double)
void	DumpInfo ()
	G4PhaseSpaceDecayChannel (const G4String &theParentName, G4double theBR, G4int theNumberOfDaughters, const G4String &theDaughterName1, const G4String &theDaughterName2="", const G4String &theDaughterName3="", const G4String &theDaughterName4="", const G4String &theDaughterName5="")
	G4PhaseSpaceDecayChannel (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
G4bool	IsOKWithParentMass (G4double parentMass)
G4bool	operator!= (const G4VDecayChannel &r) const
G4bool	operator< (const G4VDecayChannel &right) const
G4bool	operator== (const G4VDecayChannel &r) const
G4bool	SampleDaughterMasses ()
void	SetBR (G4double value)
void	SetDaughter (G4int anIndex, const G4ParticleDefinition *particle_type)
void	SetDaughter (G4int anIndex, const G4String &particle_name)
G4bool	SetDaughterMasses (G4double masses[])
void	SetNumberOfDaughters (G4int value)
void	SetParent (const G4ParticleDefinition *particle_type)
void	SetParent (const G4String &particle_name)
void	SetPolarization (const G4ThreeVector &)
void	SetRangeMass (G4double val)
void	SetVerboseLevel (G4int value)
virtual	~G4PhaseSpaceDecayChannel ()

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

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
G4DecayProducts *	ManyBodyDecayIt ()
G4DecayProducts *	OneBodyDecayIt ()
G4DecayProducts *	ThreeBodyDecayIt ()
G4DecayProducts *	TwoBodyDecayIt ()

Private Attributes
G4Cache< G4double >	current_parent_mass
G4double	givenDaughterMasses [MAX_N_DAUGHTERS]
G4bool	useGivenDaughterMass = false

Detailed Description

Definition at line 42 of file G4PhaseSpaceDecayChannel.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
MAX_N_DAUGHTERS

Definition at line 46 of file G4PhaseSpaceDecayChannel.hh.

{ MAX_N_DAUGHTERS=5 }; 

Constructor & Destructor Documentation

G4PhaseSpaceDecayChannel() [1/2]

G4PhaseSpaceDecayChannel::G4PhaseSpaceDecayChannel

(

G4int

Verbose = 1

)

Definition at line 42 of file G4PhaseSpaceDecayChannel.cc.

  : G4VDecayChannel("Phase Space", Verbose)
{
}

G4PhaseSpaceDecayChannel() [2/2]

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

Definition at line 47 of file G4PhaseSpaceDecayChannel.cc.

  : G4VDecayChannel("Phase Space", theParentName,theBR, theNumberOfDaughters,
                    theDaughterName1, theDaughterName2,
                    theDaughterName3, theDaughterName4, theDaughterName5)
{
}

~G4PhaseSpaceDecayChannel()

G4PhaseSpaceDecayChannel::~G4PhaseSpaceDecayChannel ( )

virtual

Definition at line 63 of file G4PhaseSpaceDecayChannel.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 G4GeneralPhaseSpaceDecay::DecayIt(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4NeutronBetaDecayChannel::DecayIt(), DecayIt(), G4PionRadiativeDecayChannel::DecayIt(), G4TauLeptonicDecayChannel::DecayIt(), G4AlphaDecay::DecayIt(), G4BetaMinusDecay::DecayIt(), G4BetaPlusDecay::DecayIt(), G4ECDecay::DecayIt(), G4NeutronDecay::DecayIt(), G4ProtonDecay::DecayIt(), G4TritonDecay::DecayIt(), G4VDecayChannel::GetAngularMomentum(), G4VDecayChannel::GetDaughter(), 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 G4GeneralPhaseSpaceDecay::DecayIt(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4NeutronBetaDecayChannel::DecayIt(), 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(), 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 * G4PhaseSpaceDecayChannel::DecayIt ( G4double  parentMass )

virtual

Implements G4VDecayChannel.

Definition at line 68 of file G4PhaseSpaceDecayChannel.cc.

{
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    G4cout << "G4PhaseSpaceDecayChannel::DecayIt()" << G4endl;
#endif
  
  G4DecayProducts* products = nullptr;
 
  CheckAndFillParent();
  CheckAndFillDaughters();
 
  if (parentMass >0.0) current_parent_mass.Put( parentMass );
  else                 current_parent_mass.Put(G4MT_parent_mass);
 
  switch (numberOfDaughters)
  {
    case 0:
#ifdef G4VERBOSE
      if (GetVerboseLevel()>0)
      {
        G4cout << "G4PhaseSpaceDecayChannel::DecayIt() -";
        G4cout << " daughters not defined " << G4endl;
      }
#endif
      break;
    case 1:
      products = OneBodyDecayIt();
      break;
    case 2:
      products = TwoBodyDecayIt();
      break;
    case 3:
      products = ThreeBodyDecayIt();
      break;
    default:
      products = ManyBodyDecayIt();
      break;
  }
#ifdef G4VERBOSE
  if ((products == nullptr) && (GetVerboseLevel()>0))
  {
    G4cout << "G4PhaseSpaceDecayChannel::DecayIt() - ";
    G4cout << *parent_name << " cannot decay " << G4endl;
    DumpInfo();
  }
#endif
  return products;
}

References G4VDecayChannel::CheckAndFillDaughters(), G4VDecayChannel::CheckAndFillParent(), current_parent_mass, G4VDecayChannel::DumpInfo(), G4cout, G4endl, G4VDecayChannel::G4MT_parent_mass, G4VDecayChannel::GetVerboseLevel(), ManyBodyDecayIt(), G4VDecayChannel::numberOfDaughters, OneBodyDecayIt(), G4VDecayChannel::parent_name, G4Cache< VALTYPE >::Put(), ThreeBodyDecayIt(), and TwoBodyDecayIt().

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 G4GeneralPhaseSpaceDecay::DecayIt(), 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 ThreeBodyDecayIt(), and 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 G4VDecayChannel::GetParentMass ( ) const

inlineinherited

Definition at line 272 of file G4VDecayChannel.hh.

{
  return G4MT_parent_mass;
}

References G4VDecayChannel::G4MT_parent_mass.

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(), G4GeneralPhaseSpaceDecay::DecayIt(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), G4MuonRadiativeDecayChannelWithSpin::DecayIt(), G4NeutronBetaDecayChannel::DecayIt(), DecayIt(), G4PionRadiativeDecayChannel::DecayIt(), G4TauLeptonicDecayChannel::DecayIt(), G4VDecayChannel::FillDaughters(), G4GeneralPhaseSpaceDecay::G4GeneralPhaseSpaceDecay(), G4KL3DecayChannel::G4KL3DecayChannel(), G4MuonDecayChannel::G4MuonDecayChannel(), G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin(), G4NeutronBetaDecayChannel::G4NeutronBetaDecayChannel(), G4PionRadiativeDecayChannel::G4PionRadiativeDecayChannel(), G4TauLeptonicDecayChannel::G4TauLeptonicDecayChannel(), ManyBodyDecayIt(), G4GeneralPhaseSpaceDecay::ManyBodyDecayIt(), OneBodyDecayIt(), G4GeneralPhaseSpaceDecay::OneBodyDecayIt(), G4KL3DecayChannel::PhaseSpace(), ThreeBodyDecayIt(), G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt(), TwoBodyDecayIt(), and G4GeneralPhaseSpaceDecay::TwoBodyDecayIt().

IsOKWithParentMass()

G4bool G4PhaseSpaceDecayChannel::IsOKWithParentMass ( G4double  parentMass )

virtual

Reimplemented from G4VDecayChannel.

Definition at line 853 of file G4PhaseSpaceDecayChannel.cc.

{
  if (!useGivenDaughterMass)
    return G4VDecayChannel::IsOKWithParentMass(parentMass);
 
  CheckAndFillParent();
  CheckAndFillDaughters();
 
  G4double sumOfDaughterMassMin=0.0;
  for (G4int index=0; index<numberOfDaughters; ++index)
  { 
    sumOfDaughterMassMin += givenDaughterMasses[index];
  }
  return (parentMass >= sumOfDaughterMassMin); 
}

References G4VDecayChannel::CheckAndFillDaughters(), G4VDecayChannel::CheckAndFillParent(), givenDaughterMasses, G4VDecayChannel::IsOKWithParentMass(), G4VDecayChannel::numberOfDaughters, and useGivenDaughterMass.

ManyBodyDecayIt()

G4DecayProducts * G4PhaseSpaceDecayChannel::ManyBodyDecayIt ( )

private

Definition at line 530 of file G4PhaseSpaceDecayChannel.cc.

{
  // Algorithm of this code originally written in FORTRAN by M.Asai
  // **************************************************************
  // NBODY - N-body phase space Monte-Carlo generator
  // Makoto Asai - Hiroshima Institute of Technology
  // Revised release : 19/Apr/1995
 
  G4int index, index2;
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt()" << G4endl;
#endif
 
  // parent mass
  G4double parentmass = current_parent_mass.Get();
 
  // parent particle
  G4ThreeVector dummy;
  G4DynamicParticle* parentparticle
    = new G4DynamicParticle( G4MT_parent, dummy, 0.0, parentmass);
 
  // create G4Decayproducts
  G4DecayProducts* products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
 
  // daughters'mass
  G4double* daughtermass = new G4double[numberOfDaughters]; 
    
  G4double sumofdaughtermass = 0.0;
  for (index=0; index<numberOfDaughters; ++index)
  {
    if (!useGivenDaughterMass)
    {
      daughtermass[index] = G4MT_daughters_mass[index];
    }
    else
    {
      daughtermass[index] = givenDaughterMasses[index];
    }
    sumofdaughtermass += daughtermass[index];
  }
  if (sumofdaughtermass >parentmass)
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt()" << G4endl
             << "Sum of daughter mass is larger than parent mass!" << G4endl;
      G4cout << "Parent :" << G4MT_parent->GetParticleName()
             << "  " << current_parent_mass.Get()/GeV << G4endl;
      G4cout << "Daughter 1 :" << G4MT_daughters[0]->GetParticleName()
             << "  " << daughtermass[0]/GeV << G4endl;
      G4cout << "Daughter 2:" << G4MT_daughters[1]->GetParticleName()
             << "  " << daughtermass[1]/GeV << G4endl;
      G4cout << "Daughter 3:" << G4MT_daughters[2]->GetParticleName()
             << "  " << daughtermass[2]/GeV << G4endl;
      G4cout << "Daughter 4:" << G4MT_daughters[3]->GetParticleName()
             << "  " << daughtermass[3]/GeV << G4endl;
      G4cout << "Daughter 5:" << G4MT_daughters[4]->GetParticleName()
             << "  " << daughtermass[4]/GeV << G4endl;
    }
#endif
    G4Exception("G4PhaseSpaceDecayChannel::ManyBodyDecayIt()",
                "PART112", JustWarning,
                "Can not create decay products: sum of daughter mass \
                 is larger than parent mass!");
    delete [] daughtermass;
    return products;
  }  
 
  // Calculate daughter momentum
  G4double* daughtermomentum = new G4double[numberOfDaughters];
  G4ThreeVector direction;  
  G4DynamicParticle** daughterparticle;
  G4double* sm = new G4double[numberOfDaughters];
  G4double tmas;
  G4double weight = 1.0;
  G4int numberOfTry = 0;
  const std::size_t MAX_LOOP=10000;
 
  for (std::size_t loop_counter=0; loop_counter<MAX_LOOP; ++loop_counter)
  {
    // Generate rundom number in descending order 
    G4double temp;
    G4double* rd = new G4double[numberOfDaughters];
    rd[0] = 1.0;
    for( index=1; index<numberOfDaughters-1; ++index )
    {
      rd[index] = G4UniformRand();
    }
    rd[ numberOfDaughters -1] = 0.0;
    for( index=1; index<numberOfDaughters-1; ++index)
    {
      for( index2=index+1; index2<numberOfDaughters; ++index2)
      {
        if (rd[index] < rd[index2])
        {
          temp       = rd[index];
          rd[index]  = rd[index2];
          rd[index2] = temp;
        }
      }
    }
    
    // calculate virtual mass 
    tmas = parentmass -  sumofdaughtermass;
    temp =  sumofdaughtermass; 
    for( index=0; index<numberOfDaughters; ++index )
    {
      sm[index] = rd[index]*tmas + temp;
      temp -= daughtermass[index];
      if (GetVerboseLevel()>1)
      {
        G4cout << index << "  rundom number:" << rd[index]; 
        G4cout << "   virtual mass:" << sm[index]/GeV << "[GeV/c/c]" << G4endl; 
      }
    }
    delete [] rd;
 
    // Calculate daughter momentum
    weight = 1.0;
    G4bool smOK=true;
    for( index=0; index<numberOfDaughters-1 && smOK; ++index )
    {
      smOK = (sm[index]-daughtermass[index]- sm[index+1] >=0.); 
    }
    if (!smOK) continue;
 
    index = numberOfDaughters-1;
    daughtermomentum[index]= Pmx(sm[index-1],daughtermass[index-1],sm[index]);
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1)
    {
      G4cout << "     daughter " << index << ":" << *daughters_name[index];
      G4cout << " momentum:" << daughtermomentum[index]/GeV << "[GeV/c]"
             << G4endl;
    }
#endif
    for( index=numberOfDaughters-2; index>=0; --index)
    {
      // calculate 
      daughtermomentum[index]= Pmx( sm[index],daughtermass[index],sm[index +1]);
      if(daughtermomentum[index] < 0.0)
      {
        // !!! illegal momentum !!!
#ifdef G4VERBOSE
        if (GetVerboseLevel()>0)
        {
          G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt()" << G4endl;
          G4cout << "     Cannot calculate daughter momentum " << G4endl;
          G4cout << "     parent:" << *parent_name;
          G4cout << " mass:" << parentmass/GeV << "[GeV/c/c]" << G4endl;
          G4cout << "     daughter " << index << ":" << *daughters_name[index];
          G4cout << " mass:" << daughtermass[index]/GeV << "[GeV/c/c]";
          G4cout << " mass:" << daughtermomentum[index]/GeV << "[GeV/c]"
                 << G4endl;
          if (useGivenDaughterMass)
          {
            G4cout << "Daughter Mass is given." << G4endl;
          }
        }
#endif
        delete [] sm;
        delete [] daughtermass;
        delete [] daughtermomentum;
        delete products;
        G4Exception("G4PhaseSpaceDecayChannel::ManyBodyDecayIt()",
                    "PART112", JustWarning,
                    "Can not create decay products: sum of daughter mass \
                     is larger than parent mass");
        return nullptr;   // Error detection
 
      }
      else
      {
        // calculate weight of this events
        weight *=  daughtermomentum[index]/sm[index];
#ifdef G4VERBOSE
        if (GetVerboseLevel()>1)
        {
          G4cout << "     daughter " << index << ":" << *daughters_name[index];
          G4cout << " momentum:" << daughtermomentum[index]/GeV << "[GeV/c]"
                 << G4endl;
        }
#endif
      }
    }
 
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1)
    {
      G4cout << "    weight: " << weight << G4endl;
    }
#endif
    
    // exit if number of Try exceeds 100
    if (++numberOfTry > 100)
    {
#ifdef G4VERBOSE
      if (GetVerboseLevel()>0)
      {
        G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt()" << G4endl;
        G4cout << "Cannot determine Decay Kinematics " << G4endl;
        G4cout << "parent : " << *parent_name << G4endl;
        G4cout << "daughters : "; 
        for(index=0; index<numberOfDaughters; ++index)
        {
          G4cout <<  *daughters_name[index] << " , ";
        }
        G4cout << G4endl;
      }
#endif
      G4Exception("G4PhaseSpaceDecayChannel::ManyBodyDecayIt()",
                  "PART113", JustWarning,
                  "Cannot decay: Decay Kinematics cannot be calculated");
      
      delete [] sm;
      delete [] daughtermass;
      delete [] daughtermomentum;
      delete products;
      return nullptr;  // Error detection
    }
    if ( weight < G4UniformRand()) break; 
  }
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
  {
    G4cout << "Start calculation of daughters momentum vector " << G4endl;
  }
#endif 
 
  G4double costheta, sintheta, phi;
  G4double beta;
  daughterparticle = new G4DynamicParticle*[numberOfDaughters];
 
  index = 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[index] = new G4DynamicParticle( G4MT_daughters[index],
                                  direction*daughtermomentum[index] );
  daughterparticle[index+1] = new G4DynamicParticle( G4MT_daughters[index+1],
                                    direction*(-1.0*daughtermomentum[index]) );
 
  for (index = numberOfDaughters-3;  index >= 0; --index)
  {
    // 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[index];
    beta /= std::sqrt( daughtermomentum[index]*daughtermomentum[index]
                     + sm[index+1]*sm[index+1] );
    for (index2 = index+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[index] = new G4DynamicParticle( G4MT_daughters[index],
                                    direction*(-1.0*daughtermomentum[index]));
  }
 
  // add daughters to G4Decayproducts
  for (index = 0; index<numberOfDaughters; ++index)
  {
    products->PushProducts(daughterparticle[index]);
  }
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
  { 
    G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt() -";
    G4cout << " create decay products in rest frame " << G4endl;
    products->DumpInfo();
  }
#endif
 
  delete [] daughterparticle;
  delete [] daughtermomentum;
  delete [] daughtermass;
  delete [] sm;
  
  return products;
}

References anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, CLHEP::HepLorentzVector::boost(), current_parent_mass, G4VDecayChannel::daughters_name, G4DecayProducts::DumpInfo(), G4cout, G4endl, G4Exception(), G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_daughters_mass, G4VDecayChannel::G4MT_parent, G4UniformRand, G4Cache< VALTYPE >::Get(), G4DynamicParticle::Get4Momentum(), G4ParticleDefinition::GetParticleName(), G4VDecayChannel::GetVerboseLevel(), GeV, givenDaughterMasses, JustWarning, G4VDecayChannel::numberOfDaughters, G4VDecayChannel::parent_name, Pmx(), G4DecayProducts::PushProducts(), rad, G4DynamicParticle::Set4Momentum(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), G4InuclParticleNames::sm, twopi, useGivenDaughterMass, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DecayIt().

OneBodyDecayIt()

G4DecayProducts * G4PhaseSpaceDecayChannel::OneBodyDecayIt ( )

private

Definition at line 119 of file G4PhaseSpaceDecayChannel.cc.

{
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    G4cout << "G4PhaseSpaceDecayChannel::OneBodyDecayIt()" << G4endl;
#endif
  // parent mass
  G4double parentmass = current_parent_mass.Get();
 
  // create parent G4DynamicParticle at rest
  G4ThreeVector dummy;
  G4DynamicParticle* parentparticle
    = new G4DynamicParticle( G4MT_parent, dummy, 0.0, parentmass);
  // create G4Decayproducts
  G4DecayProducts *products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
 
  // create daughter G4DynamicParticle at rest
  G4DynamicParticle* daughterparticle
    = new G4DynamicParticle( G4MT_daughters[0], dummy, 0.0);
  if (useGivenDaughterMass) daughterparticle->SetMass(givenDaughterMasses[0]);
  products->PushProducts(daughterparticle);
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
  {
    G4cout << "G4PhaseSpaceDecayChannel::OneBodyDecayIt() -";
    G4cout << " create decay products in rest frame " << G4endl;
    products->DumpInfo();
  }
#endif
  return products;
}

References current_parent_mass, G4DecayProducts::DumpInfo(), G4cout, G4endl, G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_parent, G4Cache< VALTYPE >::Get(), G4VDecayChannel::GetVerboseLevel(), givenDaughterMasses, G4DecayProducts::PushProducts(), G4DynamicParticle::SetMass(), and useGivenDaughterMass.

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 G4PhaseSpaceDecayChannel::Pmx ( G4double  e, G4double  p1, G4double  p2  )

static

Definition at line 870 of file G4PhaseSpaceDecayChannel.cc.

{
   // calcurate momentum of daughter particles in two-body decay
   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 G4DalitzDecayChannel::DecayIt(), ManyBodyDecayIt(), and TwoBodyDecayIt().

SampleDaughterMasses()

G4bool G4PhaseSpaceDecayChannel::SampleDaughterMasses

(

)

Definition at line 846 of file G4PhaseSpaceDecayChannel.cc.

{
  useGivenDaughterMass = false;
  return useGivenDaughterMass; 
}

References useGivenDaughterMass.

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.

SetDaughterMasses()

G4bool G4PhaseSpaceDecayChannel::SetDaughterMasses

(

G4double

masses[]

)

Definition at line 835 of file G4PhaseSpaceDecayChannel.cc.

{
  for (G4int idx=0; idx<numberOfDaughters; ++idx)
  {
    givenDaughterMasses[idx] = masses[idx];
  }
  useGivenDaughterMass = true;
  return useGivenDaughterMass; 
}

References givenDaughterMasses, G4VDecayChannel::numberOfDaughters, and useGivenDaughterMass.

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.

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 * G4PhaseSpaceDecayChannel::ThreeBodyDecayIt ( )

private

Definition at line 292 of file G4PhaseSpaceDecayChannel.cc.

{
  // Algorithm of this code originally written in GDECA3 of GEANT3
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    G4cout << "G4PhaseSpaceDecayChannel::ThreeBodyDecayIt()" << G4endl;
#endif
  // parent mass
  G4double parentmass = current_parent_mass.Get();
  // daughters'mass
  G4double daughtermass[3], daughterwidth[3]; 
  G4double sumofdaughtermass = 0.0;
  G4double sumofdaughterwidthsq = 0.0;
  G4bool withWidth = false; 
  for (G4int index=0; index<3; ++index)
  {
    daughtermass[index] = G4MT_daughters_mass[index];
    sumofdaughtermass += daughtermass[index];
    daughterwidth[index] = G4MT_daughters_width[index];
    sumofdaughterwidthsq += daughterwidth[index]*daughterwidth[index];
    withWidth = withWidth ||(daughterwidth[index]>1.0e-3*daughtermass[index]);
  }
  
  // create parent G4DynamicParticle at rest
  G4ThreeVector dummy;
  G4DynamicParticle* parentparticle
    = new G4DynamicParticle( G4MT_parent, dummy, 0.0, parentmass);
 
  // create G4Decayproducts
  G4DecayProducts* products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
 
  if (!useGivenDaughterMass)
  {
    if (withWidth)
    {
      G4double maxDev = (parentmass - sumofdaughtermass )
                      / std::sqrt(sumofdaughterwidthsq);
      if (maxDev <= -1.0*rangeMass )
      {
#ifdef G4VERBOSE
        if (GetVerboseLevel()>0)
        {
          G4cout << "G4PhaseSpaceDecayChannel::ThreeBodyDecayIt()" << G4endl
                 << "Sum of daughter mass is larger than parent mass!"
                 << G4endl;
          G4cout << "Parent :" << G4MT_parent->GetParticleName()
                 << "  " << current_parent_mass.Get()/GeV << G4endl;
          G4cout << "Daughter 1 :" << G4MT_daughters[0]->GetParticleName()
                 << "  " << daughtermass[0]/GeV << G4endl;
          G4cout << "Daughter 2:" << G4MT_daughters[1]->GetParticleName()
                 << "  " << daughtermass[1]/GeV << G4endl;
          G4cout << "Daughter 3:" << G4MT_daughters[2]->GetParticleName()
                 << "  " << daughtermass[2]/GeV << G4endl;
        }
#endif
        G4Exception("G4PhaseSpaceDecayChannel::ThreeBodyDecayIt()",
                    "PART112", JustWarning,
                    "Cannot create decay products: sum of daughter mass \
                     is larger than parent mass!");
        return products;
      }
      G4double dm1=daughtermass[0];
      if (daughterwidth[0] > 0.)
        dm1= DynamicalMass(daughtermass[0],daughterwidth[0], maxDev);
      G4double dm2= daughtermass[1];
      if (daughterwidth[1] > 0.)
        dm2= DynamicalMass(daughtermass[1],daughterwidth[1], maxDev);
      G4double dm3= daughtermass[2];
      if (daughterwidth[2] > 0.)
        dm3= DynamicalMass(daughtermass[2],daughterwidth[2], maxDev);
      while (dm1+dm2+dm3>parentmass)  // Loop checking, 09.08.2015, K.Kurashige
      {
        dm1= DynamicalMass(daughtermass[0],daughterwidth[0], maxDev);
        dm2= DynamicalMass(daughtermass[1],daughterwidth[1], maxDev);
        dm3= DynamicalMass(daughtermass[2],daughterwidth[2], maxDev);
      }
      daughtermass[0] = dm1;
      daughtermass[1] = dm2;
      daughtermass[2] = dm3;
      sumofdaughtermass = dm1+dm2+dm3;
    }
  }
  else
  {
    // use given daughter mass;
    daughtermass[0] = givenDaughterMasses[0];
    daughtermass[1] = givenDaughterMasses[1];
    daughtermass[2] = givenDaughterMasses[2];
    sumofdaughtermass = daughtermass[0] + daughtermass[1] + daughtermass[2];
  } 
 
  if (sumofdaughtermass >parentmass)
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4PhaseSpaceDecayChannel::ThreeBodyDecayIt()" << G4endl
             << "Sum of daughter mass is larger than parent mass!" << G4endl;
      G4cout << "Parent :" << G4MT_parent->GetParticleName()
             << "  " << current_parent_mass.Get()/GeV << G4endl;
      G4cout << "Daughter 1 :" << G4MT_daughters[0]->GetParticleName()
             << "  " << daughtermass[0]/GeV << G4endl;
      G4cout << "Daughter 2:" << G4MT_daughters[1]->GetParticleName()
             << "  " << daughtermass[1]/GeV << G4endl;
      G4cout << "Daughter 3:" << G4MT_daughters[2]->GetParticleName()
             << "  " << daughtermass[2]/GeV << G4endl;
    }
    if (useGivenDaughterMass)
    {
      G4cout << "Daughter Mass is given." << G4endl;
    }
#endif
    G4Exception("G4PhaseSpaceDecayChannel::ThreeBodyDecayIt",
                "PART112", JustWarning,
                "Can not create decay products: sum of daughter mass \
                 is larger than parent mass!");
    return products;
  }  
 
  // calculate daughter momentum
  // Generate two 
  G4double rd1, rd2, rd;
  G4double daughtermomentum[3];
  G4double momentummax=0.0, momentumsum = 0.0;
  G4double energy;
  const std::size_t MAX_LOOP=10000;
 
  for (std::size_t loop_counter=0; loop_counter<MAX_LOOP; ++loop_counter)
  {
    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];
    if (momentummax <=  momentumsum - momentummax ) break;
  }
 
  // output message
#ifdef G4VERBOSE
  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;
  }
#endif
 
  // 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);
 
  G4ThreeVector direction0(sintheta*cosphi,sintheta*sinphi,costheta);
  G4double Ekin = std::sqrt(daughtermomentum[0]*daughtermomentum[0]
                          + daughtermass[0]*daughtermass[0]) - daughtermass[0];
  G4DynamicParticle* daughterparticle
    = new G4DynamicParticle(G4MT_daughters[0],direction0,Ekin,daughtermass[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);
  G4ThreeVector 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);
  G4ThreeVector pmom = daughtermomentum[2]*direction2/direction2.mag();
  Ekin = std::sqrt(pmom.mag2() + daughtermass[2]*daughtermass[2])
       - daughtermass[2];
  daughterparticle = new G4DynamicParticle( G4MT_daughters[2], 
                                            pmom/pmom.mag(),
                                            Ekin, daughtermass[2] );
  products->PushProducts(daughterparticle);
 
  pmom = (direction0*daughtermomentum[0]
       + direction2*(daughtermomentum[2]/direction2.mag()))*(-1.0);
  Ekin = std::sqrt(pmom.mag2() + daughtermass[1]*daughtermass[1])
       - daughtermass[1];
  daughterparticle = new G4DynamicParticle( G4MT_daughters[1],
                                            pmom/pmom.mag(),
                                            Ekin, daughtermass[1] );
  products->PushProducts(daughterparticle);
  
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
  {
    G4cout << "G4PhaseSpaceDecayChannel::ThreeBodyDecayIt -";
    G4cout << " create decay products in rest frame " << G4endl;
    products->DumpInfo();
  }
#endif
  return products;
}

References current_parent_mass, G4DecayProducts::DumpInfo(), G4VDecayChannel::DynamicalMass(), G4INCL::KinematicsUtils::energy(), G4cout, G4endl, G4Exception(), G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_daughters_mass, G4VDecayChannel::G4MT_daughters_width, G4VDecayChannel::G4MT_parent, G4UniformRand, G4Cache< VALTYPE >::Get(), G4ParticleDefinition::GetParticleName(), G4VDecayChannel::GetVerboseLevel(), GeV, givenDaughterMasses, JustWarning, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), G4DecayProducts::PushProducts(), rad, G4VDecayChannel::rangeMass, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), twopi, and useGivenDaughterMass.

Referenced by DecayIt().

TwoBodyDecayIt()

G4DecayProducts * G4PhaseSpaceDecayChannel::TwoBodyDecayIt ( )

private

Definition at line 154 of file G4PhaseSpaceDecayChannel.cc.

{
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
    G4cout << "G4PhaseSpaceDecayChannel::TwoBodyDecayIt()" << G4endl;
#endif
  // parent mass
  G4double parentmass = current_parent_mass.Get();
  
  // daughters'mass, width
  G4double daughtermass[2], daughterwidth[2]; 
  daughtermass[0] = G4MT_daughters_mass[0];
  daughtermass[1] = G4MT_daughters_mass[1];
  daughterwidth[0] = G4MT_daughters_width[0];
  daughterwidth[1] = G4MT_daughters_width[1];
 
  // create parent G4DynamicParticle at rest
  G4ThreeVector dummy;
  G4DynamicParticle* parentparticle
    = new G4DynamicParticle( G4MT_parent, dummy, 0.0, parentmass);
  // create G4Decayproducts
  G4DecayProducts* products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
 
  if (!useGivenDaughterMass)
  {
    G4bool withWidth = (daughterwidth[0]>1.0e-3*daughtermass[0]) 
                    || (daughterwidth[1]>1.0e-3*daughtermass[1]);
    if (withWidth)
    {
      G4double sumofdaughterwidthsq = daughterwidth[0]*daughterwidth[0]
                                    + daughterwidth[1]*daughterwidth[1];
      // check parent mass and daughter mass
      G4double maxDev = (parentmass - daughtermass[0] - daughtermass[1] )
                      / std::sqrt(sumofdaughterwidthsq);
      if (maxDev <= -1.0*rangeMass )
      {
#ifdef G4VERBOSE
        if (GetVerboseLevel()>0)
        {
          G4cout << "G4PhaseSpaceDecayChannel::TwoBodyDecayIt()" << G4endl 
                 << "Sum of daughter mass is larger than parent mass!"
                 << G4endl;
          G4cout << "Parent :" << G4MT_parent->GetParticleName()
                 << "  " << current_parent_mass.Get()/GeV << G4endl;
          G4cout << "Daughter 1 :" << G4MT_daughters[0]->GetParticleName()
                 << "  " << daughtermass[0]/GeV << G4endl;
          G4cout << "Daughter 2:" << G4MT_daughters[1]->GetParticleName()
                 << "  " << daughtermass[1]/GeV << G4endl;
        }
#endif
        G4Exception("G4PhaseSpaceDecayChannel::TwoBodyDecayIt()",
                    "PART112", JustWarning,
                    "Cannot create decay products: sum of daughter mass is \
                     larger than parent mass!");
        return products;
      }
      G4double dm1=daughtermass[0];
      if (daughterwidth[0] > 0.)
        dm1 = DynamicalMass(daughtermass[0],daughterwidth[0], maxDev);
      G4double dm2= daughtermass[1];
      if (daughterwidth[1] > 0.)
        dm2 = DynamicalMass(daughtermass[1],daughterwidth[1], maxDev);
      while (dm1+dm2>parentmass)  // Loop checking, 09.08.2015, K.Kurashige
      {
        dm1 = DynamicalMass(daughtermass[0],daughterwidth[0], maxDev);
        dm2 = DynamicalMass(daughtermass[1],daughterwidth[1], maxDev);
      }
      daughtermass[0] = dm1;
      daughtermass[1] = dm2;
    }
  }
  else
  {
    // use given daughter mass;
    daughtermass[0] = givenDaughterMasses[0];
    daughtermass[1] = givenDaughterMasses[1];
  }
  if (parentmass < daughtermass[0] + daughtermass[1] )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4PhaseSpaceDecayChannel::TwoBodyDecayIt()" << G4endl
             << "Sum of daughter mass is larger than parent mass!" << G4endl;
      G4cout << "Parent :" << G4MT_parent->GetParticleName()
             << "  " << current_parent_mass.Get()/GeV << G4endl;
      G4cout << "Daughter 1 :" << G4MT_daughters[0]->GetParticleName()
             << "  " << daughtermass[0]/GeV << G4endl;
      G4cout << "Daughter 2:" << G4MT_daughters[1]->GetParticleName()
             << "  " << daughtermass[1]/GeV << G4endl;
      if (useGivenDaughterMass)
      {
        G4cout << "Daughter Mass is given." << G4endl;
      }
    }
#endif
    G4Exception("G4PhaseSpaceDecayChannel::TwoBodyDecayIt()",
                "PART112", JustWarning,
                "Cannot create decay products: sum of daughter mass is \
                 larger than parent mass!");
    return products;
  }  
  
  // calculate daughter momentum
  G4double 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;
  G4ThreeVector direction(sintheta*std::cos(phi),
                          sintheta*std::sin(phi), costheta);
 
  // create daughter G4DynamicParticle 
  G4double Ekin = std::sqrt(daughtermomentum*daughtermomentum
                          + daughtermass[0]*daughtermass[0]) - daughtermass[0];
  G4DynamicParticle* daughterparticle
    = new G4DynamicParticle(G4MT_daughters[0],direction,Ekin,daughtermass[0]);
  products->PushProducts(daughterparticle);
  Ekin = std::sqrt(daughtermomentum*daughtermomentum
                 + daughtermass[1]*daughtermass[1]) - daughtermass[1];
  daughterparticle
    = new G4DynamicParticle(G4MT_daughters[1], -1.0*direction,
                            Ekin, daughtermass[1]);
  products->PushProducts(daughterparticle);
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
  {
    G4cout << "G4PhaseSpaceDecayChannel::TwoBodyDecayIt() -";
    G4cout << " Create decay products in rest frame " << G4endl;
    products->DumpInfo();
  }
#endif
  return products;
}

References current_parent_mass, G4DecayProducts::DumpInfo(), G4VDecayChannel::DynamicalMass(), G4cout, G4endl, G4Exception(), G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_daughters_mass, G4VDecayChannel::G4MT_daughters_width, G4VDecayChannel::G4MT_parent, G4UniformRand, G4Cache< VALTYPE >::Get(), G4ParticleDefinition::GetParticleName(), G4VDecayChannel::GetVerboseLevel(), GeV, givenDaughterMasses, JustWarning, Pmx(), G4DecayProducts::PushProducts(), rad, G4VDecayChannel::rangeMass, twopi, and useGivenDaughterMass.

Referenced by DecayIt().

Field Documentation

current_parent_mass

G4Cache<G4double> G4PhaseSpaceDecayChannel::current_parent_mass

private

Definition at line 80 of file G4PhaseSpaceDecayChannel.hh.

Referenced by DecayIt(), ManyBodyDecayIt(), OneBodyDecayIt(), ThreeBodyDecayIt(), and TwoBodyDecayIt().

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(), ManyBodyDecayIt(), G4GeneralPhaseSpaceDecay::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(), ManyBodyDecayIt(), G4GeneralPhaseSpaceDecay::ManyBodyDecayIt(), OneBodyDecayIt(), G4GeneralPhaseSpaceDecay::OneBodyDecayIt(), G4VDecayChannel::SetDaughter(), ThreeBodyDecayIt(), G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt(), TwoBodyDecayIt(), and G4GeneralPhaseSpaceDecay::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(), ManyBodyDecayIt(), ThreeBodyDecayIt(), 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(), ThreeBodyDecayIt(), 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::G4GeneralPhaseSpaceDecay(), G4VDecayChannel::GetAngularMomentum(), G4VDecayChannel::GetParent(), ManyBodyDecayIt(), G4GeneralPhaseSpaceDecay::ManyBodyDecayIt(), OneBodyDecayIt(), G4GeneralPhaseSpaceDecay::OneBodyDecayIt(), G4VDecayChannel::SetParent(), ThreeBodyDecayIt(), G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt(), TwoBodyDecayIt(), and G4GeneralPhaseSpaceDecay::TwoBodyDecayIt().

G4MT_parent_mass

G4double G4VDecayChannel::G4MT_parent_mass = 0.0

protectedinherited

Definition at line 174 of file G4VDecayChannel.hh.

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

givenDaughterMasses

G4double G4PhaseSpaceDecayChannel::givenDaughterMasses[MAX_N_DAUGHTERS]

private

Definition at line 81 of file G4PhaseSpaceDecayChannel.hh.

Referenced by IsOKWithParentMass(), ManyBodyDecayIt(), OneBodyDecayIt(), SetDaughterMasses(), ThreeBodyDecayIt(), and TwoBodyDecayIt().

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(), G4GeneralPhaseSpaceDecay::DecayIt(), DecayIt(), G4VDecayChannel::DumpInfo(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetAngularMomentum(), G4VDecayChannel::GetDaughter(), G4VDecayChannel::GetDaughterMass(), G4VDecayChannel::GetDaughterName(), G4VDecayChannel::GetNumberOfDaughters(), IsOKWithParentMass(), G4VDecayChannel::IsOKWithParentMass(), ManyBodyDecayIt(), G4GeneralPhaseSpaceDecay::ManyBodyDecayIt(), G4DalitzDecayChannel::operator=(), G4KL3DecayChannel::operator=(), G4MuonDecayChannel::operator=(), G4MuonDecayChannelWithSpin::operator=(), G4MuonRadiativeDecayChannelWithSpin::operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), G4VDecayChannel::SetDaughter(), SetDaughterMasses(), and G4VDecayChannel::SetNumberOfDaughters().

parent_name

G4String* G4VDecayChannel::parent_name = nullptr

protectedinherited

Definition at line 156 of file G4VDecayChannel.hh.

Referenced by G4VDecayChannel::ClearDaughtersName(), G4GeneralPhaseSpaceDecay::DecayIt(), DecayIt(), G4VDecayChannel::FillDaughters(), G4VDecayChannel::FillParent(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetParentName(), ManyBodyDecayIt(), G4GeneralPhaseSpaceDecay::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().

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(), ThreeBodyDecayIt(), and 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().

useGivenDaughterMass

G4bool G4PhaseSpaceDecayChannel::useGivenDaughterMass = false

private

Definition at line 82 of file G4PhaseSpaceDecayChannel.hh.

Referenced by IsOKWithParentMass(), ManyBodyDecayIt(), OneBodyDecayIt(), SampleDaughterMasses(), SetDaughterMasses(), 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/particles/management/include/G4PhaseSpaceDecayChannel.hh
• source/particles/management/src/G4PhaseSpaceDecayChannel.cc