lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 4.1.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 16:39:52 +02:00
parent 921d3b1cda
commit 330b82b769
4524 changed files with 178689 additions and 43575 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/generator/pre_equilibrium/include/G4LowEIonFragmentation.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4LowEIonFragmentation.hh,v 1.6 2001/10/06 08:17:01 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
// by H.P. Wellisch
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundAlpha.hh
+56 -56
View File
@@ -21,10 +21,10 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundAlpha.hh,v 1.8 2001/08/01 17:08:27 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundAlpha.hh,v 1.10 2002/06/06 16:59:32 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
// by V. Lara
#ifndef G4PreCompoundAlpha_h
#define G4PreCompoundAlpha_h 1
@@ -35,11 +35,12 @@
#include "G4AlphaCoulombBarrier.hh"
class G4PreCompoundAlpha : public G4VPreCompoundIon
{
public:
// default constructor
G4PreCompoundAlpha():G4VPreCompoundIon(4,2,&theAlphaCoulombBarrier,"alpha") {}
G4PreCompoundAlpha():G4VPreCompoundIon(4,2,&theAlphaCoulombBarrier,"Alpha") {}
// copy constructor
G4PreCompoundAlpha(const G4PreCompoundAlpha &right): G4VPreCompoundIon(right) {}
@@ -51,73 +52,72 @@ public:
const G4PreCompoundAlpha & operator=(const G4PreCompoundAlpha &right) {
if (&right != this) this->G4VPreCompoundIon::operator=(right);
return *this;
}
};
G4bool operator==(const G4PreCompoundAlpha &right) const
{ return G4VPreCompoundIon::operator==(right);}
G4bool operator!=(const G4PreCompoundAlpha &right) const
{ return G4VPreCompoundIon::operator!=(right);}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4Alpha::AlphaDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
return theReactionProduct;
}
public:
void CalcExcitonLevelDensityRatios(const G4double Excitons,
const G4double Particles)
{
// Level density ratios are calculated according to the formula
// (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
// where P is number of particles
// N is number of excitons
// Af atomic number of emitting fragment
// the next is a simplification for alphas (Af = 4)
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct =
new G4ReactionProduct(G4Alpha::AlphaDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
#ifdef pctest
theReactionProduct->SetCreatorModel("G4PrecompoundModel");
#endif
return theReactionProduct;
}
SetExcitonLevelDensityRatio(((Particles*(Excitons-1.0))*
((Particles-1.0)*(Excitons-2.0)/2.0)*
((Particles-2.0)*(Excitons-3.0)/3.0)*
((Particles-3.0)*(Excitons-4.0)/4.0))/6.0);
}
private:
virtual G4double GetAlpha()
{
G4double C = 0.0;
G4double aZ = GetZ() + GetRestZ();
if (aZ <= 30) {
C = 0.10;
} else if (aZ <= 50) {
C = 0.1 + -((aZ-50.)/20.)*0.02;
} else if (aZ < 70) {
C = 0.08 + -((aZ-70.)/20.)*0.02;
} else {
C = 0.06;
}
return 1.0+C;
}
virtual G4double GetBeta()
{
return -GetCoulombBarrier();
}
virtual G4double FactorialFactor(const G4double N, const G4double P)
{
return
(N-4.0)*(P-3.0)*(
(((N-3.0)*(P-2.0))/2.0) *(
(((N-2.0)*(P-1.0))/3.0) *(
(((N-1.0)*P)/2.0)
)
)
);
}
void CalcCondensationProbability(const G4double A)
// This method computes condensation probability to create a fragment
// consisting from N nucleons inside a nucleus with A nucleons
// This value comes from the formula N^3 (N/A)^(N-1) with N = 4 (alpha)
{
SetCondensationProbability(4096.0/(A*A*A));
}
virtual G4double CoalescenceFactor(const G4double A)
{
return 4096.0/(A*A*A);
}
private:
virtual G4double GetCCoef(const G4double aZ) const;
G4AlphaCoulombBarrier theAlphaCoulombBarrier;
G4AlphaCoulombBarrier theAlphaCoulombBarrier;
};
#endif
inline G4double G4PreCompoundAlpha::GetCCoef(const G4double aZ) const
{
G4double C = 0.0;
if (aZ <= 30) {
C = 0.10;
} else if (aZ <= 50) {
C = 0.1 + -((aZ-50.)/20.)*0.02;
} else if (aZ < 70) {
C = 0.08 + -((aZ-70.)/20.)*0.02;
} else {
C = 0.06;
}
return C;
}
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundDeuteron.hh
+49 -54
View File
@@ -21,10 +21,10 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundDeuteron.hh,v 1.8 2001/08/01 17:08:28 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundDeuteron.hh,v 1.10 2002/06/06 17:02:25 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
// by V. Lara
#ifndef G4PreCompoundDeuteron_h
#define G4PreCompoundDeuteron_h 1
@@ -35,15 +35,16 @@
#include "G4DeuteronCoulombBarrier.hh"
class G4PreCompoundDeuteron : public G4VPreCompoundIon
{
public:
// default constructor
G4PreCompoundDeuteron():G4VPreCompoundIon(2,1,&theDeuteronCoulombBarrier,"Deuteron") {};
G4PreCompoundDeuteron():G4VPreCompoundIon(2,1,&theDeuteronCoulombBarrier,"Deuteron") {}
// copy constructor
G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right):
G4VPreCompoundIon(right) {}
G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right): G4VPreCompoundIon(right) {}
// destructor
~G4PreCompoundDeuteron() {}
@@ -55,64 +56,58 @@ public:
G4bool operator==(const G4PreCompoundDeuteron &right) const
{ return G4VPreCompoundIon::operator==(right);}
G4bool operator!=(const G4PreCompoundDeuteron &right) const
{ return G4VPreCompoundIon::operator!=(right);}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4Deuteron::DeuteronDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
return theReactionProduct;
}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct =
new G4ReactionProduct(G4Deuteron::DeuteronDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
#ifdef pctest
theReactionProduct->SetCreatorModel("G4PrecompoundModel");
#endif
return theReactionProduct;
}
private:
virtual G4double GetAlpha()
{
G4double C = 0.0;
G4double aZ = GetZ() + GetRestZ();
if (aZ >= 70) {
C = 0.10;
} else {
C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
}
return 1.0 + C/2.0;
}
virtual G4double GetBeta()
{
return -GetCoulombBarrier();
}
public:
void CalcExcitonLevelDensityRatios(const G4double Excitons,
const G4double Particles)
{
// Level density ratios are calculated according to the formula
// (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
// where P is number of particles
// N is number of excitons
// Af atomic number of emitting fragment
// the next is a simplification for deuterons (Af = 2)
SetExcitonLevelDensityRatio(Particles*(Excitons-1.0)*
(Particles-1.0)*(Excitons-2.0)/2.0);
}
void CalcCondensationProbability(const G4double A)
// This method computes condensation probability to create a fragment
// consisting from N nucleons inside a nucleus with A nucleons
// This value comes from the formula N^3 (N/A)^(N-1) with N = 2 (deuteron)
{
SetCondensationProbability(16.0/A);
}
virtual G4double FactorialFactor(const G4double N, const G4double P)
{
return
(N-1.0)*(N-2.0)*(P-1.0)*P/2.0;
}
virtual G4double CoalescenceFactor(const G4double A)
{
return 16.0/A;
}
private:
virtual G4double GetCCoef(const G4double aZ) const;
G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
};
#endif
inline G4double G4PreCompoundDeuteron::GetCCoef(const G4double aZ) const
{
G4double C = 0.0;
if (aZ >= 70) {
C = 0.10;
} else {
C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
}
return C/2.0;
}
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundEmission.hh
+1 -1
View File
@@ -21,7 +21,7 @@
// ********************************************************************
//
// $Id: G4PreCompoundEmission.hh,v 1.8 2001/12/13 12:04:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
// Hadronic Process: Nuclear Preequilibrium
// by V. Lara
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundFragmentVector.hh
+31 -15
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundFragmentVector.hh,v 1.4 2001/08/01 17:08:28 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundFragmentVector.hh,v 1.5 2002/06/06 17:03:57 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// Hadronic Process: Nuclear Preequilibrium
// by V. Lara
@@ -33,39 +33,55 @@
#include "G4VPreCompoundFragment.hh"
class G4PreCompoundFragmentVector
{
typedef G4std::vector<G4VPreCompoundFragment*> pcfvector;
public:
G4PreCompoundFragmentVector();
~G4PreCompoundFragmentVector();
private:
G4PreCompoundFragmentVector(const G4PreCompoundFragmentVector &right);
const G4PreCompoundFragmentVector& operator=(const G4PreCompoundFragmentVector &right);
const G4PreCompoundFragmentVector&
operator=(const G4PreCompoundFragmentVector &right);
G4bool operator==(const G4PreCompoundFragmentVector &right) const;
G4bool operator!=(const G4PreCompoundFragmentVector &right) const;
public:
void Initialize(const G4Fragment & aFragment)
{
TotalEmissionProbability = 0.0;
// for (G4int i=0; i < theChannels.entries(); i++) theChannels(i)->Init(aFragment);
for (G4std::vector<G4VPreCompoundFragment*>::iterator i=theChannels.begin();
i != theChannels.end(); i++) (*i)->Init(aFragment);
return;
}
inline void Initialize(const G4Fragment & aFragment);
G4double CalculateProbabilities(const G4Fragment & aFragment);
G4VPreCompoundFragment * ChooseFragment(void);
private:
G4std::vector<G4VPreCompoundFragment*> theChannels;
pcfvector theChannels;
G4double TotalEmissionProbability;
struct DeleteFragment
{
template<typename T>
void operator()(const T* ptr) const
{
delete ptr;
}
};
};
#include "G4PreCompoundFragmentVector.icc"
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundFragmentVector.icc
+39
View File
@@ -0,0 +1,39 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4PreCompoundFragmentVector.icc,v 1.1 2002/06/06 17:04:49 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// Hadronic Process: Nuclear Preequilibrium
// by V. Lara
inline void
G4PreCompoundFragmentVector::
Initialize(const G4Fragment & aFragment)
{
TotalEmissionProbability = 0.0;
for (pcfvector::iterator i=theChannels.begin();
i != theChannels.end(); i++) (*i)->Initialize(aFragment);
return;
}
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundHe3.hh
+53 -59
View File
@@ -21,11 +21,10 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundHe3.hh,v 1.8 2001/08/01 17:08:28 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundHe3.hh,v 1.10 2002/06/06 17:06:24 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
// by V. Lara
#ifndef G4PreCompoundHe3_h
#define G4PreCompoundHe3_h 1
@@ -36,6 +35,7 @@
#include "G4He3CoulombBarrier.hh"
class G4PreCompoundHe3 : public G4VPreCompoundIon
{
public:
@@ -45,7 +45,7 @@ public:
// copy constructor
G4PreCompoundHe3(const G4PreCompoundHe3 &right): G4VPreCompoundIon(right) {}
// DEstructor
// destructor
~G4PreCompoundHe3() {}
// operators
@@ -56,72 +56,66 @@ public:
G4bool operator==(const G4PreCompoundHe3 &right) const
{ return G4VPreCompoundIon::operator==(right);}
G4bool operator!=(const G4PreCompoundHe3 &right) const
{ return G4VPreCompoundIon::operator!=(right);}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4He3::He3Definition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
return theReactionProduct;
}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct =
new G4ReactionProduct(G4He3::He3Definition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
#ifdef pctest
theReactionProduct->SetCreatorModel("G4PrecompoundModel");
#endif
return theReactionProduct;
}
private:
virtual G4double GetAlpha()
{
G4double C = 0.0;
G4double aZ = GetZ() + GetRestZ();
if (aZ <= 30) {
C = 0.10;
} else if (aZ <= 50) {
C = 0.1 + -((aZ-50.)/20.)*0.02;
} else if (aZ < 70) {
C = 0.08 + -((aZ-70.)/20.)*0.02;
} else {
C = 0.06;
}
return 1.0 + C*(4.0/3.0);
}
virtual G4double GetBeta()
{
return -GetCoulombBarrier();
}
virtual G4double FactorialFactor(const G4double N, const G4double P)
{
return
(N-3.0)*(P-2.0)*(
(((N-2.0)*(P-1.0))/2.0) *(
(((N-1.0)*P)/3.0)
)
);
}
public:
void CalcExcitonLevelDensityRatios(const G4double Excitons,
const G4double Particles)
{
// Level density ratios are calculated according to the formula
// (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
// where P is number of particles
// N is number of excitons
// Af atomic number of emitting fragment
// the next is a simplification for He3 (Af = 3)
SetExcitonLevelDensityRatio(((Particles*(Excitons-1.0))*
((Particles-1.0)*(Excitons-2.0)/2.0)*
((Particles-2.0)*(Excitons-3.0)/3.0))/2.0);
}
void CalcCondensationProbability(const G4double A)
// This method computes condensation probability to create a fragment
// consisting from N nucleons inside a nucleus with A nucleons
// This value comes from the formula N^3 (N/A)^(N-1) with N = 3 (He3)
{
SetCondensationProbability(243.0/(A*A));
}
virtual G4double CoalescenceFactor(const G4double A)
{
return 243.0/(A*A);
}
private:
virtual G4double GetCCoef(const G4double aZ) const;
G4He3CoulombBarrier theHe3CoulombBarrier;
G4He3CoulombBarrier theHe3CoulombBarrier;
};
#endif
inline G4double G4PreCompoundHe3::GetCCoef(const G4double aZ) const
{
G4double C = 0.0;
if (aZ <= 30) {
C = 0.10;
} else if (aZ <= 50) {
C = 0.1 + -((aZ-50.)/20.)*0.02;
} else if (aZ < 70) {
C = 0.08 + -((aZ-70.)/20.)*0.02;
} else {
C = 0.06;
}
return C*(4.0/3.0);
}
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundModel.hh
+45 -27
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundModel.hh,v 1.11 2001/08/01 17:08:28 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundModel.hh,v 1.15 2002/06/06 17:09:10 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
@@ -42,8 +42,6 @@
#include "G4LorentzVector.hh"
#include "G4NucleiProperties.hh"
#include "G4Proton.hh"
#include "G4VPreCompoundFragment.hh"
#include "G4PreCompoundParameters.hh"
#include "G4ExcitationHandler.hh"
#include "G4Fragment.hh"
@@ -52,46 +50,66 @@
//#define debug
//#define verbose
//#define pctest
class G4PreCompoundModel : public G4VPreCompoundModel
{
public:
G4PreCompoundModel(G4ExcitationHandler * const value) :
G4VPreCompoundModel(value) {};
G4PreCompoundModel(G4ExcitationHandler * const value) :
G4VPreCompoundModel(value) {};
~G4PreCompoundModel() {};
~G4PreCompoundModel() {};
private:
G4PreCompoundModel() {};
G4PreCompoundModel(const G4PreCompoundModel &right) {};
const G4PreCompoundModel& operator=(const G4PreCompoundModel &right);
G4bool operator==(const G4PreCompoundModel &right) const;
G4bool operator!=(const G4PreCompoundModel &right) const;
G4PreCompoundModel() {};
G4PreCompoundModel(const G4PreCompoundModel &right) {};
const G4PreCompoundModel& operator=(const G4PreCompoundModel &right);
G4bool operator==(const G4PreCompoundModel &right) const;
G4bool operator!=(const G4PreCompoundModel &right) const;
public:
G4VParticleChange * ApplyYourself(const G4Track & thePrimary, G4Nucleus & theNucleus);
G4ReactionProductVector* DeExcite(const G4Fragment& aFragment) const;
G4VParticleChange * ApplyYourself(const G4Track & thePrimary, G4Nucleus & theNucleus);
G4ReactionProductVector* DeExcite(const G4Fragment& aFragment) const;
#ifdef pctest
static G4Fragment GetInitialFragmentForTest()
{ return G4PreCompoundModel::theInitialFragmentForTest; }
static G4std::vector<G4String*> * GetCreatorModels()
{ return &G4PreCompoundModel::theCreatorModels; }
#endif
private:
void PerformEquilibriumEmission(const G4Fragment & aFragment,
G4ReactionProductVector * theResult) const;
void PerformEquilibriumEmission(const G4Fragment & aFragment,
G4ReactionProductVector * theResult) const;
#ifdef debug
void CheckConservation(const G4Fragment & theInitialState,
const G4Fragment & aFragment,
G4ReactionProductVector * Result) const;
void CheckConservation(const G4Fragment & theInitialState,
const G4Fragment & aFragment,
G4ReactionProductVector * Result) const;
#endif
G4ParticleChange theResult;
#ifdef pctest
static G4Fragment theInitialFragmentForTest;
static G4std::vector<G4String*> theCreatorModels;
#endif
G4ParticleChange theResult;
};
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundNeutron.hh
+33 -16
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundNeutron.hh,v 1.7 2001/08/01 17:08:29 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundNeutron.hh,v 1.10 2002/06/06 17:09:33 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
@@ -64,22 +64,34 @@ public:
{ return G4VPreCompoundNucleon::operator!=(right);}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4Neutron::NeutronDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
return theReactionProduct;
}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct =
new G4ReactionProduct(G4Neutron::NeutronDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
#ifdef pctest
theReactionProduct->SetCreatorModel("G4PrecompoundModel");
#endif
return theReactionProduct;
}
private:
virtual G4double GetAlpha()
{
return 0.76+2.2/pow(GetRestA(),1.0/3.0);
}
virtual G4double GetBeta()
{
return (2.12/pow(GetRestA(),2.0/3.0)-0.05)*MeV/GetAlpha();
}
public:
G4double ProbabilityDistributionFunction(const G4double & eKin, const G4Fragment & aFragment);
// Gives the kinetic energy for fragments in pre-equilibrium decay
G4double GetKineticEnergy(const G4Fragment & aFragment);
virtual G4bool IsItPossible(const G4Fragment& aFragment)
{
return ((aFragment.GetNumberOfParticles()-aFragment.GetNumberOfCharged()) >= 1);
}
private:
@@ -89,3 +101,8 @@ private:
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundParameters.hh
+27 -26
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundParameters.hh,v 1.7 2001/08/01 17:08:29 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundParameters.hh,v 1.8 2002/06/06 17:10:07 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
@@ -35,44 +35,45 @@
class G4PreCompoundParameters
{
private:
static G4PreCompoundParameters thePreCompoundParameters;
static G4PreCompoundParameters thePreCompoundParameters;
// default constructor
G4PreCompoundParameters() : theLevelDensity(0.125/MeV),
r0(1.5*fermi),Transitionsr0(0.6*fermi),FermiEnergy(35.0*MeV) {}
// default constructor
G4PreCompoundParameters() : theLevelDensity(0.125/MeV),
r0(1.5*fermi),Transitions_r0(0.6*fermi),FermiEnergy(35.0*MeV)
{}
public:
~G4PreCompoundParameters() {};
~G4PreCompoundParameters() {};
static G4PreCompoundParameters * GetAddress();
static G4PreCompoundParameters * GetAddress();
G4double GetLevelDensity()
{ return theLevelDensity; }
G4double GetLevelDensity()
{ return theLevelDensity; }
G4double Getr0()
{ return r0; }
G4double Getr0()
{ return r0; }
G4double GetTransitionsr0()
{ return Transitionsr0; }
G4double GetTransitionsr0()
{ return Transitions_r0; }
G4double GetFermiEnergy()
{ return FermiEnergy; }
G4double GetFermiEnergy()
{ return FermiEnergy; }
private:
// Level density parameter
const G4double theLevelDensity;
// Level density parameter
const G4double theLevelDensity;
// Nuclear radius r0
const G4double r0;
// Nuclear radius r0
const G4double r0;
// Nuclear radius r0 for transitions
const G4double Transitionsr0;
// Nuclear radius r0 for transitions
const G4double Transitions_r0;
// Fermi energy level
const G4double FermiEnergy;
// Fermi energy level
const G4double FermiEnergy;
};
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundProton.hh
+38 -16
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundProton.hh,v 1.8 2001/08/01 17:08:29 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundProton.hh,v 1.11 2002/06/06 17:10:38 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
@@ -64,22 +64,44 @@ public:
{ return G4VPreCompoundNucleon::operator!=(right);}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4Proton::ProtonDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
return theReactionProduct;
}
G4double ProbabilityDistributionFunction(const G4double & eKin, const G4Fragment & aFragment);
// Gives the kinetic energy for fragments in pre-equilibrium decay
G4double GetKineticEnergy(const G4Fragment & aFragment);
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct =
new G4ReactionProduct(G4Proton::ProtonDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
#ifdef pctest
theReactionProduct->SetCreatorModel("G4PrecompoundModel");
#endif
return theReactionProduct;
}
private:
virtual G4double GetAlpha()
{
G4double aZ = G4double(GetRestZ());
G4double C = 0.0;
if (aZ >= 70) {
C = 0.10;
} else {
C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
}
return 1.0 + C;
}
virtual G4double GetBeta()
{
return -GetCoulombBarrier();
}
virtual G4bool IsItPossible(const G4Fragment& aFragment)
{
return (aFragment.GetNumberOfCharged() >= 1);
}
private:
G4ProtonCoulombBarrier theProtonCoulombBarrier;
};
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundTransitions.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4PreCompoundTransitions.hh,v 1.7 2001/08/01 17:08:29 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundTriton.hh
+47 -56
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4PreCompoundTriton.hh,v 1.8 2001/08/01 17:08:29 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PreCompoundTriton.hh,v 1.10 2002/06/06 17:11:43 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
@@ -35,8 +35,6 @@
#include "G4TritonCoulombBarrier.hh"
#include "G4ProtonCoulombBarrier.hh"
class G4PreCompoundTriton : public G4VPreCompoundIon
{
@@ -46,7 +44,7 @@ public:
// copy constructor
G4PreCompoundTriton(const G4PreCompoundTriton &right): G4VPreCompoundIon(right) {}
// destructor
~G4PreCompoundTriton() {}
@@ -63,65 +61,58 @@ public:
G4bool operator!=(const G4PreCompoundTriton &right) const
{ return G4VPreCompoundIon::operator!=(right);}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4Triton::TritonDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
return theReactionProduct;
}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct =
new G4ReactionProduct(G4Triton::TritonDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
#ifdef pctest
theReactionProduct->SetCreatorModel("G4PrecompoundModel");
#endif
return theReactionProduct;
}
private:
virtual G4double GetAlpha()
{
G4double C = 0.0;
G4double aZ = GetZ() + GetRestZ();
if (aZ >= 70) {
C = 0.10;
} else {
C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
}
return 1.0 + C/3.0;
}
virtual G4double GetBeta()
{
return -GetCoulombBarrier();
}
virtual G4double FactorialFactor(const G4double N, const G4double P)
{
return
(N-3.0)*(P-2.0)*(
(((N-2.0)*(P-1.0))/2.0) *(
(((N-1.0)*P)/3.0)
)
);
}
public:
void CalcExcitonLevelDensityRatios(const G4double Excitons,
const G4double Particles)
{
// Level density ratios are calculated according to the formula
// (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af! (Af-1)!)
// where P is number of particles
// N is number of excitons
// Af atomic number of emitting fragment
// the next is a simplification for tritons (Af = 3)
SetExcitonLevelDensityRatio(((Particles*(Excitons-1.0))*
((Particles-1.0)*(Excitons-2.0)/2.0)*
((Particles-2.0)*(Excitons-3.0)/3.0)/2.0));
}
void CalcCondensationProbability(const G4double A)
// This method computes condensation probability to create a fragment
// consisting from N nucleons inside a nucleus with A nucleons
// This value comes from the formula N^3 (N/A)^(N-1) with N = 3 (triton)
{
SetCondensationProbability(243.0/(A*A));
}
virtual G4double CoalescenceFactor(const G4double A)
{
return 243.0/(A*A);
}
private:
virtual G4double GetCCoef(const G4double aZ) const;
G4TritonCoulombBarrier theTritonCoulombBarrier;
G4TritonCoulombBarrier theTritonCoulombBarrier;
};
#endif
inline G4double G4PreCompoundTriton::GetCCoef(const G4double aZ) const
{
G4double C = 0.0;
if (aZ >= 70) {
C = 0.10;
} else {
C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
}
return C/3.0;
}
source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundFragment.hh
+83 -108
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4VPreCompoundFragment.hh,v 1.8 2001/08/01 17:08:29 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4VPreCompoundFragment.hh,v 1.11 2002/06/06 17:12:28 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
@@ -36,6 +36,8 @@
#include "G4Fragment.hh"
#include "G4VCoulombBarrier.hh"
//#define pctest
class G4ReactionProduct;
@@ -44,168 +46,141 @@ class G4VPreCompoundFragment
// ============================
// Constructors and destructor
// ============================
protected:
// default constructor
G4VPreCompoundFragment() {};
public:
// copy constructor
G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
// copy constructor
G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
// constructor
G4VPreCompoundFragment(const G4double anA, const G4double aZ,
G4VCoulombBarrier * aCoulombBarrier);
G4VPreCompoundFragment(const G4double anA, const G4double aZ,
G4VPreCompoundFragment(const G4double anA, const G4double aZ,
G4VCoulombBarrier * aCoulombBarrier,
const G4String & aName);
virtual ~G4VPreCompoundFragment();
// ==========
// operators
// ==========
const G4VPreCompoundFragment& operator=(const G4VPreCompoundFragment &right);
const G4VPreCompoundFragment&
operator= (const G4VPreCompoundFragment &right);
G4int operator==(const G4VPreCompoundFragment &right) const;
G4int operator!=(const G4VPreCompoundFragment &right) const;
friend G4std::ostream& operator<<(G4std::ostream&, const G4VPreCompoundFragment*);
friend G4std::ostream& operator<<(G4std::ostream&, const G4VPreCompoundFragment&);
friend G4std::ostream&
operator<<(G4std::ostream&, const G4VPreCompoundFragment*);
friend G4std::ostream&
operator<<(G4std::ostream&, const G4VPreCompoundFragment&);
// =====================
// Pure Virtual methods
// =====================
virtual void CalcExcitonLevelDensityRatios(const G4double Excitons, const G4double Particles) = 0;
virtual G4double GetKineticEnergy(const G4Fragment & aFragment) = 0;
// Calculates condensation probabilities to create clusters
// consisting of N nucleons inside a nucleus with A nucleons
virtual void CalcCondensationProbability(const G4double A) = 0;
virtual G4ReactionProduct * GetReactionProduct() const = 0;
protected:
virtual G4double ProbabilityDistributionFunction(const G4double & K, const G4Fragment & aFragment) = 0;
public:
// =====================
// Initialization method
// =====================
void Init(const G4Fragment & aFragment);
protected:
virtual G4double
ProbabilityDistributionFunction(const G4double K,
const G4Fragment & aFragment) = 0;
public:
// Initialization method
void Initialize(const G4Fragment & aFragment);
// ================================================
// Methods for calculating the emission probability
// ================================================
// Calculates the total (integrated over kinetic energy) emission
// probability of a fragment
G4double CalcEmissionProbability(const G4Fragment & aFragment);
G4double GetKineticEnergy(const G4Fragment & aFragment);
// See above (in virtual methods) the method ProbabilityDistributionFunction
private:
// This method performs integration for probability function over
// fragment kinetic energy
G4double IntegrateEmissionProbability(const G4double & Low, const G4double & Up,
G4double IntegrateEmissionProbability(const G4double & Low,
const G4double & Up,
const G4Fragment & aFragment);
// // This quantity takes account of the fact that proton and neutron degrees of
// // freedom are distinguishable
// G4double DistinguishablilityFactor(const G4Fragment & aFragment);
// ============================
// Data members access methods
// ============================
public:
const G4double GetA() const { return theA;}
const G4double GetZ() const { return theZ;}
inline const G4double GetA() const;
const G4double GetRestA() const { return theRestNucleusA;}
const G4double GetRestZ() const { return theRestNucleusZ;}
inline const G4double GetZ() const;
inline const G4double GetRestA() const;
inline const G4double GetRestZ() const;
inline const G4double GetCoulombBarrier() const;
inline const G4double GetBindingEnergy() const;
inline const G4double GetMaximalKineticEnergy() const;
inline const G4double GetEmissionProbability() const;
inline const G4double GetNuclearMass() const;
inline const G4double GetRestNuclearMass() const;
inline const G4double GetReducedMass() const;
inline const G4LorentzVector GetMomentum() const;
inline void SetMomentum(const G4LorentzVector & value);
inline void SetFragmentName(const G4String& aName);
inline const G4String GetName() const;
const G4double GetCoulombBarrier() const {return theCoulombBarrier;}
const G4double GetBindingEnergy() const { return theBindingEnergy;}
const G4double GetMaximalKineticEnergy() const { return theMaximalKineticEnergy;}
const G4double GetExcitonLevelDensityRatio() const { return theExcitonLevelDensityRatio;}
void SetExcitonLevelDensityRatio(const G4double value) { theExcitonLevelDensityRatio = value;}
void SetEmissionProbability(const G4double value) { theEmissionProbability = value;}
const G4double GetEmissionProbability() const { return theEmissionProbability;}
const G4double GetCondensationProbability() const { return theCondensationProbability;}
void SetCondensationProbability(const G4double value) { theCondensationProbability = value;}
const G4double GetNuclearMass() const {
return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theZ,theA);
}
const G4double GetRestNuclearMass() const {
return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theRestNucleusZ,theRestNucleusA);
}
const G4double GetReducedMass() const {
return GetRestNuclearMass()*GetNuclearMass()/(GetNuclearMass()+GetRestNuclearMass());
}
const G4LorentzVector GetMomentum() const { return theMomentum;}
void SetMomentum(const G4LorentzVector & value) { theMomentum = value;}
void SetFragmentName(const G4String& aName) { theFragmentName = aName; }
const G4String GetName() const { return theFragmentName; }
// =============
// Data members
// =============
private:
G4double theA;
G4double theZ;
G4double theRestNucleusA;
G4double theRestNucleusZ;
G4double theCoulombBarrier;
G4VCoulombBarrier * theCoulombBarrierPtr;
G4double theBindingEnergy;
G4double theMaximalKineticEnergy;
G4double theExcitonLevelDensityRatio;
G4double theEmissionProbability;
G4double theCondensationProbability;
G4LorentzVector theMomentum;
G4String theFragmentName;
};
#include "G4VPreCompoundFragment.icc"
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundFragment.icc
+126
View File
@@ -0,0 +1,126 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4VPreCompoundFragment.icc,v 1.2 2002/06/18 10:31:16 jwellisc Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
inline const G4double G4VPreCompoundFragment::
GetA() const
{
return theA;
}
inline const G4double G4VPreCompoundFragment::
GetZ() const
{
return theZ;
}
inline const G4double G4VPreCompoundFragment::
GetRestA() const
{
return theRestNucleusA;
}
inline const G4double G4VPreCompoundFragment::
GetRestZ() const
{
return theRestNucleusZ;
}
inline const G4double G4VPreCompoundFragment::
GetCoulombBarrier() const
{
return theCoulombBarrier;
}
inline const G4double G4VPreCompoundFragment::
GetBindingEnergy() const
{
return theBindingEnergy;
}
inline const G4double G4VPreCompoundFragment::
GetMaximalKineticEnergy() const
{
return theMaximalKineticEnergy;
}
inline const G4double G4VPreCompoundFragment::
GetEmissionProbability() const
{
return theEmissionProbability;
}
inline const G4double G4VPreCompoundFragment::
GetNuclearMass(void) const
{
return G4ParticleTable::GetParticleTable()->
GetIonTable()->GetIonMass(static_cast<G4int>(theZ),static_cast<G4int>(theA));
}
inline const G4double G4VPreCompoundFragment::
GetRestNuclearMass() const
{
return G4ParticleTable::GetParticleTable()->GetIonTable()->
GetIonMass(static_cast<G4int>(theRestNucleusZ),static_cast<G4int>(theRestNucleusA));
}
inline const G4double G4VPreCompoundFragment::
GetReducedMass() const
{
return GetRestNuclearMass()*GetNuclearMass()/
(GetNuclearMass()+GetRestNuclearMass());
}
inline const G4LorentzVector G4VPreCompoundFragment::
GetMomentum() const
{
return theMomentum;
}
inline void G4VPreCompoundFragment::
SetMomentum(const G4LorentzVector & value)
{
theMomentum = value;
}
inline void G4VPreCompoundFragment::
SetFragmentName(const G4String& aName)
{
theFragmentName = aName;
}
inline const G4String G4VPreCompoundFragment::
GetName() const
{
return theFragmentName;
}
source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundIon.hh
+54 -46
View File
@@ -21,20 +21,17 @@
// ********************************************************************
//
//
// $Id: G4VPreCompoundIon.hh,v 1.8 2001/08/01 17:08:30 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4VPreCompoundIon.hh,v 1.10 2002/06/06 17:14:05 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
#ifndef G4PreCompoundIon_h
#define G4PreCompoundIon_h 1
#ifndef G4VPreCompoundIon_h
#define G4VPreCompoundIon_h 1
#include "G4VPreCompoundFragment.hh"
#include "G4PreCompoundParameters.hh"
#include "Randomize.hh"
//#include "G4VCoulombBarrier.hh"
#include "G4VCoulombBarrier.hh"
class G4VPreCompoundIon : public G4VPreCompoundFragment
{
@@ -44,45 +41,56 @@ protected:
public:
// copy constructor
G4VPreCompoundIon(const G4VPreCompoundIon &right): G4VPreCompoundFragment(right) {}
// constructor
G4VPreCompoundIon(const G4double anA, const G4double aZ, G4VCoulombBarrier* aCoulombBarrier):
G4VPreCompoundFragment(anA,aZ,aCoulombBarrier) {}
G4VPreCompoundIon(const G4double anA, const G4double aZ, G4VCoulombBarrier* aCoulombBarrier,
const G4String & aName):
G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
// destructor
virtual ~G4VPreCompoundIon() {}
// operators
const G4VPreCompoundIon & operator=(const G4VPreCompoundIon &right) {
if (&right != this) this->G4VPreCompoundFragment::operator=(right);
return *this;
}
G4bool operator==(const G4VPreCompoundIon &right) const
{ return G4VPreCompoundFragment::operator==(right);}
G4bool operator!=(const G4VPreCompoundIon &right) const
{ return G4VPreCompoundFragment::operator!=(right);}
public:
G4double ProbabilityDistributionFunction(const G4double & eKin, const G4Fragment & aFragment);
// Gives the kinetic energy for fragments in pre-equilibrium decay
G4double GetKineticEnergy(const G4Fragment & aFragment);
// copy constructor
G4VPreCompoundIon(const G4VPreCompoundIon &right):
G4VPreCompoundFragment(right) {}
// constructor
G4VPreCompoundIon(const G4double anA,
const G4double aZ,
G4VCoulombBarrier* aCoulombBarrier,
const G4String & aName):
G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
virtual ~G4VPreCompoundIon() {}
// operators
const G4VPreCompoundIon &
operator=(const G4VPreCompoundIon &right) {
if (&right != this) this->G4VPreCompoundFragment::operator=(right);
return *this;
}
G4bool operator==(const G4VPreCompoundIon &right) const
{ return G4VPreCompoundFragment::operator==(right);}
G4bool operator!=(const G4VPreCompoundIon &right) const
{ return G4VPreCompoundFragment::operator!=(right);}
virtual G4double ProbabilityDistributionFunction(const G4double eKin,
const G4Fragment& aFragment);
protected:
G4bool IsItPossible(const G4Fragment& aFragment)
{
G4int pplus = aFragment.GetNumberOfCharged();
G4int pneut = aFragment.GetNumberOfParticles()-pplus;
return (pneut >= (GetA()-GetZ()) && pplus >= GetZ());
}
virtual G4double GetCCoef(const G4double aZ) const {return 1.0;}
virtual G4double GetAlpha() = 0;
virtual G4double GetBeta() = 0;
virtual G4double FactorialFactor(const G4double N, const G4double P) = 0;
virtual G4double CoalescenceFactor(const G4double A) = 0;
};
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundNucleon.hh
+32 -43
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4VPreCompoundNucleon.hh,v 1.7 2001/08/01 17:08:30 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4VPreCompoundNucleon.hh,v 1.8 2002/06/06 17:15:00 larazb Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// by V. Lara
@@ -37,56 +37,45 @@ class G4VPreCompoundNucleon : public G4VPreCompoundFragment
{
protected:
// default constructor
G4VPreCompoundNucleon() {};
G4VPreCompoundNucleon() {}
public:
// copy constructor
G4VPreCompoundNucleon(const G4VPreCompoundNucleon &right): G4VPreCompoundFragment(right) {}
G4VPreCompoundNucleon(const G4VPreCompoundNucleon &right):
G4VPreCompoundFragment(right) {}
// constructor
G4VPreCompoundNucleon(const G4double anA, const G4double aZ, G4VCoulombBarrier* aCoulombBarrier):
G4VPreCompoundFragment(anA,aZ,aCoulombBarrier) {}
G4VPreCompoundNucleon(const G4double anA,
const G4double aZ,
G4VCoulombBarrier* aCoulombBarrier,
const G4String & aName):
G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
G4VPreCompoundNucleon(const G4double anA, const G4double aZ, G4VCoulombBarrier* aCoulombBarrier,
const G4String & aName):
G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
virtual ~G4VPreCompoundNucleon() {}
virtual ~G4VPreCompoundNucleon() {}
// operators
const G4VPreCompoundNucleon &
operator=(const G4VPreCompoundNucleon &right) {
if (&right != this) this->G4VPreCompoundFragment::operator=(right);
return *this;
}
// operators
const G4VPreCompoundNucleon & operator=(const G4VPreCompoundNucleon &right) {
if (&right != this) this->G4VPreCompoundFragment::operator=(right);
return *this;
}
G4bool operator==(const G4VPreCompoundNucleon &right) const
{ return G4VPreCompoundFragment::operator==(right);}
G4bool operator!=(const G4VPreCompoundNucleon &right) const
{ return G4VPreCompoundFragment::operator!=(right);}
void CalcExcitonLevelDensityRatios(const G4double Excitons,const G4double Particles)
{
// Level density ratios are calculated according to the formula
// (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
// where P is number of particles
// N is number of excitons
// Af atomic number of emitting fragment
// the next is a simplification for nucleons (Af = 1)
SetExcitonLevelDensityRatio(Particles*(Excitons-1.0));
}
void CalcCondensationProbability(const G4double A)
// This method computes condensation probability to create a cluster
// consisting of N nucleons inside a nucleus with A nucleons.
// For Nucleons this probability is, of course, equal to 1
{
SetCondensationProbability(1.0);
}
G4bool operator==(const G4VPreCompoundNucleon &right) const
{ return G4VPreCompoundFragment::operator==(right);}
G4bool operator!=(const G4VPreCompoundNucleon &right) const
{ return G4VPreCompoundFragment::operator!=(right);}
virtual G4double ProbabilityDistributionFunction(const G4double eKin,
const G4Fragment& aFragment);
protected:
virtual G4double GetAlpha() = 0;
virtual G4double GetBeta() = 0;
virtual G4bool IsItPossible(const G4Fragment&) = 0;
};
#endif