Import Geant4 2.0.0 source tree

source/processes/hadronic/models/GNUmakefile

@@ -1,4 +1,4 @@
-# $Id: GNUmakefile,v 1.2 1999/11/06 17:29:36 hpw Exp $
+# $Id: GNUmakefile,v 1.5 2000/06/27 15:24:19 gcosmo Exp $
 # --------------------------------------------------------------
 # GNUmakefile for hadronic models library. G.Folger 10-Dec-97
 # --------------------------------------------------------------
@@ -19,10 +19,12 @@ SUBDIRS += generator/quark_gluon_string
 SUBDIRS += generator/string_common
 SUBDIRS += generator/string_fragmentation
 SUBDIRS += generator/util
+SUBDIRS += radiative_decay
 
 SUBLIBS  = G4hadronic_HE G4hadronic_LE G4hadronic_neu G4hadronic_iso
 SUBLIBS += G4hadronic_deex G4hadronic_diffstring G4hadronic_HE_gen G4hadronic_kinetic
-SUBLIBS += G4hadronic_man_gen G4hadronic_preequ G4hadronic_qgstring G4hadronic_string_common
+SUBLIBS += G4hadronic_man_gen G4hadronic_preequ G4hadronic_radioactivedecay
+SUBLIBS += G4hadronic_qgstring G4hadronic_string_common
 SUBLIBS += G4hadronic_stringfrag G4hadronic_util_gen
 
 ifndef G4INSTALL

source/processes/hadronic/models/generator/History

@@ -0,0 +1,21 @@
+$Id: History,v 1.1 1999/01/07 16:11:38 gunter Exp $
+-------------------------------------------------------------------
+
+     =========================================================
+     Geant4 - an Object-Oriented Toolkit for Simulation in HEP
+     =========================================================
+
+               Hadronics/models/Generator History file
+               ---------------------------------------
+This file should be used by G4 developers  to briefly summarize all major
+modifications introduced in the code and keep track of all tags.
+It DOES NOT substitute the  CVS log-message one should put at every
+committal in the CVS repository !
+
+     ----------------------------------------------------------
+     * Reverse chronological order (last date on top), please *
+     ----------------------------------------------------------
+GF 12-May-98: Add more functions to G4Fancy3DNucleus:
+	       doLorentzContraction with algorithm given by Nicolai
+	       give access to all nucleons with a RWTPtrOrederedVector
+              Required a mod to G4Nucleon, ie. add  operator ==

source/processes/hadronic/models/generator/ToDo

@@ -0,0 +1,18 @@
+Known problems/ missing topics
+
+date	 	date	   who	description
+found		fixed
+
+5-Nov 98 		   GF	String models need projectile momentum along +z;
+				G4VPartonStringModel should do this rotation.
+		Nov98           Above is wrong. for the excitation the 
+				transformation to the correct frame is done.		
+				
+5-Nov-98		   GF	G4VPartonStringModel must use momentum corrector
+				Do not forget Nucleus in this.
+		9-Dec98		Done. Nucleon momenta are included by correcting 
+				to sum of strings; these were checked to conserve 
+				E/p. 		
+
+30-Oct			   GF	dtor of G4VPartonStringModel should delete things;
+				Or should derived classes actually do this?

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

@@ -0,0 +1,40 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4AlphaCoulombBarrier.hh,v 1.1 2000/06/09 11:36:49 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+#ifndef G4AlphaCoulombBarrier_h
+#define G4AlphaCoulombBarrier_h 1
+
+#include "G4CoulombBarrier.hh"
+#include "globals.hh"
+
+class G4AlphaCoulombBarrier : public G4CoulombBarrier
+{
+public:
+	G4AlphaCoulombBarrier() : G4CoulombBarrier(4,2) {};
+	~G4AlphaCoulombBarrier() {};
+
+private:
+	G4AlphaCoulombBarrier(const G4AlphaCoulombBarrier & right);
+
+	const G4AlphaCoulombBarrier & operator=(const G4AlphaCoulombBarrier & right);
+	G4bool operator==(const G4AlphaCoulombBarrier & right) const;
+	G4bool operator!=(const G4AlphaCoulombBarrier & right) const;
+  
+private:
+
+	virtual G4double BarrierPenetrationFactor(const G4double aZ) const;
+
+
+};
+
+#endif

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

@@ -0,0 +1,47 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+
+#ifndef G4AlphaEvaporationChannel_h
+#define G4AlphaEvaporationChannel_h 1
+
+#include "G4EvaporationChannel.hh"
+#include "G4AlphaCoulombBarrier.hh"
+#include "G4AlphaEvaporationProbability.hh"
+
+class G4AlphaEvaporationChannel : public G4EvaporationChannel
+{
+public:
+	// only available constructor
+	G4AlphaEvaporationChannel() : G4EvaporationChannel(4,2,
+		&theEvaporationProbability,&theCoulombBarrier) {};
+
+	// destructor
+	~G4AlphaEvaporationChannel() {};
+
+private:
+	const G4AlphaEvaporationChannel & operator=(const G4AlphaEvaporationChannel & right);  
+
+	G4AlphaEvaporationChannel(const G4AlphaEvaporationChannel & right);
+
+
+public:
+	G4bool operator==(const G4AlphaEvaporationChannel & right) const;
+	G4bool operator!=(const G4AlphaEvaporationChannel & right) const;
+
+private:
+
+	G4AlphaCoulombBarrier theCoulombBarrier;
+	
+	G4AlphaEvaporationProbability theEvaporationProbability;
+
+};
+#endif

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

@@ -0,0 +1,56 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999) 
+//
+
+
+
+#ifndef G4AlphaEvaporationProbability_h
+#define G4AlphaEvaporationProbability_h 1
+
+
+#include "G4EvaporationProbability.hh"
+
+
+class G4AlphaEvaporationProbability : public G4EvaporationProbability
+{
+public:
+	// Only available constructor is default constructor
+	G4AlphaEvaporationProbability();
+
+	~G4AlphaEvaporationProbability() {}
+private:  
+	// Copy constructor
+	G4AlphaEvaporationProbability(const G4AlphaEvaporationProbability &right);
+
+	const G4AlphaEvaporationProbability & operator=(const G4AlphaEvaporationProbability &right);
+	G4bool operator==(const G4AlphaEvaporationProbability &right) const;
+	G4bool operator!=(const G4AlphaEvaporationProbability &right) const;
+  
+
+private:
+
+	virtual G4double CalcAlphaParam(const G4Fragment & fragment) const 
+	{ return 1.0 + CCoeficient(G4double(fragment.GetZ()-GetZ()));}
+	
+	virtual G4double CalcBetaParam(const G4Fragment & fragment) const 
+	{ return 0.0; }
+
+	
+	G4double CCoeficient(const G4double aZ) const;
+
+	// Excitation energy levels 
+	G4RWTValVector<G4double> ExcitEnergies;
+	// Spin of excitation energy levels 
+	G4RWTValVector<G4int> ExcitSpins;
+};
+
+
+#endif

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

@@ -0,0 +1,46 @@
+#ifndef G4CameronGilbertPairingCorrections_h
+#define G4CameronGilbertPairingCorrections_h 1
+
+#include "globals.hh"
+
+class G4CameronGilbertPairingCorrections
+{
+private:
+	// Dummy constructor
+	G4CameronGilbertPairingCorrections(G4double dummy);
+	
+	static G4CameronGilbertPairingCorrections theInstance;
+
+
+public:
+	
+	~G4CameronGilbertPairingCorrections() {};
+
+	G4double GetPairingZ(const G4int Z) {
+		if (Z <= ZTableSize && Z > 1) return PairingZTable[Z-1]*MeV;
+		else {
+			G4cerr << "G4CameronGilbertPairingCorrections: out of table for Z = " << Z << G4endl;
+			return 0.0;
+		}
+	}
+	
+	G4double GetPairingN(const G4int N) {
+		if (N <= NTableSize && N > 0) return PairingNTable[N-1]*MeV;
+		else {
+			G4cerr << "G4CameronGilbertPairingCorrections: out of table for N = " << N << G4endl;
+			return 0.0;
+		}
+	}
+	
+	
+	enum  { ZTableSize = 98, NTableSize = 150 };
+private:
+
+
+
+	static G4double PairingZTable[ZTableSize];
+
+	static G4double PairingNTable[NTableSize];
+	
+};
+#endif

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

@@ -0,0 +1,46 @@
+#ifndef G4CameronGilbertShellCorrections_h
+#define G4CameronGilbertShellCorrections_h 1
+
+#include "globals.hh"
+
+class G4CameronGilbertShellCorrections
+{
+private:
+	// Dummy constructor
+	G4CameronGilbertShellCorrections(G4double dummy);
+	
+	static G4CameronGilbertShellCorrections theInstance;
+
+
+public:
+	
+	~G4CameronGilbertShellCorrections() {};
+
+	G4double GetShellZ(const G4int Z) const {
+		if (Z <= ZTableSize && Z > 1) return ShellZTable[Z-1]*MeV;
+		else {
+			G4cerr << "G4CameronGilbertShellCorrections: out of table for Z = " << Z << G4endl;
+			return 0.0;
+		}
+	}
+	
+	G4double GetShellN(const G4int N) const {
+		if (N <= NTableSize && N > 0) return ShellNTable[N-1]*MeV;
+		else {
+			G4cerr << "G4CameronGilbertShellCorrections: out of table for N = " << N << G4endl;
+			return 0.0;
+		}
+	}
+	
+	
+	enum  { ZTableSize = 98, NTableSize = 150 };
+private:
+
+
+
+	static const G4double ShellZTable[ZTableSize];
+
+	static const G4double ShellNTable[NTableSize];
+	
+};
+#endif

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

@@ -0,0 +1,45 @@
+#ifndef G4CameronShellPlusPairingCorrections_h
+#define G4CameronShellPlusPairingCorrections_h 1
+
+#include "globals.hh"
+
+class G4CameronShellPlusPairingCorrections
+{
+private:
+
+	// Dummy constructor
+	G4CameronShellPlusPairingCorrections(G4double dummy);
+
+	static G4CameronShellPlusPairingCorrections theInstance;
+	
+public:
+	
+	~G4CameronShellPlusPairingCorrections() {};
+
+	static G4double GetShellPlusPairingZ(const G4int Z) {
+		if (Z <= TableSize && Z > 1) return SPZTable[Z-1]*MeV;
+		else {
+			G4cerr << "G4CameronShellPlusPairingCorrections: out of table for Z = " << Z << G4endl;
+			return 0.0;
+		}
+	}
+	
+	static G4double GetShellPlusPairingN(const G4int N) {
+		if (N <= TableSize && N > 0) return SPNTable[N-1]*MeV;
+		else {
+			G4cerr << "G4CameronShellPlusPairingCorrections: out of table for N = " << N << G4endl;
+			return 0.0;
+		}
+	}
+	
+		
+	enum  { TableSize = 200 };
+
+private:
+
+	static G4double SPZTable[TableSize];
+
+	static G4double SPNTable[TableSize];
+	
+};
+#endif

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

@@ -0,0 +1,46 @@
+#ifndef G4CameronTruranHilfPairingCorrections_h
+#define G4CameronTruranHilfPairingCorrections_h 1
+
+#include "globals.hh"
+
+class G4CameronTruranHilfPairingCorrections
+{
+private:
+	// Dummy constructor
+	G4CameronTruranHilfPairingCorrections(G4double dummy);
+	
+	static G4CameronTruranHilfPairingCorrections theInstance;
+
+
+public:
+	
+	~G4CameronTruranHilfPairingCorrections() {};
+
+	G4double GetPairingZ(const G4int Z) const {
+		if (Z <= ZTableSize && Z > 1) return PairingZTable[Z-1]*MeV;
+		else {
+			G4cerr << "G4CameronTruranHilfPairingCorrections: out of table for Z = " << Z << G4endl;
+			return 0.0;
+		}
+	}
+	
+	G4double GetPairingN(const G4int N) const {
+		if (N <= NTableSize && N > 0) return PairingNTable[N-1]*MeV;
+		else {
+			G4cerr << "G4CameronTruranHilfPairingCorrections: out of table for N = " << N << G4endl;
+			return 0.0;
+		}
+	}
+	
+	
+	enum  { ZTableSize = 102, NTableSize = 155 };
+private:
+
+
+
+	static const G4double PairingZTable[ZTableSize];
+
+	static const G4double PairingNTable[NTableSize];
+	
+};
+#endif

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

@@ -0,0 +1,47 @@
+#ifndef G4CameronTruranHilfShellCorrections_h
+#define G4CameronTruranHilfShellCorrections_h 1
+
+#include "globals.hh"
+
+class G4CameronTruranHilfShellCorrections
+{
+private:
+	
+	// Dummy constructor
+	G4CameronTruranHilfShellCorrections(G4double dummy);
+	
+	static G4CameronTruranHilfShellCorrections theInstance;
+
+
+public:
+	
+	~G4CameronTruranHilfShellCorrections() {};
+
+	static G4double GetShellZ(const G4int Z) {
+		if (Z <= ZTableSize && Z > 1) return ShellZTable[Z-1]*MeV;
+		else {
+			G4cerr << "G4CameronTruranHilfShellCorrections: out of table for Z = " << Z << G4endl;
+			return 0.0;
+		}
+	}
+	
+	static G4double GetShellN(const G4int N) {
+		if (N <= NTableSize && N > 0) return ShellNTable[N-1]*MeV;
+		else {
+			G4cerr << "G4CameronTruranHilfShellCorrections: out of table for N = " << N << G4endl;
+			return 0.0;
+		}
+	}
+	
+	
+	enum  { ZTableSize = 102, NTableSize = 155 };
+private:
+
+
+
+	static G4double ShellZTable[ZTableSize];
+
+	static G4double ShellNTable[NTableSize];
+	
+};
+#endif

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -128,6 +128,7 @@ private:
 
 
 
+	G4double FissionPairingCorrection(const G4int A, const G4int Z) const;
 
 
 

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

@@ -0,0 +1,48 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4CoulombBarrier.hh,v 1.1 2000/06/09 11:36:52 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+#ifndef G4CoulombBarrier_h
+#define G4CoulombBarrier_h 1
+
+#include "G4VCoulombBarrier.hh"
+#include "globals.hh"
+
+
+class G4CoulombBarrier : public G4VCoulombBarrier
+{
+public:
+	G4CoulombBarrier() : G4VCoulombBarrier(1,0) {};
+	G4CoulombBarrier(const G4int anA,const G4int aZ) :
+									G4VCoulombBarrier(anA,aZ) {};
+	~G4CoulombBarrier() {};
+
+private:
+	G4CoulombBarrier(const G4CoulombBarrier & right);
+
+	const G4CoulombBarrier & operator=(const G4CoulombBarrier & right);
+	G4bool operator==(const G4CoulombBarrier & right) const;
+	G4bool operator!=(const G4CoulombBarrier & right) const;
+  
+public:
+	G4double GetCoulombBarrier(const G4int ARes, const G4int ZRes, 
+									const G4double U) const;
+
+
+private:
+
+	virtual G4double BarrierPenetrationFactor(const G4double aZ) const {return 1.0;}
+
+
+};
+
+#endif

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

@@ -0,0 +1,40 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4DeuteronCoulombBarrier.hh,v 1.1 2000/06/09 11:36:52 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+#ifndef G4DeuteronCoulombBarrier_h
+#define G4DeuteronCoulombBarrier_h 1
+
+#include "G4CoulombBarrier.hh"
+#include "globals.hh"
+
+class G4DeuteronCoulombBarrier : public G4CoulombBarrier
+{
+public:
+	G4DeuteronCoulombBarrier() : G4CoulombBarrier(2,1) {};
+	~G4DeuteronCoulombBarrier() {};
+
+private:
+	G4DeuteronCoulombBarrier(const G4DeuteronCoulombBarrier & right);
+
+	const G4DeuteronCoulombBarrier & operator=(const G4DeuteronCoulombBarrier & right);
+	G4bool operator==(const G4DeuteronCoulombBarrier & right) const;
+	G4bool operator!=(const G4DeuteronCoulombBarrier & right) const;
+  
+private:
+
+	virtual G4double BarrierPenetrationFactor(const G4double aZ) const;
+
+
+};
+
+#endif

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

@@ -0,0 +1,46 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+
+#ifndef G4DeuteronEvaporationChannel_h
+#define G4DeuteronEvaporationChannel_h 1
+
+#include "G4EvaporationChannel.hh"
+#include "G4DeuteronCoulombBarrier.hh"
+#include "G4DeuteronEvaporationProbability.hh"
+
+class G4DeuteronEvaporationChannel : public G4EvaporationChannel
+{
+public:
+	// only available constructor
+	G4DeuteronEvaporationChannel() : G4EvaporationChannel(2,1,
+		&theEvaporationProbability,&theCoulombBarrier) {};
+
+	// destructor
+	~G4DeuteronEvaporationChannel() {};
+
+private:
+	const G4DeuteronEvaporationChannel & operator=(const G4DeuteronEvaporationChannel & right);  
+
+	G4DeuteronEvaporationChannel(const G4DeuteronEvaporationChannel & right);
+
+public:
+	G4bool operator==(const G4DeuteronEvaporationChannel & right) const;
+	G4bool operator!=(const G4DeuteronEvaporationChannel & right) const;
+
+private:
+
+	G4DeuteronCoulombBarrier theCoulombBarrier;
+	
+	G4DeuteronEvaporationProbability theEvaporationProbability;
+
+};
+#endif

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

@@ -0,0 +1,55 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999) 
+//
+
+
+
+#ifndef G4DeuteronEvaporationProbability_h
+#define G4DeuteronEvaporationProbability_h 1
+
+
+#include "G4EvaporationProbability.hh"
+
+
+class G4DeuteronEvaporationProbability : public G4EvaporationProbability
+{
+public:
+	// Only available constructor
+	G4DeuteronEvaporationProbability();
+
+	~G4DeuteronEvaporationProbability() {}
+private:  
+	// Copy constructor
+	G4DeuteronEvaporationProbability(const G4DeuteronEvaporationProbability &right);
+
+	const G4DeuteronEvaporationProbability & operator=(const G4DeuteronEvaporationProbability &right);
+	G4bool operator==(const G4DeuteronEvaporationProbability &right) const;
+	G4bool operator!=(const G4DeuteronEvaporationProbability &right) const;
+  
+
+private:
+
+	virtual G4double CalcAlphaParam(const G4Fragment & fragment) const 
+	{ return 1.0 + CCoeficient(G4double(fragment.GetZ()-GetZ()));}
+	
+	virtual G4double CalcBetaParam(const G4Fragment & fragment) const 
+	{ return 0.0; }
+
+	
+	G4double CCoeficient(const G4double aZ) const;
+
+	// Excitation energy levels 
+	G4RWTValVector<G4double> ExcitEnergies;
+	// Spin of excitation energy levels 
+	G4RWTValVector<G4int> ExcitSpins;
+
+};
+#endif

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -13,16 +13,12 @@
 #include "globals.hh"
 #include "g4rw/tvvector.h"
 #include "g4rw/tpordvec.h"
-
+#include "g4rw/tvordvec.h"
 
 #include "G4ios.hh"
 #include "G4VEvaporation.hh"
 #include "G4VEvaporationChannel.hh"
-#include "G4EvaporationChannel.hh"
-#include "G4CompetitiveFission.hh"
-#include "G4PhotonEvaporation.hh"
 #include "G4Fragment.hh"
-#include "G4NucleiPropertiesTable.hh"
 #include "G4NucleiProperties.hh"
 #include "Randomize.hh"
 
@@ -30,101 +26,28 @@
 class G4Evaporation : public G4VEvaporation
 {
 public:
-  G4Evaporation();
-  ~G4Evaporation();
+	G4Evaporation();
+	G4Evaporation(G4RWTPtrOrderedVector<G4VEvaporationChannel> * aChannelsVector) :
+		theChannels(aChannelsVector),
+		myOwnChannelsVector(false)
+	 {};
+	 
+	~G4Evaporation();
 
 private:
-  G4Evaporation(const G4Evaporation &right);
+	G4Evaporation(const G4Evaporation &right);
 
-  const G4Evaporation & operator=(const G4Evaporation &right);
-  G4bool operator==(const G4Evaporation &right) const;
-  G4bool operator!=(const G4Evaporation &right) const;
+	const G4Evaporation & operator=(const G4Evaporation &right);
+	G4bool operator==(const G4Evaporation &right) const;
+	G4bool operator!=(const G4Evaporation &right) const;
 
 public:
-  G4FragmentVector * BreakItUp(const G4Fragment &theNucleus);
-
+	G4FragmentVector * BreakItUp(const G4Fragment &theNucleus);
+		
 private:
 
-  enum {TotNumberOfChannels = 34,
-	NumberOfFissionChannel = TotNumberOfChannels-2,
-	NumberOfGammaChannel = TotNumberOfChannels-1,
-	NumExcitedStates = 35};
-
-
-
-  // Excitation energy levels for each channel
-  G4RWTValVector<G4double> ExcitEnergyChann00;  // n
-  G4RWTValVector<G4double> ExcitEnergyChann01;  // p
-  G4RWTValVector<G4double> ExcitEnergyChann02;  // deuteron
-  G4RWTValVector<G4double> ExcitEnergyChann03;  // triton
-  G4RWTValVector<G4double> ExcitEnergyChann04;  // He3
-  G4RWTValVector<G4double> ExcitEnergyChann05;  // alpha
-  G4RWTValVector<G4double> ExcitEnergyChann06;  // He5 
-  G4RWTValVector<G4double> ExcitEnergyChann07;  // He6
-  G4RWTValVector<G4double> ExcitEnergyChann08;  // Li5
-  G4RWTValVector<G4double> ExcitEnergyChann09;  // Li5
-  G4RWTValVector<G4double> ExcitEnergyChann10;
-  G4RWTValVector<G4double> ExcitEnergyChann11;
-  G4RWTValVector<G4double> ExcitEnergyChann12;
-  G4RWTValVector<G4double> ExcitEnergyChann13;
-  G4RWTValVector<G4double> ExcitEnergyChann14;
-  G4RWTValVector<G4double> ExcitEnergyChann15;
-  G4RWTValVector<G4double> ExcitEnergyChann16;
-  G4RWTValVector<G4double> ExcitEnergyChann17;
-  G4RWTValVector<G4double> ExcitEnergyChann18;
-  G4RWTValVector<G4double> ExcitEnergyChann19;
-  G4RWTValVector<G4double> ExcitEnergyChann20;
-  G4RWTValVector<G4double> ExcitEnergyChann21;
-  G4RWTValVector<G4double> ExcitEnergyChann22;
-  G4RWTValVector<G4double> ExcitEnergyChann23;
-  G4RWTValVector<G4double> ExcitEnergyChann24;
-  G4RWTValVector<G4double> ExcitEnergyChann25;
-  G4RWTValVector<G4double> ExcitEnergyChann26;
-  G4RWTValVector<G4double> ExcitEnergyChann27;
-  G4RWTValVector<G4double> ExcitEnergyChann28;
-  G4RWTValVector<G4double> ExcitEnergyChann29; 
-  G4RWTValVector<G4double> ExcitEnergyChann30;
-  G4RWTValVector<G4double> ExcitEnergyChann31; 
-
-
-  // Spin of excitation energy levels for each channel
-  G4RWTValVector<G4int> ExcitSpinChann00;
-  G4RWTValVector<G4int> ExcitSpinChann01;
-  G4RWTValVector<G4int> ExcitSpinChann02;
-  G4RWTValVector<G4int> ExcitSpinChann03;
-  G4RWTValVector<G4int> ExcitSpinChann04;
-  G4RWTValVector<G4int> ExcitSpinChann05;
-  G4RWTValVector<G4int> ExcitSpinChann06;
-  G4RWTValVector<G4int> ExcitSpinChann07;
-  G4RWTValVector<G4int> ExcitSpinChann08;
-  G4RWTValVector<G4int> ExcitSpinChann09;
-  G4RWTValVector<G4int> ExcitSpinChann10;
-  G4RWTValVector<G4int> ExcitSpinChann11;
-  G4RWTValVector<G4int> ExcitSpinChann12;
-  G4RWTValVector<G4int> ExcitSpinChann13;
-  G4RWTValVector<G4int> ExcitSpinChann14;
-  G4RWTValVector<G4int> ExcitSpinChann15;
-  G4RWTValVector<G4int> ExcitSpinChann16;
-  G4RWTValVector<G4int> ExcitSpinChann17;
-  G4RWTValVector<G4int> ExcitSpinChann18;
-  G4RWTValVector<G4int> ExcitSpinChann19;
-  G4RWTValVector<G4int> ExcitSpinChann20;
-  G4RWTValVector<G4int> ExcitSpinChann21;
-  G4RWTValVector<G4int> ExcitSpinChann22;
-  G4RWTValVector<G4int> ExcitSpinChann23;
-  G4RWTValVector<G4int> ExcitSpinChann24;
-  G4RWTValVector<G4int> ExcitSpinChann25;
-  G4RWTValVector<G4int> ExcitSpinChann26;
-  G4RWTValVector<G4int> ExcitSpinChann27;
-  G4RWTValVector<G4int> ExcitSpinChann28;
-  G4RWTValVector<G4int> ExcitSpinChann29; 
-  G4RWTValVector<G4int> ExcitSpinChann30;
-  G4RWTValVector<G4int> ExcitSpinChann31;
-
-
-  G4VEvaporationChannel * theChannels[TotNumberOfChannels];
-
-
+	G4bool myOwnChannelsVector;
+	G4RWTPtrOrderedVector<G4VEvaporationChannel> * theChannels;
 };
 
 #endif

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -17,33 +17,43 @@
 #include "G4VEmissionProbability.hh"
 #include "G4EvaporationProbability.hh"
 #include "G4VLevelDensityParameter.hh"
+#include "G4VCoulombBarrier.hh"
 #include "G4EvaporationLevelDensityParameter.hh"
 #include "G4NucleiProperties.hh"
 #include "Randomize.hh"
 #include "G4ParticleTable.hh"
 #include "G4IonTable.hh"
-#include "g4rw/tvvector.h"
+
 
 class G4EvaporationChannel : public G4VEvaporationChannel
 {
 public:
   // only available constructor
-  G4EvaporationChannel(const G4int theGamma,
-		       const G4int theA,
-		       const G4int theZ,
-		       G4RWTValVector<G4double> * theExcitationEnergies,
-		       G4RWTValVector<G4int> * theExcitationSpins);
+  G4EvaporationChannel(const G4int theA, const G4int theZ,
+  								G4VEmissionProbability * aEmissionStrategy,
+								G4VCoulombBarrier * aCoulombBarrier);
 
+public:
   // destructor
   ~G4EvaporationChannel();
   
-private:
+	void SetEmissionStrategy(G4VEmissionProbability * aEmissionStrategy)
+	{theEvaporationProbabilityPtr = aEmissionStrategy;}
+  
+	void SetCoulombBarrierStrategy(G4VCoulombBarrier * aCoulombBarrier)
+	{theCoulombBarrierPtr = aCoulombBarrier;} 
+	
+protected:
   // default constructor
   G4EvaporationChannel() {};
+  
+private:
   // copy constructor
   G4EvaporationChannel(const G4EvaporationChannel & right);
-
+  
+private:
   const G4EvaporationChannel & operator=(const G4EvaporationChannel & right);
+  
 public:
   G4bool operator==(const G4EvaporationChannel & right) const;
   G4bool operator!=(const G4EvaporationChannel & right) const;
@@ -53,12 +63,12 @@ public:
 
   G4FragmentVector * BreakUp(const G4Fragment & theNucleus);
   
-  inline void SetEmissionStrategy(G4VEmissionProbability * aStrategy)
-    {
-      if (MyOwnEvaporationProbability) delete theEvaporationProbabilityPtr;
-      theEvaporationProbabilityPtr = aStrategy;
-      MyOwnEvaporationProbability = false;
-    }
+//   inline void SetEmissionStrategy(G4VEmissionProbability * aStrategy)
+//     {
+//       if (MyOwnEvaporationProbability) delete theEvaporationProbabilityPtr;
+//       theEvaporationProbabilityPtr = aStrategy;
+//       MyOwnEvaporationProbability = false;
+//     }
 
 
   inline void SetLevelDensityParameter(G4VLevelDensityParameter * aLevelDensity)
@@ -68,41 +78,63 @@ public:
       MyOwnLevelDensity = false;
     }
 
-  inline G4double GetLevelDensityParameter(void) const { return LevelDensityParameter;}
+public:
 
+
+  inline G4double GetEmissionProbability(void) const 
+    {return EmissionProbability;}
+
+
+  inline G4double GetMaximalKineticEnergy(void) const 
+    { return MaximalKineticEnergy; }
+
+  // ----------------------
+
+private: 
+
+  // Calculate Binding Energy for separate fragment from nucleus
+  G4double CalcBindingEnergy(const G4int anA, const G4int aZ);
+
+  // Calculate maximal kinetic energy that can be carried by fragment (in MeV)
+  G4double CalcMaximalKineticEnergy(const G4double U);
+
+  // Samples fragment kinetic energy.
+  G4double CalcKineticEnergy(void);
+
+  // This has to be removed and put in Random Generator
+  G4ThreeVector IsotropicVector(const G4double Magnitude  = 1.0);
+
+	G4double PairingCorrection(const G4int A, const G4int Z) const;
+
+
+	// Data Members
+	// ************
 private:
 
   // This data member define the channel. 
   // They are intializated at object creation (constructor) time.
 
-  // Gamma is A_f(2S_f+1) factor, where A_f is fragment atomic number and S_f is fragment spin
-  G4int Gamma;
-
   // Atomic Number
   G4int A;
 
   // Charge
   G4int Z;
 
-  // 
-  G4RWTValVector<G4double> * ExcitationEnergies;
-
-  //
-  G4RWTValVector<G4int> * ExcitationSpins;
-
 
   // For evaporation probability calcualtion
-  G4bool MyOwnEvaporationProbability;
   G4VEmissionProbability * theEvaporationProbabilityPtr;
 
   // For Level Density calculation
   G4bool MyOwnLevelDensity;
   G4VLevelDensityParameter * theLevelDensityPtr;
-  G4double LevelDensityParameter;
+  
+	// For Coulomb Barrier calculation
+	G4VCoulombBarrier * theCoulombBarrierPtr;
+	G4double CoulombBarrier;
 
   //---------------------------------------------------
 
-  // This values depends on the nucleus that is being evaporated.
+  // These values depend on the nucleus that is being evaporated.
   // They are calculated through the Initialize method which takes as parameters 
   // the atomic number, charge and excitation energy of nucleus.
 
@@ -112,87 +144,18 @@ private:
   // Residual Charge
   G4int ZResidual;
 
