Import Geant4 0.0.0 source tree

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundAlpha.hh

@@ -0,0 +1,79 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+//
+// by V. Lara 
+
+#ifndef G4PreCompoundAlpha_h
+#define G4PreCompoundAlpha_h 1
+
+#include "G4VPreCompoundIon.hh"
+#include "G4Alpha.hh"
+
+
+class G4PreCompoundAlpha : public G4VPreCompoundIon
+{
+public:
+  // default constructor
+  G4PreCompoundAlpha():G4VPreCompoundIon(4,2) {};
+
+  // copy constructor
+  G4PreCompoundAlpha(const G4PreCompoundAlpha &right):
+    G4VPreCompoundIon(right) {};
+
+  ~G4PreCompoundAlpha() {};
+
+  // operators  
+  const G4PreCompoundAlpha & operator=(const G4PreCompoundAlpha &right) {
+    if (&right != this) this->G4VPreCompoundIon::operator=(right);
+    return *this;
+  };
+
+  G4bool operator==(const G4PreCompoundAlpha &right) const
+  {return G4VPreCompoundIon::operator==(right);};
+  
+  G4bool operator!=(const G4PreCompoundAlpha &right) const
+  {return G4VPreCompoundIon::operator!=(right);};
+
+  const G4DynamicParticle GetDynamicParticle() const
+    {
+      G4DynamicParticle theDynamicParticle(G4Alpha::AlphaDefinition(),GetMomentum());
+      return theDynamicParticle;
+    }
+
+public:
+  void CalcExcitonLevelDensityRatios(const G4double Excitons,
+			             const G4double Particles)
+  {
+    // Level density ratios are calculated according to the formula
+    // (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
+    // where  P is number of particles
+    //        N is number of excitons
+    //        Af atomic number of emitting fragment
+    // the next is a simplification for alphas (Af = 4)
+    
+     SetExcitonLevelDensityRatio((Particles*(Excitons-1.0))*
+				 ((Particles-1.0)*(Excitons-2.0)/2.0)*
+				 ((Particles-2.0)*(Excitons-3.0)/6.0)*
+				 ((Particles-3.0)*(Excitons-4.0)/12.0));
+  }
+
+
+
+  void CalcCondensationProbability(const G4double A)
+    // This method computes condensation probability to create a fragment
+    // consisting from N nucleons inside a nucleus with A nucleons 
+    // This value comes from the formula N^3 (N/A)^(N-1) with N = 4 (alpha)
+  {
+    SetCondensationProbability(4096.0/(A*A*A));
+  }
+
+
+};
+
+#endif
+ 

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundDeuteron.hh

@@ -0,0 +1,76 @@
+// 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.
+//
+//
+// by V. Lara 
+
+#ifndef G4PreCompoundDeuteron_h
+#define G4PreCompoundDeuteron_h 1
+
+#include "G4VPreCompoundIon.hh"
+#include "G4Deuteron.hh"
+
+class G4PreCompoundDeuteron : public G4VPreCompoundIon
+{
+public:
+  // default constructor
+  G4PreCompoundDeuteron():G4VPreCompoundIon(2,1) {};
+
+  // copy constructor
+  G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right):
+    G4VPreCompoundIon(right) {};
+
+  ~G4PreCompoundDeuteron() {};
+
+  // operators  
+  const G4PreCompoundDeuteron & operator=(const G4PreCompoundDeuteron &right) {
+    if (&right != this) this->G4VPreCompoundIon::operator=(right);
+    return *this;
+  };
+
+  G4bool operator==(const G4PreCompoundDeuteron &right) const
+  {return G4VPreCompoundIon::operator==(right);};
+  
+  G4bool operator!=(const G4PreCompoundDeuteron &right) const
+  {return G4VPreCompoundIon::operator!=(right);};
+
+  const G4DynamicParticle GetDynamicParticle() const
+    {
+      G4DynamicParticle theDynamicParticle(G4Deuteron::DeuteronDefinition(),GetMomentum());
+      return theDynamicParticle;
+    }
+
+
+public:
+  void CalcExcitonLevelDensityRatios(const G4double Excitons,
+			             const G4double Particles)
+   {
+    // Level density ratios are calculated according to the formula
+    // (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
+    // where  P is number of particles
+    //        N is number of excitons
+    //        Af atomic number of emitting fragment
+    // the next is a simplification for deuterons (Af = 2)
+
+     SetExcitonLevelDensityRatio(Particles*(Excitons-1.0)*
+				(Particles-1.0)*(Excitons-2.0)/2.0);
+   }
+
+
+  void CalcCondensationProbability(const G4double A)
+    // This method computes condensation probability to create a fragment
+    // consisting from N nucleons inside a nucleus with A nucleons 
+    // This value comes from the formula N^3 (N/A)^(N-1) with N = 2 (deuteron)
+  {
+    SetCondensationProbability(16.0/A);
+  }
+
+
+};
+
+#endif
+ 

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundHe3.hh

