G4VDecayChannel Class Reference

#include <G4VDecayChannel.hh>

Inheritance diagram for G4VDecayChannel:

Collaboration diagram for G4VDecayChannel:

Public Member Functions
	G4VDecayChannel (const G4String &aName, G4int Verbose=1)
	G4VDecayChannel (const G4String &aName, const G4String &theParentName, G4double theBR, G4int theNumberOfDaughters, const G4String &theDaughterName1, const G4String &theDaughterName2="", const G4String &theDaughterName3="", const G4String &theDaughterName4="")
virtual	~G4VDecayChannel ()
G4int	operator== (const G4VDecayChannel &right) const
G4int	operator!= (const G4VDecayChannel &right) const
G4int	operator< (const G4VDecayChannel &right) const
virtual G4DecayProducts *	DecayIt (G4double parentMass=-1.0)=0
const G4String &	GetKinematicsName () const
G4double	GetBR () const
G4int	GetNumberOfDaughters () const
G4ParticleDefinition *	GetParent ()
G4ParticleDefinition *	GetDaughter (G4int anIndex)
G4int	GetAngularMomentum ()
const G4String &	GetParentName () const
const G4String &	GetDaughterName (G4int anIndex) const
G4double	GetParentMass () const
G4double	GetDaughterMass (G4int anIndex) const
void	SetParent (const G4ParticleDefinition *particle_type)
void	SetParent (const G4String &particle_name)
void	SetBR (G4double value)
void	SetNumberOfDaughters (G4int value)
void	SetDaughter (G4int anIndex, const G4ParticleDefinition *particle_type)
void	SetDaughter (G4int anIndex, const G4String &particle_name)
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
void	DumpInfo ()
G4double	GetRangeMass () const
void	SetRangeMass (G4double val)
virtual G4bool	IsOKWithParentMass (G4double parentMass)
void	SetPolarization (const G4ThreeVector &)
const G4ThreeVector &	GetPolarization () const

Protected Member Functions
void	ClearDaughtersName ()
void	CheckAndFillDaughters ()
void	CheckAndFillParent ()
	G4VDecayChannel ()
	G4VDecayChannel (const G4VDecayChannel &)
G4VDecayChannel &	operator= (const G4VDecayChannel &)
G4double	DynamicalMass (G4double massPDG, G4double width, G4double maxDev=+1.) const

Protected Attributes
G4String	kinematics_name
G4double	rbranch
G4int	numberOfDaughters
G4String *	parent_name
G4String **	daughters_name
G4double	rangeMass
G4ThreeVector	parent_polarization
G4ParticleTable *	particletable
G4int	verboseLevel
G4ParticleDefinition *	G4MT_parent
G4ParticleDefinition **	G4MT_daughters
G4double	G4MT_parent_mass
G4double *	G4MT_daughters_mass
G4double *	G4MT_daughters_width
G4Mutex	daughtersMutex
G4Mutex	parentMutex

Static Protected Attributes
static const G4String	noName = " "

Detailed Description

Definition at line 53 of file G4VDecayChannel.hh.

Constructor & Destructor Documentation

G4VDecayChannel::G4VDecayChannel	(	const G4String &	aName,
		G4int	Verbose = 1
	)

Definition at line 69 of file G4VDecayChannel.cc.

  :kinematics_name(aName),
   rbranch(0.0),
   numberOfDaughters(0),
   parent_name(0), daughters_name(0),
   rangeMass(2.5),
   parent_polarization(),
   particletable(0),
   verboseLevel(Verbose),
   daughtersMutex(G4MUTEX_INITIALIZER),
   parentMutex(G4MUTEX_INITIALIZER)
{
  G4MT_parent = 0;
  G4MT_daughters = 0;
  G4MT_parent_mass = 0.0;
  G4MT_daughters_mass = 0;
  G4MT_daughters_width = 0;

  // set pointer to G4ParticleTable (static and singleton object)
  particletable = G4ParticleTable::GetParticleTable();
}

Here is the call graph for this function:

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

