Import Geant4 0.0.0 source tree

source/processes/hadronic/models/generator/de_excitation/include/G4B9FermiFragment.hh

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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