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
source/processes/hadronic/models/generator/pre_equilibrium/src/G4PreCompoundEmission.cc
+213 -98
View File
@@ -1,9 +1,39 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * 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.cc,v 1.3.2.1 2001/06/28 19:13:34 gunter Exp $
// GEANT4 tag $Name: $
//
// Hadronic Process: Nuclear Preequilibrium
// by V. Lara
#include "G4PreCompoundEmission.hh"
const G4PreCompoundEmission & G4PreCompoundEmission::operator=(const G4PreCompoundEmission &right)
{
G4Exception("G4PreCompoundEmission::operator= meant to not be accessable");
return *this;
G4Exception("G4PreCompoundEmission::operator= meant to not be accessable");
return *this;
}
@@ -18,125 +48,210 @@ G4bool G4PreCompoundEmission::operator!=(const G4PreCompoundEmission &right) con
}
G4PreCompoundEmission::G4PreCompoundEmission(const G4Fragment& aFragment)
{
// Assume that projectile is a proton
ProjEnergy = aFragment.GetExcitationEnergy();
}
G4ReactionProduct * G4PreCompoundEmission::PerformEmission(G4Fragment & aFragment)
{
// Choose a Fragment for emission
G4VPreCompoundFragment * theFragment = theFragmentsVector.ChooseFragment();
// Choose a Fragment for emission
G4VPreCompoundFragment * theFragment = theFragmentsVector.ChooseFragment();
// Kinetic Energy of emitted fragment
G4double KineticEnergyOfEmittedFragment = theFragment->GetKineticEnergy(aFragment);
// Sample the Fermi momentum of emitted fragment
static const G4double FermiMaxMom = 250.0*MeV;
G4ThreeVector FermiMomentum(IsotropicRandom3Vector(FermiMaxMom*pow(G4UniformRand(),1./3.)));
// Kinetic Energy of emitted fragment
G4double KineticEnergyOfEmittedFragment = theFragment->GetKineticEnergy(aFragment);
// Get the fragment momentum
G4ThreeVector P12(aFragment.GetMomentum().vect());
// Share the fragment momentum between the particles system
P12 *= 1.0/G4double(aFragment.GetNumberOfParticles());
// Add the Fermi momentum
P12 += FermiMomentum;
// Calculate the momentum magnitude of emitted fragment
G4double EmittedMass = theFragment->GetNuclearMass();
G4double p = sqrt(KineticEnergyOfEmittedFragment*(KineticEnergyOfEmittedFragment+2.0*EmittedMass));
// And sample a direction for it
G4ParticleMomentum momentum;
if (aFragment.GetMomentum().boostVector().mag2() > 1.e-7) {
// sample a non-isotropic random vector
G4double CosTheta = sqrt(G4UniformRand());
G4double SinTheta = sqrt(1.0 - CosTheta*CosTheta);
G4double Phi = twopi*G4UniformRand();
momentum = G4ParticleMomentum(p*cos(Phi)*SinTheta,
p*sin(Phi)*SinTheta,
p*CosTheta);
momentum = RotateMomentum(P12,aFragment.GetMomentum().boostVector(),momentum);
} else {
momentum = IsotropicRandom3Vector(p);
}
// Calculate the fragment momentum (three vector)
G4ThreeVector momentum = AngularDistribution(theFragment,aFragment,KineticEnergyOfEmittedFragment);
// Now we can calculate the four momentum
G4LorentzVector EmittedMomentum(momentum,sqrt(momentum.mag2()+EmittedMass*EmittedMass));
// Mass of emittef fragment
G4double EmittedMass = theFragment->GetNuclearMass();
// Excitation energy
G4double anU = theFragment->GetMaximalKineticEnergy() - KineticEnergyOfEmittedFragment +
theFragment->GetCoulombBarrier();
// Now we can calculate the four momentum
// both options are valid and give the same result but 2nd one is faster
// G4LorentzVector EmittedMomentum(momentum,sqrt(momentum.mag2()+EmittedMass*EmittedMass));
G4LorentzVector EmittedMomentum(momentum,EmittedMass+KineticEnergyOfEmittedFragment);
// check that Excitation energy is > 0
if (anU < 0.0) G4Exception("G4PreCompoundModel::DeExcite: Excitation energy less than 0!");
// Perform Lorentz boost
EmittedMomentum.boost(aFragment.GetMomentum().boostVector());
// Update nucleus parameters
// Number of excitons
aFragment.SetNumberOfExcitons(aFragment.GetNumberOfExcitons()-
G4int(theFragment->GetA()));
// Number of charges
aFragment.SetNumberOfCharged(aFragment.GetNumberOfCharged()-
G4int(theFragment->GetZ()));
// Set emitted fragment momentum
theFragment->SetMomentum(EmittedMomentum);
// Atomic number
aFragment.SetA(theFragment->GetRestA());
// NOW THE RESIDUAL NUCLEUS
// ------------------------
// Now the residual nucleus.
// The energy conservation says that
G4double ResidualEcm =
aFragment.GetGroundStateMass() + aFragment.GetExcitationEnergy() // initial energy in cm
- (EmittedMass+KineticEnergyOfEmittedFragment);
// Then the four momentum for residual is
G4LorentzVector RestMomentum(-momentum,ResidualEcm);
G4LorentzVector RestMomentum2(aFragment.GetMomentum()-EmittedMomentum);
// Just for test
// Excitation energy
// G4double anU = ResidualEcm - theFragment->GetRestNuclearMass();
// This is equivalent
// G4double anU = theFragment->GetMaximalKineticEnergy() - KineticEnergyOfEmittedFragment +
// theFragment->GetCoulombBarrier();
// check that Excitation energy is >= 0
G4double anU = RestMomentum.m()-theFragment->GetRestNuclearMass();
if (anU < 0.0) G4Exception("G4PreCompoundModel::DeExcite: Excitation energy less than 0!");
// Update nucleus parameters:
// --------------------------
// Number of excitons
aFragment.SetNumberOfParticles(aFragment.GetNumberOfParticles()-
G4int(theFragment->GetA()));
// Number of charges
aFragment.SetNumberOfCharged(aFragment.GetNumberOfCharged()-
G4int(theFragment->GetZ()));
// Atomic number
aFragment.SetA(theFragment->GetRestA());
// Charge
aFragment.SetZ(theFragment->GetRestZ());
// Charge
aFragment.SetZ(theFragment->GetRestZ());
// Calculate the residual Fragment momentum
G4double ResidualMass = theFragment->GetRestNuclearMass()+anU;
G4LorentzVector RestMomentum(-momentum,sqrt(momentum.mag2()+ ResidualMass*ResidualMass));
// Perform Lorentz boosts
RestMomentum.boost(aFragment.GetMomentum().boostVector());
// Perform Lorentz boosts
EmittedMomentum.boost(aFragment.GetMomentum().boostVector());
RestMomentum.boost(aFragment.GetMomentum().boostVector());
// Update nucleus momentum
aFragment.SetMomentum(RestMomentum);
// Update nucleus momentum
aFragment.SetMomentum(RestMomentum);
// Set emitted fragment momentum
theFragment->SetMomentum(EmittedMomentum);
G4DynamicParticle MyDP = theFragment->GetDynamicParticle();
G4ReactionProduct * theNew = new G4ReactionProduct(MyDP.GetDefinition());
theNew->SetMomentum(MyDP.GetMomentum());
theNew->SetTotalEnergy(MyDP.Get4Momentum().e());
return theNew;
// Create a G4ReactionProduct
G4ReactionProduct * MyRP = theFragment->GetReactionProduct();
return MyRP;
}
G4ThreeVector G4PreCompoundEmission::IsotropicRandom3Vector(G4double Magnitude) const
// Create a unit vector with a random direction isotropically distributed
G4ThreeVector G4PreCompoundEmission::AngularDistribution(G4VPreCompoundFragment * theFragment,
const G4Fragment& aFragment,
const G4double KineticEnergyOfEmittedFragment) const
{
G4double p = aFragment.GetNumberOfParticles();
G4double h = aFragment.GetNumberOfHoles();
G4double U = aFragment.GetExcitationEnergy();
// Kinetic Energy of emitted fragment
// G4double KineticEnergyOfEmittedFragment = theFragment->GetKineticEnergy(aFragment);
// Emission particle separation energy
G4double Bemission = theFragment->GetBindingEnergy();
// Fermi energy
G4double Ef = G4PreCompoundParameters::GetAddress()->GetFermiEnergy();
//
G4double g = 0.595*aFragment.GetA()*G4PreCompoundParameters::GetAddress()->GetLevelDensity();
// Average exciton energy relative to bottom of nuclear well
G4double Eav = 2.0*p*(p+1.0)/((p+h)*g);
// Excitation energy relative to the Fermi Level
// G4double Uf = U - (p - h)*Ef;
G4double Uf = U - KineticEnergyOfEmittedFragment - Bemission;
G4double CosTheta = 1.0 - 2.0*G4UniformRand();
G4double SinTheta = sqrt(1.0 - CosTheta*CosTheta);
G4double Phi = twopi*G4UniformRand();
G4ThreeVector Vector(Magnitude*cos(Phi)*SinTheta,
Magnitude*sin(Phi)*SinTheta,
Magnitude*CosTheta);
Eav *= rho(p+1,h,g,Uf,Ef)/rho(p,h,g,Uf,Ef);
Eav += - Uf/(p+h) + Ef;
G4double zeta = G4std::max(1.0,9.3/sqrt(KineticEnergyOfEmittedFragment/MeV));
G4double an = 3.0*sqrt((ProjEnergy+Ef)*(KineticEnergyOfEmittedFragment+Bemission+Ef))/
(zeta*2.0*aFragment.GetNumberOfExcitons()*Eav);
// (zeta*(aFragment.GetNumberOfExcitons()-1.0)*Eav);
G4double normalization = pi*bessi0(an);
G4double theta = 0.0;
G4double distrib = 0.0;
do {
theta = pi*G4UniformRand();
distrib = exp(an*cos(theta))/normalization;
} while ( G4UniformRand() > distrib );
G4double phi = twopi*G4UniformRand();
// Calculate the momentum magnitude of emitted fragment
G4double EmittedMass = theFragment->GetNuclearMass();
G4double pmag = sqrt(KineticEnergyOfEmittedFragment*(KineticEnergyOfEmittedFragment+2.0*EmittedMass));
G4double sinTheta = sin(theta);
G4double cosTheta = sqrt(1.0-sinTheta*sinTheta);
return Vector;
G4ThreeVector momentum = G4ParticleMomentum(pmag*cos(phi)*sinTheta,pmag*sin(phi)*sinTheta,pmag*cosTheta);
return momentum;
}
G4ParticleMomentum G4PreCompoundEmission::RotateMomentum(G4ParticleMomentum Pa,
G4ParticleMomentum V,
G4ParticleMomentum P) const
G4double G4PreCompoundEmission::rho(const G4double p, const G4double h, const G4double g,
const G4double E, const G4double Ef) const
{
G4ParticleMomentum U = Pa.unit();
G4double Alpha1 = U * V;
G4double Alpha2 = sqrt(V.mag2() - Alpha1*Alpha1);
G4double fact[30];
fact[0] = 1;
for (G4int n = 1; n < 21; n++) {
fact[n] = fact[n-1]*G4double(n);
}
G4double aph = (p*p + h*h + p - 3.0*h)/(4.0*g);
G4double tot = 0.0;
for (G4int j = 0; j <= h; j++) {
G4double t1 = pow(-1.0, G4double(j));
G4double t2 = fact[j]/ (fact[G4int(h)-j]*fact[G4int(h)]);
G4double t3 = E - G4double(j)*Ef - aph;
if (t3 < 0.0) t3 = 0.0;
t3 = pow(t3,p+h-1);
tot += t1*t2*t3;
}
tot *= pow(g,p+h)/(fact[G4int(p)]*fact[G4int(h)]*fact[G4int(p+h)-1]);
G4ThreeVector N = (1./Alpha2)*U.cross(V);
G4ParticleMomentum RotatedMomentum(
( (V.x() - Alpha1*U.x())/Alpha2 ) * P.x() + N.x() * P.y() + U.x() * P.z(),
( (V.y() - Alpha1*U.y())/Alpha2 ) * P.x() + N.y() * P.y() + U.y() * P.z(),
( (V.z() - Alpha1*U.z())/Alpha2 ) * P.x() + N.z() * P.y() + U.z() * P.z()
);
return RotatedMomentum;
return tot;
}
G4double G4PreCompoundEmission::bessi0(const G4double x) const
// Returns the modified Bessel function I_0(x) for any real x.
{
G4double ax,ans;
G4double y;
if ((ax=fabs(x)) < 3.75) { /* Polynomial fit. */
y=x/3.75;
y*=y;
ans=1.0+y*(3.5156229+y*(3.0899424+
y*(1.2067492+
y*(0.2659732+
y*(0.360768e-1+
y*0.45813e-2)))));
} else {
y=3.75/ax;
ans=(exp(ax)/sqrt(ax))*(0.39894228+y*(0.1328592e-1+
y*(0.225319e-2+
y*(-0.157565e-2+
y*(0.916281e-2+
y*(-0.2057706e-1+
y*(0.2635537e-1+
y*(-0.1647633e-1+
y*0.392377e-2))))))));
}
return ans;
}
source/processes/hadronic/models/generator/pre_equilibrium/src/G4PreCompoundFragmentVector.cc
+100 -59
View File
@@ -1,3 +1,32 @@
//
// ********************************************************************
// * 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.cc,v 1.3.2.1 2001/06/28 19:13:35 gunter Exp $
// GEANT4 tag $Name: $
//
// Hadronic Process: Nuclear Preequilibrium
// by V. Lara
#include "G4PreCompoundFragmentVector.hh"
#include "G4PreCompoundNeutron.hh"
@@ -8,32 +37,42 @@
#include "G4PreCompoundAlpha.hh"
G4PreCompoundFragmentVector::G4PreCompoundFragmentVector() :
TotalEmissionProbability(0.0)
TotalEmissionProbability(0.0)
{
// theChannels.reserve(6)
// neutron
theChannels.insert(new G4PreCompoundNeutron());
// theChannels.insert(new G4PreCompoundNeutron());
theChannels.push_back(new G4PreCompoundNeutron());
// proton
theChannels.insert(new G4PreCompoundProton());
// theChannels.insert(new G4PreCompoundProton());
theChannels.push_back(new G4PreCompoundProton());
// deuterium
theChannels.insert(new G4PreCompoundDeuteron());
// theChannels.insert(new G4PreCompoundDeuteron());
theChannels.push_back(new G4PreCompoundDeuteron());
// triton
theChannels.insert(new G4PreCompoundTriton());
// theChannels.insert(new G4PreCompoundTriton());
theChannels.push_back(new G4PreCompoundTriton());
// helium3
theChannels.insert(new G4PreCompoundHe3());
// theChannels.insert(new G4PreCompoundHe3());
theChannels.push_back(new G4PreCompoundHe3());
// alpha
theChannels.insert(new G4PreCompoundAlpha());
// theChannels.insert(new G4PreCompoundAlpha());
theChannels.push_back(new G4PreCompoundAlpha());
}
G4PreCompoundFragmentVector::~G4PreCompoundFragmentVector()
{
theChannels.clearAndDestroy();
// theChannels.clearAndDestroy();
for (G4std::vector<G4VPreCompoundFragment*>::iterator i=theChannels.begin();
i != theChannels.end(); i++) delete *i;
theChannels.clear();
}
const G4PreCompoundFragmentVector & G4PreCompoundFragmentVector::operator=(const G4PreCompoundFragmentVector &right)
{
G4Exception("G4PreCompoundFragmentVector::operator= meant to not be accessable");
return *this;
G4Exception("G4PreCompoundFragmentVector::operator= meant to not be accessable");
return *this;
}
@@ -51,62 +90,64 @@ G4bool G4PreCompoundFragmentVector::operator!=(const G4PreCompoundFragmentVector
G4double G4PreCompoundFragmentVector::CalculateProbabilities(const G4Fragment & aFragment)
{
TotalEmissionProbability = 0.0;
for (G4int i = 0; i < theChannels.entries(); i++) {
theChannels(i)->CalcExcitonLevelDensityRatios(aFragment.GetNumberOfExcitons(),
aFragment.GetNumberOfParticles());
theChannels(i)->CalcCondensationProbability(aFragment.GetA());
// Calculate emission probailities
if (aFragment.GetNumberOfParticles() <= theChannels(i)->GetA()-0.01) {
// if number of particles less than a fragment atomic number
// set probability to emit a fragment 0
theChannels(i)->SetEmissionProbability(0.0);
} else if (aFragment.GetNumberOfExcitons() <= theChannels(i)->GetA()+0.01 &&
aFragment.GetNumberOfExcitons() != 1) {
theChannels(i)->SetEmissionProbability(0.0);
} else if (aFragment.GetNumberOfCharged() <= theChannels(i)->GetZ()-0.01) {
// if number of charged particles (protons) is less than charge of fragment
// set probability to emit a fragment 0
theChannels(i)->SetEmissionProbability(0.0);
} else if (theChannels(i)->GetMaximalKineticEnergy() <= 0.0) {
// if the energy threshold for emitted fragment is less or equal 0
// set probability to emit a fragment 0
theChannels(i)->SetEmissionProbability(0.0);
} else {
// Compute total (integrated over kinetic energy) emission
// probability of a fragment and
// Summing channel emission probabilities
TotalEmissionProbability += theChannels(i)->CalcEmissionProbability(aFragment);
}
}
return TotalEmissionProbability;
TotalEmissionProbability = 0.0;
G4std::vector<G4VPreCompoundFragment*>::iterator aChannel;
for (aChannel=theChannels.begin(); aChannel != theChannels.end(); aChannel++) {
(*aChannel)->CalcExcitonLevelDensityRatios(aFragment.GetNumberOfExcitons(),
aFragment.GetNumberOfParticles());
(*aChannel)->CalcCondensationProbability(aFragment.GetA());
// Calculate emission probailities
if (aFragment.GetNumberOfParticles() <= (*aChannel)->GetA()-0.01) {
// if number of particles less than a fragment atomic number
// set probability to emit a fragment 0
(*aChannel)->SetEmissionProbability(0.0);
} else if (aFragment.GetNumberOfExcitons() <= (*aChannel)->GetA()+0.01 &&
aFragment.GetNumberOfExcitons() != 1) {
(*aChannel)->SetEmissionProbability(0.0);
} else if (aFragment.GetNumberOfCharged() <= (*aChannel)->GetZ()-0.01) {
// if number of charged particles (protons) is less than charge of fragment
// set probability to emit a fragment 0
(*aChannel)->SetEmissionProbability(0.0);
} else if ((*aChannel)->GetMaximalKineticEnergy() <= 0.0) {
// if the energy threshold for emitted fragment is less or equal 0
// set probability to emit a fragment 0
(*aChannel)->SetEmissionProbability(0.0);
} else {
// Compute total (integrated over kinetic energy) emission
// probability of a fragment and
// Summing channel emission probabilities
TotalEmissionProbability += (*aChannel)->CalcEmissionProbability(aFragment);
}
}
return TotalEmissionProbability;
}
G4VPreCompoundFragment * G4PreCompoundFragmentVector::ChooseFragment(void)
{
const G4int NumOfFrags = theChannels.entries();
G4double * running = new G4double[NumOfFrags];
running[0] = theChannels(0)->GetEmissionProbability();
G4int i;
for (i = 1; i < NumOfFrags; i++) {
running[i]=running[i-1]+theChannels(i)->GetEmissionProbability();
}
const G4int NumOfFrags = theChannels.size();
G4double * running = new G4double[NumOfFrags];
running[0] = (*theChannels.begin())->GetEmissionProbability();
// G4std::vector<G4VPreCompoundFragment*>::iterator aChannel;
G4int i;
for (i = 1; i < NumOfFrags; i++) {
running[i]=running[i-1]+theChannels[i]->GetEmissionProbability();
}
// Choose an emission channel
G4double aChannel = G4UniformRand()*TotalEmissionProbability;
G4int ChosenChannel = -1;
for (i = 0; i < NumOfFrags; i++) {
if (aChannel <= running[i]) {
ChosenChannel = i;
break;
}
}
delete [] running;
if (ChosenChannel < 0)
G4Exception("G4PreCompoundFragmentVector::ChooseFragment: I can't determine a channel");
// Choose an emission channel
G4double aChannel = G4UniformRand()*TotalEmissionProbability;
G4int ChosenChannel = -1;
for (i = 0; i < NumOfFrags; i++) {
if (aChannel <= running[i]) {
ChosenChannel = i;
break;
}
}
delete [] running;
if (ChosenChannel < 0)
G4Exception("G4PreCompoundFragmentVector::ChooseFragment: I can't determine a channel");
return theChannels(ChosenChannel);
return theChannels[ChosenChannel];
}
source/processes/hadronic/models/generator/pre_equilibrium/src/G4PreCompoundModel.cc
+145 -67
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.cc,v 1.11.2.1 2001/06/28 19:13:35 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#include "G4PreCompoundModel.hh"
@@ -13,8 +31,8 @@
const G4PreCompoundModel & G4PreCompoundModel::operator=(const G4PreCompoundModel &right)
{
G4Exception("G4PreCompoundModel::operator= meant to not be accessable");
return *this;
G4Exception("G4PreCompoundModel::operator= meant to not be accessable");
return *this;
}
@@ -48,10 +66,10 @@ G4VParticleChange * G4PreCompoundModel::ApplyYourself(const G4Track & thePrimary
anInitialState.SetZ(aZ);
// Number of Excitons
anInitialState.SetNumberOfExcitons(thePrimary.GetDynamicParticle()->GetDefinition()->GetBaryonNumber());
// Number of Excited Particles
anInitialState.SetNumberOfParticles(thePrimary.GetDynamicParticle()->GetDefinition()->GetBaryonNumber());
// Number of Charged
// Number of Charged Excited Particles
anInitialState.SetNumberOfCharged(thePrimary.GetDynamicParticle()->GetDefinition()->GetPDGCharge());
// Number of Holes
@@ -82,9 +100,9 @@ G4VParticleChange * G4PreCompoundModel::ApplyYourself(const G4Track & thePrimary
for(G4int i=0; i<result->length(); i++)
{
G4DynamicParticle * aNew =
new G4DynamicParticle(result->at(i)->GetDefinition(),
result->at(i)->GetTotalEnergy(),
result->at(i)->GetMomentum());
new G4DynamicParticle(result->at(i)->GetDefinition(),
result->at(i)->GetTotalEnergy(),
result->at(i)->GetMomentum());
delete result->at(i);
theResult.AddSecondary(aNew);
}
@@ -101,70 +119,77 @@ G4VParticleChange * G4PreCompoundModel::ApplyYourself(const G4Track & thePrimary
G4ReactionProductVector* G4PreCompoundModel::DeExcite(const G4Fragment & theInitialState) const
{
G4ReactionProductVector * Result = new G4ReactionProductVector;
G4ReactionProductVector * Result = new G4ReactionProductVector;
// Copy of the initial state
G4Fragment aFragment(theInitialState);
// Copy of the initial state
G4Fragment aFragment(theInitialState);
// Main loop. It is performed until equilibrium deexcitation.
for (;;) {
G4PreCompoundEmission aEmission;
// Initialize fragment according with the nucleus parameters
aEmission.Initialize(aFragment);
G4PreCompoundEmission aEmission(theInitialState);
// Main loop. It is performed until equilibrium deexcitation.
for (;;) {
// Initialize fragment according with the nucleus parameters
aEmission.Initialize(aFragment);
// Equilibrium exciton number
G4double EquilibriumExcitonNumber =
sqrt(1.19*G4PreCompoundParameters::GetAddress()->GetLevelDensity()*aFragment.GetA()*
aFragment.GetExcitationEnergy()+0.5);
// Equilibrium exciton number
G4double EquilibriumExcitonNumber =
sqrt(1.19*G4PreCompoundParameters::GetAddress()->GetLevelDensity()*aFragment.GetA()*
aFragment.GetExcitationEnergy()+0.5);
// Loop for transitions, it is performed while there are preequilibrium transitions.
G4bool ThereIsTransition = false;
do {
if (aFragment.GetNumberOfExcitons() < EquilibriumExcitonNumber) {
if (aFragment.GetNumberOfParticles() < 1) {
aFragment.SetNumberOfHoles(aFragment.GetNumberOfHoles()+1);
aFragment.SetNumberOfExcitons(aFragment.GetNumberOfExcitons()+2);
}
// Loop for transitions, it is performed while there are preequilibrium transitions.
G4bool ThereIsTransition = false;
do {
if (aFragment.GetNumberOfExcitons() < EquilibriumExcitonNumber) {
// if (aFragment.GetNumberOfParticles() < 1) {
// aFragment.SetNumberOfHoles(aFragment.GetNumberOfHoles()+1);
// aFragment.SetNumberOfParticles(aFragment.GetNumberOfParticles()+1);
// }
G4double TotalEmissionProbability = aEmission.GetTotalProbability(aFragment);
G4double TotalEmissionProbability = aEmission.GetTotalProbability(aFragment);
// Check if number of excitons is greater than 0
// else perform equilibrium emission
if (aFragment.GetNumberOfExcitons() <= 0) {
// Perform Equilibrium Emission
PerformEquilibriumEmission(aFragment,Result);
return Result;
}
// Check if number of excitons is greater than 0
// else perform equilibrium emission
if (aFragment.GetNumberOfExcitons() <= 0) {
// Perform Equilibrium Emission
#ifdef debug
CheckConservation(theInitialState,aFragment,Result);
#endif
PerformEquilibriumEmission(aFragment,Result);
return Result;
}
G4PreCompoundTransitions aTransition(aFragment);
G4PreCompoundTransitions aTransition(aFragment);
// Sum of transition probabilities
G4double TotalTransitionProbability = aTransition.GetTotalProbability();
// Sum of transition probabilities
G4double TotalTransitionProbability = aTransition.GetTotalProbability();
// Sum of all probabilities
G4double TotalProbability = TotalEmissionProbability + TotalTransitionProbability;
// Sum of all probabilities
G4double TotalProbability = TotalEmissionProbability + TotalTransitionProbability;
// Select subprocess
if (G4UniformRand() > TotalEmissionProbability/TotalProbability) {
// It will be transition to state with a new number of excitons
ThereIsTransition = true;
// Select subprocess
if (G4UniformRand() > TotalEmissionProbability/TotalProbability) {
// It will be transition to state with a new number of excitons
ThereIsTransition = true;
// Perform the transition
aFragment = aTransition.PerformTransition(aFragment);
} else {
// It will be fragment emission
ThereIsTransition = false;
// Perform the transition
aFragment = aTransition.PerformTransition(aFragment);
} else {
// It will be fragment emission
ThereIsTransition = false;
// Perform the emission and Add emitted fragment to Result
Result->insert(aEmission.PerformEmission(aFragment));
}
} else {
// Perform Equilibrium Emission
PerformEquilibriumEmission(aFragment,Result);
return Result;
}
} while (ThereIsTransition); // end of do loop
} // end of for (;;) loop
// Perform the emission and Add emitted fragment to Result
Result->insert(aEmission.PerformEmission(aFragment));
}
} else {
// Perform Equilibrium Emission
#ifdef debug
CheckConservation(theInitialState,aFragment,Result);
#endif
PerformEquilibriumEmission(aFragment,Result);
return Result;
}
} while (ThereIsTransition); // end of do loop
} // end of for (;;) loop
}
@@ -173,8 +198,8 @@ G4ReactionProductVector* G4PreCompoundModel::DeExcite(const G4Fragment & theInit
void G4PreCompoundModel::PerformEquilibriumEmission(const G4Fragment & aFragment,
G4ReactionProductVector * Result) const
{
G4ReactionProductVector * theEquilibriumResult;
theEquilibriumResult = GetExcitationHandler()->BreakItUp(aFragment);
G4ReactionProductVector * theEquilibriumResult;
theEquilibriumResult = GetExcitationHandler()->BreakItUp(aFragment);
while (theEquilibriumResult->entries() > 0) Result->insert(theEquilibriumResult->removeFirst());
@@ -183,4 +208,57 @@ void G4PreCompoundModel::PerformEquilibriumEmission(const G4Fragment & aFragment
}
#ifdef debug
void G4PreCompoundModel::CheckConservation(const G4Fragment & theInitialState,
const G4Fragment & aFragment,
G4ReactionProductVector * Result) const
{
G4double ProductsEnergy = aFragment.GetMomentum().e();
G4ThreeVector ProductsMomentum = aFragment.GetMomentum();
G4int ProductsA = G4int(aFragment.GetA());
G4int ProductsZ = G4int(aFragment.GetZ());
for (G4int h = 0; h < Result->entries(); h++) {
ProductsEnergy += Result->at(h)->GetTotalEnergy();
ProductsMomentum += Result->at(h)->GetMomentum();
ProductsA += G4int(Result->at(h)->GetDefinition()->GetBaryonNumber());
ProductsZ += G4int(Result->at(h)->GetDefinition()->GetPDGCharge());
}
if (ProductsA != theInitialState.GetA()) {
G4cout << "!!!!!!!!!! Baryonic Number Conservation Violation !!!!!!!!!!" << G4endl;
G4cout << "G4PreCompoundModel.cc: Barionic Number Conservation test for just preequilibrium fragments"
<< G4endl;
G4cout << "Initial A = " << theInitialState.GetA()
<< " Fragments A = " << ProductsA << " Diference --> "
<< theInitialState.GetA() - ProductsA << G4endl;
}
if (ProductsZ != theInitialState.GetZ()) {
G4cout << "!!!!!!!!!! Charge Conservation Violation !!!!!!!!!!" << G4endl;
G4cout << "G4PreCompoundModel.cc: Charge Conservation test for just preequilibrium fragments"
<< G4endl;
G4cout << "Initial Z = " << theInitialState.GetZ()
<< " Fragments Z = " << ProductsZ << " Diference --> "
<< theInitialState.GetZ() - ProductsZ << G4endl;
}
if (abs(ProductsEnergy-theInitialState.GetMomentum().e()) > 1.0*keV) {
G4cout << "!!!!!!!!!! Energy Conservation Violation !!!!!!!!!!" << G4endl;
G4cout << "G4PreCompoundModel.cc: Energy Conservation test for just preequilibrium fragments"
<< G4endl;
G4cout << "Initial E = " << theInitialState.GetMomentum().e()/MeV << " MeV"
<< " Fragments E = " << ProductsEnergy/MeV << " MeV Diference --> "
<< (theInitialState.GetMomentum().e() - ProductsEnergy)/MeV << " MeV" << G4endl;
}
if (abs(ProductsMomentum.x()-theInitialState.GetMomentum().x()) > 1.0*keV ||
abs(ProductsMomentum.y()-theInitialState.GetMomentum().y()) > 1.0*keV ||
abs(ProductsMomentum.z()-theInitialState.GetMomentum().z()) > 1.0*keV) {
G4cout << "!!!!!!!!!! Momentum Conservation Violation !!!!!!!!!!" << G4endl;
G4cout << "G4PreCompoundModel.cc: Momentum Conservation test for just preequilibrium fragments"
<< G4endl;
G4cout << "Initial P = " << theInitialState.GetMomentum().vect() << " MeV"
<< " Fragments P = " << ProductsMomentum << " MeV Diference --> "
<< theInitialState.GetMomentum().vect() - ProductsMomentum << " MeV" << G4endl;
}
return;
}
#endif
source/processes/hadronic/models/generator/pre_equilibrium/src/G4PreCompoundNeutron.cc
+59 -43
View File
@@ -1,63 +1,79 @@
// 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.cc,v 1.7.2.1 2001/06/28 19:13:35 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#include "G4PreCompoundNeutron.hh"
G4double G4PreCompoundNeutron::ProbabilityDistributionFunction(const G4double & eKin,
const G4Fragment & aFragment)
const G4Fragment & aFragment)
{
const G4double r0 = 1.5*fermi;
// g = 0.595*a*A
const G4double g = 0.595*G4PreCompoundParameters::GetAddress()->GetLevelDensity()*GetRestA();
G4double Alpha = 0.76+2.2/pow(GetRestA(),1.0/3.0);
G4double Beta = (2.12/pow(GetRestA(),2.0/3.0)-0.05)*MeV/Alpha;
if ( (aFragment.GetNumberOfParticles()-aFragment.GetNumberOfCharged()) < 1)
return 0.0;
const G4double r0 = G4PreCompoundParameters::GetAddress()->Getr0();
// g = 0.595*a*A
const G4double g = 0.595*G4PreCompoundParameters::GetAddress()->GetLevelDensity()*GetRestA();
G4double Alpha = 0.76+2.2/pow(GetRestA(),1.0/3.0);
G4double Beta = (2.12/pow(GetRestA(),2.0/3.0)-0.05)*MeV/Alpha;
G4double Probability = 2.0/(pi*hbarc*hbarc*hbarc) * GetReducedMass() * Alpha *
r0 * r0 * pow(GetRestA(),2.0/3.0) *
GetExcitonLevelDensityRatio()/(g*aFragment.GetExcitationEnergy()) *
pow((1.0 - (eKin+GetBindingEnergy())/aFragment.GetExcitationEnergy()),
(aFragment.GetNumberOfExcitons()-2.0))*(eKin + Beta);
// G4double Probability = 0.000234*r0*r0*pow(GetRestA(),2.0/3.0)*Alpha*GetExcitonLevelDensityRatio()/
// (SingleParticleLevelDensity*aFragment.GetExcitationEnergy())*
// pow((1.0 - (eKin+GetBindingEnergy())/aFragment.GetExcitationEnergy()),
// (aFragment.GetNumberOfExcitons()-2.0))*(eKin + Beta);
return Probability;
G4double Probability = 2.0/(pi*hbarc*hbarc*hbarc) * GetReducedMass() * Alpha *
r0 * r0 * pow(GetRestA(),2.0/3.0) *
GetExcitonLevelDensityRatio()/(g*aFragment.GetExcitationEnergy()) *
pow((1.0 - (eKin+GetBindingEnergy())/aFragment.GetExcitationEnergy()),
(aFragment.GetNumberOfExcitons()-2.0))*(eKin + Beta);
return Probability;
}
G4double G4PreCompoundNeutron::GetKineticEnergy(const G4Fragment & aFragment)
{
G4double Beta = (2.12/pow(GetRestA(),2.0/3.0)-0.05)*MeV/(0.76+2.2/pow(GetRestA(),1.0/3.0));
G4double Beta = (2.12/pow(GetRestA(),2.0/3.0)-0.05)*MeV/(0.76+2.2/pow(GetRestA(),1.0/3.0));
G4double T = aFragment.GetNumberOfParticles() + aFragment.GetNumberOfHoles() - GetA() - 1.0;
G4double R2 = GetMaximalKineticEnergy();
G4double R1 = R2 + GetCoulombBarrier();
G4double T = aFragment.GetNumberOfParticles() + aFragment.GetNumberOfHoles() - GetA() - 1.0;
G4double R2 = GetMaximalKineticEnergy();
G4double R1 = R2 + GetCoulombBarrier();
G4double E = 0.0;
G4double E = 0.0;
if (T <= -0.1) {
E = R1;
} else if (T <= 0.1) {
E = -Beta + sqrt(Beta*Beta + (G4UniformRand()*(R2*R2 + 2.0*Beta*R2)));
} else {
G4double E1 = (R1 - Beta*T)/(T + 1.0);
G4double T3 = 0.0;
do {
E = GetCoulombBarrier()+G4UniformRand()*R2;
G4double T1 = (E + Beta)/(E1 + Beta);
G4double T2 = (R1 - E)/(R1 - E1);
T3 = T1*pow(T2,T);
} while (G4UniformRand() > T3);
}
return E;
if (T <= -0.1) {
E = R1;
} else if (T <= 0.1) {
E = -Beta + sqrt(Beta*Beta + (G4UniformRand()*(R2*R2 + 2.0*Beta*R2)));
} else {
G4double E1 = (R1 - Beta*T)/(T + 1.0);
G4double T3 = 0.0;
do {
E = GetCoulombBarrier()+G4UniformRand()*R2;
G4double T1 = (E + Beta)/(E1 + Beta);
G4double T2 = (R1 - E)/(R1 - E1);
T3 = T1*pow(T2,T);
} while (G4UniformRand() > T3);
}
return E;
}
source/processes/hadronic/models/generator/pre_equilibrium/src/G4PreCompoundParameters.cc
+23 -5
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.cc,v 1.4.2.1 2001/06/28 19:13:35 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#include "G4PreCompoundParameters.hh"
source/processes/hadronic/models/generator/pre_equilibrium/src/G4PreCompoundProton.cc
+70 -63
View File
@@ -1,46 +1,62 @@
// 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.cc,v 1.6.2.1 2001/06/28 19:13:35 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#include "G4PreCompoundProton.hh"
G4double G4PreCompoundProton::ProbabilityDistributionFunction(const G4double & eKin,
const G4Fragment & aFragment)
const G4Fragment & aFragment)
{
const G4double r0 = 1.5*fermi;
// g = 0.595*a*A;
const G4double g = 0.595*G4PreCompoundParameters::GetAddress()->GetLevelDensity()*GetRestA();
// G4double R0J=1.2;
if (aFragment.GetNumberOfCharged() < 1) return 0.0;
G4double aZ = G4double(GetRestZ());
G4double C = 0.0;
if (aZ >= 70) {
C = 0.10;
} else {
C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
}
const G4double r0 = G4PreCompoundParameters::GetAddress()->Getr0();
// g = 0.595*a*A;
const G4double g = 0.595*G4PreCompoundParameters::GetAddress()->GetLevelDensity()*GetRestA();
// G4double R0J=1.2;
G4double aZ = G4double(GetRestZ());
G4double C = 0.0;
if (aZ >= 70) {
C = 0.10;
} else {
C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
}
G4double alpha = 1.0 + C;
G4double beta = -GetCoulombBarrier();
G4double XSinv = alpha * (1.0 + beta/eKin) * r0 * r0 * pow(GetRestA(),2.0/3.0);
G4double Probability = 2.0/(pi*hbarc*hbarc*hbarc) * GetReducedMass() *
(1.0 + C) * r0 * r0 * pow(GetRestA(),2.0/3.0) *
GetExcitonLevelDensityRatio()/(g*aFragment.GetExcitationEnergy()) *
pow(1.0 - (eKin+GetBindingEnergy())/aFragment.GetExcitationEnergy(),
(aFragment.GetNumberOfExcitons()-2.0))*
(eKin - GetCoulombBarrier());
// G4double Probability = 0.000234*r0*r0*pow(GetRestA(),2.0/3.0)*R0J*GetExcitonLevelDensityRatio()/
// (SingleParticleLevelDensity*aFragment.GetExcitationEnergy())*
// pow(1.0 - (eKin+GetBindingEnergy())/aFragment.GetExcitationEnergy(),
// (aFragment.GetNumberOfExcitons()-2.0))*(eKin - GetCoulombBarrier());
G4double Probability = 2.0/(pi*hbarc*hbarc*hbarc) * GetReducedMass() *
XSinv * // CalcCorrection() *
GetExcitonLevelDensityRatio()/(g*aFragment.GetExcitationEnergy()) *
pow(1.0 - (eKin+GetBindingEnergy())/aFragment.GetExcitationEnergy(),
(aFragment.GetNumberOfExcitons()-2.0))*
(eKin - GetCoulombBarrier());
return Probability;
return Probability;
}
@@ -48,44 +64,35 @@ G4double G4PreCompoundProton::ProbabilityDistributionFunction(const G4double & e
G4double G4PreCompoundProton::GetKineticEnergy(const G4Fragment & aFragment)
{
G4double DJ = - GetCoulombBarrier();
G4double DJ = - GetCoulombBarrier();
G4double T = aFragment.GetNumberOfParticles() + aFragment.GetNumberOfHoles() - GetA() - 1.0;
G4double R2 = GetMaximalKineticEnergy();
G4double R1 = R2 + GetCoulombBarrier();
G4double T = aFragment.GetNumberOfParticles() + aFragment.GetNumberOfHoles() - GetA() - 1.0;
G4double R2 = GetMaximalKineticEnergy();
G4double R1 = R2 + GetCoulombBarrier();
G4double E = 0.0;
G4double E = 0.0;
if (T <= -0.1) {
E = R1;
} else if (T <= 0.1) {
E = sqrt(G4UniformRand())*R2 + GetCoulombBarrier();
} else {
G4double E1 = (R1 - DJ*T)/(T + 1.0);
G4double T3 = 0.0;
do {
E = GetCoulombBarrier() + G4UniformRand()*R2;
G4double T1 = (E + DJ)/(E1 + DJ);
G4double T2 = (R1 - E)/(R1 - E1);
T3 = T1*pow(T2,T);
} while (G4UniformRand() > T3);
}
return E;
}
G4double G4PreCompoundProton::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;
if (T <= -0.1) {
E = R1;
} else if (T <= 0.1) {
do {
E = sqrt(G4UniformRand())*R2;
} while (E < GetCoulombBarrier());
} else {
G4double E1 = (R1 - DJ*T)/(T + 1.0);
G4double T3 = 0.0;
do {
E = GetCoulombBarrier() + G4UniformRand()*R2;
G4double T1 = (E + DJ)/(E1 + DJ);
G4double T2 = (R1 - E)/(R1 - E1);
T3 = T1*pow(T2,T);
} while (G4UniformRand() > T3);
}
return E;
}
source/processes/hadronic/models/generator/pre_equilibrium/src/G4PreCompoundTransitions.cc
+68 -37
View File
@@ -1,23 +1,48 @@
// 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.cc,v 1.6.2.1 2001/06/28 19:13:35 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#include "G4PreCompoundTransitions.hh"
#include "G4EvaporationLevelDensityParameter.hh"
#include "G4PairingCorrection.hh"
G4PreCompoundTransitions::
G4PreCompoundTransitions(const G4Fragment & aFragment)
{
// Fermi energy
const G4double FermiEnergy = 45.0*MeV;
//
const G4double r0 = 0.6*fermi;
const G4double FermiEnergy = G4PreCompoundParameters::GetAddress()->GetFermiEnergy();
// Nuclear radius
const G4double r0 = G4PreCompoundParameters::GetAddress()->GetTransitionsr0();
// In order to calculate the level density parameter
G4EvaporationLevelDensityParameter theLDP;
// Number of holes
G4double H = aFragment.GetNumberOfHoles();
@@ -26,9 +51,13 @@ G4PreCompoundTransitions(const G4Fragment & aFragment)
// Number of Excitons
G4double N = P+H;
// Nucleus
G4double A = aFragment.GetA();
G4double Z = aFragment.GetZ();
G4double U = aFragment.GetExcitationEnergy();
// Relative Energy (T_{rel})
G4double RelativeEnergy = (8.0/5.0)*FermiEnergy + aFragment.GetExcitationEnergy()/N;
G4double RelativeEnergy = (8.0/5.0)*FermiEnergy + U/N;
// Relative Velocity:
// <V_{rel}>^2
@@ -61,8 +90,9 @@ G4PreCompoundTransitions(const G4Fragment & aFragment)
if (TransitionProb1 < 0.0) TransitionProb1 = 0.0;
// g = 0.595aA; GE = g*E where E is Excitation Energy
G4double GE = 0.595*G4PreCompoundParameters::GetAddress()->GetLevelDensity()*
aFragment.GetA()*aFragment.GetExcitationEnergy();
G4double a = theLDP.LevelDensityParameter(A,Z,U-G4PairingCorrection::GetPairingCorrection(A,Z));
// G4double a = G4PreCompoundParameters::GetAddress()->GetLevelDensity();
G4double GE = 0.595*a*A*U;
// F(p,h) = 0.25*(p^2 + h^2 + p - h) - 0.5*h
@@ -70,7 +100,7 @@ G4PreCompoundTransitions(const G4Fragment & aFragment)
// F(p+1,h+1)
G4double Fph1 = Fph + N/2.0;
// (n+1)/n ((g*E - F(p,h))/(g*E - F(p+1,h+1)))^(n+1)
G4double ProbFactor = pow((GE-Fph)/(GE-Fph1),N+1.0);
G4double ProbFactor = ((N+1.0)/N) * pow((GE-Fph)/(GE-Fph1),N+1.0);
// Transition probability for \Delta n = -2 (at F(p,h) = 0)
@@ -81,7 +111,7 @@ G4PreCompoundTransitions(const G4Fragment & aFragment)
// Transition probability for \Delta n = 0 (at F(p,h) = 0)
// TransitionProb3 = TransitionProb1*(P+H+1.0)*(P*(P-1.0)+4.0*P*H+H*(H-1.0))/((P+H)*GE);
TransitionProb3 = TransitionProb1 * ProbFactor * ((N+1.0)/N) *(P*(P-1.0) + 4.0*P*H + H*(H-1.0))/(GE-Fph);
TransitionProb3 = TransitionProb1 * ProbFactor * (P*(P-1.0) + 4.0*P*H + H*(H-1.0))/(GE-Fph);
if (TransitionProb3 < 0.0) TransitionProb3 = 0.0;
@@ -90,8 +120,8 @@ G4PreCompoundTransitions(const G4Fragment & aFragment)
const G4PreCompoundTransitions & G4PreCompoundTransitions::operator=(const G4PreCompoundTransitions &right)
{
G4Exception("G4PreCompoundTransitions::operator= meant to not be accessable");
return *this;
G4Exception("G4PreCompoundTransitions::operator= meant to not be accessable");
return *this;
}
@@ -110,25 +140,26 @@ G4bool G4PreCompoundTransitions::operator!=(const G4PreCompoundTransitions &righ
G4Fragment G4PreCompoundTransitions::PerformTransition(const G4Fragment & aFragment)
{
G4Fragment result(aFragment);
G4double ChosenTransition = G4UniformRand()*this->GetTotalProbability();
G4int deltaN = 0;
if (ChosenTransition <= TransitionProb1)
{
// Number of excitons is increased on \Delta n = +2
deltaN = 2;
}
else if (ChosenTransition <= TransitionProb1+TransitionProb2)
{
// Number of excitons is increased on \Delta n = -2
deltaN = -2;
}
result.SetNumberOfExcitons(result.GetNumberOfExcitons()+deltaN);
result.SetNumberOfHoles(result.GetNumberOfHoles()+deltaN/2);
// With weight Z/A, number of charged particles is decreased on +1
if ((deltaN > 0 || result.GetNumberOfCharged() > 0) &&
(G4UniformRand() <= result.GetZ()/result.GetA())){
result.SetNumberOfCharged(result.GetNumberOfCharged()+deltaN/2);
}
return result;
G4Fragment result(aFragment);
G4double ChosenTransition = G4UniformRand()*this->GetTotalProbability();
G4int deltaN = 0;
if (ChosenTransition <= TransitionProb1)
{
// Number of excitons is increased on \Delta n = +2
deltaN = 2;
}
else if (ChosenTransition <= TransitionProb1+TransitionProb2)
{
// Number of excitons is increased on \Delta n = -2
deltaN = -2;
}
result.SetNumberOfParticles(result.GetNumberOfParticles()+deltaN/2);
result.SetNumberOfHoles(result.GetNumberOfHoles()+deltaN/2);
// With weight Z/A, number of charged particles is decreased on +1
if ((deltaN > 0 || result.GetNumberOfCharged() > 0) &&
(G4UniformRand() <= result.GetZ()/result.GetA())){
result.SetNumberOfCharged(result.GetNumberOfCharged()+deltaN/2);
}
return result;
}
source/processes/hadronic/models/generator/pre_equilibrium/src/G4VPreCompoundFragment.cc
+139 -113
View File
@@ -1,36 +1,66 @@
// 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.cc,v 1.8.2.1 2001/06/28 19:13:35 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#include "G4VPreCompoundFragment.hh"
#include "G4ios.hh"
G4VPreCompoundFragment::G4VPreCompoundFragment(const G4VPreCompoundFragment & right)
{
theA = right.theA;
theZ = right.theZ;
theRestNucleusA = right.theRestNucleusA;
theRestNucleusZ = right.theRestNucleusZ;
theCoulombBarrier = right.theCoulombBarrier;
theMaximalKineticEnergy = right.theMaximalKineticEnergy;
theExcitonLevelDensityRatio = right.theExcitonLevelDensityRatio;
theEmissionProbability = right.theEmissionProbability;
theCondensationProbability = right.theCondensationProbability;
theMomentum = right.theMomentum;
theA = right.theA;
theZ = right.theZ;
theRestNucleusA = right.theRestNucleusA;
theRestNucleusZ = right.theRestNucleusZ;
theCoulombBarrier = right.theCoulombBarrier;
theCoulombBarrierPtr = right.theCoulombBarrierPtr;
theMaximalKineticEnergy = right.theMaximalKineticEnergy;
theExcitonLevelDensityRatio = right.theExcitonLevelDensityRatio;
theEmissionProbability = right.theEmissionProbability;
theCondensationProbability = right.theCondensationProbability;
theMomentum = right.theMomentum;
theFragmentName = right.theFragmentName;
}
G4VPreCompoundFragment::G4VPreCompoundFragment(const G4double anA, const G4double aZ):
theA(anA),theZ(aZ),theRestNucleusA(0.0),theRestNucleusZ(0.0),theCoulombBarrier(0.0),
theMaximalKineticEnergy(-1.0),theExcitonLevelDensityRatio(0.0),theEmissionProbability(0.0),
theCondensationProbability(0.0),theMomentum(0.0,0.0,0.0,0.0)
G4VPreCompoundFragment::G4VPreCompoundFragment(const G4double anA,
const G4double aZ, G4VCoulombBarrier* aCoulombBarrier):
theA(anA),theZ(aZ), theCoulombBarrierPtr(aCoulombBarrier),
theRestNucleusA(0.0),theRestNucleusZ(0.0),theCoulombBarrier(0.0),
theMaximalKineticEnergy(-1.0),theExcitonLevelDensityRatio(0.0),theEmissionProbability(0.0),
theCondensationProbability(0.0),theMomentum(0.0,0.0,0.0,0.0),theFragmentName("No Name")
{}
G4VPreCompoundFragment::G4VPreCompoundFragment(const G4double anA,
const G4double aZ, G4VCoulombBarrier* aCoulombBarrier,
const G4String & aName):
theA(anA),theZ(aZ), theCoulombBarrierPtr(aCoulombBarrier),
theRestNucleusA(0.0),theRestNucleusZ(0.0),theCoulombBarrier(0.0),
theMaximalKineticEnergy(-1.0),theExcitonLevelDensityRatio(0.0),theEmissionProbability(0.0),
theCondensationProbability(0.0),theMomentum(0.0,0.0,0.0,0.0),theFragmentName(aName)
{}
@@ -43,60 +73,61 @@ G4VPreCompoundFragment::~G4VPreCompoundFragment()
const G4VPreCompoundFragment & G4VPreCompoundFragment::operator=
(const G4VPreCompoundFragment & right)
{
if (this != &right) {
theA = right.theA;
theZ = right.theZ;
theRestNucleusA = right.theRestNucleusA;
theRestNucleusZ = right.theRestNucleusZ;
theCoulombBarrier = right.theCoulombBarrier;
theMaximalKineticEnergy = right.theMaximalKineticEnergy;
theExcitonLevelDensityRatio = right.theExcitonLevelDensityRatio;
theEmissionProbability = right.theEmissionProbability;
theCondensationProbability = right.theCondensationProbability;
theMomentum = right.theMomentum;
}
return *this;
if (this != &right) {
theA = right.theA;
theZ = right.theZ;
theRestNucleusA = right.theRestNucleusA;
theRestNucleusZ = right.theRestNucleusZ;
theCoulombBarrier = right.theCoulombBarrier;
theCoulombBarrierPtr = right.theCoulombBarrierPtr;
theMaximalKineticEnergy = right.theMaximalKineticEnergy;
theExcitonLevelDensityRatio = right.theExcitonLevelDensityRatio;
theEmissionProbability = right.theEmissionProbability;
theCondensationProbability = right.theCondensationProbability;
theMomentum = right.theMomentum;
}
return *this;
}
G4int G4VPreCompoundFragment::operator==(const G4VPreCompoundFragment & right) const
{
return (this == (G4VPreCompoundFragment *) &right);
return (this == (G4VPreCompoundFragment *) &right);
}
G4int G4VPreCompoundFragment::operator!=(const G4VPreCompoundFragment & right) const
{
return (this != (G4VPreCompoundFragment *) &right);
return (this != (G4VPreCompoundFragment *) &right);
}
G4std::ostream& operator << (G4std::ostream &out, const G4VPreCompoundFragment &theFragment)
{
out << &theFragment;
return out;
out << &theFragment;
return out;
}
G4std::ostream& operator << (G4std::ostream &out, const G4VPreCompoundFragment *theFragment)
{
long old_floatfield = out.setf(0,G4std::ios::floatfield);
long old_floatfield = out.setf(0,G4std::ios::floatfield);
out
<< "PreCompound Model Emitted Fragment: A = " << G4std::setprecision(3) << theFragment->theA
<< ", Z = " << G4std::setprecision(3) << theFragment->theZ;
out.setf(G4std::ios::scientific, G4std::ios::floatfield);
// out
// << ", U = " << theFragment->theExcitationEnergy/MeV
// << " MeV" << endl
// << " P = ("
// << theFragment->theMomentum.x()/MeV << ","
// << theFragment->theMomentum.y()/MeV << ","
// << theFragment->theMomentum.z()/MeV
// << ") MeV E = "
// << theFragment->theMomentum.t()/MeV << " MeV";
out
<< "PreCompound Model Emitted Fragment: A = " << G4std::setprecision(3) << theFragment->theA
<< ", Z = " << G4std::setprecision(3) << theFragment->theZ;
out.setf(G4std::ios::scientific,G4std::ios::floatfield);
// out
// << ", U = " << theFragment->theExcitationEnergy/MeV
// << " MeV" << endl
// << " P = ("
// << theFragment->theMomentum.x()/MeV << ","
// << theFragment->theMomentum.y()/MeV << ","
// << theFragment->theMomentum.z()/MeV
// << ") MeV E = "
// << theFragment->theMomentum.t()/MeV << " MeV";
out.setf(old_floatfield,G4std::ios::floatfield);
out.setf(old_floatfield,G4std::ios::floatfield);
return out;
return out;
}
@@ -104,56 +135,46 @@ G4std::ostream& operator << (G4std::ostream &out, const G4VPreCompoundFragment *
void G4VPreCompoundFragment::Init(const G4Fragment & aFragment)
{
theRestNucleusA = aFragment.GetA() - theA;
theRestNucleusZ = aFragment.GetZ() - theZ;
theRestNucleusA = aFragment.GetA() - theA;
theRestNucleusZ = aFragment.GetZ() - theZ;
if ((theRestNucleusA < theRestNucleusZ) ||
(theRestNucleusA < theA) ||
(theRestNucleusZ < theZ)) {
// In order to be sure that emission probability will be 0.
theMaximalKineticEnergy = 0.0;
return;
}
if ((theRestNucleusA < theRestNucleusZ) ||
(theRestNucleusA < theA) ||
(theRestNucleusZ < theZ)) {
// In order to be sure that emission probability will be 0.
theMaximalKineticEnergy = 0.0;
return;
}
// Compute nuclear radius (needed to calculate Coulomb barrier)
G4double NuclearRadius = 2.173*fermi*
(1.0+0.006103*theZ*theRestNucleusZ)/(1.0+0.009443*theZ*theRestNucleusZ);
// Calculate Coulomb barrier
theCoulombBarrier = CalcCoulombBarrier(NuclearRadius,theRestNucleusZ);
// Calculate Coulomb barrier
theCoulombBarrier = theCoulombBarrierPtr->
GetCoulombBarrier(theRestNucleusA,theRestNucleusZ,
aFragment.GetExcitationEnergy());
// Compute Binding Energies for fragments
// (needed to separate a fragment from the nucleus)
// Compute Binding Energies for fragments
// (needed to separate a fragment from the nucleus)
theBindingEnergy = G4NucleiProperties::GetMassExcess(theA,theZ) +
G4NucleiProperties::GetMassExcess(theRestNucleusA,theRestNucleusZ) -
G4NucleiProperties::GetMassExcess(aFragment.GetA(),aFragment.GetZ());
theBindingEnergy = G4NucleiProperties::GetMassExcess(theA,theZ) +
G4NucleiProperties::GetMassExcess(theRestNucleusA,theRestNucleusZ) -
G4NucleiProperties::GetMassExcess(aFragment.GetA(),aFragment.GetZ());
// Compute Maximal Kinetic Energy which can be carried by fragments after separation
theMaximalKineticEnergy = aFragment.GetExcitationEnergy() -
(theBindingEnergy + theCoulombBarrier);
// Compute Maximal Kinetic Energy which can be carried by fragments after separation
// theMaximalKineticEnergy = aFragment.GetExcitationEnergy() -
// (theBindingEnergy + theCoulombBarrier);
return;
}
G4double m = aFragment.GetMomentum().m();
G4double rm = GetRestNuclearMass();
G4double em = GetNuclearMass();
theMaximalKineticEnergy = ((m - rm)*(m + rm) + em*em)/(2.0*m) - em - theCoulombBarrier;
G4double G4VPreCompoundFragment::CalcCoulombBarrier(const G4double NucRad, const G4double aZ)
// Calculation of Coulomb potential energy (barrier) for outgoing particles
{
// for neutron
G4double Barrier;
if (GetZ() == 0) {
Barrier = 0.0;
} else {
Barrier = (elm_coupling/NucRad)*((theZ*theRestNucleusZ)/
(pow(theA,1.0/3.0)+pow(theRestNucleusA,1.0/3.0)));
Barrier *= GetBarrierPenetrationFactor(aZ);
}
return Barrier;
return;
}
G4double G4VPreCompoundFragment::CalcEmissionProbability(const G4Fragment & aFragment)
{
if (GetMaximalKineticEnergy() <= 0.0) return 0.0;
if (GetMaximalKineticEnergy() <= 0.0) return 0.0;
// Coulomb barrier is the lower limit
// of integration over kinetic energy
@@ -172,30 +193,35 @@ G4double G4VPreCompoundFragment::
IntegrateEmissionProbability(const G4double & Low, const G4double & Up,
const G4Fragment & aFragment)
{
static const G4double w[8] = {0.1012285363,
0.2223810345,
0.3137066459,
0.3626837834,
0.3626837834,
0.3137066459,
0.2223810345,
0.1012285363};
static const G4double w[8] = {0.1012285363,
0.2223810345,
0.3137066459,
0.3626837834,
0.3626837834,
0.3137066459,
0.2223810345,
0.1012285363
};
static const G4double FIKS[8] = {0.9602898565,
0.7966664774,
0.5255324099,
0.1834346425,
-0.1834346425,
-0.5255324099,
-0.7966664774,
-0.9602898565};
static const G4double FIKS[8] = { 0.9602898565,
0.7966664774,
0.5255324099,
0.1834346425,
-0.1834346425,
-0.5255324099,
-0.7966664774,
-0.9602898565
};
G4double Total = 0.0;
for (G4int i = 0; i < 8; i++) {
G4double KineticE = ((Up-Low)*FIKS[i]+(Up+Low))/2.0;
Total += w[i]*ProbabilityDistributionFunction(KineticE, aFragment)*(Up-Low)/2.0;
}
return Total;
G4double Total = 0.0;
for (G4int i = 0; i < 8; i++) {
G4double KineticE = ((Up-Low)*FIKS[i]+(Up+Low))/2.0;
Total += w[i]*ProbabilityDistributionFunction(KineticE, aFragment)*(Up-Low)/2.0;
}
return Total;
}
source/processes/hadronic/models/generator/pre_equilibrium/src/G4VPreCompoundIon.cc
+100 -77
View File
@@ -1,105 +1,128 @@
// 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.cc,v 1.8.2.1 2001/06/28 19:13:36 gunter Exp $
// GEANT4 tag $Name: $
//
// by V. Lara
#include "G4VPreCompoundIon.hh"
G4double G4VPreCompoundIon::ProbabilityDistributionFunction(const G4double & eKin,
const G4Fragment & aFragment)
const G4Fragment & aFragment)
{
const G4double r0 = 1.5*fermi;
G4double exEnergy = aFragment.GetExcitationEnergy();
G4double B = GetBindingEnergy();
G4int pplus = aFragment.GetNumberOfCharged();
G4int pneut = aFragment.GetNumberOfParticles()-pplus;
if (pneut < (GetA()-GetZ()) || pplus < GetZ()) return 0.0;
G4double Z = aFragment.GetZ();
G4double C = GetCCoef(Z);
const G4double r0 = G4PreCompoundParameters::GetAddress()->Getr0();
G4double exEnergy = aFragment.GetExcitationEnergy();
G4double B = GetBindingEnergy();
G4double probA = (3.0/4.0)*sqrt(2.0/GetReducedMass())*(1.0+C)*GetExcitonLevelDensityRatio()*
GetCondensationProbability()*(eKin - GetCoulombBarrier())/
(r0*pow(GetRestA(),1.0/3.0)*exEnergy*sqrt(eKin+B));
G4double Z = aFragment.GetZ();
G4double C = GetCCoef(Z);
G4double base = 1.0 + B/exEnergy;
G4double exponent = GetA() - 1.0;
if (exponent > 100.0 && base < 1.0) return 0.0;
G4double probB = pow(base,exponent);
G4double probA = (3.0/4.0)*sqrt(2.0/GetReducedMass())*(1.0+C)*GetExcitonLevelDensityRatio()*
GetCondensationProbability()*(eKin - GetCoulombBarrier())/
(r0*pow(GetRestA(),1.0/3.0)*exEnergy*sqrt(eKin+B));
base = 1.0 - ((eKin+B)/exEnergy);
exponent = aFragment.GetNumberOfExcitons() - 1.0 - GetA();
if (exponent > 100.0 && base < 1.0) return 0.0;
G4double probC = pow(base,exponent);
G4double base = 1.0 + B/exEnergy;
G4double exponent = GetA() - 1.0;
if (exponent > 100.0 && base < 1.0) return 0.0;
G4double probB = pow(base,exponent);
base = 1.0 - ((eKin+B)/exEnergy);
exponent = aFragment.GetNumberOfExcitons() - 1.0 - GetA();
if (exponent > 100.0 && base < 1.0) return 0.0;
G4double probC = pow(base,exponent);
G4double prob = probA * probB * probC;
G4double prob = probA * probB * probC;
// G4double R0J = 1.1;
// G4double probA = GetCondensationProbability()*R0J*0.104/
// (r0*pow(GetRestA(),1.0/3.0)*sqrt(GetA()*exEnergy));
// G4double probB = GetExcitonLevelDensityRatio()*((eKin-GetCoulombBarrier())/exEnergy);
// G4double ratio = (eKin+GetBindingEnergy())/exEnergy;
// G4double exponent = GetRestA()-1.5;
// if ( exponent>100. && ratio<1. ) return 0.;
// G4double probC = pow( ratio, exponent );
// G4double probD = pow( 1.0 - ratio,
// aFragment.GetNumberOfExcitons()-GetA()-1.0 );
// G4double prob = probA*probB*probC*probD;
// G4double R0J = 1.1;
// G4double probA = GetCondensationProbability()*R0J*0.104/
// (r0*pow(GetRestA(),1.0/3.0)*sqrt(GetA()*exEnergy));
// G4double probB = GetExcitonLevelDensityRatio()*((eKin-GetCoulombBarrier())/exEnergy);
// G4double ratio = (eKin+GetBindingEnergy())/exEnergy;
// G4double exponent = GetRestA()-1.5;
// if ( exponent>100. && ratio<1. ) return 0.;
// G4double probC = pow( ratio, exponent );
// G4double probD = pow( 1.0 - ratio,
// aFragment.GetNumberOfExcitons()-GetA()-1.0 );
// G4double prob = probA*probB*probC*probD;
if (prob < 1.e-100) return 0.;
else return prob;
if (prob < 1.e-100) return 0.;
else return prob;
}
G4double G4VPreCompoundIon::GetKineticEnergy(const G4Fragment & aFragment)
{
G4double DJ = - GetCoulombBarrier();
G4double DJ = - GetCoulombBarrier();
G4double T = aFragment.GetNumberOfParticles() + aFragment.GetNumberOfHoles() - GetA() - 1.0;
G4double R2 = GetMaximalKineticEnergy();
G4double R1 = R2 + GetCoulombBarrier();
G4double T = aFragment.GetNumberOfParticles() + aFragment.GetNumberOfHoles() - GetA() - 1.0;
G4double R2 = GetMaximalKineticEnergy();
G4double R1 = R2 + GetCoulombBarrier();
G4double E = 0.0;
G4double E = 0.0;
if (T <= -0.1) E = R1;
else if (T <= 0.1) {
G4double E1 = R1;
G4double T3 = 0.0;
do {
G4double PJ1 = GetA() - 1.5;
G4double AbsBindingE = abs(GetBindingEnergy());
if (GetBindingEnergy() <= 0.0 && AbsBindingE > GetCoulombBarrier()) {
E = AbsBindingE + G4UniformRand()*aFragment.GetExcitationEnergy();
} else {
E = GetCoulombBarrier() + G4UniformRand()*R2;
}
T3 = pow((E+GetBindingEnergy())/(E1+GetBindingEnergy()),PJ1)*((E+DJ)/(E1+DJ));
} while (G4UniformRand() > T3);
} else {
G4double PJ1 = GetA() - 1.5;
G4double ES = aFragment.GetExcitationEnergy()*(GetA()-0.5)+
(aFragment.GetExcitationEnergy()-R2)*(aFragment.GetNumberOfParticles()+
if (T <= -0.1) E = R1;
else if (T <= 0.1) {
G4double E1 = R1;
G4double T3 = 0.0;
do {
G4double PJ1 = GetA() - 1.5;
G4double AbsBindingE = abs(GetBindingEnergy());
if (GetBindingEnergy() <= 0.0 && AbsBindingE > GetCoulombBarrier()) {
E = AbsBindingE + G4UniformRand()*aFragment.GetExcitationEnergy();
} else {
E = GetCoulombBarrier() + G4UniformRand()*R2;
}
T3 = pow((E+GetBindingEnergy())/(E1+GetBindingEnergy()),PJ1)*((E+DJ)/(E1+DJ));
} while (G4UniformRand() > T3);
} else {
G4double PJ1 = GetA() - 1.5;
G4double ES = aFragment.GetExcitationEnergy()*(GetA()-0.5)+
(aFragment.GetExcitationEnergy()-R2)*(aFragment.GetNumberOfParticles()+
aFragment.GetNumberOfHoles()-2.5);
G4double E1 = (ES + sqrt(ES*ES-(aFragment.GetExcitationEnergy()-R2)*(GetA()-1.5)*
(aFragment.GetNumberOfParticles()+aFragment.GetNumberOfHoles()-1.5)*
4.0*aFragment.GetExcitationEnergy()))/
((aFragment.GetNumberOfParticles()+aFragment.GetNumberOfHoles()-1.5)*2.0)
- aFragment.GetExcitationEnergy() + R1;
G4double E = 0.0;
G4double T3 = 0.0;
do {
if (GetBindingEnergy() <= 0.0 && abs(GetBindingEnergy()) > GetCoulombBarrier()) {
E = abs(GetBindingEnergy()) + G4UniformRand()*(aFragment.GetExcitationEnergy());
} else {
E = GetCoulombBarrier() + G4UniformRand()*R2;
}
T3 = (pow((E + GetBindingEnergy())/(E1 + GetBindingEnergy()),PJ1)*
((E+DJ)/(E1+DJ))) * pow((R1-E)/(R1-E1),T);
} while (G4UniformRand() > T3);
}
return E;
G4double E1 = (ES + sqrt(ES*ES-(aFragment.GetExcitationEnergy()-R2)*(GetA()-1.5)*
(aFragment.GetNumberOfParticles()+aFragment.GetNumberOfHoles()-1.5)*
4.0*aFragment.GetExcitationEnergy()))/
((aFragment.GetNumberOfParticles()+aFragment.GetNumberOfHoles()-1.5)*2.0)
- aFragment.GetExcitationEnergy() + R1;
//
G4double T3 = 0.0;
do {
if (GetBindingEnergy() <= 0.0 && abs(GetBindingEnergy()) > GetCoulombBarrier()) {
E = abs(GetBindingEnergy()) + G4UniformRand()*(aFragment.GetExcitationEnergy());
} else {
E = GetCoulombBarrier() + G4UniformRand()*R2;
}
T3 = (pow((E + GetBindingEnergy())/(E1 + GetBindingEnergy()),PJ1)*
((E+DJ)/(E1+DJ))) * pow((R1-E)/(R1-E1),T);
} while (G4UniformRand() > T3);
}
return E;
}