#include <G4MuonRadiativeDecayChannelWithSpin.hh>

Inheritance diagram for G4MuonRadiativeDecayChannelWithSpin:

Public Member Functions
virtual G4DecayProducts *	DecayIt (G4double)

void	DumpInfo ()

	G4MuonRadiativeDecayChannelWithSpin (const G4String &theParentName, G4double theBR)

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	SetPolarization (const G4ThreeVector &)

void	SetRangeMass (G4double val)

void	SetVerboseLevel (G4int value)

virtual	~G4MuonRadiativeDecayChannelWithSpin ()

Protected Member Functions
void	CheckAndFillDaughters ()

void	CheckAndFillParent ()

void	ClearDaughtersName ()

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

	G4MuonRadiativeDecayChannelWithSpin (const G4MuonRadiativeDecayChannelWithSpin &)

G4MuonRadiativeDecayChannelWithSpin &	operator= (const G4MuonRadiativeDecayChannelWithSpin &)

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
G4double	atan4 (G4double x, G4double y)

void	FillDaughters ()

void	FillParent ()

G4double	fron (G4double Pmu, G4double x, G4double y, G4double cthetaE, G4double cthetaG, G4double cthetaEG)

	G4MuonRadiativeDecayChannelWithSpin ()

const G4String &	GetNoName () const

void	rn3dim (G4double &x, G4double &y, G4double &z, G4double xlong)

Detailed Description

Definition at line 53 of file G4MuonRadiativeDecayChannelWithSpin.hh.

Constructor & Destructor Documentation

◆ G4MuonRadiativeDecayChannelWithSpin() [1/3]

G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin	(	const G4String &	theParentName,
		G4double	theBR
	)

Definition at line 52 of file G4MuonRadiativeDecayChannelWithSpin.cc.

  : G4VDecayChannel("Radiative Muon Decay",1)
{
  // set names for daughter particles
  if (theParentName == "mu+")
  {
    SetBR(theBR);
    SetParent("mu+");
    SetNumberOfDaughters(4);
    SetDaughter(0, "e+");
    SetDaughter(1, "gamma");
    SetDaughter(2, "nu_e");
    SetDaughter(3, "anti_nu_mu");
  }
  else if (theParentName == "mu-")
  {
    SetBR(theBR);
    SetParent("mu-");
    SetNumberOfDaughters(4);
    SetDaughter(0, "e-");
    SetDaughter(1, "gamma");
    SetDaughter(2, "anti_nu_e");
    SetDaughter(3, "nu_mu");
  }
  else
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4RadiativeMuonDecayChannel::G4RadiativeMuonDecayChannel():";
      G4cout << " parent particle is not muon but ";
      G4cout << theParentName << G4endl;
    }
#endif
  }
}

References G4cout, G4endl, G4VDecayChannel::GetVerboseLevel(), G4VDecayChannel::SetBR(), G4VDecayChannel::SetDaughter(), G4VDecayChannel::SetNumberOfDaughters(), and G4VDecayChannel::SetParent().

◆ ~G4MuonRadiativeDecayChannelWithSpin()

G4MuonRadiativeDecayChannelWithSpin::~G4MuonRadiativeDecayChannelWithSpin ( )

virtual

Definition at line 91 of file G4MuonRadiativeDecayChannelWithSpin.cc.

92{

93}

◆ G4MuonRadiativeDecayChannelWithSpin() [2/3]

G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin ( const G4MuonRadiativeDecayChannelWithSpin & r )

protected

Definition at line 95 of file G4MuonRadiativeDecayChannelWithSpin.cc.

  : G4VDecayChannel(r)
{
}

◆ G4MuonRadiativeDecayChannelWithSpin() [3/3]

G4MuonRadiativeDecayChannelWithSpin::G4MuonRadiativeDecayChannelWithSpin ( )

private

Definition at line 47 of file G4MuonRadiativeDecayChannelWithSpin.cc.

  : G4VDecayChannel()
{
}

Member Function Documentation

◆ atan4()

G4double G4MuonRadiativeDecayChannelWithSpin::atan4	(	G4double	x,
		G4double	y
	)

inlineprivate

Definition at line 110 of file G4MuonRadiativeDecayChannelWithSpin.hh.

