G4CompetitiveFission Class Reference

#include <G4CompetitiveFission.hh>

Inheritance diagram for G4CompetitiveFission:

Collaboration diagram for G4CompetitiveFission:

Public Member Functions
	G4CompetitiveFission ()
virtual	~G4CompetitiveFission ()
virtual G4FragmentVector *	BreakUp (const G4Fragment &theNucleus)
virtual G4Fragment *	EmittedFragment (G4Fragment *theNucleus)
virtual G4double	GetEmissionProbability (G4Fragment *theNucleus)
void	SetFissionBarrier (G4VFissionBarrier *aBarrier)
void	SetEmissionStrategy (G4VEmissionProbability *aFissionProb)
void	SetLevelDensityParameter (G4VLevelDensityParameter *aLevelDensity)
G4double	GetFissionBarrier (void) const
G4double	GetLevelDensityParameter (void) const
G4double	GetMaximalKineticEnergy (void) const
Public Member Functions inherited from G4VEvaporationChannel
	G4VEvaporationChannel (const G4String &aName="")
virtual	~G4VEvaporationChannel ()
virtual void	Initialise ()
virtual G4double	GetLifeTime (G4Fragment *theNucleus)
virtual G4FragmentVector *	BreakUpFragment (G4Fragment *theNucleus)
virtual G4bool	BreakUpChain (G4FragmentVector *theResult, G4Fragment *theNucleus)
virtual void	Dump () const
virtual void	SetICM (G4bool)
virtual void	RDMForced (G4bool)
virtual G4double	GetFinalLevelEnergy (G4int Z, G4int A, G4double energy)
virtual G4double	GetUpperLevelEnergy (G4int Z, G4int A)
G4double	GetMaxLevelEnergy (G4int Z, G4int A)
G4double	GetNearestLevelEnergy (G4int Z, G4int A, G4double energy)
void	SetPhotonEvaporation (G4VEvaporationChannel *p)
void	SetOPTxs (G4int opt)
void	UseSICB (G4bool use)

Private Member Functions
G4int	FissionAtomicNumber (G4int A)
G4double	MassDistribution (G4double x, G4int A)
G4int	FissionCharge (G4int A, G4int Z, G4double Af)
G4double	FissionKineticEnergy (G4int A, G4int Z, G4int Af1, G4int Zf1, G4int Af2, G4int Zf2, G4double U, G4double Tmax)
G4double	Ratio (G4double A, G4double A11, G4double B1, G4double A00)
G4double	SymmetricRatio (G4int A, G4double A11)
G4double	AsymmetricRatio (G4int A, G4double A11)
G4ThreeVector	IsotropicVector (G4double Magnitude)
	G4CompetitiveFission (const G4CompetitiveFission &right)
const G4CompetitiveFission &	operator= (const G4CompetitiveFission &right)
G4bool	operator== (const G4CompetitiveFission &right) const
G4bool	operator!= (const G4CompetitiveFission &right) const

Private Attributes
G4double	MaximalKineticEnergy
G4VFissionBarrier *	theFissionBarrierPtr
G4double	FissionBarrier
G4bool	MyOwnFissionBarrier
G4VEmissionProbability *	theFissionProbabilityPtr
G4double	FissionProbability
G4bool	MyOwnFissionProbability
G4bool	MyOwnLevelDensity
G4VLevelDensityParameter *	theLevelDensityPtr
G4double	LevelDensityParameter
G4PairingCorrection *	pairingCorrection
G4FissionParameters	theParam

Additional Inherited Members
Protected Attributes inherited from G4VEvaporationChannel
G4int	OPTxs
G4bool	useSICB

Detailed Description

Definition at line 47 of file G4CompetitiveFission.hh.

Constructor & Destructor Documentation

G4CompetitiveFission() [1/2]

G4CompetitiveFission::G4CompetitiveFission

(

)

Definition at line 44 of file G4CompetitiveFission.cc.

                                           : G4VEvaporationChannel("fission")
{
  theFissionBarrierPtr = new G4FissionBarrier;
  MyOwnFissionBarrier = true;

  theFissionProbabilityPtr = new G4FissionProbability;
  MyOwnFissionProbability = true;
  
  theLevelDensityPtr = new G4FissionLevelDensityParameter;
  MyOwnLevelDensity = true;

  MaximalKineticEnergy = -1000.0;
  FissionBarrier = 0.0;
  FissionProbability = 0.0;
  LevelDensityParameter = 0.0;
  pairingCorrection = G4PairingCorrection::GetInstance();
}

