Import Geant4 3.0.0 source tree
This commit is contained in:
Gabriele Cosmo
+72
-42
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -18,62 +18,92 @@
|
||||
class G4PreCompoundAlpha : public G4VPreCompoundIon
|
||||
{
|
||||
public:
|
||||
// default constructor
|
||||
G4PreCompoundAlpha():G4VPreCompoundIon(4,2) {};
|
||||
// default constructor
|
||||
G4PreCompoundAlpha():G4VPreCompoundIon(4,2) {}
|
||||
|
||||
// copy constructor
|
||||
G4PreCompoundAlpha(const G4PreCompoundAlpha &right):
|
||||
G4VPreCompoundIon(right) {};
|
||||
// copy constructor
|
||||
G4PreCompoundAlpha(const G4PreCompoundAlpha &right): G4VPreCompoundIon(right) {}
|
||||
|
||||
~G4PreCompoundAlpha() {};
|
||||
// destructor
|
||||
~G4PreCompoundAlpha() {}
|
||||
|
||||
// operators
|
||||
const G4PreCompoundAlpha & operator=(const G4PreCompoundAlpha &right) {
|
||||
if (&right != this) this->G4VPreCompoundIon::operator=(right);
|
||||
return *this;
|
||||
};
|
||||
// operators
|
||||
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);}
|
||||
|
||||
G4bool operator!=(const G4PreCompoundAlpha &right) const
|
||||
{return G4VPreCompoundIon::operator!=(right);};
|
||||
G4bool operator!=(const G4PreCompoundAlpha &right) const
|
||||
{ return G4VPreCompoundIon::operator!=(right);}
|
||||
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4Alpha::AlphaDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
const G4DynamicParticle GetDynamicParticle() const {
|
||||
G4DynamicParticle theDynamicParticle(G4Alpha::AlphaDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
|
||||
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)
|
||||
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)
|
||||
|
||||
SetExcitonLevelDensityRatio((Particles*(Excitons-1.0))*
|
||||
((Particles-1.0)*(Excitons-2.0)/2.0)*
|
||||
((Particles-2.0)*(Excitons-3.0)/6.0)*
|
||||
((Particles-3.0)*(Excitons-4.0)/12.0));
|
||||
}
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
|
||||
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));
|
||||
}
|
||||
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));
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
virtual G4double GetBarrierPenetrationFactor(const G4double aZ) const;
|
||||
virtual G4double GetCCoef(const G4double aZ) const;
|
||||
|
||||
};
|
||||
|
||||
inline G4double G4PreCompoundAlpha::GetBarrierPenetrationFactor(const G4double aZ) const
|
||||
{
|
||||
G4double K = 1.0;
|
||||
if (aZ>=70.0) {
|
||||
K = 0.98;
|
||||
} else {
|
||||
K = (((0.23684e-5*aZ) - 0.42143e-3)*aZ + 0.25222e-1)*aZ + 0.46699;
|
||||
}
|
||||
return K;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
+59
-31
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -17,38 +17,38 @@
|
||||
class G4PreCompoundDeuteron : public G4VPreCompoundIon
|
||||
{
|
||||
public:
|
||||
// default constructor
|
||||
G4PreCompoundDeuteron():G4VPreCompoundIon(2,1) {};
|
||||
// default constructor
|
||||
G4PreCompoundDeuteron():G4VPreCompoundIon(2,1) {};
|
||||
// copy constructor
|
||||
G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right):
|
||||
G4VPreCompoundIon(right) {}
|
||||
|
||||
// destructor
|
||||
~G4PreCompoundDeuteron() {}
|
||||
|
||||
// copy constructor
|
||||
G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right):
|
||||
G4VPreCompoundIon(right) {};
|
||||
// operators
|
||||
const G4PreCompoundDeuteron & operator=(const G4PreCompoundDeuteron &right) {
|
||||
if (&right != this) this->G4VPreCompoundIon::operator=(right);
|
||||
return *this;
|
||||
}
|
||||
|
||||
~G4PreCompoundDeuteron() {};
|
||||
|
||||
// operators
|
||||
const G4PreCompoundDeuteron & operator=(const G4PreCompoundDeuteron &right) {
|
||||
if (&right != this) this->G4VPreCompoundIon::operator=(right);
|
||||
return *this;
|
||||
};
|
||||
|
||||
G4bool operator==(const G4PreCompoundDeuteron &right) const
|
||||
{return G4VPreCompoundIon::operator==(right);};
|
||||
G4bool operator==(const G4PreCompoundDeuteron &right) const
|
||||
{ return G4VPreCompoundIon::operator==(right);}
|
||||
|
||||
G4bool operator!=(const G4PreCompoundDeuteron &right) const
|
||||
{return G4VPreCompoundIon::operator!=(right);};
|
||||
G4bool operator!=(const G4PreCompoundDeuteron &right) const
|
||||
{ return G4VPreCompoundIon::operator!=(right);}
|
||||
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4Deuteron::DeuteronDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4Deuteron::DeuteronDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
void CalcExcitonLevelDensityRatios(const G4double Excitons,
|
||||
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
|
||||
@@ -56,21 +56,49 @@ public:
|
||||
// Af atomic number of emitting fragment
|
||||
// the next is a simplification for deuterons (Af = 2)
|
||||
|
||||
SetExcitonLevelDensityRatio(Particles*(Excitons-1.0)*
|
||||
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
|
||||
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);
|
||||
}
|
||||
{
|
||||
SetCondensationProbability(16.0/A);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
virtual G4double GetBarrierPenetrationFactor(const G4double aZ) const;
|
||||
virtual G4double GetCCoef(const G4double aZ) const;
|
||||
|
||||
};
|
||||
|
||||
inline G4double G4PreCompoundDeuteron::GetBarrierPenetrationFactor(const G4double aZ) const
|
||||
{
|
||||
G4double K = 1.0;
|
||||
if (aZ>=70.0) {
|
||||
K = 0.80;
|
||||
} else {
|
||||
K = (((0.2357e-5*aZ) - 0.42679e-3)*aZ + 0.27035e-1)*aZ + 0.19025;
|
||||
}
|
||||
return K+0.06;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
|
||||
#ifndef G4PreCompoundEmission_h
|
||||
#define G4PreCompoundEmission_h 1
|
||||
|
||||
#include "G4VPreCompoundFragment.hh"
|
||||
#include "G4PreCompoundFragmentVector.hh"
|
||||
#include "G4ReactionProduct.hh"
|
||||
#include "G4Fragment.hh"
|
||||
#include "Randomize.hh"
|
||||
|
||||
class G4PreCompoundEmission
|
||||
{
|
||||
public:
|
||||
G4PreCompoundEmission() {};
|
||||
~G4PreCompoundEmission() {};
|
||||
|
||||
private:
|
||||
G4PreCompoundEmission(const G4PreCompoundEmission &right);
|
||||
const G4PreCompoundEmission& operator=(const G4PreCompoundEmission &right);
|
||||
G4bool operator==(const G4PreCompoundEmission &right) const;
|
||||
G4bool operator!=(const G4PreCompoundEmission &right) const;
|
||||
|
||||
public:
|
||||
|
||||
void Initialize(const G4Fragment & aFragment)
|
||||
{
|
||||
theFragmentsVector.Initialize(aFragment);
|
||||
return;
|
||||
}
|
||||
|
||||
G4double GetTotalProbability(const G4Fragment & aFragment)
|
||||
{
|
||||
return theFragmentsVector.CalculateProbabilities(aFragment);
|
||||
}
|
||||
|
||||
G4ReactionProduct * PerformEmission(G4Fragment & aFragment);
|
||||
|
||||
|
||||
private:
|
||||
|
||||
G4ThreeVector IsotropicRandom3Vector(G4double Magnitude = 1.0) const;
|
||||
|
||||
G4ParticleMomentum RotateMomentum(G4ParticleMomentum Pa, G4ParticleMomentum V,
|
||||
G4ParticleMomentum P) const;
|
||||
|
||||
|
||||
// A vector with the allowed emission fragments
|
||||
G4PreCompoundFragmentVector theFragmentsVector;
|
||||
|
||||
};
|
||||
#endif
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
#ifndef G4PreCompoundFragmentVector_h
|
||||
#define G4PreCompoundFragmentVector_h 1
|
||||
|
||||
|
||||
#include "G4VPreCompoundFragment.hh"
|
||||
#include "g4rw/tpordvec.h"
|
||||
|
||||
class G4PreCompoundFragmentVector
|
||||
{
|
||||
public:
|
||||
G4PreCompoundFragmentVector();
|
||||
~G4PreCompoundFragmentVector();
|
||||
|
||||
private:
|
||||
G4PreCompoundFragmentVector(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);
|
||||
return;
|
||||
}
|
||||
|
||||
G4double CalculateProbabilities(const G4Fragment & aFragment);
|
||||
|
||||
G4VPreCompoundFragment * ChooseFragment(void);
|
||||
|
||||
private:
|
||||
|
||||
G4RWTPtrOrderedVector<G4VPreCompoundFragment> theChannels;
|
||||
|
||||
G4double TotalEmissionProbability;
|
||||
|
||||
};
|
||||
#endif
|
||||
+73
-41
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -18,64 +18,96 @@
|
||||
class G4PreCompoundHe3 : public G4VPreCompoundIon
|
||||
{
|
||||
public:
|
||||
// default constructor
|
||||
G4PreCompoundHe3():G4VPreCompoundIon(3,2) {};
|
||||
// default constructor
|
||||
G4PreCompoundHe3():G4VPreCompoundIon(3,2) {}
|
||||
|
||||
// copy constructor
|
||||
G4PreCompoundHe3(const G4PreCompoundHe3 &right):
|
||||
G4VPreCompoundIon(right) {};
|
||||
// copy constructor
|
||||
G4PreCompoundHe3(const G4PreCompoundHe3 &right): G4VPreCompoundIon(right) {}
|
||||
|
||||
~G4PreCompoundHe3() {};
|
||||
// DEstructor
|
||||
~G4PreCompoundHe3() {}
|
||||
|
||||
// operators
|
||||
const G4PreCompoundHe3 & operator=(const G4PreCompoundHe3 &right) {
|
||||
if (&right != this) this->G4VPreCompoundIon::operator=(right);
|
||||
return *this;
|
||||
};
|
||||
// operators
|
||||
const G4PreCompoundHe3 & operator=(const G4PreCompoundHe3 &right) {
|
||||
if (&right != this) this->G4VPreCompoundIon::operator=(right);
|
||||
return *this;
|
||||
}
|
||||
|
||||
G4bool operator==(const G4PreCompoundHe3 &right) const
|
||||
{return G4VPreCompoundIon::operator==(right);};
|
||||
G4bool operator==(const G4PreCompoundHe3 &right) const
|
||||
{ return G4VPreCompoundIon::operator==(right);}
|
||||
|
||||
G4bool operator!=(const G4PreCompoundHe3 &right) const
|
||||
{return G4VPreCompoundIon::operator!=(right);};
|
||||
G4bool operator!=(const G4PreCompoundHe3 &right) const
|
||||
{ return G4VPreCompoundIon::operator!=(right);}
|
||||
|
||||
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4He3::He3Definition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
const G4DynamicParticle GetDynamicParticle() const {
|
||||
G4DynamicParticle theDynamicParticle(G4He3::He3Definition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
|
||||
|
||||
|
||||
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)
|
||||
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)/6.0));
|
||||
}
|
||||
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));
|
||||
}
|
||||
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));
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
virtual G4double GetBarrierPenetrationFactor(const G4double aZ) const;
|
||||
virtual G4double GetCCoef(const G4double aZ) const;
|
||||
|
||||
|
||||
};
|
||||
|
||||
inline G4double G4PreCompoundHe3::GetBarrierPenetrationFactor(const G4double aZ) const
|
||||
{
|
||||
G4double K = 1.0;
|
||||
if (aZ>=70.0) {
|
||||
K = 0.98;
|
||||
} else {
|
||||
K = (((0.23684e-5*aZ) - 0.42143e-3)*aZ + 0.25222e-1)*aZ + 0.46699;
|
||||
}
|
||||
return K+0.12;
|
||||
}
|
||||
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
+19
-43
@@ -1,26 +1,26 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 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: G4PreCompoundModel.hh,v 1.6 1999/12/15 14:52:38 gunter Exp $
|
||||
// GEANT4 tag $Name: geant4-02-00 $
|
||||
//
|
||||
// by V. Lara
|
||||
|
||||
// Class Description
|
||||
// Model implementation for pre-equilibrium decay models in geant4.
|
||||
// To be used in your physics list, in case you neeed this kind of physics.
|
||||
// Can be used as a stand-allone model, but also in conjunction with an intra-nuclear
|
||||
// transport, or any of the string-parton models.
|
||||
// Class Description - End
|
||||
|
||||
#ifndef G4PreCompoundModel_h
|
||||
#define G4PreCompoundModel_h 1
|
||||
|
||||
#include "G4VPreCompoundModel.hh"
|
||||
#include "G4PreCompoundNeutron.hh"
|
||||
#include "G4PreCompoundProton.hh"
|
||||
#include "G4PreCompoundDeuteron.hh"
|
||||
#include "G4PreCompoundTriton.hh"
|
||||
#include "G4PreCompoundHe3.hh"
|
||||
#include "G4PreCompoundAlpha.hh"
|
||||
#include "G4PreCompoundTransitions.hh"
|
||||
#include "G4PreCompoundEmission.hh"
|
||||
#include "G4LorentzVector.hh"
|
||||
|
||||
#include "G4NucleiProperties.hh"
|
||||
@@ -32,29 +32,23 @@
|
||||
#include "Randomize.hh"
|
||||
|
||||
|
||||
|
||||
class G4Fragment;
|
||||
|
||||
|
||||
|
||||
class G4PreCompoundModel : public G4VPreCompoundModel
|
||||
{
|
||||
public:
|
||||
|
||||
G4PreCompoundModel(G4ExcitationHandler * const value);
|
||||
G4PreCompoundModel(G4ExcitationHandler * const value) :
|
||||
G4VPreCompoundModel(value) {};
|
||||
|
||||
~G4PreCompoundModel();
|
||||
~G4PreCompoundModel() {};
|
||||
|
||||
private:
|
||||
G4PreCompoundModel() {};
|
||||
G4PreCompoundModel() {};
|
||||
|
||||
G4PreCompoundModel(const G4PreCompoundModel &right) {};
|
||||
G4PreCompoundModel(const G4PreCompoundModel &right) {};
|
||||
|
||||
const G4PreCompoundModel& operator=(const G4PreCompoundModel &right);
|
||||
|
||||
G4bool operator==(const G4PreCompoundModel &right) const;
|
||||
|
||||
G4bool operator!=(const G4PreCompoundModel &right) const;
|
||||
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);
|
||||
@@ -63,28 +57,10 @@ public:
|
||||
|
||||
private:
|
||||
|
||||
|
||||
G4ParticleChange theResult;
|
||||
|
||||
|
||||
|
||||
// static const G4int NumberOfPossibleFragments = 6;
|
||||
enum {NumberOfPossibleFragments = 6};
|
||||
|
||||
// The possible emitted fragments
|
||||
G4RWTPtrOrderedVector<G4VPreCompoundFragment> theChannels;
|
||||
|
||||
|
||||
|
||||
G4ThreeVector IsotropicRandom3Vector(G4double Magnitude = 1.0) const;
|
||||
|
||||
|
||||
void PerformEquilibriumEmission(const G4Fragment & aFragment,
|
||||
G4ReactionProductVector * theResult) const;
|
||||
|
||||
G4ParticleMomentum RotateMomentum(G4ParticleMomentum Pa, G4ParticleMomentum V,
|
||||
G4ParticleMomentum P) const;
|
||||
|
||||
|
||||
G4ParticleChange theResult;
|
||||
};
|
||||
|
||||
|
||||
|
||||
+25
-25
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -23,41 +23,41 @@
|
||||
class G4PreCompoundNeutron : public G4VPreCompoundNucleon
|
||||
{
|
||||
public:
|
||||
// default constructor
|
||||
G4PreCompoundNeutron() : G4VPreCompoundNucleon(1,0) {};
|
||||
// default constructor
|
||||
G4PreCompoundNeutron() : G4VPreCompoundNucleon(1,0) {}
|
||||
|
||||
// copy constructor
|
||||
G4PreCompoundNeutron(const G4PreCompoundNeutron &right):
|
||||
G4VPreCompoundNucleon(right) {};
|
||||
// copy constructor
|
||||
G4PreCompoundNeutron(const G4PreCompoundNeutron &right): G4VPreCompoundNucleon(right) {}
|
||||
|
||||
~G4PreCompoundNeutron() {};
|
||||
// destructor
|
||||
~G4PreCompoundNeutron() {}
|
||||
|
||||
// operators
|
||||
const G4PreCompoundNeutron & operator=(const G4PreCompoundNeutron &right) {
|
||||
if (&right != this) this->G4VPreCompoundNucleon::operator=(right);
|
||||
return *this;
|
||||
};
|
||||
// operators
|
||||
const G4PreCompoundNeutron & operator=(const G4PreCompoundNeutron &right) {
|
||||
if (&right != this) this->G4VPreCompoundNucleon::operator=(right);
|
||||
return *this;
|
||||
}
|
||||
|
||||
G4bool operator==(const G4PreCompoundNeutron &right) const
|
||||
{return G4VPreCompoundNucleon::operator==(right);};
|
||||
G4bool operator==(const G4PreCompoundNeutron &right) const
|
||||
{ return G4VPreCompoundNucleon::operator==(right);}
|
||||
|
||||
G4bool operator!=(const G4PreCompoundNeutron &right) const
|
||||
{return G4VPreCompoundNucleon::operator!=(right);};
|
||||
G4bool operator!=(const G4PreCompoundNeutron &right) const
|
||||
{ return G4VPreCompoundNucleon::operator!=(right);}
|
||||
|
||||
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4Neutron::NeutronDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4Neutron::NeutronDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
|
||||
|
||||
|
||||
public:
|
||||
G4double ProbabilityDistributionFunction(const G4double & eKin,
|
||||
const G4Fragment & aFragment);
|
||||
// Gives the kinetic energy for fragments in pre-equilibrium decay
|
||||
G4double GetKineticEnergy(const G4Fragment & aFragment);
|
||||
G4double ProbabilityDistributionFunction(const G4double & eKin, const G4Fragment & aFragment);
|
||||
|
||||
// Gives the kinetic energy for fragments in pre-equilibrium decay
|
||||
G4double GetKineticEnergy(const G4Fragment & aFragment);
|
||||
|
||||
};
|
||||
|
||||
|
||||
+2
-3
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -24,8 +24,7 @@ private:
|
||||
|
||||
|
||||
// default constructor
|
||||
G4PreCompoundParameters() : theLevelDensity(0.125) {}
|
||||
// G4PreCompoundParameters(G4int Dummy) {G4int i = Dummy;}
|
||||
G4PreCompoundParameters() : theLevelDensity(0.125/MeV) {}
|
||||
|
||||
public:
|
||||
|
||||
|
||||
+26
-24
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -21,42 +21,44 @@
|
||||
class G4PreCompoundProton : public G4VPreCompoundNucleon
|
||||
{
|
||||
public:
|
||||
// default constructor
|
||||
G4PreCompoundProton():G4VPreCompoundNucleon(1,1) {};
|
||||
// default constructor
|
||||
G4PreCompoundProton():G4VPreCompoundNucleon(1,1) {}
|
||||
|
||||
// copy constructor
|
||||
G4PreCompoundProton(const G4PreCompoundProton &right):
|
||||
G4VPreCompoundNucleon(right) {};
|
||||
// copy constructor
|
||||
G4PreCompoundProton(const G4PreCompoundProton &right): G4VPreCompoundNucleon(right) {}
|
||||
|
||||
~G4PreCompoundProton() {};
|
||||
// destructor
|
||||
~G4PreCompoundProton() {};
|
||||
|
||||
// operators
|
||||
const G4PreCompoundProton & operator=(const G4PreCompoundProton &right) {
|
||||
if (&right != this) this->G4VPreCompoundNucleon::operator=(right);
|
||||
return *this;
|
||||
};
|
||||
// operators
|
||||
const G4PreCompoundProton & operator=(const G4PreCompoundProton &right) {
|
||||
if (&right != this) this->G4VPreCompoundNucleon::operator=(right);
|
||||
return *this;
|
||||
};
|
||||
|
||||
G4bool operator==(const G4PreCompoundProton &right) const
|
||||
{return G4VPreCompoundNucleon::operator==(right);};
|
||||
G4bool operator==(const G4PreCompoundProton &right) const
|
||||
{ return G4VPreCompoundNucleon::operator==(right);}
|
||||
|
||||
|
||||
G4bool operator!=(const G4PreCompoundProton &right) const
|
||||
{return G4VPreCompoundNucleon::operator!=(right);};
|
||||
G4bool operator!=(const G4PreCompoundProton &right) const
|
||||
{ return G4VPreCompoundNucleon::operator!=(right);}
|
||||
|
||||
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4Proton::ProtonDefinition(),GetMomentum());
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4Proton::ProtonDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
G4double ProbabilityDistributionFunction(const G4double & eKin,
|
||||
const G4Fragment & aFragment);
|
||||
G4double ProbabilityDistributionFunction(const G4double & eKin, const G4Fragment & aFragment);
|
||||
|
||||
// Gives the kinetic energy for fragments in pre-equilibrium decay
|
||||
G4double GetKineticEnergy(const G4Fragment & aFragment);
|
||||
// Gives the kinetic energy for fragments in pre-equilibrium decay
|
||||
G4double GetKineticEnergy(const G4Fragment & aFragment);
|
||||
|
||||
private:
|
||||
|
||||
virtual G4double GetBarrierPenetrationFactor(const G4double aZ) const;
|
||||
|
||||
};
|
||||
|
||||
|
||||
+3
-3
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -47,10 +47,10 @@ private:
|
||||
|
||||
|
||||
public:
|
||||
G4double GetTotalProbability()
|
||||
G4double GetTotalProbability(void)
|
||||
{ return TransitionProb1+TransitionProb2+TransitionProb3; }
|
||||
|
||||
G4int GetDeltaNExciton();
|
||||
G4Fragment PerformTransition(const G4Fragment & aFragment);
|
||||
|
||||
private:
|
||||
|
||||
|
||||
+72
-41
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -17,64 +17,95 @@
|
||||
class G4PreCompoundTriton : public G4VPreCompoundIon
|
||||
{
|
||||
public:
|
||||
// default constructor
|
||||
G4PreCompoundTriton():G4VPreCompoundIon(3,1) {};
|
||||
// default constructor
|
||||
G4PreCompoundTriton():G4VPreCompoundIon(3,1) {}
|
||||
|
||||
// copy constructor
|
||||
G4PreCompoundTriton(const G4PreCompoundTriton &right):
|
||||
G4VPreCompoundIon(right) {};
|
||||
// copy constructor
|
||||
G4PreCompoundTriton(const G4PreCompoundTriton &right): G4VPreCompoundIon(right) {}
|
||||
|
||||
// destructor
|
||||
~G4PreCompoundTriton() {}
|
||||
|
||||
~G4PreCompoundTriton() {};
|
||||
// operators
|
||||
const G4PreCompoundTriton & operator=(const G4PreCompoundTriton &right) {
|
||||
if (&right != this) this->G4VPreCompoundIon::operator=(right);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// operators
|
||||
const G4PreCompoundTriton & operator=(const G4PreCompoundTriton &right) {
|
||||
if (&right != this) this->G4VPreCompoundIon::operator=(right);
|
||||
return *this;
|
||||
};
|
||||
|
||||
G4bool operator==(const G4PreCompoundTriton &right) const
|
||||
{return G4VPreCompoundIon::operator==(right);};
|
||||
G4bool operator==(const G4PreCompoundTriton &right) const
|
||||
{ return G4VPreCompoundIon::operator==(right);}
|
||||
|
||||
|
||||
G4bool operator!=(const G4PreCompoundTriton &right) const
|
||||
{return G4VPreCompoundIon::operator!=(right);};
|
||||
G4bool operator!=(const G4PreCompoundTriton &right) const
|
||||
{ return G4VPreCompoundIon::operator!=(right);}
|
||||
|
||||
const G4DynamicParticle GetDynamicParticle() const
|
||||
{
|
||||
G4DynamicParticle theDynamicParticle(G4Triton::TritonDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
const G4DynamicParticle GetDynamicParticle() const {
|
||||
G4DynamicParticle theDynamicParticle(G4Triton::TritonDefinition(),GetMomentum());
|
||||
return theDynamicParticle;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
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 tritons (Af = 3)
|
||||
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)/6.0));
|
||||
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));
|
||||
}
|
||||
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));
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
virtual G4double GetBarrierPenetrationFactor(const G4double aZ) const;
|
||||
virtual G4double GetCCoef(const G4double aZ) const;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
inline G4double G4PreCompoundTriton::GetBarrierPenetrationFactor(const G4double aZ) const
|
||||
{
|
||||
G4double K = 1.0;
|
||||
if (aZ>=70.0) {
|
||||
K = 0.80;
|
||||
} else {
|
||||
K = (((0.2357e-5*aZ) - 0.42679e-3)*aZ + 0.27035e-1)*aZ + 0.19025;
|
||||
}
|
||||
return K+0.12;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
+124
-216
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -13,111 +13,148 @@
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/iomanip"
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
#include "G4IonTable.hh"
|
||||
//#include "G4DynamicParticle.hh"
|
||||
|
||||
#include "G4Fragment.hh"
|
||||
|
||||
class G4DynamicParticle;
|
||||
|
||||
class G4VPreCompoundFragment
|
||||
{
|
||||
// ============================
|
||||
// Constructors and destructor
|
||||
// ============================
|
||||
|
||||
protected:
|
||||
// default constructor
|
||||
G4VPreCompoundFragment() {};
|
||||
// default constructor
|
||||
G4VPreCompoundFragment() {};
|
||||
|
||||
public:
|
||||
// copy constructor
|
||||
G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
|
||||
// copy constructor
|
||||
G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
|
||||
|
||||
// constructor
|
||||
G4VPreCompoundFragment(const G4double anA, const G4double aZ);
|
||||
// constructor
|
||||
G4VPreCompoundFragment(const G4double anA, const G4double aZ);
|
||||
|
||||
virtual ~G4VPreCompoundFragment();
|
||||
virtual ~G4VPreCompoundFragment();
|
||||
|
||||
// operators
|
||||
const G4VPreCompoundFragment& operator=(const G4VPreCompoundFragment &right);
|
||||
// ==========
|
||||
// operators
|
||||
// ==========
|
||||
|
||||
const G4VPreCompoundFragment& operator=(const G4VPreCompoundFragment &right);
|
||||
|
||||
G4int operator==(const G4VPreCompoundFragment &right) const;
|
||||
G4int operator==(const G4VPreCompoundFragment &right) const;
|
||||
|
||||
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&);
|
||||
|
||||
|
||||
// methods
|
||||
|
||||
void Init(const G4Fragment & aFragment);
|
||||
// =====================
|
||||
// Pure Virtual methods
|
||||
// =====================
|
||||
virtual void CalcExcitonLevelDensityRatios(const G4double Excitons, const G4double Particles) = 0;
|
||||
|
||||
virtual void CalcExcitonLevelDensityRatios(const G4double Excitons,
|
||||
const G4double Particles) = 0;
|
||||
|
||||
virtual G4double GetKineticEnergy(const G4Fragment & aFragment) = 0;
|
||||
virtual G4double GetKineticEnergy(const G4Fragment & aFragment) = 0;
|
||||
|
||||
// Calculates condensation probabilities to create fragment consisting from Nf nucleons
|
||||
// inside a nucleus with A nucleons
|
||||
virtual void CalcCondensationProbability(const G4double A) = 0;
|
||||
|
||||
// Calculates the total (integrated over kinetic energy) emission
|
||||
// probability of a fragment
|
||||
G4double CalcEmissionProbability(const G4Fragment & aFragment);
|
||||
|
||||
void SetA(const G4double value);
|
||||
const G4double GetA() const;
|
||||
|
||||
void SetZ(const G4double value);
|
||||
const G4double GetZ() const;
|
||||
|
||||
|
||||
void SetRestA(const G4double value);
|
||||
const G4double GetRestA() const;
|
||||
|
||||
void SetRestZ(const G4double value);
|
||||
const G4double GetRestZ() const;
|
||||
|
||||
|
||||
void SetCoulombBarrier(const G4double value);
|
||||
const G4double GetCoulombBarrier() const;
|
||||
|
||||
void SetBindingEnergy(const G4double value);
|
||||
const G4double GetBindingEnergy() const;
|
||||
|
||||
void SetMaximalKineticEnergy(const G4double value);
|
||||
const G4double GetMaximalKineticEnergy() const;
|
||||
|
||||
void SetExcitonLevelDensityRatio(const G4double value);
|
||||
const G4double GetExcitonLevelDensityRatio() const;
|
||||
|
||||
void SetEmissionProbability(const G4double value);
|
||||
const G4double GetEmissionProbability() const;
|
||||
|
||||
void SetCondensationProbability(const G4double value);
|
||||
const G4double GetCondensationProbability() const;
|
||||
|
||||
|
||||
const G4double GetNuclearMass() const;
|
||||
const G4double GetRestNuclearMass() const;
|
||||
// Calculates condensation probabilities to create clusters
|
||||
// consisting of N nucleons inside a nucleus with A nucleons
|
||||
virtual void CalcCondensationProbability(const G4double A) = 0;
|
||||
|
||||
virtual const G4DynamicParticle GetDynamicParticle() const = 0;
|
||||
|
||||
protected:
|
||||
virtual G4double ProbabilityDistributionFunction(const G4double & K,
|
||||
const G4Fragment & aFragment) = 0;
|
||||
private:
|
||||
G4double CalcCoulombBarrier(const G4double & NucRad);
|
||||
|
||||
// This method performs integration for probability function over
|
||||
// fragment kinetic energy
|
||||
G4double IntegrateEmissionProbability(const G4double & Low, const G4double & Up,
|
||||
const G4Fragment & aFragment);
|
||||
virtual G4double ProbabilityDistributionFunction(const G4double & K, const G4Fragment & aFragment) = 0;
|
||||
|
||||
public:
|
||||
void SetMomentum(const G4LorentzVector value);
|
||||
const G4LorentzVector GetMomentum() const;
|
||||
|
||||
virtual const G4DynamicParticle GetDynamicParticle() const = 0;
|
||||
// =====================
|
||||
// Initialization method
|
||||
// =====================
|
||||
void Init(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);
|
||||
|
||||
// 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,
|
||||
const G4Fragment & aFragment);
|
||||
|
||||
// ========================================
|
||||
// Method for calculate the Coulomb barrier
|
||||
// ========================================
|
||||
private:
|
||||
G4double CalcCoulombBarrier(const G4double NucRad, const G4double aZ);
|
||||
|
||||
// ============================
|
||||
// Data members access methods
|
||||
// ============================
|
||||
|
||||
public:
|
||||
const G4double GetA() const { return theA;}
|
||||
|
||||
const G4double GetZ() const { return theZ;}
|
||||
|
||||
const G4double GetRestA() const { return theRestNucleusA;}
|
||||
|
||||
const G4double GetRestZ() const { return theRestNucleusZ;}
|
||||
|
||||
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;}
|
||||
|
||||
protected:
|
||||
|
||||
virtual G4double GetBarrierPenetrationFactor(const G4double aZ) const
|
||||
{return 1.0;}
|
||||
|
||||
// virtual G4double Get
|
||||
|
||||
|
||||
|
||||
// =============
|
||||
// Data members
|
||||
// =============
|
||||
|
||||
private:
|
||||
|
||||
G4double theA;
|
||||
@@ -128,149 +165,20 @@ private:
|
||||
|
||||
G4double theRestNucleusZ;
|
||||
|
||||
G4double CoulombBarrier;
|
||||
G4double theCoulombBarrier;
|
||||
|
||||
G4double BindingEnergy;
|
||||
G4double theBindingEnergy;
|
||||
|
||||
G4double MaximalKineticEnergy;
|
||||
G4double theMaximalKineticEnergy;
|
||||
|
||||
G4double ExcitonLevelDensityRatio;
|
||||
G4double theExcitonLevelDensityRatio;
|
||||
|
||||
G4double EmissionProbability;
|
||||
G4double theEmissionProbability;
|
||||
|
||||
G4double CondensationProbability;
|
||||
G4double theCondensationProbability;
|
||||
|
||||
G4LorentzVector Momentum;
|
||||
G4LorentzVector theMomentum;
|
||||
|
||||
};
|
||||
|
||||
|
||||
inline void G4VPreCompoundFragment::SetA(const G4double value)
|
||||
{
|
||||
theA = value;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetA() const
|
||||
{
|
||||
return theA;
|
||||
}
|
||||
|
||||
inline void G4VPreCompoundFragment::SetZ(const G4double value)
|
||||
{
|
||||
theZ = value;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetZ() const
|
||||
{
|
||||
return theZ;
|
||||
}
|
||||
|
||||
inline void G4VPreCompoundFragment::SetRestA(const G4double value)
|
||||
{
|
||||
theRestNucleusA = value - theA;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetRestA() const
|
||||
{
|
||||
return theRestNucleusA;
|
||||
}
|
||||
|
||||
inline void G4VPreCompoundFragment::SetRestZ(const G4double value)
|
||||
{
|
||||
theRestNucleusZ = value - theZ;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetRestZ() const
|
||||
{
|
||||
return theRestNucleusZ;
|
||||
}
|
||||
|
||||
inline void G4VPreCompoundFragment::SetCoulombBarrier(const G4double value)
|
||||
{
|
||||
CoulombBarrier = value;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetCoulombBarrier() const
|
||||
{
|
||||
return CoulombBarrier;
|
||||
}
|
||||
|
||||
inline void G4VPreCompoundFragment::SetBindingEnergy(const G4double value)
|
||||
{
|
||||
BindingEnergy = value;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetBindingEnergy() const
|
||||
{
|
||||
return BindingEnergy;
|
||||
}
|
||||
|
||||
|
||||
inline void G4VPreCompoundFragment::SetMaximalKineticEnergy(const G4double value)
|
||||
{
|
||||
MaximalKineticEnergy = value;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetMaximalKineticEnergy() const
|
||||
{
|
||||
return MaximalKineticEnergy;
|
||||
}
|
||||
|
||||
inline void G4VPreCompoundFragment::SetExcitonLevelDensityRatio(const G4double value)
|
||||
{
|
||||
ExcitonLevelDensityRatio = value;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetExcitonLevelDensityRatio() const
|
||||
{
|
||||
return ExcitonLevelDensityRatio;
|
||||
}
|
||||
|
||||
|
||||
inline void G4VPreCompoundFragment::SetEmissionProbability(const G4double value)
|
||||
{
|
||||
EmissionProbability = value;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetEmissionProbability() const
|
||||
{
|
||||
return EmissionProbability;
|
||||
}
|
||||
|
||||
inline void G4VPreCompoundFragment::SetCondensationProbability(const G4double value)
|
||||
{
|
||||
CondensationProbability = value;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetCondensationProbability() const
|
||||
{
|
||||
return CondensationProbability;
|
||||
}
|
||||
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetNuclearMass() const
|
||||
// Calculate nucleus atomic mass (MeV)
|
||||
{
|
||||
return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theZ,theA)/MeV;
|
||||
}
|
||||
|
||||
inline const G4double G4VPreCompoundFragment::GetRestNuclearMass() const
|
||||
// Calculate nucleus atomic mass (MeV)
|
||||
{
|
||||
return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theRestNucleusZ,theRestNucleusA)/MeV;
|
||||
}
|
||||
|
||||
|
||||
inline void G4VPreCompoundFragment::SetMomentum(const G4LorentzVector value)
|
||||
{
|
||||
Momentum = value;
|
||||
}
|
||||
|
||||
inline const G4LorentzVector G4VPreCompoundFragment::GetMomentum() const
|
||||
{
|
||||
return Momentum;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
+24
-24
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -21,44 +21,44 @@
|
||||
class G4VPreCompoundIon : public G4VPreCompoundFragment
|
||||
{
|
||||
protected:
|
||||
// default constructor
|
||||
G4VPreCompoundIon() {};
|
||||
// default constructor
|
||||
G4VPreCompoundIon() {}
|
||||
|
||||
public:
|
||||
|
||||
// copy constructor
|
||||
G4VPreCompoundIon(const G4VPreCompoundIon &right):
|
||||
G4VPreCompoundFragment(right) {};
|
||||
// copy constructor
|
||||
G4VPreCompoundIon(const G4VPreCompoundIon &right): G4VPreCompoundFragment(right) {}
|
||||
|
||||
// constructor
|
||||
G4VPreCompoundIon(const G4double anA, const G4double aZ):
|
||||
G4VPreCompoundFragment(anA,aZ) {};
|
||||
// constructor
|
||||
G4VPreCompoundIon(const G4double anA, const G4double aZ): G4VPreCompoundFragment(anA,aZ) {}
|
||||
|
||||
// destructor
|
||||
virtual ~G4VPreCompoundIon() {}
|
||||
|
||||
virtual ~G4VPreCompoundIon() {};
|
||||
|
||||
// operators
|
||||
const G4VPreCompoundIon & operator=(const G4VPreCompoundIon &right) {
|
||||
if (&right != this) this->G4VPreCompoundFragment::operator=(right);
|
||||
return *this;
|
||||
};
|
||||
// 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);}
|
||||
|
||||
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);
|
||||
G4double ProbabilityDistributionFunction(const G4double & eKin, const G4Fragment & aFragment);
|
||||
|
||||
// Gives the kinetic energy for fragments in pre-equilibrium decay
|
||||
G4double GetKineticEnergy(const G4Fragment & aFragment);
|
||||
// Gives the kinetic energy for fragments in pre-equilibrium decay
|
||||
G4double GetKineticEnergy(const G4Fragment & aFragment);
|
||||
|
||||
protected:
|
||||
|
||||
virtual G4double GetCCoef(const G4double aZ) const {return 1.0;}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
+34
-37
@@ -1,5 +1,5 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
// the RD44 GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
@@ -17,54 +17,51 @@
|
||||
class G4VPreCompoundNucleon : public G4VPreCompoundFragment
|
||||
{
|
||||
protected:
|
||||
// copy constructor
|
||||
G4VPreCompoundNucleon() {};
|
||||
// copy constructor
|
||||
G4VPreCompoundNucleon() {};
|
||||
|
||||
public:
|
||||
|
||||
// copy constructor
|
||||
G4VPreCompoundNucleon(const G4VPreCompoundNucleon &right):
|
||||
G4VPreCompoundFragment(right) {};
|
||||
// copy constructor
|
||||
G4VPreCompoundNucleon(const G4VPreCompoundNucleon &right): G4VPreCompoundFragment(right) {}
|
||||
|
||||
// constructor
|
||||
G4VPreCompoundNucleon(const G4double anA, const G4double aZ):
|
||||
G4VPreCompoundFragment(anA,aZ) {};
|
||||
// constructor
|
||||
G4VPreCompoundNucleon(const G4double anA, const G4double aZ): G4VPreCompoundFragment(anA,aZ) {}
|
||||
|
||||
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);}
|
||||
|
||||
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)
|
||||
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));
|
||||
}
|
||||
SetExcitonLevelDensityRatio(Particles*(Excitons-1.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 = 1 (nucleon)
|
||||
{
|
||||
SetCondensationProbability(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);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user