-  // Coulomb Barrier
-  G4double CoulombBarrier;
-
-  // Binding Energy
-  G4double BindingEnergy;
+//   // Binding Energy
+//   G4double BindingEnergy;
 
+// 	// Level Density Parameter
+// 	G4double LevelDensityParameter;
+	
   // Emission Probability
   G4double EmissionProbability;
 
 
   // Maximal Kinetic Energy that can be carried by fragment
   G4double MaximalKineticEnergy;
-
-
-public:
-  inline G4int GetGamma(void) const
-    {return Gamma;}
-
-  inline G4int GetA(void) const 
-    {return A;}
-
-  inline G4int GetZ(void) const 
-    {return Z;}
-
-  inline G4double GetCoulombBarrier(void) const 
-    {return CoulombBarrier;}
-
-  inline G4double GetBindingEnergy(void) const 
-    {return BindingEnergy;}
-
-  inline G4double GetEmissionProbability(void) const 
-    {return EmissionProbability;}
-
-  inline G4double GetExcitationEnergy(const G4int i) const 
-    {
-      if (ExcitationEnergies != 0 && i < ExcitationEnergies->length()) 
-	return ExcitationEnergies->operator()(i); 
-      else return 0.0;
-    }
-
-  inline G4int GetExcitationSpin(const G4int i) const 
-    {
-      if (ExcitationSpins != 0 && i < ExcitationSpins->length())
-	return ExcitationSpins->operator()(i); 
-      else return 0;
-    }
-
-
-  inline G4double GetMaximalKineticEnergy(void) const 
-    { return MaximalKineticEnergy; }
-
-  // ----------------------
-
-  inline G4int GetResidualA(void) const 
-    { return AResidual; }
-
-  inline G4int GetResidualZ(void) const 
-    { return ZResidual; }
-
-
-
-private: 
-
-  // Coulomb barrier calculation
-  G4double CalcCoulombBarrier(const G4int ARes, const G4int ZRes);
-
-  // Calculate Binding Energy for separate fragment from nucleus
-  G4double CalcBindingEnergy(const G4int anA, const G4int aZ);
-
-  // Calculate maximal kinetic energy that can be carried by fragment (in MeV)
-  G4double CalcMaximalKineticEnergy(const G4double U);
-
-  // Samples fragment kinetic energy (in MeV).
-  G4double CalcKineticEnergy(void);
-
-
-
-
-  // This has to be removed and put in Random Generator
-  G4ThreeVector IsotropicVector(const G4double Magnitude  = 1.0);
-
 };
 
 

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -17,28 +17,40 @@
 
 
 #include "G4VLevelDensityParameter.hh"
+#include "G4CameronTruranHilfShellCorrections.hh"
 
 class G4EvaporationLevelDensityParameter : public G4VLevelDensityParameter
 {
 public:
-  G4EvaporationLevelDensityParameter() :  EvapLevelDensityParameter(0.125*(1./MeV)) {};
-  virtual ~G4EvaporationLevelDensityParameter() {};
+
+	G4EvaporationLevelDensityParameter()  {};
+
+	virtual ~G4EvaporationLevelDensityParameter() {};
 
 private:  
-  G4EvaporationLevelDensityParameter(const G4EvaporationLevelDensityParameter &right);
+	
+	G4EvaporationLevelDensityParameter(const G4EvaporationLevelDensityParameter &right);
 
-  const G4EvaporationLevelDensityParameter & operator=(const G4EvaporationLevelDensityParameter &right);
-  G4bool operator==(const G4EvaporationLevelDensityParameter &right) const;
-  G4bool operator!=(const G4EvaporationLevelDensityParameter &right) const;
+	const G4EvaporationLevelDensityParameter & operator=(const G4EvaporationLevelDensityParameter &right);
+	G4bool operator==(const G4EvaporationLevelDensityParameter &right) const;
+	G4bool operator!=(const G4EvaporationLevelDensityParameter &right) const;
   
 public:
-  G4double LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const 
-    {return EvapLevelDensityParameter;}
+	G4double LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const;
 
 private:
 
-  const G4double EvapLevelDensityParameter;
+	G4double ShellCorrection(const G4int Z, const G4int N) const
+	{ return G4CameronTruranHilfShellCorrections::GetShellZ(Z) + 
+				G4CameronTruranHilfShellCorrections::GetShellN(N);}
+		  		
+private:
 
+	static const G4double ConstEvapLevelDensityParameter;
+	static const G4double alpha;
+	static const G4double beta;
+	static const G4double gamma;
+	static const G4double Bs;
 };
 
 

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -17,43 +17,81 @@
 
 
 #include "G4VEmissionProbability.hh"
-#include "G4EvaporationChannel.hh"
+#include "G4VLevelDensityParameter.hh"
+#include "G4EvaporationLevelDensityParameter.hh"
 
+#include "g4rw/tvvector.h"
 
 class G4EvaporationProbability : public G4VEmissionProbability
 {
 public:
-  // Only available constructor
-  G4EvaporationProbability(G4VEvaporationChannel * aChannel) 
-    { theChannel = aChannel; };
+	// Only available constructor
+	G4EvaporationProbability(const G4int anA, const G4int aZ, const G4double aGamma) : 
+		theA(anA),
+		theZ(aZ),
+		Gamma(aGamma) 
+		{
+			theEvapLDPptr = new G4EvaporationLevelDensityParameter;
+		}
 
-  ~G4EvaporationProbability() {};
-private:  
-  // Default constructor
-  G4EvaporationProbability() {};
+	~G4EvaporationProbability() 
+	{
+		if (theEvapLDPptr != 0) delete theEvapLDPptr;
+	}
 
-  // Copy constructor
-  G4EvaporationProbability(const G4EvaporationProbability &right);
 
-  const G4EvaporationProbability & operator=(const G4EvaporationProbability &right);
-  G4bool operator==(const G4EvaporationProbability &right) const;
-  G4bool operator!=(const G4EvaporationProbability &right) const;
+	
+	G4double GetZ(void) const { return theZ; }
+	
+	G4double GetA(void) const { return theA;} 
+
+protected:
+
+	void SetExcitationEnergiesPtr(G4RWTValVector<G4double> * anExcitationEnergiesPtr) 
+		{ExcitationEnergies = anExcitationEnergiesPtr;}
+
+	void SetExcitationSpinsPtr(G4RWTValVector<G4int> * anExcitationSpinsPtr)
+		{ExcitationSpins = anExcitationSpinsPtr;}
+
+  
+	// Default constructor
+	G4EvaporationProbability() {}
+private:
+	// Copy constructor
+	G4EvaporationProbability(const G4EvaporationProbability &right);
+
+	const G4EvaporationProbability & operator=(const G4EvaporationProbability &right);
+	G4bool operator==(const G4EvaporationProbability &right) const;
+	G4bool operator!=(const G4EvaporationProbability &right) const;
   
 public:
-  G4double EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation);
+	G4double EmissionProbability(const G4Fragment & fragment, const G4double anEnergy);
 
 private:
 
-  G4double DostrovskyApproximation(const G4int A, const G4double U);
-  G4double BotvinaApproximation(const G4int A, const G4double U);
-  G4double NikolaiApproximation(const G4int A, const G4double U);
+	G4double CalcProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy);
+	G4double PairingCorrection(const G4int A, const G4int Z) const;
+	virtual G4double CCoeficient(const G4double aZ) const {return 0.0;};
 
+	virtual G4double CalcAlphaParam(const G4Fragment & fragment) const {return 1.0;}
+	virtual G4double CalcBetaParam(const G4Fragment & fragment) const {return 1.0;}
 
+	// Data Members
 
+	G4VLevelDensityParameter * theEvapLDPptr;
+	
+	G4int theA;
+	G4int theZ;
 
-  G4VEvaporationChannel * theChannel;
+	// Gamma is A_f(2S_f+1) factor, where A_f is fragment atomic 
+	// number and S_f is fragment spin
+	G4double Gamma;
 
+	// Discrete Excitation Energies 
+	G4RWTValVector<G4double> * ExcitationEnergies;
 
+	//
+	G4RWTValVector<G4int> * ExcitationSpins;
 
 };
 

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

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4ExcitationHandler.hh,v 1.3.4.1 1999/12/07 20:51:33 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4ExcitationHandler.hh,v 1.4 1999/12/15 14:52:15 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (May 1998)

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

@@ -1,12 +1,12 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4FissionBarrier.hh,v 1.1.10.1 1999/12/07 20:51:33 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4FissionBarrier.hh,v 1.3 2000/06/09 11:36:52 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
@@ -16,6 +16,7 @@
 
 #include "G4VFissionBarrier.hh"
 #include "globals.hh"
+#include "G4CameronShellPlusPairingCorrections.hh"
 
 class G4FissionBarrier : public G4VFissionBarrier
 {
@@ -31,13 +32,17 @@ private:
   G4bool operator!=(const G4FissionBarrier & right) const;
   
 public:
-  G4double FissionBarrier(const G4int A, const G4int Z);
+  G4double FissionBarrier(const G4int A, const G4int Z, const G4double U);
 
 
 private:
 
   G4double BarashenkovFissionBarrier(const G4int A, const G4int Z);
   
+  G4double SellPlusPairingCorrection(const G4int Z, const G4int N)
+  { return G4CameronShellPlusPairingCorrections::GetShellPlusPairingZ(Z) +
+  			  G4CameronShellPlusPairingCorrections::GetShellPlusPairingN(N); 
+	}
 
 };
 

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -17,24 +17,18 @@
 
 
 #include "G4VEmissionProbability.hh"
-#include "G4VEvaporationChannel.hh"
 #include "G4EvaporationLevelDensityParameter.hh"
 #include "G4FissionLevelDensityParameter.hh"
 
 class G4FissionProbability : public G4VEmissionProbability
 {
 public:
-  // Only available constructor
-  G4FissionProbability(G4VEvaporationChannel * aChannel)
-    { theChannel = aChannel; };
-
+  // Default constructor
+  G4FissionProbability() {};
 
   ~G4FissionProbability() {};  
 
 private:  
-  // Default constructor
-  G4FissionProbability() {};
-
   // Copy constructor
   G4FissionProbability(const G4FissionProbability &right);
 
@@ -43,13 +37,16 @@ private:
   G4bool operator!=(const G4FissionProbability &right) const;
   
 public:
-  G4double EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation);
+	G4double EmissionProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy);
 
 private:
-  G4VEvaporationChannel * theChannel;
+	G4double EvaporationPairingCorrection(const G4int A, const G4int Z) const;
 
-  G4EvaporationLevelDensityParameter theEvapLDP;
-  G4FissionLevelDensityParameter theFissLDP;
+	G4double FissionPairingCorrection(const G4int A, const G4int Z) const;
+
+
+	G4EvaporationLevelDensityParameter theEvapLDP;
+	G4FissionLevelDensityParameter theFissLDP;
 
 
 };

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

@@ -0,0 +1,40 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4He3CoulombBarrier.hh,v 1.1 2000/06/09 11:36:53 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+#ifndef G4He3CoulombBarrier_h
+#define G4He3CoulombBarrier_h 1
+
+#include "G4CoulombBarrier.hh"
+#include "globals.hh"
+
+class G4He3CoulombBarrier : public G4CoulombBarrier
+{
+public:
+	G4He3CoulombBarrier() : G4CoulombBarrier(3,2) {};
+	~G4He3CoulombBarrier() {};
+
+private:
+	G4He3CoulombBarrier(const G4He3CoulombBarrier & right);
+
+	const G4He3CoulombBarrier & operator=(const G4He3CoulombBarrier & right);
+	G4bool operator==(const G4He3CoulombBarrier & right) const;
+	G4bool operator!=(const G4He3CoulombBarrier & right) const;
+  
+private:
+
+	virtual G4double BarrierPenetrationFactor(const G4double aZ) const;
+
+
+};
+
+#endif

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

@@ -0,0 +1,46 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+
+#ifndef G4He3EvaporationChannel_h
+#define G4He3EvaporationChannel_h 1
+
+#include "G4EvaporationChannel.hh"
+#include "G4He3CoulombBarrier.hh"
+#include "G4He3EvaporationProbability.hh"
+
+class G4He3EvaporationChannel : public G4EvaporationChannel
+{
+public:
+	// only available constructor
+	G4He3EvaporationChannel() : G4EvaporationChannel(3,2,
+		&theEvaporationProbability,&theCoulombBarrier) {};
+
+	// destructor
+	~G4He3EvaporationChannel() {};
+
+private:
+	const G4He3EvaporationChannel & operator=(const G4He3EvaporationChannel & right);  
+
+	G4He3EvaporationChannel(const G4He3EvaporationChannel & right);
+
+public:
+	G4bool operator==(const G4He3EvaporationChannel & right) const;
+	G4bool operator!=(const G4He3EvaporationChannel & right) const;
+
+private:
+
+	G4He3CoulombBarrier theCoulombBarrier;
+	
+	G4He3EvaporationProbability theEvaporationProbability;
+
+};
+#endif

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

@@ -0,0 +1,56 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999) 
+//
+
+
+
+#ifndef G4He3EvaporationProbability_h
+#define G4He3EvaporationProbability_h 1
+
+
+#include "G4EvaporationProbability.hh"
+
+
+class G4He3EvaporationProbability : public G4EvaporationProbability
+{
+public:
+	// Only available constructor
+	G4He3EvaporationProbability();
+
+	~G4He3EvaporationProbability() {}
+private:  
+	// Copy constructor
+	G4He3EvaporationProbability(const G4He3EvaporationProbability &right);
+
+	const G4He3EvaporationProbability & operator=(const G4He3EvaporationProbability &right);
+	G4bool operator==(const G4He3EvaporationProbability &right) const;
+	G4bool operator!=(const G4He3EvaporationProbability &right) const;
+  
+
+private:
+
+	virtual G4double CalcAlphaParam(const G4Fragment & fragment) const 
+	{ return 1.0 + CCoeficient(G4double(fragment.GetZ()-GetZ()));}
+	
+	virtual G4double CalcBetaParam(const G4Fragment & fragment) const 
+	{ return 0.0; }
+
+	
+	G4double CCoeficient(const G4double aZ) const;
+
+	// Excitation energy levels 
+	G4RWTValVector<G4double> ExcitEnergies;
+	// Spin of excitation energy levels 
+	G4RWTValVector<G4int> ExcitSpins;
+};
+
+
+#endif

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

@@ -0,0 +1,41 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4NeutronCoulombBarrier.hh,v 1.1 2000/06/09 11:36:53 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+#ifndef G4NeutronCoulombBarrier_h
+#define G4NeutronCoulombBarrier_h 1
+
+#include "G4CoulombBarrier.hh"
+#include "globals.hh"
+
+class G4NeutronCoulombBarrier : public G4CoulombBarrier
+{
+public:
+	G4NeutronCoulombBarrier() : G4CoulombBarrier(1,0) {};
+	~G4NeutronCoulombBarrier() {};
+
+private:
+	G4NeutronCoulombBarrier(const G4NeutronCoulombBarrier & right);
+
+	const G4NeutronCoulombBarrier & operator=(const G4NeutronCoulombBarrier & right);
+	G4bool operator==(const G4NeutronCoulombBarrier & right) const;
+	G4bool operator!=(const G4NeutronCoulombBarrier & right) const;
+  
+private:
+
+	virtual G4double BarrierPenetrationFactor(const G4double aZ) const
+	{ return 1.0;}
+
+
+};
+
+#endif

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

@@ -0,0 +1,46 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+
+#ifndef G4NeutronEvaporationChannel_h
+#define G4NeutronEvaporationChannel_h 1
+
+#include "G4EvaporationChannel.hh"
+#include "G4NeutronCoulombBarrier.hh"
+#include "G4NeutronEvaporationProbability.hh"
+
+class G4NeutronEvaporationChannel : public G4EvaporationChannel
+{
+public:
+	// only available constructor
+	G4NeutronEvaporationChannel() : G4EvaporationChannel(1,0,
+		&theEvaporationProbability,&theCoulombBarrier) {};
+
+	// destructor
+	~G4NeutronEvaporationChannel() {};
+
+private:
+	const G4NeutronEvaporationChannel & operator=(const G4NeutronEvaporationChannel & right);  
+
+	G4NeutronEvaporationChannel(const G4NeutronEvaporationChannel & right);
+
+public:
+	G4bool operator==(const G4NeutronEvaporationChannel & right) const;
+	G4bool operator!=(const G4NeutronEvaporationChannel & right) const;
+
+private:
+
+	G4NeutronCoulombBarrier theCoulombBarrier;
+	
+	G4NeutronEvaporationProbability theEvaporationProbability;
+
+};
+#endif

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

@@ -0,0 +1,54 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999) 
+//
+
+
+
+#ifndef G4NeutronEvaporationProbability_h
+#define G4NeutronEvaporationProbability_h 1
+
+
+#include "G4EvaporationProbability.hh"
+
+
+class G4NeutronEvaporationProbability : public G4EvaporationProbability
+{
+public:
+	// Only available constructor
+	G4NeutronEvaporationProbability();
+		
+	~G4NeutronEvaporationProbability() {}
+private:  
+	// Copy constructor
+	G4NeutronEvaporationProbability(const G4NeutronEvaporationProbability &right);
+
+	const G4NeutronEvaporationProbability & operator=(const G4NeutronEvaporationProbability &right);
+	G4bool operator==(const G4NeutronEvaporationProbability &right) const;
+	G4bool operator!=(const G4NeutronEvaporationProbability &right) const;
+  
+
+private:
+
+	virtual G4double CalcAlphaParam(const G4Fragment & fragment) const 
+	{ return 0.76+2.2/pow(G4double(fragment.GetA()-GetA()),1.0/3.0);}
+	
+	virtual G4double CalcBetaParam(const G4Fragment & fragment) const 
+	{ return (2.12/pow(G4double(fragment.GetA()-GetA()),2.0/3.0) - 0.05)*MeV/CalcAlphaParam(fragment); }
+
+	// Excitation energy levels 
+	G4RWTValVector<G4double> ExcitEnergies;
+	// Spin of excitation energy levels 
+	G4RWTValVector<G4int> ExcitSpins;
+
+};
+
+
+#endif

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

@@ -0,0 +1,40 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4ProtonCoulombBarrier.hh,v 1.1 2000/06/09 11:36:53 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+#ifndef G4ProtonCoulombBarrier_h
+#define G4ProtonCoulombBarrier_h 1
+
+#include "G4CoulombBarrier.hh"
+#include "globals.hh"
+
+class G4ProtonCoulombBarrier : public G4CoulombBarrier
+{
+public:
+	G4ProtonCoulombBarrier() : G4CoulombBarrier(1,1) {};
+	~G4ProtonCoulombBarrier() {};
+
+private:
+	G4ProtonCoulombBarrier(const G4ProtonCoulombBarrier & right);
+
+	const G4ProtonCoulombBarrier & operator=(const G4ProtonCoulombBarrier & right);
+	G4bool operator==(const G4ProtonCoulombBarrier & right) const;
+	G4bool operator!=(const G4ProtonCoulombBarrier & right) const;
+  
+private:
+
+	virtual G4double BarrierPenetrationFactor(const G4double aZ) const;
+
+
+};
+
+#endif

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

@@ -0,0 +1,46 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+
+#ifndef G4ProtonEvaporationChannel_h
+#define G4ProtonEvaporationChannel_h 1
+
+#include "G4EvaporationChannel.hh"
+#include "G4ProtonCoulombBarrier.hh"
+#include "G4ProtonEvaporationProbability.hh"
+
+class G4ProtonEvaporationChannel : public G4EvaporationChannel
+{
+public:
+	// only available constructor
+	G4ProtonEvaporationChannel() : G4EvaporationChannel(1,1,
+		&theEvaporationProbability,&theCoulombBarrier) {};
+
+	// destructor
+	~G4ProtonEvaporationChannel() {};
+
+private:
+	const G4ProtonEvaporationChannel & operator=(const G4ProtonEvaporationChannel & right);  
+
+	G4ProtonEvaporationChannel(const G4ProtonEvaporationChannel & right);
+
+public:
+	G4bool operator==(const G4ProtonEvaporationChannel & right) const;
+	G4bool operator!=(const G4ProtonEvaporationChannel & right) const;
+
+
+private:
+
+	G4ProtonEvaporationProbability  theEvaporationProbability;
+	
+	G4ProtonCoulombBarrier  theCoulombBarrier;
+};
+#endif

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

@@ -0,0 +1,55 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999) 
+//
+
+
+
+#ifndef G4ProtonEvaporationProbability_h
+#define G4ProtonEvaporationProbability_h 1
+
+
+#include "G4EvaporationProbability.hh"
+
+
+class G4ProtonEvaporationProbability : public G4EvaporationProbability
+{
+public:
+	// Only available constructor
+	G4ProtonEvaporationProbability();
+
+	~G4ProtonEvaporationProbability() {}
+private:  
+	// Copy constructor
+	G4ProtonEvaporationProbability(const G4ProtonEvaporationProbability &right);
+
+	const G4ProtonEvaporationProbability & operator=(const G4ProtonEvaporationProbability &right);
+	G4bool operator==(const G4ProtonEvaporationProbability &right) const;
+	G4bool operator!=(const G4ProtonEvaporationProbability &right) const;
+  
+
+private:
+
+	virtual G4double CalcAlphaParam(const G4Fragment & fragment) const 
+	{ return 1.0 + CCoeficient(G4double(fragment.GetZ()-GetZ()));}
+	
+	virtual G4double CalcBetaParam(const G4Fragment & fragment) const 
+	{ return 0.0; }
+
+	
+	G4double CCoeficient(const G4double aZ) const;
+
+	// Excitation energy levels 
+	G4RWTValVector<G4double> ExcitEnergies;
+	// Spin of excitation energy levels 
+	G4RWTValVector<G4int> ExcitSpins;
+
+};
+#endif

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

@@ -0,0 +1,40 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4TritonCoulombBarrier.hh,v 1.1 2000/06/09 11:36:53 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+#ifndef G4TritonCoulombBarrier_h
+#define G4TritonCoulombBarrier_h 1
+
+#include "G4CoulombBarrier.hh"
+#include "globals.hh"
+
+class G4TritonCoulombBarrier : public G4CoulombBarrier
+{
+public:
+	G4TritonCoulombBarrier() : G4CoulombBarrier(3,1) {};
+	~G4TritonCoulombBarrier() {};
+
+private:
+	G4TritonCoulombBarrier(const G4TritonCoulombBarrier & right);
+
+	const G4TritonCoulombBarrier & operator=(const G4TritonCoulombBarrier & right);
+	G4bool operator==(const G4TritonCoulombBarrier & right) const;
+	G4bool operator!=(const G4TritonCoulombBarrier & right) const;
+  
+private:
+
+	virtual G4double BarrierPenetrationFactor(const G4double aZ) const;
+
+
+};
+
+#endif

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

@@ -0,0 +1,46 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+
+#ifndef G4TritonEvaporationChannel_h
+#define G4TritonEvaporationChannel_h 1
+
+#include "G4EvaporationChannel.hh"
+#include "G4TritonCoulombBarrier.hh"
+#include "G4TritonEvaporationProbability.hh"
+
+class G4TritonEvaporationChannel : public G4EvaporationChannel
+{
+public:
+	// only available constructor
+	G4TritonEvaporationChannel() : G4EvaporationChannel(3,1,
+		&theEvaporationProbability,&theCoulombBarrier) {};
+
+	// destructor
+	~G4TritonEvaporationChannel() {};
+
+private:
+	const G4TritonEvaporationChannel & operator=(const G4TritonEvaporationChannel & right);  
+
+	G4TritonEvaporationChannel(const G4TritonEvaporationChannel & right);
+
+public:
+	G4bool operator==(const G4TritonEvaporationChannel & right) const;
+	G4bool operator!=(const G4TritonEvaporationChannel & right) const;
+
+private:
+
+	G4TritonCoulombBarrier theCoulombBarrier;
+	
+	G4TritonEvaporationProbability theEvaporationProbability;
+
+};
+#endif

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

@@ -0,0 +1,56 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999) 
+//
+
+
+
+#ifndef G4TritonEvaporationProbability_h
+#define G4TritonEvaporationProbability_h 1
+
+
+#include "G4EvaporationProbability.hh"
+
+
+class G4TritonEvaporationProbability : public G4EvaporationProbability
+{
+public:
+	// Only available constructor
+	G4TritonEvaporationProbability();
+
+	~G4TritonEvaporationProbability() {}
+private:  
+	// Copy constructor
+	G4TritonEvaporationProbability(const G4TritonEvaporationProbability &right);
+
+	const G4TritonEvaporationProbability & operator=(const G4TritonEvaporationProbability &right);
+	G4bool operator==(const G4TritonEvaporationProbability &right) const;
+	G4bool operator!=(const G4TritonEvaporationProbability &right) const;
+  
+
+private:
+
+	virtual G4double CalcAlphaParam(const G4Fragment & fragment) const 
+	{ return 1.0 + CCoeficient(G4double(fragment.GetZ()-GetZ()));}
+	
+	virtual G4double CalcBetaParam(const G4Fragment & fragment) const 
+	{ return 0.0; }
+
+	G4double CCoeficient(const G4double aZ) const;
+
+	// Excitation energy levels 
+	G4RWTValVector<G4double> ExcitEnergies;
+	// Spin of excitation energy levels 
+	G4RWTValVector<G4int> ExcitSpins;
+
+};
+
+
+#endif

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

@@ -0,0 +1,50 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VCoulombBarrier.hh,v 1.1 2000/06/09 11:36:54 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999)
+
+#ifndef G4VCoulombBarrier_h
+#define G4VCoulombBarrier_h 1
+
+#include "globals.hh"
+
+
+class G4VCoulombBarrier
+{
+public:
+	G4VCoulombBarrier(const G4int anA, const G4int aZ);
+	virtual ~G4VCoulombBarrier() {};
+
+protected:
+	G4VCoulombBarrier() : theA(1),theZ(0) {};
+
+private:
+	G4VCoulombBarrier(const G4VCoulombBarrier & right);
+
+	const G4VCoulombBarrier & operator=(const G4VCoulombBarrier & right);
+	G4bool operator==(const G4VCoulombBarrier & right) const;
+	G4bool operator!=(const G4VCoulombBarrier & right) const;
+  
+public:
+	virtual G4double GetCoulombBarrier(const G4int ARes, const G4int ZRes, 
+												const G4double U) const = 0;
+					
+	G4int GetA(void) const {return theA;}
+	G4int GetZ(void) const {return theZ;}
+					
+private: 
+	
+		G4int theA;
+		G4int theZ;
+
+};
+
+#endif

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -23,7 +23,7 @@ class G4VEmissionProbability
 {
 public:
   G4VEmissionProbability() {};
-  virtual ~G4VEmissionProbability() {}; // *
+  virtual ~G4VEmissionProbability() {};
 
 private:  
   G4VEmissionProbability(const G4VEmissionProbability &right);
@@ -33,7 +33,7 @@ private:
   G4bool operator!=(const G4VEmissionProbability &right) const;
   
 public:
-  virtual G4double EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation) = 0;
+  virtual G4double EmissionProbability(const G4Fragment & fragment, const G4double anEnergy) = 0;
 
 };
 

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

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -38,16 +38,6 @@ public:
   virtual G4double GetEmissionProbability(void) const = 0;
 
 
-
-  virtual inline G4int GetA(void) const { return 0; }
-  virtual inline G4int GetZ(void) const { return 0; }
-  virtual inline G4int GetResidualA(void) const { return 0; }
-  virtual inline G4int GetResidualZ(void) const { return 0; }
-  virtual inline G4int GetGamma(void) const { return 0; }
-  virtual inline G4double GetLevelDensityParameter(void) const { return 0.0; }
-  virtual inline G4double GetCoulombBarrier(void) const { return 0.0; }
-  virtual inline G4double GetMaximalKineticEnergy(void) const  { return 0.0; };
-  virtual inline G4double GetFissionBarrier(void) const { return 0.0;}
 };
 
 

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

@@ -1,12 +1,12 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VFissionBarrier.hh,v 1.1.10.1 1999/12/07 20:51:35 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VFissionBarrier.hh,v 1.3 2000/06/09 11:36:54 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
@@ -31,7 +31,7 @@ private:
   G4bool operator!=(const G4VFissionBarrier & right) const;
   
 public:
-  virtual G4double FissionBarrier(const G4int A, const G4int Z) = 0;
+  virtual G4double FissionBarrier(const G4int A, const G4int Z,const G4double U) = 0;
   
 
 };

source/processes/hadronic/models/generator/de_excitation/src/G4AlphaCoulombBarrier.cc