{
  G4double phi = 0.;
 
  if        (x==0. && y>0.){
    phi = 0.5*CLHEP::pi;
  } else if (x==0. && y<0.){
    phi = 1.5*CLHEP::pi;
  } else if (y==0. && x>0.){
    phi = 0.;
  } else if (y==0. && x<0.){
    phi = CLHEP::pi;
  } else if (x>0.         ){
    phi = std::atan(y/x);
  } else if (x<0.         ){
    phi = std::atan(y/x) + CLHEP::pi;
  }
 
  return phi;
}

References CLHEP::pi.

Referenced by DecayIt().

◆ 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(), 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 G4GeneralPhaseSpaceDecay::DecayIt(), G4DalitzDecayChannel::DecayIt(), G4KL3DecayChannel::DecayIt(), G4MuonDecayChannel::DecayIt(), G4MuonDecayChannelWithSpin::DecayIt(), 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=(), operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), G4VDecayChannel::SetNumberOfDaughters(), and G4VDecayChannel::~G4VDecayChannel().

◆ DecayIt()

G4DecayProducts * G4MuonRadiativeDecayChannelWithSpin::DecayIt ( G4double )

virtual

Implements G4VDecayChannel.

Definition at line 134 of file G4MuonRadiativeDecayChannelWithSpin.cc.

{
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1) 
    G4cout << "G4MuonRadiativeDecayChannelWithSpin::DecayIt()";
