G4CompetitiveFission Class Reference

#include <G4CompetitiveFission.hh>

Inheritance diagram for G4CompetitiveFission:

Public Member Functions
	G4CompetitiveFission ()
	~G4CompetitiveFission () override
void	Initialise () 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
	G4CompetitiveFission (const G4CompetitiveFission &right)=delete
const G4CompetitiveFission &	operator= (const G4CompetitiveFission &right)=delete
G4bool	operator== (const G4CompetitiveFission &right) const =delete
G4bool	operator!= (const G4CompetitiveFission &right) const =delete
Public Member Functions inherited from G4VEvaporationChannel
	G4VEvaporationChannel (const G4String &aName="")
virtual	~G4VEvaporationChannel ()=default
virtual G4double	GetLifeTime (G4Fragment *theNucleus)
virtual G4bool	BreakUpChain (G4FragmentVector *theResult, G4Fragment *theNucleus)
G4FragmentVector *	BreakUpFragment (G4Fragment *theNucleus)
virtual G4double	ComputeInverseXSection (G4Fragment *theNucleus, G4double kinEnergy)
virtual G4double	ComputeProbability (G4Fragment *theNucleus, G4double kinEnergy)
virtual void	Dump () const
virtual void	SetICM (G4bool)
virtual void	RDMForced (G4bool)
void	SetOPTxs (G4int)
void	UseSICB (G4bool)
	G4VEvaporationChannel (const G4VEvaporationChannel &right)=delete
const G4VEvaporationChannel &	operator= (const G4VEvaporationChannel &right)=delete
G4bool	operator== (const G4VEvaporationChannel &right) const =delete
G4bool	operator!= (const G4VEvaporationChannel &right) const =delete

Additional Inherited Members
Protected Attributes inherited from G4VEvaporationChannel
G4int	OPTxs {3}
G4bool	useSICB {true}

Detailed Description

Definition at line 46 of file G4CompetitiveFission.hh.

Constructor & Destructor Documentation

G4CompetitiveFission() [1/2]

G4CompetitiveFission::G4CompetitiveFission

(

)

Definition at line 50 of file G4CompetitiveFission.cc.

                                           : G4VEvaporationChannel("fission"), theSecID(-1)
{
  theFissionBarrierPtr = new G4FissionBarrier;
  theFissionProbabilityPtr = new G4FissionProbability;
  theLevelDensityPtr = new G4FissionLevelDensityParameter;
  pairingCorrection = G4NuclearLevelData::GetInstance()->GetPairingCorrection();
  theSecID = G4PhysicsModelCatalog::GetModelID("model_G4CompetitiveFission");
}

Referenced by G4CompetitiveFission(), operator!=(), operator=(), and operator==().

~G4CompetitiveFission()

G4CompetitiveFission::~G4CompetitiveFission ( )

override

Definition at line 59 of file G4CompetitiveFission.cc.

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

G4CompetitiveFission() [2/2]

G4CompetitiveFission::G4CompetitiveFission ( const G4CompetitiveFission & right )

delete

Member Function Documentation

EmittedFragment()

G4Fragment * G4CompetitiveFission::EmittedFragment ( G4Fragment * theNucleus )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 97 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);
  if (Fragment1 != nullptr) { Fragment1->SetCreatorModelID(theSecID); }
  theNucleusMomentum -= FourMomentum1;
  theNucleus->SetZandA_asInt(Z2, A2);
  theNucleus->SetMomentum(theNucleusMomentum);
  theNucleus->SetCreatorModelID(theSecID);
  return Fragment1;
}

GetEmissionProbability()

G4double G4CompetitiveFission::GetEmissionProbability ( G4Fragment * theNucleus )

overridevirtual

Implements G4VEvaporationChannel.

Definition at line 75 of file G4CompetitiveFission.cc.

{
  if (!isInitialised) { Initialise(); }
  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*fFactor;
}

GetFissionBarrier()

G4double G4CompetitiveFission::GetFissionBarrier ( void ) const

inline

Definition at line 127 of file G4CompetitiveFission.hh.

{ 
  return fissionBarrier; 
}

GetLevelDensityParameter()

G4double G4CompetitiveFission::GetLevelDensityParameter ( void ) const

inline

GetMaximalKineticEnergy()

G4double G4CompetitiveFission::GetMaximalKineticEnergy ( void ) const

inline

Definition at line 132 of file G4CompetitiveFission.hh.

{ 
  return maxKineticEnergy; 
}

Initialise()

void G4CompetitiveFission::Initialise ( )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 66 of file G4CompetitiveFission.cc.

{
  if (!isInitialised) {
    isInitialised = true;
    G4VEvaporationChannel::Initialise();  
    if (OPTxs == 1) { fFactor = 0.5; }
  }
}

Referenced by GetEmissionProbability().

operator!=()

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

delete

operator=()

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

delete

operator==()

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

delete

SetEmissionStrategy()

void G4CompetitiveFission::SetEmissionStrategy

(

G4VEmissionProbability *

aFissionProb

)

Definition at line 383 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 375 of file G4CompetitiveFission.cc.

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

SetLevelDensityParameter()

void G4CompetitiveFission::SetLevelDensityParameter

(

G4VLevelDensityParameter *

aLevelDensity

)

Definition at line 391 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