@@ -0,0 +1,56 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4AlphaCoulombBarrier.cc,v 1.1 2000/06/09 11:43:34 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+
+#include "G4AlphaCoulombBarrier.hh"
+
+G4AlphaCoulombBarrier::G4AlphaCoulombBarrier(const G4AlphaCoulombBarrier & right)
+{
+  G4Exception("G4AlphaCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+
+
+const G4AlphaCoulombBarrier & G4AlphaCoulombBarrier::operator=(const G4AlphaCoulombBarrier & right)
+{
+ G4Exception("G4AlphaCoulombBarrier::operator= meant to not be accessable.");
+ return *this;
+}
+
+G4bool G4AlphaCoulombBarrier::operator==(const G4AlphaCoulombBarrier & right) const 
+{
+ return false;
+}
+
+G4bool G4AlphaCoulombBarrier::operator!=(const G4AlphaCoulombBarrier & right) const 
+{
+ return true;
+}
+
+
+G4double G4AlphaCoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// const G4double Zlist[size]  = {10.0, 20.0, 30.0, 50.0, 70.0};
+	// const G4double Kalpha[size] = {0.68, 0.82, 0.91, 0.97, 0.98};
+	G4double K = 1.0;
+	if (aZ>=70.0) {
+		K = 0.98;
+	} else {
+		K = (((0.23684e-5*aZ) - 0.42143e-3)*aZ + 0.25222e-1)*aZ + 0.46699;
+	}
+	return K;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4AlphaEvaporationChannel.cc

@@ -0,0 +1,37 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+#include "G4AlphaEvaporationChannel.hh"
+
+
+const G4AlphaEvaporationChannel & G4AlphaEvaporationChannel::operator=(const G4AlphaEvaporationChannel & right)
+{
+	G4Exception("G4AlphaEvaporationChannel::operator= meant to not be accessable");
+	return *this;
+}
+
+G4AlphaEvaporationChannel::G4AlphaEvaporationChannel(const G4AlphaEvaporationChannel & right)
+{
+	G4Exception("G4AlphaEvaporationChannel::CopyConstructor meant to not be accessable");
+}
+
+G4bool G4AlphaEvaporationChannel::operator==(const G4AlphaEvaporationChannel & right) const 
+{
+	return (this == (G4AlphaEvaporationChannel *) &right);
+	//  return false;
+}
+
+G4bool G4AlphaEvaporationChannel::operator!=(const G4AlphaEvaporationChannel & right) const 
+{
+	return (this != (G4AlphaEvaporationChannel *) &right);
+	//  return true;
+}
+

source/processes/hadronic/models/generator/de_excitation/src/G4AlphaEvaporationProbability.cc

@@ -0,0 +1,91 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999)
+//
+
+
+#include "G4AlphaEvaporationProbability.hh"
+
+G4AlphaEvaporationProbability::G4AlphaEvaporationProbability() :
+		G4EvaporationProbability(4,2,4) // A,Z,Gamma
+{
+	const G4int NumExcitedStates = 31+1;
+	ExcitEnergies.reshape(NumExcitedStates);
+	ExcitSpins.reshape(NumExcitedStates);
+	for (G4int i = 0; i < NumExcitedStates; i++) {
+		ExcitEnergies(i) = 0.0;
+		ExcitSpins(i) = 0;
+	}
+
+	ExcitEnergies(18) = 7.98*MeV;
+	ExcitEnergies(20) = 6.90*MeV;
+	ExcitEnergies(25) = 5.83*MeV;
+	ExcitEnergies(26) = 8.57*MeV;
+	ExcitEnergies(31) = 5.33*MeV;
+
+	ExcitSpins(18) = 4;
+	ExcitSpins(20) = 6;
+	ExcitSpins(25) = 7;
+	ExcitSpins(26) = 4;
+	ExcitSpins(31) = 13;
+	
+	SetExcitationEnergiesPtr(&ExcitEnergies);
+	SetExcitationSpinsPtr(&ExcitSpins);		
+}
+
+
+G4AlphaEvaporationProbability::G4AlphaEvaporationProbability(const G4AlphaEvaporationProbability &right)
+{
+ G4Exception("G4AlphaEvaporationProbability::copy_constructor meant to not be accessable");
+}
+
+
+
+
+const G4AlphaEvaporationProbability & G4AlphaEvaporationProbability::
+operator=(const G4AlphaEvaporationProbability &right)
+{
+  G4Exception("G4AlphaEvaporationProbability::operator= meant to not be accessable");
+  return *this;
+}
+
+
+G4bool G4AlphaEvaporationProbability::operator==(const G4AlphaEvaporationProbability &right) const
+{
+  return false;
+}
+
+G4bool G4AlphaEvaporationProbability::operator!=(const G4AlphaEvaporationProbability &right) const
+{
+  return true;
+}
+
+G4double G4AlphaEvaporationProbability::CCoeficient(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+	//	G4double Calpha[5] = { 0.10, 0.10, 0.10, 0.08, 0.06};
+	G4double C = 0.0;
+	
+	
+	if (aZ <= 30) {
+		C = 0.10;
+	} else if (aZ <= 50) {
+		C = 0.1 + -((aZ-50.)/20.)*0.02;
+	} else if (aZ < 70) {
+		C = 0.08 + -((aZ-70.)/20.)*0.02;
+	} else {
+		C = 0.06;
+	}
+	return C;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4CameronGilbertPairingCorrections.cc

@@ -0,0 +1,47 @@
+
+#include "G4CameronGilbertPairingCorrections.hh"
+
+
+// Data comes from:
+// A. Gilbert and A.G.W. Cameron, Can. J. Phys., 43, 1446(1965)
+
+// P(Z)
+G4double G4CameronGilbertPairingCorrections::PairingZTable
+[G4CameronGilbertPairingCorrections::ZTableSize] = { 
+0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,
+0.00,  2.46,  0.00,  2.09,  0.00,  1.62,  0.00,  1.62,  0.00,  1.83,
+0.00,  1.73,  0.00,  1.35,  0.00,  1.54,  0.00,  1.20,  0.00,  1.06,
+0.00,  1.36,  0.00,  1.43,  0.00,  1.17,  0.00,  1.24,  0.00,  1.20,  
+0.00,  1.28,  0.00,  1.28,  0.00,  1.35,  0.00,  1.36,  0.00,  1.19,
+0.00,  1.14,  0.00,  1.12,  0.00,  1.58,  0.00,  1.17,  0.00,  1.18,
+0.00,  1.22,  0.00,  0.97,  0.00,  0.92,  0.00,  0.62,  0.00,  0.68,
+0.00,  0.64,  0.00,  0.72,  0.00,  0.75,  0.00,  0.71,  0.00,  0.87,
+0.00,  0.83,  0.00,  0.89,  0.00,  0.79,  0.00,  0.89,  0.00,  0.78,
+0.00,  0.69,  0.00,  0.61,  0.00,  0.72,  0.00,  0.77
+};
+// P(N)
+G4double G4CameronGilbertPairingCorrections::PairingNTable
+[G4CameronGilbertPairingCorrections::NTableSize] = { 
+0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,
+0.00,  2.67,  0.00,  1.80,  0.00,  1.67,  0.00,  1.86,  0.00,  2.04,
+0.00,  1.64,  0.00,  1.44,  0.00,  1.54,  0.00,  1.30,  0.00,  1.27,
+0.00,  1.29,  0.00,  1.41,  0.00,  1.50,  0.00,  1.50,  0.00,  1.43,
+0.00,  1.88,  0.00,  1.47,  0.00,  1.57,  0.00,  1.46,  0.00,  0.93,
+0.00,  0.72,  0.00,  1.12,  0.00,  1.29,  0.00,  0.94,  0.00,  1.24,
+0.00,  1.25,  0.00,  1.14,  0.00,  1.32,  0.00,  1.15,  0.00,  1.24,
+0.00,  1.43,  0.00,  1.09,  0.00,  1.20,  0.00,  1.04,  0.00,  0.70,
+0.00,  0.85,  0.00,  0.76,  0.00,  0.92,  0.00,  0.99,  0.00,  1.10,
+0.00,  0.92,  0.00,  0.73,  0.00,  0.70,  0.00,  0.87,  0.00,  0.61,
+0.00,  0.69,  0.00,  0.55,  0.00,  0.40,  0.00,  0.73,  0.00,  0.58,
+0.00,  0.86,  0.00,  1.13,  0.00,  0.84,  0.00,  0.79,  0.00,  0.82,
+0.00,  0.71,  0.00,  0.41,  0.00,  0.38,  0.00,  0.67,  0.00,  0.61,
+0.00,  0.78,  0.00,  0.67,  0.00,  0.67,  0.00,  0.79,  0.00,  0.60,
+0.00,  0.57,  0.00,  0.49,  0.00,  0.43,  0.00,  0.50,  0.00,  0.39
+};
+
+G4CameronGilbertPairingCorrections G4CameronGilbertPairingCorrections::theInstance(10.0);
+
+G4CameronGilbertPairingCorrections::G4CameronGilbertPairingCorrections(G4double dummy)
+{
+	G4double even_more_dummy = dummy;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4CameronGilbertShellCorrections.cc

@@ -0,0 +1,47 @@
+
+#include "G4CameronGilbertShellCorrections.hh"
+
+
+// Data comes from:
+// A. Gilbert and A.G.W. Cameron, Can. J. Phys., 43, 1446(1965)
+
+// S(Z)
+const G4double G4CameronGilbertShellCorrections::ShellZTable
+[G4CameronGilbertShellCorrections::ZTableSize] = { 
+  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,
+ -2.91, -4.17, -5.72, -7.80, -8.97, -9.70,-10.10,-10.70,-11.38,-12.07,
+-12.55,-13.24,-13.93,-14.71,-15.53,-16.37,-17.36,-18.52,-18.44,-18.19,
+-17.68,-17.09,-16.65,-16.66,-16.59,-16.35,-16.18,-16.41,-16.60,-16.54,
+-16.42,-16.84,-17.22,-17.42,-17.52,-17.82,-18.19,-18.58,-19.11,-19.83,
+-19.14,-18.35,-17.40,-16.54,-15.68,-14.75,-13.71,-12.87,-12.18,-11.61,
+-11.09,-10.78,-10.53,-10.41,-10.21, -9.85, -9.36, -8.97, -8.56, -8.13,
+ -7.68, -7.33, -7.11, -7.16, -7.05, -6.81, -6.56, -6.95, -7.52, -8.03,
+ -8.41, -8.86, -7.71, -6.38, -5.47, -4.78, -4.37, -4.17, -4.12, -4.29,
+ -4.61, -5.04, -5.48, -5.96, -6.40, -6.87, -7.20, -7.74
+};
+// S(N)
+const G4double G4CameronGilbertShellCorrections::ShellNTable
+[G4CameronGilbertShellCorrections::NTableSize] = { // 155
+ 0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,
+ 6.80,  7.53,  7.55,  7.21,  7.44,  8.07,  8.94,  9.81, 10.60, 11.39,
+12.54, 13.68, 14.34, 14.19, 13.83, 13.50, 13.00, 12.13, 12.60, 13.26,
+14.13, 14.92, 15.60, 16.38, 17.08, 17.55, 17.98, 18.33, 18.56, 18.71,
+18.65, 18.55, 18.52, 18.34, 18.01, 17.38, 16.56, 15.62, 14.38, 12.88, 
+13.24, 13.71, 14.40, 15.16, 15.89, 16.43, 16.97, 17.59, 18.08, 18.72,
+19.22, 19.51, 19.73, 19.91, 20.06, 20.16, 20.09, 19.83, 19.41, 19.06,
+18.66, 17.73, 17.03, 16.44, 16.00, 15.33, 14.49, 13.42, 12.28, 11.14,
+10.10,  9.09, 10.00, 10.64, 11.18, 11.70, 12.22, 12.71, 13.05, 12.99,
+12.62, 12.11, 11.66, 11.21, 10.81, 10.38, 10.03,  9.65,  9.38,  8.99,
+ 8.62,  8.33,  8.10,  7.82,  7.56,  7.33,  7.15,  6.83,  6.69,  6.55,
+ 6.53,  6.49,  6.39,  5.82,  5.26,  4.53,  3.83,  3.08,  2.37,  1.72,
+ 1.05,  0.27, -0.69, -1.69, -2.58, -3.16, -1.72, -0.41,  0.71,  1.66,
+ 2.62,  3.22,  3.76,  4.10,  4.46,  4.83,  5.09,  5.18,  5.17,  5.10,
+ 5.05,  5.04,  5.03,  4.99,  4.98,  5.11,  5.27,  5.39,  5.37,  5.30
+};
+
+G4CameronGilbertShellCorrections G4CameronGilbertShellCorrections::theInstance(10.0);
+
+G4CameronGilbertShellCorrections::G4CameronGilbertShellCorrections(G4double dummy)
+{ 
+	G4double even_more_dumy = dummy;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4CameronShellPlusPairingCorrections.cc

@@ -0,0 +1,65 @@
+
+#include "G4CameronShellPlusPairingCorrections.hh"
+
+
+// S(Z)+P(Z) from Tab. 1 from A.G.W. Cameron, Canad. J. Phys., 35(1957)1021
+//                   or Delta M(Z) from Tab. 97 of book [1]
+G4double G4CameronShellPlusPairingCorrections::SPZTable
+[G4CameronShellPlusPairingCorrections::TableSize] = {
+  20.80, 15.80, 21.00, 16.80, 19.80, 16.50, 18.80, 16.50, 18.50, 17.20, //   1 - 10
+  18.26, 15.05, 16.01, 12.04, 13.27, 11.09, 12.17, 10.26, 11.04,  8.41, //  11 - 20 
+   9.79,  7.36,  8.15,  5.63,  5.88,  3.17,  3.32,   .82,  1.83,   .97, //  21 - 30
+   2.33,  1.27,  2.92,  1.61,  2.91,  1.35,  2.40,   .89,  1.74,   .36, //  31
+   0.95, -0.65, -0.04, -1.73, -0.96, -2.87, -2.05, -4.05, -3.40, -5.72, //  41
+  -3.75, -4.13, -2.42, -2.85, -1.01, -1.33,  0.54, -0.02,  1.74,  0.75, //  51
+   2.24,  1.00,  1.98,  0.79,  1.54,  0.39,  1.08,  0.00,  0.78, -0.35, //  61
+   0.58, -0.55,  0.59, -0.61,  0.59, -0.35,  0.32, -0.96, -0.52, -2.08, //  71
+  -2.46, -3.64, -1.55, -0.96,  0.97,  0.88,  2.37,  1.75,  2.72,  1.90, //  81
+   2.55,  1.46,  1.93,  0.86,  1.17,  0.08,  0.39, -0.76, -0.39, -1.51, //  91 - 100
+  -1.17, -2.36, -1.95, -3.06, -2.62, -3.55, -2.95, -3.75, -3.07, -3.79, // 101 - 110
+  -3.06, -3.77, -3.05, -3.78, -3.12, -3.90, -3.35, -4.24, -3.86, -4.92, // 111 - 120
+  -5.06, -6.77, -7.41, -9.18,-10.16,-11.12, -9.76, -9.23, -7.96, -7.65, // 121 - 130
+  // --------- from this point there are not tabulated values -----------------------
+   0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00, // 131 - 140
+   0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00, // 141 - 150
+   0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00, // 151
+   0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00, // 161
+   0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00, // 171
+   0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00, // 181
+   0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00,  0.00  // 191 - 200
+};
+
+// S(N)+P(N) from Tab. 1 from A.G.W. Cameron, Canad. J. Phys., 35(1957)1021
+//                   or Delta M(N) from Tab. 97 of book [1]
+G4double G4CameronShellPlusPairingCorrections::SPNTable
+[G4CameronShellPlusPairingCorrections::TableSize] = {
+  -8.40,-12.90, -8.00, 11.90, -9.20,-12.50,-10.80,-13.60,-11.20,-12.20, //   1 - 10
+ -12.81,-15.40,-13.07,-15.80,-13.81,-14.98,-12.63,-13.76,-11.37,-12.38, //  11 - 20
+  -9.23, -9.65, -7.64, -9.17, -8.05, -9.72, -8.87,-10.76, -8.64, -8.89, //  21 - 30
+  -6.60, -7.13, -4.77, -5.33, -3.06, -3.79, -1.72, -2.79, -0.93, -2.19, //  31
+  -0.52, -1.90, -0.45, -2.20, -1.22, -3.07, -2.42, -4.37, -3.94, -6.08, //  41
+  -4.49, -4.50, -3.14, -2.93, -1.04, -1.36,  0.69,  0.21,  2.11,  1.33, //  51
+   3.29,  2.46,  4.30,  3.32,  4.79,  3.62,  4.97,  3.64,  4.63,  3.07, //  61
+   4.06,  2.49,  3.30,  1.46,  2.06,  0.51,  0.74, -1.18, -1.26, -3.54, //  71
+  -3.97, -5.26, -4.18, -3.71, -2.10, -1.70, -0.08, -0.18,  0.94,  0.27, //  81
+   1.13,  0.08,  0.91, -0.31,  0.49, -0.78,  0.08, -1.15, -0.23, -1.41, //  91 - 100
+  -0.42, -1.55, -0.55, -1.66, -0.66, -1.73, -0.75, -1.74, -0.78, -1.69, // 101 - 110
+  -0.78, -1.60, -0.75, -1.46, -0.67, -1.26, -0.51, -1.04, -0.53, -1.84, // 111 - 120
+  -2.42, -4.52, -4.76, -6.33, -6.76, -7.81, -5.80, -5.37, -3.63, -3.35, // 121 - 130
+  -1.75, -1.88, -0.61, -0.90,  0.09, -0.32,  0.55, -0.13,  0.70, -0.06, // 131 - 140
+   0.49, -0.20,  0.40, -0.22,  0.36, -0.09,  0.58,  0.12,  0.75,  0.15, // 141 - 150
+   0.70,  0.17,  1.11,  0.89,  1.85,  1.62,  2.54,  2.29,  3.20,  2.91, // 151
+   3.84,  3.53,  4.48,  4.15,  5.12,  4.78,  5.75,  5.39,  6.31,  5.91, // 161
+   6.87,  6.33,  7.13,  6.61,  7.30,  6.31,  6.27,  4.83,  4.49,  2.85, // 171
+   2.32,  0.58, -0.11, -0.98,  0.81,  1.77,  3.37,  4.13,  5.60,  6.15, // 181
+   7.29,  7.35,  7.95,  7.67,  8.16,  7.83,  8.31,  8.01,  8.53,  8.27  // 191 - 200
+};
+
+
+
+G4CameronShellPlusPairingCorrections G4CameronShellPlusPairingCorrections::theInstance(10.0);
+
+G4CameronShellPlusPairingCorrections::G4CameronShellPlusPairingCorrections(G4double dummy)
+{
+	G4double even_more_dummy = dummy;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4CameronTruranHilfPairingCorrections.cc

@@ -0,0 +1,52 @@
+
+#include "G4CameronTruranHilfPairingCorrections.hh"
+
+
+
+// Data comes from:
+// J.W. Truran, A.G.W. Cameron, and E. Hilf, 
+// Proc. Int. Conf. on the Properties of Nuclei Far From the Beta-Stability,
+// Leysin, Switzerland, August 31 - September 4, 1970, Vol.1, p. 275
+// S(Z)
+const G4double G4CameronTruranHilfPairingCorrections::PairingZTable
+[G4CameronTruranHilfPairingCorrections::ZTableSize] = { // 102
+ 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 
+-2.200, 0.   ,-2.120, 0.   ,-1.981, 0.   ,-1.491, 0.   ,-1.450, 0.,
+-1.701, 0.   ,-1.344, 0.   ,-1.349, 0.   ,-1.397, 0.   ,-1.311, 0.,
+-1.161, 0.   ,-1.201, 0.   ,-1.449, 0.   ,-1.331, 0.   ,-1.272, 0.,
+-1.198, 0.   ,-1.340, 0.   ,-1.407, 0.   ,-1.287, 0.   ,-1.334, 0.,
+-1.307, 0.   ,-1.128, 0.   ,-1.152, 0.   ,-1.139, 0.   ,-1.138, 0.,
+-1.115, 0.   ,-1.070, 0.   ,-1.096, 0.   ,-1.123, 0.   ,-0.901, 0.,
+-0.933, 0.   ,-0.714, 0.   ,-0.799, 0.   ,-0.840, 0.   ,-0.726, 0.,
+-0.815, 0.   ,-0.715, 0.   ,-0.788, 0.   ,-0.793, 0.   ,-0.663, 0.,
+-0.705, 0.   ,-0.711, 0.   ,-0.561, 0.   ,-0.694, 0.   ,-0.683, 0.,
+-0.501, 0.   ,-0.491
+};
+// S(N)
+const G4double G4CameronTruranHilfPairingCorrections::PairingNTable
+[G4CameronTruranHilfPairingCorrections::NTableSize] = { 
+ 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   ,
+-2.400, 0.   ,-2.358, 0.   ,-2.057, 0.   ,-1.462, 0.   ,-1.592, 0.,
+-1.528, 0.   ,-1.470, 0.   ,-1.310, 0.   ,-1.316, 0.   ,-1.265, 0.,
+-1.279, 0.   ,-1.256, 0.   ,-1.285, 0.   ,-1.440, 0.   ,-1.517, 0.,
+-1.486, 0.   ,-1.456, 0.   ,-1.471, 0.   ,-1.336, 0.   ,-1.341, 0.,
+-1.278, 0.   ,-0.821, 0.   ,-0.814, 0.   ,-1.095, 0.   ,-1.147, 0.,
+-1.295, 0.   ,-1.281, 0.   ,-1.245, 0.   ,-1.197, 0.   ,-1.227, 0.,
+-1.291, 0.   ,-1.254, 0.   ,-1.310, 0.   ,-1.171, 0.   ,-1.092, 0.,
+-1.062, 0.   ,-0.713, 0.   ,-0.822, 0.   ,-0.843, 0.   ,-0.968, 0.,
+-1.117, 0.   ,-0.999, 0.   ,-0.877, 0.   ,-0.844, 0.   ,-0.889, 0.,
+-0.729, 0.   ,-0.706, 0.   ,-0.623, 0.   ,-0.511, 0.   ,-0.773, 0.,
+-0.662, 0.   ,-0.808, 0.   ,-0.889, 0.   ,-0.930, 0.   ,-0.771, 0.,
+-0.751, 0.   ,-0.835, 0.   ,-0.658, 0.   ,-0.607, 0.   ,-0.657, 0.,
+-0.695, 0.   ,-0.457, 0.   ,-0.345, 0.   ,-0.452, 0.   ,-0.648, 0.,
+-0.681, 0.   ,-0.416, 0.   ,-0.545, 0.   ,-0.482, 0.   ,-0.481, 0.,
+-0.611, 0.   ,-0.654, 0.   ,-0.557, 0.
+};
+
+
+G4CameronTruranHilfPairingCorrections  G4CameronTruranHilfPairingCorrections::theInstance(10.0);
+
+G4CameronTruranHilfPairingCorrections::G4CameronTruranHilfPairingCorrections(G4double dummy)
+{
+	G4double even_more_dummy = dummy;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4CameronTruranHilfShellCorrections.cc

@@ -0,0 +1,54 @@
+
+#include "G4CameronTruranHilfShellCorrections.hh"
+
+
+// Data comes from:
+// J.W. Truran, A.G.W. Cameron, and E. Hilf, 
+// Proc. Int. Conf. on the Properties of Nuclei Far From the Beta-Stability,
+// Leysin, Switzerland, August 31 - September 4, 1970, Vol.1, p. 275
+// S(Z)
+G4double G4CameronTruranHilfShellCorrections::ShellZTable
+[G4CameronTruranHilfShellCorrections::ZTableSize] = { // 102
+ 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   ,
+ 2.349, 1.936, 1.596, 1.061, 0.341,-0.040, 0.565, 1.065, 1.536,
+ 1.972, 1.855, 2.043, 1.931, 1.652, 1.347, 0.973, 0.579, 0.159,
+-0.487,-0.192, 0.443, 0.932, 1.387, 1.810, 1.969, 2.067, 2.064,
+ 1.825, 1.539, 1.251, 0.957, 1.128, 1.007, 0.603, 0.013,-0.635,
+-1.258,-1.905,-2.562,-3.266,-4.099,-3.615,-3.171,-2.814,-2.337,
+-1.778,-1.220,-0.694,-0.181, 0.323, 0.624, 0.841, 0.904, 0.906,
+ 0.930, 0.919, 0.934, 0.941, 0.978, 0.982, 1.083, 1.201, 1.281,
+ 1.189, 0.963, 0.781, 0.738, 0.696, 0.119,-0.619,-1.265,-1.898,
+-2.431,-1.326,-0.268, 0.737, 1.451, 2.138, 2.307, 2.221, 2.041,
+ 1.827, 1.239, 0.747, 0.214,-0.263,-0.778,-1.272,-1.800,-2.302,
+-2.846,-3.499,-3.042  
+};
+// S(N)
+G4double G4CameronTruranHilfShellCorrections::ShellNTable
+[G4CameronTruranHilfShellCorrections::NTableSize] = { // 155
+ 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   , 0.   ,
+ 2.439, 1.829, 1.419, 0.746,-0.082,-0.832,-0.960,-1.006,-1.045,
+-1.114,-0.900,-0.081, 0.334, 0.064,-0.639,-1.363,-2.138,-2.987,
+-4.042,-4.001,-3.582,-3.120,-2.677,-2.259,-1.778,-1.315,-0.944,
+-0.599,-0.285,-0.020, 0.121, 0.140, 0.149,-0.001,-0.230,-0.604,
+-1.010,-1.570,-2.466,-3.489,-4.552,-4.214,-3.375,-2.526,-1.725,
+-0.923,-0.164, 0.601, 1.316, 1.947, 2.482, 2.971, 3.398, 3.737,
+ 3.979, 4.183, 4.374, 4.517, 4.605, 4.539, 4.375, 4.043, 3.672,
+ 3.250, 2.776, 2.254, 1.715, 1.151, 0.463,-0.237,-1.031,-1.850,
+-2.722,-1.663,-0.724, 0.035, 0.786, 1.587, 2.145, 2.669, 2.680,
+ 2.488, 2.243, 1.969, 1.778, 1.663, 1.487, 1.325, 1.148, 0.962,
+ 0.843, 0.727, 0.574, 0.436, 0.320, 0.264, 0.397, 0.507, 0.405,
+ 0.346, 0.369, 0.397, 0.403, 0.379, 0.184,-0.226,-0.737,-1.305,
+-1.950,-2.565,-3.126,-3.721,-4.393,-5.082,-5.921,-6.712,-6.853,
+-5.592,-4.413,-3.333,-2.413,-1.582,-0.966,-0.421,-0.123, 0.228,
+ 0.543, 0.874, 1.059, 1.181, 1.186, 1.029, 1.029, 1.153, 1.227,
+ 1.330, 1.449, 1.596, 1.712, 1.851, 1.949, 2.044, 2.155, 2.307,
+ 2.621, 3.096
+};
+
+G4CameronTruranHilfShellCorrections G4CameronTruranHilfShellCorrections::theInstance(10.0);
+
+
+G4CameronTruranHilfShellCorrections::G4CameronTruranHilfShellCorrections(G4double dummy)
+{
+	G4double even_more_dummy = dummy;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4CompetitiveFission.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -18,7 +18,7 @@ G4CompetitiveFission::G4CompetitiveFission()
   theFissionBarrierPtr = new G4FissionBarrier;
   MyOwnFissionBarrier = true;
 
-  theFissionProbabilityPtr = new G4FissionProbability(this);
+  theFissionProbabilityPtr = new G4FissionProbability;
   MyOwnFissionProbability = true;
   
   theLevelDensityPtr = new G4FissionLevelDensityParameter;
@@ -64,150 +64,149 @@ G4bool G4CompetitiveFission::operator!=(const G4CompetitiveFission &right) const
 
 void G4CompetitiveFission::Initialize(const G4Fragment & fragment)
 {
-  G4int anA = fragment.GetA();
-  G4int aZ = fragment.GetZ();
-  G4double ExEnergy = fragment.GetExcitationEnergy();
+	G4int anA = G4int(fragment.GetA());
+	G4int aZ = G4int(fragment.GetZ());
+	G4double ExEnergy = fragment.GetExcitationEnergy() - FissionPairingCorrection(anA,aZ);
+  
 
-  // Calculate Fission Barrier
-  FissionBarrier = theFissionBarrierPtr->FissionBarrier(anA,aZ);
+	// Saddle point excitation energy ---> A = 65
+	// Fission is excluded for A < 65
+	if (anA >= 65 && ExEnergy > 0.0) {
+		FissionBarrier = theFissionBarrierPtr->FissionBarrier(anA,aZ,ExEnergy);
+		MaximalKineticEnergy = ExEnergy - FissionBarrier;
+		LevelDensityParameter = theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
+		FissionProbability = theFissionProbabilityPtr->EmissionProbability(fragment,MaximalKineticEnergy);
+	}
+	else {
+		MaximalKineticEnergy = -1000.0*MeV;
+		LevelDensityParameter = 0.0;
+		FissionProbability = 0.0;
+	}
 
-  // Saddle point excitation energy ---> A = 65
-  // Fission is excluded for A < 65
-  if (anA >= 65) {
-    MaximalKineticEnergy = ExEnergy - FissionBarrier;
-    LevelDensityParameter = theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
-    FissionProbability = theFissionProbabilityPtr->EmissionProbability(fragment,0);
-  }
-  else {
-    MaximalKineticEnergy = -1000.0*MeV;
-    LevelDensityParameter = 0.0;
-    FissionProbability = 0.0;
-  }
-
-  return;
+	return;
 }
 
 
 
 G4FragmentVector * G4CompetitiveFission::BreakUp(const G4Fragment & theNucleus)
 {
+	// Nucleus data
+	// Atomic number of nucleus
+	G4int A = G4int(theNucleus.GetA());
+	// Charge of nucleus
+	G4int Z = G4int(theNucleus.GetZ());
+	//   Excitation energy (in MeV)
+	G4double U = theNucleus.GetExcitationEnergy() - FissionPairingCorrection(A,Z);
+	// Check that U > 0
+	if (U <= 0.0) {
+		G4FragmentVector * theResult = new  G4FragmentVector;
+		theResult->insert(new G4Fragment(theNucleus));
+		return theResult;
+	}
 
-  // Nucleus data
-  //   Excitation energy (in MeV)
-  G4double U = theNucleus.GetExcitationEnergy()/MeV;
-  // Check that U > 0
-  if (U <= 0.0) {
-    G4FragmentVector * theResult = new  G4FragmentVector;
-    theResult->insert(new G4Fragment(theNucleus));
-    return theResult;
-  }
-  // Atomic number of nucleus
-  G4int A = theNucleus.GetA();
-  // Charge of nucleus
-  G4int Z = theNucleus.GetZ();
-  // Atomic Mass of Nucleus (in MeV)
-  G4double M = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A)/MeV;
-  // Nucleus Momentum
-  G4LorentzVector theNucleusMomentum = theNucleus.GetMomentum();
+	// Atomic Mass of Nucleus (in MeV)
+	G4double M = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A)/MeV;
+	// Nucleus Momentum
+	  G4LorentzVector theNucleusMomentum = theNucleus.GetMomentum();
 
-  // Calculate fission parameters
-  G4FissionParameters theParameters(A,Z,U*MeV,FissionBarrier);
+	// Calculate fission parameters
+	G4FissionParameters theParameters(A,Z,U,FissionBarrier);
   
-  // First fragment
-  G4int A1 = 0;
-  G4int Z1 = 0;
-  G4double M1 = 0.0;
+	// First fragment
+	G4int A1 = 0;
+	G4int Z1 = 0;
+	G4double M1 = 0.0;
 
-  // Second fragment
-  G4int A2 = 0;
-  G4int Z2 = 0;
-  G4double M2 = 0.0;
+	// Second fragment
+	G4int A2 = 0;
+	G4int Z2 = 0;
+	G4double M2 = 0.0;
 
-  G4double FragmentsExcitationEnergy = 0.0;
-  G4double FragmentsKineticEnergy = 0.0;
+	G4double FragmentsExcitationEnergy = 0.0;
+	G4double FragmentsKineticEnergy = 0.0;
 
-  G4int Trials = 0;
-  do {
+	G4int Trials = 0;
+	do {
 
-    // First fragment 
-    A1 = FissionAtomicNumber(A,theParameters);
-    Z1 = FissionCharge(A,Z,A1);
-    M1 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z1,A1)/MeV;
+		// First fragment 
+		A1 = FissionAtomicNumber(A,theParameters);
+		Z1 = FissionCharge(A,Z,A1);
+		M1 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z1,A1);
 
 
-    // Second Fragment
-    A2 = A - A1;
-    Z2 = Z - Z1;
-    if (A2 < 1 || Z2 < 0) 
-      G4Exception("G4CompetitiveFission::BreakUp: Can't define second fragment! ");
-    M2 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z2,A2)/MeV;
+		// Second Fragment
+		A2 = A - A1;
+		Z2 = Z - Z1;
+		if (A2 < 1 || Z2 < 0) 
+			G4Exception("G4CompetitiveFission::BreakUp: Can't define second fragment! ");
+		M2 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z2,A2)/MeV;
 
-    // Check that fragment masses are less or equal than total energy
-    //  if (M1 + M2 > theNucleusMomentum.mag()/MeV)
-    if (M1 + M2 > theNucleusMomentum.e()/MeV)
-      G4Exception("G4CompetitiveFission::BreakUp: Fragments Mass > Total Energy");
+		// Check that fragment masses are less or equal than total energy
+		//  if (M1 + M2 > theNucleusMomentum.mag()/MeV)
+		if (M1 + M2 > theNucleusMomentum.e()/MeV)
+			G4Exception("G4CompetitiveFission::BreakUp: Fragments Mass > Total Energy");
 
-    // Maximal Kinetic Energy (available energy for fragments)
-    //  G4double Tmax = theNucleusMomentum.mag()/MeV - M1 - M2;
-    G4double Tmax = M + U - M1 - M2;
+		// Maximal Kinetic Energy (available energy for fragments)
+		//  G4double Tmax = theNucleusMomentum.mag()/MeV - M1 - M2;
+		G4double Tmax = M + U - M1 - M2;
 
-    FragmentsKineticEnergy = FissionKineticEnergy( A , Z,
-						   A1, Z1,
-						   A2, Z2,
-						   U , Tmax,
-						   theParameters);
+		FragmentsKineticEnergy = FissionKineticEnergy( A , Z,
+																	  A1, Z1,
+																	  A2, Z2,
+																	  U , Tmax,
+																	  theParameters);
     
-    // Excitation Energy
-    FragmentsExcitationEnergy = Tmax - FragmentsKineticEnergy;
+		// Excitation Energy
+		FragmentsExcitationEnergy = Tmax - FragmentsKineticEnergy;
     
-  } while (FragmentsExcitationEnergy < 0.0 && Trials++ < 100);
+	} while (FragmentsExcitationEnergy < 0.0 && Trials++ < 100);
   
   
 
-  if (FragmentsExcitationEnergy <= 0.0) 
-    G4Exception("G4CompetitiveFission::BreakItUp: Excitation energy for fragments < 0.0!");
+	if (FragmentsExcitationEnergy <= 0.0) 
+		G4Exception("G4CompetitiveFission::BreakItUp: Excitation energy for fragments < 0.0!");
   
 
-  // while (FragmentsExcitationEnergy < 0 && Trials < 100);
+	// while (FragmentsExcitationEnergy < 0 && Trials < 100);
 
-  // Fragment 1
-  G4double U1 = FragmentsExcitationEnergy * (G4double(A1)/G4double(A));
-  // Fragment 2
-  G4double U2 = FragmentsExcitationEnergy * (G4double(A2)/G4double(A));
+	// Fragment 1
+	G4double U1 = FragmentsExcitationEnergy * (G4double(A1)/G4double(A));
+	// Fragment 2
+	G4double U2 = FragmentsExcitationEnergy * (G4double(A2)/G4double(A));
 
 
-  G4double Pmax = sqrt( 2 * ( ( (M1+U1)*(M2+U2) ) /
-			      ( (M1+U1)+(M2+U2) ) ) * FragmentsKineticEnergy);
+	G4double Pmax = sqrt( 2 * ( ( (M1+U1)*(M2+U2) ) /
+								( (M1+U1)+(M2+U2) ) ) * FragmentsKineticEnergy);
 
-  G4ParticleMomentum momentum1 = IsotropicVector( Pmax );
-  G4ParticleMomentum momentum2( -momentum1 );
+	G4ParticleMomentum momentum1 = IsotropicVector( Pmax );
+	G4ParticleMomentum momentum2( -momentum1 );
 
-  // Perform a Galileo boost for fragments
-  momentum1 += (theNucleusMomentum.boostVector() * (M1+U1));
-  momentum2 += (theNucleusMomentum.boostVector() * (M2+U2));
+	// Perform a Galileo boost for fragments
+	momentum1 += (theNucleusMomentum.boostVector() * (M1+U1));
+	momentum2 += (theNucleusMomentum.boostVector() * (M2+U2));
 
 
-  // Create 4-momentum for first fragment
-  // Warning!! Energy conservation is broken
-  G4LorentzVector FourMomentum1( momentum1 , sqrt(momentum1.mag2() + (M1+U1)*(M1+U1)));
+	// Create 4-momentum for first fragment
+	// Warning!! Energy conservation is broken
+	G4LorentzVector FourMomentum1( momentum1 , sqrt(momentum1.mag2() + (M1+U1)*(M1+U1)));
 
-  // Create 4-momentum for second fragment
-  // Warning!! Energy conservation is broken
-  G4LorentzVector FourMomentum2( momentum2 , sqrt(momentum2.mag2() + (M2+U2)*(M2+U2)));
+	// Create 4-momentum for second fragment
+	// Warning!! Energy conservation is broken
+	G4LorentzVector FourMomentum2( momentum2 , sqrt(momentum2.mag2() + (M2+U2)*(M2+U2)));
 
-  // Create Fragments
-  G4Fragment * Fragment1 = new G4Fragment( A1, Z1, FourMomentum1);
-  if (!Fragment1) G4Exception("G4CompetitiveFission::BreakItUp: Can't create Fragment1! ");
-  G4Fragment * Fragment2 = new G4Fragment( A2, Z2, FourMomentum2);
-  if (!Fragment2) G4Exception("G4CompetitiveFission::BreakItUp: Can't create Fragment2! ");
+	// Create Fragments
+	G4Fragment * Fragment1 = new G4Fragment( A1, Z1, FourMomentum1);
+	if (!Fragment1) G4Exception("G4CompetitiveFission::BreakItUp: Can't create Fragment1! ");
+	G4Fragment * Fragment2 = new G4Fragment( A2, Z2, FourMomentum2);
+	if (!Fragment2) G4Exception("G4CompetitiveFission::BreakItUp: Can't create Fragment2! ");
 
-  // Create Fragment Vector
-  G4FragmentVector * theResult = new G4FragmentVector;
+	// Create Fragment Vector
+	G4FragmentVector * theResult = new G4FragmentVector;
 
-  theResult->insert(Fragment1);
-  theResult->insert(Fragment2);
+	theResult->insert(Fragment1);
+	theResult->insert(Fragment2);
 
-  return theResult;
+	return theResult;
 
 }
 
@@ -217,62 +216,61 @@ G4int G4CompetitiveFission::FissionAtomicNumber(const G4int A, const G4FissionPa
   // Calculates the atomic number of a fission product
 {
 
-  // For Simplicity reading code
-  const G4double A1 = theParam.GetA1();
-  const G4double A2 = theParam.GetA2();
-  const G4double As = theParam.GetAs();
-  const G4double Sigma1 = theParam.GetSigma1();
-  const G4double Sigma2 = theParam.GetSigma2();
-  const G4double SigmaS = theParam.GetSigmaS();
-  const G4double w = theParam.GetW();
+	// For Simplicity reading code
+	const G4double A1 = theParam.GetA1();
+	const G4double A2 = theParam.GetA2();
+	const G4double As = theParam.GetAs();
+	const G4double Sigma1 = theParam.GetSigma1();
+	const G4double Sigma2 = theParam.GetSigma2();
+	const G4double SigmaS = theParam.GetSigmaS();
+	const G4double w = theParam.GetW();
 
   
-  G4double FasymAsym = 2.0*exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) + 
-    exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
+	G4double FasymAsym = 2.0*exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) + 
+								exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
 
-  G4double FsymA1A2 = exp(-((As-(A1+A2))*(As-(A1+A2)))/(2.0*SigmaS*SigmaS));
+	G4double FsymA1A2 = exp(-((As-(A1+A2))*(As-(A1+A2)))/(2.0*SigmaS*SigmaS));
 
 
-  G4double C2A = A2 + 3.72*Sigma2;
-  G4double C2S = As + 3.72*SigmaS;
+	G4double C2A = A2 + 3.72*Sigma2;
+	G4double C2S = As + 3.72*SigmaS;
   
-  G4double C2 = 0.0;
-  if (w > 1000.0 ) C2 = C2S;
-  else if (w < 0.001) C2 = C2A;
-  else C2 =  G4std::max(C2A,C2S);
+	G4double C2 = 0.0;
+	if (w > 1000.0 ) C2 = C2S;
+	else if (w < 0.001) C2 = C2A;
+	else C2 =  G4std::max(C2A,C2S);
 
-  G4double C1 = A-C2;
-  if (C1 < 30.0) {
-    C2 = A-30.0;
-    C1 = 30.0;
-  }
+	G4double C1 = A-C2;
+	if (C1 < 30.0) {
+		C2 = A-30.0;
+		C1 = 30.0;
+	}
 
-  G4double Am1 = (As + A1)/2.0;
-  G4double Am2 = (A1 + A2)/2.0;
+	G4double Am1 = (As + A1)/2.0;
+	G4double Am2 = (A1 + A2)/2.0;
 
-  // Get Mass distributions as sum of symmetric and asymmetric Gasussians
-  G4double Mass1 = MassDistribution(As,A,theParam); 
-  G4double Mass2 = MassDistribution(Am1,A,theParam); 
-  G4double Mass3 = MassDistribution(A1,A,theParam); 
-  G4double Mass4 = MassDistribution(Am2,A,theParam); 
-  G4double Mass5 = MassDistribution(A2,A,theParam); 
-  // get maximal value among Mass1,...,Mass5
-  G4double MassMax = Mass1;
-  if (Mass2 > MassMax) MassMax = Mass2;
-  if (Mass3 > MassMax) MassMax = Mass3;
-  if (Mass4 > MassMax) MassMax = Mass4;
-  if (Mass5 > MassMax) MassMax = Mass5;
+	// Get Mass distributions as sum of symmetric and asymmetric Gasussians
+	G4double Mass1 = MassDistribution(As,A,theParam); 
+	G4double Mass2 = MassDistribution(Am1,A,theParam); 
+	G4double Mass3 = MassDistribution(A1,A,theParam); 
+	G4double Mass4 = MassDistribution(Am2,A,theParam); 
+	G4double Mass5 = MassDistribution(A2,A,theParam); 
+	// get maximal value among Mass1,...,Mass5
+	G4double MassMax = Mass1;
+	if (Mass2 > MassMax) MassMax = Mass2;
+	if (Mass3 > MassMax) MassMax = Mass3;
+	if (Mass4 > MassMax) MassMax = Mass4;
+	if (Mass5 > MassMax) MassMax = Mass5;
 
-  // Sample a fragment mass number, which lies between C1 and C2
-  G4double m;
-  G4double Pm;
-  do {
-    m = C1+G4UniformRand()*(C2-C1);
-    Pm = MassDistribution(m,A,theParam); 
-  } while (G4UniformRand() > Pm/MassMax);
+	// Sample a fragment mass number, which lies between C1 and C2
+	G4double m;
+	G4double Pm;
+	do {
+		m = C1+G4UniformRand()*(C2-C1);
+		Pm = MassDistribution(m,A,theParam); 
+	} while (G4UniformRand() > Pm/MassMax);
 
-  //  return static_cast<G4int>(m+0.5);
-  return G4int(m+0.5);
+	return G4int(m+0.5);
 }
 
 