@@ -0,0 +1,81 @@
+// 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.
+//
+//
+// by V. Lara 
+
+
+#ifndef G4PreCompoundHe3_h
+#define G4PreCompoundHe3_h 1
+
+#include "G4VPreCompoundIon.hh"
+#include "G4He3.hh"
+
+class G4PreCompoundHe3 : public G4VPreCompoundIon
+{
+public:
+  // default constructor
+  G4PreCompoundHe3():G4VPreCompoundIon(3,2) {};
+
+  // copy constructor
+  G4PreCompoundHe3(const G4PreCompoundHe3 &right):
+    G4VPreCompoundIon(right) {};
+
+  ~G4PreCompoundHe3() {};
+
+  // operators  
+  const G4PreCompoundHe3 & operator=(const G4PreCompoundHe3 &right) {
+    if (&right != this) this->G4VPreCompoundIon::operator=(right);
+    return *this;
+  };
+
+  G4bool operator==(const G4PreCompoundHe3 &right) const
+  {return G4VPreCompoundIon::operator==(right);};
+  
+  G4bool operator!=(const G4PreCompoundHe3 &right) const
+  {return G4VPreCompoundIon::operator!=(right);};
+
+
+  const G4DynamicParticle GetDynamicParticle() const
+    {
+      G4DynamicParticle theDynamicParticle(G4He3::He3Definition(),GetMomentum());
+      return theDynamicParticle;
+    }
+
+
+
+public:
+  void CalcExcitonLevelDensityRatios(const G4double Excitons,
+			             const G4double Particles)
+  {
+    // Level density ratios are calculated according to the formula
+    // (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
+    // where  P is number of particles
+    //        N is number of excitons
+    //        Af atomic number of emitting fragment
+    // the next is a simplification for He3 (Af = 3)
+
+    SetExcitonLevelDensityRatio((Particles*(Excitons-1.0))*
+				((Particles-1.0)*(Excitons-2.0)/2.0)*
+				((Particles-2.0)*(Excitons-3.0)/6.0));  
+  }
+  
+
+
+  void CalcCondensationProbability(const G4double A)
+    // This method computes condensation probability to create a fragment
+    // consisting from N nucleons inside a nucleus with A nucleons 
+    // This value comes from the formula N^3 (N/A)^(N-1) with N = 3 (He3)
+  {
+    SetCondensationProbability(243.0/(A*A));
+  }
+
+
+};
+
+#endif
+ 

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundModel.hh

@@ -0,0 +1,89 @@
+// 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: G4PreCompoundModel.hh,v 1.5 1998/12/12 12:32:22 larazb Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+// by V. Lara
+
+#ifndef G4PreCompoundModel_h
+#define G4PreCompoundModel_h 1
+
+#include "G4VPreCompoundModel.hh"
+#include "G4PreCompoundNeutron.hh"
+#include "G4PreCompoundProton.hh"
+#include "G4PreCompoundDeuteron.hh"
+#include "G4PreCompoundTriton.hh"
+#include "G4PreCompoundHe3.hh"
+#include "G4PreCompoundAlpha.hh"
+#include "G4PreCompoundTransitions.hh"
+#include "G4LorentzVector.hh"
+
+#include "G4NucleiProperties.hh"
+#include "G4Proton.hh"
+#include "G4VPreCompoundFragment.hh"
+#include "G4PreCompoundParameters.hh"
+#include "G4ExcitationHandler.hh"
+#include "Randomize.hh"
+
+
+
+class G4Fragment;
+
+
+
+class G4PreCompoundModel : public G4VPreCompoundModel
+{
+public:
+  
+  G4PreCompoundModel(G4ExcitationHandler * const value);
+
+  ~G4PreCompoundModel();
+
+private:
+  G4PreCompoundModel() {};
+  
+  G4PreCompoundModel(const G4PreCompoundModel &right) {};
+  
+  const G4PreCompoundModel& operator=(const G4PreCompoundModel &right);
+
+  G4bool operator==(const G4PreCompoundModel &right) const;
+  
+  G4bool operator!=(const G4PreCompoundModel &right) const;
+
+public:
+  G4VParticleChange * ApplyYourself(const G4Track & thePrimary, G4Nucleus & theNucleus);
+  
+  G4DynamicParticleVector* DeExcite(const G4Fragment& aFragment) const;
+
+private:  
+
+  
+  G4ParticleChange theResult;
+  
+  
+  
+  //  static const G4int NumberOfPossibleFragments = 6;
+  enum {NumberOfPossibleFragments = 6};
+  
+  // The possible emitted fragments 
+  RWTPtrOrderedVector<G4VPreCompoundFragment> theChannels;
+
+
+
+  G4ThreeVector IsotropicRandom3Vetor(G4double Magnitude = 1.0) const;
+
+
+  void PerformEquilibriumEmission(const G4Fragment & aFragment, 
+				  G4DynamicParticleVector * theResult) const;
+
+};
+
+
+#endif
+
+

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundNeutron.hh

