G4CompetitiveFission Class Reference

#include <G4CompetitiveFission.hh>

Inheritance diagram for G4CompetitiveFission:

G4VEvaporationChannel

Public Member Functions

 G4CompetitiveFission ()
virtual ~G4CompetitiveFission ()
virtual G4FragmentVectorBreakUp (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

Detailed Description

Definition at line 50 of file G4CompetitiveFission.hh.


Constructor & Destructor Documentation

G4CompetitiveFission::G4CompetitiveFission (  ) 

Definition at line 44 of file G4CompetitiveFission.cc.

00044                                            : G4VEvaporationChannel("fission")
00045 {
00046     theFissionBarrierPtr = new G4FissionBarrier;
00047     MyOwnFissionBarrier = true;
00048 
00049     theFissionProbabilityPtr = new G4FissionProbability;
00050     MyOwnFissionProbability = true;
00051   
00052     theLevelDensityPtr = new G4FissionLevelDensityParameter;
00053     MyOwnLevelDensity = true;
00054 
00055     MaximalKineticEnergy = -1000.0*MeV;
00056     FissionBarrier = 0.0;
00057     FissionProbability = 0.0;
00058     LevelDensityParameter = 0.0;
00059 }

G4CompetitiveFission::~G4CompetitiveFission (  )  [virtual]

Definition at line 61 of file G4CompetitiveFission.cc.

00062 {
00063     if (MyOwnFissionBarrier) delete theFissionBarrierPtr;
00064 
00065     if (MyOwnFissionProbability) delete theFissionProbabilityPtr;
00066 
00067     if (MyOwnLevelDensity) delete theLevelDensityPtr;
00068 }


Member Function Documentation

G4FragmentVector * G4CompetitiveFission::BreakUp ( const G4Fragment theNucleus  )  [virtual]

Implements G4VEvaporationChannel.

Definition at line 96 of file G4CompetitiveFission.cc.

References G4Fragment::GetA_asInt(), G4Fragment::GetExcitationEnergy(), G4PairingCorrection::GetFissionPairingCorrection(), G4Fragment::GetGroundStateMass(), G4PairingCorrection::GetInstance(), G4IonTable::GetIonMass(), G4ParticleTable::GetIonTable(), G4Fragment::GetMomentum(), G4ParticleTable::GetParticleTable(), and G4Fragment::GetZ_asInt().

Referenced by G4ParaFissionModel::ApplyYourself().

00097 {
00098   // Nucleus data
00099   // Atomic number of nucleus
00100   G4int A = theNucleus.GetA_asInt();
00101   // Charge of nucleus
00102   G4int Z = theNucleus.GetZ_asInt();
00103   //   Excitation energy (in MeV)
00104   G4double U = theNucleus.GetExcitationEnergy() - 
00105     G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
00106   // Check that U > 0
00107   if (U <= 0.0) {
00108     G4FragmentVector * theResult = new  G4FragmentVector;
00109     theResult->push_back(new G4Fragment(theNucleus));
00110     return theResult;
00111   }
00112 
00113   // Atomic Mass of Nucleus (in MeV)
00114   G4double M = theNucleus.GetGroundStateMass();
00115 
00116   // Nucleus Momentum
00117   G4LorentzVector theNucleusMomentum = theNucleus.GetMomentum();
00118 
00119   // Calculate fission parameters
00120   G4FissionParameters theParameters(A,Z,U,FissionBarrier);
00121   
00122   // First fragment
00123   G4int A1 = 0;
00124   G4int Z1 = 0;
00125   G4double M1 = 0.0;
00126 
00127   // Second fragment
00128   G4int A2 = 0;
00129   G4int Z2 = 0;
00130   G4double M2 = 0.0;
00131 
00132   G4double FragmentsExcitationEnergy = 0.0;
00133   G4double FragmentsKineticEnergy = 0.0;
00134 
00135   //JMQ 04/03/09 It will be used latter to fix the bug in energy conservation
00136   G4double FissionPairingEnergy=
00137     G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
00138 
00139   G4int Trials = 0;
00140   do {
00141 
00142     // First fragment 
00143     A1 = FissionAtomicNumber(A,theParameters);
00144     Z1 = FissionCharge(A,Z,A1);
00145     M1 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z1,A1);
00146 
00147     // Second Fragment
00148     A2 = A - A1;
00149     Z2 = Z - Z1;
00150     if (A2 < 1 || Z2 < 0) {
00151       throw G4HadronicException(__FILE__, __LINE__, 
00152         "G4CompetitiveFission::BreakUp: Can't define second fragment! ");
00153     }
00154     M2 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z2,A2);
00155 
00156     // Check that fragment masses are less or equal than total energy
00157     if (M1 + M2 > theNucleusMomentum.e()) {
00158       throw G4HadronicException(__FILE__, __LINE__, 
00159         "G4CompetitiveFission::BreakUp: Fragments Mass > Total Energy");
00160     }
00161     // Maximal Kinetic Energy (available energy for fragments)
00162     G4double Tmax = M + U - M1 - M2;
00163 
00164     FragmentsKineticEnergy = FissionKineticEnergy( A , Z,
00165                                                    A1, Z1,
00166                                                    A2, Z2,
00167                                                    U , Tmax,
00168                                                    theParameters);
00169     
00170     // Excitation Energy
00171     //  FragmentsExcitationEnergy = Tmax - FragmentsKineticEnergy;
00172     // JMQ 04/03/09 BUG FIXED: in order to fulfill energy conservation the
00173     // fragments carry the fission pairing energy in form of 
00174     //excitation energy
00175 
00176     FragmentsExcitationEnergy = 
00177       Tmax - FragmentsKineticEnergy+FissionPairingEnergy;
00178 
00179   } while (FragmentsExcitationEnergy < 0.0 && Trials++ < 100);
00180     
00181   if (FragmentsExcitationEnergy <= 0.0) { 
00182     throw G4HadronicException(__FILE__, __LINE__, 
00183       "G4CompetitiveFission::BreakItUp: Excitation energy for fragments < 0.0!");
00184   }
00185 
00186   // while (FragmentsExcitationEnergy < 0 && Trials < 100);
00187   
00188   // Fragment 1
00189   G4double U1 = FragmentsExcitationEnergy * A1/static_cast<G4double>(A);
00190     // Fragment 2
00191   G4double U2 = FragmentsExcitationEnergy * A2/static_cast<G4double>(A);
00192 
00193   //JMQ  04/03/09 Full relativistic calculation is performed
00194   //
00195   G4double Fragment1KineticEnergy=
00196     (FragmentsKineticEnergy*(FragmentsKineticEnergy+2*(M2+U2)))
00197     /(2*(M1+U1+M2+U2+FragmentsKineticEnergy));
00198   G4ParticleMomentum Momentum1(IsotropicVector(std::sqrt(Fragment1KineticEnergy*(Fragment1KineticEnergy+2*(M1+U1)))));
00199   G4ParticleMomentum Momentum2(-Momentum1);
00200   G4LorentzVector FourMomentum1(Momentum1,std::sqrt(Momentum1.mag2()+(M1+U1)*(M1+U1)));
00201   G4LorentzVector FourMomentum2(Momentum2,std::sqrt(Momentum2.mag2()+(M2+U2)*(M2+U2)));
00202 
00203   //JMQ 04/03/09 now we do Lorentz boosts (instead of Galileo boosts)
00204   FourMomentum1.boost(theNucleusMomentum.boostVector());
00205   FourMomentum2.boost(theNucleusMomentum.boostVector());
00206     
00208   // There was vioation of energy momentum conservation
00209 
00210   //    G4double Pmax = std::sqrt( 2 * ( ( (M1+U1)*(M2+U2) ) /
00211   //                            ( (M1+U1)+(M2+U2) ) ) * FragmentsKineticEnergy);
00212 
00213   //G4ParticleMomentum momentum1 = IsotropicVector( Pmax );
00214   //  G4ParticleMomentum momentum2( -momentum1 );
00215 
00216   // Perform a Galileo boost for fragments
00217   //    momentum1 += (theNucleusMomentum.boostVector() * (M1+U1));
00218   //    momentum2 += (theNucleusMomentum.boostVector() * (M2+U2));
00219 
00220 
00221   // Create 4-momentum for first fragment
00222   // Warning!! Energy conservation is broken
00223   //JMQ 04/03/09 ...NOT ANY MORE!! BUGS FIXED: Energy and momentum are NOW conserved 
00224   //    G4LorentzVector FourMomentum1( momentum1 , std::sqrt(momentum1.mag2() + (M1+U1)*(M1+U1)));
00225 
00226   // Create 4-momentum for second fragment
00227   // Warning!! Energy conservation is broken
00228   //JMQ 04/03/09 ...NOT ANY MORE!! BUGS FIXED: Energy and momentum are NOW conserved
00229   //    G4LorentzVector FourMomentum2( momentum2 , std::sqrt(momentum2.mag2() + (M2+U2)*(M2+U2)));
00230 
00232 
00233   // Create Fragments
00234   G4Fragment * Fragment1 = new G4Fragment( A1, Z1, FourMomentum1);
00235   G4Fragment * Fragment2 = new G4Fragment( A2, Z2, FourMomentum2);
00236 
00237   // Create Fragment Vector
00238   G4FragmentVector * theResult = new G4FragmentVector;
00239 
00240   theResult->push_back(Fragment1);
00241   theResult->push_back(Fragment2);
00242 
00243 #ifdef debug
00244   CheckConservation(theNucleus,theResult);
00245 #endif
00246 
00247   return theResult;
00248 }