@@ -281,14 +279,14 @@ G4int G4CompetitiveFission::FissionAtomicNumber(const G4int A, const G4FissionPa
 
 
 G4double G4CompetitiveFission::MassDistribution(const G4double x, const G4double A, 
-						const G4FissionParameters & theParam)
-  // This method gives mass distribution F(x) = F_{asym}(x)+w*F_{sym}(x)
-  // which consist of symmetric and asymmetric sum of gaussians components.
+																const G4FissionParameters & theParam)
+	// This method gives mass distribution F(x) = F_{asym}(x)+w*F_{sym}(x)
+	// which consist of symmetric and asymmetric sum of gaussians components.
 {
-  G4double Xsym = exp(-0.5*(x-theParam.GetAs())*(x-theParam.GetAs())/
-		      (theParam.GetSigmaS()*theParam.GetSigmaS()));
+	G4double Xsym = exp(-0.5*(x-theParam.GetAs())*(x-theParam.GetAs())/
+							(theParam.GetSigmaS()*theParam.GetSigmaS()));
 
-  G4double Xasym = exp(-0.5*(x-theParam.GetA2())*(x-theParam.GetA2())/
+	G4double Xasym = exp(-0.5*(x-theParam.GetA2())*(x-theParam.GetA2())/
 		       (theParam.GetSigma2()*theParam.GetSigma2())) + 
     exp(-0.5*(x-(A-theParam.GetA2()))*(x-(A-theParam.GetA2()))/
 	(theParam.GetSigma2()*theParam.GetSigma2())) +
@@ -297,123 +295,122 @@ G4double G4CompetitiveFission::MassDistribution(const G4double x, const G4double
     0.5*exp(-0.5*(x-(A-theParam.GetA1()))*(x-(A-theParam.GetA1()))/
 	    (theParam.GetSigma1()*theParam.GetSigma1()));
 
-  if (theParam.GetW() > 1000) return Xsym;
-  else if (theParam.GetW() < 0.001) return Xasym;
-  else return theParam.GetW()*Xsym+Xasym;
+	if (theParam.GetW() > 1000) return Xsym;
+	else if (theParam.GetW() < 0.001) return Xasym;
+	else return theParam.GetW()*Xsym+Xasym;
 }
 
 
 
 
 G4int G4CompetitiveFission::FissionCharge(const G4double A,
-					  const G4double Z,
-					  const G4double Af)
+														const G4double Z,
+					 									const G4double Af)
   // Calculates the charge of a fission product for a given atomic number Af
 {
-  const G4double sigma = 0.6;
-  G4double DeltaZ = 0.0;
-  if (Af >= 134.0) DeltaZ = -0.45;                    //                      134 <= Af
-  else if (A <= (A-134.0)) DeltaZ = 0.45;             // Af <= (A-134) 
-  else DeltaZ = -0.45*(Af-(A/2.0))/(134.0-(A/2.0));   //       (A-134) < Af < 134
+	const G4double sigma = 0.6;
+	G4double DeltaZ = 0.0;
+	if (Af >= 134.0) DeltaZ = -0.45;                    //                      134 <= Af
+	else if (A <= (A-134.0)) DeltaZ = 0.45;             // Af <= (A-134) 
+	else DeltaZ = -0.45*(Af-(A/2.0))/(134.0-(A/2.0));   //       (A-134) < Af < 134
 
-  G4double Zmean = (Af/A)*Z + DeltaZ;
+	G4double Zmean = (Af/A)*Z + DeltaZ;
  
-  G4double theZ;
-  do {
-    theZ = RandGauss::shoot(Zmean,sigma);
-  } while (theZ  < 1.0 || theZ > (Z-1.0) || theZ > Af);
-  //  return static_cast<G4int>(theZ+0.5);
-  return G4int(theZ+0.5);
+	G4double theZ;
+	do {
+		theZ = RandGauss::shoot(Zmean,sigma);
+	} while (theZ  < 1.0 || theZ > (Z-1.0) || theZ > Af);
+	//  return static_cast<G4int>(theZ+0.5);
+	return G4int(theZ+0.5);
 }
 
 
 
 
 G4double G4CompetitiveFission::FissionKineticEnergy(const G4double A, const G4double Z,
-						    const G4double Af1, const G4double Zf1,
-						    const G4double Af2, const G4double Zf2,
-						    const G4double U, const G4double Tmax,
-						    const G4FissionParameters & theParam)
+						    										 const G4double Af1, const G4double Zf1,
+						    										 const G4double Af2, const G4double Zf2,
+						   										 const G4double U, const G4double Tmax,
+						    										 const G4FissionParameters & theParam)
   // Gives the kinetic energy of fission products
 {
+	// Find maximal value of A for fragments
+	G4double AfMax = G4std::max(Af1,Af2);
+	if (AfMax < (A/2.0)) AfMax = A - AfMax;
 
-  // Find maximal value of A for fragments
-  G4double AfMax = G4std::max(Af1,Af2);
-  if (AfMax < (A/2.0)) AfMax = A - AfMax;
+	// Weights for symmetric and asymmetric components
+	G4double Pas;
+	if (theParam.GetW() > 1000) Pas = 0.0;
+	else {
+		G4double P1 = 0.5*exp(-0.5*(AfMax-theParam.GetA1())*(AfMax-theParam.GetA1())/
+							(theParam.GetSigma1()*theParam.GetSigma1()));
 
-  // Weights for symmetric and asymmetric components
-  G4double Pas;
-  if (theParam.GetW() > 1000) Pas = 0.0;
-  else {
-    G4double P1 = 0.5*exp(-0.5*(AfMax-theParam.GetA1())*(AfMax-theParam.GetA1())/
-			  (theParam.GetSigma1()*theParam.GetSigma1()));
+		G4double P2 = exp(-0.5*(AfMax-theParam.GetA2())*(AfMax-theParam.GetA2())/
+							(theParam.GetSigma2()*theParam.GetSigma2()));
 
-    G4double P2 = exp(-0.5*(AfMax-theParam.GetA2())*(AfMax-theParam.GetA2())/
-		      (theParam.GetSigma2()*theParam.GetSigma2()));
-
-    Pas = P1+P2;
-  }
+		Pas = P1+P2;
+	}
 
 
-  G4double Ps;
-  if (theParam.GetW() < 0.001) Ps = 0.0;
-  else 
-    Ps = theParam.GetW()*exp(-0.5*(AfMax-theParam.GetAs())*(AfMax-theParam.GetAs())/
-			     (theParam.GetSigmaS()*theParam.GetSigmaS()));
+	G4double Ps;
+	if (theParam.GetW() < 0.001) Ps = 0.0;
+	else 
+		Ps = theParam.GetW()*exp(-0.5*(AfMax-theParam.GetAs())*(AfMax-theParam.GetAs())/
+				(theParam.GetSigmaS()*theParam.GetSigmaS()));
  
 
 
-  G4double Psy = Ps/(Pas+Ps);
+	G4double Psy = Ps/(Pas+Ps);
 
 
-  // Fission fractions Xsy and Xas formed in symmetric and asymmetric modes
-  G4double PPas = theParam.GetSigma1() + 2.0 * theParam.GetSigma2();
-  G4double PPsy = theParam.GetW() * theParam.GetSigmaS();
-  G4double Xas = PPas / (PPas+PPsy);
-  G4double Xsy = PPsy / (PPas+PPsy);
+	// Fission fractions Xsy and Xas formed in symmetric and asymmetric modes
+	G4double PPas = theParam.GetSigma1() + 2.0 * theParam.GetSigma2();
+	G4double PPsy = theParam.GetW() * theParam.GetSigmaS();
+	G4double Xas = PPas / (PPas+PPsy);
+	G4double Xsy = PPsy / (PPas+PPsy);
 
 
-  // Average kinetic energy for symmetric and asymmetric components
-  G4double Eaverage = 0.1071*(Z*Z)/pow(A,1.0/3.0) + 22.2;
+	// Average kinetic energy for symmetric and asymmetric components
+	G4double Eaverage = 0.1071*MeV*(Z*Z)/pow(A,1.0/3.0) + 22.2*MeV;
 
 
-  // Compute maximal average kinetic energy of fragments and Energy Dispersion (sqrt)
-  G4double TaverageAfMax;
-  G4double ESigma;
-  // Select randomly fission mode (symmetric or asymmetric)
-  if (G4UniformRand() > Psy) { // Asymmetric Mode
-    G4double A11 = theParam.GetA1()-0.7979*theParam.GetSigma1();
-    G4double A12 = theParam.GetA1()+0.7979*theParam.GetSigma1();
-    G4double A21 = theParam.GetA2()-0.7979*theParam.GetSigma2();
-    G4double A22 = theParam.GetA2()+0.7979*theParam.GetSigma2();
-    // scale factor
-    G4double ScaleFactor = 0.5*theParam.GetSigma1()*(AsymmetricRatio(A,A11)+AsymmetricRatio(A,A12))+
-      theParam.GetSigma2()*(AsymmetricRatio(A,A21)+AsymmetricRatio(A,A22));
-    // Compute average kinetic energy for fragment with AfMax
-    TaverageAfMax = (Eaverage + 12.5 * Xsy) * (PPas/ScaleFactor) * AsymmetricRatio(A,AfMax);
-    ESigma = 10.0; // MeV
+	// Compute maximal average kinetic energy of fragments and Energy Dispersion (sqrt)
+	G4double TaverageAfMax;
+	G4double ESigma;
+	// Select randomly fission mode (symmetric or asymmetric)
+	if (G4UniformRand() > Psy) { // Asymmetric Mode
+		G4double A11 = theParam.GetA1()-0.7979*theParam.GetSigma1();
+		G4double A12 = theParam.GetA1()+0.7979*theParam.GetSigma1();
+		G4double A21 = theParam.GetA2()-0.7979*theParam.GetSigma2();
+		G4double A22 = theParam.GetA2()+0.7979*theParam.GetSigma2();
+		// scale factor
+		G4double ScaleFactor = 0.5*theParam.GetSigma1()*(AsymmetricRatio(A,A11)+AsymmetricRatio(A,A12))+
+										theParam.GetSigma2()*(AsymmetricRatio(A,A21)+AsymmetricRatio(A,A22));
+		// Compute average kinetic energy for fragment with AfMax
+		TaverageAfMax = (Eaverage + 12.5 * Xsy) * (PPas/ScaleFactor) * AsymmetricRatio(A,AfMax);
+		ESigma = 10.0*MeV; // MeV
 
-  } else { // Symmetric Mode
-    G4double As0 = theParam.GetAs() + 0.7979*theParam.GetSigmaS();
-    // scale factor
-    G4double ScaleFactor = theParam.GetW()*theParam.GetSigmaS()*SymmetricRatio(A,As0);
-    // Compute average kinetic energy for fragment with AfMax
-    TaverageAfMax = (Eaverage - 12.5*Xas) * (PPsy/ScaleFactor) * SymmetricRatio(A,AfMax);
-    ESigma = 8.0; // MeV
+	} else { // Symmetric Mode
+		G4double As0 = theParam.GetAs() + 0.7979*theParam.GetSigmaS();
+		// scale factor
+		G4double ScaleFactor = theParam.GetW()*theParam.GetSigmaS()*SymmetricRatio(A,As0);
+		// Compute average kinetic energy for fragment with AfMax
+		TaverageAfMax = (Eaverage - 12.5*MeV*Xas) * (PPsy/ScaleFactor) * SymmetricRatio(A,AfMax);
+		ESigma = 8.0*MeV;
   }
 
 
-  // Select randomly, in accordance with Gaussian distribution, fragment kinetic energy
-  G4double KineticEnergy;
-  G4int i = 0;
-  do {
-    KineticEnergy = RandGauss::shoot(TaverageAfMax,ESigma);
-    if (i++ > 100) return Eaverage;
-  } while (KineticEnergy < Eaverage-3.72*ESigma || 
-	   KineticEnergy > Eaverage+3.72*ESigma ||
-	   KineticEnergy > Tmax);
+	// Select randomly, in accordance with Gaussian distribution, fragment kinetic energy
+	G4double KineticEnergy;
+	G4int i = 0;
+	do {
+		KineticEnergy = RandGauss::shoot(TaverageAfMax,ESigma);
+		if (i++ > 100) return Eaverage;
+	} while (KineticEnergy < Eaverage-3.72*ESigma || 
+				KineticEnergy > Eaverage+3.72*ESigma ||
+				KineticEnergy > Tmax);
 
-  return KineticEnergy;
+	return KineticEnergy;
 }
 
 
@@ -422,24 +419,24 @@ G4double G4CompetitiveFission::FissionKineticEnergy(const G4double A, const G4do
 
 G4double G4CompetitiveFission::AsymmetricRatio(const G4double A,const G4double A11)
 {
-  const G4double B1 = 23.5;
-  const G4double A00 = 134.0;
-  return Ratio(A,A11,B1,A00);
+	const G4double B1 = 23.5;
+	const G4double A00 = 134.0;
+	return Ratio(A,A11,B1,A00);
 }
 
 G4double G4CompetitiveFission::SymmetricRatio(const G4double A,const G4double A11)
 {
-  const G4double B1 = 5.32;
-  const G4double A00 = A/2.0;
-  return Ratio(A,A11,B1,A00);
+	const G4double B1 = 5.32;
+	const G4double A00 = A/2.0;
+	return Ratio(A,A11,B1,A00);
 }
 
 G4double G4CompetitiveFission::Ratio(const G4double A,const G4double A11,
 				     const G4double B1,const G4double A00) 
 {
-  if (A == 0) G4Exception("G4CompetitiveFission::Ratio: A == 0!");
-  if (A11 >= A/2.0 && A11 <= (A00+10.0)) return 1.0-B1*((A11-A00)/A)*((A11-A00)/A);
-  else return 1.0-B1*(10.0/A)*(10.0/A)-2.0*(10.0/A)*B1*((A11-A00-10.0)/A);
+	if (A == 0) G4Exception("G4CompetitiveFission::Ratio: A == 0!");
+	if (A11 >= A/2.0 && A11 <= (A00+10.0)) return 1.0-B1*((A11-A00)/A)*((A11-A00)/A);
+	else return 1.0-B1*(10.0/A)*(10.0/A)-2.0*(10.0/A)*B1*((A11-A00-10.0)/A);
 }
 
 
@@ -458,3 +455,12 @@ G4ThreeVector G4CompetitiveFission::IsotropicVector(const G4double Magnitude)
                        Magnitude*CosTheta);
   return Vector;
 }