@@ -0,0 +1,65 @@
+// 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.
+//
+//
+// by V. Lara
+
+
+#ifndef G4PreCompoundNeutron_h
+#define G4PreCompoundNeutron_h 1
+
+#include "G4VPreCompoundNucleon.hh"
+#include "G4DynamicParticle.hh"
+#include "G4Neutron.hh"
+#include "G4PreCompoundParameters.hh"
+#include "Randomize.hh"
+
+
+
+class G4PreCompoundNeutron : public G4VPreCompoundNucleon
+{
+public:
+  // default constructor
+  G4PreCompoundNeutron() : G4VPreCompoundNucleon(1,0) {};
+
+  // copy constructor
+  G4PreCompoundNeutron(const G4PreCompoundNeutron &right):
+    G4VPreCompoundNucleon(right) {};
+
+  ~G4PreCompoundNeutron() {};
+
+  // operators  
+  const G4PreCompoundNeutron & operator=(const G4PreCompoundNeutron &right) {
+    if (&right != this) this->G4VPreCompoundNucleon::operator=(right);
+    return *this;
+  };
+
+  G4bool operator==(const G4PreCompoundNeutron &right) const
+  {return G4VPreCompoundNucleon::operator==(right);};
+  
+  G4bool operator!=(const G4PreCompoundNeutron &right) const
+  {return G4VPreCompoundNucleon::operator!=(right);};
+
+
+  const G4DynamicParticle GetDynamicParticle() const
+    {
+      G4DynamicParticle theDynamicParticle(G4Neutron::NeutronDefinition(),GetMomentum());
+      return theDynamicParticle;
+    }
+
+
+
+public:
+  G4double ProbabilityDistributionFunction(const G4double & eKin,
+					   const G4Fragment & aFragment);
+  // Gives the kinetic energy for fragments in pre-equilibrium decay
+  G4double GetKineticEnergy(const G4Fragment & aFragment);
+
+};
+
+#endif
+ 

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundParameters.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.
+//
+//
+// by V. Lara
+
+
+#ifndef G4PreCompoundParameters_h
+#define G4PreCompoundParameters_h 1
+
+#include "globals.hh"
+
+class G4PreCompoundParameters
+{
+private:
+  static G4PreCompoundParameters  thePreCompoundParameters;
+
+  // Level density parameter
+  const G4double theLevelDensity;
+
+
+  // default constructor
+  G4PreCompoundParameters() : theLevelDensity(0.125) {}
+  //  G4PreCompoundParameters(G4int Dummy) {G4int i = Dummy;}
+
+public:
+
+  ~G4PreCompoundParameters() {};
+
+  static G4PreCompoundParameters * GetAddress();
+
+  G4double GetLevelDensity()
+  { return theLevelDensity; }
+  
+};
+
+#endif

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundProton.hh

