Import Geant4 5.2.0 source tree

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

@@ -0,0 +1,54 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4GNASHTransitions_hh
+#define G4GNASHTransitions_hh 1
+
+#include "G4VPreCompoundTransitions.hh"
+#include "G4Fragment.hh"
+
+class G4GNASHTransitions : public G4VPreCompoundTransitions
+{
+public:
+  G4GNASHTransitions() {}
+  virtual ~G4GNASHTransitions() {}
+
+private:
+
+  G4GNASHTransitions(const G4GNASHTransitions &) : G4VPreCompoundTransitions() {}
+
+  const G4GNASHTransitions& operator=(const G4GNASHTransitions &right);
+
+  G4bool operator==(const G4GNASHTransitions &right) const;
+
+  G4bool operator!=(const G4GNASHTransitions &right) const;
+
+public:
+
+  virtual G4double CalculateProbability(const G4Fragment & aFragment);
+  
+  virtual G4Fragment PerformTransition(const G4Fragment & aFragment);
+
+
+};
+
+#endif

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

@@ -0,0 +1,124 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4HETCAlpha_h
+#define G4HETCAlpha_h 1
+
+#include "G4HETCChargedFragment.hh"
+#include "G4ReactionProduct.hh"
+#include "G4Alpha.hh"
+
+#include "G4AlphaCoulombBarrier.hh"
+
+
+class G4HETCAlpha : public G4HETCChargedFragment
+{
+public:
+  // default constructor
+  G4HETCAlpha():G4HETCChargedFragment(4,2,&theAlphaCoulombBarrier,"Alpha") {}
+
+  // copy constructor
+  G4HETCAlpha(const G4HETCAlpha &right): G4HETCChargedFragment(right) {}
+
+  // destructor
+  ~G4HETCAlpha() {}
+
+  // operators  
+  const G4HETCAlpha & operator=(const G4HETCAlpha &right) 
+  {
+    if (&right != this) this->G4HETCChargedFragment::operator=(right);
+    return *this;
+  };
+  
+  G4bool operator==(const G4HETCAlpha &right) const
+  { 
+    return G4HETCChargedFragment::operator==(right);
+  }
+
+  
+  G4bool operator!=(const G4HETCAlpha &right) const
+  { 
+    return G4HETCChargedFragment::operator!=(right);
+  }
+
+
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct =
+      new G4ReactionProduct(G4Alpha::AlphaDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
+#ifdef PRECOMPOUND_TEST
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+#endif
+    return theReactionProduct;
+  }   
+    
+private:
+  virtual G4double GetAlpha()
+  {
+    G4double C = 0.0;
+    G4double aZ = GetZ() + GetRestZ();
+    if (aZ <= 30) 
+      {
+	C = 0.10;
+      } 
+    else if (aZ <= 50) 
+      {
+	C = 0.1 + -((aZ-50.)/20.)*0.02;
+      }
+    else if (aZ < 70) 
+      {
+	C = 0.08 + -((aZ-70.)/20.)*0.02;
+      }
+    else 
+      {
+	C = 0.06;
+      }
+    return 1.0+C;
+  }
+  
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
+  
+
+  virtual G4double GetSpinFactor()
+  {
+    return 1.0;
+  }
+
+  virtual G4double K(const G4Fragment & aFragment);
+
+
+private:
+
+  G4AlphaCoulombBarrier theAlphaCoulombBarrier;
+
+};
+
+#endif
+ 
+

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

@@ -0,0 +1,77 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4HETCChargedFragment_h
+#define G4HETCChargedFragment_h 1
+
+#include "G4HETCFragment.hh"
+#include "G4VCoulombBarrier.hh"
+
+
+class G4HETCChargedFragment : public G4HETCFragment
+{
+protected:
+  // default constructor
+  G4HETCChargedFragment() {}
+
+public:
+
+  // copy constructor
+  G4HETCChargedFragment(const G4HETCChargedFragment &right): 
+    G4HETCFragment(right) {}
+
+  // constructor  
+  G4HETCChargedFragment(const G4double anA, 
+			const G4double aZ, 
+			G4VCoulombBarrier* aCoulombBarrier,
+			const G4String & aName): 
+    G4HETCFragment(anA,aZ,aCoulombBarrier,aName) {}
+
+  virtual ~G4HETCChargedFragment() {}
+
+  // operators  
+  const G4HETCChargedFragment & 
+  operator=(const G4HETCChargedFragment &right) 
+  {
+    if (&right != this) this->G4HETCFragment::operator=(right);
+    return *this;
+  }
+
+  G4bool operator==(const G4HETCChargedFragment &right) const 
+  { 
+    return G4HETCFragment::operator==(right);
+  }
+    
+  G4bool operator!=(const G4HETCChargedFragment &right) const 
+  { 
+    return G4HETCFragment::operator!=(right);
+  }
+    
+
+  virtual G4double GetKineticEnergy(const G4Fragment & aFragment);
+    
+    
+};
+
+#endif

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

@@ -0,0 +1,116 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4HETCDeuteron_h
+#define G4HETCDeuteron_h 1
+
+#include "G4HETCChargedFragment.hh"
+#include "G4ReactionProduct.hh"
+#include "G4Deuteron.hh"
+
+#include "G4DeuteronCoulombBarrier.hh"
+
+
+class G4HETCDeuteron : public G4HETCChargedFragment
+{
+public:
+  // default constructor
+  G4HETCDeuteron():G4HETCChargedFragment(2,1,&theDeuteronCoulombBarrier,"Deuteron") {}
+
+  // copy constructor
+  G4HETCDeuteron(const G4HETCDeuteron &right): G4HETCChargedFragment(right) {}
+  
+  // destructor
+  ~G4HETCDeuteron() {}
+  
+  // operators  
+  const G4HETCDeuteron & operator=(const G4HETCDeuteron &right) 
+  {
+    if (&right != this) this->G4HETCChargedFragment::operator=(right);
+    return *this;
+  }
+
+  G4bool operator==(const G4HETCDeuteron &right) const
+  { 
+    return G4HETCChargedFragment::operator==(right);
+  }
+
+  
+  G4bool operator!=(const G4HETCDeuteron &right) const
+  { 
+    return G4HETCChargedFragment::operator!=(right);
+  }
+
+
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct =
+      new G4ReactionProduct(G4Deuteron::DeuteronDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
+#ifdef PRECOMPOUND_TEST
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+#endif
+    return theReactionProduct;
+  }   
+    
+private:
+  virtual G4double GetAlpha()
+  {
+    G4double C = 0.0;
+    G4double aZ = GetZ() + GetRestZ();
+    if (aZ >= 70) 
+      {
+	C = 0.10;
+      } 
+    else 
+      {
+	C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375; 
+      }
+    return 1.0 + C/2.0;
+  }
+  
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
+
+  virtual G4double GetSpinFactor()
+  {
+    // 2s+1
+    return 3.0;
+  }
+  
+  virtual G4double K(const G4Fragment & aFragment);
+
+
+private:
+
+  G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
+
+};
+
+#endif
+ 
+

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

@@ -0,0 +1,49 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4HETCEmissionFactory_hh
+#define G4HETCEmissionFactory_hh 
+
+#include "G4VPreCompoundEmissionFactory.hh"
+
+
+class G4HETCEmissionFactory : public G4VPreCompoundEmissionFactory
+{
+public:
+
+  G4HETCEmissionFactory() {};
+  virtual ~G4HETCEmissionFactory() {};
+
+private:
+
+  G4HETCEmissionFactory(const G4HETCEmissionFactory & ) : G4VPreCompoundEmissionFactory() {};
+  const G4HETCEmissionFactory & operator=(const G4HETCEmissionFactory & val);
+  G4bool operator==(const G4HETCEmissionFactory & val) const;
+  G4bool operator!=(const G4HETCEmissionFactory & val) const;
+
+private:
+
+  virtual std::vector<G4VPreCompoundFragment*> *  CreateFragmentVector();
+
+};
+
+#endif

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

@@ -0,0 +1,93 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4HETCFragment_h
+#define G4HETCFragment_h 1
+
+#include "G4VPreCompoundFragment.hh"
+
+class G4HETCFragment : public G4VPreCompoundFragment
+{
+protected:
+  // default constructor
+  G4HETCFragment() {};
+    
+public:  
+  // copy constructor
+  G4HETCFragment(const G4HETCFragment &right);
+    
+  // constructor  
+  G4HETCFragment(const G4double anA, const G4double aZ,
+		 G4VCoulombBarrier * aCoulombBarrier,
+		 const G4String &  aName);
+  
+  virtual ~G4HETCFragment();
+  
+  // ==========
+  // operators 
+  // ========== 
+  
+  const G4HETCFragment& 
+  operator= (const G4HETCFragment &right);
+  
+  G4int operator==(const G4HETCFragment &right) const;
+  
+  G4int operator!=(const G4HETCFragment &right) const;
+  
+protected:
+
+  virtual G4double K(const G4Fragment & aFragment) = 0;
+    
+  virtual G4double GetSpinFactor() = 0;
+  virtual G4double GetAlpha() = 0;
+  virtual G4double GetBeta() = 0;
+
+public:
+    
+
+  G4double CalcEmissionProbability(const G4Fragment & aFragment);
+  
+private:	
+  // This method performs integration for probability function over 
+  // fragment kinetic energy
+  G4double IntegrateEmissionProbability(const G4double & Low, 
+					const G4double & Up, 
+					const G4Fragment & aFragment);	
+    
+  // ============================
+  // Data members access methods
+  // ============================
+  
+
+  inline G4bool IsItPossible(const G4Fragment & aFragment) const;
+
+protected:
+  
+  inline G4double BetaRand(const G4int N, const G4int L) const;
+  
+};
+
+#include "G4HETCFragment.icc"
+
+#endif

source/processes/hadronic/models/generator/pre_equilibrium/include/G4HETCFragment.icc