+
+G4double G4CompetitiveFission::FissionPairingCorrection(const G4int A, const G4int Z) const
+{
+	const G4double PairingConstant = 14.0*MeV;
+	const G4int N = A - Z;
+	G4double Pair = (1.0 - G4double(Z) + 2.0*(Z/2)) + (1.0 - G4double(N) + 2.0*(N/2));
+	G4double PCorrection = Pair*PairingConstant/sqrt(G4double(A));
+	return PCorrection;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4CoulombBarrier.cc

@@ -0,0 +1,74 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4CoulombBarrier.cc,v 1.1 2000/06/09 11:43:35 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+
+#include "G4CoulombBarrier.hh"
+#include "g4std/strstream"
+
+G4CoulombBarrier::G4CoulombBarrier(const G4CoulombBarrier & right)
+{
+  G4Exception("G4CoulombBarrier::copy_constructor meant to not be accessable.");
+}
+
+
+const G4CoulombBarrier & G4CoulombBarrier::operator=(const G4CoulombBarrier & right)
+{
+ G4Exception("G4CoulombBarrier::operator= meant to not be accessable.");
+ return *this;
+}
+
+G4bool G4CoulombBarrier::operator==(const G4CoulombBarrier & right) const 
+{
+ return false;
+}
+
+G4bool G4CoulombBarrier::operator!=(const G4CoulombBarrier & right) const 
+{
+ return true;
+}
+
+
+
+G4double G4CoulombBarrier::GetCoulombBarrier(const G4int ARes, const G4int ZRes, const G4double U) const 
+  // Calculation of Coulomb potential energy (barrier) for outgoing fragment
+{
+	G4double Barrier = 0.0;
+	if (ZRes > ARes || ARes < 1) {
+		char errMessage[1024];
+		G4std::ostrstream errOs(errMessage,1024);
+		errOs << "G4CoulombBarrier::GetCoulombBarrier: ";
+		errOs << "Wrong values for ";
+		errOs << "residual nucleus A = " << ARes << " ";
+		errOs << "and residual nucleus Z = " << ZRes << G4endl;
+		G4Exception(errMessage);
+	}
+	if (GetA() == 1 && GetZ() == 0) {
+		Barrier = 0.0;   // Neutron Coulomb Barrier is 0
+	} else {
+		G4double CompoundRadius = 2.173*fermi*(1.0+0.006103*G4double(GetZ())*G4double(ZRes))/
+										(1.0+0.009443*G4double(GetZ())*G4double(ZRes));
+		Barrier = elm_coupling/CompoundRadius * G4double(GetZ())*G4double(ZRes)/
+							(pow(G4double(GetA()),1./3.) + pow(G4double(ARes),1./3.));
+
+		// Barrier penetration coeficient
+		G4double K = BarrierPenetrationFactor(ZRes);
+		
+		Barrier *= K;
+		
+		Barrier /= (1.0 + sqrt(U/(2.0*G4double(ARes))));
+	}
+	return Barrier;
+}
+
+
+

source/processes/hadronic/models/generator/de_excitation/src/G4DeuteronCoulombBarrier.cc

@@ -0,0 +1,58 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4DeuteronCoulombBarrier.cc,v 1.1 2000/06/09 11:43:35 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+
+#include "G4DeuteronCoulombBarrier.hh"
+
+G4DeuteronCoulombBarrier::G4DeuteronCoulombBarrier(const G4DeuteronCoulombBarrier & right)
+{
+  G4Exception("G4DeuteronCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+
+
+const G4DeuteronCoulombBarrier & G4DeuteronCoulombBarrier::operator=(const G4DeuteronCoulombBarrier & right)
+{
+ G4Exception("G4DeuteronCoulombBarrier::operator= meant to not be accessable.");
+ return *this;
+}
+
+G4bool G4DeuteronCoulombBarrier::operator==(const G4DeuteronCoulombBarrier & right) const 
+{
+ return false;
+}
+
+G4bool G4DeuteronCoulombBarrier::operator!=(const G4DeuteronCoulombBarrier & right) const 
+{
+ return true;
+}
+
+
+G4double G4DeuteronCoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// const G4double Zlist[size] = {10.0, 20.0, 30.0, 50.0, 70.0};
+	// const G4double Kprot[size] = {0.42, 0.58, 0.68, 0.77, 0.80};
+	// 
+	// K for deuteron is K for protons + 0.06
+	G4double K = 1.0;
+	if (aZ>=70.0) {
+		K = 0.80;
+	} else {
+		K = (((0.2357e-5*aZ) - 0.42679e-3)*aZ + 0.27035e-1)*aZ + 0.19025;
+	}
+	return K+0.06;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4DeuteronEvaporationChannel.cc

@@ -0,0 +1,36 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+#include "G4DeuteronEvaporationChannel.hh"
+
+
+const G4DeuteronEvaporationChannel & G4DeuteronEvaporationChannel::operator=(const G4DeuteronEvaporationChannel & right)
+{
+	G4Exception("G4DeuteronEvaporationChannel::operator= meant to not be accessable");
+	return *this;
+}
+
+G4DeuteronEvaporationChannel::G4DeuteronEvaporationChannel(const G4DeuteronEvaporationChannel & right)
+{
+	G4Exception("G4DeuteronEvaporationChannel::CopyConstructor meant to not be accessable");
+}
+
+G4bool G4DeuteronEvaporationChannel::operator==(const G4DeuteronEvaporationChannel & right) const 
+{
+	return (this == (G4DeuteronEvaporationChannel *) &right);
+	//  return false;
+}
+
+G4bool G4DeuteronEvaporationChannel::operator!=(const G4DeuteronEvaporationChannel & right) const 
+{
+	return (this != (G4DeuteronEvaporationChannel *) &right);
+	//  return true;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4DeuteronEvaporationProbability.cc

@@ -0,0 +1,106 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999)
+//
+
+
+#include "G4DeuteronEvaporationProbability.hh"
+
+G4DeuteronEvaporationProbability::G4DeuteronEvaporationProbability() :
+		G4EvaporationProbability(2,1,6) // A,Z,Gamma
+{
+	const G4int NumExcitedStates = 31+1;
+	ExcitEnergies.reshape(NumExcitedStates);
+	ExcitSpins.reshape(NumExcitedStates);
+	for (G4int i = 0; i < NumExcitedStates; i++) {
+		ExcitEnergies(i) = 0.0;
+		ExcitSpins(i) = 0;
+	}
+
+	ExcitEnergies(15) = 6.18*MeV;
+	ExcitEnergies(17) = 2.15*MeV;
+	ExcitEnergies(18) = 5.02*MeV;
+	ExcitEnergies(19) = 2.65*MeV;
+	ExcitEnergies(20) = 4.80*MeV;
+	ExcitEnergies(22) = 3.85*MeV;
+	ExcitEnergies(23) = 6.96*MeV;
+	ExcitEnergies(25) = 4.92*MeV;
+	ExcitEnergies(26) = 7.22*MeV;
+	ExcitEnergies(27) = 0.40*MeV;
+	ExcitEnergies(28) = 6.83*MeV;
+	ExcitEnergies(29) = 7.12*MeV;
+	ExcitEnergies(30) = 3.84*MeV;
+	ExcitEnergies(31) = 3.92*MeV;
+
+	ExcitSpins(15) = 1;
+	ExcitSpins(17) = 3;
+	ExcitSpins(18) = 4;
+	ExcitSpins(19) = 4;
+	ExcitSpins(20) = 4;
+	ExcitSpins(22) = 6;
+	ExcitSpins(23) = 6;
+	ExcitSpins(25) = 1;
+	ExcitSpins(26) = 10;
+	ExcitSpins(27) = 3;
+	ExcitSpins(28) = 10;
+	ExcitSpins(29) = 3;
+	ExcitSpins(30) = 6;
+	ExcitSpins(31) = 5;
+	
+	SetExcitationEnergiesPtr(&ExcitEnergies);
+	SetExcitationSpinsPtr(&ExcitSpins);	
+	
+}
+G4DeuteronEvaporationProbability::G4DeuteronEvaporationProbability(const G4DeuteronEvaporationProbability &right)
+{
+ G4Exception("G4DeuteronEvaporationProbability::copy_constructor meant to not be accessable");
+}
+
+
+
+
+const G4DeuteronEvaporationProbability & G4DeuteronEvaporationProbability::
+operator=(const G4DeuteronEvaporationProbability &right)
+{
+  G4Exception("G4DeuteronEvaporationProbability::operator= meant to not be accessable");
+  return *this;
+}
+
+
+G4bool G4DeuteronEvaporationProbability::operator==(const G4DeuteronEvaporationProbability &right) const
+{
+  return false;
+}
+
+G4bool G4DeuteronEvaporationProbability::operator!=(const G4DeuteronEvaporationProbability &right) const
+{
+  return true;
+}
+
+G4double G4DeuteronEvaporationProbability::CCoeficient(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+	// G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
+	// C for deuteron is equal to C for protons divided by 2
+	G4double C = 0.0;
+	
+	if (aZ >= 70) {
+		C = 0.10;
+	} else {
+		C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+	}
+	
+	return C/2.0;
+	
+}

source/processes/hadronic/models/generator/de_excitation/src/G4Evaporation.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -10,404 +10,42 @@
 
 #include "G4Evaporation.hh"
 
+#include "G4NeutronEvaporationChannel.hh"
+#include "G4ProtonEvaporationChannel.hh"
+#include "G4DeuteronEvaporationChannel.hh"
+#include "G4TritonEvaporationChannel.hh"
+#include "G4He3EvaporationChannel.hh"
+#include "G4AlphaEvaporationChannel.hh"
+#include "G4CompetitiveFission.hh"
+#include "G4PhotonEvaporation.hh"
 
-G4Evaporation::G4Evaporation()
+G4Evaporation::G4Evaporation() : myOwnChannelsVector(true)
 {
-  ExcitEnergyChann00.reshape(NumExcitedStates);
-  ExcitEnergyChann01.reshape(NumExcitedStates);
-  ExcitEnergyChann02.reshape(NumExcitedStates);
-  ExcitEnergyChann03.reshape(NumExcitedStates);
-  ExcitEnergyChann04.reshape(NumExcitedStates);
-  ExcitEnergyChann05.reshape(NumExcitedStates);
-  ExcitEnergyChann06.reshape(NumExcitedStates);
-  ExcitEnergyChann07.reshape(NumExcitedStates);
-  ExcitEnergyChann08.reshape(NumExcitedStates);
-  ExcitEnergyChann09.reshape(NumExcitedStates);
-  ExcitEnergyChann10.reshape(NumExcitedStates);
-  ExcitEnergyChann11.reshape(NumExcitedStates);
-  ExcitEnergyChann12.reshape(NumExcitedStates);
-  ExcitEnergyChann13.reshape(NumExcitedStates);
-  ExcitEnergyChann14.reshape(NumExcitedStates);
-  ExcitEnergyChann15.reshape(NumExcitedStates);
-  ExcitEnergyChann16.reshape(NumExcitedStates);
-  ExcitEnergyChann17.reshape(NumExcitedStates);
-  ExcitEnergyChann18.reshape(NumExcitedStates);
-  ExcitEnergyChann19.reshape(NumExcitedStates);
-  ExcitEnergyChann20.reshape(NumExcitedStates);
-  ExcitEnergyChann21.reshape(NumExcitedStates);
-  ExcitEnergyChann22.reshape(NumExcitedStates);
-  ExcitEnergyChann23.reshape(NumExcitedStates);
-  ExcitEnergyChann24.reshape(NumExcitedStates);
-  ExcitEnergyChann25.reshape(NumExcitedStates);
-  ExcitEnergyChann26.reshape(NumExcitedStates);
-  ExcitEnergyChann27.reshape(NumExcitedStates);
-  ExcitEnergyChann28.reshape(NumExcitedStates);
-  ExcitEnergyChann29.reshape(NumExcitedStates); 
-  ExcitEnergyChann30.reshape(NumExcitedStates);
-  ExcitEnergyChann31.reshape(NumExcitedStates);
+	theChannels = new G4RWTPtrOrderedVector<G4VEvaporationChannel>;
 
-  ExcitSpinChann00.reshape(NumExcitedStates);
-  ExcitSpinChann01.reshape(NumExcitedStates);
-  ExcitSpinChann02.reshape(NumExcitedStates);
-  ExcitSpinChann03.reshape(NumExcitedStates);
-  ExcitSpinChann04.reshape(NumExcitedStates);
-  ExcitSpinChann05.reshape(NumExcitedStates);
-  ExcitSpinChann06.reshape(NumExcitedStates);
-  ExcitSpinChann07.reshape(NumExcitedStates);
-  ExcitSpinChann08.reshape(NumExcitedStates);
-  ExcitSpinChann09.reshape(NumExcitedStates);
-  ExcitSpinChann10.reshape(NumExcitedStates);
-  ExcitSpinChann11.reshape(NumExcitedStates);
-  ExcitSpinChann12.reshape(NumExcitedStates);
-  ExcitSpinChann13.reshape(NumExcitedStates);
-  ExcitSpinChann14.reshape(NumExcitedStates);
-  ExcitSpinChann15.reshape(NumExcitedStates);
-  ExcitSpinChann16.reshape(NumExcitedStates);
-  ExcitSpinChann17.reshape(NumExcitedStates);
-  ExcitSpinChann18.reshape(NumExcitedStates);
-  ExcitSpinChann19.reshape(NumExcitedStates);
-  ExcitSpinChann20.reshape(NumExcitedStates);
-  ExcitSpinChann21.reshape(NumExcitedStates);
-  ExcitSpinChann22.reshape(NumExcitedStates);
-  ExcitSpinChann23.reshape(NumExcitedStates);
-  ExcitSpinChann24.reshape(NumExcitedStates);
-  ExcitSpinChann25.reshape(NumExcitedStates);
-  ExcitSpinChann26.reshape(NumExcitedStates);
-  ExcitSpinChann27.reshape(NumExcitedStates);
-  ExcitSpinChann28.reshape(NumExcitedStates);
-  ExcitSpinChann29.reshape(NumExcitedStates); 
-  ExcitSpinChann30.reshape(NumExcitedStates);
-  ExcitSpinChann31.reshape(NumExcitedStates);
-
-  for (G4int i = 0; i < NumExcitedStates; i++) {
-    ExcitEnergyChann00(i) = 0.0;
-    ExcitEnergyChann01(i) = 0.0;
-    ExcitEnergyChann02(i) = 0.0;
-    ExcitEnergyChann03(i) = 0.0;
-    ExcitEnergyChann04(i) = 0.0;
-    ExcitEnergyChann05(i) = 0.0;
-    ExcitEnergyChann06(i) = 0.0;
-    ExcitEnergyChann07(i) = 0.0;
-    ExcitEnergyChann08(i) = 0.0;
-    ExcitEnergyChann09(i) = 0.0;
-    ExcitEnergyChann10(i) = 0.0;
-    ExcitEnergyChann11(i) = 0.0;
-    ExcitEnergyChann12(i) = 0.0;
-    ExcitEnergyChann13(i) = 0.0;
-    ExcitEnergyChann14(i) = 0.0;
-    ExcitEnergyChann15(i) = 0.0;
-    ExcitEnergyChann16(i) = 0.0;
-    ExcitEnergyChann17(i) = 0.0;
-    ExcitEnergyChann18(i) = 0.0;
-    ExcitEnergyChann19(i) = 0.0;
-    ExcitEnergyChann20(i) = 0.0;
-    ExcitEnergyChann21(i) = 0.0;
-    ExcitEnergyChann22(i) = 0.0;
-    ExcitEnergyChann23(i) = 0.0;
-    ExcitEnergyChann24(i) = 0.0;
-    ExcitEnergyChann25(i) = 0.0;
-    ExcitEnergyChann26(i) = 0.0;
-    ExcitEnergyChann27(i) = 0.0;
-    ExcitEnergyChann28(i) = 0.0;
-    ExcitEnergyChann29(i) = 0.0; 
-    ExcitEnergyChann30(i) = 0.0;
-    ExcitEnergyChann31(i) = 0.0;
-
-    ExcitSpinChann00(i) = 0;
-    ExcitSpinChann01(i) = 0;
-    ExcitSpinChann02(i) = 0;
-    ExcitSpinChann03(i) = 0;
-    ExcitSpinChann04(i) = 0;
-    ExcitSpinChann05(i) = 0;
-    ExcitSpinChann06(i) = 0;
-    ExcitSpinChann07(i) = 0;
-    ExcitSpinChann08(i) = 0;
-    ExcitSpinChann09(i) = 0;
-    ExcitSpinChann10(i) = 0;
-    ExcitSpinChann11(i) = 0;
-    ExcitSpinChann12(i) = 0;
-    ExcitSpinChann13(i) = 0;
-    ExcitSpinChann14(i) = 0;
-    ExcitSpinChann15(i) = 0;
-    ExcitSpinChann16(i) = 0;
-    ExcitSpinChann17(i) = 0;
-    ExcitSpinChann18(i) = 0;
-    ExcitSpinChann19(i) = 0;
-    ExcitSpinChann20(i) = 0;
-    ExcitSpinChann21(i) = 0;
-    ExcitSpinChann22(i) = 0;
-    ExcitSpinChann23(i) = 0;
-    ExcitSpinChann24(i) = 0;
-    ExcitSpinChann25(i) = 0;
-    ExcitSpinChann26(i) = 0;
-    ExcitSpinChann27(i) = 0;
-    ExcitSpinChann28(i) = 0;
-    ExcitSpinChann29(i) = 0; 
-    ExcitSpinChann30(i) = 0;
-    ExcitSpinChann31(i) = 0;  
-  }
-
-  // (in MeV)
-  // neutrons
-  ExcitEnergyChann00( 9) = 3.56;
-  ExcitEnergyChann00(10) = 0.48;
-  ExcitEnergyChann00(11) = 0.98;
-  ExcitEnergyChann00(12) = 0.43;
-  ExcitEnergyChann00(15) = 3.37;
-  ExcitEnergyChann00(17) = 0.72;
-  ExcitEnergyChann00(18) = 2.13;
-  ExcitEnergyChann00(19) = 0.95;
-  ExcitEnergyChann00(20) = 2.00;
-  ExcitEnergyChann00(21) = 4.44;
-  ExcitEnergyChann00(22) = 3.09;
-  ExcitEnergyChann00(23) = 6.09;
-  ExcitEnergyChann00(25) = 2.31;
-  ExcitEnergyChann00(26) = 5.28;
-  ExcitEnergyChann00(27) = 0.12;
-  ExcitEnergyChann00(28) = 5.22;
-  ExcitEnergyChann00(29) = 6.10;
-  ExcitEnergyChann00(30) = 0.87;
-  ExcitEnergyChann00(31) = 1.98;
-  
-  // protons
-  ExcitEnergyChann01(15) = 5.96;
-  ExcitEnergyChann01(17) = 1.74;
-  ExcitEnergyChann01(18) = 4.44;
-  ExcitEnergyChann01(19) = 1.67;
-  ExcitEnergyChann01(20) = 4.32;
-  ExcitEnergyChann01(22) = 3.68;
-  ExcitEnergyChann01(23) = 6.69;
-  ExcitEnergyChann01(25) = 3.95;
-  ExcitEnergyChann01(26) = 6.32;
-  ExcitEnergyChann01(27) = 0.30;
-  ExcitEnergyChann01(28) = 6.18;
-  ExcitEnergyChann01(29) = 6.92;
-  ExcitEnergyChann01(30) = 3.06;
-  ExcitEnergyChann01(31) = 3.57;
-
-  // deuterons
-  ExcitEnergyChann02(15) = 6.18;
-  ExcitEnergyChann02(17) = 2.15;
-  ExcitEnergyChann02(18) = 5.02;
-  ExcitEnergyChann02(19) = 2.65;
-  ExcitEnergyChann02(20) = 4.80;
-  ExcitEnergyChann02(22) = 3.85;
-  ExcitEnergyChann02(23) = 6.96;
-  ExcitEnergyChann02(25) = 4.92;
-  ExcitEnergyChann02(26) = 7.22;
-  ExcitEnergyChann02(27) = 0.40;
-  ExcitEnergyChann02(28) = 6.83;
-  ExcitEnergyChann02(29) = 7.12;
-  ExcitEnergyChann02(30) = 3.84;
-  ExcitEnergyChann02(31) = 3.92;
-
-  // tritons
-  ExcitEnergyChann03(15) = 6.26;
-  ExcitEnergyChann03(17) = 3.59;
-  ExcitEnergyChann03(18) = 6.76;
-  ExcitEnergyChann03(20) = 6.34;
-  ExcitEnergyChann03(23) = 7.34;
-  ExcitEnergyChann03(25) = 5.11;
-  ExcitEnergyChann03(26) = 7.57;
-  ExcitEnergyChann03(28) = 7.28;
-  ExcitEnergyChann03(31) = 4.46;
-
-
-  // He3
-  ExcitEnergyChann04(18) = 7.29;
-  ExcitEnergyChann04(20) = 6.48;
-  ExcitEnergyChann04(25) = 5.69;
-  ExcitEnergyChann04(26) = 8.31;
-  ExcitEnergyChann04(31) = 5.10;
-
-  // alphas
-  ExcitEnergyChann05(18) = 7.98;
-  ExcitEnergyChann05(20) = 6.90;
-  ExcitEnergyChann05(25) = 5.83;
-  ExcitEnergyChann05(26) = 8.57;
-  ExcitEnergyChann05(31) = 5.33;
-  
-  // He5
-  ExcitEnergyChann06(18) = 8.56;
-  ExcitEnergyChann06(20) = 7.50;
-  ExcitEnergyChann06(25) = 6.20;
-  ExcitEnergyChann06(26) = 9.15;
-  ExcitEnergyChann06(31) = 5.53;
-
-  // He6
-  ExcitEnergyChann07(20) = 8.10;
-  ExcitEnergyChann07(25) = 6.44;
-  ExcitEnergyChann07(26) = 9.79;
-  ExcitEnergyChann07(31) = 6.20;
-
-
-  // Li5 
-  ExcitEnergyChann08(20) = 8.42;
-  ExcitEnergyChann08(25) = 7.03;
-  ExcitEnergyChann08(26) = 10.0;
-  ExcitEnergyChann08(31) = 6.38;
-
-
-  // Li6
-  ExcitEnergyChann09(20) = 8.66;
-  ExcitEnergyChann09(31) = 6.88;
-
-  
-  // Spin (2s+1)
-
-  // neutrons
-  ExcitSpinChann00( 9) = 1;
-  ExcitSpinChann00(10) = 2;
-  ExcitSpinChann00(11) = 3;
-  ExcitSpinChann00(12) = 2;
-  ExcitSpinChann00(15) = 5;
-  ExcitSpinChann00(17) = 3;
-  ExcitSpinChann00(18) = 2;
-  ExcitSpinChann00(19) = 5;
-  ExcitSpinChann00(20) = 2;
-  ExcitSpinChann00(21) = 5;
-  ExcitSpinChann00(22) = 2;
-  ExcitSpinChann00(23) = 3;
-  ExcitSpinChann00(25) = 1;
-  ExcitSpinChann00(26) = 8;
-  ExcitSpinChann00(27) = 1;
-  ExcitSpinChann00(28) = 8;
-  ExcitSpinChann00(29) = 8;
-  ExcitSpinChann00(30) = 2;
-  ExcitSpinChann00(31) = 5;
-
-  // protons
-  ExcitSpinChann01(15) = 8;
-  ExcitSpinChann01(17) = 1;
-  ExcitSpinChann01(18) = 6;
-  ExcitSpinChann01(19) = 5;
-  ExcitSpinChann01(20) = 6;
-  ExcitSpinChann01(22) = 4;
-  ExcitSpinChann01(23) = 8;
-  ExcitSpinChann01(25) = 3;
-  ExcitSpinChann01(26) = 4;
-  ExcitSpinChann01(27) = 7;
-  ExcitSpinChann01(28) = 4;
-  ExcitSpinChann01(29) = 5;
-  ExcitSpinChann01(30) = 2;
-  ExcitSpinChann01(31) = 10;
-
-  // deuterons
-  ExcitSpinChann02(15) = 1;
-  ExcitSpinChann02(17) = 3;
-  ExcitSpinChann02(18) = 4;
-  ExcitSpinChann02(19) = 4;
-  ExcitSpinChann02(20) = 4;
-  ExcitSpinChann02(22) = 6;
-  ExcitSpinChann02(23) = 6;
-  ExcitSpinChann02(25) = 1;
-  ExcitSpinChann02(26) = 10;
-  ExcitSpinChann02(27) = 3;
-  ExcitSpinChann02(28) = 10;
-  ExcitSpinChann02(29) = 3;
-  ExcitSpinChann02(30) = 6;
-  ExcitSpinChann02(31) = 5;
-
-  // tritons
-  ExcitSpinChann03(15) = 5;
-  ExcitSpinChann03(17) = 5;
-  ExcitSpinChann03(18) = 10;
-  ExcitSpinChann03(20) = 2;
-  ExcitSpinChann03(23) = 5;
-  ExcitSpinChann03(25) = 5;
-  ExcitSpinChann03(26) = 8;
-  ExcitSpinChann03(28) = 8;
-  ExcitSpinChann03(31) = 3;
-
-
-  // He3
-  ExcitSpinChann04(18) = 6;
-  ExcitSpinChann04(20) = 8;
-  ExcitSpinChann04(25) = 3;
-  ExcitSpinChann04(26) = 2;
-  ExcitSpinChann04(31) = 7;
-
-  // alphas
-  ExcitSpinChann05(18) = 4;
-  ExcitSpinChann05(20) = 6;
-  ExcitSpinChann05(25) = 7;
-  ExcitSpinChann05(26) = 4;
-  ExcitSpinChann05(31) = 13;
-  
-  // He5
-  ExcitSpinChann06(18) = 6;
-  ExcitSpinChann06(20) = 4;
-  ExcitSpinChann06(25) = 3;
-  ExcitSpinChann06(26) = 14;
-  ExcitSpinChann06(31) = 5;
-
-  // He6 
-  ExcitSpinChann07(20) = 4;
-  ExcitSpinChann07(25) = 7;
-  ExcitSpinChann07(26) = 14;
-  ExcitSpinChann07(31) = 3;
-
-  // Li5 
-  ExcitSpinChann08(20) = 6;
-  ExcitSpinChann08(25) = 5;
-  ExcitSpinChann08(26) = 8;
-  ExcitSpinChann08(31) = 12;
-
-  // Li6
-  ExcitSpinChann09(20) = 8;
-  ExcitSpinChann09(31) = 1;
-  
-
-  //                                        |Gamma|A| Z| 
-  //                                        +-----+-+--+
-  theChannels[ 0] = new G4EvaporationChannel(  2,  1, 0, &ExcitEnergyChann00, &ExcitSpinChann00); // n
-  theChannels[ 1] = new G4EvaporationChannel(  2,  1, 1, &ExcitEnergyChann01, &ExcitSpinChann01); // p
-  theChannels[ 2] = new G4EvaporationChannel(  6,  2, 1, &ExcitEnergyChann02, &ExcitSpinChann02); // H2
-  theChannels[ 3] = new G4EvaporationChannel(  6,  3, 1, &ExcitEnergyChann03, &ExcitSpinChann03); // H3
-  theChannels[ 4] = new G4EvaporationChannel(  6,  3, 2, &ExcitEnergyChann04, &ExcitSpinChann04); // He3
-  theChannels[ 5] = new G4EvaporationChannel(  4,  4, 2, &ExcitEnergyChann05, &ExcitSpinChann05); // He4
-  theChannels[ 6] = new G4EvaporationChannel( 20,  5, 2, &ExcitEnergyChann06, &ExcitSpinChann06); // He5
-  theChannels[ 7] = new G4EvaporationChannel( 30,  6, 2, &ExcitEnergyChann07, &ExcitSpinChann07); // He6
-  theChannels[ 8] = new G4EvaporationChannel( 20,  5, 3, &ExcitEnergyChann08, &ExcitSpinChann08); // Li5
-  theChannels[ 9] = new G4EvaporationChannel( 54,  6, 3, &ExcitEnergyChann09, &ExcitSpinChann09); // Li6
-  theChannels[10] = new G4EvaporationChannel( 73,  7, 3, &ExcitEnergyChann10, &ExcitSpinChann10); // Li7
-  theChannels[11] = new G4EvaporationChannel(101,  8, 3, &ExcitEnergyChann11, &ExcitSpinChann11); // Li8
-  theChannels[12] = new G4EvaporationChannel( 73,  7, 4, &ExcitEnergyChann12, &ExcitSpinChann12); // Be7
-  theChannels[13] = new G4EvaporationChannel(  8,  8, 4, &ExcitEnergyChann13, &ExcitSpinChann13); // Be8
-  theChannels[14] = new G4EvaporationChannel(146,  9, 4, &ExcitEnergyChann14, &ExcitSpinChann14); // Be9
-  theChannels[15] = new G4EvaporationChannel(100, 10, 4, &ExcitEnergyChann15, &ExcitSpinChann15); // Be10 
-  theChannels[16] = new G4EvaporationChannel(100,  9, 5, &ExcitEnergyChann16, &ExcitSpinChann16); // B9
-  theChannels[17] = new G4EvaporationChannel(343, 10, 5, &ExcitEnergyChann17, &ExcitSpinChann17); // B10
-  theChannels[18] = new G4EvaporationChannel(174, 11, 5, &ExcitEnergyChann18, &ExcitSpinChann18); // B11
-  theChannels[19] = new G4EvaporationChannel(393, 12, 5, &ExcitEnergyChann19, &ExcitSpinChann19); // B12
-  theChannels[20] = new G4EvaporationChannel(186, 11, 6, &ExcitEnergyChann20, &ExcitSpinChann20); // C11
-  theChannels[21] = new G4EvaporationChannel( 61, 12, 6, &ExcitEnergyChann21, &ExcitSpinChann21); // C12
-  theChannels[22] = new G4EvaporationChannel(202, 13, 6, &ExcitEnergyChann22, &ExcitSpinChann22); // C13
-  theChannels[23] = new G4EvaporationChannel(113, 14, 6, &ExcitEnergyChann23, &ExcitSpinChann23); // C14
-  theChannels[24] = new G4EvaporationChannel(213, 13, 7, &ExcitEnergyChann24, &ExcitSpinChann24); // N13
-  theChannels[25] = new G4EvaporationChannel(233, 14, 7, &ExcitEnergyChann25, &ExcitSpinChann25); // N14
-  theChannels[26] = new G4EvaporationChannel(180, 15, 7, &ExcitEnergyChann26, &ExcitSpinChann26); // N15
-  theChannels[27] = new G4EvaporationChannel(696, 16, 7, &ExcitEnergyChann27, &ExcitSpinChann27); // N16
-  theChannels[28] = new G4EvaporationChannel(194, 15, 8, &ExcitEnergyChann28, &ExcitSpinChann28); // O15
-  theChannels[29] = new G4EvaporationChannel(120, 16, 8, &ExcitEnergyChann29, &ExcitSpinChann29); // O16
-  theChannels[30] = new G4EvaporationChannel(458, 17, 8, &ExcitEnergyChann30, &ExcitSpinChann30); // O17
-  theChannels[31] = new G4EvaporationChannel(590, 18, 8, &ExcitEnergyChann31, &ExcitSpinChann31); // O18 
-  theChannels[32] = new G4CompetitiveFission(); // Fission Channel
-  theChannels[33] = new G4PhotonEvaporation(); // Photon Channel
+	theChannels->insert( new G4NeutronEvaporationChannel() );  // n
+	theChannels->insert( new G4ProtonEvaporationChannel() );   // p
+	theChannels->insert( new G4DeuteronEvaporationChannel() ); // Deuteron
+	theChannels->insert( new G4TritonEvaporationChannel() );   // Triton
+	theChannels->insert( new G4He3EvaporationChannel() );      // He3
+	theChannels->insert( new G4AlphaEvaporationChannel() );    // Alpha
 
+	theChannels->insert( new G4CompetitiveFission() ); // Fission Channel
+	theChannels->insert( new G4PhotonEvaporation() );  // Photon Channel
 }
 
 G4Evaporation::G4Evaporation(const G4Evaporation &right)
 {
-  G4Exception("G4Evaporation::copy_constructor meant to not be accessable.");
+	G4Exception("G4Evaporation::copy_constructor meant to not be accessable.");
 }
 
 
 G4Evaporation::~G4Evaporation()
 {
-  for (G4int i = 0; i < TotNumberOfChannels; i++) 
-    delete theChannels[i];
-
+	if (myOwnChannelsVector) {
+		theChannels->clearAndDestroy();
+		delete theChannels;
+	}
 }
 
 const G4Evaporation & G4Evaporation::operator=(const G4Evaporation &right)
@@ -430,96 +68,92 @@ G4bool G4Evaporation::operator!=(const G4Evaporation &right) const
 
 G4FragmentVector * G4Evaporation::BreakItUp(const G4Fragment &theNucleus)
 {
-  G4FragmentVector * theResult = new G4FragmentVector;
+	G4FragmentVector * theResult = new G4FragmentVector;
 
-  // CHECK that Excitation Energy != 0
-  if (theNucleus.GetExcitationEnergy() == 0) {
-    theResult->insert(new G4Fragment(theNucleus));
-    return theResult;
-  }
+	// CHECK that Excitation Energy != 0
+	if (theNucleus.GetExcitationEnergy() <= 0.0) {
+		theResult->insert(new G4Fragment(theNucleus));
+		return theResult;
+	}
 
-  // The residual nucleus (after evaporation of each fragment)
-  G4Fragment theResidualNucleus = theNucleus;
+	// The residual nucleus (after evaporation of each fragment)
+	G4Fragment theResidualNucleus = theNucleus;
 
-
-  // Starts loop over evaporated particles
-  for (;;) {
-    // loop over evaporation channels
-    G4int i;
-    for (i=0; i < TotNumberOfChannels; i++)
-      theChannels[i]->Initialize(theResidualNucleus);
-    
-    // Work out total decay probability by summing over channels 
-    G4double TotalProbability = 0;
-    for (i=0; i < TotNumberOfChannels; i++)
-      TotalProbability += theChannels[i]->GetEmissionProbability();
-
-//     G4cout << "---------------- " << theResidualNucleus.GetExcitationEnergy()/MeV << "-----------------------" << G4endl;
-//     G4cout << "Prob of neutron: " << theChannels[0]->GetEmissionProbability()/TotalProbability << G4endl;
-//     G4cout << "Prob of proton : " << theChannels[1]->GetEmissionProbability()/TotalProbability<< G4endl;
-//     G4cout << "Prob of alpha  : " << theChannels[5]->GetEmissionProbability()/TotalProbability<< G4endl;
-//     G4cout << "Prob of fission: " << theChannels[NumberOfFissionChannel]->GetEmissionProbability()/TotalProbability<< G4endl;
-
-
-    if (TotalProbability <= 0.0) {
-      // Will be no evaporation more
-      // write information about residual nucleus
-      theResult->insert(new G4Fragment(theResidualNucleus));
-      break; 
-    } else {
-      // Selection of evaporation channel, fission or gamma
-      G4double EmissionProbChannel[TotNumberOfChannels];
+	// Number of channels
+	G4int TotNumberOfChannels = theChannels->entries();  
 	
-      
-      EmissionProbChannel[0] = theChannels[0]->GetEmissionProbability();
 
+	// Starts loop over evaporated particles
+	for (;;) {
+		// loop over evaporation channels
+		G4int i;
+		for (i=0; i < TotNumberOfChannels; i++) {
+			theChannels->at(i)->Initialize(theResidualNucleus);
+    	}
+		// Work out total decay probability by summing over channels 
+		G4double TotalProbability = 0;
+		for (i=0; i < TotNumberOfChannels; i++) {
+			TotalProbability += theChannels->at(i)->GetEmissionProbability();
+		}
+		if (TotalProbability <= 0.0) {
+			// Will be no evaporation more
+			// write information about residual nucleus
+			theResult->insert(new G4Fragment(theResidualNucleus));
+			break; 
+		} else {
+			// Selection of evaporation channel, fission or gamma
+// 			G4double * EmissionProbChannel = new G4double(TotNumberOfChannels);
+			G4RWTValOrderedVector<G4double> EmissionProbChannel;
+	
+// 			EmissionProbChannel[0] = theChannels->at(0)->GetEmissionProbability();
+			EmissionProbChannel.insert(theChannels->at(0)->GetEmissionProbability()); // index 0
+			
+			for (i=1; i < TotNumberOfChannels; i++) {
+// 				EmissionProbChannel[i] = EmissionProbChannel[i-1] + 
+// 												 theChannels->at(i)->GetEmissionProbability();
+				EmissionProbChannel.insert(EmissionProbChannel(i-1) + 
+												 theChannels->at(i)->GetEmissionProbability());
+			}
 
-      for (i=1; i < TotNumberOfChannels; i++) 
-	EmissionProbChannel[i] = EmissionProbChannel[i-1] + theChannels[i]->GetEmissionProbability();
+			G4double shoot = G4UniformRand() * TotalProbability;
 
+			for (i=0; i < TotNumberOfChannels; i++) {
+// 				if (shoot < EmissionProbChannel[i]) 
+				if (shoot < EmissionProbChannel(i)) 
+				break;
+			}
+			
+// 			delete [] EmissionProbChannel;
+			EmissionProbChannel.clear();
+			
+			if( i >= TotNumberOfChannels ) {
+				G4Exception( "G4Evaporation::BreakItUp: Can't define emission probability of the channels!" );
+			} else {
+				// Perform break-up
+				G4FragmentVector * theEvaporationResult = theChannels->at(i)->BreakUp(theResidualNucleus);
 
-      G4double shoot = G4UniformRand() * TotalProbability;
+				// Check if chosen channel is fission (there are only two EXCITED fragments)
+				// or the channel could not evaporate anything
+				if ( theEvaporationResult->entries() == 1 || 
+						(theEvaporationResult->first()->GetExcitationEnergy() > 0.0 && 
+						theEvaporationResult->last()->GetExcitationEnergy() > 0.0) ) {
+					// FISSION 
+					while (theEvaporationResult->entries() > 0) theResult->insert(theEvaporationResult->removeFirst());
+					theEvaporationResult->clearAndDestroy();
+					delete theEvaporationResult;
+					break;
+				} else {
+					// EVAPORATION
+					while (theEvaporationResult->entries() > 1) theResult->insert(theEvaporationResult->removeFirst());
+					theResidualNucleus = *(theEvaporationResult->at(0));
+					theEvaporationResult->clearAndDestroy();
+					delete theEvaporationResult;
+				}
+			}
+		}
+	}
 
-      for (i=0; i < TotNumberOfChannels; i++)
-	if (shoot < EmissionProbChannel[i]) 
-	  break;
-
-      if( i == TotNumberOfChannels )
-	G4Exception( "Can't define emission probability of the channels (G4Evaporation::BreakItUp)" );
-      else if (i == NumberOfFissionChannel) {
-	// Fission has to be performed
-	G4FragmentVector * theFissionResult = theChannels[i]->BreakUp(theResidualNucleus);
-	while (theFissionResult->entries() > 0)
-	  theResult->insert(theFissionResult->removeFirst());
-
-	theFissionResult->clearAndDestroy();
-	delete theFissionResult;
-	break;
-
-      } else if (i == NumberOfGammaChannel) {
-	// Gamma evaporation has to be performed
-	G4FragmentVector * theGammaResult = theChannels[i]->BreakUp(theResidualNucleus);
-	while (theGammaResult->entries() > 0)
-	  theResult->insert(theGammaResult->removeFirst());
-
-	theGammaResult->clearAndDestroy();
-	delete theGammaResult;
-	break;
-
-      } else {
-	// Evaporation has to be performed
-	G4FragmentVector * theEvaporationResult = theChannels[i]->BreakUp(theResidualNucleus);
-	while (theEvaporationResult->entries() > 1)
-	  theResult->insert(theEvaporationResult->removeFirst());
-
-	theResidualNucleus = *(theEvaporationResult->at(0));
-	theEvaporationResult->clearAndDestroy();
-	delete theEvaporationResult;
-      }
-    }
-  }
-
-  return theResult;
+	return theResult;
 }
 
 

source/processes/hadronic/models/generator/de_excitation/src/G4EvaporationChannel.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -7,41 +7,28 @@
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
-// some corrections V.Krylov
 //
 
 #include "G4EvaporationChannel.hh"
 
-G4EvaporationChannel::G4EvaporationChannel(const G4int theGamma,
-					   const G4int theA,
-					   const G4int theZ,
-					   G4RWTValVector<G4double> * theExcitationEnergies,
-					   G4RWTValVector<G4int> * theExcitationSpins):
-  Gamma(theGamma),
-  A(theA),
-  Z(theZ),
-  ExcitationEnergies(theExcitationEnergies),
-  ExcitationSpins(theExcitationSpins),
-  AResidual(0),
-  ZResidual(0),
-  CoulombBarrier(0.0),
-  BindingEnergy(0.0),
-  MaximalKineticEnergy(-1000.0),
-  EmissionProbability(0.0)
+G4EvaporationChannel::G4EvaporationChannel(const G4int theA, const G4int theZ,
+  								G4VEmissionProbability * aEmissionStrategy,
+								G4VCoulombBarrier * aCoulombBarrier):
+	A(theA),
+	Z(theZ),
+	theEvaporationProbabilityPtr(aEmissionStrategy),
+	theCoulombBarrierPtr(aCoulombBarrier),
+	MaximalKineticEnergy(-1000.0),
+	EmissionProbability(0.0)
 { 
-  theEvaporationProbabilityPtr = new G4EvaporationProbability(this);
-  MyOwnEvaporationProbability = true;
-
-  theLevelDensityPtr = new G4EvaporationLevelDensityParameter;
-  MyOwnLevelDensity = true;
+	theLevelDensityPtr = new G4EvaporationLevelDensityParameter;
+	MyOwnLevelDensity = true;
 }
 
+
 G4EvaporationChannel::~G4EvaporationChannel()
 {
-
-  if (MyOwnEvaporationProbability) delete theEvaporationProbabilityPtr;
-
-  if (MyOwnLevelDensity) delete theLevelDensityPtr;
+	if (MyOwnLevelDensity) delete theLevelDensityPtr;
 }
 
 
@@ -49,25 +36,25 @@ G4EvaporationChannel::~G4EvaporationChannel()
 
 G4EvaporationChannel::G4EvaporationChannel(const G4EvaporationChannel & right)
 {
-  G4Exception("G4EvaporationChannel::copy_costructor meant to not be accessable");
+	G4Exception("G4EvaporationChannel::copy_costructor meant to not be accessable");
 }
 
 const G4EvaporationChannel & G4EvaporationChannel::operator=(const G4EvaporationChannel & right)
 {
-  G4Exception("G4EvaporationChannel::operator= meant to not be accessable");
-  return *this;
+	G4Exception("G4EvaporationChannel::operator= meant to not be accessable");
+	return *this;
 }
 
 G4bool G4EvaporationChannel::operator==(const G4EvaporationChannel & right) const 
 {
-  return (this == (G4EvaporationChannel *) &right);
-    //  return false;
+	return (this == (G4EvaporationChannel *) &right);
+	//  return false;
 }
 
 G4bool G4EvaporationChannel::operator!=(const G4EvaporationChannel & right) const 
 {
-    return (this != (G4EvaporationChannel *) &right);
-    //  return true;
+	return (this != (G4EvaporationChannel *) &right);
+	//  return true;
 }
 
 
@@ -75,230 +62,146 @@ G4bool G4EvaporationChannel::operator!=(const G4EvaporationChannel & right) cons
 void G4EvaporationChannel::Initialize(const G4Fragment & fragment)
 {
 
-  G4int anA = fragment.GetA();
-  G4int aZ = fragment.GetZ();
-  G4double ExEnergy = fragment.GetExcitationEnergy();
+	G4int anA = G4int(fragment.GetA());
+	G4int aZ = G4int(fragment.GetZ());
+	AResidual = anA - A;
+	ZResidual = aZ - Z;
 
-  AResidual = anA - A;
-  ZResidual = aZ - Z;
+	// Effective excitation energy
+	G4double ExEnergy = fragment.GetExcitationEnergy() - PairingCorrection(anA,aZ);
 
-  // We only take into account channels which are physically allowed
-  if (AResidual <= 0 || ZResidual <= 0 || AResidual < ZResidual ||
-      (AResidual == ZResidual && AResidual > 1)) {
-    LevelDensityParameter = 0.0;
-    CoulombBarrier = 0.0;
-    BindingEnergy = 0.0;
-    MaximalKineticEnergy = -1000.0*MeV;
-    EmissionProbability = 0.0;
-  } else {
-    // Get Level Density
-    LevelDensityParameter = theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
+	// We only take into account channels which are physically allowed
+	if (AResidual <= 0 || ZResidual <= 0 || AResidual < ZResidual ||
+      (AResidual == ZResidual && AResidual > 1) || ExEnergy <= 0.0) {
+// 		LevelDensityParameter = 0.0;
+		CoulombBarrier = 0.0;
+// 		BindingEnergy = 0.0;
+		MaximalKineticEnergy = -1000.0*MeV;
+		EmissionProbability = 0.0;
+	} else {
+// 		// Get Level Density
+// 		LevelDensityParameter = theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
 
-    // Coulomb Barrier calculation
-    CoulombBarrier = CalcCoulombBarrier(AResidual,ZResidual)*MeV;
+		// Coulomb Barrier calculation
+		CoulombBarrier = theCoulombBarrierPtr->GetCoulombBarrier(AResidual,ZResidual,ExEnergy);
 	
-    
-    // Binding Enegy (for separate fragment from nucleus)
-    BindingEnergy = CalcBindingEnergy(anA,aZ)*MeV;
+// 		// Binding Enegy (for separate fragment from nucleus)
+// 		BindingEnergy = CalcBindingEnergy(anA,aZ);
 
-    // Maximal Kinetic Energy
-    MaximalKineticEnergy = CalcMaximalKineticEnergy(G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(aZ,anA)+ExEnergy)*MeV;
-
-    // Emission probability
-    if (MaximalKineticEnergy <= 0.0) EmissionProbability = 0.0;
-    else { 
-      // Total emission probability for this channel
-      EmissionProbability = theEvaporationProbabilityPtr->EmissionProbability(fragment,0.0);
-      // Next is a loop over excited states for this channel summing probabilities
-      G4double SavedGamma = Gamma;
-      G4double SavedMaximalKineticEnergy = MaximalKineticEnergy;
-      for (G4int i = 0; i < ExcitationEnergies->length(); i++) {
-	if (ExcitationSpins->operator()(i) < 0.1) continue;
-	Gamma = ExcitationSpins->operator()(i)*A;
-	// substract excitation energies
-	MaximalKineticEnergy -= ExcitationEnergies->operator()(i)/MeV;
-	// update probability
-	G4double tmp = theEvaporationProbabilityPtr->EmissionProbability(fragment,0.0);
-	EmissionProbability += tmp;
-      }
-      // restore Gamma and MaximalKineticEnergy
-      MaximalKineticEnergy = SavedMaximalKineticEnergy;
-      Gamma = SavedGamma;
-    }
-  }
-
-  return;
+		// Maximal Kinetic Energy
+ 		MaximalKineticEnergy = CalcMaximalKineticEnergy(G4ParticleTable::GetParticleTable()->
+ 																GetIonTable()->GetNucleusMass(aZ,anA)+ExEnergy);
+		
+		// Emission probability
+		if (MaximalKineticEnergy <= 0.0) EmissionProbability = 0.0;
+		else { 
+			// Total emission probability for this channel
+			EmissionProbability = theEvaporationProbabilityPtr->EmissionProbability(fragment,MaximalKineticEnergy);
 
+		}
+	}
+	
+	return;
 }
 
 
 G4FragmentVector * G4EvaporationChannel::BreakUp(const G4Fragment & theNucleus)
 {
-  // calculate kinetic energy of evaporated fragment
-  G4double EvaporatedKineticEnergy = CalcKineticEnergy();  // MeV
-  G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A)/MeV; // MeV
-  G4double EvaporatedEnergy = EvaporatedKineticEnergy + EvaporatedMass;
 
+	G4double EvaporatedKineticEnergy = CalcKineticEnergy();
+	G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A);
+	G4double EvaporatedEnergy = EvaporatedKineticEnergy + EvaporatedMass;
 
-  G4ThreeVector momentum( IsotropicVector( sqrt( EvaporatedEnergy*EvaporatedEnergy - 
-						 EvaporatedMass*EvaporatedMass )
-					   ) );
-
-  G4LorentzVector EvaporatedMomentum( momentum, EvaporatedEnergy );
-  EvaporatedMomentum.boost( theNucleus.GetMomentum().boostVector() );
-  
-  // to avoid rounding errors in Lorentz boost which then produce 
-  // evaporated fragments with excitation energies ~10^-10 eV
-  EvaporatedMomentum.setE(sqrt(EvaporatedMomentum.vect().mag2()+EvaporatedMass*EvaporatedMass));
-  
-  
+	G4ThreeVector momentum(IsotropicVector(sqrt(EvaporatedKineticEnergy*
+															(EvaporatedKineticEnergy+2.0*EvaporatedMass))));
   
+	G4LorentzVector EvaporatedMomentum(momentum,EvaporatedEnergy);
+	EvaporatedMomentum.boost(theNucleus.GetMomentum().boostVector());
 
-  G4Fragment * EvaporatedFragment = new G4Fragment( A, Z, EvaporatedMomentum );
-  if ( !EvaporatedFragment )
-    G4Exception( "G4EvaporationChannel::BreakUp: Can't create G4Fragment! ");
+	G4Fragment * EvaporatedFragment = new G4Fragment(A,Z,EvaporatedMomentum);
 
-  G4LorentzVector FragmentMomentum( theNucleus.GetMomentum() );
-  FragmentMomentum.boost( -theNucleus.GetMomentum().boostVector() );
-  
-
-  G4LorentzVector ResidualMomentum( -momentum, FragmentMomentum.e() - EvaporatedEnergy );
-  ResidualMomentum.boost( theNucleus.GetMomentum().boostVector() );
-
-  
-  G4Fragment * ResidualFragment = new G4Fragment( AResidual, ZResidual, ResidualMomentum );
-  if ( !ResidualFragment )
-		G4Exception( "G4EvaporationChannel::BreakUp: Can't create G4Fragment! ");
+	// ** And now the residual nucleus ** 
+	G4double theExEnergy = theNucleus.GetExcitationEnergy();
+	G4double theMass = G4ParticleTable::GetParticleTable()->GetIonTable()->
+							GetNucleusMass(theNucleus.GetZ(),theNucleus.GetA());
+	G4double ResidualEnergy = theMass + (theExEnergy - EvaporatedKineticEnergy) - EvaporatedMass;
+	
+	G4LorentzVector ResidualMomentum(-momentum,ResidualEnergy);
+	ResidualMomentum.boost(theNucleus.GetMomentum().boostVector());
+	
+	G4Fragment * ResidualFragment = new G4Fragment( AResidual, ZResidual, ResidualMomentum );
 
 
-  G4FragmentVector * theResult = new G4FragmentVector;
-  if ( !theResult )
-    G4Exception( "G4EvaporationChannel::BreakUp: Can't create G4FragmentVector! ");
+	G4FragmentVector * theResult = new G4FragmentVector;
 
-  theResult->insert(EvaporatedFragment);
-  theResult->insert(ResidualFragment);
-
-  return theResult; 
+	theResult->insert(EvaporatedFragment);
+	theResult->insert(ResidualFragment);	return theResult; 
 } 
 
 
-G4double G4EvaporationChannel::CalcCoulombBarrier(const G4int ARes, const G4int ZRes)
-  // Calculation of Coulomb potential energy (barrier) in MeV for outgoing fragment
-{
-  G4double Barrier = 0.0;
-  if (Z == 0 && A == 1) return 0.0; // for neutron
-  else {
-    G4int nZZRes = Z * ZRes;
-    G4double r0 = 2.173*(1.0+0.006103 * nZZRes)/(1.0+0.009443 * nZZRes);
-    Barrier = 1.44/r0 * nZZRes / (pow( A,1./3. ) + pow( ARes,1./3. ));
-  }
-  return Barrier;
-}
 
-
-
-G4double G4EvaporationChannel::CalcBindingEnergy(const G4int anA, const G4int aZ)
-  // Calculate Binding Energy for separate fragment from nucleus
-{
-  // Mass Excess for residual nucleus
-  G4double ResNucMassExcess = G4NucleiProperties::GetMassExcess(AResidual,ZResidual)/MeV;
-  // Mass Excess for fragment
-  G4double FragmentMassExcess = G4NucleiProperties::GetMassExcess(A,Z)/MeV;
-  // Mass Excess for Nucleus
-  G4double NucleusMassExcess = G4NucleiProperties::GetMassExcess(anA,aZ)/MeV;
-
-  return ResNucMassExcess + FragmentMassExcess - NucleusMassExcess;
-}
+// G4double G4EvaporationChannel::CalcBindingEnergy(const G4int anA, const G4int aZ)
+// // Calculate Binding Energy for separate fragment from nucleus
+// {
+// 	// Mass Excess for residual nucleus
+// 	G4double ResNucMassExcess = G4NucleiProperties::GetNuclearMass(AResidual,ZResidual);
+// 	// Mass Excess for fragment
+// 	G4double FragmentMassExcess = G4NucleiProperties::GetNuclearMass(A,Z);
+// 	// Mass Excess for Compound Nucleus
+// 	G4double NucleusMassExcess = G4NucleiProperties::GetNuclearMass(anA,aZ);
+// 
+// 	return ResNucMassExcess + FragmentMassExcess - NucleusMassExcess;
+// }
 
 
 G4double G4EvaporationChannel::CalcMaximalKineticEnergy(const G4double NucleusTotalE)
-  // Calculate maximal kinetic energy that can be carried by fragment (in MeV)
+// Calculate maximal kinetic energy that can be carried by fragment.
 {
-//   // Odd-Even term correction (for maximal kinetic energy)
-//   G4double odd = 0.0;
-//   if (A < 65) {
-//     G4int NCorr = A - Z;
-//     NCorr = 2*(NCorr/2) - NCorr;
-//     G4int ZCorr = 2*(Z/2) - Z;
-//     odd = 11.0*(2+NCorr+ZCorr)/sqrt(G4double(A));
-//   }
-
-//   if (A <= 55) return U/MeV - 
-// 		 (BindingEnergy + CoulombBarrier)/MeV - odd;
-//   else if (A > 55 && A < 65) return U/MeV - 
-// 			       (BindingEnergy + CoulombBarrier)/MeV -
-// 			       odd * (1.0 - (A-55)/10.);
-
-//   else return U/MeV - (BindingEnergy + CoulombBarrier);
-
-  G4double ResidualMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass( ZResidual, AResidual )/MeV;
-  G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass( Z, A )/MeV;
-
-  return ( (NucleusTotalE/MeV)*(NucleusTotalE/MeV) + 
-	   EvaporatedMass*EvaporatedMass - ResidualMass*ResidualMass)/
-    (2.0*NucleusTotalE  ) -
-    EvaporatedMass - CoulombBarrier/MeV;
+	G4double ResidualMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetNucleusMass( ZResidual, AResidual );
+	G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetNucleusMass( Z, A );
+	
+	G4double T = (NucleusTotalE*NucleusTotalE + EvaporatedMass*EvaporatedMass - ResidualMass*ResidualMass)/
+					(2.0*NucleusTotalE) -
+					EvaporatedMass - CoulombBarrier;
+	
+	return T;
 }
 
 
 
 
 G4double G4EvaporationChannel::CalcKineticEnergy(void)
-  // Samples fragment kinetic energy (in MeV).
-  // It uses Dostrovsky's approximation for the inverse reaction cross
-  // in the probability for fragment emisson
+// Samples fragment kinetic energy.
+// It uses Dostrovsky's approximation for the inverse reaction cross
+// in the probability for fragment emisson
 {
-  if (MaximalKineticEnergy < 0.0) 
-    G4Exception("G4EvaporationChannel::CalcKineticEnergy: maximal kinetic energy is less than 0");
-  
-//   G4double Rb = 4.0*LevelDensityParameter/(1./MeV)*AResidual*MaximalKineticEnergy/MeV;
-//   G4double RbSqrt = sqrt(Rb);
-//   G4double PEX1 = 0.0;
-//   if (RbSqrt < 160.0) PEX1 = exp(-RbSqrt);
-//   G4double Rk = 0.0;
-//   G4double FRk = 0.0;
-//   do {
-//     G4double RandNumber = G4UniformRand();
-//     Rk = 1.0 + (1./RbSqrt)*log(RandNumber + (1.0-RandNumber)*PEX1);
-//     G4double Q1 = 1.0;
-//     G4double Q2 = 1.0;
-//     if (Z == 0) { // for emitted neutron
-//       G4double Beta = (2.12/pow(AResidual,2./3.) - 0.05)/
-// 	(0.76 + 2.2/pow(AResidual,1./3.));
-//       Q1 = 1.0 + Beta/(MaximalKineticEnergy/MeV);
-//       Q2 = Q1*sqrt(Q1);
-//     } 
+	if (MaximalKineticEnergy < 0.0) 
+		G4Exception("G4EvaporationChannel::CalcKineticEnergy: maximal kinetic energy is less than 0");
+
+	G4double Rb = 4.0*theLevelDensityPtr->LevelDensityParameter(AResidual+A,ZResidual+Z,MaximalKineticEnergy)*
+						MaximalKineticEnergy;
+	G4double RbSqrt = sqrt(Rb);
+	G4double PEX1 = 0.0;
+	if (RbSqrt < 160.0) PEX1 = exp(-RbSqrt);
+	G4double Rk = 0.0;
+	G4double FRk = 0.0;
+	do {
+		G4double RandNumber = G4UniformRand();
+		Rk = 1.0 + (1./RbSqrt)*log(RandNumber + (1.0-RandNumber)*PEX1);
+		G4double Q1 = 1.0;
+		G4double Q2 = 1.0;
+		if (Z == 0) { // for emitted neutron
+			G4double Beta = (2.12/pow(AResidual,2./3.) - 0.05)*MeV/
+								(0.76 + 2.2/pow(AResidual,1./3.));
+			Q1 = 1.0 + Beta/(MaximalKineticEnergy);
+			Q2 = Q1*sqrt(Q1);
+		} 
     
-//     FRk = (3.0*sqrt(3.0)/2.0)/Q2 * Rk * (Q1 - Rk*Rk);
+		FRk = (3.0*sqrt(3.0)/2.0)/Q2 * Rk * (Q1 - Rk*Rk);
     
-//   } while (FRk < G4UniformRand());
+	} while (FRk < G4UniformRand());
 
-
-  G4double Rb = 4.0*LevelDensityParameter/(1./MeV)*AResidual*(MaximalKineticEnergy)/MeV;
-  G4double RbSqrt = sqrt(Rb);
-  G4double PEX1 = 0.0;
-  if (RbSqrt < 160.0) PEX1 = exp(-RbSqrt);
-  G4double Rk = 0.0;
-  G4double FRk = 0.0;
-  do {
-    G4double RandNumber = G4UniformRand();
-    Rk = 1.0 + (1./RbSqrt)*log(RandNumber + (1.0-RandNumber)*PEX1);
-    G4double Q1 = 1.0;
-    G4double Q2 = 1.0;
-    if (Z == 0) { // for emitted neutron
-      G4double Beta = (2.12/pow(AResidual,2./3.) - 0.05)/
-	(0.76 + 2.2/pow(AResidual,1./3.));
-      Q1 = 1.0 + Beta/(MaximalKineticEnergy/MeV);
-      Q2 = Q1*sqrt(Q1);
-    } 
-    
-    FRk = (3.0*sqrt(3.0)/2.0)/Q2 * Rk * (Q1 - Rk*Rk);
-    
-  } while (FRk < G4UniformRand());
-
-
-
-  G4double result =  (MaximalKineticEnergy)/MeV * (1.0-Rk*Rk) + CoulombBarrier/MeV;
+  G4double result =  MaximalKineticEnergy * (1.0-Rk*Rk) + CoulombBarrier;
 
   return result;
 } 
@@ -308,14 +211,21 @@ G4ThreeVector G4EvaporationChannel::IsotropicVector(const G4double Magnitude)
   // Samples a isotropic random vectorwith a magnitud given by Magnitude.
   // By default Magnitude = 1.0
 {
-  G4double CosTheta = 1.0 - 2.0*G4UniformRand();
-  G4double SinTheta = sqrt(1.0 - CosTheta*CosTheta);
-  G4double Phi = twopi*G4UniformRand();
-  G4ThreeVector Vector(Magnitude*cos(Phi)*SinTheta,
-                       Magnitude*sin(Phi)*SinTheta,
-                       Magnitude*CosTheta);
-  return Vector;
+	G4double CosTheta = 1.0 - 2.0*G4UniformRand();
+	G4double SinTheta = sqrt(1.0 - CosTheta*CosTheta);
+	G4double Phi = twopi*G4UniformRand();
+	G4ThreeVector Vector(Magnitude*cos(Phi)*SinTheta,
+								Magnitude*sin(Phi)*SinTheta,
+								Magnitude*CosTheta);
+	return Vector;
 }
 
 
-
+G4double G4EvaporationChannel::PairingCorrection(const G4int anA, const G4int aZ) const
+{
+	const G4double PairingConstant = 12.0*MeV;
+	const G4int N = anA - aZ;
+	G4double Pair = (1.0 - G4double(aZ) + 2.0*(aZ/2)) + (1.0 - G4double(N) + 2.0*(N/2));
+	G4double PCorrection = Pair*PairingConstant/sqrt(G4double(anA));
+	return PCorrection;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4EvaporationLevelDensityParameter.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -13,11 +13,15 @@
 #include "G4EvaporationLevelDensityParameter.hh"
 
 
-//const G4double G4EvaporationLevelDensityParameter::EvapLevelDensityParameter = 0.125*(1./MeV);
+const G4double G4EvaporationLevelDensityParameter::ConstEvapLevelDensityParameter = 0.125*(1./MeV);
+const G4double G4EvaporationLevelDensityParameter::alpha = 0.072*(1./MeV);
+const G4double G4EvaporationLevelDensityParameter::beta = 0.275*(1./MeV);
+const G4double G4EvaporationLevelDensityParameter::gamma = 0.052*(1./MeV);
+const G4double G4EvaporationLevelDensityParameter::Bs = 1.0;
+
 
 G4EvaporationLevelDensityParameter::
-G4EvaporationLevelDensityParameter(const G4EvaporationLevelDensityParameter &right) :
-  EvapLevelDensityParameter(0.125*(1./MeV))
+G4EvaporationLevelDensityParameter(const G4EvaporationLevelDensityParameter &right)
 {
   G4Exception("G4EvaporationLevelDensityParameter::copy_constructor meant to not be accessable");
 }
@@ -41,7 +45,22 @@ G4bool G4EvaporationLevelDensityParameter::operator!=(const G4EvaporationLevelDe
   return true;
 }
 
+G4double G4EvaporationLevelDensityParameter::LevelDensityParameter(const G4int A,const G4int Z,
+																						const G4double U) const 
+{
+	G4int N = A - Z;
 
-
-
+	// Asymptotic Level Density Parameter
+	G4double AsymptoticLDP = (alpha*G4double(A) + beta*pow(G4double(A),2./3.)*Bs)/MeV;
+	
+	// Shape of the LDP U dependence
+	G4double exponent = -gamma*U;
+	G4double f = 1.;
+	if (exponent > -300.) f -= exp(exponent);
+	
+	// Level Density Parameter
+	G4double a = AsymptoticLDP*(1. + ShellCorrection(Z,N)*f/U);
+	
+	return a;
+}
 

source/processes/hadronic/models/generator/de_excitation/src/G4EvaporationProbability.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -41,145 +41,80 @@ G4bool G4EvaporationProbability::operator!=(const G4EvaporationProbability &righ
   return true;
 }
 
-
-G4double G4EvaporationProbability::EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation)
-  // Calculate integrated probability (width) for rvaporation channel:
-  // If fragment has A_f <= 4 it will be used Dostrovsky's
-  // approximation for the inverse reaction cross section.  If
-  // fragment has A_f > 4 it will be used Botvina's approximation for
-  // the inverse reaction cross section.
+G4double G4EvaporationProbability::EmissionProbability(const G4Fragment & fragment, const G4double anEnergy)
 {
-  // first af all a test
-  if (theChannel->GetMaximalKineticEnergy() <= 0.0 || fragment.GetExcitationEnergy() <= 0.0) return 0.0;
-  
-  // We take decision on which approximation we'll use.
-  if (theChannel->GetA() <= 4) return DostrovskyApproximation(fragment.GetA(),fragment.GetExcitationEnergy());
-  else return BotvinaApproximation(fragment.GetA(),fragment.GetExcitationEnergy());
+	G4double EmissionProbability = 0.0;
+	G4double MaximalKineticEnergy = anEnergy;
+	if (MaximalKineticEnergy > 0.0 && fragment.GetExcitationEnergy() > 0.0) {
+		EmissionProbability = CalcProbability(fragment,MaximalKineticEnergy);
+// 		// Next there is a loop over excited states for this channel summing probabilities
+// 		G4double SavedGamma = Gamma;
+// 		for (G4int i = 0; i < ExcitationEnergies->length(); i++) {
+// 			if (ExcitationSpins->operator()(i) < 0.1) continue;
+// 			Gamma = ExcitationSpins->operator()(i)*A; // A is the channel mass number
+// 			// substract excitation energies
+// 			MaximalKineticEnergy -= ExcitationEnergies->operator()(i);
+// 			// update probability
+// 			EmissionProbability += CalcProbability(fragment,MaximalKineticEnergy);
+// 				EmissionProbability += tmp;
+// 			}
+// 		// restore Gamma and MaximalKineticEnergy
+// 		MaximalKineticEnergy = SavedMaximalKineticEnergy;
+// 		Gamma = SavedGamma;
+// 		}
+	}
+	return EmissionProbability;
+}
+
+G4double G4EvaporationProbability::CalcProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy)
+  // Calculate integrated probability (width) for rvaporation channel
+{	
+	G4double ResidualA = G4double(fragment.GetA() - theA);
+	G4double ResidualZ = G4double(fragment.GetZ() - theZ);
+	G4double U = fragment.GetExcitationEnergy();
+	
+	G4double NuclearMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetNucleusMass(theZ,theA);
+
+
+	G4double delta0 = PairingCorrection(fragment.GetA(),fragment.GetZ());
+
+	G4double SystemEntropy = 2.0*sqrt(theEvapLDPptr->LevelDensityParameter(fragment.GetA(),fragment.GetZ(),U)*(U-delta0));
+								  
+	// compute the integrated probability of evaporation channel
+	G4double RN = 1.5*fermi;
+
+	G4double Alpha = CalcAlphaParam(fragment);
+	G4double Beta = CalcBetaParam(fragment);
+	
+	G4double Rmax = MaximalKineticEnergy;
+	G4double a = theEvapLDPptr->LevelDensityParameter(ResidualA,ResidualZ,Rmax);
+	G4double GlobalFactor = G4double(Gamma) * (Alpha/(a*a)) *
+									(NuclearMass*RN*RN*pow(ResidualA,2./3.))/
+									(2.*pi* hbar_Planck*hbar_Planck);
+	G4double Term1 = (2.0*Beta*a-3.0)/2.0 + Rmax*a;
+	G4double Term2 = (2.0*Beta*a-3.0)*sqrt(Rmax*a) + 2.0*a*Rmax;
+	
+	G4double ExpTerm1 = 0.0;
+	if (SystemEntropy <= 600.0) ExpTerm1 = exp(-SystemEntropy);
+	
+	G4double ExpTerm2 = 2.*sqrt(a*Rmax) - SystemEntropy;
+	if (ExpTerm2 > 700.0) ExpTerm2 = 700.0;
+	ExpTerm2 = exp(ExpTerm2);
+	
+	G4double Width = GlobalFactor*(Term1*ExpTerm1 + Term2*ExpTerm2);
+	
+	return Width;
 }
 
 
 
