G4CompetitiveFission Class Reference

#include <G4CompetitiveFission.hh>

Inheritance diagram for G4CompetitiveFission:

Public Member Functions
	G4CompetitiveFission ()
virtual	~G4CompetitiveFission ()
virtual G4FragmentVector *	BreakUp (const 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="Anonymous")
virtual	~G4VEvaporationChannel ()
virtual G4Fragment *	EmittedFragment (G4Fragment *theNucleus)
virtual G4FragmentVector *	BreakUpFragment (G4Fragment *theNucleus)
virtual G4FragmentVector *	BreakUp (const G4Fragment &theNucleus)=0
virtual G4double	GetEmissionProbability (G4Fragment *theNucleus)=0
G4String	GetName () const
void	SetName (const G4String &aName)
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 50 of file G4CompetitiveFission.hh.

Constructor & Destructor Documentation

G4CompetitiveFission()

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*MeV;
    FissionBarrier = 0.0;
    FissionProbability = 0.0;
    LevelDensityParameter = 0.0;
}

~G4CompetitiveFission()

G4CompetitiveFission::~G4CompetitiveFission ( )

virtual

Definition at line 61 of file G4CompetitiveFission.cc.

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

Member Function Documentation

BreakUp()

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

virtual

Implements G4VEvaporationChannel.

Definition at line 96 of file G4CompetitiveFission.cc.

{
  // 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() - 
    G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
  // Check that U > 0
  if (U <= 0.0) {
    G4FragmentVector * theResult = new  G4FragmentVector;
    theResult->push_back(new G4Fragment(theNucleus));
    return theResult;
  }
 
  // Atomic Mass of Nucleus (in MeV)
  G4double M = theNucleus.GetGroundStateMass();
 
  // Nucleus Momentum
  G4LorentzVector theNucleusMomentum = theNucleus.GetMomentum();
 
  // Calculate fission parameters
  G4FissionParameters theParameters(A,Z,U,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;
 
  //JMQ 04/03/09 It will be used latter to fix the bug in energy conservation
  G4double FissionPairingEnergy=
    G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
 
  G4int Trials = 0;
  do {
 
    // First fragment 
    A1 = FissionAtomicNumber(A,theParameters);
    Z1 = FissionCharge(A,Z,A1);
    M1 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z1,A1);
 
    // Second Fragment
    A2 = A - A1;
    Z2 = Z - Z1;
    if (A2 < 1 || Z2 < 0) {
      throw G4HadronicException(__FILE__, __LINE__, 
    "G4CompetitiveFission::BreakUp: Can't define second fragment! ");
    }
    M2 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z2,A2);
 
    // Check that fragment masses are less or equal than total energy
    if (M1 + M2 > theNucleusMomentum.e()) {
      throw G4HadronicException(__FILE__, __LINE__, 
    "G4CompetitiveFission::BreakUp: Fragments Mass > Total Energy");
    }
    // Maximal Kinetic Energy (available energy for fragments)
    G4double Tmax = M + U - M1 - M2;
 
    FragmentsKineticEnergy = FissionKineticEnergy( A , Z,
                           A1, Z1,
                           A2, Z2,
                           U , Tmax,
                           theParameters);
    
    // 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+FissionPairingEnergy;
 
  } while (FragmentsExcitationEnergy < 0.0 && Trials++ < 100);
    
  if (FragmentsExcitationEnergy <= 0.0) { 
    throw G4HadronicException(__FILE__, __LINE__, 
      "G4CompetitiveFission::BreakItUp: Excitation energy for fragments < 0.0!");
  }
 
  // while (FragmentsExcitationEnergy < 0 && Trials < 100);
  
  // Fragment 1
  G4double U1 = FragmentsExcitationEnergy * A1/static_cast<G4double>(A);
    // Fragment 2
  G4double U2 = FragmentsExcitationEnergy * A2/static_cast<G4double>(A);
 
  //JMQ  04/03/09 Full relativistic calculation is performed
  //
  G4double Fragment1KineticEnergy=
    (FragmentsKineticEnergy*(FragmentsKineticEnergy+2*(M2+U2)))
    /(2*(M1+U1+M2+U2+FragmentsKineticEnergy));
  G4ParticleMomentum Momentum1(IsotropicVector(std::sqrt(Fragment1KineticEnergy*(Fragment1KineticEnergy+2*(M1+U1)))));
  G4ParticleMomentum Momentum2(-Momentum1);
  G4LorentzVector FourMomentum1(Momentum1,std::sqrt(Momentum1.mag2()+(M1+U1)*(M1+U1)));
  G4LorentzVector FourMomentum2(Momentum2,std::sqrt(Momentum2.mag2()+(M2+U2)*(M2+U2)));
 
  //JMQ 04/03/09 now we do Lorentz boosts (instead of Galileo boosts)
  FourMomentum1.boost(theNucleusMomentum.boostVector());
  FourMomentum2.boost(theNucleusMomentum.boostVector());
    
  //////////JMQ 04/03: Old version calculation is commented
  // There was vioation of energy momentum conservation
 
  //    G4double Pmax = std::sqrt( 2 * ( ( (M1+U1)*(M2+U2) ) /
  //                ( (M1+U1)+(M2+U2) ) ) * FragmentsKineticEnergy);
 
  //G4ParticleMomentum momentum1 = IsotropicVector( Pmax );
  //  G4ParticleMomentum momentum2( -momentum1 );
 
  // Perform a Galileo boost for fragments
  //    momentum1 += (theNucleusMomentum.boostVector() * (M1+U1));
  //    momentum2 += (theNucleusMomentum.boostVector() * (M2+U2));
 
 
  // Create 4-momentum for first fragment
  // Warning!! Energy conservation is broken
  //JMQ 04/03/09 ...NOT ANY MORE!! BUGS FIXED: Energy and momentum are NOW conserved 
  //    G4LorentzVector FourMomentum1( momentum1 , std::sqrt(momentum1.mag2() + (M1+U1)*(M1+U1)));
 
  // Create 4-momentum for second fragment
  // Warning!! Energy conservation is broken
  //JMQ 04/03/09 ...NOT ANY MORE!! BUGS FIXED: Energy and momentum are NOW conserved
  //    G4LorentzVector FourMomentum2( momentum2 , std::sqrt(momentum2.mag2() + (M2+U2)*(M2+U2)));
 
  //////////
 
  // Create Fragments
  G4Fragment * Fragment1 = new G4Fragment( A1, Z1, FourMomentum1);
  G4Fragment * Fragment2 = new G4Fragment( A2, Z2, FourMomentum2);
 
  // Create Fragment Vector
  G4FragmentVector * theResult = new G4FragmentVector;
 
  theResult->push_back(Fragment1);
  theResult->push_back(Fragment2);
 