@@ -0,0 +1,46 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+
+#include <CLHEP/Random/RandGamma.h>
+#define G4RandGamma  RandGamma
+
+
+inline G4bool G4HETCFragment::
+IsItPossible(const G4Fragment & aFragment) const
+{
+  G4int pplus = aFragment.GetNumberOfCharged();
+  G4int pneut = aFragment.GetNumberOfParticles()-pplus;
+  return (pneut >= (GetA()-GetZ()) && pplus >= GetZ());
+}
+
+
+inline G4double G4HETCFragment::
+BetaRand(const G4int N, const G4int L) const
+{
+  G4double Y1 = G4RandGamma::shoot(N,1);
+  G4double Y2 = G4RandGamma::shoot(L,1);
+  
+  return Y1/(Y1+Y2);
+}

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

@@ -0,0 +1,132 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4HETCHe3_h
+#define G4HETCHe3_h 1
+
+#include "G4HETCChargedFragment.hh"
+#include "G4ReactionProduct.hh"
+#include "G4He3.hh"
+
+#include "G4He3CoulombBarrier.hh"
+
+
+class G4HETCHe3 : public G4HETCChargedFragment
+{
+public:
+  // default constructor
+  G4HETCHe3():G4HETCChargedFragment(3,2,&theHe3CoulombBarrier,"He3") {}
+
+  // copy constructor
+  G4HETCHe3(const G4HETCHe3 &right): G4HETCChargedFragment(right) {}
+
+  // destructor
+  ~G4HETCHe3() {}
+
+  // operators  
+  const G4HETCHe3 & operator=(const G4HETCHe3 &right) 
+  {
+    if (&right != this) this->G4HETCChargedFragment::operator=(right);
+    return *this;
+  }
+  
+  G4bool operator==(const G4HETCHe3 &right) const
+  { 
+    return G4HETCChargedFragment::operator==(right);
+  }
+
+  
+  G4bool operator!=(const G4HETCHe3 &right) const
+  { 
+    return G4HETCChargedFragment::operator!=(right);
+  }
+
+
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct =
+      new G4ReactionProduct(G4He3::He3Definition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
+#ifdef PRECOMPOUND_TEST
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+#endif
+    return theReactionProduct;
+  }   
+    
+private:
+  virtual G4double GetAlpha()
+  {
+    G4double C = 0.0;
+    G4double aZ = GetZ() + GetRestZ();
+    if (aZ <= 30) 
+      {
+	C = 0.10;
+      } 
+    else if (aZ <= 50) 
+      {
+	C = 0.1 + -((aZ-50.)/20.)*0.02;
+      } 
+    else if (aZ < 70) 
+      {
+	C = 0.08 + -((aZ-70.)/20.)*0.02;
+      }
+    else 
+      {
+	C = 0.06;
+      }
+    return 1.0 + C*(4.0/3.0);
+  }
+  
+
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
+  
+  //   virtual G4double FactorialFactor(const G4double N, const G4double P)
+  //   {
+  //     return 
+  //       (N-3.0)*(P-2.0)*(
+  // 		       (((N-2.0)*(P-1.0))/2.0) *(
+  // 						 (((N-1.0)*P)/3.0) 
+  // 						 )
+  // 		       );
+  //   }
+  
+  virtual G4double GetSpinFactor()
+  {
+    // 2s+1
+    return 2.0;
+  }    
+
+  virtual G4double K(const G4Fragment & aFragment);
+
+private:
+
+  G4He3CoulombBarrier theHe3CoulombBarrier;
+
+};
+
+#endif

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

@@ -0,0 +1,108 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+
+#ifndef G4HETCNeutron_h
+#define G4HETCNeutron_h 1
+
+#include "G4HETCFragment.hh"
+#include "G4ReactionProduct.hh"
+#include "G4Neutron.hh"
+#include "G4PreCompoundParameters.hh"
+#include "Randomize.hh"
+
+#include "G4NeutronCoulombBarrier.hh"
+
+
+class G4HETCNeutron : public G4HETCFragment
+{
+public:
+  // default constructor
+  G4HETCNeutron() : G4HETCFragment(1,0,&theNeutronCoulomBarrier,"Neutron") {}
+
+  // copy constructor
+  G4HETCNeutron(const G4HETCNeutron &right): G4HETCFragment(right) {}
+
+  // destructor
+  ~G4HETCNeutron() {}
+
+  // operators  
+  const G4HETCNeutron & operator=(const G4HETCNeutron &right) {
+    if (&right != this) this->G4HETCFragment::operator=(right);
+    return *this;
+  }
+
+  G4bool operator==(const G4HETCNeutron &right) const
+  { return G4HETCFragment::operator==(right);}
+  
+  G4bool operator!=(const G4HETCNeutron &right) const
+  { return G4HETCFragment::operator!=(right);}
+
+
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct = 
+      new G4ReactionProduct(G4Neutron::NeutronDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
+#ifdef PRECOMPOUND_TEST
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+#endif
+    return theReactionProduct;
+  }
+
+  virtual G4double GetKineticEnergy(const G4Fragment & aFragment);
+  
+private:
+  virtual G4double GetAlpha()
+  {
+    return 0.76+2.2/pow(GetRestA(),1.0/3.0);
+  }
+  
+  virtual G4double GetBeta() 
+  {
+    return (2.12/pow(GetRestA(),2.0/3.0)-0.05)*MeV/GetAlpha();
+  }
+
+  virtual G4double GetSpinFactor()
+  {
+    // (2s+1)
+    return 2.0;
+  }
+  
+  virtual G4double K(const G4Fragment& aFragment);
+
+private:
+  
+  G4NeutronCoulombBarrier theNeutronCoulomBarrier;
+
+};
+
+#endif
+ 
+
+
+
+
+

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

@@ -0,0 +1,116 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4HETCProton_h
+#define G4HETCProton_h 1
+
+#include "G4HETCChargedFragment.hh"
+#include "G4ReactionProduct.hh"
+#include "G4Proton.hh"
+#include "G4PreCompoundParameters.hh"
+#include "Randomize.hh"
+
+#include "G4ProtonCoulombBarrier.hh"
+
+
+class G4HETCProton : public G4HETCChargedFragment
+{
+public:
+  // default constructor
+  G4HETCProton():G4HETCChargedFragment(1,1,&theProtonCoulombBarrier,"Proton") {}
+  
+  // copy constructor
+  G4HETCProton(const G4HETCProton &right): G4HETCChargedFragment(right) {}
+
+  // destructor
+  ~G4HETCProton() {};
+  
+  // operators  
+  const G4HETCProton & operator=(const G4HETCProton &right) 
+  {
+    if (&right != this) this->G4HETCChargedFragment::operator=(right);
+    return *this;
+  }
+
+  G4bool operator==(const G4HETCProton &right) const
+  { 
+    return G4HETCChargedFragment::operator==(right);
+  }
+
+  
+  G4bool operator!=(const G4HETCProton &right) const
+  { 
+    return G4HETCChargedFragment::operator!=(right);
+  }
+
+
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct = 
+      new G4ReactionProduct(G4Proton::ProtonDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
+#ifdef PRECOMPOUND_TEST
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+#endif
+    return theReactionProduct;
+  }
+  
+private:
+  virtual G4double GetAlpha()
+  {
+    G4double aZ = static_cast<G4double>(GetRestZ());
+    G4double C = 0.0;
+    if (aZ >= 70) 
+      {
+	C = 0.10;
+      } 
+    else 
+      {
+	C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+      }
+    return 1.0 + C;
+  }
+  
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
+  
+  virtual G4double GetSpinFactor()
+  {
+    // 2s+1
+    return 2.0;
+  }
+
+  virtual G4double K(const G4Fragment & aFragment);
+
+private:
+
+  G4ProtonCoulombBarrier theProtonCoulombBarrier;
+
+};
+
+#endif
+ 

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

@@ -0,0 +1,118 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4HETCTriton_h
+#define G4HETCTriton_h 1
+
+#include "G4HETCChargedFragment.hh"
+#include "G4ReactionProduct.hh"
+#include "G4Triton.hh"
+
+#include "G4TritonCoulombBarrier.hh"
+
+
+class G4HETCTriton : public G4HETCChargedFragment
+{
+public:
+  // default constructor
+  G4HETCTriton():G4HETCChargedFragment(3,1,&theTritonCoulombBarrier,"Triton") {}
+
+  // copy constructor
+  G4HETCTriton(const G4HETCTriton &right): G4HETCChargedFragment(right) {}
+
+  // destructor
+  ~G4HETCTriton() {}
+
+  // operators  
+  const G4HETCTriton & operator=(const G4HETCTriton &right) 
+  {
+    if (&right != this) this->G4HETCChargedFragment::operator=(right);
+    return *this;
+  }
+
+  G4bool operator==(const G4HETCTriton &right) const
+  { 
+    return G4HETCChargedFragment::operator==(right);
+  }
+
+  
+  G4bool operator!=(const G4HETCTriton &right) const
+  { 
+    return G4HETCChargedFragment::operator!=(right);
+  }
+
+
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct =
+      new G4ReactionProduct(G4Triton::TritonDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
+#ifdef PRECOMPOUND_TEST
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+#endif
+    return theReactionProduct;
+  }   
+    
+private:
+  virtual G4double GetAlpha()
+  {
+    G4double C = 0.0;
+    G4double aZ = GetZ() + GetRestZ();
+    if (aZ >= 70) 
+      {
+	C = 0.10;
+      } 
+    else 
+      {
+	C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375; 
+      }
+    
+    return 1.0 + C/3.0;
+  }
+  
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
+
+
+
+  virtual G4double GetSpinFactor()
+  {
+    // 2s+1
+    return 2.0;
+  }
+
+  virtual G4double K(const G4Fragment& aFragment);
+
+private:
+  
+  G4TritonCoulombBarrier theTritonCoulombBarrier;
+  
+};
+
+#endif
+ 
+

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4LowEIonFragmentation.hh,v 1.7 2002/12/12 19:17:31 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4LowEIonFragmentation.hh,v 1.9 2003/05/30 14:05:57 hpw Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by H.P. Wellisch
 