-G4double G4EvaporationProbability::DostrovskyApproximation(const G4int A, const G4double U)
-  // Width for evaporation channel with Dostrovsky's approximation for
-  // inverse cross section.  
+G4double G4EvaporationProbability::PairingCorrection(const G4int A, const G4int Z) const
 {
-  G4double SystemEntropy = 2.0*sqrt((theChannel->GetLevelDensityParameter()/(1./MeV)) *
-				    A * U/MeV);
- // r0 -> Absorption Radius R=r0 A^(1/3)
- G4double r0 = 2.173*(1.0+0.006103*theChannel->GetZ()*theChannel->GetResidualZ())/
-   (1.0+0.009443*theChannel->GetZ()*theChannel->GetResidualZ());   
- // compute the integrated probability of evaporation channel
-
- G4double RN = 1.5;
- G4double CC;
- if (theChannel->GetA() == 1) CC = 0.2; // neutron, proton
- // deuterium, triton, alpha, 
- else if ((theChannel->GetZ() == 1 && (theChannel->GetA() == 2 || theChannel->GetA() == 3)) ||
-	  (theChannel->GetZ() == 2 && (theChannel->GetA() == 3 || theChannel->GetA() == 4))) 
-   CC = 0.1;
- // He5, He6, Li5, Li6, ...., O17, O18
- else CC = pow(G4double(theChannel->GetA())/G4double(theChannel->GetResidualA()),2.0/3.0); 
-
-
- G4double ALFA;
- G4double BETA;
- if (theChannel->GetZ() == 0) {  // neutron 
-   ALFA = 0.76+2.2/pow(theChannel->GetResidualA(),1.0/3.0);
-   BETA = (2.12/pow(theChannel->GetResidualA(),2.0/3.0) - 0.05)/ALFA;
- } else {
-   ALFA = 1.0 + CC;
-   BETA = 0.0;
- }
-
-
- G4double Q1 = (theChannel->GetLevelDensityParameter()/(1./MeV)) * theChannel->GetResidualA();
- G4double Q2 = Q1*theChannel->GetMaximalKineticEnergy()/MeV;
- G4double Q3 = (theChannel->GetGamma()*pow(theChannel->GetResidualA(),2.0/3.0))*(ALFA/(Q1*Q1))*
-   (G4double(theChannel->GetResidualA())/G4double(theChannel->GetResidualA()+theChannel->GetA()))*
-   (pi*RN*RN)/(2.0*41.5*pi2);
- G4double Q4 = (2.0*BETA*Q1-3.0)/2.0 + Q2;
- G4double Q5 = (2.0*BETA*Q1-3.0)*(sqrt(Q2)-0.5)+2.0*Q2;
-
- G4double PEX1;
- if (SystemEntropy > 160.0) PEX1 = 0.0;
- else PEX1 = Q4*exp(-SystemEntropy);
-
- G4double PP2 = SystemEntropy - 2.0*sqrt(Q2);
-
- G4double PEX2;
- if (PP2 > 160.0) PEX2 = 0.0;
- else PEX2 = Q5*exp(-PP2);
-
- return Q3*(PEX1+PEX2);
+	const G4double PairingConstant = 12.0*MeV;
+	const G4int N = A - Z;
+	G4double Pair = (1.0 - G4double(Z) + 2.0*(Z/2)) + (1.0 - G4double(N) + 2.0*(N/2));
+	G4double PCorrection = Pair*PairingConstant/sqrt(G4double(A));
+	return PCorrection;
 }
 
 