Definition at line 91 of file G4VDecayChannel.cc.

               :kinematics_name(aName),
        rbranch(theBR),
        numberOfDaughters(theNumberOfDaughters),
        parent_name(0), daughters_name(0),
                rangeMass(1.0),
                parent_polarization(),
        particletable(0),
        verboseLevel(1),
        daughtersMutex(G4MUTEX_INITIALIZER),
        parentMutex(G4MUTEX_INITIALIZER)
{
  G4MT_parent = 0;
  G4MT_daughters = 0;
  G4MT_parent_mass = 0.0;
  G4MT_daughters_mass = 0;
  G4MT_daughters_width = 0;

  // set pointer to G4ParticleTable (static and singleton object)
  particletable = G4ParticleTable::GetParticleTable();

  // parent name
  parent_name = new G4String(theParentName);

  // cleate array
  daughters_name = new G4String*[numberOfDaughters];
  for (G4int index=0;index<numberOfDaughters;index++) daughters_name[index]=0;

  // daughters' name
  if (numberOfDaughters>0) daughters_name[0] = new G4String(theDaughterName1);
  if (numberOfDaughters>1) daughters_name[1] = new G4String(theDaughterName2);
  if (numberOfDaughters>2) daughters_name[2] = new G4String(theDaughterName3);
  if (numberOfDaughters>3) daughters_name[3] = new G4String(theDaughterName4);
}

Here is the call graph for this function:

G4VDecayChannel::~G4VDecayChannel ( )

virtual

Definition at line 214 of file G4VDecayChannel.cc.

{
  ClearDaughtersName();
  if (parent_name != 0) delete parent_name;
  parent_name = 0;
  if (G4MT_daughters_mass != 0) delete [] G4MT_daughters_mass;
  G4MT_daughters_mass =0;
  if (G4MT_daughters_width != 0) delete [] G4MT_daughters_width;
  G4MT_daughters_width = 0;
  G4MUTEXDESTROY(daughtersMutex);
  G4MUTEXDESTROY(parentMutex);
} 

Here is the call graph for this function:

G4VDecayChannel::G4VDecayChannel ( )

protected

Definition at line 49 of file G4VDecayChannel.cc.

  :kinematics_name(""),
   rbranch(0.0),
   numberOfDaughters(0),
   parent_name(0), daughters_name(0),
   rangeMass(2.5),
   parent_polarization(),
   particletable(0),
   verboseLevel(1)      
{
  G4MT_parent = 0;
  G4MT_daughters = 0;
  G4MT_parent_mass = 0.0;
  G4MT_daughters_mass = 0;
  G4MT_daughters_width = 0;

  // set pointer to G4ParticleTable (static and singleton object)
  particletable = G4ParticleTable::GetParticleTable();
}

Here is the call graph for this function:

G4VDecayChannel::G4VDecayChannel ( const G4VDecayChannel &  right )

protected

Definition at line 133 of file G4VDecayChannel.cc.

{
  kinematics_name = right.kinematics_name;
  verboseLevel = right.verboseLevel;
  rbranch = right.rbranch;
  rangeMass =  right.rangeMass;

  // copy parent name
  parent_name = new G4String(*right.parent_name);
  G4MT_parent = 0;
  G4MT_parent_mass = 0.0; 

  //create array
  numberOfDaughters = right.numberOfDaughters;

  daughters_name =0;
  if ( numberOfDaughters >0 ) {
    daughters_name = new G4String*[numberOfDaughters];
    //copy daughters name
    for (G4int index=0; index < numberOfDaughters; index++)
      {
    daughters_name[index] = new G4String(*right.daughters_name[index]);
      }
  }

  //
  G4MT_daughters_mass = 0;
  G4MT_daughters = 0;
  G4MT_daughters_width = 0;

  // particle table
  particletable = G4ParticleTable::GetParticleTable();

  parent_polarization = right.parent_polarization;

  G4MUTEXINIT(daughtersMutex);
  G4MUTEXINIT(parentMutex);
}

Here is the call graph for this function:

Member Function Documentation

void G4VDecayChannel::CheckAndFillDaughters ( )

inlineprotected

Definition at line 324 of file G4VDecayChannel.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VDecayChannel::CheckAndFillParent ( )

inlineprotected

Definition at line 332 of file G4VDecayChannel.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VDecayChannel::ClearDaughtersName ( )

protected

Definition at line 227 of file G4VDecayChannel.cc.

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

  numberOfDaughters = 0;
}

Here is the caller graph for this function:

virtual G4DecayProducts* G4VDecayChannel::DecayIt ( G4double  parentMass = -1.0 )

pure virtual

Implemented in G4GeneralPhaseSpaceDecay, G4MuonRadiativeDecayChannelWithSpin, G4PionRadiativeDecayChannel, G4MuonDecayChannelWithSpin, G4PhaseSpaceDecayChannel, G4TauLeptonicDecayChannel, G4DalitzDecayChannel, G4MuonDecayChannel, G4NeutronBetaDecayChannel, G4KL3DecayChannel, G4ITDecay, G4BetaMinusDecay, G4BetaPlusDecay, G4NeutronDecay, G4ProtonDecay, G4ECDecay, and G4AlphaDecay.