@@ -0,0 +1,64 @@
+// 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.
+//
+//
+// by V. Lara
+
+#ifndef G4PreCompoundProton_h
+#define G4PreCompoundProton_h 1
+
+#include "G4VPreCompoundNucleon.hh"
+#include "G4DynamicParticle.hh"
+#include "G4Proton.hh"
+#include "G4PreCompoundParameters.hh"
+#include "Randomize.hh"
+
+
+class G4PreCompoundProton : public G4VPreCompoundNucleon
+{
+public:
+  // default constructor
+  G4PreCompoundProton():G4VPreCompoundNucleon(1,1) {};
+
+  // copy constructor
+  G4PreCompoundProton(const G4PreCompoundProton &right):
+    G4VPreCompoundNucleon(right) {};
+
+  ~G4PreCompoundProton() {};
+
+  // operators  
+  const G4PreCompoundProton & operator=(const G4PreCompoundProton &right) {
+    if (&right != this) this->G4VPreCompoundNucleon::operator=(right);
+    return *this;
+  };
+
+  G4bool operator==(const G4PreCompoundProton &right) const
+  {return G4VPreCompoundNucleon::operator==(right);};
+
+  
+  G4bool operator!=(const G4PreCompoundProton &right) const
+  {return G4VPreCompoundNucleon::operator!=(right);};
+
+
+  const G4DynamicParticle GetDynamicParticle() const
+    {
+      G4DynamicParticle theDynamicParticle(G4Proton::ProtonDefinition(),GetMomentum());
+      return theDynamicParticle;
+    }
+
+
+public:
+  G4double ProbabilityDistributionFunction(const G4double & eKin,
+					   const G4Fragment & aFragment);
+
+  // Gives the kinetic energy for fragments in pre-equilibrium decay
+  G4double GetKineticEnergy(const G4Fragment & aFragment);
+
+};
+
+#endif
+ 

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundTransitions.hh

@@ -0,0 +1,63 @@
+// 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.
+//
+//
+// by V. Lara
+
+#ifndef G4PreCompoundTransitions_h
+#define G4PreCompoundTransitions_h 1
+
+// Compute transition probailities:
+// TransitionProb1 => probability of transition with  \Delta N = +2
+//                    number of excitons will be increased on 2
+// TransitionProb2 => probability of transition with  \Delta N = -2
+//                    number of excitons will be decreased on 2
+// TransitionProb3 => probability of transition with  \Delta N = 0
+//                    number of excitons will be the same
+
+#include "globals.hh"
+#include "G4Fragment.hh"
+#include "G4PreCompoundParameters.hh"
+#include "G4Proton.hh"
+#include "Randomize.hh"
+
+class G4PreCompoundTransitions
+{
+public:
+
+  // Calculates transition probabilities with Delta N = +2 (Trans1) -2 (Trans2) and 0 (Trans3)
+  G4PreCompoundTransitions(const G4Fragment & aFragment);
+
+  ~G4PreCompoundTransitions() {};
+
+private:
+  G4PreCompoundTransitions() {};
+  
+  G4PreCompoundTransitions(const G4PreCompoundTransitions &right) {};
+  
+  const G4PreCompoundTransitions& operator=(const G4PreCompoundTransitions &right);
+
+  G4bool operator==(const G4PreCompoundTransitions &right) const;
+  
+  G4bool operator!=(const G4PreCompoundTransitions &right) const;
+
+
+public:
+  G4double GetTotalProbability()
+  { return TransitionProb1+TransitionProb2+TransitionProb3; }
+  
+  G4int GetDeltaNExciton();
+  
+private:
+	
+  G4double TransitionProb1;
+  G4double TransitionProb2;
+  G4double TransitionProb3;
+
+};
+
+#endif

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundTriton.hh