G4double G4CompetitiveFission::GetEmissionProbability ( G4Fragment theNucleus  )  [virtual]

Implements G4VEvaporationChannel.

Definition at line 70 of file G4CompetitiveFission.cc.

References G4VEmissionProbability::EmissionProbability(), G4VFissionBarrier::FissionBarrier(), G4Fragment::GetA_asInt(), G4Fragment::GetExcitationEnergy(), G4PairingCorrection::GetFissionPairingCorrection(), G4PairingCorrection::GetInstance(), G4Fragment::GetZ_asInt(), and G4VLevelDensityParameter::LevelDensityParameter().

00071 {
00072   G4int anA = fragment->GetA_asInt();
00073   G4int aZ  = fragment->GetZ_asInt();
00074   G4double ExEnergy = fragment->GetExcitationEnergy() - 
00075     G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(anA,aZ);
00076   
00077 
00078   // Saddle point excitation energy ---> A = 65
00079   // Fission is excluded for A < 65
00080   if (anA >= 65 && ExEnergy > 0.0) {
00081     FissionBarrier = theFissionBarrierPtr->FissionBarrier(anA,aZ,ExEnergy);
00082     MaximalKineticEnergy = ExEnergy - FissionBarrier;
00083     LevelDensityParameter = 
00084       theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
00085     FissionProbability = 
00086       theFissionProbabilityPtr->EmissionProbability(*fragment,MaximalKineticEnergy);
00087     }
00088   else {
00089     MaximalKineticEnergy = -1000.0*MeV;
00090     LevelDensityParameter = 0.0;
00091     FissionProbability = 0.0;
00092   }
00093   return FissionProbability;
00094 }