Here is the caller graph for this function:

void G4VDecayChannel::DumpInfo

(

)

Definition at line 548 of file G4VDecayChannel.cc.

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

Here is the caller graph for this function:

G4double G4VDecayChannel::DynamicalMass ( G4double  massPDG, G4double  width, G4double  maxDev = +1.  ) const

protected

Definition at line 568 of file G4VDecayChannel.cc.

{ 
  if (width<=0.0) return massPDG;
  if (maxDev >rangeMass) maxDev = rangeMass;
  if (maxDev <=-1.*rangeMass) return massPDG;  // can not calculate
 
  G4double x = G4UniformRand()*(maxDev+rangeMass) - rangeMass;
  G4double y = G4UniformRand();
  const size_t MAX_LOOP=10000;
  for (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;
}

G4int G4VDecayChannel::GetAngularMomentum

(

)

Definition at line 490 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 allways 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;
}

Here is the call graph for this function:

G4double G4VDecayChannel::GetBR ( ) const

inline

Definition at line 297 of file G4VDecayChannel.hh.

{ return rbranch; }

Here is the caller graph for this function:

G4ParticleDefinition * G4VDecayChannel::GetDaughter ( G4int  anIndex )

inline

Definition at line 212 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 0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VDecayChannel::GetDaughterMass ( G4int  anIndex ) const

inline

Definition at line 242 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;
  }
}

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

inline

Definition at line 228 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();
  }
}

Here is the caller graph for this function:

const G4String & G4VDecayChannel::GetKinematicsName ( ) const

inline

Definition at line 291 of file G4VDecayChannel.hh.

{ return kinematics_name; }

Here is the caller graph for this function:

G4int G4VDecayChannel::GetNumberOfDaughters ( ) const

inline

Definition at line 285 of file G4VDecayChannel.hh.

{ 
  return  numberOfDaughters;
}

Here is the caller graph for this function:

G4ParticleDefinition * G4VDecayChannel::GetParent ( )

inline

Definition at line 256 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VDecayChannel::GetParentMass ( ) const

inline

Definition at line 271 of file G4VDecayChannel.hh.

{
  return G4MT_parent_mass;
}

const G4String & G4VDecayChannel::GetParentName ( ) const

inline

Definition at line 265 of file G4VDecayChannel.hh.

{
  return *parent_name;
}

Here is the caller graph for this function:

const G4ThreeVector & G4VDecayChannel::GetPolarization ( ) const

inline

Definition at line 318 of file G4VDecayChannel.hh.

{
  return parent_polarization;
}

G4double G4VDecayChannel::GetRangeMass ( ) const

inline

Definition at line 306 of file G4VDecayChannel.hh.

{ return rangeMass; }

G4int G4VDecayChannel::GetVerboseLevel ( ) const

inline

Definition at line 303 of file G4VDecayChannel.hh.

{ return verboseLevel; }

Here is the caller graph for this function:

G4bool G4VDecayChannel::IsOKWithParentMass ( G4double  parentMass )

virtual

Reimplemented in G4PhaseSpaceDecayChannel.

Definition at line 586 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); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4VDecayChannel::operator!= ( const G4VDecayChannel &  right ) const

inline

Definition at line 77 of file G4VDecayChannel.hh.

{return (this != &right);}

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

inline

Definition at line 206 of file G4VDecayChannel.hh.

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

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

protected

Definition at line 172 of file G4VDecayChannel.cc.

{
  if (this != &right) { 
    kinematics_name = right.kinematics_name;
    verboseLevel = right.verboseLevel;
    rbranch = right.rbranch;
    rangeMass =  right.rangeMass;
    parent_polarization = right.parent_polarization;
    // 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 !=0) 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]);
      }
    }
  }

  //
  G4MT_parent = 0;
  G4MT_daughters = 0;
  G4MT_parent_mass = 0.0;
  G4MT_daughters_mass = 0;
  G4MT_daughters_width = 0;

  // particle table
  particletable = G4ParticleTable::GetParticleTable();

  G4MUTEXINIT(daughtersMutex);
  G4MUTEXINIT(parentMutex);

  return *this;
}

Here is the call graph for this function:

G4int G4VDecayChannel::operator== ( const G4VDecayChannel &  right ) const