@@ -0,0 +1,80 @@
+// 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.
+//
+//
+// by V. Lara
+
+#ifndef G4PreCompoundTriton_h
+#define G4PreCompoundTriton_h 1
+
+#include "G4VPreCompoundIon.hh"
+#include "G4Triton.hh"
+
+class G4PreCompoundTriton : public G4VPreCompoundIon
+{
+public:
+  // default constructor
+  G4PreCompoundTriton():G4VPreCompoundIon(3,1) {};
+
+  // copy constructor
+  G4PreCompoundTriton(const G4PreCompoundTriton &right):
+    G4VPreCompoundIon(right) {};
+
+  ~G4PreCompoundTriton() {};
+
+  // operators  
+  const G4PreCompoundTriton & operator=(const G4PreCompoundTriton &right) {
+    if (&right != this) this->G4VPreCompoundIon::operator=(right);
+    return *this;
+  };
+
+  G4bool operator==(const G4PreCompoundTriton &right) const
+  {return G4VPreCompoundIon::operator==(right);};
+
+  
+  G4bool operator!=(const G4PreCompoundTriton &right) const
+  {return G4VPreCompoundIon::operator!=(right);};
+
+  const G4DynamicParticle GetDynamicParticle() const
+    {
+      G4DynamicParticle theDynamicParticle(G4Triton::TritonDefinition(),GetMomentum());
+      return theDynamicParticle;
+    }
+
+
+
+
+public:
+  void CalcExcitonLevelDensityRatios(const G4double Excitons,
+			             const G4double Particles)
+   {
+     // Level density ratios are calculated according to the formula
+     // (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
+     // where  P is number of particles
+     //        N is number of excitons
+     //        Af atomic number of emitting fragment
+     // the next is a simplification for tritons (Af = 3)
+
+     SetExcitonLevelDensityRatio((Particles*(Excitons-1.0))*
+				 ((Particles-1.0)*(Excitons-2.0)/2.0)*
+				 ((Particles-2.0)*(Excitons-3.0)/6.0));
+   }
+
+
+  void CalcCondensationProbability(const G4double A)
+    // This method computes condensation probability to create a fragment
+    // consisting from N nucleons inside a nucleus with A nucleons 
+    // This value comes from the formula N^3 (N/A)^(N-1) with N = 3 (triton)
+  {
+    SetCondensationProbability(243.0/(A*A));
+  }
+
+
+};
+
+#endif
+ 

source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundFragment.hh

