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

Import Geant4 0.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-01 15:25:35 +02:00
parent 54d6b71f95
commit b97f8d0df7
3237 changed files with 807095 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/GNUmakefile
+31
View File
@@ -0,0 +1,31 @@
# $Id: GNUmakefile,v 2.5 1998/11/06 18:03:59 hpw Exp $
# --------------------------------------------------------------
# GNUmakefile for hadronic models library. G.Folger 10-Dec-97
# --------------------------------------------------------------
name := G4hadronic_models
SUBDIRS = low_energy
SUBDIRS += high_energy
SUBDIRS += neutron_hp
SUBDIRS += generator/de_excitation
SUBDIRS += generator/diffractive_string
SUBDIRS += generator/high_energy
SUBDIRS += generator/kinetic_model
SUBDIRS += generator/management
SUBDIRS += generator/pre_equilibrium
SUBDIRS += generator/quark_gluon_string
SUBDIRS += generator/string_common
SUBDIRS += generator/string_fragmentation
SUBDIRS += generator/util
SUBLIBS = G4hadronic_HE G4hadronic_LE G4hadronic_neu
SUBLIBS += G4hadronic_deex G4hadronic_diffstring G4hadronic_HE_gen G4hadronic_kinetic
SUBLIBS += G4hadronic_man_gen G4hadronic_preequ G4hadronic_qgstring G4hadronic_string_common
SUBLIBS += G4hadronic_stringfrag G4hadronic_util_gen
ifndef G4INSTALL
G4INSTALL = ../../../..
endif
include $(G4INSTALL)/config/globlib.gmk
source/processes/hadronic/models/generator/GNUmakefile
+18
View File
@@ -0,0 +1,18 @@
# $Id: GNUmakefile,v 2.3 1998/11/06 18:03:59 hpw Exp $
# ----------------------------------------------------------------
# GNUmakefile for hadronic processes library. G.Folger 10-Dec-97.
# ----------------------------------------------------------------
name := G4hadronic_gen
SUBDIRS = de_excitation diffractive_string high_energy kinetic_model management
SUBDIRS += string_common string_fragmentation util pre_equilibrium quark_gluon_string
SUBLIBS = G4hadronic_deex G4hadronic_diffstring G4hadronic_HE_gen G4hadronic_kinetic
SUBLIBS += G4hadronic_man_gen G4hadronic_preequ G4hadronic_qgstring G4hadronic_string_common
SUBLIBS += G4hadronic_stringfrag G4hadronic_util_gen
ifndef G4INSTALL
G4INSTALL = ../../../../..
endif
include $(G4INSTALL)/config/globlib.gmk
source/processes/hadronic/models/generator/History
+21
View File
@@ -0,0 +1,21 @@
$Id: History,v 2.0 1998/07/02 16:22:33 gunter Exp $
-------------------------------------------------------------------
=========================================================
Geant4 - an Object-Oriented Toolkit for Simulation in HEP
=========================================================
Hadronics/models/Generator History file
---------------------------------------
This file should be used by G4 developers to briefly summarize all major
modifications introduced in the code and keep track of all tags.
It DOES NOT substitute the CVS log-message one should put at every
committal in the CVS repository !
----------------------------------------------------------
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
GF 12-May-98: Add more functions to G4Fancy3DNucleus:
doLorentzContraction with algorithm given by Nicolai
give access to all nucleons with a RWTPtrOrederedVector
Required a mod to G4Nucleon, ie. add operator ==
source/processes/hadronic/models/generator/de_excitation/GNUmakefile
+39
View File
@@ -0,0 +1,39 @@
# $Id: GNUmakefile,v 1.1 1998/08/22 09:07:55 hpw Exp $
# -----------------------------------------------------------
# GNUmakefile for hadronic library. Gabriele Cosmo, 18/9/96.
# -----------------------------------------------------------
name := G4hadronic_deex
ifndef G4INSTALL
G4INSTALL = ../../../../../..
endif
include $(G4INSTALL)/config/architecture.gmk
G4TMPDIR = $(G4TMP)/$(G4SYSTEM)/$(name)
CPPFLAGS += -I$(G4BASE)/global/management/include \
-I$(G4BASE)/global/HEPRandom/include \
-I$(G4BASE)/global/HEPNumerics/include \
-I$(G4BASE)/global/HEPGeometry/include \
-I$(G4BASE)/track/include \
-I$(G4BASE)/geometry/volumes/include \
-I$(G4BASE)/geometry/management/include \
-I$(G4BASE)/processes/management/include \
-I$(G4BASE)/processes/hadronic/management/include/ \
-I$(G4BASE)/processes/hadronic/util/include \
-I$(G4BASE)/processes/hadronic/processes/include \
-I$(G4BASE)/processes/hadronic/cross_sections/include \
-I$(G4BASE)/processes/hadronic/models/generator/util/include \
-I$(G4BASE)/particles/management/include \
-I$(G4BASE)/particles/leptons/include \
-I$(G4BASE)/particles/bosons/include \
-I$(G4BASE)/particles/hadrons/mesons/include \
-I$(G4BASE)/particles/hadrons/barions/include \
-I$(G4BASE)/particles/hadrons/ions/include \
-I$(G4BASE)/particles/shortlived/include \
-I$(G4BASE)/materials/include
include $(G4INSTALL)/config/common.gmk
source/processes/hadronic/models/generator/de_excitation/include/G4B9FermiFragment.hh
+44
View File
@@ -0,0 +1,44 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4B9FermiFragment_h
#define G4B9FermiFragment_h 1
#include "G4UnstableFermiFragment.hh"
#include "G4IonTable.hh"
class G4B9FermiFragment : public G4UnstableFermiFragment
{
public:
G4B9FermiFragment(const G4int anA, const G4int aZ, const G4int Pol, const G4double ExE):
G4UnstableFermiFragment(anA,aZ,Pol,ExE)
{};
~G4B9FermiFragment();
private:
G4B9FermiFragment();
G4B9FermiFragment(const G4B9FermiFragment &right);
const G4B9FermiFragment & operator=(const G4B9FermiFragment &right);
G4bool operator==(const G4B9FermiFragment &right) const;
G4bool operator!=(const G4B9FermiFragment &right) const;
public:
G4FragmentVector * GetFragment(const G4LorentzVector & aMomentum);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4Be8FermiFragment.hh
+43
View File
@@ -0,0 +1,43 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4Be8FermiFragment_h
#define G4Be8FermiFragment_h 1
#include "G4UnstableFermiFragment.hh"
#include "G4IonTable.hh"
class G4Be8FermiFragment : public G4UnstableFermiFragment
{
public:
G4Be8FermiFragment(const G4int anA, const G4int aZ, const G4int Pol, const G4double ExE):
G4UnstableFermiFragment(anA,aZ,Pol,ExE)
{};
~G4Be8FermiFragment();
private:
G4Be8FermiFragment();
G4Be8FermiFragment(const G4Be8FermiFragment &right);
const G4Be8FermiFragment & operator=(const G4Be8FermiFragment &right);
G4bool operator==(const G4Be8FermiFragment &right) const;
G4bool operator!=(const G4Be8FermiFragment &right) const;
public:
G4FragmentVector * GetFragment(const G4LorentzVector & aMomentum);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4CompetitiveFission.hh
+146
View File
@@ -0,0 +1,146 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
#ifndef G4CompetitiveFission_h
#define G4CompetitiveFission_h 1
#include "G4VEvaporationChannel.hh"
#include "G4Fragment.hh"
#include "G4VFissionBarrier.hh"
#include "G4FissionBarrier.hh"
#include "G4VEmissionProbability.hh"
#include "G4FissionProbability.hh"
#include "G4VLevelDensityParameter.hh"
#include "G4FissionLevelDensityParameter.hh"
#include "G4FissionParameters.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include "Randomize.hh"
class G4CompetitiveFission : public G4VEvaporationChannel
{
public:
G4CompetitiveFission();
virtual ~G4CompetitiveFission();
private:
G4CompetitiveFission(const G4CompetitiveFission &right);
const G4CompetitiveFission & operator=(const G4CompetitiveFission &right);
public:
G4bool operator==(const G4CompetitiveFission &right) const;
G4bool operator!=(const G4CompetitiveFission &right) const;
public:
G4FragmentVector * BreakUp(const G4Fragment &theNucleus);
void Initialize(const G4Fragment & fragment);
inline void SetFissionBarrier(G4VFissionBarrier * aBarrier)
{
if (MyOwnFissionBarrier) delete theFissionBarrierPtr;
theFissionBarrierPtr = aBarrier;
MyOwnFissionBarrier = false;
}
inline void SetEmissionStrategy(G4VEmissionProbability * aFissionProb)
{
if (MyOwnFissionProbability) delete theFissionProbabilityPtr;
theFissionProbabilityPtr = aFissionProb;
MyOwnFissionProbability = false;
}
inline void SetLevelDensityParameter(G4VLevelDensityParameter * aLevelDensity)
{
if (MyOwnLevelDensity) delete theLevelDensityPtr;
theLevelDensityPtr = aLevelDensity;
MyOwnLevelDensity = false;
}
inline G4double GetFissionBarrier(void) const { return FissionBarrier; }
inline G4double GetEmissionProbability(void) const { return FissionProbability; }
inline G4double GetLevelDensityParameter(void) const { return LevelDensityParameter; }
inline G4double GetMaximalKineticEnergy(void) const { return MaximalKineticEnergy; }
private:
// Maximal Kinetic Energy that can be carried by fragment
G4double MaximalKineticEnergy;
// For Fission barrier
G4VFissionBarrier * theFissionBarrierPtr;
G4double FissionBarrier;
G4bool MyOwnFissionBarrier;
// For Fission probability emission
G4VEmissionProbability * theFissionProbabilityPtr;
G4double FissionProbability;
G4bool MyOwnFissionProbability;
// For Level Density calculation
G4bool MyOwnLevelDensity;
G4VLevelDensityParameter * theLevelDensityPtr;
G4double LevelDensityParameter;
// --------------------
// Sample AtomicNumber of Fission products
G4int FissionAtomicNumber(const G4int A, const G4FissionParameters & theParam);
G4double MassDistribution(const G4double x, const G4double A, const G4FissionParameters & theParam);
// Sample Charge of fission products
G4int FissionCharge(const G4double A, const G4double Z, const G4double Af);
// Sample Kinetic energy of fission products
G4double FissionKineticEnergy(const G4double A, const G4double Z,
const G4double Af1, const G4double Zf1,
const G4double Af2, const G4double Zf2,
const G4double U, const G4double Tmax,
const G4FissionParameters & theParam);
G4double Ratio(const G4double A,const G4double A11,const G4double B1,const G4double A00);
G4double SymmetricRatio(const G4double A,const G4double A11);
G4double AsymmetricRatio(const G4double A,const G4double A11);
G4ThreeVector IsotropicVector(const G4double Magnitude = 1.0);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4ConstantLevelDensityParameter.hh
+42
View File
@@ -0,0 +1,42 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations (photon evaporation)
// by C. Dallapiccola (Nov 1998)
//
#ifndef G4ConstantLevelDensityParameter_h
#define G4ConstantLevelDensityParameter_h 1
#include "G4VLevelDensityParameter.hh"
class G4ConstantLevelDensityParameter : public G4VLevelDensityParameter
{
public:
G4ConstantLevelDensityParameter() : EvapLevelDensityParameter(0.125*(1./MeV)) {};
virtual ~G4ConstantLevelDensityParameter() {};
private:
G4ConstantLevelDensityParameter(const G4ConstantLevelDensityParameter &right);
const G4ConstantLevelDensityParameter & operator=(const G4ConstantLevelDensityParameter &right);
G4bool operator==(const G4ConstantLevelDensityParameter &right) const;
G4bool operator!=(const G4ConstantLevelDensityParameter &right) const;
public:
G4double LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const
{return A * EvapLevelDensityParameter;}
private:
const G4double EvapLevelDensityParameter;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4ContinuumGammaDeexcitation.hh
+67
View File
@@ -0,0 +1,67 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4ContinuumGammaDeexcitation
//
// Authors: Carlo Dallapiccola (dallapiccola@umdhep.umd.edu)
// Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
//
//
// Class G4ContinuumGammaDeexcitation.hh
//
#ifndef G4ContinuumGammaDeexcitation_hh
#define G4ContinuumGammaDeexcitation_hh
#include "G4VGammaDeexcitation.hh"
#include "globals.hh"
#include "G4ContinuumGammaTransition.hh"
#include "G4Fragment.hh"
#include "G4NuclearLevelManager.hh"
class G4ContinuumGammaDeexcitation : public G4VGammaDeexcitation
{
public:
// Constructor
G4ContinuumGammaDeexcitation();
// Destructor
~G4ContinuumGammaDeexcitation();
// Functions
public:
virtual G4VGammaTransition* CreateTransition();
virtual G4bool CanDoTransition() const;
private:
G4int _Z;
G4int _A;
G4NuclearLevelManager _levelManager;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4ContinuumGammaTransition.hh
+70
View File
@@ -0,0 +1,70 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4ContinuumGammaTransition
//
// Authors: Carlo Dallapiccola (dallapiccola@umdhep.umd.edu)
// Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
//
// Header file for G4ContinuumGammaTransition
//
#ifndef G4ContinuumGammaTransition_hh
#define G4ContinuumGammaTransition_hh
#include "globals.hh"
#include "G4VGammaTransition.hh"
#include "G4NuclearLevelManager.hh"
#include "G4VLevelDensityParameter.hh"
class G4ContinuumGammaTransition : public G4VGammaTransition
{
public:
// Constructor
G4ContinuumGammaTransition(const G4NuclearLevelManager& levelManager,
G4int Z, G4int A, G4double excitation, G4int verbose);
// Destructor
~G4ContinuumGammaTransition();
// Functions
virtual G4double GammaEnergy();
virtual G4double GetEnergyTo() const;
virtual void SetEnergyFrom(const G4double energy);
private:
G4double E1Pdf(G4double energy);
G4int _A;
G4int _Z;
G4double _eMin;
G4double _eMax;
G4double _maxLevelE;
G4double _minLevelE;
G4double _excitation;
G4double _eGamma;
G4NuclearLevelManager _levelManager;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4DiscreteGammaDeexcitation.hh
+62
View File
@@ -0,0 +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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4DiscreteGammaDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
//
#ifndef G4DiscreteGammaDeexcitation_hh
#define G4DiscreteGammaDeexcitation_hh
#include "G4VGammaDeexcitation.hh"
#include "globals.hh"
#include "G4DiscreteGammaTransition.hh"
#include "G4Fragment.hh"
#include "G4NuclearLevelManager.hh"
class G4DiscreteGammaDeexcitation : public G4VGammaDeexcitation
{
public:
// Constructor
G4DiscreteGammaDeexcitation();
// Destructor
~G4DiscreteGammaDeexcitation();
// Functions
public:
virtual G4VGammaTransition* CreateTransition();
virtual G4bool CanDoTransition() const;
private:
G4int _Z;
G4int _A;
G4double _tolerance;
G4NuclearLevelManager _levelManager;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4DiscreteGammaTransition.hh
+58
View File
@@ -0,0 +1,58 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4DiscreteGammaTransition
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4DiscreteGammaTransition_hh
#define G4DiscreteGammaTransition_hh
#include "globals.hh"
#include "G4VGammaTransition.hh"
#include "G4NuclearLevel.hh"
class G4DiscreteGammaTransition : public G4VGammaTransition
{
public:
// Constructor
G4DiscreteGammaTransition(const G4NuclearLevel& level);
// Destructor
~G4DiscreteGammaTransition();
// Functions
public:
virtual G4double GammaEnergy();
virtual G4double GetEnergyTo() const;
virtual void SetEnergyFrom(const G4double energy);
private:
G4double _gammaEnergy;
G4NuclearLevel _level;
G4double _excitation;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4DummyMF.hh
+36
View File
@@ -0,0 +1,36 @@
// 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.
//
// $Id: G4DummyMF.hh,v 1.1 1998/08/22 08:53:34 hpw Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (May 1998)
#ifndef G4DummyMF_h
#define G4DummyMF_h 1
#include "G4MultiFragmentation.hh"
class G4DummyMF : public G4MultiFragmentation
{
public:
G4DummyMF();
~G4DummyMF();
private:
G4DummyMF(const G4DummyMF &right);
const G4DummyMF & operator=(const G4DummyMF &right);
int operator==(const G4DummyMF &right) const;
int operator!=(const G4DummyMF &right) const;
public:
G4FragmentVector * BreakItUp(const G4Fragment &theNucleus);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4DummyProbability.hh
+41
View File
@@ -0,0 +1,41 @@
//
//
#ifndef G4DummyProbability_hh
#define G4DummyProbability_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4DummyProbability : public G4VEmissionProbability
{
public:
G4DummyProbability() {};
~G4DummyProbability();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4DummyProbability() {};
G4DummyProbability(const G4DummyProbability& right);
const G4DummyProbability& operator=(const G4DummyProbability& right);
G4bool operator==(const G4DummyProbability& right) const;
G4bool operator!=(const G4DummyProbability& right) const;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1Probability.hh
+44
View File
@@ -0,0 +1,44 @@
//
//
#ifndef G4E1Probability_hh
#define G4E1Probability_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1Probability : public G4VEmissionProbability
{
public:
G4E1Probability() {};
~G4E1Probability();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1Probability() {};
G4E1Probability(const G4E1Probability& right);
const G4E1Probability& operator=(const G4E1Probability& right);
G4bool operator==(const G4E1Probability& right) const;
G4bool operator!=(const G4E1Probability& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1Probability001.hh
+44
View File
@@ -0,0 +1,44 @@
//
//
#ifndef G4E1Probability001_hh
#define G4E1Probability001_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1Probability001 : public G4VEmissionProbability
{
public:
G4E1Probability001() {};
~G4E1Probability001();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1Probability001() {};
G4E1Probability001(const G4E1Probability001& right);
const G4E1Probability001& operator=(const G4E1Probability001& right);
G4bool operator==(const G4E1Probability001& right) const;
G4bool operator!=(const G4E1Probability001& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1Probability01.hh
+44
View File
@@ -0,0 +1,44 @@
//
//
#ifndef G4E1Probability01_hh
#define G4E1Probability01_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1Probability01 : public G4VEmissionProbability
{
public:
G4E1Probability01() {};
~G4E1Probability01();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1Probability01() {};
G4E1Probability01(const G4E1Probability01& right);
const G4E1Probability01& operator=(const G4E1Probability01& right);
G4bool operator==(const G4E1Probability01& right) const;
G4bool operator!=(const G4E1Probability01& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1Probability10.hh
+44
View File
@@ -0,0 +1,44 @@
//
//
#ifndef G4E1Probability10_hh
#define G4E1Probability10_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1Probability10 : public G4VEmissionProbability
{
public:
G4E1Probability10() {};
~G4E1Probability10();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1Probability10() {};
G4E1Probability10(const G4E1Probability10& right);
const G4E1Probability10& operator=(const G4E1Probability10& right);
G4bool operator==(const G4E1Probability10& right) const;
G4bool operator!=(const G4E1Probability10& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1Probability100.hh
+44
View File
@@ -0,0 +1,44 @@
//
//
#ifndef G4E1Probability100_hh
#define G4E1Probability100_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1Probability100 : public G4VEmissionProbability
{
public:
G4E1Probability100() {};
~G4E1Probability100();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1Probability100() {};
G4E1Probability100(const G4E1Probability100& right);
const G4E1Probability100& operator=(const G4E1Probability100& right);
G4bool operator==(const G4E1Probability100& right) const;
G4bool operator!=(const G4E1Probability100& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1SingleProbability001.hh
+45
View File
@@ -0,0 +1,45 @@
//
//
#ifndef G4E1SingleProbability001_hh
#define G4E1SingleProbability001_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1SingleProbability001 : public G4VEmissionProbability
{
public:
G4E1SingleProbability001() {};
~G4E1SingleProbability001();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1SingleProbability001() {};
G4E1SingleProbability001(const G4E1SingleProbability001& right);
const G4E1SingleProbability001& operator=(const G4E1SingleProbability001&
right);
G4bool operator==(const G4E1SingleProbability001& right) const;
G4bool operator!=(const G4E1SingleProbability001& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1SingleProbability01.hh
+45
View File
@@ -0,0 +1,45 @@
//
//
#ifndef G4E1SingleProbability01_hh
#define G4E1SingleProbability01_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1SingleProbability01 : public G4VEmissionProbability
{
public:
G4E1SingleProbability01() {};
~G4E1SingleProbability01();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1SingleProbability01() {};
G4E1SingleProbability01(const G4E1SingleProbability01& right);
const G4E1SingleProbability01& operator=(const G4E1SingleProbability01&
right);
G4bool operator==(const G4E1SingleProbability01& right) const;
G4bool operator!=(const G4E1SingleProbability01& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1SingleProbability1.hh
+44
View File
@@ -0,0 +1,44 @@
//
//
#ifndef G4E1SingleProbability1_hh
#define G4E1SingleProbability1_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1SingleProbability1 : public G4VEmissionProbability
{
public:
G4E1SingleProbability1() {};
~G4E1SingleProbability1();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1SingleProbability1() {};
G4E1SingleProbability1(const G4E1SingleProbability1& right);
const G4E1SingleProbability1& operator=(const G4E1SingleProbability1& right);
G4bool operator==(const G4E1SingleProbability1& right) const;
G4bool operator!=(const G4E1SingleProbability1& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1SingleProbability10.hh
+45
View File
@@ -0,0 +1,45 @@
//
//
#ifndef G4E1SingleProbability10_hh
#define G4E1SingleProbability10_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1SingleProbability10 : public G4VEmissionProbability
{
public:
G4E1SingleProbability10() {};
~G4E1SingleProbability10();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1SingleProbability10() {};
G4E1SingleProbability10(const G4E1SingleProbability10& right);
const G4E1SingleProbability10& operator=(const G4E1SingleProbability10&
right);
G4bool operator==(const G4E1SingleProbability10& right) const;
G4bool operator!=(const G4E1SingleProbability10& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4E1SingleProbability100.hh
+45
View File
@@ -0,0 +1,45 @@
//
//
#ifndef G4E1SingleProbability100_hh
#define G4E1SingleProbability100_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
#include "G4VLevelDensityParameter.hh"
class G4E1SingleProbability100 : public G4VEmissionProbability
{
public:
G4E1SingleProbability100() {};
~G4E1SingleProbability100();
G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
private:
// G4E1SingleProbability100() {};
G4E1SingleProbability100(const G4E1SingleProbability100& right);
const G4E1SingleProbability100& operator=(const G4E1SingleProbability100&
right);
G4bool operator==(const G4E1SingleProbability100& right) const;
G4bool operator!=(const G4E1SingleProbability100& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
const G4double lowLim, const G4double upLim,
const G4int numIters);
// G4VLevelDensityParameter* _levelDensity; // Don't need this
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4Evaporation.hh
+135
View File
@@ -0,0 +1,135 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
#ifndef G4Evaporation_h
#define G4Evaporation_h 1
#include "globals.hh"
#include <rw/tvvector.h>
#include <rw/tpordvec.h>
#include "G4ios.hh"
#include "G4VEvaporation.hh"
#include "G4VEvaporationChannel.hh"
#include "G4EvaporationChannel.hh"
#include "G4CompetitiveFission.hh"
#include "G4PhotonEvaporation.hh"
#include "G4Fragment.hh"
#include "G4NucleiPropertiesTable.hh"
#include "G4NucleiProperties.hh"
#include "Randomize.hh"
class G4Evaporation : public G4VEvaporation
{
public:
G4Evaporation();
~G4Evaporation();
private:
G4Evaporation(const G4Evaporation &right);
const G4Evaporation & operator=(const G4Evaporation &right);
G4bool operator==(const G4Evaporation &right) const;
G4bool operator!=(const G4Evaporation &right) const;
public:
G4FragmentVector * BreakItUp(const G4Fragment &theNucleus);
private:
enum {TotNumberOfChannels = 34,
NumberOfFissionChannel = TotNumberOfChannels-2,
NumberOfGammaChannel = TotNumberOfChannels-1,
NumExcitedStates = 35};
// Excitation energy levels for each channel
RWTValVector<G4double> ExcitEnergyChann00; // n
RWTValVector<G4double> ExcitEnergyChann01; // p
RWTValVector<G4double> ExcitEnergyChann02; // deuteron
RWTValVector<G4double> ExcitEnergyChann03; // triton
RWTValVector<G4double> ExcitEnergyChann04; // He3
RWTValVector<G4double> ExcitEnergyChann05; // alpha
RWTValVector<G4double> ExcitEnergyChann06; // He5
RWTValVector<G4double> ExcitEnergyChann07; // He6
RWTValVector<G4double> ExcitEnergyChann08; // Li5
RWTValVector<G4double> ExcitEnergyChann09; // Li5
RWTValVector<G4double> ExcitEnergyChann10;
RWTValVector<G4double> ExcitEnergyChann11;
RWTValVector<G4double> ExcitEnergyChann12;
RWTValVector<G4double> ExcitEnergyChann13;
RWTValVector<G4double> ExcitEnergyChann14;
RWTValVector<G4double> ExcitEnergyChann15;
RWTValVector<G4double> ExcitEnergyChann16;
RWTValVector<G4double> ExcitEnergyChann17;
RWTValVector<G4double> ExcitEnergyChann18;
RWTValVector<G4double> ExcitEnergyChann19;
RWTValVector<G4double> ExcitEnergyChann20;
RWTValVector<G4double> ExcitEnergyChann21;
RWTValVector<G4double> ExcitEnergyChann22;
RWTValVector<G4double> ExcitEnergyChann23;
RWTValVector<G4double> ExcitEnergyChann24;
RWTValVector<G4double> ExcitEnergyChann25;
RWTValVector<G4double> ExcitEnergyChann26;
RWTValVector<G4double> ExcitEnergyChann27;
RWTValVector<G4double> ExcitEnergyChann28;
RWTValVector<G4double> ExcitEnergyChann29;
RWTValVector<G4double> ExcitEnergyChann30;
RWTValVector<G4double> ExcitEnergyChann31;
// Spin of excitation energy levels for each channel
RWTValVector<G4int> ExcitSpinChann00;
RWTValVector<G4int> ExcitSpinChann01;
RWTValVector<G4int> ExcitSpinChann02;
RWTValVector<G4int> ExcitSpinChann03;
RWTValVector<G4int> ExcitSpinChann04;
RWTValVector<G4int> ExcitSpinChann05;
RWTValVector<G4int> ExcitSpinChann06;
RWTValVector<G4int> ExcitSpinChann07;
RWTValVector<G4int> ExcitSpinChann08;
RWTValVector<G4int> ExcitSpinChann09;
RWTValVector<G4int> ExcitSpinChann10;
RWTValVector<G4int> ExcitSpinChann11;
RWTValVector<G4int> ExcitSpinChann12;
RWTValVector<G4int> ExcitSpinChann13;
RWTValVector<G4int> ExcitSpinChann14;
RWTValVector<G4int> ExcitSpinChann15;
RWTValVector<G4int> ExcitSpinChann16;
RWTValVector<G4int> ExcitSpinChann17;
RWTValVector<G4int> ExcitSpinChann18;
RWTValVector<G4int> ExcitSpinChann19;
RWTValVector<G4int> ExcitSpinChann20;
RWTValVector<G4int> ExcitSpinChann21;
RWTValVector<G4int> ExcitSpinChann22;
RWTValVector<G4int> ExcitSpinChann23;
RWTValVector<G4int> ExcitSpinChann24;
RWTValVector<G4int> ExcitSpinChann25;
RWTValVector<G4int> ExcitSpinChann26;
RWTValVector<G4int> ExcitSpinChann27;
RWTValVector<G4int> ExcitSpinChann28;
RWTValVector<G4int> ExcitSpinChann29;
RWTValVector<G4int> ExcitSpinChann30;
RWTValVector<G4int> ExcitSpinChann31;
G4VEvaporationChannel * theChannels[TotNumberOfChannels];
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4EvaporationChannel.hh
+199
View File
@@ -0,0 +1,199 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4EvaporationChannel_h
#define G4EvaporationChannel_h 1
#include "G4VEvaporationChannel.hh"
#include "G4VEmissionProbability.hh"
#include "G4EvaporationProbability.hh"
#include "G4VLevelDensityParameter.hh"
#include "G4EvaporationLevelDensityParameter.hh"
#include "G4NucleiProperties.hh"
#include "Randomize.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include <rw/tvvector.h>
class G4EvaporationChannel : public G4VEvaporationChannel
{
public:
// only available constructor
G4EvaporationChannel(const G4int theGamma,
const G4int theA,
const G4int theZ,
RWTValVector<G4double> * theExcitationEnergies,
RWTValVector<G4int> * theExcitationSpins);
// destructor
~G4EvaporationChannel();
private:
// default constructor
G4EvaporationChannel() {};
// copy constructor
G4EvaporationChannel(const G4EvaporationChannel & right);
const G4EvaporationChannel & operator=(const G4EvaporationChannel & right);
public:
G4bool operator==(const G4EvaporationChannel & right) const;
G4bool operator!=(const G4EvaporationChannel & right) const;
public:
void Initialize(const G4Fragment & fragment);
G4FragmentVector * BreakUp(const G4Fragment & theNucleus);
inline void SetEmissionStrategy(G4VEmissionProbability * aStrategy)
{
if (MyOwnEvaporationProbability) delete theEvaporationProbabilityPtr;
theEvaporationProbabilityPtr = aStrategy;
MyOwnEvaporationProbability = false;
}
inline void SetLevelDensityParameter(G4VLevelDensityParameter * aLevelDensity)
{
if (MyOwnLevelDensity) delete theLevelDensityPtr;
theLevelDensityPtr = aLevelDensity;
MyOwnLevelDensity = false;
}
inline G4double GetLevelDensityParameter(void) const { return LevelDensityParameter;}
private:
// This data member define the channel.
// They are intializated at object creation (constructor) time.
// Gamma is A_f(2S_f+1) factor, where A_f is fragment atomic number and S_f is fragment spin
G4int Gamma;
// Atomic Number
G4int A;
// Charge
G4int Z;
//
RWTValVector<G4double> * ExcitationEnergies;
//
RWTValVector<G4int> * ExcitationSpins;
// For evaporation probability calcualtion
G4bool MyOwnEvaporationProbability;
G4VEmissionProbability * theEvaporationProbabilityPtr;
// For Level Density calculation
G4bool MyOwnLevelDensity;
G4VLevelDensityParameter * theLevelDensityPtr;
G4double LevelDensityParameter;
//---------------------------------------------------
// This values depends on the nucleus that is being evaporated.
// They are calculated through the Initialize method which takes as parameters
// the atomic number, charge and excitation energy of nucleus.
// Residual Atomic Number
G4int AResidual;
// Residual Charge
G4int ZResidual;
// Coulomb Barrier
G4double CoulombBarrier;
// Binding Energy
G4double BindingEnergy;
// Emission Probability
G4double EmissionProbability;
// Maximal Kinetic Energy that can be carried by fragment
G4double MaximalKineticEnergy;
public:
inline G4int GetGamma(void) const
{return Gamma;}
inline G4int GetA(void) const
{return A;}
inline G4int GetZ(void) const
{return Z;}
inline G4double GetCoulombBarrier(void) const
{return CoulombBarrier;}
inline G4double GetBindingEnergy(void) const
{return BindingEnergy;}
inline G4double GetEmissionProbability(void) const
{return EmissionProbability;}
inline G4double GetExcitationEnergy(const G4int i) const
{
if (ExcitationEnergies != 0 && i < ExcitationEnergies->length())
return ExcitationEnergies->operator()(i);
else return 0.0;
}
inline G4int GetExcitationSpin(const G4int i) const
{
if (ExcitationSpins != 0 && i < ExcitationSpins->length())
return ExcitationSpins->operator()(i);
else return 0;
}
inline G4double GetMaximalKineticEnergy(void) const
{ return MaximalKineticEnergy; }
// ----------------------
inline G4int GetResidualA(void) const
{ return AResidual; }
inline G4int GetResidualZ(void) const
{ return ZResidual; }
private:
// Coulomb barrier calculation
G4double CalcCoulombBarrier(const G4int ARes, const G4int ZRes);
// Calculate Binding Energy for separate fragment from nucleus
G4double CalcBindingEnergy(const G4int anA, const G4int aZ);
// Calculate maximal kinetic energy that can be carried by fragment (in MeV)
G4double CalcMaximalKineticEnergy(const G4double U);
// Samples fragment kinetic energy (in MeV).
G4double CalcKineticEnergy(void);
// This has to be removed and put in Random Generator
G4ThreeVector IsotropicVector(const G4double Magnitude = 1.0);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4EvaporationLevelDensityParameter.hh
+45
View File
@@ -0,0 +1,45 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4EvaporationLevelDensityParameter_h
#define G4EvaporationLevelDensityParameter_h 1
#include "G4VLevelDensityParameter.hh"
class G4EvaporationLevelDensityParameter : public G4VLevelDensityParameter
{
public:
G4EvaporationLevelDensityParameter() : EvapLevelDensityParameter(0.125*(1./MeV)) {};
virtual ~G4EvaporationLevelDensityParameter() {};
private:
G4EvaporationLevelDensityParameter(const G4EvaporationLevelDensityParameter &right);
const G4EvaporationLevelDensityParameter & operator=(const G4EvaporationLevelDensityParameter &right);
G4bool operator==(const G4EvaporationLevelDensityParameter &right) const;
G4bool operator!=(const G4EvaporationLevelDensityParameter &right) const;
public:
G4double LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const
{return EvapLevelDensityParameter;}
private:
const G4double EvapLevelDensityParameter;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4EvaporationProbability.hh
+61
View File
@@ -0,0 +1,61 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4EvaporationProbability_h
#define G4EvaporationProbability_h 1
#include "G4VEmissionProbability.hh"
#include "G4EvaporationChannel.hh"
class G4EvaporationProbability : public G4VEmissionProbability
{
public:
// Only available constructor
G4EvaporationProbability(G4VEvaporationChannel * aChannel)
{ theChannel = aChannel; };
~G4EvaporationProbability() {};
private:
// Default constructor
G4EvaporationProbability() {};
// Copy constructor
G4EvaporationProbability(const G4EvaporationProbability &right);
const G4EvaporationProbability & operator=(const G4EvaporationProbability &right);
G4bool operator==(const G4EvaporationProbability &right) const;
G4bool operator!=(const G4EvaporationProbability &right) const;
public:
G4double EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation);
private:
G4double DostrovskyApproximation(const G4int A, const G4double U);
G4double BotvinaApproximation(const G4int A, const G4double U);
G4double NikolaiApproximation(const G4int A, const G4double U);
G4VEvaporationChannel * theChannel;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4ExcitationHandler.hh
+201
View File
@@ -0,0 +1,201 @@
// 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.
//
// $Id: G4ExcitationHandler.hh,v 1.6 1998/12/12 12:34:57 larazb Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (May 1998)
// Modif (30 June 1998) by V. Lara:
// -Using G4ParticleTable and therefore G4IonTable
// it can return all kind of fragments produced in
// deexcitation
// -It uses default algorithms for:
// Evaporation: G4StatEvaporation
// MultiFragmentation: G4DummyMF (a dummy one)
// Fermi Breakup model: G4StatFermiBreakUp
#ifndef G4ExcitationHandler_h
#define G4ExcitationHandler_h 1
#include "G4MultiFragmentation.hh"
#include "G4VFermiBreakUp.hh"
#include "G4VEvaporation.hh"
#include "G4VPhotonEvaporation.hh"
#include "G4Fragment.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
// needed for default models
#include "G4Evaporation.hh"
#include "G4StatMF.hh"
#include "G4FermiBreakUp.hh"
#include "G4PhotonEvaporation.hh"
#include "G4IonConstructor.hh"
class G4ExcitationHandler
{
public:
G4ExcitationHandler();
~G4ExcitationHandler();
private:
G4ExcitationHandler(const G4ExcitationHandler &right);
const G4ExcitationHandler & operator=(const G4ExcitationHandler &right);
G4bool operator==(const G4ExcitationHandler &right) const;
G4bool operator!=(const G4ExcitationHandler &right) const;
public:
G4DynamicParticleVector * BreakItUp(const G4Fragment &theInitialState) const;
void SetEvaporation(G4VEvaporation *const value);
void SetMultiFragmentation(G4MultiFragmentation *const value);
void SetFermiModel(G4VFermiBreakUp *const value);
void SetPhotonEvaporation(G4VPhotonEvaporation * const value);
void SetMaxZForFermiBreakUp(G4int aZ);
void SetMaxAForFermiBreakUp(G4int anA);
void SetMaxAandZForFermiBreakUp(G4int anA,G4int aZ);
void SetMinEForMultiFrag(G4double anE);
private:
G4DynamicParticleVector * Transform(G4FragmentVector * theFragmentVector) const;
const G4VEvaporation * GetEvaporation() const;
const G4MultiFragmentation * GetMultiFragmentation() const;
const G4VFermiBreakUp * GetFermiModel() const;
const G4VPhotonEvaporation * GetPhotonEvaporation() const;
const G4int GetMaxZ() const;
const G4int GetMaxA() const;
const G4double GetMinE() const;
private:
G4VEvaporation *theEvaporation;
G4MultiFragmentation *theMultiFragmentation;
G4VFermiBreakUp *theFermiModel;
G4VPhotonEvaporation * thePhotonEvaporation;
G4int maxZForFermiBreakUp;
G4int maxAForFermiBreakUp;
G4double minEForMultiFrag;
G4ParticleTable *theTableOfParticles;
G4bool MyOwnEvaporationClass;
G4bool MyOwnMultiFragmentationClass;
G4bool MyOwnFermiBreakUpClass;
G4bool MyOwnPhotonEvaporationClass;
};
inline const G4VEvaporation * G4ExcitationHandler::GetEvaporation() const
{
return theEvaporation;
}
inline void G4ExcitationHandler::SetEvaporation(G4VEvaporation *const value)
{
if (theEvaporation != 0 && MyOwnEvaporationClass) delete theEvaporation;
MyOwnEvaporationClass = false;
theEvaporation = value;
}
inline const G4MultiFragmentation * G4ExcitationHandler::GetMultiFragmentation() const
{
return theMultiFragmentation;
}
inline void G4ExcitationHandler::SetMultiFragmentation(G4MultiFragmentation *const value)
{
if (theMultiFragmentation != 0 && MyOwnMultiFragmentationClass) delete theMultiFragmentation;
MyOwnMultiFragmentationClass = false;
theMultiFragmentation = value;
}
inline const G4VFermiBreakUp * G4ExcitationHandler::GetFermiModel() const
{
return theFermiModel;
}
inline void G4ExcitationHandler::SetFermiModel(G4VFermiBreakUp *const value)
{
if (theFermiModel != 0 && MyOwnFermiBreakUpClass) delete theFermiModel;
MyOwnFermiBreakUpClass = false;
theFermiModel = value;
}
inline const G4VPhotonEvaporation * G4ExcitationHandler::GetPhotonEvaporation() const
{
return thePhotonEvaporation;
}
inline void G4ExcitationHandler::SetPhotonEvaporation(G4VPhotonEvaporation *const value)
{
if (thePhotonEvaporation != 0 && MyOwnPhotonEvaporationClass) delete thePhotonEvaporation;
MyOwnPhotonEvaporationClass = false;
thePhotonEvaporation = value;
}
inline void G4ExcitationHandler::SetMaxZForFermiBreakUp(G4int aZ)
{
maxZForFermiBreakUp = aZ;
}
inline void G4ExcitationHandler::SetMaxAForFermiBreakUp(G4int anA)
{
maxAForFermiBreakUp = anA;
}
inline void G4ExcitationHandler::SetMaxAandZForFermiBreakUp(G4int anA, G4int aZ)
{
maxAForFermiBreakUp = anA;
maxZForFermiBreakUp = aZ;
}
inline void G4ExcitationHandler::SetMinEForMultiFrag(G4double anE)
{
// minEForMultiFrag = anE;
minEForMultiFrag = 1.0*GeV;
}
inline const G4int G4ExcitationHandler::GetMaxZ() const
{
return maxZForFermiBreakUp;
}
inline const G4int G4ExcitationHandler::GetMaxA() const
{
return maxAForFermiBreakUp;
}
inline const G4double G4ExcitationHandler::GetMinE() const
{
return minEForMultiFrag;
}
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4FermiBreakUp.hh
+40
View File
@@ -0,0 +1,40 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4FermiBreakUp_h
#define G4FermiBreakUp_h 1
#include "G4VFermiBreakUp.hh"
#include "G4FermiConfiguration.hh"
#include "G4FermiConfigurationList.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
class G4FermiBreakUp : public G4VFermiBreakUp
{
public:
G4FermiBreakUp();
~G4FermiBreakUp();
private:
G4FermiBreakUp(const G4FermiBreakUp &right);
const G4FermiBreakUp & operator=(const G4FermiBreakUp &right);
G4bool operator==(const G4FermiBreakUp &right) const;
G4bool operator!=(const G4FermiBreakUp &right) const;
public:
G4FragmentVector * BreakItUp(const G4Fragment &theNucleus);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4FermiConfiguration.hh
+199
View File
@@ -0,0 +1,199 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4FermiConfiguration_h
#define G4FermiConfiguration_h 1
#include "globals.hh"
#include "Randomize.hh"
#include "G4VFermiFragment.hh"
#include "G4StableFermiFragment.hh"
#include "G4B9FermiFragment.hh"
#include "G4Be8FermiFragment.hh"
#include "G4He5FermiFragment.hh"
#include "G4Li5FermiFragment.hh"
#include "G4ParticleMomentum.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include "G4Fragment.hh"
#include <rw/tvvector.h>
#include <rw/tvordvec.h>
static const G4int NumberOfFragments = 100;
class G4FermiConfiguration
{
public:
G4FermiConfiguration();
~G4FermiConfiguration();
G4FermiConfiguration(const G4FermiConfiguration &right);
const G4FermiConfiguration & operator=(const G4FermiConfiguration &right);
G4bool operator==(const G4FermiConfiguration &right) const;
G4bool operator!=(const G4FermiConfiguration &right) const;
public:
void Initialize(const G4int max);
G4bool SplitNucleus(const G4int A, const G4int Z);
G4double DecayProbability(const G4int A, const G4double TotalE);
G4FragmentVector * GetFragments(const G4Fragment & theNucleus);
private:
G4double CoulombBarrier(void);
// RWTPtrOrderedVector<G4ParticleMomentum>* FragmentsMomentum(G4double KineticEnergy);
RWTPtrOrderedVector<G4LorentzVector>* FragmentsMomentum(G4double KineticEnergy);
G4double RNKSI(const G4int K);
G4ParticleMomentum IsotropicVector(const G4double Magnitude = 1.0);
// Kappa = V/V_0 it is used in calculation of Coulomb energy
static const G4double Kappa;
static G4StableFermiFragment Fragment00;
static G4StableFermiFragment Fragment01;
static G4StableFermiFragment Fragment02;
static G4StableFermiFragment Fragment03;
static G4StableFermiFragment Fragment04;
static G4StableFermiFragment Fragment05;
static G4He5FermiFragment Fragment06; // He5
static G4Li5FermiFragment Fragment07; // Li5
static G4StableFermiFragment Fragment08;
static G4StableFermiFragment Fragment09;
static G4StableFermiFragment Fragment10;
static G4StableFermiFragment Fragment11;
static G4StableFermiFragment Fragment12;
static G4StableFermiFragment Fragment13;
static G4StableFermiFragment Fragment14;
static G4StableFermiFragment Fragment15;
static G4StableFermiFragment Fragment16;
static G4Be8FermiFragment Fragment17; // Be8
static G4StableFermiFragment Fragment18;
static G4B9FermiFragment Fragment19; // B9
static G4StableFermiFragment Fragment20;
static G4StableFermiFragment Fragment21;
static G4StableFermiFragment Fragment22;
static G4StableFermiFragment Fragment23;
static G4StableFermiFragment Fragment24;
static G4StableFermiFragment Fragment25;
static G4StableFermiFragment Fragment26;
static G4StableFermiFragment Fragment27;
static G4StableFermiFragment Fragment28;
static G4StableFermiFragment Fragment29;
static G4StableFermiFragment Fragment30;
static G4StableFermiFragment Fragment31;
static G4StableFermiFragment Fragment32;
static G4StableFermiFragment Fragment33;
static G4StableFermiFragment Fragment34;
static G4StableFermiFragment Fragment35;
static G4StableFermiFragment Fragment36;
static G4StableFermiFragment Fragment37;
static G4StableFermiFragment Fragment38;
static G4StableFermiFragment Fragment39;
static G4StableFermiFragment Fragment40;
static G4StableFermiFragment Fragment41;
static G4StableFermiFragment Fragment42;
static G4StableFermiFragment Fragment43;
static G4StableFermiFragment Fragment44;
static G4StableFermiFragment Fragment45;
static G4StableFermiFragment Fragment46;
static G4StableFermiFragment Fragment47;
static G4StableFermiFragment Fragment48;
static G4StableFermiFragment Fragment49;
static G4StableFermiFragment Fragment50;
static G4StableFermiFragment Fragment51;
static G4StableFermiFragment Fragment52;
static G4StableFermiFragment Fragment53;
static G4StableFermiFragment Fragment54;
static G4StableFermiFragment Fragment55;
static G4StableFermiFragment Fragment56;
static G4StableFermiFragment Fragment57;
static G4StableFermiFragment Fragment58;
static G4StableFermiFragment Fragment59;
static G4StableFermiFragment Fragment60;
static G4StableFermiFragment Fragment61;
static G4StableFermiFragment Fragment62;
static G4StableFermiFragment Fragment63;
static G4StableFermiFragment Fragment64;
static G4StableFermiFragment Fragment65;
static G4StableFermiFragment Fragment66;
static G4StableFermiFragment Fragment67;
static G4StableFermiFragment Fragment68;
static G4StableFermiFragment Fragment69;
static G4StableFermiFragment Fragment70;
static G4StableFermiFragment Fragment71;
static G4StableFermiFragment Fragment72;
static G4StableFermiFragment Fragment73;
static G4StableFermiFragment Fragment74;
static G4StableFermiFragment Fragment75;
static G4StableFermiFragment Fragment76;
static G4StableFermiFragment Fragment77;
static G4StableFermiFragment Fragment78;
static G4StableFermiFragment Fragment79;
static G4StableFermiFragment Fragment80;
static G4StableFermiFragment Fragment81;
static G4StableFermiFragment Fragment82;
static G4StableFermiFragment Fragment83;
static G4StableFermiFragment Fragment84;
static G4StableFermiFragment Fragment85;
static G4StableFermiFragment Fragment86;
static G4StableFermiFragment Fragment87;
static G4StableFermiFragment Fragment88;
static G4StableFermiFragment Fragment89;
static G4StableFermiFragment Fragment90;
static G4StableFermiFragment Fragment91;
static G4StableFermiFragment Fragment92;
static G4StableFermiFragment Fragment93;
static G4StableFermiFragment Fragment94;
static G4StableFermiFragment Fragment95;
static G4StableFermiFragment Fragment96;
static G4StableFermiFragment Fragment97;
static G4StableFermiFragment Fragment98;
static G4StableFermiFragment Fragment99;
static G4VFermiFragment * theListOfFragments[NumberOfFragments];
// G4VFermiFragment * theConfiguration[MaxConfigSize];
// G4int Index[MaxConfigSize];
RWTValOrderedVector<G4int> Index;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4FermiConfigurationList.hh
+61
View File
@@ -0,0 +1,61 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4FermiConfigurationList_h
#define G4FermiConfigurationList_h 1
#include "globals.hh"
#include "G4FermiConfiguration.hh"
#include "Randomize.hh"
#include <rw/tvvector.h>
#include <rw/tvordvec.h>
class G4FermiConfigurationList
{
public:
G4FermiConfigurationList();
~G4FermiConfigurationList()
{};
private:
G4FermiConfigurationList(const G4FermiConfigurationList &right);
const G4FermiConfigurationList & operator=(const G4FermiConfigurationList &right);
G4bool operator==(const G4FermiConfigurationList &right) const;
G4bool operator!=(const G4FermiConfigurationList &right) const;
public:
G4bool Initialize(const G4int A, const G4int Z, const G4double TotalEnergyRF);
G4FermiConfiguration ChooseConfiguration(void);
private:
enum {MaxNumOfFragments = 6};
G4double TotNumOfConfigurations; // NumberOfFragments;
G4double NumOfConfigurations[MaxNumOfFragments]; // NumberOfChannelsPerFragment[MaxNumOfFragments];
RWTValOrderedVector<G4double> NormalizedWeights;
RWTValOrderedVector<G4FermiConfiguration> Configurations;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4FissionBarrier.hh
+44
View File
@@ -0,0 +1,44 @@
// 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.
//
// $Id: G4FissionBarrier.hh,v 1.1 1998/10/15 07:52:46 larazb Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
#ifndef G4FissionBarrier_h
#define G4FissionBarrier_h 1
#include "G4VFissionBarrier.hh"
#include "globals.hh"
class G4FissionBarrier : public G4VFissionBarrier
{
public:
G4FissionBarrier() {};
~G4FissionBarrier() {};
private:
G4FissionBarrier(const G4FissionBarrier & right);
const G4FissionBarrier & operator=(const G4FissionBarrier & right);
G4bool operator==(const G4FissionBarrier & right) const;
G4bool operator!=(const G4FissionBarrier & right) const;
public:
G4double FissionBarrier(const G4int A, const G4int Z);
private:
G4double BarashenkovFissionBarrier(const G4int A, const G4int Z);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4FissionLevelDensityParameter.hh
+47
View File
@@ -0,0 +1,47 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4FissionLevelDensityParameter_h
#define G4FissionLevelDensityParameter_h 1
#include "G4VLevelDensityParameter.hh"
#include "G4EvaporationLevelDensityParameter.hh"
class G4FissionLevelDensityParameter : public G4VLevelDensityParameter
{
public:
G4FissionLevelDensityParameter() {};
virtual ~G4FissionLevelDensityParameter() {};
private:
G4FissionLevelDensityParameter(const G4FissionLevelDensityParameter &right);
const G4FissionLevelDensityParameter & operator=(const G4FissionLevelDensityParameter &right);
G4bool operator==(const G4FissionLevelDensityParameter &right) const;
G4bool operator!=(const G4FissionLevelDensityParameter &right) const;
public:
G4double LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const;
private:
G4EvaporationLevelDensityParameter theEvaporationLevelDensityParameter;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4FissionParameters.hh
+77
View File
@@ -0,0 +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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4FissionParameters_h
#define G4FissionParameters_h 1
#include "globals.hh"
class G4FissionParameters
{
public:
// Only available constructor
G4FissionParameters(const G4int A, const G4int Z, const G4double ExEnergy, const G4double FissionBarrier);
~G4FissionParameters() {};
private:
// Default constructor
G4FissionParameters() {};
// Copy constructor
G4FissionParameters(const G4FissionParameters &right);
const G4FissionParameters & operator=(const G4FissionParameters &right);
G4bool operator==(const G4FissionParameters &right) const;
G4bool operator!=(const G4FissionParameters &right) const;
public:
inline G4double GetA1(void) const { return A1; }
inline G4double GetA2(void) const { return A2; }
inline G4double GetAs(void) const { return As; }
inline G4double GetSigma1(void) const { return Sigma1; }
inline G4double GetSigma2(void) const { return Sigma2; }
inline G4double GetSigmaS(void) const { return SigmaS; }
inline G4double GetW(void) const { return w; }
private:
// Mean numbers of the corresponding Gaussians for assymmetric
// fission
static const G4double A1;
static const G4double A2;
// Mean number for symmetric fission
G4double As;
// Dispersions of the corresponding Gaussians for assymmetric
// fission
G4double Sigma1;
G4double Sigma2;
// Dispersion for symmetric fission
G4double SigmaS;
// Weight which determines the relative contribution of symmetric
// and assymmetric components
G4double w;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4FissionProbability.hh
+58
View File
@@ -0,0 +1,58 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4FissionProbability_h
#define G4FissionProbability_h 1
#include "G4VEmissionProbability.hh"
#include "G4VEvaporationChannel.hh"
#include "G4EvaporationLevelDensityParameter.hh"
#include "G4FissionLevelDensityParameter.hh"
class G4FissionProbability : public G4VEmissionProbability
{
public:
// Only available constructor
G4FissionProbability(G4VEvaporationChannel * aChannel)
{ theChannel = aChannel; };
~G4FissionProbability() {};
private:
// Default constructor
G4FissionProbability() {};
// Copy constructor
G4FissionProbability(const G4FissionProbability &right);
const G4FissionProbability & operator=(const G4FissionProbability &right);
G4bool operator==(const G4FissionProbability &right) const;
G4bool operator!=(const G4FissionProbability &right) const;
public:
G4double EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation);
private:
G4VEvaporationChannel * theChannel;
G4EvaporationLevelDensityParameter theEvapLDP;
G4FissionLevelDensityParameter theFissLDP;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4He5FermiFragment.hh
+45
View File
@@ -0,0 +1,45 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4He5FermiFragment_h
#define G4He5FermiFragment_h 1
#include "G4UnstableFermiFragment.hh"
#include "G4IonTable.hh"
class G4He5FermiFragment : public G4UnstableFermiFragment
{
public:
G4He5FermiFragment(const G4int anA, const G4int aZ, const G4int Pol, const G4double ExE):
G4UnstableFermiFragment(anA,aZ,Pol,ExE)
{};
~G4He5FermiFragment();
private:
G4He5FermiFragment();
G4He5FermiFragment(const G4He5FermiFragment &right);
const G4He5FermiFragment & operator=(const G4He5FermiFragment &right);
G4bool operator==(const G4He5FermiFragment &right) const;
G4bool operator!=(const G4He5FermiFragment &right) const;
public:
G4FragmentVector * GetFragment(const G4LorentzVector & aMomentum);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4Li5FermiFragment.hh
+45
View File
@@ -0,0 +1,45 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4Li5FermiFragment_h
#define G4Li5FermiFragment_h 1
#include "G4UnstableFermiFragment.hh"
#include "G4IonTable.hh"
class G4Li5FermiFragment : public G4UnstableFermiFragment
{
public:
G4Li5FermiFragment(const G4int anA, const G4int aZ, const G4int Pol, const G4double ExE):
G4UnstableFermiFragment(anA,aZ,Pol,ExE)
{};
~G4Li5FermiFragment();
private:
G4Li5FermiFragment();
G4Li5FermiFragment(const G4Li5FermiFragment &right);
const G4Li5FermiFragment & operator=(const G4Li5FermiFragment &right);
G4bool operator==(const G4Li5FermiFragment &right) const;
G4bool operator!=(const G4Li5FermiFragment &right) const;
public:
G4FragmentVector * GetFragment(const G4LorentzVector & aMomentum);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4MultiFragmentation.hh
+40
View File
@@ -0,0 +1,40 @@
// 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.
//
// $Id: G4MultiFragmentation.hh,v 1.1 1998/08/22 08:53:36 hpw Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (May 1998)
#ifndef G4MultiFragmentation_h
#define G4MultiFragmentation_h 1
#include "G4FragmentVector.hh"
class G4MultiFragmentation
{
public:
G4MultiFragmentation();
virtual ~G4MultiFragmentation();
private:
G4MultiFragmentation(const G4MultiFragmentation &right);
const G4MultiFragmentation & operator=(const G4MultiFragmentation &right);
int operator==(const G4MultiFragmentation &right) const;
int operator!=(const G4MultiFragmentation &right) const;
public:
virtual G4FragmentVector * BreakItUp(const G4Fragment &theNucleus) = 0;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4NuclearLevel.hh
+99
View File
@@ -0,0 +1,99 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4NuclearLevel
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 25 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4NUCLEARLEVEL_HH
#define G4NUCLEARLEVEL_HH
#include "globals.hh"
#include "G4NuclearLevel.hh"
#include "G4DataVector.hh"
class G4NuclearLevel
{
public:
G4NuclearLevel(const G4double energy, const G4DataVector& eGamma, const G4DataVector& wGamma);
G4NuclearLevel() {};
~G4NuclearLevel();
const G4DataVector& GammaEnergies() const;
const G4DataVector& GammaWeights() const;
const G4DataVector& GammaProbabilities() const;
const G4DataVector& GammaCumulativeProbabilities() const;
G4double Energy() const;
G4int NumberOfGammas() const;
void PrintAll() const;
G4bool operator==(const G4NuclearLevel &right) const;
G4bool operator!=(const G4NuclearLevel &right) const;
G4bool operator<(const G4NuclearLevel &right) const;
protected:
private:
// G4NuclearLevel(const G4NuclearLevel &right);
// const G4NuclearLevel& operator=(const G4NuclearLevel &right);
void MakeProbabilities();
void MakeCumProb();
G4DataVector _energies;
G4DataVector _weights;
G4DataVector _prob;
G4DataVector _cumProb;
G4double _energy;
G4int _nGammas;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4NuclearLevelManager.hh
+100
View File
@@ -0,0 +1,100 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4NuclearLevelManager
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 25 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4NUCLEARLEVELMANAGER_HH
#define G4NUCLEARLEVELMANAGER_HH
#include "globals.hh"
#include "G4PtrLevelVector.hh"
#include "G4NuclearLevel.hh"
#include "G4ios.hh"
#include <fstream.h>
class G4NuclearLevelManager
{
public:
G4NuclearLevelManager();
G4NuclearLevelManager(G4int Z, G4int A);
~G4NuclearLevelManager();
void SetNucleus(G4int Z, G4int A);
G4bool IsValid(G4int Z, G4int A) const;
G4int NumberOfLevels() const;
const G4PtrLevelVector* GetLevels() const;
const G4NuclearLevel* NearestLevel(G4double energy, G4double eDiffMax=9999.*GeV) const;
const G4NuclearLevel* LowestLevel() const;
const G4NuclearLevel* HighestLevel() const;
G4double MinLevelEnergy() const;
G4double MaxLevelEnergy() const;
void PrintAll();
G4NuclearLevelManager(const G4NuclearLevelManager &right);
protected:
private:
const G4NuclearLevelManager& operator=(const G4NuclearLevelManager &right);
G4bool operator==(const G4NuclearLevelManager &right) const;
G4bool operator!=(const G4NuclearLevelManager &right) const;
G4bool Read(ifstream& aDataFile);
void MakeLevels();
G4int _A;
G4int _Z;
G4PtrLevelVector* _levels;
G4double _levelEnergy;
G4double _gammaEnergy;
G4double _probability;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4PhotonEvaporation.hh
+78
View File
@@ -0,0 +1,78 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4PhotonEvaporation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4PHOTONEVAPORATION_HH
#define G4PHOTONEVAPORATION_HH
#include "globals.hh"
#include "G4VPhotonEvaporation.hh"
#include "G4VEvaporationChannel.hh"
#include "G4VEmissionProbability.hh"
#include "G4VGammaDeexcitation.hh"
class G4Fragment;
class G4PhotonEvaporation : public G4VPhotonEvaporation, public G4VEvaporationChannel
{
public:
G4PhotonEvaporation();
virtual ~G4PhotonEvaporation();
virtual G4FragmentVector* BreakItUp(const G4Fragment& nucleus);
virtual void Initialize(const G4Fragment& fragment);
virtual G4FragmentVector* BreakUp(const G4Fragment& nucleus);
virtual G4double GetEmissionProbability() const;
virtual void SetEmissionStrategy(G4VEmissionProbability* probAlgorithm);
void SetVerboseLevel(G4int verbose);
private:
G4int _verbose;
G4bool _myOwnProbAlgorithm;
G4VEmissionProbability* _probAlgorithm;
G4VGammaDeexcitation* _discrDeexcitation;
G4VGammaDeexcitation* _contDeexcitation;
G4VGammaDeexcitation* _cdDeexcitation;
G4Fragment _nucleus;
G4double _gammaE;
G4PhotonEvaporation(const G4PhotonEvaporation &right);
const G4PhotonEvaporation& operator=(const G4PhotonEvaporation &right);
// MGP - Check == and != multiple inheritance... must be a mess!
G4bool operator==(const G4PhotonEvaporation &right) const;
G4bool operator!=(const G4PhotonEvaporation &right) const;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4PtrLevelVector.hh
+37
View File
@@ -0,0 +1,37 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4PtrLevelVector
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 25 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4PTRLEVELVECTOR_HH
#define G4PTRLEVELVECTOR_HH
class G4NuclearLevel;
#include <rw/tpsrtvec.h>
typedef RWTPtrSortedVector<G4NuclearLevel> G4PtrLevelVector;
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4RandGeneralTmp.hh
+86
View File
@@ -0,0 +1,86 @@
//
// -----------------------------------------------------------------------
// HEP Random
// --- G4RandGeneralTmp ---
// class header file
// -----------------------------------------------------------------------
// Class defining methods for shooting generally distributed random values,
// given a user-defined probability distribution function.
// =======================================================================
// S.Magni & G.Pieri - Created: 29 April 1998
// G.Cosmo - Added constructor using default engine from the
// static generator: 20 Aug 1998
// =======================================================================
#ifndef G4RandGeneralTmp_h
#define G4RandGeneralTmp_h 1
#include "CLHEP/Random/Random.h"
class G4RandGeneralTmp : public HepRandom {
public:
G4RandGeneralTmp ( HepDouble* aProbFunc, HepInt theProbSize );
G4RandGeneralTmp ( HepRandomEngine& anEngine,
HepDouble* aProbFunc, HepInt theProbSize );
G4RandGeneralTmp ( HepRandomEngine* anEngine,
HepDouble* aProbFunc, HepInt theProbSize );
// These constructors should be used to instantiate a G4RandGeneralTmp
// distribution object defining a local engine for it.
// The static generator will be skeeped using the non-static methods
// defined below. In case no engine is specified in the constructor, the
// default engine used by the static generator is applied.
// If the engine is passed by pointer the corresponding engine object
// will be deleted by the G4RandGeneralTmp destructor.
// If the engine is passed by reference the corresponding engine object
// will not be deleted by the RandGauss destructor.
// The probability distribution function (Pdf) must be provided by the user
// as an array of positive real number. The array size must also be
// provided. The Pdf doesn't need to be normalized to 1.
virtual ~G4RandGeneralTmp();
// Destructor
// Methods to shoot random values using the static generator
// N.B.: The methods are NOT static since they use nonstatic members
// theIntegralPdf & nBins
inline HepDouble shoot();
inline void shootArray ( const HepInt size, HepDouble* vect);
// Methods to shoot random values using a given engine
// by-passing the static generator.
HepDouble shoot( HepRandomEngine* anEngine );
void shootArray ( HepRandomEngine* anEngine, const HepInt size,
HepDouble* vect );
// Methods using the localEngine to shoot random values, by-passing
// the static generator.
HepDouble fire();
void fireArray ( const HepInt size, HepDouble* vect);
HepDouble operator()();
private:
// Private copy constructor. Defining it here disallows use.
G4RandGeneralTmp(const G4RandGeneralTmp&){;}
HepRandomEngine* localEngine;
HepBoolean deleteEngine;
HepDouble* theIntegralPdf;
HepInt nBins;
};
#include "G4RandGeneralTmp.icc"
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4RandGeneralTmp.icc
+19
View File
@@ -0,0 +1,19 @@
// -----------------------------------------------------------------------
// HEP Random
// --- RandGeneralTmp ---
// inlined functions implementation file
// -----------------------------------------------------------------------
// =======================================================================
// Gabriele Cosmo - Created: 20th August 1998
// =======================================================================
inline HepDouble G4RandGeneralTmp::shoot()
{
return fire();
}
inline void G4RandGeneralTmp::shootArray( const HepInt size, HepDouble* vect )
{
fireArray(size, vect);
}
source/processes/hadronic/models/generator/de_excitation/include/G4StableFermiFragment.hh
+43
View File
@@ -0,0 +1,43 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4StableFermiFragment_h
#define G4StableFermiFragment_h 1
#include "G4VFermiFragment.hh"
class G4StableFermiFragment : public G4VFermiFragment
{
public:
G4StableFermiFragment(const G4int anA, const G4int aZ, const G4int Pol, const G4double ExE):
G4VFermiFragment(anA,aZ,Pol,ExE)
{};
~G4StableFermiFragment();
private:
G4StableFermiFragment();
G4StableFermiFragment(const G4StableFermiFragment &right);
const G4StableFermiFragment & operator=(const G4StableFermiFragment &right);
G4bool operator==(const G4StableFermiFragment &right) const;
G4bool operator!=(const G4StableFermiFragment &right) const;
public:
G4FragmentVector * GetFragment(const G4LorentzVector & aMomentum);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4StatMF.hh
+103
View File
@@ -0,0 +1,103 @@
#ifndef G4StatMF_h
#define G4StatMF_h 1
#include <rw/tvordvec.h>
#include "globals.hh"
#include "G4MultiFragmentation.hh"
#include "G4Fragment.hh"
#include "G4FragmentVector.hh"
#include "G4StatMFFragment.hh"
#include "G4StatMFParameters.hh"
#include "G4VStatMFCanonical.hh"
#include "G4StatMFMicrocanonical.hh"
#include "G4StatMFMacrocanonical.hh"
#include "G4NucleiProperties.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include "Randomize.hh"
class G4StatMF : public G4MultiFragmentation
{
public:
G4StatMF();
~G4StatMF();
private:
G4StatMF(const G4StatMF & right);
G4StatMF & operator=(const G4StatMF & right);
G4bool operator==(const G4StatMF & right);
G4bool operator!=(const G4StatMF & right);
public:
G4FragmentVector *BreakItUp(const G4Fragment &theNucleus);
private:
// This finds temperature of breaking channel.
G4bool FindTemperatureOfBreakingChannel(const G4Fragment & theFragment,
const G4double & Multiplicity,
G4double & Temperature,
G4double & EnergyCol);
// Calculate asymptotic fragments momenta
void CoulombImpulse(const G4Fragment & theFragment,
const G4int & NumberOfChargedFragments,
const G4int & Multiplicity,
const G4double & Temperature,
const G4double & CoulombEnergy,
G4ThreeVector * MomentumOfFragments);
// Randomly samples fragments positions inside prolongated ellipsoid
void Place(const G4Fragment & theFragment,
const G4int & Multiplicity,
G4ThreeVector * Position);
// This method will find a solution of Newton's equation of motion
// for fragments in the self-consistent time-dependent Coulomb field
void SolveEqOfMotion(G4ThreeVector * InitialPos,
G4ThreeVector * InitialVel,
G4ThreeVector * FinalVel,
const G4int & Multiplicity,
const G4double & CoulombEnergy,
const G4double & KineticEnergy);
// Calculates fragments momentum components at the breakup instant.
// Fragment kinetic energies will be calculated according to the
// Boltzamann distribution at given temperature.
void CalculateFragmentsMomentum(const G4int & INET,
const G4int & NFrags,
const G4double & T,
const G4double & TotKineticE,
G4ThreeVector * Momentum);
// Rotates a 3-vector P to close momentum triangle P + A + B = 0
G4ThreeVector Rotor(const G4ThreeVector & P,
const G4ThreeVector & A,
const G4ThreeVector & B);
G4double CalculateFragmentExcitationEnergy(const G4int & index, const G4double & T);
// Samples a isotropic random vectorwith a magnitud given by Magnitude.
// By default Magnitude = 1
G4ThreeVector IsotropicVector(const G4double Magnitude = 1.0);
private:
// G4StatMFMicrocanonical * theMicrocanonicalSim;
// G4StatMFMacrocanonical * theMacrocanonicalSim;
G4VStatMFCanonical * theSim;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4StatMFFragment.hh
+127
View File
@@ -0,0 +1,127 @@
#ifndef G4StatMFFragment_h
#define G4StatMFFragment_h 1
#include "G4StatMFParameters.hh"
class G4StatMFFragment {
public:
// default constructor
G4StatMFFragment():
InvLevelDensity(0.0),
ZARatio(0.0),
DegeneracyFactor(0.0),
Multiplicity(0.0),
A(0.0),
Z(0.0),
Energy(0.0)
{};
// destructor
~G4StatMFFragment() {};
private:
// copy constructor
G4StatMFFragment(const G4StatMFFragment & right);
// operators
const G4StatMFFragment & operator=(const G4StatMFFragment & right);
public:
G4bool operator==(const G4StatMFFragment & right) const;
G4bool operator!=(const G4StatMFFragment & right) const;
private:
// Inverse Level Density
G4double InvLevelDensity;
// Z/A ratio
G4double ZARatio;
// Degeneracy Factor
G4double DegeneracyFactor;
// Fragments Multiplicitie
G4double Multiplicity;
// Atomic number
G4double A;
// Charge
G4double Z;
// Energy
G4double Energy;
public:
void SetInvLevelDensity(const G4double value) {
InvLevelDensity = value;
}
void SetInvLevelDensity(const G4int value) {
//
if (value == 0) InvLevelDensity = 0.0;
else InvLevelDensity = G4StatMFParameters::GetEpsilon0()/
(1.0+0.002*((value+1.0)/25.0)*((value+1.0)/25.0));
}
const G4double GetInvLevelDensity() const {
return InvLevelDensity;
}
void SetZARatio(const G4double value) {
ZARatio = value;
}
const G4double GetZARatio() const {
return ZARatio;
}
void SetDegeneracyFactor(const G4double value) {
DegeneracyFactor = value;
}
const G4double GetDegeneracyFactor() const {
return DegeneracyFactor;
}
void SetMultiplicity(const G4double value) {
Multiplicity = value;
}
const G4double GetMultiplicity() const {
return Multiplicity;
}
void SetA(const G4double value) {
A = value;
}
const G4double GetA() const {
return A;
}
void SetZ(const G4double value) {
Z = value;
}
const G4double GetZ() const {
return Z;
}
void SetEnergy(const G4double value) {
Energy = value;
}
const G4double GetEnergy() const {
return Energy;
}
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4StatMFMacrocanonical.hh
+94
View File
@@ -0,0 +1,94 @@
#ifndef G4StatMFMacrocanonical_h
#define G4StatMFMacrocanonical_h 1
#include <rw/tvordvec.h>
#include "G4Fragment.hh"
#include "G4StatMFFragment.hh"
#include "G4StatMFParameters.hh"
#include "G4VStatMFCanonical.hh"
#include "Randomize.hh"
class G4StatMFMacrocanonical : public G4VStatMFCanonical {
public:
// G4StatMFMacrocanonical class must be initialized with a G4Fragment.
G4StatMFMacrocanonical(const G4Fragment & theFragment);
// destructor
~G4StatMFMacrocanonical();
private:
// default constructor
G4StatMFMacrocanonical() {};
// copy constructor
G4StatMFMacrocanonical(const G4StatMFMacrocanonical &right) {};
// operators
G4StatMFMacrocanonical & operator=(const G4StatMFMacrocanonical & right);
G4bool operator==(const G4StatMFMacrocanonical & right) const;
G4bool operator!=(const G4StatMFMacrocanonical & right) const;
public:
// Choice of fragment atomic numbers and charges.
void ChooseAandZ(const G4Fragment &theFragment);
private:
// Initailization method
void Initialize(const G4Fragment & theFragment);
//
void CalculateTemperature(const G4Fragment & theFragment);
// Calculates excitation energy per nucleon and summed fragment multiplicity and entropy
void FragmentsExcitationEnergyAndEntropy(const G4Fragment & theFragment,
const G4double Kappa,
G4double & ExcitEnergyPerNucleon,
G4double & TotalMultiplicity);
// This calculates fragment charges over fragment atomic numbers
void CalculateZARatio(const G4Fragment & theFragment, const G4double & Kappa);
//
void CalculateMultiplicities(const G4Fragment & theFragment, const G4double & Kappa);
// Calculates fragment multiplicities
void MeanFragmentMultiplicities(const G4Fragment & theFragment, const G4double & Kappa);
// Calculate Fragment energies at actual temperature
void FragmentEnergies(const G4Fragment & theFragment,const G4double & Kappa);
// Calculates summed fragments entropy
G4double TotalFragmentsEntropy(const G4double & A, const G4double & Kappa);
// Determines fragments multiplicities and compute total fragment multiplicity
G4double ChooseA(const G4double A, RWTValVector<G4double> & ANumbers);
//
void ChooseZ(const G4int & Z, const G4double Multiplicity);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Chemical Potential \mu
G4double ChemPotentialMu;
// Chemical Potential \nu
G4double ChemPotentialNu;
//
G4double YN, YP, Y2, Y3, Y4;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4StatMFMicrocanonical.hh
+109
View File
@@ -0,0 +1,109 @@
#ifndef G4StatMFMicrocanonical_h
#define G4StatMFMicrocanonical_h 1
//#include <rw/tvvector.h>
#include <rw/tvordvec.h>
#include "G4Fragment.hh"
#include "G4StatMFFragment.hh"
#include "G4StatMFParameters.hh"
#include "G4VStatMFCanonical.hh"
#include "Randomize.hh"
//class G4StatMF1DVector : public RWTValVector<G4int> {
//public:
// G4StatMF1DVector() {};
// G4StatMF1DVector(G4int n):RWTValVector<G4int>(n) {};
//};
class G4StatMFMicrocanonical : public G4VStatMFCanonical {
public:
// G4StatMFMicrocanonical class must be initialized with a G4Fragment.
G4StatMFMicrocanonical(const G4Fragment & theFragment);
// destructor
~G4StatMFMicrocanonical();
private:
// default constructor
G4StatMFMicrocanonical() {};
// copy constructor
G4StatMFMicrocanonical(const G4StatMFMicrocanonical &right) {};
// operators
G4StatMFMicrocanonical & operator=(const G4StatMFMicrocanonical & right);
G4bool operator==(const G4StatMFMicrocanonical & right) const;
G4bool operator!=(const G4StatMFMicrocanonical & right) const;
public:
// Choice of fragment atomic numbers and charges.
void ChooseAandZ(const G4Fragment &theFragment);
private:
// Initailization method
void Initialize(const G4Fragment & theFragment);
// Calculate Entropy of Compound Nucleus
G4double CalcEntropyOfCompoundNucleus(const G4Fragment & theFragment, G4double & TConf);
G4bool DistributeNucleonsBetweenFragments(const G4int & k, G4int * ANumbers);
G4double CalcFragmentsConfigProbability(const G4Fragment & theFragment, const G4int & M,
const G4int * ANumbers, const G4double & SCompound);
G4double CalcFreeInternalEnergy(const G4Fragment & theFragment, const G4double & T);
// Gives fragments charges
void ChooseZ(const G4Fragment & theFragment, const G4int & FragmentMultiplicity);
// -----------
G4double CalcEnergyConfiguration(const G4double A, const G4double Z, const G4int M,
G4double * ECOLA, G4double * EA, const G4int * Anumbers,
const G4double T);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Statistical weights
G4double W, WW2, WW3, WW4;
RWTValOrderedVector<G4double> W2, W3, W4;
// Number of configurations for breakups with multiplicities 2, 3 and 4
G4int M2, M3, M4;
// Atomic numbers of fragments for each configuration with multiplicities 2, 3 and 4
// RWTValOrderedVector<G4StatMF1DVector> ANum2;
// RWTValOrderedVector< RWTValVector<G4int> > ANum2;
RWTValOrderedVector< G4int* > ANum2;
// RWTValOrderedVector<G4StatMF1DVector> ANum3;
// RWTValOrderedVector< RWTValVector<G4int> > ANum3;
RWTValOrderedVector< G4int* > ANum3;
// RWTValOrderedVector<G4StatMF1DVector> ANum4;
// RWTValOrderedVector< RWTValVector<G4int> > ANum4;
RWTValOrderedVector< G4int* > ANum4;
// Statistical weight of compound nucleus
G4double WCompoundNucleus;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4StatMFParameters.hh
+67
View File
@@ -0,0 +1,67 @@
#ifndef G4StatMFParameters_h
#define G4StatMFParameters_h 1
#include "globals.hh"
class G4StatMFParameters
{
private:
static G4StatMFParameters theStatMFParameters;
// +----------------------+
// | Constant Parameters: |
// +----------------------+
// Kappa is used for calculate volume V_f for translational motion of fragments
static const G4double Kappa;
// KappaCoulomb is used for calculate Coulomb term energy
static const G4double KappaCoulomb;
// Inverse level density
static const G4double Epsilon0;
// Bethe-Weizsacker coefficients
static const G4double E0;
static const G4double Beta0;
static const G4double Gamma0;
// Critical temperature (for liquid-gas phase transitions)
static const G4double CriticalTemp;
// Nuclear radius
static const G4double r0;
// default constructor
G4StatMFParameters()
// :
// Kappa(1.0),
// KappaCoulomb(2.0),
// Epsilon0(16.0), // MeV
// E0(16.0), // MeV
// Beta0(18.0), // MeV
// Gamma0(25.0), // MeV
// CriticalTemp(18.0), // MeV
// r0(1.17) // fm
{}
public:
~G4StatMFParameters() {};
static G4StatMFParameters * GetAddress();
static G4double GetKappa() { return Kappa; }
static G4double GetKappaCoulomb() { return KappaCoulomb; }
static G4double GetEpsilon0() { return Epsilon0; }
static G4double GetE0() { return E0; }
static G4double GetBeta0() { return Beta0; }
static G4double GetGamma0() { return Gamma0; }
static G4double GetCriticalTemp() { return CriticalTemp; }
static G4double Getr0() { return r0; }
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4UnstableFermiFragment.hh
+52
View File
@@ -0,0 +1,52 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4UnstableFermiFragment_h
#define G4UnstableFermiFragment_h 1
#include "G4VFermiFragment.hh"
#include "Randomize.hh"
class G4UnstableFermiFragment : public G4VFermiFragment
{
public:
G4UnstableFermiFragment(const G4int anA, const G4int aZ, const G4int Pol, const G4double ExE):
G4VFermiFragment(anA,aZ,Pol,ExE)
{};
~G4UnstableFermiFragment();
protected:
G4UnstableFermiFragment();
private:
G4UnstableFermiFragment(const G4UnstableFermiFragment &right);
const G4UnstableFermiFragment & operator=(const G4UnstableFermiFragment &right);
G4bool operator==(const G4UnstableFermiFragment &right) const;
G4bool operator!=(const G4UnstableFermiFragment &right) const;
public:
RWTPtrOrderedVector<G4LorentzVector> *
FragmentsMomentum(G4double KinE, const G4int K, const G4double * Masses);
private:
G4double RNKSI(const G4int K);
G4ParticleMomentum IsotropicVector(const G4double Magnitude = 1.0);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VEmissionProbability.hh
+41
View File
@@ -0,0 +1,41 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4VEmissionProbability_h
#define G4VEmissionProbability_h 1
#include "globals.hh"
#include "G4Fragment.hh"
class G4VEmissionProbability
{
public:
G4VEmissionProbability() {};
virtual ~G4VEmissionProbability() {}; // *
private:
G4VEmissionProbability(const G4VEmissionProbability &right);
const G4VEmissionProbability & operator=(const G4VEmissionProbability &right);
G4bool operator==(const G4VEmissionProbability &right) const;
G4bool operator!=(const G4VEmissionProbability &right) const;
public:
virtual G4double EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation) = 0;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VEvaporation.hh
+41
View File
@@ -0,0 +1,41 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998) written from G4Evaporation.hh (May 1998)
//
#ifndef G4VEvaporation_h
#define G4VEvaporation_h 1
#include "globals.hh"
#include "G4Fragment.hh"
class G4VEvaporation
{
public:
G4VEvaporation() {};
virtual ~G4VEvaporation() {}; // *
private:
G4VEvaporation(const G4VEvaporation &right);
const G4VEvaporation & operator=(const G4VEvaporation &right);
G4bool operator==(const G4VEvaporation &right) const;
G4bool operator!=(const G4VEvaporation &right) const;
public:
virtual G4FragmentVector * BreakItUp(const G4Fragment &theNucleus) = 0;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VEvaporationChannel.hh
+54
View File
@@ -0,0 +1,54 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4VEvaporationChannel_h
#define G4VEvaporationChannel_h 1
#include "globals.hh"
#include "G4Fragment.hh"
class G4VEvaporationChannel
{
public:
G4VEvaporationChannel() {};
virtual ~G4VEvaporationChannel() {};
private:
G4VEvaporationChannel(const G4VEvaporationChannel & right);
const G4VEvaporationChannel & operator=(const G4VEvaporationChannel & right);
public:
G4bool operator==(const G4VEvaporationChannel & right) const;
G4bool operator!=(const G4VEvaporationChannel & right) const;
public:
virtual void Initialize(const G4Fragment & fragment) = 0;
virtual G4FragmentVector * BreakUp(const G4Fragment & theNucleus) = 0;
virtual G4double GetEmissionProbability(void) const = 0;
virtual inline G4int GetA(void) const { return 0; }
virtual inline G4int GetZ(void) const { return 0; }
virtual inline G4int GetResidualA(void) const { return 0; }
virtual inline G4int GetResidualZ(void) const { return 0; }
virtual inline G4int GetGamma(void) const { return 0; }
virtual inline G4double GetLevelDensityParameter(void) const { return 0.0; }
virtual inline G4double GetCoulombBarrier(void) const { return 0.0; }
virtual inline G4double GetMaximalKineticEnergy(void) const { return 0.0; };
virtual inline G4double GetFissionBarrier(void) const { return 0.0;}
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VFermiBreakUp.hh
+37
View File
@@ -0,0 +1,37 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4VFermiBreakUp_h
#define G4VFermiBreakUp_h 1
#include "globals.hh"
#include "G4FragmentVector.hh"
class G4VFermiBreakUp
{
public:
G4VFermiBreakUp();
virtual ~G4VFermiBreakUp();
private:
G4VFermiBreakUp(const G4VFermiBreakUp &right);
const G4VFermiBreakUp & operator=(const G4VFermiBreakUp &right);
G4bool operator==(const G4VFermiBreakUp &right) const;
G4bool operator!=(const G4VFermiBreakUp &right) const;
public:
virtual G4FragmentVector * BreakItUp(const G4Fragment &theNucleus) = 0;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VFermiFragment.hh
+71
View File
@@ -0,0 +1,71 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4VFermiFragment_h
#define G4VFermiFragment_h 1
#include "G4FragmentVector.hh"
#include "G4NucleiProperties.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
class G4VFermiFragment
{
public:
G4VFermiFragment(const G4int anA, const G4int aZ, const G4int Pol, const G4double ExE):
A(anA),
Z(aZ),
Polarization(Pol),
ExcitEnergy(ExE)
{}
virtual ~G4VFermiFragment() {};
protected:
G4VFermiFragment() {};
private:
G4VFermiFragment(const G4VFermiFragment &right);
const G4VFermiFragment & operator=(const G4VFermiFragment &right);
G4bool operator==(const G4VFermiFragment &right) const;
G4bool operator!=(const G4VFermiFragment &right) const;
public:
virtual G4FragmentVector * GetFragment(const G4LorentzVector & aMomentum) = 0;
G4int GetA(void) {return A;}
G4int GetZ(void) {return Z;}
G4int GetPolarization(void) {return Polarization;}
G4double GetExcitationEnergy(void) {return ExcitEnergy;}
G4double GetFragmentMass(void){
return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A) + ExcitEnergy;
}
protected:
G4int A;
G4int Z;
G4int Polarization;
G4double ExcitEnergy;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VFissionBarrier.hh
+39
View File
@@ -0,0 +1,39 @@
// 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.
//
// $Id: G4VFissionBarrier.hh,v 1.2 1998/11/13 17:38:59 larazb Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
#ifndef G4VFissionBarrier_h
#define G4VFissionBarrier_h 1
#include "globals.hh"
class G4VFissionBarrier
{
public:
G4VFissionBarrier() {};
virtual ~G4VFissionBarrier() {};
private:
G4VFissionBarrier(const G4VFissionBarrier & right);
const G4VFissionBarrier & operator=(const G4VFissionBarrier & right);
G4bool operator==(const G4VFissionBarrier & right) const;
G4bool operator!=(const G4VFissionBarrier & right) const;
public:
virtual G4double FissionBarrier(const G4int A, const G4int Z) = 0;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VGammaDeexcitation.hh
+99
View File
@@ -0,0 +1,99 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4VGammaDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4VGAMMADEEXCITATION_HH
#define G4VGAMMADEEXCITATION_HH
#include "globals.hh"
#include "G4VGammaTransition.hh"
#include "G4Fragment.hh"
#include "G4FragmentVector.hh"
class G4VGammaDeexcitation
{
public:
G4VGammaDeexcitation();
virtual ~G4VGammaDeexcitation();
virtual G4VGammaTransition* CreateTransition() = 0;
virtual G4bool CanDoTransition() const = 0;
// Single gamma transition
virtual G4FragmentVector* DoTransition();
// Chain of gamma transitions
virtual G4FragmentVector* DoChain();
virtual G4Fragment* GenerateGamma();
virtual const G4Fragment& GetNucleus() const;
virtual void SetNucleus(const G4Fragment& nucleus);
virtual void SetVerboseLevel(G4int verbose);
protected:
void Initialize();
void UpdateNucleus(const G4Fragment* gamma);
void Update(const G4Fragment* gamma);
G4VGammaTransition* _transition; // Owned pointer
G4int _verbose;
private:
G4Fragment _nucleus;
G4VGammaDeexcitation(const G4VGammaDeexcitation &right);
const G4VGammaDeexcitation& operator=(const G4VGammaDeexcitation &right);
G4bool operator==(const G4VGammaDeexcitation &right) const;
G4bool operator!=(const G4VGammaDeexcitation &right) const;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VGammaTransition.hh
+59
View File
@@ -0,0 +1,59 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4VGammaTransition
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4VGAMMATRANSITION_HH
#define G4VGAMMATRANSITION_HH
#include "globals.hh"
class G4VGammaTransition
{
public:
G4VGammaTransition() {};
virtual ~G4VGammaTransition() {};
virtual G4double GammaEnergy() = 0;
virtual G4double GetEnergyTo() const = 0;
virtual void SetEnergyFrom(const G4double energy) = 0;
private:
G4VGammaTransition(const G4VGammaTransition &right);
const G4VGammaTransition& operator=(const G4VGammaTransition &right);
G4bool operator==(const G4VGammaTransition &right) const;
G4bool operator!=(const G4VGammaTransition &right) const;
protected:
G4int _verbose;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VLevelDensityParameter.hh
+40
View File
@@ -0,0 +1,40 @@
// 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.
//
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#ifndef G4VLevelDensityParameter_h
#define G4VLevelDensityParameter_h 1
#include "globals.hh"
class G4VLevelDensityParameter
{
public:
G4VLevelDensityParameter() {};
virtual ~G4VLevelDensityParameter() {};
private:
G4VLevelDensityParameter(const G4VLevelDensityParameter &right);
const G4VLevelDensityParameter & operator=(const G4VLevelDensityParameter &right);
G4bool operator==(const G4VLevelDensityParameter &right) const;
G4bool operator!=(const G4VLevelDensityParameter &right) const;
public:
virtual G4double LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const = 0;
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VPhotonEvaporation.hh
+50
View File
@@ -0,0 +1,50 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4VPhotonEvaporation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4VPHOTONEVAPORATION_HH
#define G4VPHOTONEVAPORATION_HH
#include "globals.hh"
#include "G4Fragment.hh"
class G4VPhotonEvaporation
{
public:
G4VPhotonEvaporation() {};
virtual ~G4VPhotonEvaporation() {};
G4bool operator==(const G4VPhotonEvaporation &right) const;
G4bool operator!=(const G4VPhotonEvaporation &right) const;
virtual G4FragmentVector* BreakItUp(const G4Fragment &theNucleus) = 0;
private:
G4VPhotonEvaporation(const G4VPhotonEvaporation &right);
const G4VPhotonEvaporation& operator=(const G4VPhotonEvaporation &right);
};
#endif
source/processes/hadronic/models/generator/de_excitation/include/G4VStatMFCanonical.hh
+137
View File
@@ -0,0 +1,137 @@
#ifndef G4VStatMFCanonical_h
#define G4VStatMFCanonical_h 1
#include <rw/tvordvec.h>
#include "G4Fragment.hh"
#include "G4StatMFFragment.hh"
#include "G4StatMFParameters.hh"
#include "Randomize.hh"
class G4VStatMFCanonical
{
public:
G4VStatMFCanonical() {};
virtual ~G4VStatMFCanonical() {};
private:
// copy constructor
G4VStatMFCanonical(const G4VStatMFCanonical & right) {};
// operators
G4VStatMFCanonical & operator=(const G4VStatMFCanonical & right);
G4bool operator==(const G4VStatMFCanonical & right);
G4bool operator!=(const G4VStatMFCanonical & right);
public:
// Choice of fragment atomic numbers and charges
virtual void ChooseAandZ(const G4Fragment & theFragment) = 0;
G4double GetMeanMultiplicity(void) const {return MeanMultiplicity;}
G4double GetMeanTemperature(void) const { return MeanTemperature; }
G4double GetMeanEntropy(void) const { return MeanEntropy; }
G4int GetMultiplicity(void) const { return Multiplicity; }
G4int GetFragmentA(const G4int & i) const
{
if (i < FragmentsA.entries() && i >= 0) return FragmentsA(i);
else {
cout << "G4VStatMFCanonical::GetFragmentA: trying to get access to fragment "
<< i << " from a total of "
<< FragmentsZ.entries() << " fragments" << endl;
return -1;
}
}
G4int GetFragmentZ(const G4int & i) const
{
if (i < FragmentsZ.entries() && i >= 0) return FragmentsZ(i);
else {
cout << "G4VStatMFCanonical::GetFragmentZ: trying to get access to fragment "
<< i << " from a total of "
<< FragmentsZ.entries() << " fragments" << endl;
return -1;
}
}
G4double GetFragmentInvLevelDensity(const G4int & i) const
{
if (i < theChannels.length() && i >= 0) return theChannels(i)->GetInvLevelDensity();
else {
cout << "G4VStatMFCanonical::GetFragmentInvLevelDensity: trying to get access to channel "
<< i << " from a total of "
<< theChannels.length() << " channels." << endl;
return 0;
}
}
void SortFragments(void);
G4int GetNumOfNeutrons(void) const { return NumOfNeutrons; }
G4int GetNumOfCharged(void) const { return NumOfCharged; }
G4int GetOrderedA(const G4int & i) const
{
if (i < OrderedA.entries()) return OrderedA(i);
else return 0;
}
G4int GetOrderedZ(const G4int & i) const
{
if (i < OrderedZ.entries()) return OrderedZ(i);
else return 0;
}
G4double Beta(const G4double & T) const ;
G4double DBetaDT(const G4double & T) const ;
protected:
// the possible channels
RWTPtrOrderedVector<G4StatMFFragment> theChannels;
// Free internal energy at temperature T = 0
G4double FreeInternalE0;
// Mean breakup multiplicity
G4double MeanMultiplicity;
// Mean channel temperature
G4double MeanTemperature;
// Mean channel entropy
G4double MeanEntropy;
// Multiplicity
G4int Multiplicity;
// Fragment Atomic Numbers
RWTValOrderedVector<G4int> FragmentsA;
// Fragment Charges
RWTValOrderedVector<G4int> FragmentsZ;
G4int NumOfNeutrons;
G4int NumOfCharged;
RWTValOrderedVector<G4int> OrderedA;
RWTValOrderedVector<G4int> OrderedZ;
};
#endif
source/processes/hadronic/models/generator/de_excitation/src/G4B9FermiFragment.cc
+96
View File
@@ -0,0 +1,96 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4B9FermiFragment.hh"
G4B9FermiFragment::G4B9FermiFragment()
{
}
G4B9FermiFragment::G4B9FermiFragment(const G4B9FermiFragment &right)
{
G4Exception("G4B9FermiFragment::copy_constructor meant to not be accessable");
}
G4B9FermiFragment::~G4B9FermiFragment()
{
}
const G4B9FermiFragment & G4B9FermiFragment::operator=(const G4B9FermiFragment &right)
{
G4Exception("G4B9FermiFragment::operator= meant to not be accessable");
return *this;
}
G4bool G4B9FermiFragment::operator==(const G4B9FermiFragment &right) const
{
return false;
}
G4bool G4B9FermiFragment::operator!=(const G4B9FermiFragment &right) const
{
return true;
}
G4FragmentVector * G4B9FermiFragment::GetFragment(const G4LorentzVector & aMomentum)
// B9 ----> alpha + alpha + proton
{
const G4int NumSubFrag = 3;
G4double Masses[NumSubFrag];
G4double Charges[NumSubFrag];
G4double AtomNum[NumSubFrag];
Masses[0] = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(2,4); // alpha
Masses[1] = Masses[0]; // alpha
Masses[2] = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(1,1); // proton
AtomNum[0] = 4;
AtomNum[1] = 4;
AtomNum[2] = 1;
Charges[0] = 2;
Charges[1] = 2;
Charges[2] = 1;
// G4double AvalKineticE = G4NucleiPropertiesTable::GetMassExcess(Z,A) + ExcitEnergy - // B9
// G4NucleiPropertiesTable::GetMassExcess(1,1) - // proton
// 2.0*G4NucleiPropertiesTable::GetMassExcess(2,4);
G4double AvalKineticE = sqrt(aMomentum.e()*aMomentum.e() -
aMomentum.vect().mag2()) - // B9
Masses[2] - // proton
2.0*Masses[0];
RWTPtrOrderedVector<G4LorentzVector> * SubFragsMomentum =
FragmentsMomentum(AvalKineticE, NumSubFrag,Masses);
G4FragmentVector * theResult = new G4FragmentVector;
for (G4int i = 0; i < NumSubFrag; i++) {
// Lorentz boost
SubFragsMomentum->at(i)->boost(aMomentum.boostVector());
theResult->insert(new G4Fragment(AtomNum[i],Charges[i],*(SubFragsMomentum->at(i))));
}
SubFragsMomentum->clearAndDestroy();
delete SubFragsMomentum;
return theResult;
}
source/processes/hadronic/models/generator/de_excitation/src/G4Be8FermiFragment.cc
+92
View File
@@ -0,0 +1,92 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4Be8FermiFragment.hh"
G4Be8FermiFragment::G4Be8FermiFragment()
{
}
G4Be8FermiFragment::G4Be8FermiFragment(const G4Be8FermiFragment &right)
{
G4Exception("G4Be8FermiFragment::copy_constructor meant to not be accessable");
}
G4Be8FermiFragment::~G4Be8FermiFragment()
{
}
const G4Be8FermiFragment & G4Be8FermiFragment::operator=(const G4Be8FermiFragment &right)
{
G4Exception("G4Be8FermiFragment::operator= meant to not be accessable");
return *this;
}
G4bool G4Be8FermiFragment::operator==(const G4Be8FermiFragment &right) const
{
return false;
}
G4bool G4Be8FermiFragment::operator!=(const G4Be8FermiFragment &right) const
{
return true;
}
G4FragmentVector * G4Be8FermiFragment::GetFragment(const G4LorentzVector & aMomentum)
// Be8 ----> alpha + alpha
{
const G4int NumSubFrag = 2;
G4double Masses[NumSubFrag];
G4double Charges[NumSubFrag];
G4double AtomNum[NumSubFrag];
Masses[0] = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(2,4); // alpha
Masses[1] = Masses[0]; // alpha
AtomNum[0] = 4;
AtomNum[1] = 4;
Charges[0] = 2;
Charges[1] = 2;
// G4double AvalKineticE = G4NucleiPropertiesTable::GetMassExcess(Z,A) + ExcitEnergy - // Be8
// 2.0*G4NucleiPropertiesTable::GetMassExcess(2,4); // alphas
G4double AvalKineticE = sqrt(aMomentum.e()*aMomentum.e() -
aMomentum.vect().mag2()) -// Be8
2.0*AtomNum[0]; // alphas
RWTPtrOrderedVector<G4LorentzVector> * SubFragsMomentum =
FragmentsMomentum(AvalKineticE, NumSubFrag,Masses);
G4FragmentVector * theResult = new G4FragmentVector;
for (G4int i = 0; i < NumSubFrag; i++) {
// Lorentz boost
SubFragsMomentum->at(i)->boost(aMomentum.boostVector());
theResult->insert(new G4Fragment(AtomNum[i],Charges[i],*(SubFragsMomentum->at(i))));
}
SubFragsMomentum->clearAndDestroy();
delete SubFragsMomentum;
return theResult;
}
source/processes/hadronic/models/generator/de_excitation/src/G4CompetitiveFission.cc
+460
View File
@@ -0,0 +1,460 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
// some corrections by V. Krylov (Oct. 1988)
// some corrections to V. Krylov by V. Lara (Dec. 1988)
#include "G4CompetitiveFission.hh"
G4CompetitiveFission::G4CompetitiveFission()
{
theFissionBarrierPtr = new G4FissionBarrier;
MyOwnFissionBarrier = true;
theFissionProbabilityPtr = new G4FissionProbability(this);
MyOwnFissionProbability = true;
theLevelDensityPtr = new G4FissionLevelDensityParameter;
MyOwnLevelDensity = true;
MaximalKineticEnergy = -1000.0*MeV;
FissionBarrier = 0.0;
FissionProbability = 0.0;
LevelDensityParameter = 0.0;
}
G4CompetitiveFission::G4CompetitiveFission(const G4CompetitiveFission &right)
{
}
G4CompetitiveFission::~G4CompetitiveFission()
{
if (MyOwnFissionBarrier) delete theFissionBarrierPtr;
if (MyOwnFissionProbability) delete theFissionProbabilityPtr;
if (MyOwnLevelDensity) delete theLevelDensityPtr;
}
const G4CompetitiveFission & G4CompetitiveFission::operator=(const G4CompetitiveFission &right)
{
G4Exception("G4CompetitiveFission::operator= meant to not be accessable");
return *this;
}
G4bool G4CompetitiveFission::operator==(const G4CompetitiveFission &right) const
{
return (this == (G4CompetitiveFission *) &right);
}
G4bool G4CompetitiveFission::operator!=(const G4CompetitiveFission &right) const
{
return (this != (G4CompetitiveFission *) &right);
}
void G4CompetitiveFission::Initialize(const G4Fragment & fragment)
{
G4int anA = fragment.GetA();
G4int aZ = fragment.GetZ();
G4double ExEnergy = fragment.GetExcitationEnergy();
// Calculate Fission Barrier
FissionBarrier = theFissionBarrierPtr->FissionBarrier(anA,aZ);
// Saddle point excitation energy ---> A = 65
// Fission is excluded for A < 65
if (anA >= 65) {
MaximalKineticEnergy = ExEnergy - FissionBarrier;
LevelDensityParameter = theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
FissionProbability = theFissionProbabilityPtr->EmissionProbability(fragment,0);
}
else {
MaximalKineticEnergy = -1000.0*MeV;
LevelDensityParameter = 0.0;
FissionProbability = 0.0;
}
return;
}
G4FragmentVector * G4CompetitiveFission::BreakUp(const G4Fragment & theNucleus)
{
// Nucleus data
// Excitation energy (in MeV)
G4double U = theNucleus.GetExcitationEnergy()/MeV;
// Check that U > 0
if (U <= 0.0) {
G4FragmentVector * theResult = new G4FragmentVector;
theResult->insert(new G4Fragment(theNucleus));
return theResult;
}
// Atomic number of nucleus
G4int A = theNucleus.GetA();
// Charge of nucleus
G4int Z = theNucleus.GetZ();
// Atomic Mass of Nucleus (in MeV)
G4double M = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A)/MeV;
// Nucleus Momentum
G4LorentzVector theNucleusMomentum = theNucleus.GetMomentum();
// Calculate fission parameters
G4FissionParameters theParameters(A,Z,U*MeV,FissionBarrier);
// First fragment
G4int A1 = 0;
G4int Z1 = 0;
G4double M1 = 0.0;
// Second fragment
G4int A2 = 0;
G4int Z2 = 0;
G4double M2 = 0.0;
G4double FragmentsExcitationEnergy = 0.0;
G4double FragmentsKineticEnergy = 0.0;
G4int Trials = 0;
do {
// First fragment
A1 = FissionAtomicNumber(A,theParameters);
Z1 = FissionCharge(A,Z,A1);
M1 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z1,A1)/MeV;
// Second Fragment
A2 = A - A1;
Z2 = Z - Z1;
if (A2 < 1 || Z2 < 0)
G4Exception("G4CompetitiveFission::BreakUp: Can't define second fragment! ");
M2 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z2,A2)/MeV;
// Check that fragment masses are less or equal than total energy
// if (M1 + M2 > theNucleusMomentum.mag()/MeV)
if (M1 + M2 > theNucleusMomentum.e()/MeV)
G4Exception("G4CompetitiveFission::BreakUp: Fragments Mass > Total Energy");
// Maximal Kinetic Energy (available energy for fragments)
// G4double Tmax = theNucleusMomentum.mag()/MeV - M1 - M2;
G4double Tmax = M + U - M1 - M2;
FragmentsKineticEnergy = FissionKineticEnergy( A , Z,
A1, Z1,
A2, Z2,
U , Tmax,
theParameters);
// Excitation Energy
FragmentsExcitationEnergy = Tmax - FragmentsKineticEnergy;
} while (FragmentsExcitationEnergy < 0.0 && Trials++ < 100);
if (FragmentsExcitationEnergy <= 0.0)
G4Exception("G4CompetitiveFission::BreakItUp: Excitation energy for fragments < 0.0!");
// while (FragmentsExcitationEnergy < 0 && Trials < 100);
// Fragment 1
G4double U1 = FragmentsExcitationEnergy * (G4double(A1)/G4double(A));
// Fragment 2
G4double U2 = FragmentsExcitationEnergy * (G4double(A2)/G4double(A));
G4double Pmax = sqrt( 2 * ( ( (M1+U1)*(M2+U2) ) /
( (M1+U1)+(M2+U2) ) ) * FragmentsKineticEnergy);
G4ParticleMomentum momentum1 = IsotropicVector( Pmax );
G4ParticleMomentum momentum2( -momentum1 );
// Perform a Galileo boost for fragments
momentum1 += (theNucleusMomentum.boostVector() * (M1+U1));
momentum2 += (theNucleusMomentum.boostVector() * (M2+U2));
// Create 4-momentum for first fragment
// Warning!! Energy conservation is broken
G4LorentzVector FourMomentum1( momentum1 , sqrt(momentum1.mag2() + (M1+U1)*(M1+U1)));
// Create 4-momentum for second fragment
// Warning!! Energy conservation is broken
G4LorentzVector FourMomentum2( momentum2 , sqrt(momentum2.mag2() + (M2+U2)*(M2+U2)));
// Create Fragments
G4Fragment * Fragment1 = new G4Fragment( A1, Z1, FourMomentum1);
if (!Fragment1) G4Exception("G4CompetitiveFission::BreakItUp: Can't create Fragment1! ");
G4Fragment * Fragment2 = new G4Fragment( A2, Z2, FourMomentum2);
if (!Fragment2) G4Exception("G4CompetitiveFission::BreakItUp: Can't create Fragment2! ");
// Create Fragment Vector
G4FragmentVector * theResult = new G4FragmentVector;
theResult->insert(Fragment1);
theResult->insert(Fragment2);
return theResult;
}
G4int G4CompetitiveFission::FissionAtomicNumber(const G4int A, const G4FissionParameters & theParam)
// Calculates the atomic number of a fission product
{
// For Simplicity reading code
const G4double A1 = theParam.GetA1();
const G4double A2 = theParam.GetA2();
const G4double As = theParam.GetAs();
const G4double Sigma1 = theParam.GetSigma1();
const G4double Sigma2 = theParam.GetSigma2();
const G4double SigmaS = theParam.GetSigmaS();
const G4double w = theParam.GetW();
G4double FasymAsym = 2.0*exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) +
exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
G4double FsymA1A2 = exp(-((As-(A1+A2))*(As-(A1+A2)))/(2.0*SigmaS*SigmaS));
G4double C2A = A2 + 3.72*Sigma2;
G4double C2S = As + 3.72*SigmaS;
G4double C2 = 0.0;
if (w > 1000.0 ) C2 = C2S;
else if (w < 0.001) C2 = C2A;
else C2 = max(C2A,C2S);
G4double C1 = A-C2;
if (C1 < 30.0) {
C2 = A-30.0;
C1 = 30.0;
}
G4double Am1 = (As + A1)/2.0;
G4double Am2 = (A1 + A2)/2.0;
// Get Mass distributions as sum of symmetric and asymmetric Gasussians
G4double Mass1 = MassDistribution(As,A,theParam);
G4double Mass2 = MassDistribution(Am1,A,theParam);
G4double Mass3 = MassDistribution(A1,A,theParam);
G4double Mass4 = MassDistribution(Am2,A,theParam);
G4double Mass5 = MassDistribution(A2,A,theParam);
// get maximal value among Mass1,...,Mass5
G4double MassMax = Mass1;
if (Mass2 > MassMax) MassMax = Mass2;
if (Mass3 > MassMax) MassMax = Mass3;
if (Mass4 > MassMax) MassMax = Mass4;
if (Mass5 > MassMax) MassMax = Mass5;
// Sample a fragment mass number, which lies between C1 and C2
G4double m;
G4double Pm;
do {
m = C1+G4UniformRand()*(C2-C1);
Pm = MassDistribution(m,A,theParam);
} while (G4UniformRand() > Pm/MassMax);
// return static_cast<G4int>(m+0.5);
return G4int(m+0.5);
}
G4double G4CompetitiveFission::MassDistribution(const G4double x, const G4double A,
const G4FissionParameters & theParam)
// This method gives mass distribution F(x) = F_{asym}(x)+w*F_{sym}(x)
// which consist of symmetric and asymmetric sum of gaussians components.
{
G4double Xsym = exp(-0.5*(x-theParam.GetAs())*(x-theParam.GetAs())/
(theParam.GetSigmaS()*theParam.GetSigmaS()));
G4double Xasym = exp(-0.5*(x-theParam.GetA2())*(x-theParam.GetA2())/
(theParam.GetSigma2()*theParam.GetSigma2())) +
exp(-0.5*(x-(A-theParam.GetA2()))*(x-(A-theParam.GetA2()))/
(theParam.GetSigma2()*theParam.GetSigma2())) +
0.5*exp(-0.5*(x-theParam.GetA1())*(x-theParam.GetA1())/
(theParam.GetSigma1()*theParam.GetSigma1())) +
0.5*exp(-0.5*(x-(A-theParam.GetA1()))*(x-(A-theParam.GetA1()))/
(theParam.GetSigma1()*theParam.GetSigma1()));
if (theParam.GetW() > 1000) return Xsym;
else if (theParam.GetW() < 0.001) return Xasym;
else return theParam.GetW()*Xsym+Xasym;
}
G4int G4CompetitiveFission::FissionCharge(const G4double A,
const G4double Z,
const G4double Af)
// Calculates the charge of a fission product for a given atomic number Af
{
const G4double sigma = 0.6;
G4double DeltaZ = 0.0;
if (Af >= 134.0) DeltaZ = -0.45; // 134 <= Af
else if (A <= (A-134.0)) DeltaZ = 0.45; // Af <= (A-134)
else DeltaZ = -0.45*(Af-(A/2.0))/(134.0-(A/2.0)); // (A-134) < Af < 134
G4double Zmean = (Af/A)*Z + DeltaZ;
G4double theZ;
do {
theZ = RandGauss::shoot(Zmean,sigma);
} while (theZ < 1.0 || theZ > (Z-1.0) || theZ > Af);
// return static_cast<G4int>(theZ+0.5);
return G4int(theZ+0.5);
}
G4double G4CompetitiveFission::FissionKineticEnergy(const G4double A, const G4double Z,
const G4double Af1, const G4double Zf1,
const G4double Af2, const G4double Zf2,
const G4double U, const G4double Tmax,
const G4FissionParameters & theParam)
// Gives the kinetic energy of fission products
{
// Find maximal value of A for fragments
G4double AfMax = max(Af1,Af2);
if (AfMax < (A/2.0)) AfMax = A - AfMax;
// Weights for symmetric and asymmetric components
G4double Pas;
if (theParam.GetW() > 1000) Pas = 0.0;
else {
G4double P1 = 0.5*exp(-0.5*(AfMax-theParam.GetA1())*(AfMax-theParam.GetA1())/
(theParam.GetSigma1()*theParam.GetSigma1()));
G4double P2 = exp(-0.5*(AfMax-theParam.GetA2())*(AfMax-theParam.GetA2())/
(theParam.GetSigma2()*theParam.GetSigma2()));
Pas = P1+P2;
}
G4double Ps;
if (theParam.GetW() < 0.001) Ps = 0.0;
else
Ps = theParam.GetW()*exp(-0.5*(AfMax-theParam.GetAs())*(AfMax-theParam.GetAs())/
(theParam.GetSigmaS()*theParam.GetSigmaS()));
G4double Psy = Ps/(Pas+Ps);
// Fission fractions Xsy and Xas formed in symmetric and asymmetric modes
G4double PPas = theParam.GetSigma1() + 2.0 * theParam.GetSigma2();
G4double PPsy = theParam.GetW() * theParam.GetSigmaS();
G4double Xas = PPas / (PPas+PPsy);
G4double Xsy = PPsy / (PPas+PPsy);
// Average kinetic energy for symmetric and asymmetric components
G4double Eaverage = 0.1071*(Z*Z)/pow(A,1.0/3.0) + 22.2;
// Compute maximal average kinetic energy of fragments and Energy Dispersion (sqrt)
G4double TaverageAfMax;
G4double ESigma;
// Select randomly fission mode (symmetric or asymmetric)
if (G4UniformRand() > Psy) { // Asymmetric Mode
G4double A11 = theParam.GetA1()-0.7979*theParam.GetSigma1();
G4double A12 = theParam.GetA1()+0.7979*theParam.GetSigma1();
G4double A21 = theParam.GetA2()-0.7979*theParam.GetSigma2();
G4double A22 = theParam.GetA2()+0.7979*theParam.GetSigma2();
// scale factor
G4double ScaleFactor = 0.5*theParam.GetSigma1()*(AsymmetricRatio(A,A11)+AsymmetricRatio(A,A12))+
theParam.GetSigma2()*(AsymmetricRatio(A,A21)+AsymmetricRatio(A,A22));
// Compute average kinetic energy for fragment with AfMax
TaverageAfMax = (Eaverage + 12.5 * Xsy) * (PPas/ScaleFactor) * AsymmetricRatio(A,AfMax);
ESigma = 10.0; // MeV
} else { // Symmetric Mode
G4double As0 = theParam.GetAs() + 0.7979*theParam.GetSigmaS();
// scale factor
G4double ScaleFactor = theParam.GetW()*theParam.GetSigmaS()*SymmetricRatio(A,As0);
// Compute average kinetic energy for fragment with AfMax
TaverageAfMax = (Eaverage - 12.5*Xas) * (PPsy/ScaleFactor) * SymmetricRatio(A,AfMax);
ESigma = 8.0; // MeV
}
// Select randomly, in accordance with Gaussian distribution, fragment kinetic energy
G4double KineticEnergy;
G4int i = 0;
do {
KineticEnergy = RandGauss::shoot(TaverageAfMax,ESigma);
if (i++ > 100) return Eaverage;
} while (KineticEnergy < Eaverage-3.72*ESigma ||
KineticEnergy > Eaverage+3.72*ESigma ||
KineticEnergy > Tmax);
return KineticEnergy;
}
G4double G4CompetitiveFission::AsymmetricRatio(const G4double A,const G4double A11)
{
const G4double B1 = 23.5;
const G4double A00 = 134.0;
return Ratio(A,A11,B1,A00);
}
G4double G4CompetitiveFission::SymmetricRatio(const G4double A,const G4double A11)
{
const G4double B1 = 5.32;
const G4double A00 = A/2.0;
return Ratio(A,A11,B1,A00);
}
G4double G4CompetitiveFission::Ratio(const G4double A,const G4double A11,
const G4double B1,const G4double A00)
{
if (A == 0) G4Exception("G4CompetitiveFission::Ratio: A == 0!");
if (A11 >= A/2.0 && A11 <= (A00+10.0)) return 1.0-B1*((A11-A00)/A)*((A11-A00)/A);
else return 1.0-B1*(10.0/A)*(10.0/A)-2.0*(10.0/A)*B1*((A11-A00-10.0)/A);
}
G4ThreeVector G4CompetitiveFission::IsotropicVector(const G4double Magnitude)
// Samples a isotropic random vectorwith a magnitud given by Magnitude.
// By default Magnitude = 1.0
{
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);
return Vector;
}
source/processes/hadronic/models/generator/de_excitation/src/G4ConstantLevelDensityParameter.cc
+46
View File
@@ -0,0 +1,46 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// Constant level density parameter (for photon evaporation)
//
// by C. Dallapiccola (Nov 1998)
//
#include "G4ConstantLevelDensityParameter.hh"
G4ConstantLevelDensityParameter::
G4ConstantLevelDensityParameter(const G4ConstantLevelDensityParameter& right) :
EvapLevelDensityParameter(0.125*(1./MeV))
{
G4Exception("G4ConstantLevelDensityParameter::copy_constructor meant to not be accessable");
}
const G4ConstantLevelDensityParameter & G4ConstantLevelDensityParameter::
operator=(const G4ConstantLevelDensityParameter &right)
{
G4Exception("G4ConstantLevelDensityParameter::operator= meant to not be accessable");
return *this;
}
G4bool G4ConstantLevelDensityParameter::operator==(const G4ConstantLevelDensityParameter &right) const
{
return false;
}
G4bool G4ConstantLevelDensityParameter::operator!=(const G4ConstantLevelDensityParameter &right) const
{
return true;
}
source/processes/hadronic/models/generator/de_excitation/src/G4ContinuumGammaDeexcitation.cc
+131
View File
@@ -0,0 +1,131 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4ContinuumGammaDeexcitation
//
// Authors: Carlo Dallapiccola (dallapiccola@umdhep.umd.edu)
// Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
//
// Class G4ContinuumGammaDeexcitation.cc
//
// Concrete class derived from G4VGammaDeexcitation
//
//
#include "G4ContinuumGammaDeexcitation.hh"
#include "G4Gamma.hh"
#include "G4ContinuumGammaTransition.hh"
#include "G4NuclearLevelManager.hh"
#include "G4Fragment.hh"
#include "G4ConstantLevelDensityParameter.hh"
//
// Constructor
//
G4ContinuumGammaDeexcitation::G4ContinuumGammaDeexcitation(): _Z(0), _A(0)
{ }
G4ContinuumGammaDeexcitation::~G4ContinuumGammaDeexcitation()
{ }
G4VGammaTransition* G4ContinuumGammaDeexcitation::CreateTransition()
{
G4Fragment nucleus = GetNucleus();
G4int Z = nucleus.GetZ();
G4int A = nucleus.GetA();
G4double excitation = nucleus.GetExcitationEnergy();
if (_A != A || _Z != Z)
{
_levelManager.SetNucleus(Z,A);
_A = A;
_Z = Z;
}
if (_verbose > 1)
G4cout << "G4ContinuumGammaDeexcitation::CreateTransition - Created" << endl;
return new G4ContinuumGammaTransition(_levelManager,Z,A,excitation,_verbose );
}
G4bool G4ContinuumGammaDeexcitation::CanDoTransition() const
{
G4bool canDo = true;
if (_transition == 0)
{
canDo = false;
if (_verbose > 0)
G4cout
<< "G4ContinuumGammaDeexcitation::CanDoTransition - Null transition "
<< endl;
}
G4Fragment nucleus = GetNucleus();
G4double excitation = nucleus.GetExcitationEnergy();
G4double A = nucleus.GetA();
G4double Z = nucleus.GetZ();
if (A <2 || Z<3)
{
canDo = false;
if (_verbose > 0)
G4cout
<< "G4ContinuumGammaDeexcitation::CanDoTransition - n/p/H"
<< endl;
}
if (excitation <= 0.)
{
canDo = false;
if (_verbose > 0)
G4cout
<< "G4ContinuumGammaDeexcitation::CanDoTransition - Excitation <= 0"
<< endl;
}
if (excitation <= _levelManager.MaxLevelEnergy())
{
canDo = false;
if (_verbose > 0)
G4cout << "G4ContinuumGammaDeexcitation::CanDoTransition - Excitation "
<< excitation << " below max discrete level "
<< _levelManager.MaxLevelEnergy() << endl;
}
if (canDo)
{ if (_verbose > 1)
G4cout <<"G4ContinuumGammaDeexcitation::CanDoTransition - CanDo"
<< endl;
}
return canDo;
}
source/processes/hadronic/models/generator/de_excitation/src/G4ContinuumGammaTransition.cc
+191
View File
@@ -0,0 +1,191 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4ContinuumGammaTransition
//
// Authors: Carlo Dallapiccola (dallapiccola@umdhep.umd.edu)
// Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
//
// Class G4ContinuumGammaTransition.cc
//
#include "G4ContinuumGammaTransition.hh"
#include "G4VLevelDensityParameter.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "G4RandGeneralTmp.hh"
//
// Constructor
//
G4ContinuumGammaTransition::G4ContinuumGammaTransition(const G4NuclearLevelManager& levelManager,
G4int Z, G4int A, G4double excitation,
G4int verbose):
_Z(Z), _A(A), _excitation(excitation), _levelManager(levelManager)
{
const G4PtrLevelVector* levels = levelManager.GetLevels();
G4double eTolerance = 0.;
if (levels != 0)
{
G4int lastButOne = levelManager.NumberOfLevels() - 2;
if (lastButOne >= 0)
{
eTolerance = levelManager.MaxLevelEnergy() - levels->at(lastButOne)->Energy();
if (eTolerance < 0.) eTolerance = 0.;
}
}
_verbose = verbose;
_eGamma = 0.;
_maxLevelE = levelManager.MaxLevelEnergy() + eTolerance;
_minLevelE = levelManager.MinLevelEnergy();
// Energy range for photon generation; upper limit is defined 5*Gamma(GDR) from GDR peak
_eMin = 0.001 * MeV;
// Giant Dipole Resonance energy
G4double energyGDR = (40.3 / pow(_A,0.2) ) * MeV;
// Giant Dipole Resonance width
G4double widthGDR = 0.30 * energyGDR;
// Extend
G4double factor = 5;
_eMax = energyGDR + factor * widthGDR;
if (_eMax > excitation) _eMax = _excitation;
}
//
// Destructor
//
G4ContinuumGammaTransition::~G4ContinuumGammaTransition() {}
//
// Override GammaEnergy function from G4VGammaTransition
//
G4double G4ContinuumGammaTransition::GammaEnergy()
{
_eGamma = 0.;
G4int nBins = 200;
G4double sampleArray[200];
G4int i;
for (i=0; i<nBins; i++)
{
G4double e = _eMin + ( (_eMax - _eMin) / nBins) * i;
sampleArray[i] = E1Pdf(e);
if(_verbose > 10)
G4cout << "*---* G4ContinuumTransition: e = " << e
<< " pdf = " << sampleArray[i] << endl;
}
G4RandGeneralTmp randGeneral(sampleArray, nBins);
G4double random = randGeneral.shoot();
_eGamma = _eMin + (_eMax - _eMin) * random;
G4double finalExcitation = _excitation - _eGamma;
if(_verbose > 10)
G4cout << "*---*---* G4ContinuumTransition: eGamma = " << _eGamma
<< " finalExcitation = " << finalExcitation
<< " random = " << random << endl;
if (finalExcitation < 0)
{
_eGamma = _excitation;
finalExcitation = 0.;
}
if (finalExcitation < _maxLevelE && finalExcitation > 0.)
{
G4double levelE = _levelManager.NearestLevel(finalExcitation)->Energy();
G4double diff = finalExcitation - levelE;
_eGamma = _eGamma + diff;
}
return _eGamma;
}
G4double G4ContinuumGammaTransition::GetEnergyTo() const
{
G4double excitation = _excitation - _eGamma;
if (excitation < 0.) excitation = 0.;
return excitation ;
}
void G4ContinuumGammaTransition::SetEnergyFrom(const G4double energy)
{
if (energy > 0.) _excitation = energy;
return;
}
G4double G4ContinuumGammaTransition::E1Pdf(G4double e)
{
G4double theProb = 0.0;
if( (_excitation - e) < 0.0 || e < 0 || _excitation < 0) return theProb;
G4ConstantLevelDensityParameter ldPar;
G4double aLevelDensityParam = ldPar.LevelDensityParameter(_A,_Z,_excitation);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*_excitation));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(_excitation - e)));
if(_verbose > 20)
G4cout << _A << " LevelDensityParameter = " << aLevelDensityParam
<< " Bef Aft " << levelDensBef << " " << levelDensAft << endl;
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
// G4double sigma0 = 2.5 * _A * millibarn;
G4double sigma0 = 2.5 * _A;
G4double Egdp = (40.3 / pow(_A,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / (pi * hbarc)*(pi * hbarc);
G4double numerator = sigma0 * e*e * GammaR*GammaR;
G4double denominator = (e*e - Egdp*Egdp)* (e*e - Egdp*Egdp) + GammaR*GammaR*e*e;
// if (denominator < 1.0e-9) denominator = 1.0e-9;
G4double sigmaAbs = numerator/denominator ;
if(_verbose > 20)
G4cout << ".. " << Egdp << " .. " << GammaR
<< " .. " << normC << " .. " << sigmaAbs
<< " .. " << e*e << " .. " << levelDensAft/levelDensBef
<< endl;
// theProb = normC * sigmaAbs * e*e * levelDensAft/levelDensBef;
theProb = sigmaAbs * e*e * levelDensAft/levelDensBef;
return theProb;
}
source/processes/hadronic/models/generator/de_excitation/src/G4DiscreteGammaDeexcitation.cc
+151
View File
@@ -0,0 +1,151 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4DiscreteGammaDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#include "G4DiscreteGammaDeexcitation.hh"
#include "G4DiscreteGammaTransition.hh"
#include "G4NuclearLevelManager.hh"
G4DiscreteGammaDeexcitation::G4DiscreteGammaDeexcitation(): _Z(0),_A(0)
{
_tolerance = 0.1 * MeV;
}
G4DiscreteGammaDeexcitation::~G4DiscreteGammaDeexcitation() {}
G4VGammaTransition* G4DiscreteGammaDeexcitation::CreateTransition()
{
G4Fragment nucleus = GetNucleus();
G4int A = nucleus.GetA();
G4int Z = nucleus.GetZ();
if (_levelManager.IsValid(Z,A))
{
if (_verbose > 1)
G4cout
<< "G4DiscreteGammaDeexcitation::CreateTransition - (A,Z) is valid "
<< endl;
if (_A != A || _Z != Z)
{
_levelManager.SetNucleus(Z,A);
_A = A;
_Z = Z;
}
G4double excitation = nucleus.GetExcitationEnergy();
// const G4NuclearLevel* level =_levelManager.NearestLevel(excitation, _tolerance);
const G4NuclearLevel* level =_levelManager.NearestLevel(excitation);
if (level != 0)
{
if (_verbose > 0)
G4cout
<< "G4DiscreteGammaDeexcitation::CreateTransition - Created from level energy "
<< level->Energy() << ", excitation is "
<< excitation << endl;
return new G4DiscreteGammaTransition(*level);
}
else
{
if (_verbose > 0)
G4cout
<< "G4DiscreteGammaDeexcitation::CreateTransition - No transition created from "
<< excitation << " within tolerance " << _tolerance << endl;
return 0;
}
}
else return 0;
}
G4bool G4DiscreteGammaDeexcitation::CanDoTransition() const
{
G4bool canDo = true;
if (_transition == 0)
{
canDo = false;
if (_verbose > 0)
G4cout
<< "G4DiscreteGammaDeexcitation::CanDoTransition - Null transition "
<< endl;
}
G4Fragment nucleus = GetNucleus();
G4double A = nucleus.GetA();
G4double Z = nucleus.GetZ();
if (A <2 || Z<3 || Z>92)
{
canDo = false;
if (_verbose > 0)
G4cout
<< "G4DiscreteGammaDeexcitation::CanDoTransition - n/p/H/>U"
<< endl;
}
G4double excitation = nucleus.GetExcitationEnergy();
if (excitation <= 0.)
{
canDo = false;
if (_verbose > 0)
G4cout
<< "G4DiscreteGammaDeexcitation::CanDoTransition - Excitation <= 0"
<< endl;
}
if (excitation > _levelManager.MaxLevelEnergy() + _tolerance) canDo = false;
if (excitation < _levelManager.MinLevelEnergy() - _tolerance) canDo = false;
// The following is a protection to avoid looping in case of elements with very low
// ensdf levels
if (excitation < _levelManager.MinLevelEnergy() * 0.9) canDo = false;
if (_verbose > 0)
{
G4cout << "G4DiscreteGammaDeexcitation::CanDoTransition - Excitation "
<< excitation << ", Min-Max are "
<< _levelManager.MinLevelEnergy() << " "
<< _levelManager.MaxLevelEnergy() << endl;
}
if (canDo)
{ if (_verbose > 0)
G4cout <<"G4DiscreteGammaDeexcitation::CanDoTransition - CanDo" << endl; }
// else
// {
// delete _transition;
// _transition = 0;
// }
return canDo;
}
source/processes/hadronic/models/generator/de_excitation/src/G4DiscreteGammaTransition.cc
+86
View File
@@ -0,0 +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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4ContDiscrGammaTransition
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#include "G4DiscreteGammaTransition.hh"
#include "Randomize.hh"
G4DiscreteGammaTransition::G4DiscreteGammaTransition(const G4NuclearLevel& level):
_level(level), _excitation(0.), _gammaEnergy(0.)
{ }
G4DiscreteGammaTransition::~G4DiscreteGammaTransition()
{ }
G4double G4DiscreteGammaTransition::GammaEnergy()
{
_gammaEnergy = 0.;
G4int nGammas = _level.NumberOfGammas();
if (nGammas > 0)
{
G4double random = G4UniformRand();
G4int iGamma = 0;
if (random <= _level.GammaCumulativeProbabilities().at(0)) iGamma = 0;
else
{
G4int i;
for (i=1; i<nGammas; i++)
{
if (random > _level.GammaCumulativeProbabilities().at(i-1) &&
random <= _level.GammaCumulativeProbabilities().at(i))
{ iGamma = i; }
}
}
// Small correction due to the fact that there are mismatches between
// nominal level energies and emitted gamma energies
G4double eCorrection = _level.Energy() - _excitation;
_gammaEnergy = _level.GammaEnergies().at(iGamma) - eCorrection;
if (_gammaEnergy < 0.) _gammaEnergy = 0.;
}
return _gammaEnergy;
}
G4double G4DiscreteGammaTransition::GetEnergyTo() const
{
G4double energyTo = _excitation - _gammaEnergy;
if (energyTo < 0.) energyTo = 0.;
return energyTo;
}
void G4DiscreteGammaTransition::SetEnergyFrom(const G4double energy)
{
_excitation = energy;
return;
}
source/processes/hadronic/models/generator/de_excitation/src/G4DummyMF.cc
+51
View File
@@ -0,0 +1,51 @@
// 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.
//
// $Id: G4DummyMF.cc,v 1.1 1998/08/22 08:53:45 hpw Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (May 1998)
#include "G4DummyMF.hh"
G4DummyMF::G4DummyMF()
{
}
G4DummyMF::G4DummyMF(const G4DummyMF &right)
{
}
G4DummyMF::~G4DummyMF()
{
}
const G4DummyMF & G4DummyMF::operator=(const G4DummyMF &right)
{
G4Exception("G4DummyMF::operator= meant to not be accessable");
return *this;
}
int G4DummyMF::operator==(const G4DummyMF &right) const
{
return 0;
}
int G4DummyMF::operator!=(const G4DummyMF &right) const
{
return 1;
}
G4FragmentVector * G4DummyMF::BreakItUp(const G4Fragment &theNucleus)
{
// G4cout << "G4DummyMF::BreakItUp called"<<endl;
G4FragmentVector * theResult =
new G4FragmentVector;
// all calculations here
return theResult;
}
source/processes/hadronic/models/generator/de_excitation/src/G4DummyProbability.cc
+75
View File
@@ -0,0 +1,75 @@
//
// Class G4DummyProbability.cc
//
#include "G4DummyProbability.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4DummyProbability::G4DummyProbability(const G4DummyProbability& right)
{
G4Exception("G4DummyProbability::copy_constructor meant to not be accessible");
}
const G4DummyProbability& G4DummyProbability::
operator=(const G4DummyProbability& right)
{
G4Exception("G4DummyProbability::operator= meant to not be accessible");
return *this;
}
G4bool G4DummyProbability::operator==(const G4DummyProbability& right) const
{
return false;
}
G4bool G4DummyProbability::operator!=(const G4DummyProbability& right) const
{
return true;
}
// Calculate the emission probability
//
G4double G4DummyProbability::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
G4double theProb = 0.0;
return theProb;
}
G4double G4DummyProbability::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to last ground level.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
// Fall-back is a uniform random number
G4double uniformNum = G4UniformRand();
theProb = uniformNum;
return theProb;
}
G4DummyProbability::~G4DummyProbability() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1Probability.cc
+188
View File
@@ -0,0 +1,188 @@
//
// Class G4E1Probability.cc
//
#include "G4E1Probability.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1Probability::G4E1Probability(const G4E1Probability& right)
{
G4Exception("G4E1Probability::copy_constructor meant to not be accessible");
}
const G4E1Probability& G4E1Probability::
operator=(const G4E1Probability& right)
{
G4Exception("G4E1Probability::operator= meant to not be accessible");
return *this;
}
G4bool G4E1Probability::operator==(const G4E1Probability& right) const
{
return false;
}
G4bool G4E1Probability::operator!=(const G4E1Probability& right) const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1Probability::EmissionProbDensity(const G4Fragment& frag,
const G4double gammaE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - gammaE
// (U = nucleus excitation energy, gammaE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-gammaE) < 0.0 || gammaE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-gammaE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, gammaE = "<<Uexcite<<" "<<gammaE<<endl;
//cout<<" Uexcite, gammaE = "<<Uexcite*MeV<<" "<<gammaE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * gammaE*gammaE * GammaR*GammaR;
G4double denominator = (gammaE*gammaE - Egdp*Egdp)*
(gammaE*gammaE - Egdp*Egdp) + GammaR*GammaR*gammaE*gammaE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * gammaE*gammaE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1Probability::EmissionProbability(const G4Fragment& frag,
const G4double gammaE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to last ground level.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double Uafter = 0.0;
const G4double Uexcite = frag.GetExcitationEnergy();
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 100;
// Fall-back is a uniform random number
//G4double uniformNum = G4UniformRand();
//theProb = uniformNum;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,gammaE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ/(upperLim-lowerLim);
return theProb;
}
G4double G4E1Probability::EmissionIntegration(const G4Fragment& frag,
const G4double gammaE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)*Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1Probability::~G4E1Probability() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1Probability001.cc
+189
View File
@@ -0,0 +1,189 @@
//
// Class G4E1Probability001.cc
//
#include "G4E1Probability001.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1Probability001::G4E1Probability001(const G4E1Probability001& right)
{
G4Exception("G4E1Probability001::copy_constructor meant to not be accessible");
}
const G4E1Probability001& G4E1Probability001::
operator=(const G4E1Probability001& right)
{
G4Exception("G4E1Probability001::operator= meant to not be accessible");
return *this;
}
G4bool G4E1Probability001::operator==(const G4E1Probability001& right) const
{
return false;
}
G4bool G4E1Probability001::operator!=(const G4E1Probability001& right) const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1Probability001::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1Probability001::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to last ground level.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 0.001;
G4double Uafter = 0.0;
const G4double Uexcite = frag.GetExcitationEnergy();
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Fall-back is a uniform random number
//G4double uniformNum = G4UniformRand();
//theProb = uniformNum;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1Probability001::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1Probability001::~G4E1Probability001() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1Probability01.cc
+189
View File
@@ -0,0 +1,189 @@
//
// Class G4E1Probability01.cc
//
#include "G4E1Probability01.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1Probability01::G4E1Probability01(const G4E1Probability01& right)
{
G4Exception("G4E1Probability01::copy_constructor meant to not be accessible");
}
const G4E1Probability01& G4E1Probability01::
operator=(const G4E1Probability01& right)
{
G4Exception("G4E1Probability01::operator= meant to not be accessible");
return *this;
}
G4bool G4E1Probability01::operator==(const G4E1Probability01& right) const
{
return false;
}
G4bool G4E1Probability01::operator!=(const G4E1Probability01& right) const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1Probability01::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1Probability01::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to last ground level.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 0.01;
G4double Uafter = 0.0;
const G4double Uexcite = frag.GetExcitationEnergy();
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Fall-back is a uniform random number
//G4double uniformNum = G4UniformRand();
//theProb = uniformNum;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1Probability01::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1Probability01::~G4E1Probability01() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1Probability10.cc
+189
View File
@@ -0,0 +1,189 @@
//
// Class G4E1Probability10.cc
//
#include "G4E1Probability10.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1Probability10::G4E1Probability10(const G4E1Probability10& right)
{
G4Exception("G4E1Probability10::copy_constructor meant to not be accessible");
}
const G4E1Probability10& G4E1Probability10::
operator=(const G4E1Probability10& right)
{
G4Exception("G4E1Probability10::operator= meant to not be accessible");
return *this;
}
G4bool G4E1Probability10::operator==(const G4E1Probability10& right) const
{
return false;
}
G4bool G4E1Probability10::operator!=(const G4E1Probability10& right) const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1Probability10::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1Probability10::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to last ground level.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 10.0;
G4double Uafter = 0.0;
const G4double Uexcite = frag.GetExcitationEnergy();
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Fall-back is a uniform random number
//G4double uniformNum = G4UniformRand();
//theProb = uniformNum;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1Probability10::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1Probability10::~G4E1Probability10() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1Probability100.cc
+189
View File
@@ -0,0 +1,189 @@
//
// Class G4E1Probability100.cc
//
#include "G4E1Probability100.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1Probability100::G4E1Probability100(const G4E1Probability100& right)
{
G4Exception("G4E1Probability100::copy_constructor meant to not be accessible");
}
const G4E1Probability100& G4E1Probability100::
operator=(const G4E1Probability100& right)
{
G4Exception("G4E1Probability100::operator= meant to not be accessible");
return *this;
}
G4bool G4E1Probability100::operator==(const G4E1Probability100& right) const
{
return false;
}
G4bool G4E1Probability100::operator!=(const G4E1Probability100& right) const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1Probability100::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1Probability100::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to last ground level.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 100.0;
G4double Uafter = 0.0;
const G4double Uexcite = frag.GetExcitationEnergy();
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Fall-back is a uniform random number
//G4double uniformNum = G4UniformRand();
//theProb = uniformNum;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1Probability100::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1Probability100::~G4E1Probability100() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1SingleProbability001.cc
+190
View File
@@ -0,0 +1,190 @@
//
// Class G4E1SingleProbability001.cc
//
#include "G4E1SingleProbability001.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1SingleProbability001::G4E1SingleProbability001(
const G4E1SingleProbability001& right)
{
G4Exception("G4E1SingleProbability001::copy_constructor meant to not be accessible");
}
const G4E1SingleProbability001& G4E1SingleProbability001::
operator=(const G4E1SingleProbability001& right)
{
G4Exception("G4E1SingleProbability001::operator= meant to not be accessible");
return *this;
}
G4bool G4E1SingleProbability001::operator==(const G4E1SingleProbability001&
right) const
{
return false;
}
G4bool G4E1SingleProbability001::operator!=(const G4E1SingleProbability001&
right)
const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1SingleProbability001::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1SingleProbability001::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to the level
// Uexcite-exciteE.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 0.01; // playing with scale factors
const G4double Uexcite = frag.GetExcitationEnergy();
G4double Uafter = Uexcite - exciteE;
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1SingleProbability001::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1SingleProbability001::~G4E1SingleProbability001() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1SingleProbability01.cc
+190
View File
@@ -0,0 +1,190 @@
//
// Class G4E1SingleProbability01.cc
//
#include "G4E1SingleProbability01.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1SingleProbability01::G4E1SingleProbability01(
const G4E1SingleProbability01& right)
{
G4Exception("G4E1SingleProbability01::copy_constructor meant to not be accessible");
}
const G4E1SingleProbability01& G4E1SingleProbability01::
operator=(const G4E1SingleProbability01& right)
{
G4Exception("G4E1SingleProbability01::operator= meant to not be accessible");
return *this;
}
G4bool G4E1SingleProbability01::operator==(const G4E1SingleProbability01&
right) const
{
return false;
}
G4bool G4E1SingleProbability01::operator!=(const G4E1SingleProbability01&
right)
const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1SingleProbability01::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1SingleProbability01::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to the level
// Uexcite-exciteE.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 0.1; // playing with scale factors
const G4double Uexcite = frag.GetExcitationEnergy();
G4double Uafter = Uexcite - exciteE;
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1SingleProbability01::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1SingleProbability01::~G4E1SingleProbability01() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1SingleProbability1.cc
+189
View File
@@ -0,0 +1,189 @@
//
// Class G4E1SingleProbability1.cc
//
#include "G4E1SingleProbability1.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1SingleProbability1::G4E1SingleProbability1(const G4E1SingleProbability1&
right)
{
G4Exception("G4E1SingleProbability1::copy_constructor meant to not be accessible");
}
const G4E1SingleProbability1& G4E1SingleProbability1::
operator=(const G4E1SingleProbability1& right)
{
G4Exception("G4E1SingleProbability1::operator= meant to not be accessible");
return *this;
}
G4bool G4E1SingleProbability1::operator==(const G4E1SingleProbability1&
right) const
{
return false;
}
G4bool G4E1SingleProbability1::operator!=(const G4E1SingleProbability1& right)
const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1SingleProbability1::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1SingleProbability1::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to the level
// Uexcite-exciteE.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 1.0; // playing with scale factors
const G4double Uexcite = frag.GetExcitationEnergy();
G4double Uafter = Uexcite - exciteE;
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1SingleProbability1::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1SingleProbability1::~G4E1SingleProbability1() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1SingleProbability10.cc
+190
View File
@@ -0,0 +1,190 @@
//
// Class G4E1SingleProbability10.cc
//
#include "G4E1SingleProbability10.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1SingleProbability10::G4E1SingleProbability10(const G4E1SingleProbability10&
right)
{
G4Exception("G4E1SingleProbability10::copy_constructor meant to not be accessible");
}
const G4E1SingleProbability10& G4E1SingleProbability10::
operator=(const G4E1SingleProbability10& right)
{
G4Exception("G4E1SingleProbability10::operator= meant to not be accessible");
return *this;
}
G4bool G4E1SingleProbability10::operator==(const G4E1SingleProbability10&
right) const
{
return false;
}
G4bool G4E1SingleProbability10::operator!=(const G4E1SingleProbability10&
right)
const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1SingleProbability10::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1SingleProbability10::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to the level
// Uexcite-exciteE.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 10.0; // playing with scale factors
const G4double Uexcite = frag.GetExcitationEnergy();
G4double Uafter = Uexcite - exciteE;
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1SingleProbability10::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1SingleProbability10::~G4E1SingleProbability10() {}
source/processes/hadronic/models/generator/de_excitation/src/G4E1SingleProbability100.cc
+190
View File
@@ -0,0 +1,190 @@
//
// Class G4E1SingleProbability100.cc
//
#include "G4E1SingleProbability100.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include "Randomize.hh"
// Constructors and operators
//
G4E1SingleProbability100::G4E1SingleProbability100(
const G4E1SingleProbability100& right)
{
G4Exception("G4E1SingleProbability100::copy_constructor meant to not be accessible");
}
const G4E1SingleProbability100& G4E1SingleProbability100::
operator=(const G4E1SingleProbability100& right)
{
G4Exception("G4E1SingleProbability100::operator= meant to not be accessible");
return *this;
}
G4bool G4E1SingleProbability100::operator==(const G4E1SingleProbability100&
right) const
{
return false;
}
G4bool G4E1SingleProbability100::operator!=(const G4E1SingleProbability100&
right)
const
{
return true;
}
// Calculate the emission probability
//
G4double G4E1SingleProbability100::EmissionProbDensity(const G4Fragment& frag,
const G4double exciteE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - exciteE
// (U = nucleus excitation energy, exciteE = total evaporated photon
// energy).
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
const G4double Afrag = frag.GetA();
const G4double Zfrag = frag.GetZ();
const G4double Uexcite = frag.GetExcitationEnergy();
if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei).
G4ConstantLevelDensityParameter a;
G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
G4double levelDensBef = exp(2.0*sqrt(aLevelDensityParam*Uexcite));
G4double levelDensAft = exp(2.0*sqrt(aLevelDensityParam*(Uexcite-exciteE)));
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * Afrag * millibarn; // millibarns
G4double Egdp = (40.3 / pow(Afrag,0.2) )*MeV;
G4double GammaR = 0.30 * Egdp;
G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
// CD
//cout<<" PROB TESTS "<<endl;
//cout<<" hbarc = "<<hbarc<<endl;
//cout<<" pi = "<<pi<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite<<" "<<exciteE<<endl;
//cout<<" Uexcite, exciteE = "<<Uexcite*MeV<<" "<<exciteE*MeV<<endl;
//cout<<" lev density param = "<<aLevelDensityParam<<endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<endl;
//cout<<" sigma0 = "<<sigma0<<endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<endl;
//cout<<" normC = "<<normC<<endl;
G4double numerator = sigma0 * exciteE*exciteE * GammaR*GammaR;
G4double denominator = (exciteE*exciteE - Egdp*Egdp)*
(exciteE*exciteE - Egdp*Egdp) + GammaR*GammaR*exciteE*exciteE;
G4double sigmaAbs = numerator/denominator;
theProb = normC * sigmaAbs * exciteE*exciteE *
levelDensAft/levelDensBef;
// CD
//cout<<" sigmaAbs = "<<sigmaAbs<<endl;
//cout<<" Probability = "<<theProb<<endl;
return theProb;
}
G4double G4E1SingleProbability100::EmissionProbability(const G4Fragment& frag,
const G4double exciteE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to the level
// Uexcite-exciteE.
// fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
G4double ScaleFactor = 100.0; // playing with scale factors
const G4double Uexcite = frag.GetExcitationEnergy();
G4double Uafter = Uexcite - exciteE;
G4double normC = 3.0;
const G4double upperLim = Uexcite;
const G4double lowerLim = Uafter;
const G4int numIters = 25;
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by normC
G4double integ = normC *
EmissionIntegration(frag,exciteE,lowerLim,upperLim,numIters);
if(integ > 0.0) theProb = integ;
return theProb * ScaleFactor;
}
G4double G4E1SingleProbability100::EmissionIntegration(const G4Fragment& frag,
const G4double exciteE,
const G4double lowLim, const G4double upLim,
const G4int numIters)
{
// Simple Gaussian quadrature integration
G4double x;
G4double root3 = 1.0/sqrt(3.0);
G4double Step = (upLim-lowLim)/(2.0*numIters);
G4double Delta = Step*root3;
G4double mean = 0.0;
G4double theInt = 0.0;
for(G4int i = 0; i < numIters; i++) {
x = (2*i + 1)/Step;
G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
mean += E1ProbDensityA + E1ProbDensityB;
}
if(mean*Step > 0.0) theInt = mean*Step;
return theInt;
}
G4E1SingleProbability100::~G4E1SingleProbability100() {}
source/processes/hadronic/models/generator/de_excitation/src/G4Evaporation.cc
+526
View File
@@ -0,0 +1,526 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
#include "G4Evaporation.hh"
G4Evaporation::G4Evaporation()
{
ExcitEnergyChann00.reshape(NumExcitedStates);
ExcitEnergyChann01.reshape(NumExcitedStates);
ExcitEnergyChann02.reshape(NumExcitedStates);
ExcitEnergyChann03.reshape(NumExcitedStates);
ExcitEnergyChann04.reshape(NumExcitedStates);
ExcitEnergyChann05.reshape(NumExcitedStates);
ExcitEnergyChann06.reshape(NumExcitedStates);
ExcitEnergyChann07.reshape(NumExcitedStates);
ExcitEnergyChann08.reshape(NumExcitedStates);
ExcitEnergyChann09.reshape(NumExcitedStates);
ExcitEnergyChann10.reshape(NumExcitedStates);
ExcitEnergyChann11.reshape(NumExcitedStates);
ExcitEnergyChann12.reshape(NumExcitedStates);
ExcitEnergyChann13.reshape(NumExcitedStates);
ExcitEnergyChann14.reshape(NumExcitedStates);
ExcitEnergyChann15.reshape(NumExcitedStates);
ExcitEnergyChann16.reshape(NumExcitedStates);
ExcitEnergyChann17.reshape(NumExcitedStates);
ExcitEnergyChann18.reshape(NumExcitedStates);
ExcitEnergyChann19.reshape(NumExcitedStates);
ExcitEnergyChann20.reshape(NumExcitedStates);
ExcitEnergyChann21.reshape(NumExcitedStates);
ExcitEnergyChann22.reshape(NumExcitedStates);
ExcitEnergyChann23.reshape(NumExcitedStates);
ExcitEnergyChann24.reshape(NumExcitedStates);
ExcitEnergyChann25.reshape(NumExcitedStates);
ExcitEnergyChann26.reshape(NumExcitedStates);
ExcitEnergyChann27.reshape(NumExcitedStates);
ExcitEnergyChann28.reshape(NumExcitedStates);
ExcitEnergyChann29.reshape(NumExcitedStates);
ExcitEnergyChann30.reshape(NumExcitedStates);
ExcitEnergyChann31.reshape(NumExcitedStates);
ExcitSpinChann00.reshape(NumExcitedStates);
ExcitSpinChann01.reshape(NumExcitedStates);
ExcitSpinChann02.reshape(NumExcitedStates);
ExcitSpinChann03.reshape(NumExcitedStates);
ExcitSpinChann04.reshape(NumExcitedStates);
ExcitSpinChann05.reshape(NumExcitedStates);
ExcitSpinChann06.reshape(NumExcitedStates);
ExcitSpinChann07.reshape(NumExcitedStates);
ExcitSpinChann08.reshape(NumExcitedStates);
ExcitSpinChann09.reshape(NumExcitedStates);
ExcitSpinChann10.reshape(NumExcitedStates);
ExcitSpinChann11.reshape(NumExcitedStates);
ExcitSpinChann12.reshape(NumExcitedStates);
ExcitSpinChann13.reshape(NumExcitedStates);
ExcitSpinChann14.reshape(NumExcitedStates);
ExcitSpinChann15.reshape(NumExcitedStates);
ExcitSpinChann16.reshape(NumExcitedStates);
ExcitSpinChann17.reshape(NumExcitedStates);
ExcitSpinChann18.reshape(NumExcitedStates);
ExcitSpinChann19.reshape(NumExcitedStates);
ExcitSpinChann20.reshape(NumExcitedStates);
ExcitSpinChann21.reshape(NumExcitedStates);
ExcitSpinChann22.reshape(NumExcitedStates);
ExcitSpinChann23.reshape(NumExcitedStates);
ExcitSpinChann24.reshape(NumExcitedStates);
ExcitSpinChann25.reshape(NumExcitedStates);
ExcitSpinChann26.reshape(NumExcitedStates);
ExcitSpinChann27.reshape(NumExcitedStates);
ExcitSpinChann28.reshape(NumExcitedStates);
ExcitSpinChann29.reshape(NumExcitedStates);
ExcitSpinChann30.reshape(NumExcitedStates);
ExcitSpinChann31.reshape(NumExcitedStates);
for (G4int i = 0; i < NumExcitedStates; i++) {
ExcitEnergyChann00(i) = 0.0;
ExcitEnergyChann01(i) = 0.0;
ExcitEnergyChann02(i) = 0.0;
ExcitEnergyChann03(i) = 0.0;
ExcitEnergyChann04(i) = 0.0;
ExcitEnergyChann05(i) = 0.0;
ExcitEnergyChann06(i) = 0.0;
ExcitEnergyChann07(i) = 0.0;
ExcitEnergyChann08(i) = 0.0;
ExcitEnergyChann09(i) = 0.0;
ExcitEnergyChann10(i) = 0.0;
ExcitEnergyChann11(i) = 0.0;
ExcitEnergyChann12(i) = 0.0;
ExcitEnergyChann13(i) = 0.0;
ExcitEnergyChann14(i) = 0.0;
ExcitEnergyChann15(i) = 0.0;
ExcitEnergyChann16(i) = 0.0;
ExcitEnergyChann17(i) = 0.0;
ExcitEnergyChann18(i) = 0.0;
ExcitEnergyChann19(i) = 0.0;
ExcitEnergyChann20(i) = 0.0;
ExcitEnergyChann21(i) = 0.0;
ExcitEnergyChann22(i) = 0.0;
ExcitEnergyChann23(i) = 0.0;
ExcitEnergyChann24(i) = 0.0;
ExcitEnergyChann25(i) = 0.0;
ExcitEnergyChann26(i) = 0.0;
ExcitEnergyChann27(i) = 0.0;
ExcitEnergyChann28(i) = 0.0;
ExcitEnergyChann29(i) = 0.0;
ExcitEnergyChann30(i) = 0.0;
ExcitEnergyChann31(i) = 0.0;
ExcitSpinChann00(i) = 0;
ExcitSpinChann01(i) = 0;
ExcitSpinChann02(i) = 0;
ExcitSpinChann03(i) = 0;
ExcitSpinChann04(i) = 0;
ExcitSpinChann05(i) = 0;
ExcitSpinChann06(i) = 0;
ExcitSpinChann07(i) = 0;
ExcitSpinChann08(i) = 0;
ExcitSpinChann09(i) = 0;
ExcitSpinChann10(i) = 0;
ExcitSpinChann11(i) = 0;
ExcitSpinChann12(i) = 0;
ExcitSpinChann13(i) = 0;
ExcitSpinChann14(i) = 0;
ExcitSpinChann15(i) = 0;
ExcitSpinChann16(i) = 0;
ExcitSpinChann17(i) = 0;
ExcitSpinChann18(i) = 0;
ExcitSpinChann19(i) = 0;
ExcitSpinChann20(i) = 0;
ExcitSpinChann21(i) = 0;
ExcitSpinChann22(i) = 0;
ExcitSpinChann23(i) = 0;
ExcitSpinChann24(i) = 0;
ExcitSpinChann25(i) = 0;
ExcitSpinChann26(i) = 0;
ExcitSpinChann27(i) = 0;
ExcitSpinChann28(i) = 0;
ExcitSpinChann29(i) = 0;
ExcitSpinChann30(i) = 0;
ExcitSpinChann31(i) = 0;
}
// (in MeV)
// neutrons
ExcitEnergyChann00( 9) = 3.56;
ExcitEnergyChann00(10) = 0.48;
ExcitEnergyChann00(11) = 0.98;
ExcitEnergyChann00(12) = 0.43;
ExcitEnergyChann00(15) = 3.37;
ExcitEnergyChann00(17) = 0.72;
ExcitEnergyChann00(18) = 2.13;
ExcitEnergyChann00(19) = 0.95;
ExcitEnergyChann00(20) = 2.00;
ExcitEnergyChann00(21) = 4.44;
ExcitEnergyChann00(22) = 3.09;
ExcitEnergyChann00(23) = 6.09;
ExcitEnergyChann00(25) = 2.31;
ExcitEnergyChann00(26) = 5.28;
ExcitEnergyChann00(27) = 0.12;
ExcitEnergyChann00(28) = 5.22;
ExcitEnergyChann00(29) = 6.10;
ExcitEnergyChann00(30) = 0.87;
ExcitEnergyChann00(31) = 1.98;
// protons
ExcitEnergyChann01(15) = 5.96;
ExcitEnergyChann01(17) = 1.74;
ExcitEnergyChann01(18) = 4.44;
ExcitEnergyChann01(19) = 1.67;
ExcitEnergyChann01(20) = 4.32;
ExcitEnergyChann01(22) = 3.68;
ExcitEnergyChann01(23) = 6.69;
ExcitEnergyChann01(25) = 3.95;
ExcitEnergyChann01(26) = 6.32;
ExcitEnergyChann01(27) = 0.30;
ExcitEnergyChann01(28) = 6.18;
ExcitEnergyChann01(29) = 6.92;
ExcitEnergyChann01(30) = 3.06;
ExcitEnergyChann01(31) = 3.57;
// deuterons
ExcitEnergyChann02(15) = 6.18;
ExcitEnergyChann02(17) = 2.15;
ExcitEnergyChann02(18) = 5.02;
ExcitEnergyChann02(19) = 2.65;
ExcitEnergyChann02(20) = 4.80;
ExcitEnergyChann02(22) = 3.85;
ExcitEnergyChann02(23) = 6.96;
ExcitEnergyChann02(25) = 4.92;
ExcitEnergyChann02(26) = 7.22;
ExcitEnergyChann02(27) = 0.40;
ExcitEnergyChann02(28) = 6.83;
ExcitEnergyChann02(29) = 7.12;
ExcitEnergyChann02(30) = 3.84;
ExcitEnergyChann02(31) = 3.92;
// tritons
ExcitEnergyChann03(15) = 6.26;
ExcitEnergyChann03(17) = 3.59;
ExcitEnergyChann03(18) = 6.76;
ExcitEnergyChann03(20) = 6.34;
ExcitEnergyChann03(23) = 7.34;
ExcitEnergyChann03(25) = 5.11;
ExcitEnergyChann03(26) = 7.57;
ExcitEnergyChann03(28) = 7.28;
ExcitEnergyChann03(31) = 4.46;
// He3
ExcitEnergyChann04(18) = 7.29;
ExcitEnergyChann04(20) = 6.48;
ExcitEnergyChann04(25) = 5.69;
ExcitEnergyChann04(26) = 8.31;
ExcitEnergyChann04(31) = 5.10;
// alphas
ExcitEnergyChann05(18) = 7.98;
ExcitEnergyChann05(20) = 6.90;
ExcitEnergyChann05(25) = 5.83;
ExcitEnergyChann05(26) = 8.57;
ExcitEnergyChann05(31) = 5.33;
// He5
ExcitEnergyChann06(18) = 8.56;
ExcitEnergyChann06(20) = 7.50;
ExcitEnergyChann06(25) = 6.20;
ExcitEnergyChann06(26) = 9.15;
ExcitEnergyChann06(31) = 5.53;
// He6
ExcitEnergyChann07(20) = 8.10;
ExcitEnergyChann07(25) = 6.44;
ExcitEnergyChann07(26) = 9.79;
ExcitEnergyChann07(31) = 6.20;
// Li5
ExcitEnergyChann08(20) = 8.42;
ExcitEnergyChann08(25) = 7.03;
ExcitEnergyChann08(26) = 10.0;
ExcitEnergyChann08(31) = 6.38;
// Li6
ExcitEnergyChann09(20) = 8.66;
ExcitEnergyChann09(31) = 6.88;
// Spin (2s+1)
// neutrons
ExcitSpinChann00( 9) = 1;
ExcitSpinChann00(10) = 2;
ExcitSpinChann00(11) = 3;
ExcitSpinChann00(12) = 2;
ExcitSpinChann00(15) = 5;
ExcitSpinChann00(17) = 3;
ExcitSpinChann00(18) = 2;
ExcitSpinChann00(19) = 5;
ExcitSpinChann00(20) = 2;
ExcitSpinChann00(21) = 5;
ExcitSpinChann00(22) = 2;
ExcitSpinChann00(23) = 3;
ExcitSpinChann00(25) = 1;
ExcitSpinChann00(26) = 8;
ExcitSpinChann00(27) = 1;
ExcitSpinChann00(28) = 8;
ExcitSpinChann00(29) = 8;
ExcitSpinChann00(30) = 2;
ExcitSpinChann00(31) = 5;
// protons
ExcitSpinChann01(15) = 8;
ExcitSpinChann01(17) = 1;
ExcitSpinChann01(18) = 6;
ExcitSpinChann01(19) = 5;
ExcitSpinChann01(20) = 6;
ExcitSpinChann01(22) = 4;
ExcitSpinChann01(23) = 8;
ExcitSpinChann01(25) = 3;
ExcitSpinChann01(26) = 4;
ExcitSpinChann01(27) = 7;
ExcitSpinChann01(28) = 4;
ExcitSpinChann01(29) = 5;
ExcitSpinChann01(30) = 2;
ExcitSpinChann01(31) = 10;
// deuterons
ExcitSpinChann02(15) = 1;
ExcitSpinChann02(17) = 3;
ExcitSpinChann02(18) = 4;
ExcitSpinChann02(19) = 4;
ExcitSpinChann02(20) = 4;
ExcitSpinChann02(22) = 6;
ExcitSpinChann02(23) = 6;
ExcitSpinChann02(25) = 1;
ExcitSpinChann02(26) = 10;
ExcitSpinChann02(27) = 3;
ExcitSpinChann02(28) = 10;
ExcitSpinChann02(29) = 3;
ExcitSpinChann02(30) = 6;
ExcitSpinChann02(31) = 5;
// tritons
ExcitSpinChann03(15) = 5;
ExcitSpinChann03(17) = 5;
ExcitSpinChann03(18) = 10;
ExcitSpinChann03(20) = 2;
ExcitSpinChann03(23) = 5;
ExcitSpinChann03(25) = 5;
ExcitSpinChann03(26) = 8;
ExcitSpinChann03(28) = 8;
ExcitSpinChann03(31) = 3;
// He3
ExcitSpinChann04(18) = 6;
ExcitSpinChann04(20) = 8;
ExcitSpinChann04(25) = 3;
ExcitSpinChann04(26) = 2;
ExcitSpinChann04(31) = 7;
// alphas
ExcitSpinChann05(18) = 4;
ExcitSpinChann05(20) = 6;
ExcitSpinChann05(25) = 7;
ExcitSpinChann05(26) = 4;
ExcitSpinChann05(31) = 13;
// He5
ExcitSpinChann06(18) = 6;
ExcitSpinChann06(20) = 4;
ExcitSpinChann06(25) = 3;
ExcitSpinChann06(26) = 14;
ExcitSpinChann06(31) = 5;
// He6
ExcitSpinChann07(20) = 4;
ExcitSpinChann07(25) = 7;
ExcitSpinChann07(26) = 14;
ExcitSpinChann07(31) = 3;
// Li5
ExcitSpinChann08(20) = 6;
ExcitSpinChann08(25) = 5;
ExcitSpinChann08(26) = 8;
ExcitSpinChann08(31) = 12;
// Li6
ExcitSpinChann09(20) = 8;
ExcitSpinChann09(31) = 1;
// |Gamma|A| Z|
// +-----+-+--+
theChannels[ 0] = new G4EvaporationChannel( 2, 1, 0, &ExcitEnergyChann00, &ExcitSpinChann00); // n
theChannels[ 1] = new G4EvaporationChannel( 2, 1, 1, &ExcitEnergyChann01, &ExcitSpinChann01); // p
theChannels[ 2] = new G4EvaporationChannel( 6, 2, 1, &ExcitEnergyChann02, &ExcitSpinChann02); // H2
theChannels[ 3] = new G4EvaporationChannel( 6, 3, 1, &ExcitEnergyChann03, &ExcitSpinChann03); // H3
theChannels[ 4] = new G4EvaporationChannel( 6, 3, 2, &ExcitEnergyChann04, &ExcitSpinChann04); // He3
theChannels[ 5] = new G4EvaporationChannel( 4, 4, 2, &ExcitEnergyChann05, &ExcitSpinChann05); // He4
theChannels[ 6] = new G4EvaporationChannel( 20, 5, 2, &ExcitEnergyChann06, &ExcitSpinChann06); // He5
theChannels[ 7] = new G4EvaporationChannel( 30, 6, 2, &ExcitEnergyChann07, &ExcitSpinChann07); // He6
theChannels[ 8] = new G4EvaporationChannel( 20, 5, 3, &ExcitEnergyChann08, &ExcitSpinChann08); // Li5
theChannels[ 9] = new G4EvaporationChannel( 54, 6, 3, &ExcitEnergyChann09, &ExcitSpinChann09); // Li6
theChannels[10] = new G4EvaporationChannel( 73, 7, 3, &ExcitEnergyChann10, &ExcitSpinChann10); // Li7
theChannels[11] = new G4EvaporationChannel(101, 8, 3, &ExcitEnergyChann11, &ExcitSpinChann11); // Li8
theChannels[12] = new G4EvaporationChannel( 73, 7, 4, &ExcitEnergyChann12, &ExcitSpinChann12); // Be7
theChannels[13] = new G4EvaporationChannel( 8, 8, 4, &ExcitEnergyChann13, &ExcitSpinChann13); // Be8
theChannels[14] = new G4EvaporationChannel(146, 9, 4, &ExcitEnergyChann14, &ExcitSpinChann14); // Be9
theChannels[15] = new G4EvaporationChannel(100, 10, 4, &ExcitEnergyChann15, &ExcitSpinChann15); // Be10
theChannels[16] = new G4EvaporationChannel(100, 9, 5, &ExcitEnergyChann16, &ExcitSpinChann16); // B9
theChannels[17] = new G4EvaporationChannel(343, 10, 5, &ExcitEnergyChann17, &ExcitSpinChann17); // B10
theChannels[18] = new G4EvaporationChannel(174, 11, 5, &ExcitEnergyChann18, &ExcitSpinChann18); // B11
theChannels[19] = new G4EvaporationChannel(393, 12, 5, &ExcitEnergyChann19, &ExcitSpinChann19); // B12
theChannels[20] = new G4EvaporationChannel(186, 11, 6, &ExcitEnergyChann20, &ExcitSpinChann20); // C11
theChannels[21] = new G4EvaporationChannel( 61, 12, 6, &ExcitEnergyChann21, &ExcitSpinChann21); // C12
theChannels[22] = new G4EvaporationChannel(202, 13, 6, &ExcitEnergyChann22, &ExcitSpinChann22); // C13
theChannels[23] = new G4EvaporationChannel(113, 14, 6, &ExcitEnergyChann23, &ExcitSpinChann23); // C14
theChannels[24] = new G4EvaporationChannel(213, 13, 7, &ExcitEnergyChann24, &ExcitSpinChann24); // N13
theChannels[25] = new G4EvaporationChannel(233, 14, 7, &ExcitEnergyChann25, &ExcitSpinChann25); // N14
theChannels[26] = new G4EvaporationChannel(180, 15, 7, &ExcitEnergyChann26, &ExcitSpinChann26); // N15
theChannels[27] = new G4EvaporationChannel(696, 16, 7, &ExcitEnergyChann27, &ExcitSpinChann27); // N16
theChannels[28] = new G4EvaporationChannel(194, 15, 8, &ExcitEnergyChann28, &ExcitSpinChann28); // O15
theChannels[29] = new G4EvaporationChannel(120, 16, 8, &ExcitEnergyChann29, &ExcitSpinChann29); // O16
theChannels[30] = new G4EvaporationChannel(458, 17, 8, &ExcitEnergyChann30, &ExcitSpinChann30); // O17
theChannels[31] = new G4EvaporationChannel(590, 18, 8, &ExcitEnergyChann31, &ExcitSpinChann31); // O18
theChannels[32] = new G4CompetitiveFission(); // Fission Channel
theChannels[33] = new G4PhotonEvaporation(); // Photon Channel
}
G4Evaporation::G4Evaporation(const G4Evaporation &right)
{
G4Exception("G4Evaporation::copy_constructor meant to not be accessable.");
}
G4Evaporation::~G4Evaporation()
{
for (G4int i = 0; i < TotNumberOfChannels; i++)
delete theChannels[i];
}
const G4Evaporation & G4Evaporation::operator=(const G4Evaporation &right)
{
G4Exception("G4Evaporation::operator= meant to not be accessable.");
return *this;
}
G4bool G4Evaporation::operator==(const G4Evaporation &right) const
{
return false;
}
G4bool G4Evaporation::operator!=(const G4Evaporation &right) const
{
return true;
}
G4FragmentVector * G4Evaporation::BreakItUp(const G4Fragment &theNucleus)
{
G4FragmentVector * theResult = new G4FragmentVector;
// CHECK that Excitation Energy != 0
if (theNucleus.GetExcitationEnergy() == 0) {
theResult->insert(new G4Fragment(theNucleus));
return theResult;
}
// The residual nucleus (after evaporation of each fragment)
G4Fragment theResidualNucleus = theNucleus;
// Starts loop over evaporated particles
for (;;) {
// loop over evaporation channels
G4int i;
for (i=0; i < TotNumberOfChannels; i++)
theChannels[i]->Initialize(theResidualNucleus);
// Work out total decay probability by summing over channels
G4double TotalProbability = 0;
for (i=0; i < TotNumberOfChannels; i++)
TotalProbability += theChannels[i]->GetEmissionProbability();
// G4cout << "---------------- " << theResidualNucleus.GetExcitationEnergy()/MeV << "-----------------------" << endl;
// G4cout << "Prob of neutron: " << theChannels[0]->GetEmissionProbability()/TotalProbability << endl;
// G4cout << "Prob of proton : " << theChannels[1]->GetEmissionProbability()/TotalProbability<< endl;
// G4cout << "Prob of alpha : " << theChannels[5]->GetEmissionProbability()/TotalProbability<< endl;
// G4cout << "Prob of fission: " << theChannels[NumberOfFissionChannel]->GetEmissionProbability()/TotalProbability<< endl;
if (TotalProbability <= 0.0) {
// Will be no evaporation more
// write information about residual nucleus
theResult->insert(new G4Fragment(theResidualNucleus));
break;
} else {
// Selection of evaporation channel, fission or gamma
G4double EmissionProbChannel[TotNumberOfChannels];
EmissionProbChannel[0] = theChannels[0]->GetEmissionProbability();
for (i=1; i < TotNumberOfChannels; i++)
EmissionProbChannel[i] = EmissionProbChannel[i-1] + theChannels[i]->GetEmissionProbability();
G4double shoot = G4UniformRand() * TotalProbability;
for (i=0; i < TotNumberOfChannels; i++)
if (shoot < EmissionProbChannel[i])
break;
if( i == TotNumberOfChannels )
G4Exception( "Can't define emission probability of the channels (G4Evaporation::BreakItUp)" );
else if (i == NumberOfFissionChannel) {
// Fission has to be performed
G4FragmentVector * theFissionResult = theChannels[i]->BreakUp(theResidualNucleus);
while (theFissionResult->entries() > 0)
theResult->insert(theFissionResult->removeFirst());
theFissionResult->clearAndDestroy();
delete theFissionResult;
break;
} else if (i == NumberOfGammaChannel) {
// Gamma evaporation has to be performed
G4FragmentVector * theGammaResult = theChannels[i]->BreakUp(theResidualNucleus);
while (theGammaResult->entries() > 0)
theResult->insert(theGammaResult->removeFirst());
theGammaResult->clearAndDestroy();
delete theGammaResult;
break;
} else {
// Evaporation has to be performed
G4FragmentVector * theEvaporationResult = theChannels[i]->BreakUp(theResidualNucleus);
while (theEvaporationResult->entries() > 1)
theResult->insert(theEvaporationResult->removeFirst());
theResidualNucleus = *(theEvaporationResult->at(0));
theEvaporationResult->clearAndDestroy();
delete theEvaporationResult;
}
}
}
return theResult;
}
source/processes/hadronic/models/generator/de_excitation/src/G4EvaporationChannel.cc
+310
View File
@@ -0,0 +1,310 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
// some corrections V.Krylov
//
#include "G4EvaporationChannel.hh"
G4EvaporationChannel::G4EvaporationChannel(const G4int theGamma,
const G4int theA,
const G4int theZ,
RWTValVector<G4double> * theExcitationEnergies,
RWTValVector<G4int> * theExcitationSpins):
Gamma(theGamma),
A(theA),
Z(theZ),
ExcitationEnergies(theExcitationEnergies),
ExcitationSpins(theExcitationSpins),
AResidual(0),
ZResidual(0),
CoulombBarrier(0.0),
BindingEnergy(0.0),
MaximalKineticEnergy(-1000.0),
EmissionProbability(0.0)
{
theEvaporationProbabilityPtr = new G4EvaporationProbability(this);
MyOwnEvaporationProbability = true;
theLevelDensityPtr = new G4EvaporationLevelDensityParameter;
MyOwnLevelDensity = true;
}
G4EvaporationChannel::~G4EvaporationChannel()
{
if (MyOwnEvaporationProbability) delete theEvaporationProbabilityPtr;
if (MyOwnLevelDensity) delete theLevelDensityPtr;
}
G4EvaporationChannel::G4EvaporationChannel(const G4EvaporationChannel & right)
{
G4Exception("G4EvaporationChannel::copy_costructor meant to not be accessable");
}
const G4EvaporationChannel & G4EvaporationChannel::operator=(const G4EvaporationChannel & right)
{
G4Exception("G4EvaporationChannel::operator= meant to not be accessable");
return *this;
}
G4bool G4EvaporationChannel::operator==(const G4EvaporationChannel & right) const
{
return (this == (G4EvaporationChannel *) &right);
// return false;
}
G4bool G4EvaporationChannel::operator!=(const G4EvaporationChannel & right) const
{
return (this != (G4EvaporationChannel *) &right);
// return true;
}
void G4EvaporationChannel::Initialize(const G4Fragment & fragment)
{
G4int anA = fragment.GetA();
G4int aZ = fragment.GetZ();
G4double ExEnergy = fragment.GetExcitationEnergy();
AResidual = anA - A;
ZResidual = aZ - Z;
// We only take into account channels which are physically allowed
if (AResidual <= 0 || ZResidual <= 0 || AResidual < ZResidual ||
(AResidual == ZResidual && AResidual > 1)) {
LevelDensityParameter = 0.0;
CoulombBarrier = 0.0;
BindingEnergy = 0.0;
MaximalKineticEnergy = -1000.0*MeV;
EmissionProbability = 0.0;
} else {
// Get Level Density
LevelDensityParameter = theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
// Coulomb Barrier calculation
CoulombBarrier = CalcCoulombBarrier(AResidual,ZResidual)*MeV;
// Binding Enegy (for separate fragment from nucleus)
BindingEnergy = CalcBindingEnergy(anA,aZ)*MeV;
// Maximal Kinetic Energy
MaximalKineticEnergy = CalcMaximalKineticEnergy(G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(aZ,anA)+ExEnergy)*MeV;
// Emission probability
if (MaximalKineticEnergy <= 0.0) EmissionProbability = 0.0;
else {
// Total emission probability for this channel
EmissionProbability = theEvaporationProbabilityPtr->EmissionProbability(fragment,0.0);
// Next is a loop over excited states for this channel summing probabilities
G4double SavedGamma = Gamma;
G4double SavedMaximalKineticEnergy = MaximalKineticEnergy;
for (G4int i = 0; i < ExcitationEnergies->length(); i++) {
if (ExcitationSpins->operator()(i) < 0.1) continue;
Gamma = ExcitationSpins->operator()(i)*A;
// substract excitation energies
MaximalKineticEnergy -= ExcitationEnergies->operator()(i)/MeV;
// update probability
G4double tmp = theEvaporationProbabilityPtr->EmissionProbability(fragment,0.0);
EmissionProbability += tmp;
}
// restore Gamma and MaximalKineticEnergy
MaximalKineticEnergy = SavedMaximalKineticEnergy;
Gamma = SavedGamma;
}
}
return;
}
G4FragmentVector * G4EvaporationChannel::BreakUp(const G4Fragment & theNucleus)
{
// calculate kinetic energy of evaporated fragment
G4double EvaporatedKineticEnergy = CalcKineticEnergy(); // MeV
G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A)/MeV; // MeV
G4double EvaporatedEnergy = EvaporatedKineticEnergy + EvaporatedMass;
G4ThreeVector momentum( IsotropicVector( sqrt( EvaporatedEnergy*EvaporatedEnergy -
EvaporatedMass*EvaporatedMass )
) );
G4LorentzVector EvaporatedMomentum( momentum, EvaporatedEnergy );
EvaporatedMomentum.boost( theNucleus.GetMomentum().boostVector() );
G4Fragment * EvaporatedFragment = new G4Fragment( A, Z, EvaporatedMomentum );
if ( !EvaporatedFragment )
G4Exception( "G4EvaporationChannel::BreakUp: Can't create G4Fragment! ");
G4LorentzVector FragmentMomentum( theNucleus.GetMomentum() );
FragmentMomentum.boost( -theNucleus.GetMomentum().boostVector() );
G4LorentzVector ResidualMomentum( -momentum, FragmentMomentum.e() - EvaporatedEnergy );
ResidualMomentum.boost( theNucleus.GetMomentum().boostVector() );
G4Fragment * ResidualFragment = new G4Fragment( AResidual, ZResidual, ResidualMomentum );
if ( !ResidualFragment )
G4Exception( "G4EvaporationChannel::BreakUp: Can't create G4Fragment! ");
G4FragmentVector * theResult = new G4FragmentVector;
if ( !theResult )
G4Exception( "G4EvaporationChannel::BreakUp: Can't create G4FragmentVector! ");
theResult->insert(EvaporatedFragment);
theResult->insert(ResidualFragment);
return theResult;
}
G4double G4EvaporationChannel::CalcCoulombBarrier(const G4int ARes, const G4int ZRes)
// Calculation of Coulomb potential energy (barrier) in MeV for outgoing fragment
{
G4double Barrier = 0.0;
if (Z == 0 && A == 1) return 0.0; // for neutron
else {
G4int nZZRes = Z * ZRes;
G4double r0 = 2.173*(1.0+0.006103 * nZZRes)/(1.0+0.009443 * nZZRes);
Barrier = 1.44/r0 * nZZRes / (pow( A,1./3. ) + pow( ARes,1./3. ));
}
return Barrier;
}
G4double G4EvaporationChannel::CalcBindingEnergy(const G4int anA, const G4int aZ)
// Calculate Binding Energy for separate fragment from nucleus
{
// Mass Excess for residual nucleus
G4double ResNucMassExcess = G4NucleiProperties::GetMassExcess(AResidual,ZResidual)/MeV;
// Mass Excess for fragment
G4double FragmentMassExcess = G4NucleiProperties::GetMassExcess(A,Z)/MeV;
// Mass Excess for Nucleus
G4double NucleusMassExcess = G4NucleiProperties::GetMassExcess(anA,aZ)/MeV;
return ResNucMassExcess + FragmentMassExcess - NucleusMassExcess;
}
G4double G4EvaporationChannel::CalcMaximalKineticEnergy(const G4double NucleusTotalE)
// Calculate maximal kinetic energy that can be carried by fragment (in MeV)
{
// // Odd-Even term correction (for maximal kinetic energy)
// G4double odd = 0.0;
// if (A < 65) {
// G4int NCorr = A - Z;
// NCorr = 2*(NCorr/2) - NCorr;
// G4int ZCorr = 2*(Z/2) - Z;
// odd = 11.0*(2+NCorr+ZCorr)/sqrt(G4double(A));
// }
// if (A <= 55) return U/MeV -
// (BindingEnergy + CoulombBarrier)/MeV - odd;
// else if (A > 55 && A < 65) return U/MeV -
// (BindingEnergy + CoulombBarrier)/MeV -
// odd * (1.0 - (A-55)/10.);
// else return U/MeV - (BindingEnergy + CoulombBarrier);
G4double ResidualMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass( ZResidual, AResidual )/MeV;
G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass( Z, A )/MeV;
return ( (NucleusTotalE/MeV)*(NucleusTotalE/MeV) +
EvaporatedMass*EvaporatedMass - ResidualMass*ResidualMass)/
(2.0*NucleusTotalE ) -
EvaporatedMass - CoulombBarrier/MeV;
}
G4double G4EvaporationChannel::CalcKineticEnergy(void)
// Samples fragment kinetic energy (in MeV).
// It uses Dostrovsky's approximation for the inverse reaction cross
// in the probability for fragment emisson
{
if (MaximalKineticEnergy < 0.0)
G4Exception("G4EvaporationChannel::CalcKineticEnergy: maximal kinetic energy is less than 0");
// G4double Rb = 4.0*LevelDensityParameter/(1./MeV)*AResidual*MaximalKineticEnergy/MeV;
// G4double RbSqrt = sqrt(Rb);
// G4double PEX1 = 0.0;
// if (RbSqrt < 160.0) PEX1 = exp(-RbSqrt);
// G4double Rk = 0.0;
// G4double FRk = 0.0;
// do {
// G4double RandNumber = G4UniformRand();
// Rk = 1.0 + (1./RbSqrt)*log(RandNumber + (1.0-RandNumber)*PEX1);
// G4double Q1 = 1.0;
// G4double Q2 = 1.0;
// if (Z == 0) { // for emitted neutron
// G4double Beta = (2.12/pow(AResidual,2./3.) - 0.05)/
// (0.76 + 2.2/pow(AResidual,1./3.));
// Q1 = 1.0 + Beta/(MaximalKineticEnergy/MeV);
// Q2 = Q1*sqrt(Q1);
// }
// FRk = (3.0*sqrt(3.0)/2.0)/Q2 * Rk * (Q1 - Rk*Rk);
// } while (FRk < G4UniformRand());
G4double Rb = 4.0*LevelDensityParameter/(1./MeV)*AResidual*(MaximalKineticEnergy)/MeV;
G4double RbSqrt = sqrt(Rb);
G4double PEX1 = 0.0;
if (RbSqrt < 160.0) PEX1 = exp(-RbSqrt);
G4double Rk = 0.0;
G4double FRk = 0.0;
do {
G4double RandNumber = G4UniformRand();
Rk = 1.0 + (1./RbSqrt)*log(RandNumber + (1.0-RandNumber)*PEX1);
G4double Q1 = 1.0;
G4double Q2 = 1.0;
if (Z == 0) { // for emitted neutron
G4double Beta = (2.12/pow(AResidual,2./3.) - 0.05)/
(0.76 + 2.2/pow(AResidual,1./3.));
Q1 = 1.0 + Beta/(MaximalKineticEnergy/MeV);
Q2 = Q1*sqrt(Q1);
}
FRk = (3.0*sqrt(3.0)/2.0)/Q2 * Rk * (Q1 - Rk*Rk);
} while (FRk < G4UniformRand());
G4double result = (MaximalKineticEnergy)/MeV * (1.0-Rk*Rk) + CoulombBarrier/MeV;
return result;
}
G4ThreeVector G4EvaporationChannel::IsotropicVector(const G4double Magnitude)
// Samples a isotropic random vectorwith a magnitud given by Magnitude.
// By default Magnitude = 1.0
{
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);
return Vector;
}
source/processes/hadronic/models/generator/de_excitation/src/G4EvaporationLevelDensityParameter.cc
+47
View File
@@ -0,0 +1,47 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#include "G4EvaporationLevelDensityParameter.hh"
//const G4double G4EvaporationLevelDensityParameter::EvapLevelDensityParameter = 0.125*(1./MeV);
G4EvaporationLevelDensityParameter::
G4EvaporationLevelDensityParameter(const G4EvaporationLevelDensityParameter &right) :
EvapLevelDensityParameter(0.125*(1./MeV))
{
G4Exception("G4EvaporationLevelDensityParameter::copy_constructor meant to not be accessable");
}
const G4EvaporationLevelDensityParameter & G4EvaporationLevelDensityParameter::
operator=(const G4EvaporationLevelDensityParameter &right)
{
G4Exception("G4EvaporationLevelDensityParameter::operator= meant to not be accessable");
return *this;
}
G4bool G4EvaporationLevelDensityParameter::operator==(const G4EvaporationLevelDensityParameter &right) const
{
return false;
}
G4bool G4EvaporationLevelDensityParameter::operator!=(const G4EvaporationLevelDensityParameter &right) const
{
return true;
}
source/processes/hadronic/models/generator/de_excitation/src/G4EvaporationProbability.cc
+185
View File
@@ -0,0 +1,185 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#include "G4EvaporationProbability.hh"
G4EvaporationProbability::G4EvaporationProbability(const G4EvaporationProbability &right)
{
G4Exception("G4EvaporationProbability::copy_constructor meant to not be accessable");
}
const G4EvaporationProbability & G4EvaporationProbability::
operator=(const G4EvaporationProbability &right)
{
G4Exception("G4EvaporationProbability::operator= meant to not be accessable");
return *this;
}
G4bool G4EvaporationProbability::operator==(const G4EvaporationProbability &right) const
{
return false;
}
G4bool G4EvaporationProbability::operator!=(const G4EvaporationProbability &right) const
{
return true;
}
G4double G4EvaporationProbability::EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation)
// Calculate integrated probability (width) for rvaporation channel:
// If fragment has A_f <= 4 it will be used Dostrovsky's
// approximation for the inverse reaction cross section. If
// fragment has A_f > 4 it will be used Botvina's approximation for
// the inverse reaction cross section.
{
// first af all a test
if (theChannel->GetMaximalKineticEnergy() <= 0.0 || fragment.GetExcitationEnergy() <= 0.0) return 0.0;
// We take decision on which approximation we'll use.
if (theChannel->GetA() <= 4) return DostrovskyApproximation(fragment.GetA(),fragment.GetExcitationEnergy());
else return BotvinaApproximation(fragment.GetA(),fragment.GetExcitationEnergy());
}
G4double G4EvaporationProbability::DostrovskyApproximation(const G4int A, const G4double U)
// Width for evaporation channel with Dostrovsky's approximation for
// inverse cross section.
{
G4double SystemEntropy = 2.0*sqrt((theChannel->GetLevelDensityParameter()/(1./MeV)) *
A * U/MeV);
// r0 -> Absorption Radius R=r0 A^(1/3)
G4double r0 = 2.173*(1.0+0.006103*theChannel->GetZ()*theChannel->GetResidualZ())/
(1.0+0.009443*theChannel->GetZ()*theChannel->GetResidualZ());
// compute the integrated probability of evaporation channel
G4double RN = 1.5;
G4double CC;
if (theChannel->GetA() == 1) CC = 0.2; // neutron, proton
// deuterium, triton, alpha,
else if ((theChannel->GetZ() == 1 && (theChannel->GetA() == 2 || theChannel->GetA() == 3)) ||
(theChannel->GetZ() == 2 && (theChannel->GetA() == 3 || theChannel->GetA() == 4)))
CC = 0.1;
// He5, He6, Li5, Li6, ...., O17, O18
else CC = pow(G4double(theChannel->GetA())/G4double(theChannel->GetResidualA()),2.0/3.0);
G4double ALFA;
G4double BETA;
if (theChannel->GetZ() == 0) { // neutron
ALFA = 0.76+2.2/pow(theChannel->GetResidualA(),1.0/3.0);
BETA = (2.12/pow(theChannel->GetResidualA(),2.0/3.0) - 0.05)/ALFA;
} else {
ALFA = 1.0 + CC;
BETA = 0.0;
}
G4double Q1 = (theChannel->GetLevelDensityParameter()/(1./MeV)) * theChannel->GetResidualA();
G4double Q2 = Q1*theChannel->GetMaximalKineticEnergy()/MeV;
G4double Q3 = (theChannel->GetGamma()*pow(theChannel->GetResidualA(),2.0/3.0))*(ALFA/(Q1*Q1))*
(G4double(theChannel->GetResidualA())/G4double(theChannel->GetResidualA()+theChannel->GetA()))*
(pi*RN*RN)/(2.0*41.5*pi2);
G4double Q4 = (2.0*BETA*Q1-3.0)/2.0 + Q2;
G4double Q5 = (2.0*BETA*Q1-3.0)*(sqrt(Q2)-0.5)+2.0*Q2;
G4double PEX1;
if (SystemEntropy > 160.0) PEX1 = 0.0;
else PEX1 = Q4*exp(-SystemEntropy);
G4double PP2 = SystemEntropy - 2.0*sqrt(Q2);
G4double PEX2;
if (PP2 > 160.0) PEX2 = 0.0;
else PEX2 = Q5*exp(-PP2);
return Q3*(PEX1+PEX2);
}
G4double G4EvaporationProbability::BotvinaApproximation(const G4int A, const G4double U)
// Width for evaporation channel with Botvina's approximation for
// inverse cross section.
{
G4double SystemEntropy = 2.0*sqrt((theChannel->GetLevelDensityParameter()/(1./MeV))*
A * U/MeV);
// r0 -> Absorption Radius R=r0 A^(1/3)
G4double r0 = 2.173*(1.0+0.006103*theChannel->GetZ()*theChannel->GetResidualZ())/
(1.0+0.009443*theChannel->GetZ()*theChannel->GetResidualZ());
// compute the integrated probability of evaporation channel
G4double DALF = 0.869+9.91/theChannel->GetResidualZ();
G4double KinPlusCoul = theChannel->GetMaximalKineticEnergy()/MeV + theChannel->GetCoulombBarrier()/MeV;
if (KinPlusCoul <= theChannel->GetCoulombBarrier()/(5.0*MeV) || theChannel->GetZ() == 0) return 0.0;
G4double CC = pow(G4double(theChannel->GetA())/G4double(theChannel->GetResidualA()),2.0/3.0);
G4double ALFA = 1.0+CC;
G4double Q1 = (theChannel->GetLevelDensityParameter()/(1./MeV)) * theChannel->GetResidualA();
G4double Q3 = theChannel->GetGamma() * pow(theChannel->GetResidualA(),2.0/3.0) * (ALFA/(Q1*Q1))
*(G4double(theChannel->GetResidualA())/G4double(theChannel->GetResidualA()+theChannel->GetA()))*
((pi*r0*r0)/(2.0*41.5*pi2));
G4double TempMKE = theChannel->GetMaximalKineticEnergy()/MeV - 1.0;
G4double prob3 = 0.0;
if (TempMKE > 0.0) {
G4double Q2 = Q1*TempMKE;
G4double Q4 = (2.0*Q1-3.0)/2.0 + Q2;
G4double Q5 = (2.0*Q1-3.0)*(sqrt(Q2)-0.5)+2.0*Q2;
prob3 = Q3*(Q4*exp(-SystemEntropy)+Q5*exp(2.0*sqrt(Q2)-SystemEntropy));
}
G4double EX = theChannel->GetCoulombBarrier()/MeV + 1.0;
G4double EM = KinPlusCoul-Q1/(DALF*DALF);
G4double prob4 = 0.0;
G4double SQ = 0.0;
G4double CSI = 0.0;
G4double F1CSI = 0.0;
if (EM >= EX) {
SQ = sqrt(Q1/(KinPlusCoul-EX));
G4double F1X = DALF-SQ;
G4double F2X = SQ/(2.0*(KinPlusCoul-EX));
if (F1X >= (0.5*F2X)) {
CSI = 0.693/F1X;
G4double SQCSI = sqrt(Q1/(KinPlusCoul-EX+CSI));
G4double F2CSI = SQCSI/(2.0*(KinPlusCoul-EX+CSI));
prob4 = Q3*2.0*Q1*Q1*(1.0/F1X)*
exp(2.0*sqrt(Q1*(KinPlusCoul-EX))-SystemEntropy-F2CSI*CSI*CSI/2.0);
} else {
CSI = 0.48/sqrt(0.5*F2X);
F1CSI = DALF-sqrt(Q1/(KinPlusCoul-EX+CSI));
prob4 = Q3*Q1*Q1*sqrt(6.2832/F2X)*
exp(2.0*sqrt(Q1*(KinPlusCoul-EX))-SystemEntropy-F1CSI*CSI);
}
} else if (EM < EX && EM > theChannel->GetCoulombBarrier()/(5.0*MeV)) {
SQ = sqrt(Q1/(KinPlusCoul-EM));
G4double F2M = SQ/(2.0*(KinPlusCoul-EM));
CSI = 0.48/sqrt(0.5*F2M);
F1CSI = DALF - sqrt(Q1/(KinPlusCoul-EM+CSI));
prob4 = Q3*2.0*Q1*Q1*sqrt(6.2832/F2M)*
exp(DALF*(EM-EX)+2.0*sqrt(Q1*(KinPlusCoul-EM))-SystemEntropy-F1CSI*CSI);
} else return prob3;
return prob3+prob4;
}
source/processes/hadronic/models/generator/de_excitation/src/G4ExcitationHandler.cc
+249
View File
@@ -0,0 +1,249 @@
// 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.
//
// $Id: G4ExcitationHandler.cc,v 1.12 1998/12/15 19:27:42 hpw Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (May 1998)
// Modif (30 June 1998) by V. Lara:
// -Modified the Transform method for use G4ParticleTable and
// therefore G4IonTable. It makes possible to convert all kind
// of fragments (G4Fragment) produced in deexcitation to
// G4DynamicParticle
// -It uses default algorithms for:
// Evaporation: G4StatEvaporation
// MultiFragmentation: G4DummyMF (a dummy one)
// Fermi Breakup model: G4StatFermiBreakUp
#include "G4ExcitationHandler.hh"
G4ExcitationHandler::G4ExcitationHandler():MyOwnEvaporationClass(true),
MyOwnMultiFragmentationClass(true),MyOwnFermiBreakUpClass(true),
MyOwnPhotonEvaporationClass(true),
maxAForFermiBreakUp(16),maxZForFermiBreakUp(8),minEForMultiFrag(1000.0*MeV) // make Multifrag. unavailable
{ // change by 3.0
theTableOfParticles = G4ParticleTable::GetParticleTable();
theEvaporation = new G4Evaporation;
theMultiFragmentation = new G4StatMF;
theFermiModel = new G4FermiBreakUp;
thePhotonEvaporation = new G4PhotonEvaporation;
}
G4ExcitationHandler::G4ExcitationHandler(const G4ExcitationHandler &right)
{
G4Exception("G4ExcitationHandler::copy_constructor: is meant to not be accessable! ");
}
G4ExcitationHandler::~G4ExcitationHandler()
{
if (MyOwnEvaporationClass) delete theEvaporation;
if (MyOwnMultiFragmentationClass) delete theMultiFragmentation;
if (MyOwnFermiBreakUpClass) delete theFermiModel;
if (MyOwnPhotonEvaporationClass) delete thePhotonEvaporation;
}
const G4ExcitationHandler & G4ExcitationHandler::operator=(const G4ExcitationHandler &right)
{
G4Exception("G4ExcitationHandler::operator=: is meant to not be accessable! ");
return *this;
}
G4bool G4ExcitationHandler::operator==(const G4ExcitationHandler &right) const
{
G4Exception("G4ExcitationHandler::operator==: is meant to not be accessable! ");
return false;
}
G4bool G4ExcitationHandler::operator!=(const G4ExcitationHandler &right) const
{
G4Exception("G4ExcitationHandler::operator!=: is meant to not be accessable! ");
return true;
}
G4DynamicParticleVector * G4ExcitationHandler::BreakItUp(const G4Fragment &theInitialState) const
{
G4FragmentVector* theResult = 0;
G4double exEnergy = theInitialState.GetExcitationEnergy();
G4double A = theInitialState.GetA();
G4int Z = theInitialState.GetZ();
G4int Zmax = GetMaxZ();
G4double Amax = GetMaxA();
// Initial State De-Excitation
if(A<GetMaxA()&&Z<GetMaxZ()) {
theResult = theFermiModel->BreakItUp(theInitialState);
} else if (exEnergy>GetMinE()*A) {
theResult = theMultiFragmentation->BreakItUp(theInitialState);
} else {
theResult = theEvaporation->BreakItUp(theInitialState);
}
// De-Excitation loop
G4Fragment theExcitedNucleus;
G4FragmentVector* theTempResult = 0;
// Check if there are excited fragments
G4int i;
for (i = 0; i < theResult->entries(); i++) {
exEnergy = theResult->at(i)->GetExcitationEnergy();
if (exEnergy > 0.0) {
A = theResult->at(i)->GetA();
Z = theResult->at(i)->GetZ();
theExcitedNucleus = *(theResult->at(i));
// try to de-excite this fragment
if(A<GetMaxA()&&Z<GetMaxZ()) {
theTempResult = theFermiModel->BreakItUp(theExcitedNucleus);
} else if(exEnergy>GetMinE()*A) {
theTempResult = theMultiFragmentation->BreakItUp(theExcitedNucleus);
} else {
theTempResult = theEvaporation->BreakItUp(theExcitedNucleus);
}
// The Nucleus has been fragmented?
if (theTempResult->entries() > 1) {
// If so :
// Remove excited fragment from the result
delete theResult->removeAt(i);
// and add theTempResult elements to theResult
while (theTempResult->entries() > 0)
theResult->insert(theTempResult->removeFirst());
i--;
} else { // If not :
// it doesn't matter, we Follow with the next fragment but
// I have to make
theTempResult->clearAndDestroy();
delete theTempResult;
}
}
}
// if (theTempResult != 0 )
// {
// theTempResult->clearAndDestroy();
// delete theTempResult;
// }
// Now we try to deexcite by means of PhotonEvaporation those fragments
// which are excited.
// In next version the Photon Evaporation has to be integrated in the main loop
theTempResult = 0;
for (i = 0; i < theResult->entries(); i++) {
if (theResult->at(i)->GetExcitationEnergy() > 0.0 && theResult->at(i)->GetA() > 1) {
theExcitedNucleus = *(theResult->at(i));
theTempResult = thePhotonEvaporation->BreakItUp(theExcitedNucleus);
// Remove excited fragment from the result
delete theResult->removeAt(i);
// and add theTempResult elements to theResult
while (theTempResult->entries() > 0)
theResult->insert(theTempResult->removeFirst());
theTempResult->clearAndDestroy();
delete theTempResult;
}
}
for (i = 0; i < theResult->entries(); i++)
G4LorentzVector mom(theResult->at(i)->GetMomentum());
// Change G4FragmentVector by G4DynamicParticle
return Transform(theResult);
}
G4DynamicParticleVector *
G4ExcitationHandler::Transform(G4FragmentVector * theFragmentVector) const
{
if (theFragmentVector == 0) return 0;
// Conversion from G4FragmentVector to G4DynamicParticleVector
G4ParticleDefinition *theGamma = G4Gamma::GammaDefinition();
G4ParticleDefinition *theNeutron = G4Neutron::NeutronDefinition();
G4ParticleDefinition *theProton = G4Proton::ProtonDefinition();
G4ParticleDefinition *theDeuteron = G4Deuteron::DeuteronDefinition();
G4ParticleDefinition *theTriton = G4Triton::TritonDefinition();
G4ParticleDefinition *theHelium3 = G4He3::He3Definition();
G4ParticleDefinition *theAlpha = G4Alpha::AlphaDefinition();
G4ParticleDefinition *theKindOfFragment = 0;
theNeutron->SetVerboseLevel(2);
G4DynamicParticleVector * theDynamicParticleVector = new G4DynamicParticleVector;
G4int theFragmentA, theFragmentZ;
G4LorentzVector theFragmentMomentum;
for (G4int i = 0; i < theFragmentVector->entries(); i++) {
// theFragmentVector->at(i)->DumpInfo();
theFragmentA = theFragmentVector->at(i)->GetA();
theFragmentZ = theFragmentVector->at(i)->GetZ();
theFragmentMomentum = theFragmentVector->at(i)->GetMomentum();
theKindOfFragment = 0;
if (theFragmentA == 0 && theFragmentZ == 0) { // photon
theKindOfFragment = theGamma;
} else if (theFragmentA == 1 && theFragmentZ == 0) { // neutron
theKindOfFragment = theNeutron;
} else if (theFragmentA == 1 && theFragmentZ == 1) { // proton
theKindOfFragment = theProton;
} else if (theFragmentA == 2 && theFragmentZ == 1) { // deuteron
theKindOfFragment = theDeuteron;
} else if (theFragmentA == 3 && theFragmentZ == 1) { // triton
theKindOfFragment = theTriton;
} else if (theFragmentA == 3 && theFragmentZ == 2) { // helium3
theKindOfFragment = theHelium3;
} else if (theFragmentA == 4 && theFragmentZ == 2) { // alpha
theKindOfFragment = theAlpha;
} else {
theKindOfFragment = theTableOfParticles->FindIon(theFragmentZ,theFragmentA,0,theFragmentZ);
}
if (theKindOfFragment != 0)
theDynamicParticleVector->insert(new G4DynamicParticle(theKindOfFragment,
theFragmentMomentum.vect()));
}
if (theFragmentVector != 0)
{
theFragmentVector->clearAndDestroy();
delete theFragmentVector;
}
return theDynamicParticleVector;
}
source/processes/hadronic/models/generator/de_excitation/src/G4FermiBreakUp.cc
+85
View File
@@ -0,0 +1,85 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4FermiBreakUp.hh"
G4FermiBreakUp::G4FermiBreakUp()
{
}
G4FermiBreakUp::G4FermiBreakUp(const G4FermiBreakUp &right)
{
G4Exception("G4FermiBreakUp::copy_constructor meant to not be accessable");
}
G4FermiBreakUp::~G4FermiBreakUp()
{
}
const G4FermiBreakUp & G4FermiBreakUp::operator=(const G4FermiBreakUp &right)
{
G4Exception("G4FermiBreakUp::operator= meant to not be accessable");
return *this;
}
G4bool G4FermiBreakUp::operator==(const G4FermiBreakUp &right) const
{
return false;
}
G4bool G4FermiBreakUp::operator!=(const G4FermiBreakUp &right) const
{
return true;
}
G4FragmentVector * G4FermiBreakUp::BreakItUp(const G4Fragment &theNucleus)
{
// CHECK that Excitation Energy != 0
if (theNucleus.GetExcitationEnergy() == 0) {
G4FragmentVector * theResult = new G4FragmentVector;
theResult->insert(new G4Fragment(theNucleus));
return theResult;
}
// Total energy of nucleus in nucleus rest frame (MeV)
G4double TotalEnergyRF = theNucleus.GetExcitationEnergy()/MeV +
G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theNucleus.GetZ(),theNucleus.GetA())/MeV;
G4FermiConfigurationList theConfigurationList;
// Split the nucleus
G4bool Split = theConfigurationList.Initialize(theNucleus.GetA(), theNucleus.GetZ(),
TotalEnergyRF);
if ( !Split ) {
G4FragmentVector * theResult = new G4FragmentVector;
theResult->insert(new G4Fragment(theNucleus));
return theResult;
}
// Chose a configuration
G4FermiConfiguration theConfiguration(theConfigurationList.ChooseConfiguration());
// Get the fragments corresponding to chosen configuration.
G4FragmentVector * theResult = theConfiguration.GetFragments(theNucleus);
return theResult;
}
source/processes/hadronic/models/generator/de_excitation/src/G4FermiConfiguration.cc
+579
View File
@@ -0,0 +1,579 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4FermiConfiguration.hh"
// Kappa = V/V_0 it is used in calculation of Coulomb energy
// Kappa is adimensional
const G4double G4FermiConfiguration::Kappa = 1.0;
// A Z Pol ExcitE
G4StableFermiFragment G4FermiConfiguration::Fragment00( 1, 0, 2, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment01( 1, 1, 2, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment02( 2, 1, 3, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment03( 3, 1, 2, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment04( 3, 2, 2, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment05( 4, 2, 1, 0.00*keV );
G4He5FermiFragment G4FermiConfiguration::Fragment06( 5, 2, 4, 16.76*keV ); // He5
G4Li5FermiFragment G4FermiConfiguration::Fragment07( 5, 3, 4, 16.66*keV ); // Li5
G4StableFermiFragment G4FermiConfiguration::Fragment08( 6, 2, 1, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment09( 6, 3, 3, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment10( 6, 3, 1, 3.56*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment11( 7, 3, 4, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment12( 7, 3, 2, 0.48*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment13( 7, 4, 4, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment14( 7, 4, 2, 0.43*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment15( 8, 3, 5, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment16( 8, 3, 3, 0.98*keV );
G4Be8FermiFragment G4FermiConfiguration::Fragment17( 8, 4, 1, 0.00*keV ); // Be8
G4StableFermiFragment G4FermiConfiguration::Fragment18( 9, 4, 4, 0.00*keV );
G4B9FermiFragment G4FermiConfiguration::Fragment19( 9, 5, 4, 0.00*keV ); // B9
G4StableFermiFragment G4FermiConfiguration::Fragment20( 10, 4, 1, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment21( 10, 4, 5, 3.37*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment22( 10, 4, 8, 5.96*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment23( 10, 4, 1, 6.18*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment24( 10, 4, 5, 6.26*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment25( 10, 5, 7, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment26( 10, 5, 3, 0.72*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment27( 10, 5, 1, 1.74*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment28( 10, 5, 3, 2.15*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment29( 10, 5, 5, 3.59*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment30( 10, 6, 3, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment31( 10, 6, 5, 3.35*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment32( 11, 5, 4, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment33( 11, 5, 2, 2.13*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment34( 11, 5, 6, 4.44*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment35( 11, 5, 4, 5.02*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment36( 11, 5, 10, 6.76*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment37( 11, 5, 6, 7.29*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment38( 11, 5, 4, 7.98*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment39( 11, 5, 6, 8.56*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment40( 11, 6, 4, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment41( 11, 6, 2, 2.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment42( 11, 6, 6, 4.32*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment43( 11, 6, 4, 4.80*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment44( 11, 6, 2, 6.34*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment45( 11, 6, 8, 6.48*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment46( 11, 6, 6, 6.90*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment47( 11, 6, 4, 7.50*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment48( 11, 6, 4, 8.10*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment49( 11, 6, 6, 8.42*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment50( 11, 6, 8, 8.66*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment51( 12, 5, 3, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment52( 12, 5, 5, 0.95*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment53( 12, 5, 5, 1.67*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment54( 12, 5, 4, 2.65*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment55( 12, 6, 1, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment56( 12, 6, 5, 4.44*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment57( 13, 6, 2, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment58( 13, 6, 2, 3.09*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment59( 13, 6, 4, 3.68*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment60( 13, 6, 6, 3.85*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment61( 13, 7, 2, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment62( 14, 6, 1, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment63( 14, 6, 3, 6.09*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment64( 14, 6, 8, 6.69*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment65( 14, 6, 6, 6.96*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment66( 14, 6, 5, 7.34*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment67( 14, 7, 3, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment68( 14, 7, 1, 2.31*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment69( 14, 7, 3, 3.95*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment70( 14, 7, 1, 4.92*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment71( 14, 7, 5, 5.11*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment72( 14, 7, 3, 5.69*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment73( 14, 7, 7, 5.83*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment74( 14, 7, 3, 6.20*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment75( 14, 7, 7, 6.44*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment76( 14, 7, 5, 7.03*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment77( 15, 7, 2, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment78( 15, 7, 8, 5.28*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment79( 15, 7, 4, 6.32*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment80( 15, 7, 10, 7.22*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment81( 15, 7, 8, 7.57*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment82( 15, 7, 2, 8.31*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment83( 15, 7, 4, 8.57*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment84( 15, 7, 14, 9.15*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment85( 15, 7, 14, 9.79*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment86( 15, 7, 8, 10.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment87( 15, 8, 2, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment88( 15, 8, 8, 5.22*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment89( 15, 8, 4, 6.18*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment90( 15, 8, 10, 6.83*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment91( 15, 8, 8, 7.28*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment92( 16, 7, 5, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment93( 16, 7, 1, 0.12*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment94( 16, 7, 7, 0.30*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment95( 16, 7, 3, 0.40*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment96( 16, 8, 1, 0.00*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment97( 16, 8, 8, 6.10*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment98( 16, 8, 5, 6.92*keV );
G4StableFermiFragment G4FermiConfiguration::Fragment99( 16, 8, 3, 7.12*keV );
G4VFermiFragment * G4FermiConfiguration::theListOfFragments[NumberOfFragments] = {
&G4FermiConfiguration::Fragment00,
&G4FermiConfiguration::Fragment01,
&G4FermiConfiguration::Fragment02,
&G4FermiConfiguration::Fragment03,
&G4FermiConfiguration::Fragment04,
&G4FermiConfiguration::Fragment05,
&G4FermiConfiguration::Fragment06,
&G4FermiConfiguration::Fragment07,
&G4FermiConfiguration::Fragment08,
&G4FermiConfiguration::Fragment09,
&G4FermiConfiguration::Fragment10,
&G4FermiConfiguration::Fragment11,
&G4FermiConfiguration::Fragment12,
&G4FermiConfiguration::Fragment13,
&G4FermiConfiguration::Fragment14,
&G4FermiConfiguration::Fragment15,
&G4FermiConfiguration::Fragment16,
&G4FermiConfiguration::Fragment17,
&G4FermiConfiguration::Fragment18,
&G4FermiConfiguration::Fragment19,
&G4FermiConfiguration::Fragment20,
&G4FermiConfiguration::Fragment21,
&G4FermiConfiguration::Fragment22,
&G4FermiConfiguration::Fragment23,
&G4FermiConfiguration::Fragment24,
&G4FermiConfiguration::Fragment25,
&G4FermiConfiguration::Fragment26,
&G4FermiConfiguration::Fragment27,
&G4FermiConfiguration::Fragment28,
&G4FermiConfiguration::Fragment29,
&G4FermiConfiguration::Fragment30,
&G4FermiConfiguration::Fragment31,
&G4FermiConfiguration::Fragment32,
&G4FermiConfiguration::Fragment33,
&G4FermiConfiguration::Fragment34,
&G4FermiConfiguration::Fragment35,
&G4FermiConfiguration::Fragment36,
&G4FermiConfiguration::Fragment37,
&G4FermiConfiguration::Fragment38,
&G4FermiConfiguration::Fragment39,
&G4FermiConfiguration::Fragment40,
&G4FermiConfiguration::Fragment41,
&G4FermiConfiguration::Fragment42,
&G4FermiConfiguration::Fragment43,
&G4FermiConfiguration::Fragment44,
&G4FermiConfiguration::Fragment45,
&G4FermiConfiguration::Fragment46,
&G4FermiConfiguration::Fragment47,
&G4FermiConfiguration::Fragment48,
&G4FermiConfiguration::Fragment49,
&G4FermiConfiguration::Fragment50,
&G4FermiConfiguration::Fragment51,
&G4FermiConfiguration::Fragment52,
&G4FermiConfiguration::Fragment53,
&G4FermiConfiguration::Fragment54,
&G4FermiConfiguration::Fragment55,
&G4FermiConfiguration::Fragment56,
&G4FermiConfiguration::Fragment57,
&G4FermiConfiguration::Fragment58,
&G4FermiConfiguration::Fragment59,
&G4FermiConfiguration::Fragment60,
&G4FermiConfiguration::Fragment61,
&G4FermiConfiguration::Fragment62,
&G4FermiConfiguration::Fragment63,
&G4FermiConfiguration::Fragment64,
&G4FermiConfiguration::Fragment65,
&G4FermiConfiguration::Fragment66,
&G4FermiConfiguration::Fragment67,
&G4FermiConfiguration::Fragment68,
&G4FermiConfiguration::Fragment69,
&G4FermiConfiguration::Fragment70,
&G4FermiConfiguration::Fragment71,
&G4FermiConfiguration::Fragment72,
&G4FermiConfiguration::Fragment73,
&G4FermiConfiguration::Fragment74,
&G4FermiConfiguration::Fragment75,
&G4FermiConfiguration::Fragment76,
&G4FermiConfiguration::Fragment77,
&G4FermiConfiguration::Fragment78,
&G4FermiConfiguration::Fragment79,
&G4FermiConfiguration::Fragment80,
&G4FermiConfiguration::Fragment81,
&G4FermiConfiguration::Fragment82,
&G4FermiConfiguration::Fragment83,
&G4FermiConfiguration::Fragment84,
&G4FermiConfiguration::Fragment85,
&G4FermiConfiguration::Fragment86,
&G4FermiConfiguration::Fragment87,
&G4FermiConfiguration::Fragment88,
&G4FermiConfiguration::Fragment89,
&G4FermiConfiguration::Fragment90,
&G4FermiConfiguration::Fragment91,
&G4FermiConfiguration::Fragment92,
&G4FermiConfiguration::Fragment93,
&G4FermiConfiguration::Fragment94,
&G4FermiConfiguration::Fragment95,
&G4FermiConfiguration::Fragment96,
&G4FermiConfiguration::Fragment97,
&G4FermiConfiguration::Fragment98,
&G4FermiConfiguration::Fragment99
};
G4FermiConfiguration::G4FermiConfiguration()
{
}
G4FermiConfiguration::G4FermiConfiguration(const G4FermiConfiguration &right)
{
Index = right.Index;
}
G4FermiConfiguration::~G4FermiConfiguration()
{
}
const G4FermiConfiguration & G4FermiConfiguration::operator=(const G4FermiConfiguration &right)
{
Index = right.Index;
return *this;
}
G4bool G4FermiConfiguration::operator==(const G4FermiConfiguration &right) const
{
if (Index.entries() == right.Index.entries()) {
for (G4int i = 0; i < Index.entries(); i++) {
if (Index(i) != right.Index(i)) return false;
}
return true;
}
else return false;
}
G4bool G4FermiConfiguration::operator!=(const G4FermiConfiguration &right) const
{
return !(*this == right);
}
void G4FermiConfiguration::Initialize(const G4int max)
{
Index.clear();
for (G4int i = 0; i < max; i++) Index.insert(1);
}
G4bool G4FermiConfiguration::SplitNucleus(const G4int A, const G4int Z)
{
// Splits nucleus (A,Z) into K fragments
// Returns TRUE if splitting is succesful and FALSE in other case
G4int K = Index.entries();
G4int L = 0;
G4int SumA = 0, SumZ = 0;
for (;;) {
L++;
if (L < K) {
Index[L-1]++;
if (Index[L-1] > Index[L]) {
Index[L-1] = 1;
continue;
} else {
SumA = 0;
for (G4int i = 1; i <= K; i++) SumA += theListOfFragments[Index[i-1]-1]->GetA();
if (SumA > A) {
Index[L-1] = 1;
continue;
} else if (SumA < A) {
L = 0;
continue;
} else {
SumZ = 0;
for (G4int i = 1; i <= K; i++) SumZ += theListOfFragments[Index[i-1]-1]->GetZ();
if (SumZ != Z) {
L = 0;
continue;
} else {
return true;
}
}
}
} else {
Index[L-1]++;
if (Index[L-1] > 100) {
return false;
} else {
SumA = 0;
for (G4int i = 1; i <= K; i++) SumA += theListOfFragments[Index[i-1]-1]->GetA();
if (SumA < A) {
L = 0;
continue;
} else if (SumA == A) {
SumZ = 0;
for (G4int i = 1; i <= K; i++) SumZ += theListOfFragments[Index[i-1]-1]->GetZ();
if (SumZ != Z) {
L = 0;
continue;
} else {
return true;
}
} else {
return false;
}
}
}
}
}
G4double G4FermiConfiguration::CoulombBarrier(void)
{
// Calculates Coulomb Barrier (MeV) for given channel with K fragments.
const G4double Coef = ((3. * 1.44) / (5. * 1.3)) * pow(1./(1.+Kappa), 1./3.);
G4double SumA = 0, SumZ = 0;
G4double CoulombEnergy = 0.;
for (G4int i = 0; i < Index.entries(); i++) {
G4double z = theListOfFragments[Index[i]-1]->GetZ();
G4double a = theListOfFragments[Index[i]-1]->GetA();
CoulombEnergy += (z*z) / pow(a, 1./3.);
SumA += a;
SumZ += z;
}
CoulombEnergy -= SumZ*SumZ/pow(SumA, 1./3.);
return -Coef * CoulombEnergy;
}
G4double G4FermiConfiguration::DecayProbability(const G4int A, const G4double TotalE)
// Decay probability for a given channel with K fragments
{
// A: Atomic Weight
// TotalE: Total energy of nucleus (MeV)
G4int K = Index.entries();
G4int i;
const G4double VAK = (1.3/(0.21*sqrt(0.94)))*(1.3/(0.21*sqrt(0.94)))*(1.3/(0.21*sqrt(0.94)))*
Kappa*sqrt(2.0/pi)/3.0;
G4double * GAF = new G4double[K];
GAF[0] = 0.0;
GAF[1] = 1.0/sqrt(pi);
for (i = 2; i < K; i++) {
G4double qk = 1./(1.5*i-2.5);
G4double gq = 1. + qk*(1./12. + qk*(1./288. - qk*(139./51840.)));
GAF[i] = sqrt(0.1591549*qk)/gq;
}
G4double DeltaEnergy = TotalE; // MeV
G4double Weight = 0.;
G4double ProdAMass = 1.;
G4double ProdSpin = 1.;
for (i = 0; i<K; i++) {
ProdAMass *= theListOfFragments[Index[i]-1]->GetA();
ProdSpin *= theListOfFragments[Index[i]-1]->GetPolarization();
DeltaEnergy -= (theListOfFragments[Index[i]-1]->GetFragmentMass()/MeV +
theListOfFragments[Index[i]-1]->GetExcitationEnergy()/MeV);
};
if ((DeltaEnergy -= CoulombBarrier()) <= 0.0) {
delete [] GAF;
return Weight;
}
ProdAMass /= A;
ProdAMass *= sqrt(ProdAMass)*ProdSpin;
if (K <= 2) {
Weight = 1.1283792*A*Kappa*ProdAMass*sqrt(DeltaEnergy);
if (Index[0] == Index[1]) Weight *= 0.5;
} else {
DeltaEnergy *= 2.71828183/(1.5*K-2.5);
G4double VTK = A*Kappa*DeltaEnergy*sqrt(DeltaEnergy);
G4double VMK = 1.0, RPM= 1.0;
for (G4int i = 0; i < K-1; i++) {
VMK *= VTK;
G4int MRS = 1;
for (G4int j = i+1; j<K; j++) if(Index[i] == Index[j]) MRS++;
RPM *= MRS;
};
Weight = VMK*ProdAMass*GAF[K-1]/(DeltaEnergy*RPM);
}
delete [] GAF;
return Weight;
}
G4FragmentVector * G4FermiConfiguration::GetFragments(const G4Fragment & theNucleus)
{
G4int K = Index.entries();
// Avalaible kinetic energy of system.
G4double AvalKineticEnergy = theNucleus.GetExcitationEnergy()/MeV +
G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theNucleus.GetZ(),theNucleus.GetA())/MeV;
G4int i;
for (i = 0; i < K; i++)
AvalKineticEnergy -= theListOfFragments[Index[i]-1]->GetFragmentMass()/MeV;
// Calculate Momenta of K fragments
RWTPtrOrderedVector<G4LorentzVector>* MomentumComponents =
FragmentsMomentum(AvalKineticEnergy*MeV);
G4FragmentVector * theResult = new G4FragmentVector;
// Go back to the Lab Frame
for (i = 0; i < K; i++) {
G4LorentzVector FourMomentum(*(MomentumComponents->at(i)));
// Lorentz boost
FourMomentum.boost(theNucleus.GetMomentum().boostVector());
G4FragmentVector * fragment = theListOfFragments[Index[i]-1]->GetFragment(FourMomentum);
do {
theResult->insert(fragment->removeFirst());
} while (fragment->entries() > 0);
delete fragment;
}
MomentumComponents->clearAndDestroy();
delete MomentumComponents;
return theResult;
}
RWTPtrOrderedVector<G4LorentzVector>*
G4FermiConfiguration::FragmentsMomentum(G4double KineticEnergy)
{
// Calculates momentum for K fragments (Kopylov's method of sampling is used)
// KinetEnergy is the available kinetic energy
G4int K = Index.entries();
RWTPtrOrderedVector<G4LorentzVector>* MomentumList =
new RWTPtrOrderedVector<G4LorentzVector>(K);
G4double AvalaibleMass = 0;
for (G4int i=0; i<K; i++) AvalaibleMass += theListOfFragments[Index[i]-1]->GetFragmentMass();
G4double PFragMagCM = 0.0;
G4double Mass = AvalaibleMass+KineticEnergy;
G4LorentzVector PFragCM(0.0,0.0,0.0,0.0);
G4LorentzVector PFragLab(0.0,0.0,0.0,0.0);
G4LorentzVector PRestCM(0.0,0.0,0.0,0.0);
G4LorentzVector PRestLab(0.0,0.0,0.0,Mass);
for (G4int l = 0; l < K-1; l++) {
G4int LK = K - l;
G4double FragMass = theListOfFragments[Index[LK-1]-1]->GetFragmentMass();
AvalaibleMass -= FragMass;
if (LK > 2) KineticEnergy *= RNKSI(LK-1);
else KineticEnergy = 0.0;
G4double RestMass = AvalaibleMass + KineticEnergy;
PFragMagCM = sqrt(
abs((Mass*Mass - (FragMass + RestMass)*(FragMass + RestMass))*
(Mass*Mass - (FragMass - RestMass)*(FragMass - RestMass)))
)/ (2.0*Mass);
// Create a unit vector with a random direction isotropically distributed
G4ParticleMomentum RandVector(IsotropicVector(PFragMagCM));
PFragCM.setVect(RandVector);
// PFragCM.setE((Mass*Mass + FragMass*FragMass - RestMass*RestMass)/(2.0*Mass));
PFragCM.setE(sqrt(RandVector.mag2()+FragMass*FragMass));
PRestCM.setVect(-RandVector);
// PRestCM.setE((Mass*Mass + RestMass*RestMass - FragMass*FragMass)/(2.0*Mass));
PRestCM.setE(sqrt(RandVector.mag2()+RestMass*RestMass));
G4ThreeVector BoostV = PRestLab.boostVector();
PFragLab = PFragCM;
PFragLab.boost(BoostV);
PRestLab = PRestCM;
PRestLab.boost(BoostV);
MomentumList->prepend(new G4LorentzVector(PFragLab));
Mass = RestMass;
}
MomentumList->prepend(new G4LorentzVector(PRestLab));
return MomentumList;
}
G4double G4FermiConfiguration::RNKSI(const G4int K)
{
G4double csim = (3.0*K-5.0)/(3.0*K-4.0);
G4double pex = 1.5*K-2.5;
G4double fcsim = sqrt(1.0-csim)*pow(csim,pex);
G4double csi = 0.0;
G4double fcsi= 0.0;
G4double rf = 0.0;
do {
csi = G4UniformRand();
fcsi = sqrt(1.0-csi)*pow(csi,pex);
rf = fcsim*G4UniformRand();
} while (rf > fcsi);
return csi;
}
G4ParticleMomentum G4FermiConfiguration::IsotropicVector(const G4double Magnitude)
// Samples a isotropic random vectorwith a magnitud given by Magnitude.
// By default Magnitude = 1.0
{
G4double CosTheta = 1.0 - 2.0*G4UniformRand();
G4double SinTheta = sqrt(1.0 - CosTheta*CosTheta);
G4double Phi = twopi*G4UniformRand();
G4ParticleMomentum Vector(Magnitude*cos(Phi)*SinTheta,
Magnitude*sin(Phi)*SinTheta,
Magnitude*CosTheta);
return Vector;
}
source/processes/hadronic/models/generator/de_excitation/src/G4FermiConfigurationList.cc
+108
View File
@@ -0,0 +1,108 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4FermiConfigurationList.hh"
G4FermiConfigurationList::G4FermiConfigurationList():
TotNumOfConfigurations(0)
{
for (G4int i = 0; i < MaxNumOfFragments; i++) NumOfConfigurations[i] = 0;
}
G4FermiConfigurationList::G4FermiConfigurationList(const G4FermiConfigurationList &right)
{
G4Exception("G4FermiConfigurationList::copy_constructor meant to not be accessable");
}
const G4FermiConfigurationList & G4FermiConfigurationList::operator=(const G4FermiConfigurationList &right)
{
G4Exception("G4FermiConfigurationList::operator= meant to not be accessable");
return *this;
}
G4bool G4FermiConfigurationList::operator==(const G4FermiConfigurationList &right) const
{
return false;
}
G4bool G4FermiConfigurationList::operator!=(const G4FermiConfigurationList &right) const
{
return true;
}
G4bool G4FermiConfigurationList::Initialize(const G4int A, const G4int Z, const G4double TotalEnergyRF)
{
//
// let's split nucleus into k = 2,...,6 fragments
//
Configurations.clear();
NormalizedWeights.clear();
G4FermiConfiguration aConfiguration;
RWTValOrderedVector<G4double> NOTNormalizedWeights;
G4double NormStatWeight = 0.0;
for (G4int k = 2; k <= 6; k++) {
// Initialize Configuration for k fragments
aConfiguration.Initialize(k);
G4bool SplitSuccesed;
do {
// Splits the nucleus into k fragments
SplitSuccesed = aConfiguration.SplitNucleus(A,Z);
if (SplitSuccesed) {
TotNumOfConfigurations++;
NumOfConfigurations[k-1]++;
// Non-Normalized statistical weight (decay probavility) for given channel with k fragments
// Decay probability returns very big numbers--> I put a temporal scale factor 10^-6
G4double StatWeight = aConfiguration.DecayProbability(A,TotalEnergyRF)*1.0e-6;
NormStatWeight += StatWeight;
// Statistical weights (it will be normalized...)
NOTNormalizedWeights.insert(StatWeight);
G4int NumeroDeConf = Configurations.entries();
// Store configuration
Configurations.insert(aConfiguration);
}
// Repeat splitting into k fragments (it may be several posibilities for a choosen K)
} while (SplitSuccesed);
}
if (NormStatWeight > 0.0) {
// Let's normalize statistical weights of channels
for (G4int i = 0; i < TotNumOfConfigurations; i++)
NormalizedWeights.insert(NOTNormalizedWeights(i)/NormStatWeight);
return true;
}
else return false;
}
G4FermiConfiguration G4FermiConfigurationList::ChooseConfiguration(void)
{
G4double RandomWeight = G4UniformRand();
G4double AcumWeight = 0.0;
G4int thisConfig = 0;
do {
AcumWeight += NormalizedWeights(thisConfig); // We are adding the prob. of each configuration
thisConfig++;
} while ((thisConfig <= TotNumOfConfigurations) && (AcumWeight < RandomWeight));
return Configurations(thisConfig - 1);
}
source/processes/hadronic/models/generator/de_excitation/src/G4FissionBarrier.cc
+143
View File
@@ -0,0 +1,143 @@
// 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.
//
// $Id: G4FissionBarrier.cc,v 1.1 1998/10/15 07:56:56 larazb Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
#include "G4FissionBarrier.hh"
G4FissionBarrier::G4FissionBarrier(const G4FissionBarrier & right)
{
G4Exception("G4FissionBarrier::copy_constructor meant to not be accessable.");
}
const G4FissionBarrier & G4FissionBarrier::operator=(const G4FissionBarrier & right)
{
G4Exception("G4FissionBarrier::operator= meant to not be accessable.");
return *this;
}
G4bool G4FissionBarrier::operator==(const G4FissionBarrier & right) const
{
return false;
}
G4bool G4FissionBarrier::operator!=(const G4FissionBarrier & right) const
{
return true;
}
G4double G4FissionBarrier::FissionBarrier(const G4int A, const G4int Z)
// Compute fission barrier according with Barashenkov's prescription for A >= 65
{
if (A >= 65) return BarashenkovFissionBarrier(A,Z)*MeV;
else return 1.0*GeV;
}
G4double G4FissionBarrier::BarashenkovFissionBarrier(const G4int A, const G4int Z)
// Calculates Fission Barrier heights (in MeV), which are function of the nuclear
// fissility parameteter x = Z*Z/A.
// Barashenkov V., Iljinov A. and Toneev V. parametrization (1972)
{
const G4double ShellCorr1[130] = {
20.80, 15.80, 21.00, 16.80, 19.80,
16.50, 18.80, 16.50, 18.50, 17.20,
18.26, 15.05, 16.01, 12.04, 13.27,
11.09, 12.17, 10.26, 11.04, 8.41,
9.79, 7.36, 8.15, 5.63, 5.88,
3.17, 3.32, 0.82, 1.83, 0.97,
2.33, 1.27, 2.92, 1.61, 2.91,
1.35, 2.40, 0.89, 1.74, 0.36,
0.95, -0.65, -0.04, -1.73, -0.96,
-2.87, -2.05, -4.05, -3.40, -5.72,
-3.75, -4.13, -2.42, -2.85, -1.01,
-1.33, 0.54, -0.02, 1.74, 0.75,
2.24, 1.00, 1.98, 0.79, 1.54,
0.39, 1.08, 0.00, 0.78, -0.35,
0.58, -0.55, 0.59, -0.61, 0.59,
-0.35, 0.32, -0.96, -0.52, -2.08,
-2.46, -3.64, -1.55, -0.96, 0.97,
0.88, 2.37, 1.75, 2.72, 1.90,
2.55, 1.46, 1.93, 0.86, 1.17,
0.08, 0.39, -0.76, -0.39, -1.51,
-1.17, -2.36, -1.95, -3.06, -2.62,
-3.55, -2.95, -3.75, -3.07, -3.79,
-3.06, -3.77, -3.05, -3.78, -3.12,
-3.90, -3.35, -4.24, -3.86, -4.92,
-5.06, -6.77, -7.41, -9.18, -10.16,
-11.12, -9.76, -9.23, -7.96, -7.65};
const G4double ShellCorr2[200] = {
-8.40, -12.90, -8.00, -11.90, -9.20,
-12.50, -10.80, -13.60, -11.20, -12.20,
-12.81, -15.40, -13.07, -15.80, -13.81,
-14.98, -12.63, -13.76, -11.37, -12.38,
-9.23, -9.65, -7.64, -9.17, -8.05,
-9.72, -8.87, -10.76, -8.64, -8.89,
-6.60, -7.13, -4.77, -5.33, -3.06,
-3.79, -1.72, -2.79, -0.93, -2.19,
-0.52, -1.90, -0.45, -2.20, -1.22,
-3.07, -2.42, -4.37, -3.94, -6.08,
-4.49, -4.50, -3.14, -2.93, -1.04,
-1.36, 0.69, 0.21, 2.11, 1.33,
3.29, 2.46, 4.30, 3.32, 4.79,
3.62, 4.97, 3.64, 4.63, 3.07,
4.06, 2.49, 3.30, 1.46, 2.06,
0.51, 0.74, -1.18, -1.26, -3.54,
-3.97, -5.26, -4.18, -3.71, -2.10,
-1.70, -0.08, -0.18, 0.94, 0.27,
1.13, 0.08, 0.91, -0.31, 0.49,
-0.78, 0.08, -1.15, -0.23, -1.41,
-0.42, -1.55, -0.55, -1.66, -0.66,
-1.73, -0.75, -1.74, -0.78, -1.69,
-0.78, -1.60, -0.75, -1.46, -0.67,
-1.26, -0.51, -1.04, -0.53, -1.84,
-2.42, -4.52, -4.76, -6.33, -6.76,
-7.81, -5.80, -5.37, -3.63, -3.35,
-1.75, -1.88, -0.61, -0.90, 0.09,
-0.32, 0.55, -0.13, 0.70, -0.06,
0.49, -0.20, 0.40, -0.22, 0.36,
-0.09, 0.58, 0.12, 0.75, 0.15,
0.70, 0.17, 1.11, 0.89, 1.85,
1.62, 2.54, 2.29, 3.20, 2.91,
3.84, 3.53, 4.48, 4.15, 5.12,
4.78, 5.75, 5.39, 6.31, 5.91,
6.87, 6.33, 7.13, 6.61, 7.30,
6.31, 6.27, 4.83, 4.49, 2.85,
2.32, 0.58, -0.11, -0.98, 0.81,
1.77, 3.37, 4.13, 5.60, 6.15,
7.29, 7.35, 7.95, 7.67, 8.16,
7.83, 8.31, 8.01, 8.53, 8.27};
const G4int N = A - Z;
// const G4double x = (static_cast<G4double>(Z)*static_cast<G4double>(Z))/
// static_cast<G4double>(A);
const G4double x = (G4double(Z)*G4double(Z))/G4double(A);
G4double BF0 = 0.0;
if (x <= 33.5) BF0 = 12.5 + 4.7*pow((33.5-x),0.75);
else BF0 = 12.5 - 2.7*pow((x-33.5),2.0/3.0);
// Determine which kind of nucleus is: even-even, odd-odd, even-odd, odd-even
G4double D = 0.0;
G4int I = 2*(Z/2);
G4int J = 2*(N/2);
if (I < Z) D = 0.0;
else D = -0.5;
if (J < N) D += 1.0;
if (Z > 130 || N > 200) return BF0 + D;
else return BF0 + D - ShellCorr1[Z-1] - ShellCorr2[N-1];
}
source/processes/hadronic/models/generator/de_excitation/src/G4FissionLevelDensityParameter.cc
+52
View File
@@ -0,0 +1,52 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#include "G4FissionLevelDensityParameter.hh"
G4FissionLevelDensityParameter::
G4FissionLevelDensityParameter(const G4FissionLevelDensityParameter &right)
{
G4Exception("G4FissionLevelDensityParameter::copy_constructor meant to not be accessable");
}
const G4FissionLevelDensityParameter & G4FissionLevelDensityParameter::
operator=(const G4FissionLevelDensityParameter &right)
{
G4Exception("G4FissionLevelDensityParameter::operator= meant to not be accessable");
return *this;
}
G4bool G4FissionLevelDensityParameter::
operator==(const G4FissionLevelDensityParameter &right) const
{
return false;
}
G4bool G4FissionLevelDensityParameter::
operator!=(const G4FissionLevelDensityParameter &right) const
{
return true;
}
G4double G4FissionLevelDensityParameter::
LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const
{
G4double EvapLDP = theEvaporationLevelDensityParameter.LevelDensityParameter(A,Z,U);
if (Z >= 89) return 1.04*EvapLDP;
else if (Z >= 85) return (1.04*(1./MeV) + 0.01*(89-Z))*EvapLDP;
else return 1.08*EvapLDP;
}
source/processes/hadronic/models/generator/de_excitation/src/G4FissionParameters.cc
+92
View File
@@ -0,0 +1,92 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#include "G4FissionParameters.hh"
const G4double G4FissionParameters::A1 = 134.0;
const G4double G4FissionParameters::A2 = 141.0;
G4FissionParameters::G4FissionParameters(const G4int A, const G4int Z, const G4double ExEnergy,
const G4double FissionBarrier)
{
G4double U = ExEnergy/MeV;
As = A/2.0;
if (A >= 235) Sigma2 = 5.6; // MeV
else Sigma2 = 5.6 + 0.096*(A-235); // MeV
Sigma1 = 0.5*Sigma2; // MeV
SigmaS = exp(0.00553*U + 4.1386); // MeV
G4double FasymAsym = 2.0*exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) +
exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
G4double FsymA1A2 = exp(-((As-(A1+A2))*(As-(A1+A2)))/(2.0*SigmaS*SigmaS));
G4double wa;
G4double w1,w2;
w = 0.0;
if (Z >= 90) { // Z >= 90
if (U <= 16.25) wa = exp(0.5385*U-9.9564); // U <= 16.25 MeV
else wa = exp(0.09197*U-2.7003); // U > 16.25 MeV
} else if (Z == 89) { // Z == 89
wa = exp(0.09197*U-1.0808);
} else if (Z >= 82) { // 82 <= Z <= 88
G4double X = FissionBarrier/MeV - 7.5;
if (X < 0.0) X = 0.0;
wa = exp(0.09197*(U-X)-1.0808);
} else { // Z < 82
w = 1001.0;
}
if (w == 0.0) {
w1 = max(1.03*wa - FasymAsym, 0.0001);
w2 = max(1.0 - FsymA1A2*wa, 0.0001);
w = w1/w2;
if (82 <= Z && Z < 89 && A < 227) w *= exp(0.3*(A-227));
}
}
G4FissionParameters::G4FissionParameters(const G4FissionParameters &right)
{
G4Exception("G4FissionParameters::copy_constructor meant to not be accessable");
}
const G4FissionParameters & G4FissionParameters::operator=(const G4FissionParameters &right)
{
G4Exception("G4FissionParameters::operator= meant to not be accessable");
return *this;
}
G4bool G4FissionParameters::operator==(const G4FissionParameters &right) const
{
return false;
}
G4bool G4FissionParameters::operator!=(const G4FissionParameters &right) const
{
return true;
}
source/processes/hadronic/models/generator/de_excitation/src/G4FissionProbability.cc
+71
View File
@@ -0,0 +1,71 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Oct 1998)
//
#include "G4FissionProbability.hh"
G4FissionProbability::G4FissionProbability(const G4FissionProbability &right)
{
G4Exception("G4FissionProbability::copy_constructor meant to not be accessable");
}
const G4FissionProbability & G4FissionProbability::operator=(const G4FissionProbability &right)
{
G4Exception("G4FissionProbability::operator= meant to not be accessable");
return *this;
}
G4bool G4FissionProbability::operator==(const G4FissionProbability &right) const
{
return false;
}
G4bool G4FissionProbability::operator!=(const G4FissionProbability &right) const
{
return true;
}
G4double G4FissionProbability::EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation)
//
{
G4double A = fragment.GetA();
G4double Z = fragment.GetZ();
G4double U = fragment.GetExcitationEnergy();
G4double SystemEntropy = 2.0*sqrt((theEvapLDP.LevelDensityParameter(A,Z,U)/(1./MeV))*A*U/MeV);
// Compute integrated probability of fission channel
if (theChannel->GetMaximalKineticEnergy() <= 0.0) return 0.0;
G4double Q1 = 2.0*sqrt((theFissLDP.LevelDensityParameter(A,Z,U)/(1./MeV))*A*
theChannel->GetMaximalKineticEnergy()/MeV);
G4double Q2 = 1./(4.0*pi);
// G4double Tfis = 21.e-6*940.0;
//return min(Tfis,(Q2/((theFissLDP.LevelDensityParameter(A,Z,U)/(1./MeV))*A))*
// ((Q1-1.0)*exp(Q1-SystemEntropy)+exp(-SystemEntropy)));
return (Q2/((theFissLDP.LevelDensityParameter(A,Z,U)/(1./MeV))*A))*
((Q1-1.0)*exp(Q1-SystemEntropy)+exp(-SystemEntropy));
}
source/processes/hadronic/models/generator/de_excitation/src/G4He5FermiFragment.cc
+94
View File
@@ -0,0 +1,94 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4He5FermiFragment.hh"
G4He5FermiFragment::G4He5FermiFragment()
{
}
G4He5FermiFragment::G4He5FermiFragment(const G4He5FermiFragment &right)
{
G4Exception("G4He5FermiFragment::copy_constructor meant to not be accessable");
}
G4He5FermiFragment::~G4He5FermiFragment()
{
}
const G4He5FermiFragment & G4He5FermiFragment::operator=(const G4He5FermiFragment &right)
{
G4Exception("G4He5FermiFragment::operator= meant to not be accessable");
return *this;
}
G4bool G4He5FermiFragment::operator==(const G4He5FermiFragment &right) const
{
return false;
}
G4bool G4He5FermiFragment::operator!=(const G4He5FermiFragment &right) const
{
return true;
}
G4FragmentVector * G4He5FermiFragment::GetFragment(const G4LorentzVector & aMomentum)
// He5 ----> alpha + neutron
{
const G4int NumSubFrag = 2;
G4double Masses[NumSubFrag];
G4double Charges[NumSubFrag];
G4double AtomNum[NumSubFrag];
Masses[0] = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(2,4); // alpha
Masses[1] = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(0,1); // neutron
AtomNum[0] = 4;
AtomNum[1] = 1;
Charges[0] = 2;
Charges[1] = 0;
// G4double AvalKineticE = G4NucleiPropertiesTable::GetMassExcess(Z,A) + ExcitEnergy - // He5
// G4NucleiPropertiesTable::GetMassExcess(0,1) - // neutron
// G4NucleiPropertiesTable::GetMassExcess(2,4); // alpha
G4double AvalKineticE = sqrt(aMomentum.e()*aMomentum.e() -
aMomentum.vect().mag2()) - // He5
Masses[1] - // neutron
Masses[0]; // alpha
RWTPtrOrderedVector<G4LorentzVector> * SubFragsMomentum =
FragmentsMomentum(AvalKineticE, NumSubFrag,Masses);
G4FragmentVector * theResult = new G4FragmentVector;
for (G4int i = 0; i < NumSubFrag; i++) {
// Lorentz boost
SubFragsMomentum->at(i)->boost(aMomentum.boostVector());
theResult->insert(new G4Fragment(AtomNum[i],Charges[i],*(SubFragsMomentum->at(i))));
}
SubFragsMomentum->clearAndDestroy();
delete SubFragsMomentum;
return theResult;
}
source/processes/hadronic/models/generator/de_excitation/src/G4Li5FermiFragment.cc
+92
View File
@@ -0,0 +1,92 @@
// 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.
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4Li5FermiFragment.hh"
G4Li5FermiFragment::G4Li5FermiFragment()
{
}
G4Li5FermiFragment::G4Li5FermiFragment(const G4Li5FermiFragment &right)
{
G4Exception("G4Li5FermiFragment::copy_constructor meant to not be accessable");
}
G4Li5FermiFragment::~G4Li5FermiFragment()
{
}
const G4Li5FermiFragment & G4Li5FermiFragment::operator=(const G4Li5FermiFragment &right)
{
G4Exception("G4Li5FermiFragment::operator= meant to not be accessable");
return *this;
}
G4bool G4Li5FermiFragment::operator==(const G4Li5FermiFragment &right) const
{
return false;
}
G4bool G4Li5FermiFragment::operator!=(const G4Li5FermiFragment &right) const
{
return true;
}
G4FragmentVector * G4Li5FermiFragment::GetFragment(const G4LorentzVector & aMomentum)
// Li5 ----> alpha + proton
{
const G4int NumSubFrag = 2;
G4double Masses[NumSubFrag];
G4double Charges[NumSubFrag];
G4double AtomNum[NumSubFrag];
Masses[0] = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(2,4); // alpha
Masses[1] = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(1,1); // proton
AtomNum[0] = 4;
AtomNum[1] = 1;
Charges[0] = 2;
Charges[1] = 1;
// G4double AvalKineticE = G4NucleiPropertiesTable::GetMassExcess(Z,A) + ExcitEnergy - // Li5
// G4NucleiPropertiesTable::GetMassExcess(1,1) - // proton
// G4NucleiPropertiesTable::GetMassExcess(2,4); // alpha
G4double AvalKineticE = sqrt(aMomentum.e()*aMomentum.e() -
aMomentum.vect().mag2()) - // Li5
Masses[0] - // proton
Masses[1]; // alpha
RWTPtrOrderedVector<G4LorentzVector> * SubFragsMomentum =
FragmentsMomentum(AvalKineticE, NumSubFrag,Masses);
G4FragmentVector * theResult = new G4FragmentVector;
for (G4int i = 0; i < NumSubFrag; i++) {
// Lorentz boost
SubFragsMomentum->at(i)->boost(aMomentum.boostVector());
theResult->insert(new G4Fragment(AtomNum[i],Charges[i],*(SubFragsMomentum->at(i))));
}
SubFragsMomentum->clearAndDestroy();
delete SubFragsMomentum;
return theResult;
}
source/processes/hadronic/models/generator/de_excitation/src/G4MultiFragmentation.cc
+46
View File
@@ -0,0 +1,46 @@
// 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.
//
// $Id: G4MultiFragmentation.cc,v 1.1 1998/08/22 08:53:49 hpw Exp $
// GEANT4 tag $Name: geant4-00 $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (May 1998)
#include "G4MultiFragmentation.hh"
G4MultiFragmentation::G4MultiFragmentation()
{
}
G4MultiFragmentation::G4MultiFragmentation(const G4MultiFragmentation &right)
{
}
G4MultiFragmentation::~G4MultiFragmentation()
{
}
const G4MultiFragmentation & G4MultiFragmentation::operator=(const G4MultiFragmentation &right)
{
G4Exception("G4MultiFragmentation::operator= meant to not be accessable");
return *this;
}
int G4MultiFragmentation::operator==(const G4MultiFragmentation &right) const
{
return (this == (G4MultiFragmentation *) &right);
}
int G4MultiFragmentation::operator!=(const G4MultiFragmentation &right) const
{
return (this != (G4MultiFragmentation *) &right);
}
source/processes/hadronic/models/generator/de_excitation/src/G4NuclearLevel.cc
+153
View File
@@ -0,0 +1,153 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4NuclearLevel
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 24 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#include "G4NuclearLevel.hh"
#include "globals.hh"
G4NuclearLevel::G4NuclearLevel(const G4double energy,
const G4DataVector& eGamma, const G4DataVector& wGamma)
{
_energy = energy;
G4int i;
for (i=0; i<eGamma.entries(); i++)
{
_energies.insert(eGamma.at(i));
_weights.insert(wGamma.at(i));
}
_nGammas = _energies.entries();
MakeProbabilities();
MakeCumProb();
}
G4NuclearLevel::~G4NuclearLevel()
{ }
G4bool G4NuclearLevel::operator==(const G4NuclearLevel &right) const
{
return (this == (G4NuclearLevel *) &right);
}
G4bool G4NuclearLevel::operator!=(const G4NuclearLevel &right) const
{
return (this != (G4NuclearLevel *) &right);
}
G4bool G4NuclearLevel::operator<(const G4NuclearLevel &right) const
{
if (_energy < right.Energy()) return true;
else return false;
}
const G4DataVector& G4NuclearLevel::GammaEnergies() const
{
return _energies;
}
const G4DataVector& G4NuclearLevel::GammaWeights() const
{
return _weights;
}
const G4DataVector& G4NuclearLevel::GammaProbabilities() const
{
return _prob;
}
const G4DataVector& G4NuclearLevel::GammaCumulativeProbabilities() const
{
return _cumProb;
}
G4double G4NuclearLevel::Energy() const
{
return _energy;
}
G4int G4NuclearLevel::NumberOfGammas() const
{
return _nGammas;
}
void G4NuclearLevel::PrintAll() const
{
G4cout << "---- Level energy = " << _energy << ", " << _nGammas << " photons" << endl;
G4int i;
G4cout << " Gammas: ";
for (i=0; i<_nGammas; i++) { G4cout << _energies.at(i) << " "; }
G4cout << endl << " Weights: ";
for (i=0; i<_nGammas; i++) { G4cout << _weights.at(i) << " "; }
G4cout << endl << " Relative transition probabilities ";
for (i=0; i<_nGammas; i++) { G4cout << _prob.at(i) << " "; }
G4cout << endl << " Cumulative probabilities: ";
for (i=0; i<_nGammas; i++) { G4cout << _cumProb.at(i) << " "; }
G4cout << endl;
return;
}
void G4NuclearLevel::MakeProbabilities()
{
G4double sum = 0.;
G4int i = 0;
for (i=0; i<_nGammas; i++)
{
sum += _weights.at(i);
}
for (i=0; i<_nGammas; i++)
{
if (sum > 0.) { _prob.insert(_weights.at(i) / sum); }
else { _prob.insert(1./_nGammas); }
}
return;
}
void G4NuclearLevel::MakeCumProb()
{
if (_nGammas > 0)
{
G4double sum = _prob.at(0);
_cumProb.insert(sum);
G4int i = 0;
for (i=1; i<_nGammas; i++)
{
sum += _prob.at(i);
_cumProb.insert(sum);
}
}
return;
}
source/processes/hadronic/models/generator/de_excitation/src/G4NuclearLevelManager.cc
+311
View File
@@ -0,0 +1,311 @@
// 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.
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4NuclearLevelManager
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 24 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#include "G4NuclearLevelManager.hh"
#include "globals.hh"
#include "G4NuclearLevel.hh"
#include "G4ios.hh"
#include <stdlib.h>
#include <fstream.h>
#include <strstream.h>
G4NuclearLevelManager::G4NuclearLevelManager():
_A(0), _Z(0), _levels(0), _levelEnergy(0), _gammaEnergy(0), _probability(0)
{ }
G4NuclearLevelManager::G4NuclearLevelManager(G4int Z, G4int A): _Z(Z), _A(A)
{
if (A <= 0 || Z <= 0 || Z > A )
G4Exception("==== G4NuclearLevelManager ==== (Z,A) <0, or Z>A");
_levels = 0;
MakeLevels();
}
G4NuclearLevelManager::~G4NuclearLevelManager()
{
if ( _levels ) {
if (_levels->entries()>0) _levels->clearAndDestroy();
delete _levels;
_levels = 0;
}
}
void G4NuclearLevelManager::SetNucleus(G4int Z, G4int A)
{
if (_Z != Z || _A != A)
{
_A = A;
_Z = Z;
MakeLevels();
}
}
G4bool G4NuclearLevelManager::IsValid(G4int Z, G4int A) const
{
G4bool valid = true;
if (A < 0 || Z < 0 || A < Z) valid = false;
G4String dirName = getenv("G4LEVELGAMMADATA");
char name[100] = {""};
ostrstream ost(name, 100, ios::out);
ost << dirName << "/" << "z" << Z << ".a" << A;
G4String file(name);
ifstream inFile(file);
if (! inFile) valid = false;
return valid;
}
G4int G4NuclearLevelManager::NumberOfLevels() const
{
G4int n = 0;
if (_levels != 0) n = _levels->entries();
return n;
}
const G4PtrLevelVector* G4NuclearLevelManager::GetLevels() const
{
return _levels;
}
const G4NuclearLevel* G4NuclearLevelManager::NearestLevel(G4double energy, G4double eDiffMax) const
{
G4int iNear = -1;
G4double diff = 9999. * GeV;
if (_levels != 0)
{
G4int i = 0;
for (i=0; i<_levels->entries(); i++)
{
G4double e = _levels->at(i)->Energy();
G4double eDiff = abs(e - energy);
if (eDiff < diff && eDiff <= eDiffMax)
{
diff = eDiff;
iNear = i;
}
}
}
if (_levels != 0 && iNear >= 0 && iNear < _levels->entries())
{ return _levels->at(iNear); }
else
{ return 0; }
}
G4double G4NuclearLevelManager::MinLevelEnergy() const
{
G4double eMin = 9999.*GeV;
if (_levels != 0)
{
if (_levels->entries() > 0) eMin = _levels->first()->Energy();
}
return eMin;
}
G4double G4NuclearLevelManager::MaxLevelEnergy() const
{
G4double eMax = 0.;
if (_levels != 0)
{
if (_levels->entries() > 0) eMax = _levels->last()->Energy();
}
return eMax;
}
const G4NuclearLevel* G4NuclearLevelManager::HighestLevel() const
{
if (_levels!= 0 && _levels->entries() > 0) return _levels->first();
else return 0;
}
const G4NuclearLevel* G4NuclearLevelManager::LowestLevel() const
{
if (_levels != 0 && _levels->entries() > 0) return _levels->last();
else return 0;
}
G4bool G4NuclearLevelManager::Read(ifstream& dataFile)
{
const G4double minProbability = 0.001;
G4bool result = true;
if (dataFile >> _levelEnergy)
{
dataFile >> _gammaEnergy >> _probability;
_levelEnergy *= keV;
_gammaEnergy *= keV;
// The following adjustment is needed to take care of anomalies in
// data files, where some transitions show up with relative probability
// zero
if (_probability < minProbability) _probability = minProbability;
// G4cout << "Read " << _levelEnergy << " " << _gammaEnergy << " " << _probability << endl;
}
else
{
result = false;
}
return result;
}
void G4NuclearLevelManager::MakeLevels()
{
G4String dirName = getenv("G4LEVELGAMMADATA");
char name[100] = {""};
ostrstream ost(name, 100, ios::out);
ost << dirName << "/" << "z" << _Z << ".a" << _A;
G4String file(name);
ifstream inFile(file, ios::in);
if (! inFile)
{
// G4cout << " G4NuclearLevelManager: (" << _Z << "," << _A
// << ") does not have LevelsAndGammas file" << endl;
return;
}
if (_levels != 0)
{
if (_levels->entries()>0) _levels->clearAndDestroy();
delete _levels;
}
_levels = new G4PtrLevelVector;
G4DataVector eLevel;
G4DataVector eGamma;
G4DataVector wGamma;
while (Read(inFile))
{
eLevel.insert(_levelEnergy);
eGamma.insert(_gammaEnergy);
wGamma.insert(_probability);
}
// ---- MGP ---- Don't forget to close the file
inFile.close();
G4int nData = eLevel.entries();
// G4cout << " ==== MakeLevels ===== " << nData << " data read " << endl;
G4double thisLevelEnergy = eLevel.at(0);
G4DataVector thisLevelEnergies;
G4DataVector thisLevelWeights;
G4double e = -1.;
G4int i;
for (i=0; i<nData; i++)
{
e = eLevel.at(i);
if (e != thisLevelEnergy)
{
// G4cout << "Making a new level... " << e << " "
// << thisLevelEnergies.entries() << " "
// << thisLevelWeights.entries() << endl;
G4NuclearLevel* newLevel = new G4NuclearLevel(thisLevelEnergy,thisLevelEnergies,thisLevelWeights);
_levels->insert(newLevel);
// Reset data vectors
thisLevelEnergies.clear();
thisLevelWeights.clear();
thisLevelEnergy = e;
}
// Append current data
thisLevelEnergies.insert(eGamma.at(i));
thisLevelWeights.insert(wGamma.at(i));
}
// Make last level
if (e > 0.)
{
G4NuclearLevel* newLevel = new G4NuclearLevel(e,thisLevelEnergies,thisLevelWeights);
_levels->insert(newLevel);
}
return;
}
void G4NuclearLevelManager::PrintAll()
{
G4int nLevels = 0;
if (_levels != 0) nLevels = _levels->entries();
G4cout << " ==== G4NuclearLevelManager ==== (" << _Z << ", " << _A << ") has "
<< nLevels << " levels" << endl
<< "Highest level is at energy " << MaxLevelEnergy() << " MeV " << endl
<< "Lowest level is at energy " << MinLevelEnergy() << " MeV " << endl;
G4int i = 0;
for (i=0; i<nLevels; i++)
{ _levels->at(i)->PrintAll(); }
}
G4NuclearLevelManager::G4NuclearLevelManager(const G4NuclearLevelManager &right)
{
_levelEnergy = right._levelEnergy;
_gammaEnergy = right._gammaEnergy;
_probability = right._probability;
_A = right._A;
_Z = right._Z;
if (right._levels != 0)
{
_levels = new G4PtrLevelVector;
G4int n = right._levels->entries();
G4int i;
for (i=0; i<n; i++)
{
_levels->insert(new G4NuclearLevel(*(right._levels->at(i))));
}
}
else
{
_levels = 0;
}
}

Some files were not shown because too many files have changed in this diff Show More