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

Import Geant4 3.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 16:10:37 +02:00
parent 137e303ecc
commit 36c080dca6
3464 changed files with 119310 additions and 52696 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundAlpha.hh
+84 -70
View File
@@ -1,109 +1,123 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundAlpha.hh,v 1.6.2.1 2001/06/28 19:13:31 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#ifndef G4PreCompoundAlpha_h
#define G4PreCompoundAlpha_h 1
#include "G4VPreCompoundIon.hh"
#include "G4ReactionProduct.hh"
#include "G4Alpha.hh"
#include "G4AlphaCoulombBarrier.hh"
class G4PreCompoundAlpha : public G4VPreCompoundIon
{
public:
// default constructor
G4PreCompoundAlpha():G4VPreCompoundIon(4,2) {}
// default constructor
G4PreCompoundAlpha():G4VPreCompoundIon(4,2,&theAlphaCoulombBarrier,"alpha") {}
// copy constructor
G4PreCompoundAlpha(const G4PreCompoundAlpha &right): G4VPreCompoundIon(right) {}
// copy constructor
G4PreCompoundAlpha(const G4PreCompoundAlpha &right): G4VPreCompoundIon(right) {}
// destructor
~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;
}
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)
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)/3.0)*
((Particles-3.0)*(Excitons-4.0)/4.0))/6.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;
virtual G4double GetCCoef(const G4double aZ) const;
G4AlphaCoulombBarrier theAlphaCoulombBarrier;
};
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;
}
#endif
inline G4double G4PreCompoundAlpha::GetCCoef(const G4double aZ) const
{
G4double C = 0.0;
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;
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
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundDeuteron.hh
+68 -54
View File
@@ -1,54 +1,77 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundDeuteron.hh,v 1.6.2.1 2001/06/28 19:13:31 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#ifndef G4PreCompoundDeuteron_h
#define G4PreCompoundDeuteron_h 1
#include "G4VPreCompoundIon.hh"
#include "G4ReactionProduct.hh"
#include "G4Deuteron.hh"
#include "G4DeuteronCoulombBarrier.hh"
class G4PreCompoundDeuteron : public G4VPreCompoundIon
{
public:
// default constructor
G4PreCompoundDeuteron():G4VPreCompoundIon(2,1) {};
// copy constructor
G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right):
// default constructor
G4PreCompoundDeuteron():G4VPreCompoundIon(2,1,&theDeuteronCoulombBarrier,"Deuteron") {};
// copy constructor
G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right):
G4VPreCompoundIon(right) {}
// destructor
~G4PreCompoundDeuteron() {}
// destructor
~G4PreCompoundDeuteron() {}
// operators
const G4PreCompoundDeuteron & operator=(const G4PreCompoundDeuteron &right) {
if (&right != this) this->G4VPreCompoundIon::operator=(right);
return *this;
}
// 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;
}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4Deuteron::DeuteronDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
return theReactionProduct;
}
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,49 +79,40 @@ 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;
virtual G4double GetCCoef(const G4double aZ) const;
G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
};
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;
}
#endif
inline G4double G4PreCompoundDeuteron::GetCCoef(const G4double aZ) const
{
G4double C = 0.0;
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;
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
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundEmission.hh
+56 -18
View File
@@ -1,3 +1,31 @@
//
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundEmission.hh,v 1.3.2.1 2001/06/28 19:13:32 gunter Exp $
// GEANT4 tag $Name: $
//
// Hadronic Process: Nuclear Preequilibrium
// by V. Lara
#ifndef G4PreCompoundEmission_h
#define G4PreCompoundEmission_h 1
@@ -7,14 +35,16 @@
#include "G4ReactionProduct.hh"
#include "G4Fragment.hh"
#include "Randomize.hh"
#include "G4PreCompoundParameters.hh"
class G4PreCompoundEmission
{
public:
G4PreCompoundEmission() {};
~G4PreCompoundEmission() {};
G4PreCompoundEmission(const G4Fragment& aFragment);
~G4PreCompoundEmission() {};
private:
G4PreCompoundEmission() {};
G4PreCompoundEmission(const G4PreCompoundEmission &right);
const G4PreCompoundEmission& operator=(const G4PreCompoundEmission &right);
G4bool operator==(const G4PreCompoundEmission &right) const;
@@ -22,30 +52,38 @@ private:
public:
void Initialize(const G4Fragment & aFragment)
{
theFragmentsVector.Initialize(aFragment);
return;
}
void Initialize(const G4Fragment & aFragment)
{
theFragmentsVector.Initialize(aFragment);
return;
}
G4double GetTotalProbability(const G4Fragment & aFragment)
{
return theFragmentsVector.CalculateProbabilities(aFragment);
}
G4double GetTotalProbability(const G4Fragment & aFragment)
{
return theFragmentsVector.CalculateProbabilities(aFragment);
}
G4ReactionProduct * PerformEmission(G4Fragment & aFragment);
G4ReactionProduct * PerformEmission(G4Fragment & aFragment);
private:
G4ThreeVector IsotropicRandom3Vector(G4double Magnitude = 1.0) const;
G4ParticleMomentum RotateMomentum(G4ParticleMomentum Pa, G4ParticleMomentum V,
G4ParticleMomentum P) const;
G4ThreeVector AngularDistribution(G4VPreCompoundFragment * theFragment,
const G4Fragment& aFragment,
const G4double KineticEnergy) const;
// A vector with the allowed emission fragments
G4PreCompoundFragmentVector theFragmentsVector;
G4double rho(const G4double p, const G4double h, const G4double g,
const G4double E, const G4double Ef) const;
G4double bessi0(const G4double x) const;
// A vector with the allowed emission fragments
G4PreCompoundFragmentVector theFragmentsVector;
// Projectile energy
G4double ProjEnergy;
};
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundFragmentVector.hh
+48 -17
View File
@@ -1,40 +1,71 @@
//
// ********************************************************************
// * 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 *
// * 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.hh,v 1.2.2.1 2001/06/28 19:13:33 gunter Exp $
// GEANT4 tag $Name: $
//
// Hadronic Process: Nuclear Preequilibrium
// by V. Lara
#ifndef G4PreCompoundFragmentVector_h
#define G4PreCompoundFragmentVector_h 1
#include "G4VPreCompoundFragment.hh"
#include "g4rw/tpordvec.h"
class G4PreCompoundFragmentVector
{
public:
G4PreCompoundFragmentVector();
~G4PreCompoundFragmentVector();
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;
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;
}
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;
}
G4double CalculateProbabilities(const G4Fragment & aFragment);
G4double CalculateProbabilities(const G4Fragment & aFragment);
G4VPreCompoundFragment * ChooseFragment(void);
G4VPreCompoundFragment * ChooseFragment(void);
private:
G4RWTPtrOrderedVector<G4VPreCompoundFragment> theChannels;
G4std::vector<G4VPreCompoundFragment*> theChannels;
G4double TotalEmissionProbability;
G4double TotalEmissionProbability;
};
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundHe3.hh
+83 -69
View File
@@ -1,11 +1,29 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundHe3.hh,v 1.6.2.1 2001/06/28 19:13:33 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
@@ -13,101 +31,97 @@
#define G4PreCompoundHe3_h 1
#include "G4VPreCompoundIon.hh"
#include "G4ReactionProduct.hh"
#include "G4He3.hh"
#include "G4He3CoulombBarrier.hh"
class G4PreCompoundHe3 : public G4VPreCompoundIon
{
public:
// default constructor
G4PreCompoundHe3():G4VPreCompoundIon(3,2) {}
// default constructor
G4PreCompoundHe3():G4VPreCompoundIon(3,2,&theHe3CoulombBarrier,"He3") {}
// copy constructor
G4PreCompoundHe3(const G4PreCompoundHe3 &right): G4VPreCompoundIon(right) {}
// copy constructor
G4PreCompoundHe3(const G4PreCompoundHe3 &right): G4VPreCompoundIon(right) {}
// DEstructor
~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;
}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4He3::He3Definition());
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 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)/3.0))/2.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;
virtual G4double GetCCoef(const G4double aZ) const;
G4He3CoulombBarrier theHe3CoulombBarrier;
};
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;
}
#endif
inline G4double G4PreCompoundHe3::GetCCoef(const G4double aZ) const
{
G4double C = 0.0;
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);
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
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundModel.hh
+43 -15
View File
@@ -1,11 +1,29 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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.9.2.1 2001/06/28 19:13:33 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
// Class Description
@@ -32,23 +50,27 @@
#include "Randomize.hh"
//#define debug
//#define verbose
class G4PreCompoundModel : public G4VPreCompoundModel
{
public:
G4PreCompoundModel(G4ExcitationHandler * const value) :
G4VPreCompoundModel(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);
@@ -59,8 +81,14 @@ private:
void PerformEquilibriumEmission(const G4Fragment & aFragment,
G4ReactionProductVector * theResult) const;
G4ParticleChange theResult;
#ifdef debug
void CheckConservation(const G4Fragment & theInitialState,
const G4Fragment & aFragment,
G4ReactionProductVector * Result) const;
#endif
G4ParticleChange theResult;
};
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundNeutron.hh
+55 -29
View File
@@ -1,11 +1,29 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundNeutron.hh,v 1.5.2.1 2001/06/28 19:13:33 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
@@ -13,51 +31,59 @@
#define G4PreCompoundNeutron_h 1
#include "G4VPreCompoundNucleon.hh"
#include "G4DynamicParticle.hh"
#include "G4ReactionProduct.hh"
#include "G4Neutron.hh"
#include "G4PreCompoundParameters.hh"
#include "Randomize.hh"
#include "G4NeutronCoulombBarrier.hh"
class G4PreCompoundNeutron : public G4VPreCompoundNucleon
{
public:
// default constructor
G4PreCompoundNeutron() : G4VPreCompoundNucleon(1,0) {}
// default constructor
G4PreCompoundNeutron() : G4VPreCompoundNucleon(1,0,&theNeutronCoulomBarrier,"Neutron") {}
// copy constructor
G4PreCompoundNeutron(const G4PreCompoundNeutron &right): G4VPreCompoundNucleon(right) {}
// copy constructor
G4PreCompoundNeutron(const G4PreCompoundNeutron &right): G4VPreCompoundNucleon(right) {}
// destructor
~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;
}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4Neutron::NeutronDefinition());
theReactionProduct->SetMomentum(GetMomentum().vect());
theReactionProduct->SetTotalEnergy(GetMomentum().e());
return theReactionProduct;
}
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:
G4NeutronCoulombBarrier theNeutronCoulomBarrier;
};
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundParameters.hh
+49 -10
View File
@@ -1,11 +1,29 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundParameters.hh,v 1.5.2.1 2001/06/28 19:13:33 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
@@ -19,12 +37,9 @@ class G4PreCompoundParameters
private:
static G4PreCompoundParameters thePreCompoundParameters;
// Level density parameter
const G4double theLevelDensity;
// default constructor
G4PreCompoundParameters() : theLevelDensity(0.125/MeV) {}
G4PreCompoundParameters() : theLevelDensity(0.125/MeV),
r0(1.5*fermi),Transitionsr0(0.6*fermi),FermiEnergy(35.0*MeV) {}
public:
@@ -35,6 +50,30 @@ public:
G4double GetLevelDensity()
{ return theLevelDensity; }
G4double Getr0()
{ return r0; }
G4double GetTransitionsr0()
{ return Transitionsr0; }
G4double GetFermiEnergy()
{ return FermiEnergy; }
private:
// Level density parameter
const G4double theLevelDensity;
// Nuclear radius r0
const G4double r0;
// Nuclear radius r0 for transitions
const G4double Transitionsr0;
// Fermi energy level
const G4double FermiEnergy;
};
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundProton.hh
+53 -31
View File
@@ -1,64 +1,86 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundProton.hh,v 1.6.2.1 2001/06/28 19:13:33 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#ifndef G4PreCompoundProton_h
#define G4PreCompoundProton_h 1
#include "G4VPreCompoundNucleon.hh"
#include "G4DynamicParticle.hh"
#include "G4ReactionProduct.hh"
#include "G4Proton.hh"
#include "G4PreCompoundParameters.hh"
#include "Randomize.hh"
#include "G4ProtonCoulombBarrier.hh"
class G4PreCompoundProton : public G4VPreCompoundNucleon
{
public:
// default constructor
G4PreCompoundProton():G4VPreCompoundNucleon(1,1) {}
// default constructor
G4PreCompoundProton():G4VPreCompoundNucleon(1,1,&theProtonCoulombBarrier,"Proton") {}
// copy constructor
G4PreCompoundProton(const G4PreCompoundProton &right): G4VPreCompoundNucleon(right) {}
// copy constructor
G4PreCompoundProton(const G4PreCompoundProton &right): G4VPreCompoundNucleon(right) {}
// destructor
~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());
return theDynamicParticle;
}
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);
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;
G4ProtonCoulombBarrier theProtonCoulombBarrier;
};
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundTransitions.hh
+25 -8
View File
@@ -1,11 +1,29 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundTransitions.hh,v 1.5.2.1 2001/06/28 19:13:33 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#ifndef G4PreCompoundTransitions_h
@@ -32,10 +50,10 @@ public:
// Calculates transition probabilities with Delta N = +2 (Trans1) -2 (Trans2) and 0 (Trans3)
G4PreCompoundTransitions(const G4Fragment & aFragment);
~G4PreCompoundTransitions() {};
~G4PreCompoundTransitions() {}
private:
G4PreCompoundTransitions() {};
G4PreCompoundTransitions() {}
G4PreCompoundTransitions(const G4PreCompoundTransitions &right) {};
@@ -45,7 +63,6 @@ private:
G4bool operator!=(const G4PreCompoundTransitions &right) const;
public:
G4double GetTotalProbability(void)
{ return TransitionProb1+TransitionProb2+TransitionProb3; }
source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundTriton.hh
+82 -66
View File
@@ -1,111 +1,127 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4PreCompoundTriton.hh,v 1.6.2.1 2001/06/28 19:13:33 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#ifndef G4PreCompoundTriton_h
#define G4PreCompoundTriton_h 1
#include "G4VPreCompoundIon.hh"
#include "G4ReactionProduct.hh"
#include "G4Triton.hh"
#include "G4TritonCoulombBarrier.hh"
#include "G4ProtonCoulombBarrier.hh"
class G4PreCompoundTriton : public G4VPreCompoundIon
{
public:
// default constructor
G4PreCompoundTriton():G4VPreCompoundIon(3,1) {}
// default constructor
G4PreCompoundTriton():G4VPreCompoundIon(3,1,&theTritonCoulombBarrier,"Triton") {}
// copy constructor
G4PreCompoundTriton(const G4PreCompoundTriton &right): G4VPreCompoundIon(right) {}
// copy constructor
G4PreCompoundTriton(const G4PreCompoundTriton &right): G4VPreCompoundIon(right) {}
// destructor
~G4PreCompoundTriton() {}
// destructor
~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;
}
G4ReactionProduct * GetReactionProduct() const
{
G4ReactionProduct * theReactionProduct = new G4ReactionProduct(G4Triton::TritonDefinition());
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! (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)
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));
}
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;
virtual G4double GetCCoef(const G4double aZ) const;
G4TritonCoulombBarrier theTritonCoulombBarrier;
};
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;
}
#endif
inline G4double G4PreCompoundTriton::GetCCoef(const G4double aZ) const
{
G4double C = 0.0;
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;
}
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;
return C/3.0;
}
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundFragment.hh
+116 -89
View File
@@ -1,11 +1,29 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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.hh,v 1.6.2.1 2001/06/28 19:13:34 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#ifndef G4VPreCompoundFragment_h
@@ -16,144 +34,147 @@
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include "G4Fragment.hh"
#include "G4VCoulombBarrier.hh"
class G4DynamicParticle;
class G4ReactionProduct;
class G4VPreCompoundFragment
{
// ============================
// Constructors and destructor
// ============================
// ============================
// 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,
G4VCoulombBarrier * aCoulombBarrier);
virtual ~G4VPreCompoundFragment();
G4VPreCompoundFragment(const G4double anA, const G4double aZ,
G4VCoulombBarrier * aCoulombBarrier,
const G4String & aName);
// ==========
// operators
// ==========
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;
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;
// =====================
// Pure Virtual methods
// =====================
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 clusters
// consisting of N nucleons inside a nucleus with A nucleons
virtual void CalcCondensationProbability(const G4double A) = 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 const G4DynamicParticle GetDynamicParticle() const = 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);
// =====================
// Initialization method
// =====================
void Init(const G4Fragment & aFragment);
// ================================================
// Methods for calculating the emission probability
// ================================================
// ================================================
// Methods for calculating the emission probability
// ================================================
// Calculates the total (integrated over kinetic energy) emission
// probability of a fragment
G4double CalcEmissionProbability(const G4Fragment & aFragment);
// 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
// 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);
// 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
// ============================
// // 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 GetA() const { return theA;}
const G4double GetZ() const { return theZ;}
const G4double GetZ() const { return theZ;}
const G4double GetRestA() const { return theRestNucleusA;}
const G4double GetRestA() const { return theRestNucleusA;}
const G4double GetRestZ() const { return theRestNucleusZ;}
const G4double GetRestZ() const { return theRestNucleusZ;}
const G4double GetCoulombBarrier() const {return theCoulombBarrier;}
const G4double GetCoulombBarrier() const {return theCoulombBarrier;}
const G4double GetBindingEnergy() const { return theBindingEnergy;}
const G4double GetBindingEnergy() const { return theBindingEnergy;}
const G4double GetMaximalKineticEnergy() const { return theMaximalKineticEnergy;}
const G4double GetMaximalKineticEnergy() const { return theMaximalKineticEnergy;}
const G4double GetExcitonLevelDensityRatio() const { return theExcitonLevelDensityRatio;}
void SetExcitonLevelDensityRatio(const G4double value) { theExcitonLevelDensityRatio = value;}
const G4double GetExcitonLevelDensityRatio() const { return theExcitonLevelDensityRatio;}
void SetExcitonLevelDensityRatio(const G4double value) { theExcitonLevelDensityRatio = value;}
void SetEmissionProbability(const G4double value) { theEmissionProbability = value;}
void SetEmissionProbability(const G4double value) { theEmissionProbability = value;}
const G4double GetEmissionProbability() const { return theEmissionProbability;}
const G4double GetEmissionProbability() const { return theEmissionProbability;}
const G4double GetCondensationProbability() const { return theCondensationProbability;}
void SetCondensationProbability(const G4double value) { theCondensationProbability = value;}
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 GetNuclearMass() const {
return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theZ,theA);
}
const G4double GetRestNuclearMass() const {
return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theRestNucleusZ,theRestNucleusA);
}
const G4double GetRestNuclearMass() const {
return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theRestNucleusZ,theRestNucleusA);
}
const G4double GetReducedMass() const {
return GetRestNuclearMass()*GetNuclearMass()/(GetNuclearMass()+GetRestNuclearMass());
}
const G4double GetReducedMass() const {
return GetRestNuclearMass()*GetNuclearMass()/(GetNuclearMass()+GetRestNuclearMass());
}
const G4LorentzVector GetMomentum() const { return theMomentum;}
const G4LorentzVector GetMomentum() const { return theMomentum;}
void SetMomentum(const G4LorentzVector & value) { theMomentum = value;}
void SetMomentum(const G4LorentzVector & value) { theMomentum = value;}
protected:
virtual G4double GetBarrierPenetrationFactor(const G4double aZ) const
{return 1.0;}
// virtual G4double Get
void SetFragmentName(const G4String& aName) { theFragmentName = aName; }
const G4String GetName() const { return theFragmentName; }
// =============
// Data members
// =============
// =============
// Data members
// =============
private:
@@ -164,8 +185,10 @@ private:
G4double theRestNucleusA;
G4double theRestNucleusZ;
G4double theCoulombBarrier;
G4VCoulombBarrier * theCoulombBarrierPtr;
G4double theBindingEnergy;
@@ -179,6 +202,10 @@ private:
G4LorentzVector theMomentum;
G4String theFragmentName;
};
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundIon.hh
+50 -27
View File
@@ -1,11 +1,29 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4VPreCompoundIon.hh,v 1.6.2.1 2001/06/28 19:13:34 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
@@ -16,49 +34,54 @@
#include "G4VPreCompoundFragment.hh"
#include "G4PreCompoundParameters.hh"
#include "Randomize.hh"
//#include "G4VCoulombBarrier.hh"
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, 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() {}
// destructor
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;}
virtual G4double GetCCoef(const G4double aZ) const {return 1.0;}
};
#endif
source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundNucleon.hh
+62 -39
View File
@@ -1,68 +1,91 @@
// This code implementation is the intellectual property of
// 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.
// ********************************************************************
// * 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 *
// * 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: G4VPreCompoundNucleon.hh,v 1.5.2.1 2001/06/28 19:13:34 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#ifndef G4VPreCompoundNucleon_h
#define G4VPreCompoundNucleon_h 1
#include "G4VPreCompoundFragment.hh"
#include "G4VCoulombBarrier.hh"
class G4VPreCompoundNucleon : public G4VPreCompoundFragment
{
protected:
// copy constructor
G4VPreCompoundNucleon() {};
// default 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, G4VCoulombBarrier* aCoulombBarrier):
G4VPreCompoundFragment(anA,aZ,aCoulombBarrier) {}
virtual ~G4VPreCompoundNucleon() {}
G4VPreCompoundNucleon(const G4double anA, const G4double aZ, G4VCoulombBarrier* aCoulombBarrier,
const G4String & aName):
G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
// operators
const G4VPreCompoundNucleon & operator=(const G4VPreCompoundNucleon &right) {
if (&right != this) this->G4VPreCompoundFragment::operator=(right);
return *this;
}
virtual ~G4VPreCompoundNucleon() {}
G4bool operator==(const G4VPreCompoundNucleon &right) const
{ return G4VPreCompoundFragment::operator==(right);}
// 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);}
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 cluster
// consisting of N nucleons inside a nucleus with A nucleons.
// For Nucleons this probability is, of course, equal to 1
{
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);
}
};
#endif