G4double G4CompetitiveFission::GetFissionBarrier ( void   )  const [inline]

Definition at line 92 of file G4CompetitiveFission.hh.

00092 { return FissionBarrier; }

G4double G4CompetitiveFission::GetLevelDensityParameter ( void   )  const [inline]

Definition at line 94 of file G4CompetitiveFission.hh.

00094 { return LevelDensityParameter; }

G4double G4CompetitiveFission::GetMaximalKineticEnergy ( void   )  const [inline]

Definition at line 96 of file G4CompetitiveFission.hh.

00096 { return MaximalKineticEnergy; }

void G4CompetitiveFission::SetEmissionStrategy ( G4VEmissionProbability aFissionProb  )  [inline]

Definition at line 76 of file G4CompetitiveFission.hh.

00077   {
00078     if (MyOwnFissionProbability) delete theFissionProbabilityPtr;
00079     theFissionProbabilityPtr = aFissionProb;
00080     MyOwnFissionProbability = false;
00081   }

void G4CompetitiveFission::SetFissionBarrier ( G4VFissionBarrier aBarrier  )  [inline]

Definition at line 69 of file G4CompetitiveFission.hh.

00070   {
00071     if (MyOwnFissionBarrier) delete theFissionBarrierPtr;
00072     theFissionBarrierPtr = aBarrier;
00073     MyOwnFissionBarrier = false;
00074   }

void G4CompetitiveFission::SetLevelDensityParameter ( G4VLevelDensityParameter aLevelDensity  )  [inline]

Definition at line 84 of file G4CompetitiveFission.hh.

00085   { 
00086     if (MyOwnLevelDensity) delete theLevelDensityPtr;
00087     theLevelDensityPtr = aLevelDensity;
00088     MyOwnLevelDensity = false;
00089   }


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:51:41 2013 for Geant4 by  doxygen 1.4.7