#endif
 
  CheckAndFillParent();
  CheckAndFillDaughters();
 
  // parent mass
  G4double parentmass = G4MT_parent->GetPDGMass();
 
  G4double EMMU = parentmass;
 
  // daughters'mass
  G4double daughtermass[4]; 
  //G4double sumofdaughtermass = 0.0;
  for (G4int index=0; index<4; ++index)
  {
    daughtermass[index] = G4MT_daughters[index]->GetPDGMass();
    //sumofdaughtermass += daughtermass[index];
  }
 
  G4double EMASS = daughtermass[0];
 
  //create parent G4DynamicParticle at rest
  G4ThreeVector dummy;
  G4DynamicParticle* parentparticle
    = new G4DynamicParticle( G4MT_parent, dummy, 0.0 );
 
  // create G4Decayproducts
  G4DecayProducts *products = new G4DecayProducts(*parentparticle);
  delete parentparticle;
 
  G4int i = 0;
 
  G4double eps = EMASS/EMMU;
 
  G4double som0, x, y, xx, yy, zz;
  G4double cthetaE, cthetaG, cthetaGE, phiE, phiG;
  const std::size_t MAX_LOOP=10000;
 
  for (std::size_t loop_counter1=0; loop_counter1<MAX_LOOP; ++loop_counter1)
  {
    // leap1:
 
    ++i;
 
    // leap2:
 
    for (std::size_t loop_counter2=0; loop_counter2<MAX_LOOP; ++loop_counter2)
    {
      // -------------------------------------------------------------------
      // Build two vectors of random length and random direction, for the
      // positron and the photon.
      // x/y is the length of the vector, xx, yy and zz the components,
      // phi is the azimutal angle, theta the polar angle.
      // -------------------------------------------------------------------
 
      // For the positron
      //
      x = G4UniformRand();
 
      rn3dim(xx,yy,zz,x);
 
      if(std::fabs((xx*xx)+(yy*yy)+(zz*zz)-(x*x))>0.001)
      {
        G4cout << "Norm of x not correct" << G4endl;
      }
 
      phiE = atan4(xx,yy);
      cthetaE = zz/x;
      G4double sthetaE = std::sqrt((xx*xx)+(yy*yy))/x;
 
      // What you get:
      //
      // x       = positron energy
      // phiE    = azimutal angle of positron momentum
      // cthetaE = cosine of polar angle of positron momentum
      // sthetaE = sine of polar angle of positron momentum
      //
 
      // For the photon
      //
      y = G4UniformRand();
 
      rn3dim(xx,yy,zz,y);
 
      if(std::fabs((xx*xx)+(yy*yy)+(zz*zz)-(y*y))>0.001)
      {
        G4cout << " Norm of y not correct " << G4endl;
      }
 
      phiG = atan4(xx,yy);
      cthetaG = zz/y;
      G4double sthetaG = std::sqrt((xx*xx)+(yy*yy))/y;
 
      // What you get:
      //
      // y       = photon energy
      // phiG    = azimutal angle of photon momentum
      // cthetaG = cosine of polar angle of photon momentum
      // sthetaG = sine of polar angle of photon momentum
      //
 
      //      Calculate the angle between positron and photon (cosine)
      //
      cthetaGE = cthetaE*cthetaG+sthetaE*sthetaG*std::cos(phiE-phiG);
 
 
      G4double term0 = eps*eps;
      G4double term1 = x*((1.0-eps)*(1.0-eps))+2.0*eps;
      G4double beta  = std::sqrt( x*((1.0-eps)*(1.0-eps))*
                                 (x*((1.0-eps)*(1.0-eps))+4.0*eps))/term1;
      G4double delta = 1.0-beta*cthetaGE;
 
      G4double term3 = y*(1.0-(eps*eps));
      G4double term6 = term1*delta*term3;
 
      G4double Qsqr = (1.0-term1-term3+term0+0.5*term6)/((1.0-eps)*(1.0-eps));
 
      // Check the kinematics.
      //
      if  ( Qsqr>=0.0 && Qsqr<=1.0 ) break;
 
    } // end loop count
 
    // Do the calculation for -1 muon polarization (i.e. mu+)
    //
    G4double Pmu = -1.0;
    if (GetParentName() == "mu-")  { Pmu = +1.0; }
 
    som0 = fron(Pmu,x,y,cthetaE,cthetaG,cthetaGE);
 
    // Sample the decay rate
    //
    if (G4UniformRand()*177.0 <= som0) break;
  }
 
  G4double E = EMMU/2.*(x*((1.-eps)*(1.-eps))+2.*eps);
  G4double G = EMMU/2.*y*(1.-eps*eps);
 
  if(E < EMASS) E = EMASS;
 
  // calculate daughter momentum
  G4double daughtermomentum[4];
 
  daughtermomentum[0] = std::sqrt(E*E - EMASS*EMASS);
 
  G4double sthetaE = std::sqrt(1.-cthetaE*cthetaE);
  G4double cphiE = std::cos(phiE);
  G4double sphiE = std::sin(phiE);
 
  // Coordinates of the decay positron with respect to the muon spin
 
  G4double px = sthetaE*cphiE;
  G4double py = sthetaE*sphiE;
  G4double pz = cthetaE;
 
  G4ThreeVector direction0(px,py,pz);
 
  direction0.rotateUz(parent_polarization);
 
  G4DynamicParticle * daughterparticle0 
    = new G4DynamicParticle( G4MT_daughters[0], daughtermomentum[0]*direction0);
 
  products->PushProducts(daughterparticle0);
 
  daughtermomentum[1] = G;
 
  G4double sthetaG = std::sqrt(1.-cthetaG*cthetaG);
  G4double cphiG = std::cos(phiG);
  G4double sphiG = std::sin(phiG);
 
  // Coordinates of the decay gamma with respect to the muon spin
 
  px = sthetaG*cphiG;
  py = sthetaG*sphiG;
  pz = cthetaG;
 
  G4ThreeVector direction1(px,py,pz);
 
  direction1.rotateUz(parent_polarization);
 
  G4DynamicParticle * daughterparticle1
    = new G4DynamicParticle( G4MT_daughters[1], daughtermomentum[1]*direction1);
 
  products->PushProducts(daughterparticle1);
 
  // daughter 3 ,4 (neutrinos)
  // create neutrinos in the C.M frame of two neutrinos
 
  G4double energy2 = parentmass-E-G;
 
  G4ThreeVector P34 = -1.*(daughtermomentum[0]*direction0
                          +daughtermomentum[1]*direction1);  
  G4double vmass2 = energy2*energy2 - P34.mag2();
  G4double vmass = std::sqrt(vmass2);
 
  G4double costhetan = 2.*G4UniformRand()-1.0;
  G4double sinthetan = std::sqrt((1.0-costhetan)*(1.0+costhetan));
  G4double phin  = twopi*G4UniformRand()*rad;
  G4double sinphin = std::sin(phin);
  G4double cosphin = std::cos(phin);
 
  G4ThreeVector direction2(sinthetan*cosphin,sinthetan*sinphin,costhetan);
 
  G4DynamicParticle * daughterparticle2
    = new G4DynamicParticle( G4MT_daughters[2], direction2*(vmass/2.));
  G4DynamicParticle * daughterparticle3
    = new G4DynamicParticle( G4MT_daughters[3], direction2*(-1.0*vmass/2.));
 
  // boost to the muon rest frame
  G4double beta = P34.mag()/energy2;
  G4ThreeVector direction34 = P34.unit();
 
  G4LorentzVector p4 = daughterparticle2->Get4Momentum();
  p4.boost(direction34.x()*beta,direction34.y()*beta,direction34.z()*beta);
  daughterparticle2->Set4Momentum(p4);
 
  p4 = daughterparticle3->Get4Momentum();
  p4.boost(direction34.x()*beta,direction34.y()*beta,direction34.z()*beta);
  daughterparticle3->Set4Momentum(p4);
 
  products->PushProducts(daughterparticle2);
  products->PushProducts(daughterparticle3);
 
  daughtermomentum[2] = daughterparticle2->GetTotalMomentum();
  daughtermomentum[3] = daughterparticle3->GetTotalMomentum();
 
  // output message
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
  {
    G4cout << "G4MuonRadiativeDecayChannelWithSpin::DecayIt() -";
    G4cout << " create decay products in rest frame " <<G4endl;
    G4double TT = daughterparticle0->GetTotalEnergy()
      + daughterparticle1->GetTotalEnergy()
      + daughterparticle2->GetTotalEnergy() 
      + daughterparticle3->GetTotalEnergy(); 
    G4cout << "e    :" << daughterparticle0->GetTotalEnergy()/MeV << G4endl; 
    G4cout << "gamma:" << daughterparticle1->GetTotalEnergy()/MeV << G4endl; 
    G4cout << "nu2  :" << daughterparticle2->GetTotalEnergy()/MeV << G4endl; 
    G4cout << "nu2  :" << daughterparticle3->GetTotalEnergy()/MeV << G4endl; 
    G4cout << "total:" << (TT-parentmass)/keV << G4endl;
    if (GetVerboseLevel()>1) { products->DumpInfo(); }
  }