@@ -0,0 +1,276 @@
+// 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.
+//
+//
+// by V. Lara
+
+#ifndef G4VPreCompoundFragment_h
+#define G4VPreCompoundFragment_h 1
+
+#include "G4ios.hh"
+#include <iomanip.h>
+#include "G4ParticleDefinition.hh"
+#include "G4ParticleTable.hh"
+#include "G4IonTable.hh"
+//#include "G4DynamicParticle.hh"
+
+#include "G4Fragment.hh"
+
+class G4DynamicParticle;
+
+class G4VPreCompoundFragment
+{
+protected:
+  // default constructor
+  G4VPreCompoundFragment() {};
+
+public:  
+  // copy constructor
+  G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
+
+  // constructor  
+  G4VPreCompoundFragment(const G4double anA, const G4double aZ);
+
+  virtual ~G4VPreCompoundFragment();
+
+  // operators  
+  const G4VPreCompoundFragment& operator=(const G4VPreCompoundFragment &right);
+
+  G4int operator==(const G4VPreCompoundFragment &right) const;
+  
+  G4int operator!=(const G4VPreCompoundFragment &right) const;
+
+  friend ostream& operator<<(ostream&, const G4VPreCompoundFragment*);
+  friend ostream& operator<<(ostream&, const G4VPreCompoundFragment&);
+
+
+  // methods
+
+  void Init(const G4Fragment & aFragment);
+  
+  virtual void CalcExcitonLevelDensityRatios(const G4double Excitons,
+			                     const G4double Particles) = 0;
+  
+  virtual G4double GetKineticEnergy(const G4Fragment & aFragment) = 0;
+
+  // Calculates condensation probabilities to create fragment consisting from Nf nucleons 
+  // inside a nucleus with A nucleons
+  virtual void CalcCondensationProbability(const G4double A) = 0;
+
+  // Calculates the total (integrated over kinetic energy) emission
+  // probability of a fragment
+  G4double CalcEmissionProbability(const G4Fragment & aFragment);
+
+  void SetA(const G4double value);
+  const G4double GetA() const;
+
+  void SetZ(const G4double value);
+  const G4double GetZ() const;
+  
+
+  void SetRestA(const G4double value);
+  const G4double GetRestA() const;
+
+  void SetRestZ(const G4double value);
+  const G4double GetRestZ() const;
+  
+
+  void SetCoulombBarrier(const G4double value);
+  const G4double GetCoulombBarrier() const;
+
+  void SetBindingEnergy(const G4double value);
+  const G4double GetBindingEnergy() const;
+
+  void SetMaximalKineticEnergy(const G4double value);
+  const G4double GetMaximalKineticEnergy() const;
+
+  void SetExcitonLevelDensityRatio(const G4double value);
+  const G4double GetExcitonLevelDensityRatio() const;
+
+  void SetEmissionProbability(const G4double value);
+  const G4double GetEmissionProbability() const;
+
+  void SetCondensationProbability(const G4double value);
+  const G4double GetCondensationProbability() const;
+
+
+  const G4double GetNuclearMass() const;
+  const G4double GetRestNuclearMass() const;
+
+protected:
+  virtual G4double ProbabilityDistributionFunction(const G4double & K,
+					   const G4Fragment & aFragment) = 0;
+private:
+  G4double CalcCoulombBarrier(const G4double & NucRad);
+  
+   // This method performs integration for probability function over 
+   // fragment kinetic energy
+  G4double IntegrateEmissionProbability(const G4double & Low, const G4double & Up, 
+  					const G4Fragment & aFragment);
+
+public:
+  void SetMomentum(const G4LorentzVector value);
+  const G4LorentzVector GetMomentum() const;
+
+  virtual const G4DynamicParticle GetDynamicParticle() const = 0; 
+
+private:
+
+  G4double theA;
+
+  G4double theZ;
+
+  G4double theRestNucleusA;
+
+  G4double theRestNucleusZ;
+
+  G4double CoulombBarrier;
+
+  G4double BindingEnergy;
+
+  G4double MaximalKineticEnergy;
+
+  G4double ExcitonLevelDensityRatio;
+
+  G4double EmissionProbability;
+
+  G4double CondensationProbability;
+
+  G4LorentzVector Momentum;
+
+};
+
+
+inline void G4VPreCompoundFragment::SetA(const G4double value)
+{
+  theA = value;
+}
+
+inline const G4double G4VPreCompoundFragment::GetA() const
+{
+  return theA;
+}
+
+inline void G4VPreCompoundFragment::SetZ(const G4double value)
+{
+  theZ = value;
+}
+
+inline const G4double G4VPreCompoundFragment::GetZ() const
+{
+  return theZ;
+}
+
+inline void G4VPreCompoundFragment::SetRestA(const G4double value)
+{
+  theRestNucleusA = value - theA;
+}
+
+inline const G4double G4VPreCompoundFragment::GetRestA() const
+{
+  return theRestNucleusA;
+}
+
+inline void G4VPreCompoundFragment::SetRestZ(const G4double value)
+{
+  theRestNucleusZ = value - theZ;
+}
+
+inline const G4double G4VPreCompoundFragment::GetRestZ() const
+{
+  return theRestNucleusZ;
+}
+
+inline void G4VPreCompoundFragment::SetCoulombBarrier(const G4double value)
+{
+  CoulombBarrier = value;
+}
+
+inline const G4double G4VPreCompoundFragment::GetCoulombBarrier() const
+{
+  return CoulombBarrier;
+}
+
+inline void G4VPreCompoundFragment::SetBindingEnergy(const G4double value)
+{
+  BindingEnergy = value;
+}
+
+inline const G4double G4VPreCompoundFragment::GetBindingEnergy() const
+{
+  return BindingEnergy;
+}
+
+
+inline void G4VPreCompoundFragment::SetMaximalKineticEnergy(const G4double value)
+{
+  MaximalKineticEnergy = value;
+}
+
+inline const G4double G4VPreCompoundFragment::GetMaximalKineticEnergy() const
+{
+  return MaximalKineticEnergy;
+}
+
+inline void G4VPreCompoundFragment::SetExcitonLevelDensityRatio(const G4double value)
+{
+  ExcitonLevelDensityRatio = value;
+}
+
+inline const G4double G4VPreCompoundFragment::GetExcitonLevelDensityRatio() const
+{
+  return ExcitonLevelDensityRatio;
+}
+
+
+inline void G4VPreCompoundFragment::SetEmissionProbability(const G4double value)
+{
+  EmissionProbability = value;
+}
+
+inline const G4double G4VPreCompoundFragment::GetEmissionProbability() const
+{
+  return EmissionProbability;
+}
+
+inline void G4VPreCompoundFragment::SetCondensationProbability(const G4double value)
+{
+  CondensationProbability = value;
+}
+
+inline const G4double G4VPreCompoundFragment::GetCondensationProbability() const
+{
+  return CondensationProbability;
+}
+
+
+inline const G4double G4VPreCompoundFragment::GetNuclearMass() const
+  // Calculate nucleus atomic mass (MeV)
+{
+  return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theZ,theA)/MeV;
+}
+
+inline const G4double G4VPreCompoundFragment::GetRestNuclearMass() const
+  // Calculate nucleus atomic mass (MeV)
+{
+  return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(theRestNucleusZ,theRestNucleusA)/MeV;
+}
+
+
+inline void G4VPreCompoundFragment::SetMomentum(const G4LorentzVector value)
+{
+  Momentum = value;
+}
+
+inline const G4LorentzVector G4VPreCompoundFragment::GetMomentum() const
+{
+  return Momentum;
+}
+
+
+
+#endif