inline

Definition at line 76 of file G4VDecayChannel.hh.

{return (this == &right);}

void G4VDecayChannel::SetBR ( G4double  value )

inline

Definition at line 294 of file G4VDecayChannel.hh.

{ rbranch = value; }

Here is the caller graph for this function:

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

Definition at line 325 of file G4VDecayChannel.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 269 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;
  }

  //ANDREA:-> Feb 25 2016
  // 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_daugheters == 0
  // moreover this method can be called only after SetNumberOfDaugthers
  // has been called (see previous if), in such a case daughters_name != 0
  if ( daughters_name == 0 ) {
      G4Exception("G4VDecayChannel::SetDaughter","PART112",FatalException,
          "Trying to add a daughter without specifying number of secondaries, useSetNumberOfDaughters first");
      return;
  }
  if ( G4MT_daughters != 0 ) {
      G4Exception("G4VDecayChannel::SetDaughter","PART111",FatalException,
          "Trying to modify a daughter of a decay channel, but decay channel already has daughters.");
      return;
  }
  //<-:ANDREA

  // 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
  }
}

Here is the call graph for this function:

void G4VDecayChannel::SetNumberOfDaughters

(

G4int

value

)

Definition at line 257 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]=0;
    numberOfDaughters = size;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VDecayChannel::SetParent

(

const G4ParticleDefinition *

particle_type

)

Definition at line 485 of file G4VDecayChannel.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VDecayChannel::SetParent ( const G4String &  particle_name )

inline

Definition at line 277 of file G4VDecayChannel.hh.

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

void G4VDecayChannel::SetPolarization ( const G4ThreeVector &  polar )

inline

Definition at line 312 of file G4VDecayChannel.hh.

{
  parent_polarization = polar;
}

Here is the caller graph for this function:

void G4VDecayChannel::SetRangeMass ( G4double  val )

inline

Definition at line 309 of file G4VDecayChannel.hh.

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

void G4VDecayChannel::SetVerboseLevel ( G4int  value )

inline

Definition at line 300 of file G4VDecayChannel.hh.

{ verboseLevel = value; }

Here is the caller graph for this function:

Member Data Documentation

G4String** G4VDecayChannel::daughters_name

protected

Definition at line 173 of file G4VDecayChannel.hh.

G4Mutex G4VDecayChannel::daughtersMutex

protected

Definition at line 197 of file G4VDecayChannel.hh.

G4ParticleDefinition** G4VDecayChannel::G4MT_daughters

protected

Definition at line 193 of file G4VDecayChannel.hh.

G4double* G4VDecayChannel::G4MT_daughters_mass

protected

Definition at line 195 of file G4VDecayChannel.hh.

G4double* G4VDecayChannel::G4MT_daughters_width

protected

Definition at line 196 of file G4VDecayChannel.hh.

G4ParticleDefinition* G4VDecayChannel::G4MT_parent

protected

Definition at line 192 of file G4VDecayChannel.hh.

G4double G4VDecayChannel::G4MT_parent_mass

protected

Definition at line 194 of file G4VDecayChannel.hh.

G4String G4VDecayChannel::kinematics_name

protected

Definition at line 165 of file G4VDecayChannel.hh.

const G4String G4VDecayChannel::noName = " "

staticprotected

Definition at line 190 of file G4VDecayChannel.hh.

G4int G4VDecayChannel::numberOfDaughters

protected

Definition at line 169 of file G4VDecayChannel.hh.

G4String* G4VDecayChannel::parent_name

protected

Definition at line 171 of file G4VDecayChannel.hh.

G4ThreeVector G4VDecayChannel::parent_polarization

protected

Definition at line 179 of file G4VDecayChannel.hh.

G4Mutex G4VDecayChannel::parentMutex

protected

Definition at line 198 of file G4VDecayChannel.hh.

G4ParticleTable* G4VDecayChannel::particletable

protected

Definition at line 182 of file G4VDecayChannel.hh.

G4double G4VDecayChannel::rangeMass

protected

Definition at line 176 of file G4VDecayChannel.hh.

G4double G4VDecayChannel::rbranch

protected

Definition at line 167 of file G4VDecayChannel.hh.

G4int G4VDecayChannel::verboseLevel

protected

Definition at line 185 of file G4VDecayChannel.hh.

---

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

• geant4.10.03.p01/source/particles/management/include/G4VDecayChannel.hh
• geant4.10.03.p01/source/particles/management/src/G4VDecayChannel.cc