#endif
 
 return products;
}

References atan4(), anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, CLHEP::HepLorentzVector::boost(), G4VDecayChannel::CheckAndFillDaughters(), G4VDecayChannel::CheckAndFillParent(), G4DecayProducts::DumpInfo(), eps, fron(), G4cout, G4endl, G4VDecayChannel::G4MT_daughters, G4VDecayChannel::G4MT_parent, G4UniformRand, G4DynamicParticle::Get4Momentum(), G4VDecayChannel::GetParentName(), G4ParticleDefinition::GetPDGMass(), G4DynamicParticle::GetTotalEnergy(), G4DynamicParticle::GetTotalMomentum(), G4VDecayChannel::GetVerboseLevel(), keV, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), MeV, G4VDecayChannel::parent_polarization, G4DecayProducts::PushProducts(), rad, rn3dim(), CLHEP::Hep3Vector::rotateUz(), G4DynamicParticle::Set4Momentum(), twopi, CLHEP::Hep3Vector::unit(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

◆ fron()

G4double G4MuonRadiativeDecayChannelWithSpin::fron	(	G4double	Pmu,
		G4double	x,
		G4double	y,
		G4double	cthetaE,
		G4double	cthetaG,
		G4double	cthetaEG
	)

private

Definition at line 400 of file G4MuonRadiativeDecayChannelWithSpin.cc.

{
  G4double mu  = 105.65;
  G4double me  =   0.511;
  G4double rho =   0.75;
  G4double del =   0.75;
  G4double eps =   0.0;
  G4double kap =   0.0;
  G4double ksi =   1.0;
 
  G4double delta = 1-cthetaGE;
 
  // Calculation of the functions f(x,y)
 
  G4double f_1s  = 12.0*((y*y)*(1.0-y)+x*y*(2.0-3.0*y)
                   +2.0*(x*x)*(1.0-2.0*y)-2.0*(x*x*x));
  G4double f0s   = 6.0*(-x*y*(2.0-3.0*(y*y))
                   -2.0*(x*x)*(1.0-y-3.0*(y*y))+2.0*(x*x*x)*(1.0+2.0*y));
  G4double f1s   = 3.0*((x*x)*y*(2.0-3.0*y-3.0*(y*y))
                   -(x*x*x)*y*(4.0+3.0*y));
  G4double f2s   = 1.5*((x*x*x)*(y*y)*(2.0+y));
 
  G4double f_1se = 12.0*(x*y*(1.0-y)+(x*x)*(2.0-3.0*y)
                   -2.0*(x*x*x));
  G4double f0se  = 6.0*(-(x*x)*(2.0-y-2.0*(y*y))
                   +(x*x*x)*(2.0+3.0*y));
  G4double f1se  = -3.0*(x*x*x)*y*(2.0+y);
  G4double f2se  = 0.0;
 
  G4double f_1sg = 12.0*((y*y)*(1.0-y)+x*y*(1.0-2.0*y)
                   -(x*x)*y);
  G4double f0sg  = 6.0*(-x*(y*y)*(2.0-3.0*y)-(x*x)*y*(1.0-4.0*y)
                   +(x*x*x)*y);
  G4double f1sg  = 3.0*((x*x)*(y*y)*(1.0-3.0*y)
                   -2.0*(x*x*x)*(y*y));
  G4double f2sg  = 1.5*(x*x*x)*(y*y*y);
 
  G4double f_1v  = 8.0*((y*y)*(3.0-2.0*y)+6.0*x*y*(1.0-y)
                   +2.0*(x*x)*(3.0-4.0*y)-4.0*(x*x*x));
  G4double f0v   = 8.0*(-x*y*(3.0-y-(y*y))-(x*x)*(3.0-y-4.0*(y*y))
                   +2.0*(x*x*x)*(1.0+2.0*y));
  G4double f1v   = 2.0*((x*x)*y*(6.0-5.0*y-2.0*(y*y))
                   -2.0*(x*x*x)*y*(4.0+3.0*y));
  G4double f2v   = 2.0*(x*x*x)*(y*y)*(2.0+y);
 
  G4double f_1ve = 8.0*(x*y*(1.0-2.0*y)
                   +2.0*(x*x)*(1.0-3.0*y)-4.0*(x*x*x));
  G4double f0ve  = 4.0*(-(x*x)*(2.0-3.0*y-4.0*(y*y))
                   +2.0*(x*x*x)*(2.0+3.0*y));
  G4double f1ve  = -4.0*(x*x*x)*y*(2.0+y);
  G4double f2ve  = 0.0;
 
  G4double f_1vg = 8.0*((y*y)*(1.0-2.0*y)+x*y*(1.0-4.0*y)
                   -2.0*(x*x)*y);
  G4double f0vg  = 4.0*(2.0*x*(y*y)*(1.0+y)-(x*x)*y*(1.0-4.0*y)
                   +2.0*(x*x*x)*y);
  G4double f1vg  = 2.0*((x*x)*(y*y)*(1.0-2.0*y)
                   -4.0*(x*x*x)*(y*y));
  G4double f2vg  = 2.0*(x*x*x)*(y*y*y);
 
  G4double f_1t  = 8.0*((y*y)*(3.0-y)+3.0*x*y*(2.0-y)
                   +2.0*(x*x)*(3.0-2.0*y)-2.0*(x*x*x));
  G4double f0t   = 4.0*(-x*y*(6.0+(y*y))
                   -2.0*(x*x)*(3.0+y-3.0*(y*y))+2.0*(x*x*x)*(1.0+2.0*y));
  G4double f1t   = 2.0*((x*x)*y*(6.0-5.0*y+(y*y))
                   -(x*x*x)*y*(4.0+3.0*y));
  G4double f2t   = (x*x*x)*(y*y)*(2.0+y);
 
  G4double f_1te = -8.0*(x*y*(1.0+3.0*y)+(x*x)*(2.0+3.0*y)
                   +2.0*(x*x*x));
  G4double f0te  = 4.0*((x*x)*(2.0+3.0*y+4.0*(y*y))
                   +(x*x*x)*(2.0+3.0*y));
  G4double f1te  = -2.0*(x*x*x)*y*(2.0+y);
  G4double f2te  = 0.0;
 
  G4double f_1tg = -8.0*((y*y)*(1.0+y)+x*y+(x*x)*y);
  G4double f0tg  = 4.0*(x*(y*y)*(2.0-y)+(x*x)*y*(1.0+2.0*y)
                   +(x*x*x)*y);
  G4double f1tg  = -2.0*((x*x)*(y*y)*(1.0-y)+2.0*(x*x*x)*y);
  G4double f2tg  = (x*x*x)*(y*y*y);
 
  G4double term = delta+2.0*(me*me)/((mu*mu)*(x*x));
  term = 1.0/term;
 
  G4double nss = term*f_1s+f0s+delta*f1s+(delta*delta)*f2s;
  G4double nv = term*f_1v+f0v+delta*f1v+(delta*delta)*f2v;
  G4double nt = term*f_1t+f0t+delta*f1t+(delta*delta)*f2t;
 
  G4double nse = term*f_1se+f0se+delta*f1se+(delta*delta)*f2se;
  G4double nve = term*f_1ve+f0ve+delta*f1ve+(delta*delta)*f2ve;
  G4double nte = term*f_1te+f0te+delta*f1te+(delta*delta)*f2te;
 
  G4double nsg = term*f_1sg+f0sg+delta*f1sg+(delta*delta)*f2sg;
  G4double nvg = term*f_1vg+f0vg+delta*f1vg+(delta*delta)*f2vg;
  G4double ntg = term*f_1tg+f0tg+delta*f1tg+(delta*delta)*f2tg;
 
  G4double term1 = nv;
  G4double term2 = 2.0*nss+nv-nt;
  G4double term3 = 2.0*nss-2.0*nv+nt;
 
  G4double term1e = 1.0/3.0*(1.0-4.0/3.0*del);
  G4double term2e = 2.0*nse+5.0*nve-nte;
  G4double term3e = 2.0*nse-2.0*nve+nte;
 
  G4double term1g = 1.0/3.0*(1.0-4.0/3.0*del);
  G4double term2g = 2.0*nsg+5.0*nvg-ntg;
  G4double term3g = 2.0*nsg-2.0*nvg+ntg;
 
  G4double som00 = term1+(1.0-4.0/3.0*rho)*term2+eps*term3;
  G4double som01 = Pmu*ksi*(cthetaE*(nve-term1e*term2e+kap*term3e)
                   +cthetaG*(nvg-term1g*term2g+kap*term3g));
 
  G4double som0 = (som00+som01)/y;
  som0  = fine_structure_const/8./(twopi*twopi*twopi)*som0;
 
  return som0;
}

References eps, source.hepunit::fine_structure_const, and twopi.

Referenced by DecayIt().

◆ 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

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

◆ operator!=()

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

inlineinherited

Definition at line 69 of file G4VDecayChannel.hh.

69{ 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=()

G4MuonRadiativeDecayChannelWithSpin & G4MuonRadiativeDecayChannelWithSpin::operator= ( const G4MuonRadiativeDecayChannelWithSpin & right )

protected

Definition at line 101 of file G4MuonRadiativeDecayChannelWithSpin.cc.

{
  if (this != &right)
  { 
    kinematics_name = right.kinematics_name;
    verboseLevel = right.verboseLevel;
    rbranch = right.rbranch;
 
    // copy parent name
    parent_name = new G4String(*right.parent_name);
 
    // clear daughters_name array
    ClearDaughtersName();
 
    // recreate array
    numberOfDaughters = right.numberOfDaughters;
    if ( numberOfDaughters > 0 )
    {
      if (daughters_name != nullptr) ClearDaughtersName();
      daughters_name = new G4String*[numberOfDaughters];
      // copy daughters name
      for (G4int index=0; index<numberOfDaughters; ++index)
      {
        daughters_name[index] = new G4String(*right.daughters_name[index]);
      }
    }
    parent_polarization = right.parent_polarization;
  }
  return *this;
}

References G4VDecayChannel::ClearDaughtersName(), G4VDecayChannel::daughters_name, G4VDecayChannel::kinematics_name, G4VDecayChannel::numberOfDaughters, G4VDecayChannel::parent_name, G4VDecayChannel::parent_polarization, G4VDecayChannel::rbranch, and G4VDecayChannel::verboseLevel.

◆ operator==()

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

inlineinherited

Definition at line 68 of file G4VDecayChannel.hh.

68{ return (this == &r); }

◆ rn3dim()

void G4MuonRadiativeDecayChannelWithSpin::rn3dim	(	G4double &	x,
		G4double &	y,
		G4double &	z,
		G4double	xlong
	)

inlineprivate

Definition at line 87 of file G4MuonRadiativeDecayChannelWithSpin.hh.

{
  G4double a = 0.; G4double b = 0.; G4double c = 0.; G4double r = 0.;
 
  do
  {
    a = G4UniformRand() - 0.5;
    b = G4UniformRand() - 0.5;
    c = G4UniformRand() - 0.5;
    r = a*a + b*b + c*c;
  } while (r > 0.25); // Loop checking, 09.08.2015, K.Kurashige
 
  G4double rinv = xlong/(std::sqrt(r)); 
  x = a * rinv;
  y = b * rinv;
  z = c * rinv;
 
  return;
}

References G4UniformRand.

Referenced by DecayIt().

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

322{ 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().

Field Documentation

◆ daughters_name

G4String** G4VDecayChannel::daughters_name = nullptr

protectedinherited

◆ 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(), 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(), G4GeneralPhaseSpaceDecay::ManyBodyDecayIt(), G4PhaseSpaceDecayChannel::OneBodyDecayIt(), G4GeneralPhaseSpaceDecay::OneBodyDecayIt(), G4VDecayChannel::SetDaughter(), G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt(), G4PhaseSpaceDecayChannel::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(), 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(), 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(), G4PhaseSpaceDecayChannel::ManyBodyDecayIt(), G4GeneralPhaseSpaceDecay::ManyBodyDecayIt(), G4PhaseSpaceDecayChannel::OneBodyDecayIt(), G4GeneralPhaseSpaceDecay::OneBodyDecayIt(), G4VDecayChannel::SetParent(), G4PhaseSpaceDecayChannel::ThreeBodyDecayIt(), G4GeneralPhaseSpaceDecay::ThreeBodyDecayIt(), G4PhaseSpaceDecayChannel::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 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=(), 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.

◆ parent_name

G4String* G4VDecayChannel::parent_name = nullptr

protectedinherited

◆ parent_polarization

G4ThreeVector G4VDecayChannel::parent_polarization

protectedinherited

Definition at line 164 of file G4VDecayChannel.hh.

Referenced by G4MuonDecayChannelWithSpin::DecayIt(), DecayIt(), G4VDecayChannel::G4VDecayChannel(), G4VDecayChannel::GetPolarization(), 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(), 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=(), operator=(), G4NeutronBetaDecayChannel::operator=(), G4PionRadiativeDecayChannel::operator=(), G4TauLeptonicDecayChannel::operator=(), G4VDecayChannel::operator=(), and G4VDecayChannel::SetBR().

◆ verboseLevel

G4int G4VDecayChannel::verboseLevel = 1

protectedinherited

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

source/particles/management/include/G4MuonRadiativeDecayChannelWithSpin.hh
source/particles/management/src/G4MuonRadiativeDecayChannelWithSpin.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ G4MuonRadiativeDecayChannelWithSpin() [1/3]

◆ ~G4MuonRadiativeDecayChannelWithSpin()

◆ G4MuonRadiativeDecayChannelWithSpin() [2/3]

◆ G4MuonRadiativeDecayChannelWithSpin() [3/3]

Member Function Documentation

◆ atan4()

◆ CheckAndFillDaughters()

◆ CheckAndFillParent()

◆ ClearDaughtersName()

◆ DecayIt()

◆ DumpInfo()

◆ DynamicalMass()

◆ FillDaughters()

◆ FillParent()

◆ fron()

◆ GetAngularMomentum()

◆ GetBR()

◆ GetDaughter()

◆ GetDaughterMass()

◆ GetDaughterName()

◆ GetKinematicsName()

◆ GetNoName()

◆ GetNumberOfDaughters()

◆ GetParent()

◆ GetParentMass()

◆ GetParentName()

◆ GetPolarization()

◆ GetRangeMass()

◆ GetVerboseLevel()

◆ IsOKWithParentMass()

◆ operator!=()

◆ operator<()

◆ operator=()

◆ operator==()

◆ rn3dim()

◆ SetBR()

◆ SetDaughter() [1/2]

◆ SetDaughter() [2/2]

◆ SetNumberOfDaughters()

◆ SetParent() [1/2]

◆ SetParent() [2/2]

◆ SetPolarization()

◆ SetRangeMass()

◆ SetVerboseLevel()

Field Documentation

◆ daughters_name

◆ daughtersMutex

◆ G4MT_daughters

◆ G4MT_daughters_mass

◆ G4MT_daughters_width

◆ G4MT_parent

◆ G4MT_parent_mass

◆ kinematics_name

◆ noName

◆ numberOfDaughters

◆ parent_name

◆ parent_polarization

◆ parentMutex

◆ particletable

◆ rangeMass

◆ rbranch

◆ verboseLevel