-
-G4double G4EvaporationProbability::BotvinaApproximation(const G4int A, const G4double U)
-  // Width for evaporation channel with Botvina's approximation for
-  // inverse cross section.
-{
-
-  G4double SystemEntropy = 2.0*sqrt((theChannel->GetLevelDensityParameter()/(1./MeV))*
-				    A * U/MeV);
-  // r0 -> Absorption Radius R=r0 A^(1/3)
-  G4double r0 = 2.173*(1.0+0.006103*theChannel->GetZ()*theChannel->GetResidualZ())/
-    (1.0+0.009443*theChannel->GetZ()*theChannel->GetResidualZ());   
-
-  // compute the integrated probability of evaporation channel
-  G4double DALF = 0.869+9.91/theChannel->GetResidualZ();
-
-  G4double KinPlusCoul = theChannel->GetMaximalKineticEnergy()/MeV + theChannel->GetCoulombBarrier()/MeV;
-  if (KinPlusCoul <= theChannel->GetCoulombBarrier()/(5.0*MeV) || theChannel->GetZ() == 0) return 0.0;
-    
-  G4double CC = pow(G4double(theChannel->GetA())/G4double(theChannel->GetResidualA()),2.0/3.0);
-
-  G4double ALFA = 1.0+CC;
-
-  G4double Q1 = (theChannel->GetLevelDensityParameter()/(1./MeV)) * theChannel->GetResidualA();
-
-  G4double Q3 = theChannel->GetGamma() * pow(theChannel->GetResidualA(),2.0/3.0) * (ALFA/(Q1*Q1))
-    *(G4double(theChannel->GetResidualA())/G4double(theChannel->GetResidualA()+theChannel->GetA()))*
-    ((pi*r0*r0)/(2.0*41.5*pi2));
-
-  G4double TempMKE = theChannel->GetMaximalKineticEnergy()/MeV - 1.0;
-  G4double prob3 = 0.0;
-  if (TempMKE > 0.0) {
-    G4double Q2 = Q1*TempMKE;
-    G4double Q4 = (2.0*Q1-3.0)/2.0 + Q2;
-    G4double Q5 = (2.0*Q1-3.0)*(sqrt(Q2)-0.5)+2.0*Q2;
-    prob3 = Q3*(Q4*exp(-SystemEntropy)+Q5*exp(2.0*sqrt(Q2)-SystemEntropy));
-  }
-  G4double EX = theChannel->GetCoulombBarrier()/MeV + 1.0;
-  G4double EM = KinPlusCoul-Q1/(DALF*DALF);
-  G4double prob4 = 0.0;
-  G4double SQ = 0.0;
-  G4double CSI = 0.0;
-  G4double F1CSI = 0.0;
-  if (EM >= EX) { 
-    SQ = sqrt(Q1/(KinPlusCoul-EX));
-    G4double F1X = DALF-SQ;
-    G4double F2X = SQ/(2.0*(KinPlusCoul-EX));
-    if (F1X >= (0.5*F2X)) {
-      CSI = 0.693/F1X;
-      G4double SQCSI = sqrt(Q1/(KinPlusCoul-EX+CSI));
-      G4double F2CSI = SQCSI/(2.0*(KinPlusCoul-EX+CSI));
-      prob4 = Q3*2.0*Q1*Q1*(1.0/F1X)*
-	exp(2.0*sqrt(Q1*(KinPlusCoul-EX))-SystemEntropy-F2CSI*CSI*CSI/2.0);
-    } else {
-      CSI = 0.48/sqrt(0.5*F2X);
-      F1CSI = DALF-sqrt(Q1/(KinPlusCoul-EX+CSI));
-      prob4 = Q3*Q1*Q1*sqrt(6.2832/F2X)*
-	exp(2.0*sqrt(Q1*(KinPlusCoul-EX))-SystemEntropy-F1CSI*CSI);
-    }
-  } else if (EM < EX && EM > theChannel->GetCoulombBarrier()/(5.0*MeV)) { 
-    SQ = sqrt(Q1/(KinPlusCoul-EM));
-    G4double F2M = SQ/(2.0*(KinPlusCoul-EM));
-    CSI = 0.48/sqrt(0.5*F2M);
-    F1CSI = DALF - sqrt(Q1/(KinPlusCoul-EM+CSI));
-    prob4 = Q3*2.0*Q1*Q1*sqrt(6.2832/F2M)*
-      exp(DALF*(EM-EX)+2.0*sqrt(Q1*(KinPlusCoul-EM))-SystemEntropy-F1CSI*CSI);
-  } else return prob3;
-  return prob3+prob4;
-}
-