Here is the call graph for this function:

~G4CompetitiveFission()

G4CompetitiveFission::~G4CompetitiveFission ( )

virtual

Definition at line 62 of file G4CompetitiveFission.cc.

{
  if (MyOwnFissionBarrier) delete theFissionBarrierPtr;
  if (MyOwnFissionProbability) delete theFissionProbabilityPtr;
  if (MyOwnLevelDensity) delete theLevelDensityPtr;
}

G4CompetitiveFission() [2/2]

G4CompetitiveFission::G4CompetitiveFission ( const G4CompetitiveFission &  right )

private

Member Function Documentation

AsymmetricRatio()

G4double G4CompetitiveFission::AsymmetricRatio ( G4int  A, G4double  A11  )

inlineprivate

Definition at line 179 of file G4CompetitiveFission.hh.

{
  return Ratio(G4double(A),A11,23.5,134.0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

BreakUp()

G4FragmentVector * G4CompetitiveFission::BreakUp ( const G4Fragment &  theNucleus )

virtual

Implements G4VEvaporationChannel.

Definition at line 95 of file G4CompetitiveFission.cc.

{
  G4FragmentVector * theResult = new G4FragmentVector();
  G4Fragment* frag0 = new G4Fragment(theNucleus);
  G4Fragment* frag1 = EmittedFragment(frag0);
  if(frag1) { theResult->push_back(frag1); }
  theResult->push_back(frag0);
  return theResult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EmittedFragment()

G4Fragment * G4CompetitiveFission::EmittedFragment ( G4Fragment *  theNucleus )

virtual

Reimplemented from G4VEvaporationChannel.

Definition at line 105 of file G4CompetitiveFission.cc.

{
  G4Fragment * Fragment1 = 0; 
  // Nucleus data
  // Atomic number of nucleus
  G4int A = theNucleus->GetA_asInt();
  // Charge of nucleus
  G4int Z = theNucleus->GetZ_asInt();
  //   Excitation energy (in MeV)
  G4double U = theNucleus->GetExcitationEnergy();
  G4double pcorr = pairingCorrection->GetFissionPairingCorrection(A,Z);
  if (U <= pcorr) { return Fragment1; }

  // Atomic Mass of Nucleus (in MeV)
  G4double M = theNucleus->GetGroundStateMass();

  // Nucleus Momentum
  G4LorentzVector theNucleusMomentum = theNucleus->GetMomentum();

  // Calculate fission parameters
  theParam.DefineParameters(A, Z, U-pcorr, FissionBarrier);
  
  // First fragment
  G4int A1 = 0;
  G4int Z1 = 0;
  G4double M1 = 0.0;

  // Second fragment
  G4int A2 = 0;
  G4int Z2 = 0;
  G4double M2 = 0.0;

  G4double FragmentsExcitationEnergy = 0.0;
  G4double FragmentsKineticEnergy = 0.0;

  G4int Trials = 0;
  do {

    // First fragment 
    A1 = FissionAtomicNumber(A);
    Z1 = FissionCharge(A, Z, A1);
    M1 = G4NucleiProperties::GetNuclearMass(A1, Z1);

    // Second Fragment
    A2 = A - A1;
    Z2 = Z - Z1;
    if (A2 < 1 || Z2 < 0 || Z2 > A2) {
      FragmentsExcitationEnergy = -1.0;
      continue;
    }
    M2 = G4NucleiProperties::GetNuclearMass(A2, Z2);
    // Maximal Kinetic Energy (available energy for fragments)
    G4double Tmax = M + U - M1 - M2 - pcorr;

    // Check that fragment masses are less or equal than total energy
    if (Tmax < 0.0) {
      FragmentsExcitationEnergy = -1.0;
      continue;
    }

    FragmentsKineticEnergy = FissionKineticEnergy( A , Z,
                           A1, Z1,
                           A2, Z2,
                           U , Tmax);
    
    // Excitation Energy
    // FragmentsExcitationEnergy = Tmax - FragmentsKineticEnergy;
    // JMQ 04/03/09 BUG FIXED: in order to fulfill energy conservation the
    // fragments carry the fission pairing energy in form of 
    // excitation energy

    FragmentsExcitationEnergy = 
      // Tmax - FragmentsKineticEnergy;
      Tmax - FragmentsKineticEnergy + pcorr;

    // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
  } while (FragmentsExcitationEnergy < 0.0
       && ++Trials < 100);
    
  if (FragmentsExcitationEnergy <= 0.0) { 
    throw G4HadronicException(__FILE__, __LINE__, 
      "G4CompetitiveFission::BreakItUp: Excitation energy for fragments < 0.0!");
  }

  // Fragment 1
  M1 += FragmentsExcitationEnergy * A1/static_cast<G4double>(A);
  // Fragment 2
  M2 += FragmentsExcitationEnergy * A2/static_cast<G4double>(A);
  // primary
  M += U;

  G4double etot1 = ((M - M2)*(M + M2) + M1*M1)/(2*M);
  G4ParticleMomentum Momentum1(IsotropicVector(std::sqrt((etot1 - M1)*(etot1+M1))));
  G4LorentzVector FourMomentum1(Momentum1, etot1);
  FourMomentum1.boost(theNucleusMomentum.boostVector());
    
  // Create Fragments
  Fragment1 = new G4Fragment( A1, Z1, FourMomentum1);
  theNucleusMomentum -= FourMomentum1;
  theNucleus->SetZandA_asInt(Z2, A2);
  theNucleus->SetMomentum(theNucleusMomentum);
  return Fragment1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FissionAtomicNumber()

G4int G4CompetitiveFission::FissionAtomicNumber ( G4int  A )

private

Definition at line 210 of file G4CompetitiveFission.cc.

{

  // For Simplicity reading code
  G4int A1 = theParam.GetA1();
  G4int A2 = theParam.GetA2();
  G4double As = theParam.GetAs();
  G4double Sigma2 = theParam.GetSigma2();
  G4double SigmaS = theParam.GetSigmaS();
  G4double w = theParam.GetW();
  
  G4double C2A = A2 + 3.72*Sigma2;
  G4double C2S = As + 3.72*SigmaS;
  
  G4double C2 = 0.0;
  if (w > 1000.0 )    { C2 = C2S; }
  else if (w < 0.001) { C2 = C2A; }
  else                { C2 =  std::max(C2A,C2S); }

  G4double C1 = A-C2;
  if (C1 < 30.0) {
    C2 = A-30.0;
    C1 = 30.0;
  }

  G4double Am1 = (As + A1)*0.5;
  G4double Am2 = (A1 + A2)*0.5;

  // Get Mass distributions as sum of symmetric and asymmetric Gasussians
  G4double Mass1 = MassDistribution(As,A); 
  G4double Mass2 = MassDistribution(Am1,A); 
  G4double Mass3 = MassDistribution(G4double(A1),A); 
  G4double Mass4 = MassDistribution(Am2,A); 
  G4double Mass5 = MassDistribution(G4double(A2),A); 
  // get maximal value among Mass1,...,Mass5
  G4double MassMax = Mass1;
  if (Mass2 > MassMax) { MassMax = Mass2; }
  if (Mass3 > MassMax) { MassMax = Mass3; }
  if (Mass4 > MassMax) { MassMax = Mass4; }
  if (Mass5 > MassMax) { MassMax = Mass5; }

  // Sample a fragment mass number, which lies between C1 and C2
  G4double xm;
  G4double Pm;
  do {
    xm = C1+G4UniformRand()*(C2-C1);
    Pm = MassDistribution(xm,A); 
    // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
  } while (MassMax*G4UniformRand() > Pm);
  G4int ires = G4lrint(xm);

  return ires;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FissionCharge()

G4int G4CompetitiveFission::FissionCharge ( G4int  A, G4int  Z, G4double  Af  )

private

Definition at line 288 of file G4CompetitiveFission.cc.

{
  static const G4double sigma = 0.6;
  G4double DeltaZ = 0.0;
  if (Af >= 134.0)          { DeltaZ = -0.45; }  
  else if (Af <= (A-134.0)) { DeltaZ = 0.45; }
  else                      { DeltaZ = -0.45*(Af-A*0.5)/(134.0-A*0.5); }

  G4double Zmean = (Af/A)*Z + DeltaZ;
 
  G4double theZ;
  do {
    theZ = G4RandGauss::shoot(Zmean,sigma);
    // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
  } while (theZ  < 1.0 || theZ > (Z-1.0) || theZ > Af);
  
  return G4lrint(theZ);
}

Here is the call graph for this function:

Here is the caller graph for this function:

FissionKineticEnergy()

G4double G4CompetitiveFission::FissionKineticEnergy ( G4int  A, G4int  Z, G4int  Af1, G4int  Zf1, G4int  Af2, G4int  Zf2, G4double  U, G4double  Tmax  )

private

Definition at line 309 of file G4CompetitiveFission.cc.

{
  // Find maximal value of A for fragments
  G4int AfMax = std::max(Af1,Af2);

  // Weights for symmetric and asymmetric components
  G4double Pas = 0.0;
  if (theParam.GetW() <= 1000) { 
    G4double x1 = (AfMax-theParam.GetA1())/theParam.GetSigma1();
    G4double x2 = (AfMax-theParam.GetA2())/theParam.GetSigma2();
    Pas = 0.5*G4Exp(-0.5*x1*x1) + G4Exp(-0.5*x2*x2);
  }

  G4double Ps = 0.0;
  if (theParam.GetW() >= 0.001) {
    G4double xs = (AfMax-theParam.GetAs())/theParam.GetSigmaS();
    Ps = theParam.GetW()*G4Exp(-0.5*xs*xs);
  }
  G4double Psy = Ps/(Pas+Ps);

  // Fission fractions Xsy and Xas formed in symmetric and asymmetric modes
  G4double PPas = theParam.GetSigma1() + 2.0 * theParam.GetSigma2();
  G4double PPsy = theParam.GetW() * theParam.GetSigmaS();
  G4double Xas = PPas / (PPas+PPsy);
  G4double Xsy = PPsy / (PPas+PPsy);

  // Average kinetic energy for symmetric and asymmetric components
  G4double Eaverage = (0.1071*(Z*Z)/G4Pow::GetInstance()->Z13(A) + 22.2)*CLHEP::MeV;

  // Compute maximal average kinetic energy of fragments and Energy Dispersion 
  G4double TaverageAfMax;
  G4double ESigma = 10*CLHEP::MeV;
  // Select randomly fission mode (symmetric or asymmetric)
  if (G4UniformRand() > Psy) { // Asymmetric Mode
    G4double A11 = theParam.GetA1()-0.7979*theParam.GetSigma1();
    G4double A12 = theParam.GetA1()+0.7979*theParam.GetSigma1();
    G4double A21 = theParam.GetA2()-0.7979*theParam.GetSigma2();
    G4double A22 = theParam.GetA2()+0.7979*theParam.GetSigma2();
    // scale factor
    G4double ScaleFactor = 0.5*theParam.GetSigma1()*
      (AsymmetricRatio(A,A11)+AsymmetricRatio(A,A12))+
      theParam.GetSigma2()*(AsymmetricRatio(A,A21)+AsymmetricRatio(A,A22));
    // Compute average kinetic energy for fragment with AfMax
    TaverageAfMax = (Eaverage + 12.5 * Xsy) * (PPas/ScaleFactor) * 
      AsymmetricRatio(A,G4double(AfMax));

  } else { // Symmetric Mode
    G4double As0 = theParam.GetAs() + 0.7979*theParam.GetSigmaS();
    // Compute average kinetic energy for fragment with AfMax
    TaverageAfMax = (Eaverage - 12.5*CLHEP::MeV*Xas)
      *SymmetricRatio(A, G4double(AfMax))/SymmetricRatio(A, As0);
    ESigma = 8.0*CLHEP::MeV;
  }

  // Select randomly, in accordance with Gaussian distribution, 
  // fragment kinetic energy
  G4double KineticEnergy;
  G4int i = 0;
  do {
    KineticEnergy = G4RandGauss::shoot(TaverageAfMax, ESigma);
    if (++i > 100) return Eaverage;
    // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
  } while (KineticEnergy < Eaverage-3.72*ESigma || 
       KineticEnergy > Eaverage+3.72*ESigma ||
       KineticEnergy > Tmax);
  
  return KineticEnergy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetEmissionProbability()

G4double G4CompetitiveFission::GetEmissionProbability ( G4Fragment *  theNucleus )

virtual

Implements G4VEvaporationChannel.

Definition at line 69 of file G4CompetitiveFission.cc.

{
  G4int anA = fragment->GetA_asInt();
  G4int aZ  = fragment->GetZ_asInt();
  G4double ExEnergy = fragment->GetExcitationEnergy() - 
    pairingCorrection->GetFissionPairingCorrection(anA,aZ);
  
  // Saddle point excitation energy ---> A = 65
  // Fission is excluded for A < 65
  if (anA >= 65 && ExEnergy > 0.0) {
    FissionBarrier = theFissionBarrierPtr->FissionBarrier(anA,aZ,ExEnergy);
    MaximalKineticEnergy = ExEnergy - FissionBarrier;
    LevelDensityParameter = 
      theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
    FissionProbability = 
      theFissionProbabilityPtr->EmissionProbability(*fragment,
                            MaximalKineticEnergy);
    }
  else {
    MaximalKineticEnergy = -1000.0;
    LevelDensityParameter = 0.0;
    FissionProbability = 0.0;
  }
  return FissionProbability;
}

Here is the call graph for this function:

GetFissionBarrier()

G4double G4CompetitiveFission::GetFissionBarrier ( void  ) const

inline

Definition at line 148 of file G4CompetitiveFission.hh.

{ 
  return FissionBarrier; 
}

GetLevelDensityParameter()

G4double G4CompetitiveFission::GetLevelDensityParameter ( void  ) const

inline

Definition at line 153 of file G4CompetitiveFission.hh.

{ 
  return LevelDensityParameter; 
}

GetMaximalKineticEnergy()

G4double G4CompetitiveFission::GetMaximalKineticEnergy ( void  ) const

inline

Definition at line 158 of file G4CompetitiveFission.hh.

{ 
  return MaximalKineticEnergy; 
}

IsotropicVector()

G4ThreeVector G4CompetitiveFission::IsotropicVector ( G4double  Magnitude )

inlineprivate

Definition at line 192 of file G4CompetitiveFission.hh.

{
  G4double CosTheta = 1.0 - 2.0*G4UniformRand();
  G4double SinTheta = std::sqrt(1.0 - CosTheta*CosTheta);
  G4double Phi = CLHEP::twopi*G4UniformRand();
  G4ThreeVector Vector(Magnitude*std::cos(Phi)*SinTheta,
               Magnitude*std::sin(Phi)*SinTheta,
               Magnitude*CosTheta);
  return Vector;
}

Here is the caller graph for this function:

MassDistribution()

G4double G4CompetitiveFission::MassDistribution ( G4double  x, G4int  A  )

private

Definition at line 266 of file G4CompetitiveFission.cc.

{
  G4double y0 = (x-theParam.GetAs())/theParam.GetSigmaS();
  G4double Xsym = G4Exp(-0.5*y0*y0);

  G4double y1 = (x - theParam.GetA1())/theParam.GetSigma1();
  G4double y2 = (x - theParam.GetA2())/theParam.GetSigma2();
  G4double z1 = (x - A + theParam.GetA1())/theParam.GetSigma1();
  G4double z2 = (x - A + theParam.GetA2())/theParam.GetSigma2();
  G4double Xasym = G4Exp(-0.5*y1*y1) + G4Exp(-0.5*y2*y2) 
    + 0.5*( G4Exp(-0.5*z1*z1) + G4Exp(-0.5*z2*z2));

  G4double res;
  G4double w = theParam.GetW();
  if (w > 1000)       { res = Xsym; }
  else if (w < 0.001) { res = Xasym; }
  else                { res = w*Xsym+Xasym; }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

G4bool G4CompetitiveFission::operator!= ( const G4CompetitiveFission &  right ) const

private

operator=()

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

private

operator==()

G4bool G4CompetitiveFission::operator== ( const G4CompetitiveFission &  right ) const

private

Ratio()

G4double G4CompetitiveFission::Ratio ( G4double  A, G4double  A11, G4double  B1, G4double  A00  )

inlineprivate

Definition at line 164 of file G4CompetitiveFission.hh.

{
  G4double res;
  if (A11 >= A*0.5 && A11 <= (A00+10.0)) {
    G4double x = (A11-A00)/A;
    res = 1.0 - B1*x*x;
  } else {
    G4double x = 10.0/A;
    res = 1.0 - B1*x*x - 2.0*x*B1*(A11-A00-10.0)/A;
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetEmissionStrategy()

void G4CompetitiveFission::SetEmissionStrategy ( G4VEmissionProbability *  aFissionProb )

inline

Definition at line 133 of file G4CompetitiveFission.hh.

{
  if (MyOwnFissionProbability) delete theFissionProbabilityPtr;
  theFissionProbabilityPtr = aFissionProb;
  MyOwnFissionProbability = false;
}

Here is the caller graph for this function:

SetFissionBarrier()

void G4CompetitiveFission::SetFissionBarrier ( G4VFissionBarrier *  aBarrier )

inline

Definition at line 125 of file G4CompetitiveFission.hh.

{
  if (MyOwnFissionBarrier) delete theFissionBarrierPtr;
  theFissionBarrierPtr = aBarrier;
  MyOwnFissionBarrier = false;
}

SetLevelDensityParameter()

void G4CompetitiveFission::SetLevelDensityParameter ( G4VLevelDensityParameter *  aLevelDensity )

inline

Definition at line 141 of file G4CompetitiveFission.hh.

{ 
  if (MyOwnLevelDensity) delete theLevelDensityPtr;
  theLevelDensityPtr = aLevelDensity;
  MyOwnLevelDensity = false;
}

Here is the caller graph for this function:

SymmetricRatio()

G4double G4CompetitiveFission::SymmetricRatio ( G4int  A, G4double  A11  )

inlineprivate

Definition at line 185 of file G4CompetitiveFission.hh.

{
  G4double A0 = G4double(A);
  return Ratio(A0,A11,5.32,A0*0.5);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

FissionBarrier

G4double G4CompetitiveFission::FissionBarrier

private

Definition at line 106 of file G4CompetitiveFission.hh.

FissionProbability

G4double G4CompetitiveFission::FissionProbability

private

Definition at line 111 of file G4CompetitiveFission.hh.

LevelDensityParameter

G4double G4CompetitiveFission::LevelDensityParameter

private

Definition at line 117 of file G4CompetitiveFission.hh.

MaximalKineticEnergy

G4double G4CompetitiveFission::MaximalKineticEnergy

private

Definition at line 102 of file G4CompetitiveFission.hh.

MyOwnFissionBarrier

G4bool G4CompetitiveFission::MyOwnFissionBarrier

private

Definition at line 107 of file G4CompetitiveFission.hh.

MyOwnFissionProbability

G4bool G4CompetitiveFission::MyOwnFissionProbability

private

Definition at line 112 of file G4CompetitiveFission.hh.

MyOwnLevelDensity

G4bool G4CompetitiveFission::MyOwnLevelDensity

private

Definition at line 115 of file G4CompetitiveFission.hh.

pairingCorrection

G4PairingCorrection* G4CompetitiveFission::pairingCorrection

private

Definition at line 119 of file G4CompetitiveFission.hh.

theFissionBarrierPtr

G4VFissionBarrier* G4CompetitiveFission::theFissionBarrierPtr

private

Definition at line 105 of file G4CompetitiveFission.hh.

theFissionProbabilityPtr

G4VEmissionProbability* G4CompetitiveFission::theFissionProbabilityPtr

private

Definition at line 110 of file G4CompetitiveFission.hh.

theLevelDensityPtr

G4VLevelDensityParameter* G4CompetitiveFission::theLevelDensityPtr

private

Definition at line 116 of file G4CompetitiveFission.hh.

theParam

G4FissionParameters G4CompetitiveFission::theParam

private

Definition at line 121 of file G4CompetitiveFission.hh.

---

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

• G4CompetitiveFission.hh
• G4CompetitiveFission.cc