source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundIon.hh

@@ -0,0 +1,65 @@
+// 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.
+//
+//
+// by V. Lara
+
+
+#ifndef G4PreCompoundIon_h
+#define G4PreCompoundIon_h 1
+
+
+#include "G4VPreCompoundFragment.hh"
+#include "G4PreCompoundParameters.hh"
+#include "Randomize.hh"
+
+
+class G4VPreCompoundIon : public G4VPreCompoundFragment
+{
+protected:
+  // default constructor
+  G4VPreCompoundIon() {};
+
+public:
+
+  // copy constructor
+  G4VPreCompoundIon(const G4VPreCompoundIon &right):
+    G4VPreCompoundFragment(right) {};
+
+  // constructor  
+  G4VPreCompoundIon(const G4double anA, const G4double aZ):
+    G4VPreCompoundFragment(anA,aZ) {};
+
+  virtual ~G4VPreCompoundIon() {};
+
+  // operators  
+  const G4VPreCompoundIon & operator=(const G4VPreCompoundIon &right) {
+    if (&right != this) this->G4VPreCompoundFragment::operator=(right);
+    return *this;
+  };
+
+
+  G4bool operator==(const G4VPreCompoundIon &right) const
+  {return G4VPreCompoundFragment::operator==(right);};
+
+  G4bool operator!=(const G4VPreCompoundIon &right) const
+  {return G4VPreCompoundFragment::operator!=(right);};
+
+
+
+public:
+  G4double ProbabilityDistributionFunction(const G4double & eKin,
+					   const G4Fragment & aFragment);
+
+  // Gives the kinetic energy for fragments in pre-equilibrium decay
+  G4double GetKineticEnergy(const G4Fragment & aFragment);
+
+
+};
+
+#endif
+ 

source/processes/hadronic/models/generator/pre_equilibrium/include/G4VPreCompoundNucleon.hh

@@ -0,0 +1,72 @@
+// 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.
+//
+//
+// by V. Lara
+
+#ifndef G4VPreCompoundNucleon_h
+#define G4VPreCompoundNucleon_h 1
+
+#include "G4VPreCompoundFragment.hh"
+
+
+class G4VPreCompoundNucleon : public G4VPreCompoundFragment
+{
+protected:
+  // copy constructor
+  G4VPreCompoundNucleon() {};
+
+public:
+
+  // copy constructor
+  G4VPreCompoundNucleon(const G4VPreCompoundNucleon &right):
+    G4VPreCompoundFragment(right) {};
+
+  // constructor  
+  G4VPreCompoundNucleon(const G4double anA, const G4double aZ):
+    G4VPreCompoundFragment(anA,aZ) {};
+
+  virtual ~G4VPreCompoundNucleon() {};
+
+  // operators  
+  const G4VPreCompoundNucleon & operator=(const G4VPreCompoundNucleon &right) {
+    if (&right != this) this->G4VPreCompoundFragment::operator=(right);
+    return *this;
+  };
+
+  G4bool operator==(const G4VPreCompoundNucleon &right) const 
+  {return G4VPreCompoundFragment::operator==(right); };
+  
+  G4bool operator!=(const G4VPreCompoundNucleon &right) const 
+  {return G4VPreCompoundFragment::operator!=(right); };
+
+
+  void CalcExcitonLevelDensityRatios(const G4double Excitons, 
+				     const G4double Particles)
+  {
+    // Level density ratios are calculated according to the formula
+    // (P!*(N-1)!)/((P-Af)!*(N-1-Af)!*Af!)
+    // where  P is number of particles
+    //        N is number of excitons
+    //        Af atomic number of emitting fragment
+    // the next is a simplification for nucleons (Af = 1)
+
+    SetExcitonLevelDensityRatio(Particles*(Excitons-1.0));
+  }
+   
+  void CalcCondensationProbability(const G4double A)
+    // This method computes condensation probability to create a fragment
+    // consisting from N nucleons inside a nucleus with A nucleons 
+    // This value comes from the formula N^3 (N/A)^(N-1) with N = 1 (nucleon)
+  {
+    SetCondensationProbability(1.0);
+  }
+
+};
+
+#endif
+