source/processes/hadronic/models/generator/de_excitation/src/G4ExcitationHandler.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4ExcitationHandler.cc,v 1.3.8.1 1999/12/07 20:51:37 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4ExcitationHandler.cc,v 1.6 2000/06/21 14:26:24 stesting Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (May 1998)
@@ -78,7 +78,7 @@ G4ReactionProductVector * G4ExcitationHandler::BreakItUp(const G4Fragment &theIn
   G4FragmentVector* theResult = 0; 
   G4double exEnergy = theInitialState.GetExcitationEnergy();
   G4double A = theInitialState.GetA();
-  G4int Z = theInitialState.GetZ();
+  G4int Z = G4int(theInitialState.GetZ());
   G4int Zmax = GetMaxZ();
   G4double Amax = GetMaxA();
   
@@ -113,7 +113,7 @@ G4ReactionProductVector * G4ExcitationHandler::BreakItUp(const G4Fragment &theIn
     exEnergy = theResult->at(i)->GetExcitationEnergy();
     if (exEnergy > 0.0) {
       A = theResult->at(i)->GetA();
-      Z = theResult->at(i)->GetZ();
+      Z = G4int(theResult->at(i)->GetZ());
       theExcitedNucleus = *(theResult->at(i));
       // try to de-excite this fragment
       if(A<GetMaxA()&&Z<GetMaxZ()&&
@@ -211,8 +211,8 @@ G4ExcitationHandler::Transform(G4FragmentVector * theFragmentVector) const
 
   for (G4int i = 0; i < theFragmentVector->entries(); i++) {
 //     theFragmentVector->at(i)->DumpInfo();
-    theFragmentA = theFragmentVector->at(i)->GetA();
-    theFragmentZ = theFragmentVector->at(i)->GetZ();
+    theFragmentA = G4int(theFragmentVector->at(i)->GetA());
+    theFragmentZ = G4int(theFragmentVector->at(i)->GetZ());
     theFragmentMomentum = theFragmentVector->at(i)->GetMomentum();
     theKindOfFragment = 0;
     if (theFragmentA == 0 && theFragmentZ == 0) {       // photon
@@ -246,6 +246,18 @@ G4ExcitationHandler::Transform(G4FragmentVector * theFragmentVector) const
       theFragmentVector->clearAndDestroy();
       delete theFragmentVector;
     }
+  G4int debugit;
+  for(debugit=0; debugit<theReactionProductVector->length(); debugit++)
+  {
+    if(theReactionProductVector->at(debugit)->GetTotalEnergy()<1.*eV)
+    {
+       G4cerr << "G4ExcitationHandler: Warning: Photonevaporation data not exact."<<G4endl;
+       G4cerr << "G4ExcitationHandler: Warning: Found gamma with energy = "
+              << theReactionProductVector->at(debugit)->GetTotalEnergy()/MeV << "MeV"
+              << G4endl;
+       theReactionProductVector->removeAt(debugit);
+    }
+  }
   return theReactionProductVector;
 }
 

source/processes/hadronic/models/generator/de_excitation/src/G4FissionBarrier.cc

@@ -1,12 +1,12 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4FissionBarrier.cc,v 1.1.10.1 1999/12/07 20:51:38 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4FissionBarrier.cc,v 1.3 2000/06/09 11:43:36 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
@@ -38,106 +38,39 @@ G4bool G4FissionBarrier::operator!=(const G4FissionBarrier & right) const
 
 
 
-G4double G4FissionBarrier::FissionBarrier(const G4int A, const G4int Z)
+G4double G4FissionBarrier::FissionBarrier(const G4int A, const G4int Z, const G4double U)
   // Compute fission barrier according with Barashenkov's prescription for A >= 65
 {
-  if (A >= 65) return BarashenkovFissionBarrier(A,Z)*MeV;
-  else return 1.0*GeV;
+  if (A >= 65) return BarashenkovFissionBarrier(A,Z)/(1.0 + sqrt(U/(2.0*G4double(A))));
+  else return 100.0*GeV;
 }
 
 
 G4double G4FissionBarrier::BarashenkovFissionBarrier(const G4int A, const G4int Z)
-  // Calculates Fission Barrier heights (in MeV), which are function of the nuclear 
-  // fissility parameteter x = Z*Z/A. 
-  // Barashenkov V., Iljinov A. and Toneev V. parametrization (1972)
+  // Calculates Fission Barrier heights 
 {
-  const G4double ShellCorr1[130] = {
-    20.80,  15.80,  21.00,  16.80,  19.80,
-    16.50,  18.80,  16.50,  18.50,  17.20,
-    18.26,  15.05,  16.01,  12.04,  13.27,
-    11.09,  12.17,  10.26,  11.04,   8.41,
-    9.79,   7.36,   8.15,   5.63,   5.88,
-    3.17,   3.32,   0.82,   1.83,   0.97,
-    2.33,   1.27,   2.92,   1.61,   2.91,
-    1.35,   2.40,   0.89,   1.74,   0.36,
-    0.95,  -0.65,  -0.04,  -1.73,  -0.96,
-    -2.87,  -2.05,  -4.05,  -3.40,  -5.72,
-    -3.75,  -4.13,  -2.42,  -2.85,  -1.01,
-    -1.33,   0.54,  -0.02,   1.74,   0.75,
-    2.24,   1.00,   1.98,   0.79,   1.54,
-    0.39,   1.08,   0.00,   0.78,  -0.35,
-    0.58,  -0.55,   0.59,  -0.61,   0.59,
-    -0.35,   0.32,  -0.96,  -0.52,  -2.08,
-    -2.46,  -3.64,  -1.55,  -0.96,   0.97,
-    0.88,   2.37,   1.75,   2.72,   1.90,
-    2.55,   1.46,   1.93,   0.86,   1.17,
-    0.08,   0.39,  -0.76,  -0.39,  -1.51,
-    -1.17,  -2.36,  -1.95,  -3.06,  -2.62,
-    -3.55,  -2.95,  -3.75,  -3.07,  -3.79,
-    -3.06,  -3.77,  -3.05,  -3.78,  -3.12,
-    -3.90,  -3.35,  -4.24,  -3.86,  -4.92,
-    -5.06,  -6.77,  -7.41,  -9.18, -10.16,
-    -11.12,  -9.76,  -9.23,  -7.96,  -7.65};
-  const G4double ShellCorr2[200] = {
-    -8.40, -12.90,  -8.00, -11.90,  -9.20,
-    -12.50, -10.80, -13.60, -11.20, -12.20,
-    -12.81, -15.40, -13.07, -15.80, -13.81,
-    -14.98, -12.63, -13.76, -11.37, -12.38,
-    -9.23,  -9.65,  -7.64,  -9.17,  -8.05,
-    -9.72,  -8.87, -10.76,  -8.64,  -8.89,
-    -6.60,  -7.13,  -4.77,  -5.33,  -3.06,
-    -3.79,  -1.72,  -2.79,  -0.93,  -2.19,
-    -0.52,  -1.90,  -0.45,  -2.20,  -1.22,
-    -3.07,  -2.42,  -4.37,  -3.94,  -6.08,
-    -4.49,  -4.50,  -3.14,  -2.93,  -1.04,
-    -1.36,   0.69,   0.21,   2.11,   1.33,
-    3.29,   2.46,   4.30,   3.32,   4.79,
-    3.62,   4.97,   3.64,   4.63,   3.07,
-    4.06,   2.49,   3.30,   1.46,   2.06,
-    0.51,   0.74,  -1.18,  -1.26,  -3.54,
-    -3.97,  -5.26,  -4.18,  -3.71,  -2.10,
-    -1.70,  -0.08,  -0.18,   0.94,   0.27,
-    1.13,   0.08,   0.91,  -0.31,   0.49,
-    -0.78,   0.08,  -1.15,  -0.23,  -1.41,
-    -0.42,  -1.55,  -0.55,  -1.66,  -0.66,
-    -1.73,  -0.75,  -1.74,  -0.78,  -1.69,
-    -0.78,  -1.60,  -0.75,  -1.46,  -0.67,
-    -1.26,  -0.51,  -1.04,  -0.53,  -1.84,
-    -2.42,  -4.52,  -4.76,  -6.33,  -6.76,
-    -7.81,  -5.80,  -5.37,  -3.63,  -3.35,
-    -1.75,  -1.88,  -0.61,  -0.90,   0.09,
-    -0.32,   0.55,  -0.13,   0.70,  -0.06,
-    0.49,  -0.20,   0.40,  -0.22,   0.36,
-    -0.09,   0.58,   0.12,   0.75,   0.15,
-    0.70,   0.17,   1.11,   0.89,   1.85,
-    1.62,   2.54,   2.29,   3.20,   2.91,
-    3.84,   3.53,   4.48,   4.15,   5.12,
-    4.78,   5.75,   5.39,   6.31,   5.91,
-    6.87,   6.33,   7.13,   6.61,   7.30,
-    6.31,   6.27,   4.83,   4.49,   2.85,
-    2.32,   0.58,  -0.11,  -0.98,   0.81,
-    1.77,   3.37,   4.13,   5.60,   6.15,
-    7.29,   7.35,   7.95,   7.67,   8.16,
-    7.83,   8.31,   8.01,   8.53,   8.27};
+	// Liquid drop model parameters for
+	// surface energy of a spherical nucleus
+	const G4double aSurf = 17.9439*MeV;
+	// and coulomb energy
+	const G4double aCoul = 0.7053*MeV;
+	const G4int N = A - Z;
+	const G4double k = 1.7826;
 
-  const G4int N = A - Z;
-  //  const G4double x = (static_cast<G4double>(Z)*static_cast<G4double>(Z))/
-    //    static_cast<G4double>(A);
-  const G4double x = (G4double(Z)*G4double(Z))/G4double(A);
-  G4double BF0 = 0.0;
-  if (x <= 33.5) BF0 = 12.5 + 4.7*pow((33.5-x),0.75);
-  else BF0 = 12.5 - 2.7*pow((x-33.5),2.0/3.0);
+	// fissibility parameter
+	G4double x = (aCoul/(2.0*aSurf))*(G4double(Z)*G4double(Z))/G4double(A);
+	x /= (1.0 - k*(G4double(N-Z)/G4double(A))*(G4double(N-Z)/G4double(A)));
+  
+	// Liquid drop model part of Fission Barrier
+	G4double BF0 = aSurf*pow(G4double(A),2./3.);
+	if (x <= 2./3.) BF0 *= 0.38*(3./4.-x);
+	else BF0 *= 0.83*(1. - x)*(1. - x)*(1. - x);
 
 
-  // Determine which kind of nucleus is: even-even, odd-odd, even-odd, odd-even
-  G4double D = 0.0;
-  G4int I = 2*(Z/2); 
-  G4int J = 2*(N/2);
-  if (I < Z) D = 0.0;
-  else D = -0.5;
-  if (J < N) D += 1.0;
+	// 
+	G4double D = 1.248*MeV;
+	D *= (G4double(N)-2.0*(N/2)) + (G4double(Z)-2.0*(Z/2));
 
-  if (Z > 130 || N > 200) return BF0 + D;
-  else return BF0 + D - ShellCorr1[Z-1] - ShellCorr2[N-1];
+  return BF0 + D - SellPlusPairingCorrection(Z,N);
 }
 

source/processes/hadronic/models/generator/de_excitation/src/G4FissionLevelDensityParameter.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,

source/processes/hadronic/models/generator/de_excitation/src/G4FissionParameters.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -20,36 +20,36 @@ const G4double G4FissionParameters::A2 = 141.0;
 G4FissionParameters::G4FissionParameters(const G4int A, const G4int Z, const G4double ExEnergy,
 					 const G4double FissionBarrier)
 {
-  G4double U = ExEnergy/MeV;
+  G4double U = ExEnergy; 
   
   As = A/2.0;
 
-  if (A >= 235) Sigma2 = 5.6;  // MeV
+  if (A <= 235) Sigma2 = 5.6;  // MeV
   else Sigma2 = 5.6 + 0.096*(A-235); // MeV
 
   Sigma1 = 0.5*Sigma2; // MeV
 
-  SigmaS = exp(0.00553*U + 4.1386); // MeV
-
+  SigmaS = exp(0.00553*U/MeV + 2.1386); // MeV
+	if (SigmaS > 20.0) SigmaS = 20.0;
 
   G4double FasymAsym = 2.0*exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) + 
     exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
   
-  G4double FsymA1A2 = exp(-((As-(A1+A2))*(As-(A1+A2)))/(2.0*SigmaS*SigmaS));
+  G4double FsymA1A2 = exp(-((As-(A1+A2)/2.0)*(As-(A1+A2)/2.0))/(2.0*SigmaS*SigmaS));
   
 
   G4double wa;
   G4double w1,w2;
   w = 0.0;
   if (Z >= 90) {         // Z >= 90
-    if (U <= 16.25) wa = exp(0.5385*U-9.9564);  // U <= 16.25 MeV
-    else wa = exp(0.09197*U-2.7003);            // U  > 16.25 MeV
+    if (U <= 16.25) wa = exp(0.5385*U/MeV-9.9564);  // U <= 16.25 MeV
+    else wa = exp(0.09197*U/MeV-2.7003);            // U  > 16.25 MeV
   } else if (Z == 89) {  // Z == 89
     wa = exp(0.09197*U-1.0808);
   } else if (Z >= 82) {  //  82 <= Z <= 88
-    G4double X = FissionBarrier/MeV - 7.5;
+    G4double X = FissionBarrier - 7.5*MeV;
     if (X < 0.0) X = 0.0;
-    wa = exp(0.09197*(U-X)-1.0808);
+    wa = exp(0.09197*(U-X)/MeV-1.0808);
   } else {               // Z < 82
     w = 1001.0;
   }
@@ -60,7 +60,7 @@ G4FissionParameters::G4FissionParameters(const G4int A, const G4int Z, const G4d
     
     w = w1/w2;
 
-    if (82 <= Z && Z < 89 && A < 227)  w *= exp(0.3*(A-227));
+    if (82 <= Z && Z < 89 && A < 227)  w *= exp(0.3*(227-A));
   }
   
 }

source/processes/hadronic/models/generator/de_excitation/src/G4FissionProbability.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
@@ -41,31 +41,45 @@ G4bool G4FissionProbability::operator!=(const G4FissionProbability &right) const
 }
 
 
-G4double G4FissionProbability::EmissionProbability(const G4Fragment & fragment, const G4double photonExcitation)
-  //
+G4double G4FissionProbability::EmissionProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy)
+	// Compute integrated probability of fission channel
 {
-  G4double A = fragment.GetA();
-  G4double Z = fragment.GetZ();
-  G4double U = fragment.GetExcitationEnergy();
-  G4double SystemEntropy = 2.0*sqrt((theEvapLDP.LevelDensityParameter(A,Z,U)/(1./MeV))*A*U/MeV);
+	if (MaximalKineticEnergy <= 0.0) return 0.0;
+	G4double A = fragment.GetA();
+	G4double Z = fragment.GetZ();
+	G4double U = fragment.GetExcitationEnergy();
+  
+	G4double Ucompound = U - EvaporationPairingCorrection(G4int(A),G4int(Z));
+	G4double Ufission = U - FissionPairingCorrection(G4int(A),G4int(Z));
+  
+	G4double SystemEntropy = 2.0*sqrt(theEvapLDP.LevelDensityParameter(A,Z,Ucompound)*Ucompound);
+	
+	G4double afission = theFissLDP.LevelDensityParameter(A,Z,Ufission);
 
-  // Compute integrated probability of fission channel
-  if (theChannel->GetMaximalKineticEnergy() <= 0.0) return 0.0;
+	G4double Cf = 2.0*sqrt(afission*MaximalKineticEnergy);
 
-  G4double Q1 = 2.0*sqrt((theFissLDP.LevelDensityParameter(A,Z,U)/(1./MeV))*A*
-			 theChannel->GetMaximalKineticEnergy()/MeV);
-
-  G4double Q2 = 1./(4.0*pi);
-
-  //  G4double Tfis = 21.e-6*940.0;
-
-
-  //return min(Tfis,(Q2/((theFissLDP.LevelDensityParameter(A,Z,U)/(1./MeV))*A))*
-  //	     ((Q1-1.0)*exp(Q1-SystemEntropy)+exp(-SystemEntropy)));
-
-
-   return (Q2/((theFissLDP.LevelDensityParameter(A,Z,U)/(1./MeV))*A))*
-     ((Q1-1.0)*exp(Q1-SystemEntropy)+exp(-SystemEntropy));
+	G4double Q1 = 1.0 + (Cf - 1.0)*exp(Cf);
+	G4double Q2 = 4.0*pi*afission*exp(SystemEntropy);
+	
+	G4double probability = Q1/Q2;
+ 
+	return probability;
 }
 
+G4double G4FissionProbability::EvaporationPairingCorrection(const G4int A, const G4int Z) const
+{
+	const G4double PairingConstant = 12.0*MeV;
+	const G4int N = A - Z;
+	G4double Pair = (1.0 - G4double(Z) + 2.0*(Z/2)) + (1.0 - G4double(N) + 2.0*(N/2));
+	G4double PCorrection = Pair*PairingConstant/sqrt(G4double(A));
+	return PCorrection;
+}
 
+G4double G4FissionProbability::FissionPairingCorrection(const G4int A, const G4int Z) const
+{
+	const G4double PairingConstant = 14.0*MeV;
+	const G4int N = A - Z;
+	G4double Pair = (1.0 - G4double(Z) + 2.0*(Z/2)) + (1.0 - G4double(N) + 2.0*(N/2));
+	G4double PCorrection = Pair*PairingConstant/sqrt(G4double(A));
+	return PCorrection;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4He3CoulombBarrier.cc

@@ -0,0 +1,58 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4He3CoulombBarrier.cc,v 1.1 2000/06/09 11:43:36 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+
+#include "G4He3CoulombBarrier.hh"
+
+G4He3CoulombBarrier::G4He3CoulombBarrier(const G4He3CoulombBarrier & right)
+{
+  G4Exception("G4He3CoulombBarrier::copy_constructor meant to not be accessable.");
+}
+
+
+const G4He3CoulombBarrier & G4He3CoulombBarrier::operator=(const G4He3CoulombBarrier & right)
+{
+ G4Exception("G4He3CoulombBarrier::operator= meant to not be accessable.");
+ return *this;
+}
+
+G4bool G4He3CoulombBarrier::operator==(const G4He3CoulombBarrier & right) const 
+{
+ return false;
+}
+
+G4bool G4He3CoulombBarrier::operator!=(const G4He3CoulombBarrier & right) const 
+{
+ return true;
+}
+
+
+G4double G4He3CoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// const G4double Zlist[size]  = {10.0, 20.0, 30.0, 50.0, 70.0};
+	// const G4double KHe3[size] = {0.68, 0.82, 0.91, 0.97, 0.98};
+	//
+	// K for He3 is K for alphas + 0.12
+	G4double K = 1.0;
+	if (aZ>=70.0) {
+		K = 0.98;
+	} else {
+		K = (((0.23684e-5*aZ) - 0.42143e-3)*aZ + 0.25222e-1)*aZ + 0.46699;
+	}
+	return K+0.12;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4He3EvaporationChannel.cc

@@ -0,0 +1,37 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+#include "G4He3EvaporationChannel.hh"
+
+
+const G4He3EvaporationChannel & G4He3EvaporationChannel::operator=(const G4He3EvaporationChannel & right)
+{
+	G4Exception("G4He3EvaporationChannel::operator= meant to not be accessable");
+	return *this;
+}
+
+G4He3EvaporationChannel::G4He3EvaporationChannel(const G4He3EvaporationChannel & right)
+{
+	G4Exception("G4He3EvaporationChannel::CopyConstructor meant to not be accessable");
+}
+
+G4bool G4He3EvaporationChannel::operator==(const G4He3EvaporationChannel & right) const 
+{
+	return (this == (G4He3EvaporationChannel *) &right);
+	//  return false;
+}
+
+G4bool G4He3EvaporationChannel::operator!=(const G4He3EvaporationChannel & right) const 
+{
+	return (this != (G4He3EvaporationChannel *) &right);
+	//  return true;
+}
+

source/processes/hadronic/models/generator/de_excitation/src/G4He3EvaporationProbability.cc

@@ -0,0 +1,91 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999)
+//
+
+
+#include "G4He3EvaporationProbability.hh"
+
+G4He3EvaporationProbability::G4He3EvaporationProbability() :
+		G4EvaporationProbability(3,2,6) // A,Z,Gamma
+{
+	const G4int NumExcitedStates = 31+1;
+	ExcitEnergies.reshape(NumExcitedStates);
+	ExcitSpins.reshape(NumExcitedStates);
+	for (G4int i = 0; i < NumExcitedStates; i++) {
+		ExcitEnergies(i) = 0.0;
+		ExcitSpins(i) = 0;
+	}
+	
+	ExcitEnergies(18) = 7.29*MeV;
+	ExcitEnergies(20) = 6.48*MeV;
+	ExcitEnergies(25) = 5.69*MeV;
+	ExcitEnergies(26) = 8.31*MeV;
+	ExcitEnergies(31) = 5.10*MeV;
+
+	ExcitSpins(18) = 6;
+	ExcitSpins(20) = 8;
+	ExcitSpins(25) = 3;
+	ExcitSpins(26) = 2;
+	ExcitSpins(31) = 7;	
+	
+	SetExcitationEnergiesPtr(&ExcitEnergies);
+	SetExcitationSpinsPtr(&ExcitSpins);	
+}
+
+G4He3EvaporationProbability::G4He3EvaporationProbability(const G4He3EvaporationProbability &right)
+{
+ G4Exception("G4He3EvaporationProbability::copy_constructor meant to not be accessable");
+}
+
+
+
+
+const G4He3EvaporationProbability & G4He3EvaporationProbability::
+operator=(const G4He3EvaporationProbability &right)
+{
+  G4Exception("G4He3EvaporationProbability::operator= meant to not be accessable");
+  return *this;
+}
+
+
+G4bool G4He3EvaporationProbability::operator==(const G4He3EvaporationProbability &right) const
+{
+  return false;
+}
+
+G4bool G4He3EvaporationProbability::operator!=(const G4He3EvaporationProbability &right) const
+{
+  return true;
+}
+
+G4double G4He3EvaporationProbability::CCoeficient(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+	//	G4double Calpha[5] = { 0.10, 0.10, 0.10, 0.08, 0.06};
+	// C for He3 is equal to C for alpha times 4/3
+	G4double C = 0.0;
+	
+	
+	if (aZ <= 30) {
+		C = 0.10;
+	} else if (aZ <= 50) {
+		C = 0.1 + -((aZ-50.)/20.)*0.02;
+	} else if (aZ < 70) {
+		C = 0.08 + -((aZ-70.)/20.)*0.02;
+	} else {
+		C = 0.06;
+	}
+	return C*(4.0/3.0);
+}

source/processes/hadronic/models/generator/de_excitation/src/G4NeutronCoulombBarrier.cc

@@ -0,0 +1,38 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4NeutronCoulombBarrier.cc,v 1.1 2000/06/09 11:43:36 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+
+#include "G4NeutronCoulombBarrier.hh"
+
+G4NeutronCoulombBarrier::G4NeutronCoulombBarrier(const G4NeutronCoulombBarrier & right)
+{
+  G4Exception("G4NeutronCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+
+
+const G4NeutronCoulombBarrier & G4NeutronCoulombBarrier::operator=(const G4NeutronCoulombBarrier & right)
+{
+ G4Exception("G4NeutronCoulombBarrier::operator= meant to not be accessable.");
+ return *this;
+}
+
+G4bool G4NeutronCoulombBarrier::operator==(const G4NeutronCoulombBarrier & right) const 
+{
+ return false;
+}
+
+G4bool G4NeutronCoulombBarrier::operator!=(const G4NeutronCoulombBarrier & right) const 
+{
+ return true;
+}
+

source/processes/hadronic/models/generator/de_excitation/src/G4NeutronEvaporationChannel.cc

@@ -0,0 +1,37 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+#include "G4NeutronEvaporationChannel.hh"
+
+
+const G4NeutronEvaporationChannel & G4NeutronEvaporationChannel::operator=(const G4NeutronEvaporationChannel & right)
+{
+	G4Exception("G4NeutronEvaporationChannel::operator= meant to not be accessable");
+	return *this;
+}
+
+G4NeutronEvaporationChannel::G4NeutronEvaporationChannel(const G4NeutronEvaporationChannel & right)
+{
+	G4Exception("G4NeutronEvaporationChannel::CopyConstructor meant to not be accessable");
+}
+
+G4bool G4NeutronEvaporationChannel::operator==(const G4NeutronEvaporationChannel & right) const 
+{
+	return (this == (G4NeutronEvaporationChannel *) &right);
+	//  return false;
+}
+
+G4bool G4NeutronEvaporationChannel::operator!=(const G4NeutronEvaporationChannel & right) const 
+{
+	return (this != (G4NeutronEvaporationChannel *) &right);
+	//  return true;
+}
+

source/processes/hadronic/models/generator/de_excitation/src/G4NeutronEvaporationProbability.cc

@@ -0,0 +1,96 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999)
+//
+
+
+#include "G4NeutronEvaporationProbability.hh"
+
+G4NeutronEvaporationProbability::G4NeutronEvaporationProbability() :
+		G4EvaporationProbability(1,0,2) // A,Z,Gamma
+{
+	const G4int NumExcitedStates = 31+1;
+	ExcitEnergies.reshape(NumExcitedStates);
+	ExcitSpins.reshape(NumExcitedStates);
+	for (G4int i = 0; i < NumExcitedStates; i++) {
+		ExcitEnergies(i) = 0.0;
+		ExcitSpins(i) = 0;
+	}
+	
+	ExcitEnergies( 9) = 3.56*MeV;
+	ExcitEnergies(10) = 0.48*MeV;
+	ExcitEnergies(11) = 0.98*MeV;
+	ExcitEnergies(12) = 0.43*MeV;
+	ExcitEnergies(15) = 3.37*MeV;
+	ExcitEnergies(17) = 0.72*MeV;
+	ExcitEnergies(18) = 2.13*MeV;
+	ExcitEnergies(19) = 0.95*MeV;
+	ExcitEnergies(20) = 2.00*MeV;
+	ExcitEnergies(21) = 4.44*MeV;
+	ExcitEnergies(22) = 3.09*MeV;
+	ExcitEnergies(23) = 6.09*MeV;
+	ExcitEnergies(25) = 2.31*MeV;
+	ExcitEnergies(26) = 5.28*MeV;
+	ExcitEnergies(27) = 0.12*MeV;
+	ExcitEnergies(28) = 5.22*MeV;
+	ExcitEnergies(29) = 6.10*MeV;
+	ExcitEnergies(30) = 0.87*MeV;
+	ExcitEnergies(31) = 1.98*MeV;
+
+
+	ExcitSpins( 9) = 1;
+	ExcitSpins(10) = 2;
+	ExcitSpins(11) = 3;
+	ExcitSpins(12) = 2;
+	ExcitSpins(15) = 5;
+	ExcitSpins(17) = 3;
+	ExcitSpins(18) = 2;
+	ExcitSpins(19) = 5;
+	ExcitSpins(20) = 2;
+	ExcitSpins(21) = 5;
+	ExcitSpins(22) = 2;
+	ExcitSpins(23) = 3;
+	ExcitSpins(25) = 1;
+	ExcitSpins(26) = 8;
+	ExcitSpins(27) = 1;
+	ExcitSpins(28) = 8;
+	ExcitSpins(29) = 8;
+	ExcitSpins(30) = 2;
+	ExcitSpins(31) = 5;
+
+	SetExcitationEnergiesPtr(&ExcitEnergies);
+	SetExcitationSpinsPtr(&ExcitSpins);
+}
+
+
+G4NeutronEvaporationProbability::G4NeutronEvaporationProbability(const G4NeutronEvaporationProbability &right)
+{
+ G4Exception("G4NeutronEvaporationProbability::copy_constructor meant to not be accessable");
+}
+
+
+
+
+const G4NeutronEvaporationProbability & G4NeutronEvaporationProbability::
+operator=(const G4NeutronEvaporationProbability &right)
+{
+  G4Exception("G4NeutronEvaporationProbability::operator= meant to not be accessable");
+  return *this;
+}
+
+
+G4bool G4NeutronEvaporationProbability::operator==(const G4NeutronEvaporationProbability &right) const
+{
+  return false;
+}
+
+G4bool G4NeutronEvaporationProbability::operator!=(const G4NeutronEvaporationProbability &right) const
+{
+  return true;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4NuclearLevelManager.cc

@@ -86,8 +86,12 @@ G4bool G4NuclearLevelManager::IsValid(G4int Z, G4int A) const
   G4std::ostrstream ost(name, 100, G4std::ios::out);
   ost << dirName << "/" << "z" << Z << ".a" << A;
   G4String file(name); 
-  
-  G4std::ifstream inFile(file);
+
+#ifdef G4USE_STD_NAMESPACE  
+  G4std::ifstream inFile(file, G4std::ios::in);
+#else
+  ifstream inFile(file, ios::in|ios::nocreate);
+#endif
   if (! inFile) valid = false;  
 
   return valid;
@@ -210,9 +214,11 @@ void G4NuclearLevelManager::MakeLevels()
   G4std::ostrstream ost(name, 100, G4std::ios::out);
   ost << dirName << "/" << "z" << _nucleusZ << ".a" << _nucleusA;
   G4String file(name); 
-  
+#ifdef G4USE_STD_NAMESPACE  
   G4std::ifstream inFile(file, G4std::ios::in);
-  
+#else
+  ifstream inFile(file, ios::in|ios::nocreate);
+#endif
   if (! inFile) 
     {
       //      G4cout << " G4NuclearLevelManager: (" << _nucleusZ << "," << _nucleusA 

source/processes/hadronic/models/generator/de_excitation/src/G4ProtonCoulombBarrier.cc

@@ -0,0 +1,56 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4ProtonCoulombBarrier.cc,v 1.1 2000/06/09 11:43:36 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+
+#include "G4ProtonCoulombBarrier.hh"
+
+G4ProtonCoulombBarrier::G4ProtonCoulombBarrier(const G4ProtonCoulombBarrier & right)
+{
+  G4Exception("G4ProtonCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+
+
+const G4ProtonCoulombBarrier & G4ProtonCoulombBarrier::operator=(const G4ProtonCoulombBarrier & right)
+{
+ G4Exception("G4ProtonCoulombBarrier::operator= meant to not be accessable.");
+ return *this;
+}
+
+G4bool G4ProtonCoulombBarrier::operator==(const G4ProtonCoulombBarrier & right) const 
+{
+ return false;
+}
+
+G4bool G4ProtonCoulombBarrier::operator!=(const G4ProtonCoulombBarrier & right) const 
+{
+ return true;
+}
+
+
+G4double G4ProtonCoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// const G4double Zlist[size] = {10.0, 20.0, 30.0, 50.0, 70.0};
+	// const G4double Kprot[size] = {0.42, 0.58, 0.68, 0.77, 0.80};
+	G4double K = 1.0;
+	if (aZ>=70.0) {
+		K = 0.80;
+	} else {
+		K = (((0.2357e-5*aZ) - 0.42679e-3)*aZ + 0.27035e-1)*aZ + 0.19025;
+	}
+	return K;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4ProtonEvaporationChannel.cc

@@ -0,0 +1,38 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+#include "G4ProtonEvaporationChannel.hh"
+
+
+const G4ProtonEvaporationChannel & G4ProtonEvaporationChannel::operator=(const G4ProtonEvaporationChannel & right)
+{
+	G4Exception("G4ProtonEvaporationChannel::operator= meant to not be accessable");
+	return *this;
+}
+
+G4ProtonEvaporationChannel::G4ProtonEvaporationChannel(const G4ProtonEvaporationChannel & right)
+{
+	G4Exception("G4ProtonEvaporationChannel::CopyConstructor meant to not be accessable");
+}
+
+G4bool G4ProtonEvaporationChannel::operator==(const G4ProtonEvaporationChannel & right) const 
+{
+	return (this == (G4ProtonEvaporationChannel *) &right);
+	//  return false;
+}
+
+G4bool G4ProtonEvaporationChannel::operator!=(const G4ProtonEvaporationChannel & right) const 
+{
+	return (this != (G4ProtonEvaporationChannel *) &right);
+	//  return true;
+}
+
+

source/processes/hadronic/models/generator/de_excitation/src/G4ProtonEvaporationProbability.cc

@@ -0,0 +1,103 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999)
+//
+
+
+#include "G4ProtonEvaporationProbability.hh"
+
+G4ProtonEvaporationProbability::G4ProtonEvaporationProbability() :
+		G4EvaporationProbability(1,1,2) // A,Z,Gamma
+{
+	const G4int NumExcitedStates = 31+1;
+	ExcitEnergies.reshape(NumExcitedStates);
+	ExcitSpins.reshape(NumExcitedStates);
+	for (G4int i = 0; i < NumExcitedStates; i++) {
+		ExcitEnergies(i) = 0.0;
+		ExcitSpins(i) = 0;
+	}
+	ExcitEnergies(15) = 5.96*MeV;
+	ExcitEnergies(17) = 1.74*MeV;
+	ExcitEnergies(18) = 4.44*MeV;
+	ExcitEnergies(19) = 1.67*MeV;
+	ExcitEnergies(20) = 4.32*MeV;
+	ExcitEnergies(22) = 3.68*MeV;
+	ExcitEnergies(23) = 6.69*MeV;
+	ExcitEnergies(25) = 3.95*MeV;
+	ExcitEnergies(26) = 6.32*MeV;
+	ExcitEnergies(27) = 0.30*MeV;
+	ExcitEnergies(28) = 6.18*MeV;
+	ExcitEnergies(29) = 6.92*MeV;
+	ExcitEnergies(30) = 3.06*MeV;
+	ExcitEnergies(31) = 3.57*MeV;
+
+
+	ExcitSpins(15) = 8;
+	ExcitSpins(17) = 1;
+	ExcitSpins(18) = 6;
+	ExcitSpins(19) = 5;
+	ExcitSpins(20) = 6;
+	ExcitSpins(22) = 4;
+	ExcitSpins(23) = 8;
+	ExcitSpins(25) = 3;
+	ExcitSpins(26) = 4;
+	ExcitSpins(27) = 7;
+	ExcitSpins(28) = 4;
+	ExcitSpins(29) = 5;
+	ExcitSpins(30) = 2;
+	ExcitSpins(31) = 10;
+	
+	SetExcitationEnergiesPtr(&ExcitEnergies);
+	SetExcitationSpinsPtr(&ExcitSpins);	
+	
+}
+
+G4ProtonEvaporationProbability::G4ProtonEvaporationProbability(const G4ProtonEvaporationProbability &right)
+{
+ G4Exception("G4ProtonEvaporationProbability::copy_constructor meant to not be accessable");
+}
+
+const G4ProtonEvaporationProbability & G4ProtonEvaporationProbability::
+operator=(const G4ProtonEvaporationProbability &right)
+{
+  G4Exception("G4ProtonEvaporationProbability::operator= meant to not be accessable");
+  return *this;
+}
+
+
+G4bool G4ProtonEvaporationProbability::operator==(const G4ProtonEvaporationProbability &right) const
+{
+  return false;
+}
+
+G4bool G4ProtonEvaporationProbability::operator!=(const G4ProtonEvaporationProbability &right) const
+{
+  return true;
+}
+
+G4double G4ProtonEvaporationProbability::CCoeficient(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+	// G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
+	G4double C = 0.0;
+	
+	if (aZ >= 70) {
+		C = 0.10;
+	} else {
+		C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+	}
+	
+	return C;
+	
+}

source/processes/hadronic/models/generator/de_excitation/src/G4TritonCoulombBarrier.cc

@@ -0,0 +1,58 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4TritonCoulombBarrier.cc,v 1.1 2000/06/09 11:43:36 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+
+#include "G4TritonCoulombBarrier.hh"
+
+G4TritonCoulombBarrier::G4TritonCoulombBarrier(const G4TritonCoulombBarrier & right)
+{
+  G4Exception("G4TritonCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+
+
+const G4TritonCoulombBarrier & G4TritonCoulombBarrier::operator=(const G4TritonCoulombBarrier & right)
+{
+ G4Exception("G4TritonCoulombBarrier::operator= meant to not be accessable.");
+ return *this;
+}
+
+G4bool G4TritonCoulombBarrier::operator==(const G4TritonCoulombBarrier & right) const 
+{
+ return false;
+}
+
+G4bool G4TritonCoulombBarrier::operator!=(const G4TritonCoulombBarrier & right) const 
+{
+ return true;
+}
+
+
+G4double G4TritonCoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// const G4double Zlist[size] = {10.0, 20.0, 30.0, 50.0, 70.0};
+	// const G4double Kprot[size] = {0.42, 0.58, 0.68, 0.77, 0.80};
+	// 
+	// K for Triton is K for protons + 0.12
+	G4double K = 1.0;
+	if (aZ>=70.0) {
+		K = 0.80;
+	} else {
+		K = (((0.2357e-5*aZ) - 0.42679e-3)*aZ + 0.27035e-1)*aZ + 0.19025;
+	}
+	return K+0.12;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4TritonEvaporationChannel.cc

@@ -0,0 +1,36 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov. 1999)
+//
+
+#include "G4TritonEvaporationChannel.hh"
+
+
+const G4TritonEvaporationChannel & G4TritonEvaporationChannel::operator=(const G4TritonEvaporationChannel & right)
+{
+	G4Exception("G4TritonEvaporationChannel::operator= meant to not be accessable");
+	return *this;
+}
+
+G4TritonEvaporationChannel::G4TritonEvaporationChannel(const G4TritonEvaporationChannel & right)
+{
+	G4Exception("G4TritonEvaporationChannel::CopyConstructor meant to not be accessable");
+}
+
+G4bool G4TritonEvaporationChannel::operator==(const G4TritonEvaporationChannel & right) const 
+{
+	return (this == (G4TritonEvaporationChannel *) &right);
+	//  return false;
+}
+
+G4bool G4TritonEvaporationChannel::operator!=(const G4TritonEvaporationChannel & right) const 
+{
+	return (this != (G4TritonEvaporationChannel *) &right);
+	//  return true;
+}

source/processes/hadronic/models/generator/de_excitation/src/G4TritonEvaporationProbability.cc

@@ -0,0 +1,96 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Nov 1999)
+//
+
+
+#include "G4TritonEvaporationProbability.hh"
+
+G4TritonEvaporationProbability::G4TritonEvaporationProbability() :
+		G4EvaporationProbability(3,1,6) // A,Z,Gamma
+{
+	const G4int NumExcitedStates = 31+1;
+	ExcitEnergies.reshape(NumExcitedStates);
+	ExcitSpins.reshape(NumExcitedStates);
+	for (G4int i = 0; i < NumExcitedStates; i++) {
+		ExcitEnergies(i) = 0.0;
+		ExcitSpins(i) = 0;
+	}
+	
+	ExcitEnergies(15) = 6.26*MeV;
+	ExcitEnergies(17) = 3.59*MeV;
+	ExcitEnergies(18) = 6.76*MeV;
+	ExcitEnergies(20) = 6.34*MeV;
+	ExcitEnergies(23) = 7.34*MeV;
+	ExcitEnergies(25) = 5.11*MeV;
+	ExcitEnergies(26) = 7.57*MeV;
+	ExcitEnergies(28) = 7.28*MeV;
+	ExcitEnergies(31) = 4.46*MeV;
+
+	ExcitSpins(15) = 5;
+	ExcitSpins(17) = 5;
+	ExcitSpins(18) = 10;
+	ExcitSpins(20) = 2;
+	ExcitSpins(23) = 5;
+	ExcitSpins(25) = 5;
+	ExcitSpins(26) = 8;
+	ExcitSpins(28) = 8;
+	ExcitSpins(31) = 3;
+
+	SetExcitationEnergiesPtr(&ExcitEnergies);
+	SetExcitationSpinsPtr(&ExcitSpins);	
+}
+
+G4TritonEvaporationProbability::G4TritonEvaporationProbability(const G4TritonEvaporationProbability &right)
+{
+ G4Exception("G4TritonEvaporationProbability::copy_constructor meant to not be accessable");
+}
+
+
+
+
+const G4TritonEvaporationProbability & G4TritonEvaporationProbability::
+operator=(const G4TritonEvaporationProbability &right)
+{
+  G4Exception("G4TritonEvaporationProbability::operator= meant to not be accessable");
+  return *this;
+}
+
+
+G4bool G4TritonEvaporationProbability::operator==(const G4TritonEvaporationProbability &right) const
+{
+  return false;
+}
+
+G4bool G4TritonEvaporationProbability::operator!=(const G4TritonEvaporationProbability &right) const
+{
+  return true;
+}
+
+G4double G4TritonEvaporationProbability::CCoeficient(const G4double aZ) const
+{
+	// Data comes from 
+	// Dostrovsky, Fraenkel and Friedlander
+	// Physical Review, vol 116, num. 3 1959
+	// 
+	// const G4int size = 5;
+	// G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+	// G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
+	// C for triton is equal to C for protons divided by 3
+	G4double C = 0.0;
+	
+	if (aZ >= 70) {
+		C = 0.10;
+	} else {
+		C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+	}
+	
+	return C/3.0;
+	
+}

source/processes/hadronic/models/generator/de_excitation/src/G4VCoulombBarrier.cc

@@ -0,0 +1,56 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VCoulombBarrier.cc,v 1.1 2000/06/09 11:43:37 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
+//
+// Hadronic Process: Nuclear De-excitations
+// by V. Lara (Dec 1999)
+
+
+#include "G4VCoulombBarrier.hh"
+#include "g4std/strstream"
+
+G4VCoulombBarrier::G4VCoulombBarrier(const G4int anA, const G4int aZ)
+{
+	if (anA >= aZ && anA > 0) {
+		theA = anA;
+		theZ = aZ;
+	} else {
+		char errMessage[1024];
+		G4std::ostrstream errOs(errMessage,1024);
+		errOs << "G4VCoulombBarrier::G4VCoulombBarrier: ";
+		errOs << "Wrong values for ";
+		errOs << "A = " << anA << " ";
+		errOs << "and Z = " << aZ << G4endl;
+		G4Exception(errMessage);
+	}
+}
+
+
+G4VCoulombBarrier::G4VCoulombBarrier(const G4VCoulombBarrier & right)
+{
+  G4Exception("G4VCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+
+
+const G4VCoulombBarrier & G4VCoulombBarrier::operator=(const G4VCoulombBarrier & right)
+{
+ G4Exception("G4VCoulombBarrier::operator= meant to not be accessable.");
+ return *this;
+}
+
+G4bool G4VCoulombBarrier::operator==(const G4VCoulombBarrier & right) const 
+{
+ return false;
+}
+
+G4bool G4VCoulombBarrier::operator!=(const G4VCoulombBarrier & right) const 
+{
+ return true;
+}
+

source/processes/hadronic/models/generator/de_excitation/src/G4VEmissionProbability.cc

@@ -1,5 +1,5 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,

source/processes/hadronic/models/generator/de_excitation/src/G4VFissionBarrier.cc

@@ -1,12 +1,12 @@
 // This code implementation is the intellectual property of
-// the GEANT4 collaboration.
+// the RD44 GEANT4 collaboration.
 //
 // By copying, distributing or modifying the Program (or any work
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VFissionBarrier.cc,v 1.1.10.1 1999/12/07 20:51:41 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VFissionBarrier.cc,v 1.3 2000/06/09 11:43:37 larazb Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)

source/processes/hadronic/models/generator/diffractive_string/include/G4DiffractiveHHScatterer.hh

@@ -5,7 +5,7 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4DiffractiveHHScatterer.hh,v 1.1.10.1 1999/12/07 20:51:42 gunter Exp $
+// $Id: G4DiffractiveHHScatterer.hh,v 1.2 1999/12/15 14:52:22 gunter Exp $
 
 #ifndef G4DiffractiveHHScatterer_h
 #define G4DiffractiveHHScatterer_h 1

source/processes/hadronic/models/generator/diffractive_string/include/G4DiffractiveSplitableHadron.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4DiffractiveSplitableHadron.hh,v 1.2.8.1 1999/12/07 20:51:42 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4DiffractiveSplitableHadron.hh,v 1.3 1999/12/15 14:52:22 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 
 #ifndef G4DiffractiveSplitableHadron_h

source/processes/hadronic/models/generator/diffractive_string/include/G4FTFModel.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4FTFModel.hh,v 1.2.4.1 1999/12/07 20:51:43 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4FTFModel.hh,v 1.3 1999/12/15 14:52:22 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 #ifndef G4FTFModel_h
 #define G4FTFModel_h 1

source/processes/hadronic/models/generator/diffractive_string/include/G4FTFParticipants.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4FTFParticipants.hh,v 1.1.8.1.2.1 1999/12/07 20:51:43 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4FTFParticipants.hh,v 1.3 1999/12/15 14:52:23 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 
 #ifndef G4FTFParticipants_h

source/processes/hadronic/models/generator/diffractive_string/src/G4DiffractiveSplitableHadron.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4DiffractiveSplitableHadron.cc,v 1.1.10.1.2.1 1999/12/10 15:42:06 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4DiffractiveSplitableHadron.cc,v 1.2 1999/12/15 14:52:23 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 
 // ------------------------------------------------------------

source/processes/hadronic/models/generator/diffractive_string/src/G4FTFModel.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4FTFModel.cc,v 1.2.2.1.2.1.2.1 1999/12/08 17:34:41 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4FTFModel.cc,v 1.4 1999/12/15 14:52:23 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 
 // ------------------------------------------------------------

source/processes/hadronic/models/generator/diffractive_string/src/G4FTFParticipants.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4FTFParticipants.cc,v 1.1.10.1.2.1 1999/12/08 17:34:42 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4FTFParticipants.cc,v 1.2 1999/12/15 14:52:24 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // ------------------------------------------------------------
 //      GEANT 4 class implementation file

source/processes/hadronic/models/generator/high_energy/include/G4TheoFSGenerator.hh

@@ -6,7 +6,7 @@
 // and all its terms.
 //
 // $Id: G4TheoFSGenerator.hh,v 1.2 1999/04/12 15:45:28 hpw Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 #ifndef G4TheoFSGenerator_h
 #define G4TheoFSGenerator_h 1

source/processes/hadronic/models/generator/high_energy/src/G4TheoFSGenerator.cc

@@ -6,7 +6,7 @@
 // and all its terms.
 //
 // $Id: G4TheoFSGenerator.cc,v 1.3 1999/04/18 11:30:49 hpw Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // G4TheoFSGenerator
 #include "G4DynamicParticle.hh"

source/processes/hadronic/models/generator/management/include/G4V3DNucleus.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4V3DNucleus.hh,v 1.2.8.1 1999/12/07 20:51:43 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4V3DNucleus.hh,v 1.3 1999/12/15 14:52:37 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 #ifndef G4V3DNucleus_h
 #define G4V3DNucleus_h 1

source/processes/hadronic/models/generator/management/include/G4VHighEnergyGenerator.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VHighEnergyGenerator.hh,v 1.2.8.1 1999/12/07 20:51:44 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VHighEnergyGenerator.hh,v 1.3 1999/12/15 14:52:37 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 #ifndef G4VHighEnergyGenerator_h
 #define G4VHighEnergyGenerator_h 1

source/processes/hadronic/models/generator/management/include/G4VIntraNuclearTransportModel.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VIntraNuclearTransportModel.hh,v 1.3.8.1 1999/12/07 20:51:44 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VIntraNuclearTransportModel.hh,v 1.4 1999/12/15 14:52:37 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // $Id: G4IntraNuclearTransportMode.hh,v 1.0 1998/06/30
 // -----------------------------------------------------------------------------

source/processes/hadronic/models/generator/management/include/G4VKineticNucleon.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VKineticNucleon.hh,v 1.1.8.1 1999/12/07 20:51:44 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VKineticNucleon.hh,v 1.2 1999/12/15 14:52:37 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 #ifndef G4VKineticNucleon_h
 #define G4VKineticNucleon_h 1

source/processes/hadronic/models/generator/management/include/G4VNuclearDensity.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VNuclearDensity.hh,v 1.1.10.1 1999/12/07 20:51:44 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VNuclearDensity.hh,v 1.3 2000/05/23 13:41:56 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 #ifndef G4VNuclearDensity_h
 #define G4VNuclearDensity_h 1
@@ -28,11 +28,12 @@ class G4VNuclearDensity
     };
     
     virtual G4double GetRelativeDensity(G4ThreeVector aPosition) = 0;
-   
-    virtual G4double GetRadius(const G4double maxRelativeDenisty) = 0 ;
+    virtual G4double GetRadius(const G4double maxRelativeDenisty) = 0;
+    virtual G4double GetDeriv(const G4ThreeVector & point) = 0;    
 
   protected:    
     inline void Setrho0(G4double arho0) { rho0=arho0; };
+    inline G4double Getrho0() { return rho0; };
    
   private:
   

source/processes/hadronic/models/generator/management/include/G4VPreCompoundModel.hh

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VPreCompoundModel.hh,v 1.2.8.1 1999/12/07 20:51:44 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VPreCompoundModel.hh,v 1.3 1999/12/15 14:52:37 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 
 #ifndef G4VPreCompoundModel_h

source/processes/hadronic/models/generator/management/src/G4V3DNucleus.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4V3DNucleus.cc,v 1.1.10.1 1999/12/07 20:51:45 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4V3DNucleus.cc,v 1.2 1999/12/15 14:52:38 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 #include "G4V3DNucleus.hh"
 

source/processes/hadronic/models/generator/management/src/G4VHighEnergyGenerator.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VHighEnergyGenerator.cc,v 1.1.10.1 1999/12/07 20:51:46 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VHighEnergyGenerator.cc,v 1.2 1999/12/15 14:52:38 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // G4VHighEnergyGenerator
 #include "G4VHighEnergyGenerator.hh"

source/processes/hadronic/models/generator/management/src/G4VIntraNuclearTransportModel.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VIntraNuclearTransportModel.cc,v 1.2.8.1 1999/12/07 20:51:46 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VIntraNuclearTransportModel.cc,v 1.3 1999/12/15 14:52:38 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 // $Id: G4VIntraNuclearTransportModel.cc,v 1.0 1998/06/30
 // -----------------------------------------------------------------------------

source/processes/hadronic/models/generator/management/src/G4VKineticNucleon.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VKineticNucleon.cc,v 1.1.8.1 1999/12/07 20:51:46 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VKineticNucleon.cc,v 1.2 1999/12/15 14:52:38 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 #include "G4VKineticNucleon.hh"
 

source/processes/hadronic/models/generator/management/src/G4VNuclearDensity.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VNuclearDensity.cc,v 1.1.10.1 1999/12/07 20:51:46 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VNuclearDensity.cc,v 1.2 1999/12/15 14:52:38 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 
 #include "G4VNuclearDensity.hh"

source/processes/hadronic/models/generator/management/src/G4VPreCompoundModel.cc

@@ -5,8 +5,8 @@
 // based on the Program) you indicate your acceptance of this statement,
 // and all its terms.
 //
-// $Id: G4VPreCompoundModel.cc,v 1.1.10.1 1999/12/07 20:51:46 gunter Exp $
-// GEANT4 tag $Name: geant4-01-01 $
+// $Id: G4VPreCompoundModel.cc,v 1.2 1999/12/15 14:52:38 gunter Exp $
+// GEANT4 tag $Name: geant4-02-00 $
 //
 
 #include "G4VPreCompoundModel.hh"