G4CompetitiveFission Class Reference

#include <G4CompetitiveFission.hh>

Inheritance diagram for G4CompetitiveFission:

Public Member Functions
	G4CompetitiveFission ()
	~G4CompetitiveFission () override
G4Fragment *	EmittedFragment (G4Fragment *theNucleus) override
G4double	GetEmissionProbability (G4Fragment *theNucleus) override
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 G4double	GetEmissionProbability (G4Fragment *theNucleus)=0
virtual void	Initialise ()
virtual G4double	GetLifeTime (G4Fragment *theNucleus)
virtual G4Fragment *	EmittedFragment (G4Fragment *theNucleus)
virtual G4bool	BreakUpChain (G4FragmentVector *theResult, G4Fragment *theNucleus)
G4FragmentVector *	BreakUpFragment (G4Fragment *theNucleus)
virtual void	Dump () const
virtual void	SetICM (G4bool)
virtual void	RDMForced (G4bool)
void	SetOPTxs (G4int opt)
void	UseSICB (G4bool use)

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

Detailed Description

Definition at line 46 of file G4CompetitiveFission.hh.

Constructor & Destructor Documentation

G4CompetitiveFission()

G4CompetitiveFission::G4CompetitiveFission ( )

explicit

Definition at line 49 of file G4CompetitiveFission.cc.

                                           : G4VEvaporationChannel("fission")
{
  theFissionBarrierPtr = new G4FissionBarrier;
  myOwnFissionBarrier = true;
 
  theFissionProbabilityPtr = new G4FissionProbability;
  myOwnFissionProbability = true;
  
  theLevelDensityPtr = new G4FissionLevelDensityParameter;
  myOwnLevelDensity = true;
 
  maxKineticEnergy = fissionBarrier = fissionProbability = 0.0;
  pairingCorrection = G4NuclearLevelData::GetInstance()->GetPairingCorrection();
}

~G4CompetitiveFission()

G4CompetitiveFission::~G4CompetitiveFission ( )

override

Definition at line 64 of file G4CompetitiveFission.cc.

{
  if (myOwnFissionBarrier) delete theFissionBarrierPtr;
  if (myOwnFissionProbability) delete theFissionProbabilityPtr;
  if (myOwnLevelDensity) delete theLevelDensityPtr;
}

Member Function Documentation

EmittedFragment()

G4Fragment * G4CompetitiveFission::EmittedFragment ( G4Fragment *  theNucleus )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 92 of file G4CompetitiveFission.cc.

{
  G4Fragment * Fragment1 = nullptr; 
  // 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 + 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 = 
    std::sqrt((etot1 - M1)*(etot1+M1))*G4RandomDirection();
  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;
}

GetEmissionProbability()

G4double G4CompetitiveFission::GetEmissionProbability ( G4Fragment *  theNucleus )

overridevirtual

Implements G4VEvaporationChannel.

Definition at line 71 of file G4CompetitiveFission.cc.

{
  G4int Z = fragment->GetZ_asInt();
  G4int A = fragment->GetA_asInt();
  fissionProbability = 0.0;
  // Saddle point excitation energy ---> A = 65
  if (A >= 65 && Z > 16) {
    G4double exEnergy = fragment->GetExcitationEnergy() - 
      pairingCorrection->GetFissionPairingCorrection(A, Z);
  
    if (exEnergy > 0.0) {
      fissionBarrier = theFissionBarrierPtr->FissionBarrier(A, Z, exEnergy);
      maxKineticEnergy = exEnergy - fissionBarrier;
      fissionProbability = 
    theFissionProbabilityPtr->EmissionProbability(*fragment,
                              maxKineticEnergy);
    }
  }
  return fissionProbability;
}

GetFissionBarrier()

G4double G4CompetitiveFission::GetFissionBarrier ( void  ) const

inline

Definition at line 122 of file G4CompetitiveFission.hh.

{ 
  return fissionBarrier; 
}

GetLevelDensityParameter()

G4double G4CompetitiveFission::GetLevelDensityParameter ( void  ) const

inline

GetMaximalKineticEnergy()

G4double G4CompetitiveFission::GetMaximalKineticEnergy ( void  ) const

inline

Definition at line 127 of file G4CompetitiveFission.hh.

{ 
  return maxKineticEnergy; 
}

SetEmissionStrategy()

void G4CompetitiveFission::SetEmissionStrategy

(

G4VEmissionProbability *

aFissionProb

)

Definition at line 376 of file G4CompetitiveFission.cc.

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

Referenced by G4INCLXXInterface::G4INCLXXInterface().

SetFissionBarrier()

void G4CompetitiveFission::SetFissionBarrier

(

G4VFissionBarrier *

aBarrier

)

Definition at line 368 of file G4CompetitiveFission.cc.

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

SetLevelDensityParameter()

void G4CompetitiveFission::SetLevelDensityParameter

(

G4VLevelDensityParameter *

aLevelDensity

)

Definition at line 384 of file G4CompetitiveFission.cc.

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

Referenced by G4INCLXXInterface::G4INCLXXInterface().

---

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

• G4CompetitiveFission.hh
• G4CompetitiveFission.cc