#ifdef debug
  CheckConservation(theNucleus,theResult);
#endif
 
  return theResult;
}

Referenced by G4ParaFissionModel::ApplyYourself().

GetEmissionProbability()

G4double G4CompetitiveFission::GetEmissionProbability ( G4Fragment *  theNucleus )

virtual

Implements G4VEvaporationChannel.

Definition at line 70 of file G4CompetitiveFission.cc.

{
  G4int anA = fragment->GetA_asInt();
  G4int aZ  = fragment->GetZ_asInt();
  G4double ExEnergy = fragment->GetExcitationEnergy() - 
    G4PairingCorrection::GetInstance()->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*MeV;
    LevelDensityParameter = 0.0;
    FissionProbability = 0.0;
  }
  return FissionProbability;
}

GetFissionBarrier()

G4double G4CompetitiveFission::GetFissionBarrier ( void  ) const

inline

Definition at line 92 of file G4CompetitiveFission.hh.

{ return FissionBarrier; }

GetLevelDensityParameter()

G4double G4CompetitiveFission::GetLevelDensityParameter ( void  ) const

inline

Definition at line 94 of file G4CompetitiveFission.hh.

{ return LevelDensityParameter; }

GetMaximalKineticEnergy()

G4double G4CompetitiveFission::GetMaximalKineticEnergy ( void  ) const

inline

Definition at line 96 of file G4CompetitiveFission.hh.

{ return MaximalKineticEnergy; }

SetEmissionStrategy()

void G4CompetitiveFission::SetEmissionStrategy ( G4VEmissionProbability *  aFissionProb )

inline

Definition at line 76 of file G4CompetitiveFission.hh.

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

SetFissionBarrier()

void G4CompetitiveFission::SetFissionBarrier ( G4VFissionBarrier *  aBarrier )

inline

Definition at line 69 of file G4CompetitiveFission.hh.

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

SetLevelDensityParameter()

void G4CompetitiveFission::SetLevelDensityParameter ( G4VLevelDensityParameter *  aLevelDensity )

inline

Definition at line 84 of file G4CompetitiveFission.hh.

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

---

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

• G4CompetitiveFission.hh
• G4CompetitiveFission.cc