@@ -55,7 +55,7 @@ public:
 
 private:
   
-  G4LowEIonFragmentation(const G4LowEIonFragmentation &right) {};
+  G4LowEIonFragmentation(const G4LowEIonFragmentation &) : G4HadronicInteraction() {};
   
   const G4LowEIonFragmentation& operator=(const G4LowEIonFragmentation &right);
 
@@ -70,7 +70,7 @@ public:
 //    clog << "area/millibarn = "<<area/millibarn<<G4endl;
 //    clog << "hits = "<<hits<<G4endl;
 //    clog << "totalTries = "<<totalTries<<G4endl;
-    return area*G4double(hits)/G4double(totalTries)/millibarn;
+    return area*static_cast<G4double>(hits)/static_cast<G4double>(totalTries)/millibarn;
   }
 private:  
 

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

@@ -21,100 +21,107 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundAlpha.hh,v 1.12 2002/12/12 19:17:31 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundAlpha.hh,v 1.13 2003/03/24 13:56:42 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
 #ifndef G4PreCompoundAlpha_h
 #define G4PreCompoundAlpha_h 1
 
-#include "G4VPreCompoundIon.hh"
+#include "G4PreCompoundIon.hh"
 #include "G4ReactionProduct.hh"
 #include "G4Alpha.hh"
 
 #include "G4AlphaCoulombBarrier.hh"
 
 
-class G4PreCompoundAlpha : public G4VPreCompoundIon
+class G4PreCompoundAlpha : public G4PreCompoundIon
 {
 public:
   // default constructor
-  G4PreCompoundAlpha():G4VPreCompoundIon(4,2,&theAlphaCoulombBarrier,"Alpha") {}
+  G4PreCompoundAlpha():G4PreCompoundIon(4,2,&theAlphaCoulombBarrier,"Alpha") {}
 
   // copy constructor
-  G4PreCompoundAlpha(const G4PreCompoundAlpha &right): G4VPreCompoundIon(right) {}
+  G4PreCompoundAlpha(const G4PreCompoundAlpha &right): G4PreCompoundIon(right) {}
 
   // destructor
   ~G4PreCompoundAlpha() {}
 
   // operators  
   const G4PreCompoundAlpha & operator=(const G4PreCompoundAlpha &right) {
-    if (&right != this) this->G4VPreCompoundIon::operator=(right);
+    if (&right != this) this->G4PreCompoundIon::operator=(right);
     return *this;
   };
 
   G4bool operator==(const G4PreCompoundAlpha &right) const
-  { return G4VPreCompoundIon::operator==(right);}
+  { return G4PreCompoundIon::operator==(right);}
 
   
   G4bool operator!=(const G4PreCompoundAlpha &right) const
-  { return G4VPreCompoundIon::operator!=(right);}
+  { return G4PreCompoundIon::operator!=(right);}
 
 
-    G4ReactionProduct * GetReactionProduct() const
-	{
-	    G4ReactionProduct * theReactionProduct =
-                new G4ReactionProduct(G4Alpha::AlphaDefinition());
-            theReactionProduct->SetMomentum(GetMomentum().vect());
-            theReactionProduct->SetTotalEnergy(GetMomentum().e());
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct =
+      new G4ReactionProduct(G4Alpha::AlphaDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
 #ifdef PRECOMPOUND_TEST
-            theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
 #endif
-            return theReactionProduct;
-        }   
+    return theReactionProduct;
+  }   
     
 private:
-    virtual G4double GetAlpha()
-	{
-	    G4double C = 0.0;
-	    G4double aZ = GetZ() + GetRestZ();
-	    if (aZ <= 30) {
-		C = 0.10;
-	    } else if (aZ <= 50) {
-		C = 0.1 + -((aZ-50.)/20.)*0.02;
-	    } else if (aZ < 70) {
-		C = 0.08 + -((aZ-70.)/20.)*0.02;
-	    } else {
-		C = 0.06;
-	    }
-	    return 1.0+C;
-	}
+  virtual G4double GetAlpha()
+  {
+    G4double C = 0.0;
+    G4double aZ = GetZ() + GetRestZ();
+    if (aZ <= 30) 
+      {
+	C = 0.10;
+      } 
+    else if (aZ <= 50) 
+      {
+	C = 0.1 + -((aZ-50.)/20.)*0.02;
+      } 
+    else if (aZ < 70) 
+      {
+	C = 0.08 + -((aZ-70.)/20.)*0.02;
+      }
+    else 
+      {
+	C = 0.06;
+      }
+    return 1.0+C;
+  }
 
-    virtual G4double GetBeta()
-	{
-	    return -GetCoulombBarrier();
-	}
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
 
-    virtual G4double FactorialFactor(const G4double N, const G4double P)
-	{
-	    return 
-		(N-4.0)*(P-3.0)*(
-		    (((N-3.0)*(P-2.0))/2.0) *(
-			(((N-2.0)*(P-1.0))/3.0) *(
-			    (((N-1.0)*P)/2.0)
-			    )
-			)
-		    );
-	}
+  virtual G4double FactorialFactor(const G4double N, const G4double P)
+  {
+    return 
+      (N-4.0)*(P-3.0)*(
+		       (((N-3.0)*(P-2.0))/2.0) *(
+						 (((N-2.0)*(P-1.0))/3.0) *(
+									   (((N-1.0)*P)/2.0)
+									   )
+						 )
+		       );
+  }
 
-    virtual G4double CoalescenceFactor(const G4double A)
-	{
-	    return 4096.0/(A*A*A);
-	}    
+  virtual G4double CoalescenceFactor(const G4double A)
+  {
+    return 4096.0/(A*A*A);
+  }    
 private:
 
-    G4AlphaCoulombBarrier theAlphaCoulombBarrier;
+  G4AlphaCoulombBarrier theAlphaCoulombBarrier;
 
 };
 

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

@@ -21,90 +21,92 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundDeuteron.hh,v 1.12 2002/12/12 19:17:31 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundDeuteron.hh,v 1.13 2003/03/24 13:56:43 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
 #ifndef G4PreCompoundDeuteron_h
 #define G4PreCompoundDeuteron_h 1
 
-#include "G4VPreCompoundIon.hh"
+#include "G4PreCompoundIon.hh"
 #include "G4ReactionProduct.hh"
 #include "G4Deuteron.hh"
 
 #include "G4DeuteronCoulombBarrier.hh"
 
 
-class G4PreCompoundDeuteron : public G4VPreCompoundIon
+class G4PreCompoundDeuteron : public G4PreCompoundIon
 {
 public:
   // default constructor
-  G4PreCompoundDeuteron():G4VPreCompoundIon(2,1,&theDeuteronCoulombBarrier,"Deuteron") {}
+  G4PreCompoundDeuteron():G4PreCompoundIon(2,1,&theDeuteronCoulombBarrier,"Deuteron") {}
 
   // copy constructor
-  G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right): G4VPreCompoundIon(right) {}
+  G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right): G4PreCompoundIon(right) {}
 
   // destructor
   ~G4PreCompoundDeuteron() {}
 
   // operators  
   const G4PreCompoundDeuteron & operator=(const G4PreCompoundDeuteron &right) {
-    if (&right != this) this->G4VPreCompoundIon::operator=(right);
+    if (&right != this) this->G4PreCompoundIon::operator=(right);
     return *this;
   }
 
   G4bool operator==(const G4PreCompoundDeuteron &right) const
-  { return G4VPreCompoundIon::operator==(right);}
+  { return G4PreCompoundIon::operator==(right);}
 
   
   G4bool operator!=(const G4PreCompoundDeuteron &right) const
-  { return G4VPreCompoundIon::operator!=(right);}
+  { return G4PreCompoundIon::operator!=(right);}
 
 
-    G4ReactionProduct * GetReactionProduct() const
-	{
-            G4ReactionProduct * theReactionProduct =
-                new G4ReactionProduct(G4Deuteron::DeuteronDefinition());
-            theReactionProduct->SetMomentum(GetMomentum().vect());
-            theReactionProduct->SetTotalEnergy(GetMomentum().e());
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct =
+      new G4ReactionProduct(G4Deuteron::DeuteronDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
 #ifdef PRECOMPOUND_TEST
-            theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
 #endif
-            return theReactionProduct;
-        }   
-    
+    return theReactionProduct;
+  }   
+  
 private:
-    virtual G4double GetAlpha()
-	{
-	    G4double C = 0.0;
-	    G4double aZ = GetZ() + GetRestZ();
-	    if (aZ >= 70) {
-		C = 0.10;
-	    } else {
-		C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375; 
-	    }
-	    return 1.0 + C/2.0;
-	}
+  virtual G4double GetAlpha()
+  {
+    G4double C = 0.0;
+    G4double aZ = GetZ() + GetRestZ();
+    if (aZ >= 70) 
+      {
+	C = 0.10;
+      } 
+    else 
+      {
+	C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375; 
+      }
+    return 1.0 + C/2.0;
+  }
     
-    virtual G4double GetBeta()
-	{
-	    return -GetCoulombBarrier();
-	}
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
 
-    virtual G4double FactorialFactor(const G4double N, const G4double P)
-	{
-	    return 
-		(N-1.0)*(N-2.0)*(P-1.0)*P/2.0;
-	}
-
-    virtual G4double CoalescenceFactor(const G4double A)
-	{
-	    return 16.0/A;
-	}    
+  virtual G4double FactorialFactor(const G4double N, const G4double P)
+  {
+    return (N-1.0)*(N-2.0)*(P-1.0)*P/2.0;
+  }
+  
+  virtual G4double CoalescenceFactor(const G4double A)
+  {
+    return 16.0/A;
+  }    
 private:
-
-    G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
+  
+  G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
 
 };
 

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

@@ -20,8 +20,8 @@
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
-// $Id: G4PreCompoundEmission.hh,v 1.9 2002/12/12 19:17:31 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundEmission.hh,v 1.10 2003/03/24 13:56:44 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // Hadronic Process: Nuclear Preequilibrium
 // by V. Lara 
@@ -30,20 +30,22 @@
 #define G4PreCompoundEmission_h 1
 
 #include "G4VPreCompoundFragment.hh"
-#include "G4PreCompoundFragmentVector.hh"
 #include "G4ReactionProduct.hh"
 #include "G4Fragment.hh"
 #include "Randomize.hh"
 #include "G4PreCompoundParameters.hh"
+#include "G4PreCompoundFragmentVector.hh"
+
+class G4VPreCompoundEmissionFactory;
+
 
 class G4PreCompoundEmission
 {
 public:
-  G4PreCompoundEmission(const G4Fragment& aFragment);
-  ~G4PreCompoundEmission() {};
+  G4PreCompoundEmission();
+  ~G4PreCompoundEmission();
 
 private:
-  G4PreCompoundEmission() {};
   G4PreCompoundEmission(const G4PreCompoundEmission &right);
   const G4PreCompoundEmission& operator=(const G4PreCompoundEmission &right);
   G4bool operator==(const G4PreCompoundEmission &right) const;
@@ -51,20 +53,16 @@ private:
 
 public:
 
-  void Initialize(const G4Fragment & aFragment) 
-  {
-    theFragmentsVector.Initialize(aFragment);
-    return;
-  }
+  inline void SetUp(const G4Fragment & aFragment);
+  inline void Initialize(const G4Fragment & aFragment);
 	
-  G4double GetTotalProbability(const G4Fragment & aFragment) 
-  {
-    return theFragmentsVector.CalculateProbabilities(aFragment);
-  }
+  inline G4double GetTotalProbability(const G4Fragment & aFragment);
 	
   G4ReactionProduct * PerformEmission(G4Fragment & aFragment);
 
-	
+  void SetDefaultModel();
+  void SetHETCModel();
+
 private:
 
   G4ThreeVector AngularDistribution(G4VPreCompoundFragment * theFragment,
@@ -76,17 +74,22 @@ private:
   G4double rho(const G4double p, const G4double h, const G4double g, 
 	       const G4double E, const G4double Ef) const;
 
-  //  G4double bessi0(const G4double x) const;					 
-					 
+  //==============
+  // Data Members
+  //==============
+
   // A vector with the allowed emission fragments 
-  G4PreCompoundFragmentVector theFragmentsVector;
-	
+  G4PreCompoundFragmentVector * theFragmentsVector;
+  G4VPreCompoundEmissionFactory * theFragmentsFactory;
+
   // Projectile energy
   G4double ProjEnergy;
 
   // Projectile direction
   G4ThreeVector theIncidentDirection;
 
-
 };
+
+#include "G4PreCompoundEmission.icc"
+
 #endif

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundEmission.icc

@@ -0,0 +1,44 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+inline void G4PreCompoundEmission::Initialize(const G4Fragment & aFragment) 
+{
+  theFragmentsVector->Initialize(aFragment);
+  return;
+}
+
+
+inline G4double G4PreCompoundEmission::GetTotalProbability(const G4Fragment & aFragment) 
+{
+  return theFragmentsVector->CalculateProbabilities(aFragment);
+}
+
+inline void G4PreCompoundEmission::SetUp(const G4Fragment & aFragment)
+{
+  // This should be the projectile energy. If I would know which is the projectile (proton, neutron)
+  // I could remove the binding energy. But, what happens if INC precedes precompound? This approximation
+  // seems to work well enough
+  ProjEnergy = aFragment.GetExcitationEnergy();
+  theIncidentDirection = aFragment.GetMomentum().vect().unit();
+  theFragmentsVector->ResetStage();
+  return;
+}

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

@@ -0,0 +1,49 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4PreCompoundEmissionFactory_hh
+#define G4PreCompoundEmissionFactory_hh 
+
+#include "G4VPreCompoundEmissionFactory.hh"
+
+
+class G4PreCompoundEmissionFactory : public G4VPreCompoundEmissionFactory
+{
+public:
+
+  G4PreCompoundEmissionFactory() {};
+  virtual ~G4PreCompoundEmissionFactory() {};
+
+private:
+
+  G4PreCompoundEmissionFactory(const G4PreCompoundEmissionFactory & ) : G4VPreCompoundEmissionFactory() {};
+  const G4PreCompoundEmissionFactory & operator=(const G4PreCompoundEmissionFactory & val);
+  G4bool operator==(const G4PreCompoundEmissionFactory & val) const;
+  G4bool operator!=(const G4PreCompoundEmissionFactory & val) const;
+
+private:
+
+  virtual std::vector<G4VPreCompoundFragment*> *  CreateFragmentVector();
+
+};
+
+#endif

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

@@ -0,0 +1,86 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4PreCompoundFragment_h
+#define G4PreCompoundFragment_h 1
+
+#include "G4VPreCompoundFragment.hh"
+
+class G4PreCompoundFragment : public G4VPreCompoundFragment
+{
+protected:
+  // default constructor
+  G4PreCompoundFragment() {};
+    
+public:  
+  // copy constructor
+  G4PreCompoundFragment(const G4PreCompoundFragment &right);
+    
+  // constructor  
+  G4PreCompoundFragment(const G4double anA, const G4double aZ,
+			G4VCoulombBarrier * aCoulombBarrier,
+			const G4String &  aName);
+  
+  virtual ~G4PreCompoundFragment();
+  
+  // ==========
+  // operators 
+  // ========== 
+  
+  const G4PreCompoundFragment& 
+  operator= (const G4PreCompoundFragment &right);
+  
+  G4int operator==(const G4PreCompoundFragment &right) const;
+  
+  G4int operator!=(const G4PreCompoundFragment &right) const;
+      
+public:
+  
+  // Initialization method
+  void Initialize(const G4Fragment & aFragment);
+    
+  // ================================================
+  // Methods for calculating the emission probability
+  // ================================================
+  
+  // Calculates the total (integrated over kinetic energy) emission
+  // probability of a fragment
+  G4double CalcEmissionProbability(const G4Fragment & aFragment);
+  
+  G4double GetKineticEnergy(const G4Fragment & aFragment);
+
+private:	
+  // This method performs integration for probability function over 
+  // fragment kinetic energy
+  G4double IntegrateEmissionProbability(const G4double & Low, 
+					const G4double & Up, 
+					const G4Fragment & aFragment);	
+protected:
+
+  virtual G4double 
+  ProbabilityDistributionFunction(const G4double K, 
+				  const G4Fragment & aFragment) = 0;  
+};
+
+#endif

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundFragmentVector.hh,v 1.6 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundFragmentVector.hh,v 1.8 2003/06/16 17:07:11 gunter Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // Hadronic Process: Nuclear Preequilibrium
 // by V. Lara 
@@ -34,54 +34,40 @@
 #include "G4VPreCompoundFragment.hh"
 
 
+
 class G4PreCompoundFragmentVector 
 {
-  typedef G4std::vector<G4VPreCompoundFragment*>  pcfvector;
+  typedef std::vector<G4VPreCompoundFragment*>  pcfvector;
 public:
-  G4PreCompoundFragmentVector();
-  ~G4PreCompoundFragmentVector();
-	
+  inline G4PreCompoundFragmentVector(pcfvector * avector);
+  inline ~G4PreCompoundFragmentVector();
+  
 private:
   G4PreCompoundFragmentVector(const G4PreCompoundFragmentVector &right);
   const G4PreCompoundFragmentVector& 
   operator=(const G4PreCompoundFragmentVector &right);
   G4bool operator==(const G4PreCompoundFragmentVector &right) const;
   G4bool operator!=(const G4PreCompoundFragmentVector &right) const;	
-    
+  
 public:
 
   inline void Initialize(const G4Fragment & aFragment);
+  inline void ResetStage();
+  inline void SetVector(pcfvector * avector);
+
   G4double CalculateProbabilities(const G4Fragment & aFragment);
 	
   G4VPreCompoundFragment * ChooseFragment(void);
 		
 private:
 
-  pcfvector theChannels;
+  pcfvector * theChannels;
 
   G4double TotalEmissionProbability;
 
-  struct DeleteFragment 
-  {
-    template<typename T>
-    void operator()(const T* ptr) const
-    {
-      delete ptr;
-    }
-  };
-
 };
 
 #include "G4PreCompoundFragmentVector.icc"
 
 #endif
 
-
-
-
-
-
-
-
-
-

source/processes/hadronic/models/generator/pre_equilibrium/include/G4PreCompoundFragmentVector.icc

@@ -21,19 +21,42 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundFragmentVector.icc,v 1.2 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundFragmentVector.icc,v 1.3 2003/03/24 13:56:46 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // Hadronic Process: Nuclear Preequilibrium
 // by V. Lara 
 
 
+inline G4PreCompoundFragmentVector::G4PreCompoundFragmentVector(pcfvector * avector) :
+  theChannels(avector), TotalEmissionProbability(0.0)
+{
+}
+
+
+inline G4PreCompoundFragmentVector::~G4PreCompoundFragmentVector()
+{
+}
+
+inline void G4PreCompoundFragmentVector::SetVector(pcfvector * avector)
+{
+  theChannels = avector;
+}
+
 inline void 
 G4PreCompoundFragmentVector::
 Initialize(const G4Fragment & aFragment)
 {
     TotalEmissionProbability = 0.0;
-    for (pcfvector::iterator i=theChannels.begin(); 
-	 i != theChannels.end(); i++) (*i)->Initialize(aFragment);
+    for (pcfvector::iterator i=theChannels->begin(); 
+	 i != theChannels->end(); i++) (*i)->Initialize(aFragment);
     return;
 }
+
+inline void G4PreCompoundFragmentVector::
+ResetStage()
+{
+  for (pcfvector::iterator i=theChannels->begin(); i != theChannels->end(); i++)
+    (*i)->ResetStage();
+  return;
+}

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

@@ -21,98 +21,105 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundHe3.hh,v 1.12 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundHe3.hh,v 1.13 2003/03/24 13:56:47 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
 #ifndef G4PreCompoundHe3_h
 #define G4PreCompoundHe3_h 1
 
-#include "G4VPreCompoundIon.hh"
+#include "G4PreCompoundIon.hh"
 #include "G4ReactionProduct.hh"
 #include "G4He3.hh"
 
 #include "G4He3CoulombBarrier.hh"
 
 
-class G4PreCompoundHe3 : public G4VPreCompoundIon
+class G4PreCompoundHe3 : public G4PreCompoundIon
 {
 public:
   // default constructor
-  G4PreCompoundHe3():G4VPreCompoundIon(3,2,&theHe3CoulombBarrier,"He3") {}
+  G4PreCompoundHe3():G4PreCompoundIon(3,2,&theHe3CoulombBarrier,"He3") {}
 
   // copy constructor
-  G4PreCompoundHe3(const G4PreCompoundHe3 &right): G4VPreCompoundIon(right) {}
+  G4PreCompoundHe3(const G4PreCompoundHe3 &right): G4PreCompoundIon(right) {}
 
   // destructor
   ~G4PreCompoundHe3() {}
 
   // operators  
   const G4PreCompoundHe3 & operator=(const G4PreCompoundHe3 &right) {
-    if (&right != this) this->G4VPreCompoundIon::operator=(right);
+    if (&right != this) this->G4PreCompoundIon::operator=(right);
     return *this;
   }
 
   G4bool operator==(const G4PreCompoundHe3 &right) const
-  { return G4VPreCompoundIon::operator==(right);}
+  { return G4PreCompoundIon::operator==(right);}
 
   
   G4bool operator!=(const G4PreCompoundHe3 &right) const
-  { return G4VPreCompoundIon::operator!=(right);}
+  { return G4PreCompoundIon::operator!=(right);}
 
 
-    G4ReactionProduct * GetReactionProduct() const
-	{
-            G4ReactionProduct * theReactionProduct =
-                new G4ReactionProduct(G4He3::He3Definition());
-            theReactionProduct->SetMomentum(GetMomentum().vect());
-            theReactionProduct->SetTotalEnergy(GetMomentum().e());
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct =
+      new G4ReactionProduct(G4He3::He3Definition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
 #ifdef PRECOMPOUND_TEST
-            theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
 #endif
-            return theReactionProduct;
-        }   
+    return theReactionProduct;
+  }   
     
 private:
-    virtual G4double GetAlpha()
-	{
-	    G4double C = 0.0;
-	    G4double aZ = GetZ() + GetRestZ();
-	    if (aZ <= 30) {
-		C = 0.10;
-	    } else if (aZ <= 50) {
-		C = 0.1 + -((aZ-50.)/20.)*0.02;
-	    } else if (aZ < 70) {
-		C = 0.08 + -((aZ-70.)/20.)*0.02;
-	    } else {
-		C = 0.06;
-	    }
-	    return 1.0 + C*(4.0/3.0);
-	}
+  virtual G4double GetAlpha()
+  {
+    G4double C = 0.0;
+    G4double aZ = GetZ() + GetRestZ();
+    if (aZ <= 30) 
+      {
+	C = 0.10;
+      }
+    else if (aZ <= 50) 
+      {
+	C = 0.1 + -((aZ-50.)/20.)*0.02;
+      } 
+    else if (aZ < 70) 
+      {
+	C = 0.08 + -((aZ-70.)/20.)*0.02;
+      }
+    else 
+      {
+	C = 0.06;
+      }
+    return 1.0 + C*(4.0/3.0);
+  }
 
-    virtual G4double GetBeta()
-	{
-	    return -GetCoulombBarrier();
-	}
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
 
-    virtual G4double FactorialFactor(const G4double N, const G4double P)
-	{
-	    return 
-		(N-3.0)*(P-2.0)*(
-		    (((N-2.0)*(P-1.0))/2.0) *(
-			(((N-1.0)*P)/3.0) 
-			)
-		    );
-	}
+  virtual G4double FactorialFactor(const G4double N, const G4double P)
+  {
+    return 
+      (N-3.0)*(P-2.0)*(
+		       (((N-2.0)*(P-1.0))/2.0) *(
+						 (((N-1.0)*P)/3.0) 
+						 )
+		       );
+  }
 
-    virtual G4double CoalescenceFactor(const G4double A)
-	{
-	    return 243.0/(A*A);
-	}    
+  virtual G4double CoalescenceFactor(const G4double A)
+  {
+    return 243.0/(A*A);
+  }    
 private:
 
-    G4He3CoulombBarrier theHe3CoulombBarrier;
+  G4He3CoulombBarrier theHe3CoulombBarrier;
 
 };
 

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

@@ -0,0 +1,87 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4PreCompoundIon_h
+#define G4PreCompoundIon_h 1
+
+#include "G4PreCompoundFragment.hh"
+
+class G4PreCompoundIon : public G4PreCompoundFragment
+{
+protected:
+  // default constructor
+  G4PreCompoundIon() {}
+
+public:
+
+  // copy constructor
+  G4PreCompoundIon(const G4PreCompoundIon &right): 
+    G4PreCompoundFragment(right) {}
+    
+  // constructor  
+  G4PreCompoundIon(const G4double anA, 
+		   const G4double aZ, 
+		   G4VCoulombBarrier* aCoulombBarrier,
+		   const G4String & aName): 
+    G4PreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
+    
+  virtual ~G4PreCompoundIon() {}
+    
+  // operators  
+  const G4PreCompoundIon & 
+  operator=(const G4PreCompoundIon &right) 
+  {
+    if (&right != this) this->G4PreCompoundFragment::operator=(right);
+    return *this;
+  }
+    
+  G4bool operator==(const G4PreCompoundIon &right) const 
+  { 
+    return G4PreCompoundFragment::operator==(right);
+  }
+    
+  G4bool operator!=(const G4PreCompoundIon &right) const 
+  { 
+    return G4PreCompoundFragment::operator!=(right);
+  }
+    
+  virtual G4double ProbabilityDistributionFunction(const G4double eKin,
+						   const G4Fragment& aFragment);
+
+protected:
+  G4bool IsItPossible(const G4Fragment& aFragment) 
+  {
+    G4int pplus = aFragment.GetNumberOfCharged();   
+    G4int pneut = aFragment.GetNumberOfParticles()-pplus;
+    return (pneut >= (GetA()-GetZ()) && pplus >= GetZ());
+  }
+  
+  virtual G4double GetAlpha() = 0;
+  virtual G4double GetBeta() = 0;
+  virtual G4double FactorialFactor(const G4double N, const G4double P) = 0;
+  virtual G4double CoalescenceFactor(const G4double A) = 0; 
+    
+};
+
+#endif

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

@@ -21,6 +21,8 @@
 // ********************************************************************
 //
 //
+// $Id: G4PreCompoundModel.hh,v 1.21 2003/06/16 17:07:12 gunter Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
@@ -35,10 +37,9 @@
 #define G4PreCompoundModel_h 1
 
 #include "G4VPreCompoundModel.hh"
-#include "G4PreCompoundTransitions.hh"
-#include "G4PreCompoundEmission.hh"
 #include "G4LorentzVector.hh"
 
+
 #include "G4NucleiProperties.hh"
 #include "G4PreCompoundParameters.hh"
 #include "G4ExcitationHandler.hh"
@@ -53,60 +54,61 @@ class G4PreCompoundModel : public G4VPreCompoundModel
 {
 public:
     
-    G4PreCompoundModel(G4ExcitationHandler * const value) : 
-	G4VPreCompoundModel(value) {};
+  G4PreCompoundModel(G4ExcitationHandler * const value) : 
+    G4VPreCompoundModel(value), useHETCEmission(false), useGNASHTransition(false) {}
 
-    ~G4PreCompoundModel() {};
+  ~G4PreCompoundModel() {}
 
 private:
-    G4PreCompoundModel() {};
+  G4PreCompoundModel() {}
 
-    G4PreCompoundModel(const G4PreCompoundModel &right) : G4VPreCompoundModel() {};
+  G4PreCompoundModel(const G4PreCompoundModel &) : G4VPreCompoundModel() {}
 
-    const G4PreCompoundModel& operator=(const G4PreCompoundModel &right);
-    G4bool operator==(const G4PreCompoundModel &right) const;
-    G4bool operator!=(const G4PreCompoundModel &right) const;
+  const G4PreCompoundModel& operator=(const G4PreCompoundModel &right);
+  G4bool operator==(const G4PreCompoundModel &right) const;
+  G4bool operator!=(const G4PreCompoundModel &right) const;
 
 public:
-    G4VParticleChange * ApplyYourself(const G4Track & thePrimary, G4Nucleus & theNucleus);
+  G4VParticleChange * ApplyYourself(const G4Track & thePrimary, G4Nucleus & theNucleus);
 
-    G4ReactionProductVector* DeExcite(const G4Fragment& aFragment) const;
+  G4ReactionProductVector* DeExcite(const G4Fragment& aFragment) const;
 
 #ifdef PRECOMPOUND_TEST
-    static G4Fragment GetInitialFragmentForTest()
-	{ return G4PreCompoundModel::theInitialFragmentForTest; }
-    static G4std::vector<G4String*> * GetCreatorModels()
-	{ return &G4PreCompoundModel::theCreatorModels; }
+  static G4Fragment GetInitialFragmentForTest()
+  { return G4PreCompoundModel::theInitialFragmentForTest; }
+  static std::vector<G4String*> * GetCreatorModels()
+  { return &G4PreCompoundModel::theCreatorModels; }
 #endif
 
+  inline void UseHETCEmission() { useHETCEmission = true; }
+  inline void UseDefaultEmission() { useHETCEmission = false; }
+  inline void UseGNASHTransition() { useGNASHTransition = true; }
+  inline void UseDefaultTransition() { useGNASHTransition = false; }
+
 private:  
 
-    void PerformEquilibriumEmission(const G4Fragment & aFragment, 
-				    G4ReactionProductVector * theResult) const;
+  void PerformEquilibriumEmission(const G4Fragment & aFragment, 
+				  G4ReactionProductVector * theResult) const;
 
 #ifdef debug				  
-    void CheckConservation(const G4Fragment & theInitialState,
-			   const G4Fragment & aFragment,
-			   G4ReactionProductVector * Result) const;
+  void CheckConservation(const G4Fragment & theInitialState,
+			 const G4Fragment & aFragment,
+			 G4ReactionProductVector * Result) const;
 #endif
 
-    G4ParticleChange theResult;
+  //==============
+  // Data Members 
+  //==============
+
+  G4ParticleChange theResult;
+  G4bool           useHETCEmission;
+  G4bool           useGNASHTransition;
 
 #ifdef PRECOMPOUND_TEST
-    static G4Fragment theInitialFragmentForTest;
-    static G4std::vector<G4String*> theCreatorModels;
+  static G4Fragment theInitialFragmentForTest;
+  static std::vector<G4String*> theCreatorModels;
 #endif
 
 };
 #endif
 
-
-
-
-
-
-
-
-
-
-

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundNeutron.hh,v 1.12 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundNeutron.hh,v 1.13 2003/03/24 13:56:49 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
@@ -30,7 +30,7 @@
 #ifndef G4PreCompoundNeutron_h
 #define G4PreCompoundNeutron_h 1
 
-#include "G4VPreCompoundNucleon.hh"
+#include "G4PreCompoundNucleon.hh"
 #include "G4ReactionProduct.hh"
 #include "G4Neutron.hh"
 #include "G4PreCompoundParameters.hh"
@@ -39,70 +39,65 @@
 #include "G4NeutronCoulombBarrier.hh"
 
 
-class G4PreCompoundNeutron : public G4VPreCompoundNucleon
+class G4PreCompoundNeutron : public G4PreCompoundNucleon
 {
 public:
   // default constructor
-  G4PreCompoundNeutron() : G4VPreCompoundNucleon(1,0,&theNeutronCoulomBarrier,"Neutron") {}
+  G4PreCompoundNeutron() : G4PreCompoundNucleon(1,0,&theNeutronCoulomBarrier,"Neutron") {}
 
   // copy constructor
-  G4PreCompoundNeutron(const G4PreCompoundNeutron &right): G4VPreCompoundNucleon(right) {}
+  G4PreCompoundNeutron(const G4PreCompoundNeutron &right): G4PreCompoundNucleon(right) {}
 
   // destructor
   ~G4PreCompoundNeutron() {}
 
   // operators  
   const G4PreCompoundNeutron & operator=(const G4PreCompoundNeutron &right) {
-    if (&right != this) this->G4VPreCompoundNucleon::operator=(right);
+    if (&right != this) this->G4PreCompoundNucleon::operator=(right);
     return *this;
   }
 
   G4bool operator==(const G4PreCompoundNeutron &right) const
-  { return G4VPreCompoundNucleon::operator==(right);}
+  { return G4PreCompoundNucleon::operator==(right);}
   
   G4bool operator!=(const G4PreCompoundNeutron &right) const
-  { return G4VPreCompoundNucleon::operator!=(right);}
+  { return G4PreCompoundNucleon::operator!=(right);}
 
 
-    G4ReactionProduct * GetReactionProduct() const
-	{
-	    G4ReactionProduct * theReactionProduct = 
-		new G4ReactionProduct(G4Neutron::NeutronDefinition());
-	    theReactionProduct->SetMomentum(GetMomentum().vect());
-	    theReactionProduct->SetTotalEnergy(GetMomentum().e());
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct = 
+      new G4ReactionProduct(G4Neutron::NeutronDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
 #ifdef PRECOMPOUND_TEST
-	    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
 #endif
-	    return theReactionProduct;
-	}
-    
+    return theReactionProduct;
+  }
+  
 private:
-    virtual G4double GetAlpha()
-	{
-	    return 0.76+2.2/pow(GetRestA(),1.0/3.0);
-	}
-
-    virtual G4double GetBeta() 
-	{
-	    return (2.12/pow(GetRestA(),2.0/3.0)-0.05)*MeV/GetAlpha();
-	}
-
-    virtual G4bool IsItPossible(const G4Fragment& aFragment)
-	{
-	    return ((aFragment.GetNumberOfParticles()-aFragment.GetNumberOfCharged()) >= 1);  
-	}
-    
+  virtual G4double GetAlpha()
+  {
+    return 0.76+2.2/pow(GetRestA(),1.0/3.0);
+  }
+  
+  virtual G4double GetBeta() 
+  {
+    return (2.12/pow(GetRestA(),2.0/3.0)-0.05)*MeV/GetAlpha();
+  }
+  
+  virtual G4bool IsItPossible(const G4Fragment& aFragment)
+  {
+    return ((aFragment.GetNumberOfParticles()-aFragment.GetNumberOfCharged()) >= 1);  
+  }
+  
 
 private:
-
+  
   G4NeutronCoulombBarrier theNeutronCoulomBarrier;
 
 };
 
 #endif
- 
-
-
-
-
 

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

@@ -0,0 +1,80 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+// by V. Lara
+
+#ifndef G4PreCompoundNucleon_h
+#define G4PreCompoundNucleon_h 1
+
+#include "G4PreCompoundFragment.hh"
+
+class G4PreCompoundNucleon : public G4PreCompoundFragment
+{
+private:
+  // default constructor
+  G4PreCompoundNucleon() {};
+
+public:
+  
+  // copy constructor
+  G4PreCompoundNucleon(const G4PreCompoundNucleon &right): 
+    G4PreCompoundFragment(right) {}
+
+  // constructor  
+  G4PreCompoundNucleon(const G4double anA, 
+		       const G4double aZ, 
+		       G4VCoulombBarrier* aCoulombBarrier,
+		       const G4String & aName): 
+    G4PreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
+  
+  virtual ~G4PreCompoundNucleon() {}
+
+  // operators  
+  const G4PreCompoundNucleon & 
+  operator=(const G4PreCompoundNucleon &right) 
+  {
+    if (&right != this) this->G4PreCompoundFragment::operator=(right);
+    return *this;
+  }
+  
+  G4bool operator==(const G4PreCompoundNucleon &right) const 
+  { 
+    return G4PreCompoundFragment::operator==(right);
+  }
+    
+  G4bool operator!=(const G4PreCompoundNucleon &right) const 
+  { 
+    return G4PreCompoundFragment::operator!=(right);
+  }
+    
+  virtual G4double ProbabilityDistributionFunction(const G4double eKin,
+						   const G4Fragment& aFragment);
+
+    
+protected:
+
+  virtual G4double GetAlpha() = 0;
+  virtual G4double GetBeta() = 0;
+  virtual G4bool IsItPossible(const G4Fragment&) = 0;     
+};
+
+#endif

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundParameters.hh,v 1.9 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundParameters.hh,v 1.10 2003/03/24 13:56:50 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 

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

@@ -21,15 +21,15 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundProton.hh,v 1.13 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundProton.hh,v 1.15 2003/05/26 11:46:53 lara Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
 #ifndef G4PreCompoundProton_h
 #define G4PreCompoundProton_h 1
 
-#include "G4VPreCompoundNucleon.hh"
+#include "G4PreCompoundNucleon.hh"
 #include "G4ReactionProduct.hh"
 #include "G4Proton.hh"
 #include "G4PreCompoundParameters.hh"
@@ -38,72 +38,75 @@
 #include "G4ProtonCoulombBarrier.hh"
 
 
-class G4PreCompoundProton : public G4VPreCompoundNucleon
+class G4PreCompoundProton : public G4PreCompoundNucleon
 {
 public:
   // default constructor
-  G4PreCompoundProton():G4VPreCompoundNucleon(1,1,&theProtonCoulombBarrier,"Proton") {}
+  G4PreCompoundProton():G4PreCompoundNucleon(1,1,&theProtonCoulombBarrier,"Proton") {}
 
   // copy constructor
-  G4PreCompoundProton(const G4PreCompoundProton &right): G4VPreCompoundNucleon(right) {}
+  G4PreCompoundProton(const G4PreCompoundProton &right): G4PreCompoundNucleon(right) {}
 
   // destructor
   ~G4PreCompoundProton() {};
 
   // operators  
   const G4PreCompoundProton & operator=(const G4PreCompoundProton &right) {
-    if (&right != this) this->G4VPreCompoundNucleon::operator=(right);
+    if (&right != this) this->G4PreCompoundNucleon::operator=(right);
     return *this;
   };
 
   G4bool operator==(const G4PreCompoundProton &right) const
-  { return G4VPreCompoundNucleon::operator==(right);}
+  { return G4PreCompoundNucleon::operator==(right);}
 
   
   G4bool operator!=(const G4PreCompoundProton &right) const
-  { return G4VPreCompoundNucleon::operator!=(right);}
+  { return G4PreCompoundNucleon::operator!=(right);}
 
 
-    G4ReactionProduct * GetReactionProduct() const
-	{
-	    G4ReactionProduct * theReactionProduct = 
-		new G4ReactionProduct(G4Proton::ProtonDefinition());
-	    theReactionProduct->SetMomentum(GetMomentum().vect());
-	    theReactionProduct->SetTotalEnergy(GetMomentum().e());
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct = 
+      new G4ReactionProduct(G4Proton::ProtonDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
 #ifdef PRECOMPOUND_TEST
-	    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
 #endif
-	    return theReactionProduct;
-	}
-
+    return theReactionProduct;
+  }
+  
 private:
-    virtual G4double GetAlpha()
-	{
-	    G4double aZ = G4double(GetRestZ());
-	    G4double C = 0.0;
-	    if (aZ >= 70) {
-		C = 0.10;
-	    } else {
-		C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
-	    }
-	    return 1.0 + C;
-	}
-
-    virtual G4double GetBeta()
-	{
-	    return -GetCoulombBarrier();
-	}
-
-    virtual G4bool IsItPossible(const G4Fragment& aFragment)
-	{
-	    return (aFragment.GetNumberOfCharged() >= 1);
-	}
-
+  virtual G4double GetAlpha()
+  {
+    G4double aZ = static_cast<G4double>(GetRestZ());
+    G4double C = 0.0;
+    if (aZ >= 70) 
+      {
+	C = 0.10;
+      } 
+    else 
+      {
+	C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+      }
+    return 1.0 + C;
+  }
 
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
+  
+  virtual G4bool IsItPossible(const G4Fragment& aFragment)
+  {
+    return (aFragment.GetNumberOfCharged() >= 1);
+  }
+  
+  
 private:
-
+  
   G4ProtonCoulombBarrier theProtonCoulombBarrier;
-
+  
 };
 
 #endif

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundTransitions.hh,v 1.8 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundTransitions.hh,v 1.10 2003/05/30 14:05:57 hpw Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
@@ -37,25 +37,27 @@
 // TransitionProb3 => probability of transition with  \Delta N = 0
 //                    number of excitons will be the same
 
+#include "G4VPreCompoundTransitions.hh"
+
 #include "globals.hh"
 #include "G4Fragment.hh"
 #include "G4PreCompoundParameters.hh"
 #include "G4Proton.hh"
 #include "Randomize.hh"
 
-class G4PreCompoundTransitions
+class G4PreCompoundTransitions : public G4VPreCompoundTransitions
 {
 public:
 
   // Calculates transition probabilities with Delta N = +2 (Trans1) -2 (Trans2) and 0 (Trans3)
-  G4PreCompoundTransitions(const G4Fragment & aFragment);
 
-  ~G4PreCompoundTransitions() {}
+  G4PreCompoundTransitions() : TransitionProb1(0.0), TransitionProb2(0.0), TransitionProb3(0.0) {}
+
+  virtual ~G4PreCompoundTransitions() {}
 
 private:
-  G4PreCompoundTransitions() {}
   
-  G4PreCompoundTransitions(const G4PreCompoundTransitions &right) {};
+  G4PreCompoundTransitions(const G4PreCompoundTransitions &) : G4VPreCompoundTransitions() {};
   
   const G4PreCompoundTransitions& operator=(const G4PreCompoundTransitions &right);
 
@@ -64,10 +66,10 @@ private:
   G4bool operator!=(const G4PreCompoundTransitions &right) const;
 
 public:
-  G4double GetTotalProbability(void)
-  { return TransitionProb1+TransitionProb2+TransitionProb3; }
   
-  G4Fragment PerformTransition(const G4Fragment & aFragment);
+  virtual G4double CalculateProbability(const G4Fragment & aFragment);
+  
+  virtual G4Fragment PerformTransition(const G4Fragment & aFragment);
   
 private:
 	

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

@@ -21,98 +21,99 @@
 // ********************************************************************
 //
 //
-// $Id: G4PreCompoundTriton.hh,v 1.12 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4PreCompoundTriton.hh,v 1.13 2003/03/24 13:56:53 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
 #ifndef G4PreCompoundTriton_h
 #define G4PreCompoundTriton_h 1
 
-#include "G4VPreCompoundIon.hh"
+#include "G4PreCompoundIon.hh"
 #include "G4ReactionProduct.hh"
 #include "G4Triton.hh"
 
 #include "G4TritonCoulombBarrier.hh"
 
 
-class G4PreCompoundTriton : public G4VPreCompoundIon
+class G4PreCompoundTriton : public G4PreCompoundIon
 {
 public:
   // default constructor
-  G4PreCompoundTriton():G4VPreCompoundIon(3,1,&theTritonCoulombBarrier,"Triton") {}
+  G4PreCompoundTriton():G4PreCompoundIon(3,1,&theTritonCoulombBarrier,"Triton") {}
 
   // copy constructor
-  G4PreCompoundTriton(const G4PreCompoundTriton &right): G4VPreCompoundIon(right) {}
+  G4PreCompoundTriton(const G4PreCompoundTriton &right): G4PreCompoundIon(right) {}
 
   // destructor
   ~G4PreCompoundTriton() {}
 
   // operators  
   const G4PreCompoundTriton & operator=(const G4PreCompoundTriton &right) {
-    if (&right != this) this->G4VPreCompoundIon::operator=(right);
+    if (&right != this) this->G4PreCompoundIon::operator=(right);
     return *this;
   }
 
   G4bool operator==(const G4PreCompoundTriton &right) const
-  { return G4VPreCompoundIon::operator==(right);}
+  { return G4PreCompoundIon::operator==(right);}
 
   
   G4bool operator!=(const G4PreCompoundTriton &right) const
-  { return G4VPreCompoundIon::operator!=(right);}
+  { return G4PreCompoundIon::operator!=(right);}
 
 
-    G4ReactionProduct * GetReactionProduct() const
-	{
-            G4ReactionProduct * theReactionProduct =
-                new G4ReactionProduct(G4Triton::TritonDefinition());
-            theReactionProduct->SetMomentum(GetMomentum().vect());
-            theReactionProduct->SetTotalEnergy(GetMomentum().e());
+  G4ReactionProduct * GetReactionProduct() const
+  {
+    G4ReactionProduct * theReactionProduct =
+      new G4ReactionProduct(G4Triton::TritonDefinition());
+    theReactionProduct->SetMomentum(GetMomentum().vect());
+    theReactionProduct->SetTotalEnergy(GetMomentum().e());
 #ifdef PRECOMPOUND_TEST
-            theReactionProduct->SetCreatorModel("G4PrecompoundModel");
+    theReactionProduct->SetCreatorModel("G4PrecompoundModel");
 #endif
-            return theReactionProduct;
-        }   
+    return theReactionProduct;
+  }   
     
 private:
-    virtual G4double GetAlpha()
-	{
-	    G4double C = 0.0;
-	    G4double aZ = GetZ() + GetRestZ();
-	    if (aZ >= 70) {
-		C = 0.10;
-	    } else {
-		C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375; 
-	    }
+  virtual G4double GetAlpha()
+  {
+    G4double C = 0.0;
+    G4double aZ = GetZ() + GetRestZ();
+    if (aZ >= 70) 
+      {
+	C = 0.10;
+      } 
+    else 
+      {
+	C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375; 
+      }
  
-	    return 1.0 + C/3.0;
-	}
+    return 1.0 + C/3.0;
+  }
 
-    virtual G4double GetBeta()
-	{
-	    return -GetCoulombBarrier();
-	}
+  virtual G4double GetBeta()
+  {
+    return -GetCoulombBarrier();
+  }
 
-    virtual G4double FactorialFactor(const G4double N, const G4double P)
-	{
-	    return 
-		(N-3.0)*(P-2.0)*(
-		    (((N-2.0)*(P-1.0))/2.0) *(
-			(((N-1.0)*P)/3.0) 
-			)
-		    );
-	}
+  virtual G4double FactorialFactor(const G4double N, const G4double P)
+  {
+    return 
+      (N-3.0)*(P-2.0)*(
+		       (((N-2.0)*(P-1.0))/2.0) *(
+						 (((N-1.0)*P)/3.0) 
+						 )
+		       );
+  }
 
-    virtual G4double CoalescenceFactor(const G4double A)
-	{
-	    return 243.0/(A*A);
-	}    
+  virtual G4double CoalescenceFactor(const G4double A)
+  {
+    return 243.0/(A*A);
+  }    
 private:
 
-    G4TritonCoulombBarrier theTritonCoulombBarrier;
+  G4TritonCoulombBarrier theTritonCoulombBarrier;
 
 };
 
 #endif
- 
-

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

@@ -0,0 +1,67 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+
+// by V. Lara
+
+
+#ifndef G4VPreCompoundEmissionFactory_hh
+#define G4VPreCompoundEmissionFactory_hh
+
+
+#include "G4VPreCompoundFragment.hh"
+#include <vector>
+
+class G4VPreCompoundEmissionFactory
+{
+public:
+  G4VPreCompoundEmissionFactory() : _fragvector(0) {};
+  virtual ~G4VPreCompoundEmissionFactory();
+  
+private:
+  G4VPreCompoundEmissionFactory(const G4VPreCompoundEmissionFactory & ) {};
+  const G4VPreCompoundEmissionFactory & operator=(const G4VPreCompoundEmissionFactory & val);
+  G4bool operator==(const G4VPreCompoundEmissionFactory & val) const;
+  G4bool operator!=(const G4VPreCompoundEmissionFactory & val) const;
+
+public:
+  
+  std::vector<G4VPreCompoundFragment*> * GetFragmentVector();
+
+protected:
+
+  virtual std::vector<G4VPreCompoundFragment*> * CreateFragmentVector() = 0;
+
+private:
+  std::vector<G4VPreCompoundFragment*> * _fragvector;
+
+  struct DeleteFragment 
+  {
+    template<typename T>
+    void operator()(const T* ptr) const
+    {
+      delete ptr;
+    }
+  };
+  
+};
+#endif

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4VPreCompoundFragment.hh,v 1.13 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4VPreCompoundFragment.hh,v 1.15 2003/06/16 17:07:14 gunter Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
@@ -30,7 +30,7 @@
 #define G4VPreCompoundFragment_h 1
 
 #include "G4ios.hh"
-#include "g4std/iomanip"
+#include <iomanip>
 #include "G4ParticleTable.hh"
 #include "G4IonTable.hh"
 #include "G4Fragment.hh"
@@ -49,11 +49,11 @@ protected:
   G4VPreCompoundFragment() {};
     
 public:  
-    // copy constructor
-    G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
+  // copy constructor
+  G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
     
-    // constructor  
-    G4VPreCompoundFragment(const G4double anA, const G4double aZ,
+  // constructor  
+  G4VPreCompoundFragment(const G4double anA, const G4double aZ,
 			 G4VCoulombBarrier * aCoulombBarrier,
 			 const G4String &  aName);
   
@@ -70,47 +70,28 @@ public:
   
   G4int operator!=(const G4VPreCompoundFragment &right) const;
   
-  friend G4std::ostream& 
-  operator<<(G4std::ostream&, const G4VPreCompoundFragment*);
-  friend G4std::ostream& 
-  operator<<(G4std::ostream&, const G4VPreCompoundFragment&);
-    
+  friend std::ostream& 
+  operator<<(std::ostream&, const G4VPreCompoundFragment*);
+  friend std::ostream& 
+  operator<<(std::ostream&, const G4VPreCompoundFragment&);
+  
   // =====================
   // Pure Virtual methods
   // =====================
   virtual G4ReactionProduct * GetReactionProduct() const = 0; 	
   
-protected:
-  virtual G4double 
-  ProbabilityDistributionFunction(const G4double K, 
-				  const G4Fragment & aFragment) = 0;
-    
-public:
-    
   // Initialization method
   void Initialize(const G4Fragment & aFragment);
     
-  // ================================================
   // Methods for calculating the emission probability
-  // ================================================
+  // ------------------------------------------------
   
   // Calculates the total (integrated over kinetic energy) emission
   // probability of a fragment
-  G4double CalcEmissionProbability(const G4Fragment & aFragment);
+  virtual G4double CalcEmissionProbability(const G4Fragment & aFragment) = 0;
   
-  G4double GetKineticEnergy(const G4Fragment & aFragment);
+  virtual G4double GetKineticEnergy(const G4Fragment & aFragment) = 0;
 
-private:	
-  // This method performs integration for probability function over 
-  // fragment kinetic energy
-  G4double IntegrateEmissionProbability(const G4double & Low, 
-					const G4double & Up, 
-					const G4Fragment & aFragment);	
-    
-    // ============================
-    // Data members access methods
-    // ============================
-    
 public:
   inline const G4double GetA() const;
   
@@ -126,6 +107,8 @@ public:
   
   inline const G4double GetMaximalKineticEnergy() const;
   
+  inline const G4double GetEnergyThreshold() const;
+
   inline const G4double GetEmissionProbability() const;
   
   inline const G4double GetNuclearMass() const;
@@ -136,17 +119,23 @@ public:
   
   inline const G4LorentzVector GetMomentum() const;
   
-  inline void SetMomentum(const G4LorentzVector & value);
+  inline void  SetMomentum(const G4LorentzVector & value);
   
-  inline void SetFragmentName(const G4String& aName);
+  inline void  SetFragmentName(const G4String& aName);
   
   inline const G4String GetName() const;
-  
-  
+ 
+  inline void ResetStage();
+
+  inline G4int GetStage() const;
+
+  inline void IncrementStage();
+
+
   // =============
   // Data members
   // =============
-  
+
 private:
   
   G4double theA;
@@ -156,28 +145,25 @@ private:
   G4double theRestNucleusA;
   
   G4double theRestNucleusZ;
-  
+protected:  
   G4double theCoulombBarrier;
-  
+private:
   G4VCoulombBarrier * theCoulombBarrierPtr;
   
   G4double theBindingEnergy;
   
   G4double theMaximalKineticEnergy;
   
+protected:
   G4double theEmissionProbability;
-  
+private:  
   G4LorentzVector theMomentum;
   
   G4String theFragmentName;
-  
+
+  G4int theStage;    
 };
 
 #include "G4VPreCompoundFragment.icc"
 
 #endif
-
-
-
-
-

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4VPreCompoundFragment.icc,v 1.3 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4VPreCompoundFragment.icc,v 1.4 2003/03/24 13:56:55 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
@@ -68,6 +68,12 @@ GetMaximalKineticEnergy() const
 { 
   return theMaximalKineticEnergy;
 }
+
+inline const G4double G4VPreCompoundFragment::
+GetEnergyThreshold() const 
+{ 
+  return theMaximalKineticEnergy - theCoulombBarrier;
+}
     
 inline const G4double G4VPreCompoundFragment::
 GetEmissionProbability() const 
@@ -124,3 +130,18 @@ GetName() const
   return theFragmentName; 
 }
     
+inline void G4VPreCompoundFragment::ResetStage()
+{
+  theStage = 1;
+}
+
+inline G4int G4VPreCompoundFragment::GetStage() const
+{
+  return theStage;
+}
+
+inline void G4VPreCompoundFragment::IncrementStage()
+{
+  theStage++;
+}
+

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4VPreCompoundIon.hh,v 1.11 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4VPreCompoundIon.hh,v 1.12 2003/03/24 13:56:56 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
@@ -41,42 +41,42 @@ protected:
 
 public:
 
-    // copy constructor
-    G4VPreCompoundIon(const G4VPreCompoundIon &right): 
-	G4VPreCompoundFragment(right) {}
+  // copy constructor
+  G4VPreCompoundIon(const G4VPreCompoundIon &right): 
+    G4VPreCompoundFragment(right) {}
     
-    // constructor  
-    G4VPreCompoundIon(const G4double anA, 
-		      const G4double aZ, 
-		      G4VCoulombBarrier* aCoulombBarrier,
-		      const G4String & aName): 
-	G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
+  // constructor  
+  G4VPreCompoundIon(const G4double anA, 
+		    const G4double aZ, 
+		    G4VCoulombBarrier* aCoulombBarrier,
+		    const G4String & aName): 
+    G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
     
-    virtual ~G4VPreCompoundIon() {}
+  virtual ~G4VPreCompoundIon() {}
     
-    // operators  
-    const G4VPreCompoundIon & 
-    operator=(const G4VPreCompoundIon &right) {
-	if (&right != this) this->G4VPreCompoundFragment::operator=(right);
-	return *this;
-    }
+  // operators  
+  const G4VPreCompoundIon & 
+  operator=(const G4VPreCompoundIon &right) {
+    if (&right != this) this->G4VPreCompoundFragment::operator=(right);
+    return *this;
+  }
     
-    G4bool operator==(const G4VPreCompoundIon &right) const 
-	{ return G4VPreCompoundFragment::operator==(right);}
+  G4bool operator==(const G4VPreCompoundIon &right) const 
+  { return G4VPreCompoundFragment::operator==(right);}
     
-    G4bool operator!=(const G4VPreCompoundIon &right) const 
-	{ return G4VPreCompoundFragment::operator!=(right);}
-    
-    virtual G4double ProbabilityDistributionFunction(const G4double eKin,
-						     const G4Fragment& aFragment);
+  G4bool operator!=(const G4VPreCompoundIon &right) const 
+  { return G4VPreCompoundFragment::operator!=(right);}
     
+  virtual G4double ProbabilityDistributionFunction(const G4double eKin,
+						   const G4Fragment& aFragment);
+
 protected:
-    G4bool IsItPossible(const G4Fragment& aFragment) 
-	{
-	    G4int pplus = aFragment.GetNumberOfCharged();   
-	    G4int pneut = aFragment.GetNumberOfParticles()-pplus;
-	    return (pneut >= (GetA()-GetZ()) && pplus >= GetZ());
-	}
+  G4bool IsItPossible(const G4Fragment& aFragment) 
+  {
+    G4int pplus = aFragment.GetNumberOfCharged();   
+    G4int pneut = aFragment.GetNumberOfParticles()-pplus;
+    return (pneut >= (GetA()-GetZ()) && pplus >= GetZ());
+  }
 
   virtual G4double GetAlpha() = 0;
   virtual G4double GetBeta() = 0;

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

@@ -21,8 +21,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4VPreCompoundNucleon.hh,v 1.9 2002/12/12 19:17:32 gunter Exp $
-// GEANT4 tag $Name: geant4-05-01 $
+// $Id: G4VPreCompoundNucleon.hh,v 1.10 2003/03/24 13:56:57 larazb Exp $
+// GEANT4 tag $Name: geant4-05-02 $
 //
 // by V. Lara
 
@@ -46,29 +46,30 @@ public:
     G4VPreCompoundFragment(right) {}
 
   // constructor  
-    G4VPreCompoundNucleon(const G4double anA, 
-			  const G4double aZ, 
-			  G4VCoulombBarrier* aCoulombBarrier,
-			  const G4String & aName): 
-	G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
+  G4VPreCompoundNucleon(const G4double anA, 
+			const G4double aZ, 
+			G4VCoulombBarrier* aCoulombBarrier,
+			const G4String & aName): 
+    G4VPreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
 
-    virtual ~G4VPreCompoundNucleon() {}
+  virtual ~G4VPreCompoundNucleon() {}
 
-    // operators  
-    const G4VPreCompoundNucleon & 
-    operator=(const G4VPreCompoundNucleon &right) {
-	if (&right != this) this->G4VPreCompoundFragment::operator=(right);
-	return *this;
-    }
+  // operators  
+  const G4VPreCompoundNucleon & 
+  operator=(const G4VPreCompoundNucleon &right) {
+    if (&right != this) this->G4VPreCompoundFragment::operator=(right);
+    return *this;
+  }
 
-    G4bool operator==(const G4VPreCompoundNucleon &right) const 
-	{ return G4VPreCompoundFragment::operator==(right);}
+  G4bool operator==(const G4VPreCompoundNucleon &right) const 
+  { return G4VPreCompoundFragment::operator==(right);}
     
-    G4bool operator!=(const G4VPreCompoundNucleon &right) const 
-	{ return G4VPreCompoundFragment::operator!=(right);}
+  G4bool operator!=(const G4VPreCompoundNucleon &right) const 
+  { return G4VPreCompoundFragment::operator!=(right);}
     
-    virtual G4double ProbabilityDistributionFunction(const G4double eKin,
-						     const G4Fragment& aFragment);
+  virtual G4double ProbabilityDistributionFunction(const G4double eKin,
+						   const G4Fragment& aFragment);
+
     
 protected:
   virtual G4double GetAlpha() = 0;

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

@@ -0,0 +1,40 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4VPreCompoundTransitions_hh
+#define G4VPreCompoundTransitions_hh 1
+
+#include "G4Fragment.hh"
+
+class G4VPreCompoundTransitions
+{
+public:
+
+  G4VPreCompoundTransitions() {}
+  virtual ~G4VPreCompoundTransitions() {}
+
+  virtual G4double CalculateProbability(const G4Fragment& aFragment) = 0;
+  virtual G4Fragment PerformTransition(const G4Fragment&  aFragment) = 0;
+
+};
+
+#endif