Import Geant4 4.0.0 source tree

source/processes/hadronic/models/GNUmakefile

@@ -1,4 +1,4 @@
-# $Id: GNUmakefile,v 1.5 2000/06/27 15:24:19 gcosmo Exp $
+# $Id: GNUmakefile,v 1.8 2001/11/16 14:19:19 hpw Exp $
 # --------------------------------------------------------------
 # GNUmakefile for hadronic models library. G.Folger 10-Dec-97
 # --------------------------------------------------------------
@@ -20,12 +20,22 @@ SUBDIRS += generator/string_common
 SUBDIRS += generator/string_fragmentation
 SUBDIRS += generator/util
 SUBDIRS += radiative_decay
+SUBDIRS += chiral_inv_phase_space/body
+SUBDIRS += chiral_inv_phase_space/interface
+SUBDIRS += coherent_elastic
+SUBDIRS += cascade/evaporation
+SUBDIRS += cascade/utils
 
 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_radioactivedecay
 SUBLIBS += G4hadronic_qgstring G4hadronic_string_common
 SUBLIBS += G4hadronic_stringfrag G4hadronic_util_gen
+SUBLIBS += G4hadronic_body_ci
+SUBLIBS += G4hadronic_interface_ci
+SUBLIBS += G4hadronic_coherent_elastic
+SUBLIBS += G4hadronic_hetcpp_evaporation
+SUBLIBS += G4hadronic_hetcpp_utils
 
 ifndef G4INSTALL
   G4INSTALL = ../../../..

source/processes/hadronic/models/cascade/GNUmakefile

@@ -0,0 +1,18 @@
+# --------------------------------------------------------------
+# GNUmakefile for chips library. HPW 20-Nov-99
+# --------------------------------------------------------------
+
+name := G4hadronic_hetcpp
+
+SUBDIRS  =  evaporation
+SUBDIRS  +=  utils
+
+SUBLIBS  = G4hadronic_hetcpp_evaporation
+SUBLIBS  += G4hadronic_hetcpp_utils
+
+ifndef G4INSTALL
+  G4INSTALL = ../../../../..
+endif
+
+
+include $(G4INSTALL)/config/globlib.gmk

source/processes/hadronic/models/cascade/evaporation/GNUmakefile

@@ -0,0 +1,36 @@
+# $Id: GNUmakefile,v 1.5 2001/11/16 14:22:18 hpw Exp $
+# -----------------------------------------------------------
+# GNUmakefile for hadronic library.  Gabriele Cosmo, 18/9/96.
+# -----------------------------------------------------------
+
+name := G4hadronic_hetcpp_evaporation
+
+ifndef G4INSTALL
+  G4INSTALL = ../../../../../..
+endif
+
+include $(G4INSTALL)/config/architecture.gmk
+
+CPPFLAGS += -I$(G4BASE)/global/management/include \
+            -I$(G4BASE)/global/HEPRandom/include \
+            -I$(G4BASE)/global/HEPGeometry/include \
+            -I$(G4BASE)/track/include \
+            -I$(G4BASE)/geometry/volumes/include \
+            -I$(G4BASE)/geometry/management/include \
+            -I$(G4BASE)/processes/management/include \
+            -I$(G4BASE)/processes/hadronic/management/include/ \
+            -I$(G4BASE)/processes/hadronic/util/include \
+            -I$(G4BASE)/processes/hadronic/cross_sections/include/ \
+            -I$(G4BASE)/processes/hadronic/models/generator/management/include/ \
+            -I$(G4BASE)/processes/hadronic/models/generator/util/include/ \
+            -I$(G4BASE)/processes/hadronic/models/generator/de_excitation/include/ \
+            -I$(G4BASE)/processes/hadronic/models/cascade/utils/include \
+            -I$(G4BASE)/particles/management/include \
+            -I$(G4BASE)/particles/leptons/include \
+            -I$(G4BASE)/particles/bosons/include \
+            -I$(G4BASE)/particles/hadrons/mesons/include \
+            -I$(G4BASE)/particles/hadrons/barions/include \
+            -I$(G4BASE)/particles/hadrons/ions/include \
+            -I$(G4BASE)/materials/include
+           
+include $(G4INSTALL)/config/common.gmk

source/processes/hadronic/models/cascade/evaporation/include/G4BEChargedChannel.hh

@@ -0,0 +1,55 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BEChargedChannel_h
+#define G4BEChargedChannel_h 1
+
+#include "globals.hh"
+#include "G4BertiniEvaporationChannel.hh"
+#include "Randomize.hh"
+
+class G4BEChargedChannel : public G4BertiniEvaporationChannel
+{
+public:
+  G4BEChargedChannel();
+  virtual ~G4BEChargedChannel(); 
+  
+  virtual void calculateProbability();
+  virtual G4DynamicParticle * emit() = 0;
+  virtual G4double coulombFactor() = 0;
+  G4double coulombFactorForProton();
+  G4double qmFactorForProton();
+  G4double qmFactorForAlpha();
+  G4double sampleKineticEnergy();
+  
+protected:  
+  G4double A;
+  G4double spin;
+};
+
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BEDeuteronChannel.hh

@@ -0,0 +1,48 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BEDeuteronChannel_h
+#define G4BEDeuteronChannel_h 1
+
+#include "G4BEChargedChannel.hh"
+
+class G4BEDeuteronChannel : public G4BEChargedChannel
+{
+public:
+  G4BEDeuteronChannel();
+  virtual ~G4BEDeuteronChannel(); 
+
+  G4DynamicParticle * emit();
+  G4double constant();
+  virtual G4double coulombFactor();
+  virtual G4double qmFactor( );
+  
+private:  
+};
+
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BEGammaDeexcitation.hh

@@ -0,0 +1,59 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BEGammaDeexcitation_h
+#define G4BEGammaDeexcitation_h 1
+
+#include "globals.hh"
+
+class G4BEGammaDeexcitation
+{
+public:
+  G4BEGammaDeexcitation();
+  virtual ~G4BEGammaDeexcitation();
+
+  void setVerboseLevel( G4int verbose ); 
+
+  void setNucleusA( G4int inputA );
+  void setNucleusZ( G4int inputZ );
+  void setExcitationEnergy( G4double inputE );
+
+  G4DynamicParticle * emit();
+
+private:  
+  G4double sampleKineticEnergy();
+  G4int verboseLevel;
+  G4int nucleusA;
+  G4int nucleusZ;
+  G4double excitationEnergy;
+  void isotropicCosines( G4double&,
+			 G4double&,
+			 G4double& );
+};
+
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BEHe3Channel.hh

@@ -0,0 +1,48 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BEHe3Channel_h
+#define G4BEHe3Channel_h 1
+
+#include "G4BEChargedChannel.hh"
+
+class G4BEHe3Channel : public G4BEChargedChannel
+{
+public:
+  G4BEHe3Channel();
+  virtual ~G4BEHe3Channel(); 
+
+  G4DynamicParticle * emit();
+  G4double constant();
+  virtual G4double coulombFactor();
+  virtual G4double qmFactor( );
+  
+private:  
+};
+
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BEHe4Channel.hh

@@ -0,0 +1,48 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BEHe4Channel_h
+#define G4BEHe4Channel_h 1
+
+#include "G4BEChargedChannel.hh"
+
+class G4BEHe4Channel : public G4BEChargedChannel
+{
+public:
+  G4BEHe4Channel();
+  virtual ~G4BEHe4Channel(); 
+
+  G4DynamicParticle * emit();
+  G4double constant();
+  virtual G4double coulombFactor();
+  virtual G4double qmFactor( );
+  
+private:  
+};
+
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BENeutronChannel.hh

@@ -0,0 +1,50 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BENeutronChannel_h
+#define G4BENeutronChannel_h 1
+
+#include "globals.hh"
+#include "G4BertiniEvaporationChannel.hh"
+
+class G4BENeutronChannel : public G4BertiniEvaporationChannel
+{
+public:
+  G4BENeutronChannel();
+  virtual ~G4BENeutronChannel(); 
+
+  virtual void calculateProbability();
+
+  G4DynamicParticle * emit();
+  G4double sampleKineticEnergy();
+
+private:  
+  G4double alpha();
+  G4double beta();
+};
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BEProtonChannel.hh

@@ -0,0 +1,48 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, 30-May-2000
+
+#ifndef G4BEProtonChannel_h
+#define G4BEProtonChannel_h 1
+
+#include "G4BEChargedChannel.hh"
+
+class G4BEProtonChannel : public G4BEChargedChannel
+{
+public:
+  G4BEProtonChannel();
+  virtual ~G4BEProtonChannel(); 
+
+  G4DynamicParticle * emit();
+  G4double constant();
+  virtual G4double coulombFactor();
+  virtual G4double qmFactor( );
+  
+private:  
+};
+
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BETritonChannel.hh

@@ -0,0 +1,48 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BETritonChannel_h 
+#define G4BETritonChannel_h 1
+
+#include "G4BEChargedChannel.hh"
+
+class G4BETritonChannel : public G4BEChargedChannel
+{
+public:
+  G4BETritonChannel();
+  virtual ~G4BETritonChannel(); 
+
+  G4DynamicParticle * emit();
+  G4double constant();
+  virtual G4double coulombFactor();
+  virtual G4double qmFactor( );
+  
+private:  
+};
+
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BertiniEvaporation.hh

@@ -0,0 +1,65 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BertiniEvaporation_h
+#define G4BertiniEvaporation_h 1
+
+#include "globals.hh"
+#include "G4LayeredNucleus.hh"
+#include "G4BertiniEvaporationChannel.hh"
+#include "G4ParticleChange.hh"   
+#include "G4VEvaporation.hh"
+
+
+class G4BertiniEvaporation : public G4VEvaporation
+{
+
+public:
+  G4BertiniEvaporation();
+  ~G4BertiniEvaporation(); 
+
+  virtual G4FragmentVector * BreakItUp(const G4Fragment &theNucleus)
+  {
+    G4LayeredNucleus aNuc( theNucleus.GetA(), theNucleus.GetZ() );
+    aNuc.AddExcitationEnergy(theNucleus.GetExcitationEnergy());
+    return BreakItUp(aNuc);
+  }
+  G4FragmentVector * BreakItUp( G4LayeredNucleus & nucleus);
+  void setVerboseLevel( const G4int verbose );
+  
+private:  
+  G4int verboseLevel;
+  G4std::vector< G4BertiniEvaporationChannel * > channelVector;
+  void fillResult( G4std::vector< G4DynamicParticle * > secondaryParticleVector,
+		   G4FragmentVector * aResult );
+  void splitBe8( const G4double E, 
+		 const G4ThreeVector boost,
+		 G4std::vector< G4DynamicParticle * > & secondaryParticleVector);
+  void isotropicCosines( G4double & u, G4double & v,G4double & w );
+};
+
+#endif

source/processes/hadronic/models/cascade/evaporation/include/G4BertiniEvaporationChannel.hh

@@ -0,0 +1,88 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#ifndef G4BertiniEvaporationChannel_h
+#define G4BertiniEvaporationChannel_h 1
+
+#include "globals.hh"
+#include "G4DynamicParticle.hh"
+#include "G4NucleiProperties.hh" 
+
+class G4BertiniEvaporationChannel
+{
+public:
+  G4BertiniEvaporationChannel();
+  virtual ~G4BertiniEvaporationChannel(); 
+
+  void setVerboseLevel( G4int verbose );
+  void setNucleusA( G4int inputA );
+  void setNucleusZ( G4int inputZ );
+  G4int getParticleA();
+  G4int getParticleZ();
+  void setExcitationEnergy( G4double inputE );
+  void setQ( G4double inputQ );
+  void setPairingCorrection( G4int isCorrection );
+  G4double getLevelDensityParameter();
+  G4String getName();
+  
+  virtual G4double getProbability() ;
+  virtual void setProbability( G4double newProb ) ;
+  virtual void calculateProbability() = 0 ;
+  virtual G4double qmFactor ();
+  virtual G4double getQ();
+  virtual G4double getCoulomb();
+  virtual G4double getThresh();
+
+  virtual G4DynamicParticle* emit() = 0;
+  
+protected:  
+  G4String name;
+  G4int verboseLevel;
+  G4int nucleusA;
+  G4int nucleusZ;
+  G4int particleA;
+  G4int particleZ;
+  G4double exmass;
+  G4double emissionProbability;
+  G4double rho;
+  G4double correction;
+  G4double excitationEnergy;
+  //  G4int massInNeutronMasses;
+  G4int spin;
+  G4double Q( G4double a, G4double z );
+  G4double pairingEnergyProtons( G4int A );
+  G4double pairingEnergyNeutrons( G4int N );
+  G4double cameron( G4double a, G4double z );
+  G4double cameronShellCorrectionP( G4int Z );
+  G4double cameronShellCorrectionN( G4int N );
+  void isotropicCosines( G4double&,
+			 G4double&,
+			 G4double& );
+};
+
+
+#endif

source/processes/hadronic/models/cascade/evaporation/src/G4BEChargedChannel.cc

@@ -0,0 +1,202 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "G4BEChargedChannel.hh"
+
+
+G4BEChargedChannel::G4BEChargedChannel()
+{
+    verboseLevel = 0;
+}
+
+
+G4BEChargedChannel::~G4BEChargedChannel()
+{
+}
+
+
+void G4BEChargedChannel::calculateProbability()
+{
+  G4int residualZ = nucleusZ - particleZ;
+  G4int residualA = nucleusA - particleA;
+
+//    Check if nucleus is too small, if this evaporation channel
+//    leads to an impossible residual nucleus or if there is no enough
+//    energy.
+  if ( nucleusA < 2.0 * particleA || 
+       nucleusZ < 2.0 * particleZ ||
+       residualA <= residualZ || 
+       excitationEnergy - getThresh() - correction < 0 )
+    {
+      if ( verboseLevel >= 6 )
+	G4cout << "G4BEChargedChannel : calculateProbability for " << getName() << " = 0 " << G4endl;
+      emissionProbability = 0;
+      return;
+    }
+
+  // In HETC88 s-s0 was used in exp( s ), in which s0 was either 50 or
+  // max(s_i), where i goes over all channels.
+
+  G4double levelParam = getLevelDensityParameter();
+  G4double s        = 2 * sqrt( levelParam  * ( excitationEnergy - getThresh() - correction ) );
+  G4double constant = A / 2 * ( 2 * spin + 1 ) * ( 1 + coulombFactor() );
+  G4double eye1     = ( pow( s, 2 ) - 3 * s + 3 ) / ( 4 * pow( levelParam, 2 ) ) * exp( s );
+
+  emissionProbability = constant * pow( residualA, 0.6666666 ) * eye1;
+
+  if ( verboseLevel >= 6 )
+    G4cout << "G4BEChargedChannel : calculateProbability for " << getName() << G4endl
+	   << "                    res A = " << residualA << G4endl 
+	   << "                    res Z = " << residualZ << G4endl 
+	   << "                 c*(c_i+1) = "<< constant << G4endl
+	   << "                  qmfactor = "<< qmFactor() << G4endl
+	   << "             coulombfactor = "<< coulombFactor() << G4endl
+	   << "                        E = " << excitationEnergy << G4endl
+	   << "               correction = " << correction << G4endl
+	   << "                     eye1 = " << eye1 << G4endl
+	   << "               levelParam = " << levelParam << G4endl
+	   << "                   thresh = " << getThresh() << G4endl
+	   << "                        s = " << s << G4endl
+	   << "              probability = " << emissionProbability << G4endl;
+
+  return;
+}
+
+
+G4double G4BEChargedChannel::sampleKineticEnergy()
+{
+//    G4double randExp1;
+//    G4double randExp2;
+//    G4double s;
+//    G4double levelParam;
+//    G4double kineticEnergyAv;
+//    G4double kineticEnergy;
+  
+//    randExp1 = RandExponential::shoot( 1 );
+//    randExp2 = RandExponential::shoot( 1 );
+//    levelParam = getLevelDensityParameter();
+//    s = 2 * sqrt( levelParam  * ( excitationEnergy - getThresh() - correction ) );
+//    kineticEnergyAv = 2 * ( pow( s, 3 ) - 6.0 * pow( s, 2 ) + 15.0 * s - 15.0 )  / 
+//        ( ( 2.0 * pow( s, 2 ) - 6.0 * s + 6.0 ) * levelParam );
+  
+//    kineticEnergy = 0.5 * ( randExp1 + randExp2 ) * kineticEnergyAv + getThresh() - getQ();
+
+//    if ( verboseLevel >= 10 )
+//      G4cout << "  G4BEChargedChannel : sampleKineticEnergy() " << G4endl
+//  	   << "         kinetic e = " << kineticEnergy << G4endl
+//  	   << "           average = " << kineticEnergyAv << G4endl
+//  	   << "                 s = " << s << G4endl
+//  	   << "        levelParam = " << levelParam << G4endl
+//  	   << "          randExp1 = " << randExp1 << G4endl
+//  	   << "          randExp2 = " << randExp2 << G4endl;
+
+  G4double levelParam;
+  levelParam = getLevelDensityParameter();
+  
+  const G4double xMax  = excitationEnergy - getThresh() - correction; // maximum number
+  const G4double xProb = ( - 1 + sqrt ( 1 + 4 * levelParam * xMax ) ) / ( 2 * levelParam ); // most probable value
+  const G4double m = xProb * exp ( 2 * sqrt ( levelParam * ( xMax - xProb ) ) ); // maximum value of P(x)
+
+  // Sample x according to density function P(x) with rejection method
+  G4double r1;
+  G4double r2;
+  G4int koe=0;
+  do
+    {
+      r1 = G4UniformRand() * xMax;
+      r2 = G4UniformRand() * m;
+      koe++;
+    }
+  while (  r1 * exp ( 2 * sqrt ( levelParam * ( xMax - r1 ) ) )  < r2 );
+
+//  G4cout << "Q ch " << koe << G4endl;
+  G4double kineticEnergy = r1 + getCoulomb(); // add coulomb potential;
+
+  if ( verboseLevel >= 10 )
+    G4cout << " G4BENeutronChannel : sampleKineticEnergy() " << G4endl
+	   << "       kinetic n e = " << kineticEnergy << G4endl
+	   << "        levelParam = " << levelParam << G4endl
+	   << "             thresh= " << getThresh() << G4endl;
+
+  return kineticEnergy;
+}
+
+
+G4double G4BEChargedChannel::coulombFactorForProton()
+{
+  //  Coefficient c_p:s for empirical cross section formula are
+  //  defined with the proton constant.  See Dostrovsky, Phys. Rev.,
+  //  vol. 116, 1959.
+  G4double t[7] = { 0.08 , 0 , -0.06 , -0.1 , -0.1 , -0.1 , -0.1 };
+  G4int Z = nucleusZ - particleZ;
+
+  if ( Z >= 70.0 ) return t[6];
+  if ( Z <= 10.0 ) return t[0];
+  
+  // Linear interpolation
+  G4int   n = G4int( 0.1 * Z + 1.0 ); 
+  G4float x = ( 10 * n - Z ) * 0.1; 
+  G4double ret_val =  x * t[n - 2] + ( 1.0 - x ) * t[n-1];
+
+  return ret_val;
+}
+
+
+G4double G4BEChargedChannel::qmFactorForProton()
+{
+  //  Coefficient k_p for empirical cross section formula are defined
+  //  with the proton constant.  See Dostrovsky, Phys. Rev., vol. 116,
+  //  1959
+  G4double t[7] = {  0.36, 0.51, 0.60, 0.66, 0.68, 0.69, 0.69 };
+  G4int Z = nucleusZ - particleZ;
+
+  if ( Z >= 70.0 ) return t[6];
+  if ( Z <= 10.0 ) return t[0];
+
+  // Linear interpolation
+  G4int   n = G4int( 0.1 * Z + 1.0 ); 
+  G4float x = ( 10 * n - Z ) * 0.1; 
+  return x * t[n - 2] + ( 1.0 - x ) * t[n-1];
+}
+
+
+G4double G4BEChargedChannel::qmFactorForAlpha()
+{
+//  Coefficient k_alpha for empirical cross section formula presented
+//  in Dostrovsky, Phys. Rev., vol. 116, 1959
+
+  G4double t[7] = {  0.77, 0.81, 0.85, 0.89, 0.93, 0.97,  1.00 };
+  G4int Z = nucleusZ - particleZ;
+
+  if ( Z >= 70.0 ) return t[6];
+  if ( Z <= 10.0 ) return t[0];
+
+  // Linear interpolation
+  G4int   n = G4int( 0.1 * Z + 1.0 ); 
+  G4float x = ( 10 * n - Z ) * 0.1; 
+  return x * t[n - 2] + ( 1.0 - x ) * t[n-1];
+}

source/processes/hadronic/models/cascade/evaporation/src/G4BEDeuteronChannel.cc

@@ -0,0 +1,76 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "G4BEDeuteronChannel.hh"
+#include "G4Deuteron.hh"
+
+
+G4BEDeuteronChannel::G4BEDeuteronChannel()
+{
+  name = "deuteron";
+  verboseLevel = 0;
+  particleA = 2;
+  particleZ = 1;
+  rho = 0.70588;
+  exmass = G4NucleiProperties::GetMassExcess( particleA, particleZ ); 
+  A=2;
+  spin = 1;
+}
+
+
+G4BEDeuteronChannel::~G4BEDeuteronChannel()
+{
+}
+
+
+G4DynamicParticle*  G4BEDeuteronChannel::emit()
+{
+  G4double u, v, w;
+  G4DynamicParticle * pParticle = new G4DynamicParticle;
+  pParticle -> SetDefinition( G4Deuteron::Deuteron() );
+  pParticle -> SetKineticEnergy( sampleKineticEnergy() ); 
+  isotropicCosines( u, v, w );
+  pParticle -> SetMomentumDirection( u, v, w );  
+  return pParticle;
+}
+
+
+G4double G4BEDeuteronChannel::coulombFactor()
+{
+  // Coefficient c_i representing the variation of charged-particle
+  // capture cross sections with Z for each particle.  See Dostrovsky,
+  // Phys. Rev. 116, 1959.
+  return 0.5 * coulombFactorForProton();
+}
+
+
+G4double G4BEDeuteronChannel::qmFactor()
+{
+  // Coefficient k_i representing the quantum mechanical barrier
+  // penetration, see Dostrovsky, Phys. Rev. 116, 1959.
+  return qmFactorForProton() + 0.06;
+}

source/processes/hadronic/models/cascade/evaporation/src/G4BEGammaDeexcitation.cc

@@ -0,0 +1,107 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include "Randomize.hh"
+#include "G4Neutron.hh"
+#include "G4Proton.hh"
+#include "G4Deuteron.hh"
+#include "G4Triton.hh"
+#include "G4Alpha.hh"
+#include "G4Nucleus.hh"  
+#include "G4BEGammaDeexcitation.hh"
+
+
+G4BEGammaDeexcitation::G4BEGammaDeexcitation()
+{
+}
+
+
+G4BEGammaDeexcitation::~G4BEGammaDeexcitation()
+{
+}
+
+
+void G4BEGammaDeexcitation::setVerboseLevel( G4int level )
+{
+  verboseLevel = level ;
+}
+
+
+void G4BEGammaDeexcitation::setNucleusA( G4int a )
+{
+  nucleusA = a;
+}
+
+
+void G4BEGammaDeexcitation::setNucleusZ( G4int z )
+{
+  nucleusZ = z;
+}
+
+
+void G4BEGammaDeexcitation::setExcitationEnergy( G4double energy )
+{
+  excitationEnergy = energy;
+}
+
+
+G4double  G4BEGammaDeexcitation::sampleKineticEnergy()
+{
+  return excitationEnergy  * G4UniformRand(); 
+}
+
+
+G4DynamicParticle *  G4BEGammaDeexcitation::emit()
+{
+  // Isotropic distribution assumed to gammas
+  G4double u, v, w;
+  G4DynamicParticle * pParticle = new G4DynamicParticle;
+  pParticle -> SetDefinition( G4Gamma::Gamma() );
+  pParticle -> SetKineticEnergy( sampleKineticEnergy() ); 
+  isotropicCosines( u, v, w );
+  pParticle -> SetMomentumDirection( u, v, w );  
+  return pParticle;
+}
+
+
+void G4BEGammaDeexcitation::isotropicCosines( G4double & u, 
+					      G4double & v, 
+					      G4double & w )
+{
+  // Samples isotropic random direction cosines.
+  G4double CosTheta = 1.0 - 2.0 * G4UniformRand();
+  G4double SinTheta = sqrt( 1.0 - CosTheta * CosTheta );
+  G4double Phi = twopi * G4UniformRand();
+
+  u = cos( Phi ) * SinTheta;
+  v = cos( Phi ) * CosTheta,
+  w = sin( Phi );
+
+  return;
+}

source/processes/hadronic/models/cascade/evaporation/src/G4BEHe3Channel.cc

@@ -0,0 +1,71 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "G4BEHe3Channel.hh"
+#include "G4He3.hh"
+
+G4BEHe3Channel::G4BEHe3Channel()
+{
+  name = "He3";
+    verboseLevel = 0;
+    particleA = 3;
+    particleZ = 2;
+    rho = 0.70588;
+    A=3;
+    spin = 0.5;
+}
+
+
+G4BEHe3Channel::~G4BEHe3Channel()
+{
+}
+
+
+G4DynamicParticle*  G4BEHe3Channel::emit()
+{
+  G4double u , v , w;
+  G4DynamicParticle * pParticle = new G4DynamicParticle;
+  pParticle -> SetDefinition( G4He3::He3() );
+  pParticle -> SetKineticEnergy( sampleKineticEnergy() ); 
+  isotropicCosines( u, v, w);
+  pParticle -> SetMomentumDirection( u, v, w);  
+  return pParticle;
+}
+
+
+G4double G4BEHe3Channel::coulombFactor()
+{
+  return 0;
+}
+
+
+G4double G4BEHe3Channel::qmFactor()
+{
+  // Coefficient representing the quantum mechanical barrier
+  // penetration, see Dostrovsky, Phys. Rev. 116, 1959.
+  return qmFactorForAlpha() - 0.06;
+}

source/processes/hadronic/models/cascade/evaporation/src/G4BEHe4Channel.cc

@@ -0,0 +1,71 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "G4BEHe4Channel.hh"
+#include "G4Alpha.hh"
+
+G4BEHe4Channel::G4BEHe4Channel()
+{
+  name = "He4";
+    verboseLevel = 0;
+    particleA = 4;
+    particleZ = 2;
+    rho = 0.70588;
+    A=4;
+    spin = 0;
+}
+
+
+G4BEHe4Channel::~G4BEHe4Channel()
+{
+}
+
+
+G4DynamicParticle * G4BEHe4Channel::emit()
+{
+  G4double u , v , w;
+  G4DynamicParticle * pParticle = new G4DynamicParticle;
+  pParticle -> SetDefinition( G4Alpha::Alpha() );
+  pParticle -> SetKineticEnergy( sampleKineticEnergy() ); 
+  isotropicCosines( u , v , w );
+  pParticle -> SetMomentumDirection( u , v , w );  
+  return pParticle;
+}
+
+
+G4double G4BEHe4Channel::coulombFactor()
+{
+  return 0;
+}
+
+
+G4double G4BEHe4Channel::qmFactor()
+{
+  // Coefficient representing the quantum mechanical barrier
+  // penetration, see Dostrovsky, Phys. Rev. 116, 1959.
+  return qmFactorForAlpha();
+}

source/processes/hadronic/models/cascade/evaporation/src/G4BENeutronChannel.cc

@@ -0,0 +1,201 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include "Randomize.hh"
+#include "G4Neutron.hh"
+#include "G4Proton.hh"
+#include "G4Deuteron.hh"
+#include "G4Triton.hh"
+#include "G4Alpha.hh"
+#include "G4ParticleTable.hh"    
+#include "G4Nucleus.hh"  
+#include "G4BENeutronChannel.hh"
+
+
+G4BENeutronChannel::G4BENeutronChannel()
+{
+  name         = "neutron";
+  particleA    = 1;
+  particleZ    = 0;
+  verboseLevel = 0;
+  rho          = 0;
+}
+
+
+G4BENeutronChannel::~G4BENeutronChannel()
+{
+}
+
+
+void G4BENeutronChannel::calculateProbability()
+{
+  const G4int residualZ = nucleusZ - particleZ;
+  const G4int residualA = nucleusA - particleA;
+
+  if ( nucleusA  <  2.0 * particleA ||  
+       nucleusZ  <  2.0 * particleZ ||  
+       residualA <= residualZ       ||  
+       excitationEnergy - getThresh() - correction < 0 )
+    {
+      if ( verboseLevel >= 6 )
+	G4cout << "G4BENeutronChannel : calculateProbability = 0 " << G4endl;
+      emissionProbability = 0;
+      return;
+    }
+
+  // In HETC88 s-s0 was used in exp( s ), in which s0 was either 50 or
+  // max(s_i), where i goes over all channels.
+
+  const G4double levelParam = getLevelDensityParameter();
+  
+  const G4double s    = 2 * sqrt( levelParam  * ( excitationEnergy - getThresh() - correction ) );
+  const G4double temp = ( pow( s, 2 ) - 3 * s + 3 ) / ( 4 * pow( levelParam, 2 ) ) 
+    + beta() * ( s - 1 ) /  ( 2 * levelParam );
+  const G4double eye0 = exp( s ) * ( s - 1 ) /  ( 2 * levelParam );
+  const G4double eye1 = ( pow( s, 2 ) - 3*s +3 ) * exp( s ) / ( 4 * pow( levelParam, 2 ) ) ;
+  
+  emissionProbability = pow( residualA, 0.666666 ) * alpha() * ( eye1 + beta() * eye0 );
+  
+  if ( verboseLevel >= 6 )
+    G4cout << "G4BENeutronChannel : calculateProbability " << G4endl
+	   << "                    res A = " << residualA << G4endl 
+	   << "                    res Z = " << residualZ << G4endl 
+	   << "                    alpha = " << alpha() << G4endl 
+	   << "                     beta = " << beta() << G4endl
+	   << "                        E = " << excitationEnergy << G4endl
+	   << "               correction = " << correction << G4endl
+	   << "                     eye1 = " << eye1 << G4endl
+	   << "                     eye0 = " <<  eye0 << G4endl
+	   << "               levelParam = " << levelParam << G4endl
+	   << "                   thresh = " << getThresh() << G4endl
+	   << "                        s = " << s << G4endl
+	   << "              probability = " << emissionProbability << G4endl;
+
+  return;
+}
+
+
+G4double  G4BENeutronChannel::sampleKineticEnergy()
+{
+  // Samples the kinetic energy of the particle in CMS
+  //
+  // Algorithm used in HETC98
+  //
+//    G4double e1;
+//    G4double e2;
+//    G4double s;
+//    G4double levelParam;
+//    G4double eye0;
+//    G4double eye1;
+//    G4double kineticEnergyAv;
+//    G4double kineticEnergy;
+  
+//    e1 = RandExponential::shoot( 1 );
+//    e2 = RandExponential::shoot( 1 );
+
+//    levelParam  = getLevelDensityParameter();
+//    s = 2 * sqrt( levelParam  * ( excitationEnergy - getThresh() - correction ) );
+//    eye0 = 0.5 * ( s - 1 ) * exp( s ) / levelParam;
+//    eye1 = ( pow( s, 2 ) - 3*s + 3 ) * exp( s ) / ( 4 * pow( levelParam, 2 ) );
+//    kineticEnergyAv = 2 * ( pow( s, 3 ) - 6.0 * pow( s, 2 ) + 15.0 * s - 15.0 )  / 
+//        ( ( 2.0 * pow( s, 2 ) - 6.0 * s + 6.0 ) * levelParam );
+//    kineticEnergyAv = ( kineticEnergyAv + beta() ) / ( 1.0 + beta() * eye0
+//  	   / eye1 );
+  
+//    kineticEnergy = 0.5 * ( e1 + e2 ) * kineticEnergyAv + getThresh() - getQ();
+
+  ////////////////
+  // A random number is sampled from the density function
+  // P(x) = x * exp ( 2 sqrt ( a ( xMax - x ) ) )  [not normalized],
+  // x belongs to [ 0, xMax ]
+  // with the 'Hit or Miss' -method
+  // Kinetic energy is this energy scaled properly
+  
+  G4double levelParam;
+  levelParam = getLevelDensityParameter();
+  
+  const G4double xMax  = excitationEnergy - getThresh() - correction + beta(); // maximum number
+  const G4double xProb = ( - 1 + sqrt ( 1 + 4 * levelParam * xMax ) ) / ( 2 * levelParam ); // most probable value
+  const G4double m = xProb * exp ( 2 * sqrt ( levelParam * ( xMax - xProb ) ) ); // maximum value of P(x)
+
+  // Sample x according to density function P(x) with rejection method
+  G4double r1;
+  G4double r2;
+  G4int koe=0;
+  do
+    {
+      r1 = beta() + G4UniformRand() * ( xMax - beta() );
+      r2 = G4UniformRand() * m;
+      koe++;
+    }
+  while (  r1 * exp ( 2 * sqrt ( levelParam * ( xMax - r1 ) ) )  < r2 );
+
+//  G4cout <<  koe << G4endl;
+  G4double kineticEnergy = r1 - beta();
+
+  if ( verboseLevel >= 10 )
+    G4cout << " G4BENeutronChannel : sampleKineticEnergy() " << G4endl
+	   << "       kinetic n e = " << kineticEnergy << G4endl
+	   << "        levelParam = " << levelParam << G4endl
+	   << "             thresh= " << getThresh() << G4endl
+	   << "               beta= " << beta() << G4endl;
+
+  return kineticEnergy;
+}
+
+
+G4DynamicParticle *  G4BENeutronChannel::emit()
+{
+  G4double u;
+  G4double v;
+  G4double w;
+  G4DynamicParticle * pParticle = new G4DynamicParticle;
+
+  pParticle -> SetDefinition( G4Neutron::Neutron() );
+  pParticle -> SetKineticEnergy( sampleKineticEnergy() ); 
+  isotropicCosines( u, v, w );
+  pParticle -> SetMomentumDirection( u , v , w );  
+
+  return pParticle;
+}
+
+
+G4double G4BENeutronChannel::alpha()
+{
+  const G4double residualA = nucleusA - particleA;
+  return 0.76 + 1.93 * pow( residualA, -0.33333 );
+}
+
+
+G4double G4BENeutronChannel::beta()
+{
+  G4double residualA = nucleusA - particleA;
+  return ( 1.66 * pow ( residualA, -0.66666 ) - 0.05 )/alpha()*MeV;
+}
+

source/processes/hadronic/models/cascade/evaporation/src/G4BEProtonChannel.cc

@@ -0,0 +1,71 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, 30-May-2000
+
+#include "G4BEProtonChannel.hh"
+#include "G4Proton.hh"
+
+G4BEProtonChannel::G4BEProtonChannel()
+{
+  name = "proton";
+    verboseLevel = 0;
+    particleA = 1;
+    particleZ = 1;
+    rho = 0; 
+    A=1;
+    spin = 0.5;
+}
+
+
+G4BEProtonChannel::~G4BEProtonChannel()
+{
+}
+
+
+G4DynamicParticle*  G4BEProtonChannel::emit()
+{
+  G4double u , v , w;
+  G4DynamicParticle * pParticle = new G4DynamicParticle;
+  pParticle -> SetDefinition( G4Proton::Proton() );
+  pParticle -> SetKineticEnergy( sampleKineticEnergy() ); 
+  isotropicCosines( u , v , w );
+  pParticle -> SetMomentumDirection( u , v , w );  
+  return pParticle;
+}
+
+
+G4double G4BEProtonChannel::coulombFactor()
+{
+  return coulombFactorForProton();
+}
+
+
+G4double G4BEProtonChannel::qmFactor()
+{
+  // Coefficient representing the quantum mechanical barrier
+  // penetration, see Dostrovsky, Phys. Rev. 116, 1959.
+  return qmFactorForProton();
+}

source/processes/hadronic/models/cascade/evaporation/src/G4BETritonChannel.cc

@@ -0,0 +1,71 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "G4BETritonChannel.hh"
+#include "G4Triton.hh"
+
+G4BETritonChannel::G4BETritonChannel()
+{
+  name = "triton";
+    verboseLevel = 0;
+    particleA = 3;
+    particleZ = 1;
+    rho = 0.70588;
+    A=3;
+    spin = 0.5;
+}
+
+
+G4BETritonChannel::~G4BETritonChannel()
+{
+}
+
+
+G4DynamicParticle*  G4BETritonChannel::emit()
+{
+  G4double u , v , w;
+  G4DynamicParticle * pParticle = new G4DynamicParticle;
+  pParticle -> SetDefinition( G4Triton::Triton() );
+  pParticle -> SetKineticEnergy( sampleKineticEnergy() ); 
+  isotropicCosines( u , v , w );
+  pParticle -> SetMomentumDirection( u , v , w );  
+  return pParticle;
+}
+
+
+G4double G4BETritonChannel::coulombFactor()
+{
+  return 0.333333*coulombFactorForProton();
+}
+
+
+G4double G4BETritonChannel::qmFactor()
+{
+  // Coefficient representing the quantum mechanical barrier
+  // penetration, see Dostrovsky, Phys. Rev. 116, 1959.
+  return qmFactorForProton() + 0.12;
+}

source/processes/hadronic/models/cascade/evaporation/src/G4BertiniEvaporation.cc

@@ -0,0 +1,413 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "globals.hh"
+#include "G4BertiniEvaporation.hh"
+#include "G4BENeutronChannel.hh"
+#include "G4BEProtonChannel.hh"
+#include "G4BEDeuteronChannel.hh"
+#include "G4BETritonChannel.hh"
+#include "G4BEHe3Channel.hh"
+#include "G4BEHe4Channel.hh"
+#include "G4BEGammaDeexcitation.hh"
+
+// verboseLevels : 4 inform about basic probabilities and branchings
+//                 6 some details about calculations
+//                 8 inform about final values
+//                10 inform everything
+
+G4BertiniEvaporation::G4BertiniEvaporation()
+{
+    G4cout << "Info G4BertiniEvaporation: This is still very fresh code."<< G4endl;
+    G4cout << "     G4BertiniEvaporation: feed-back for improvement is very wellcome."<< G4endl;
+    verboseLevel = 0;
+ 
+    channelVector.push_back( new G4BENeutronChannel );
+    channelVector.push_back( new G4BEProtonChannel  );
+    channelVector.push_back( new G4BEDeuteronChannel);
+    channelVector.push_back( new G4BETritonChannel  );
+    channelVector.push_back( new G4BEHe3Channel     );
+    channelVector.push_back( new G4BEHe4Channel     );
+}
+
+
+G4BertiniEvaporation::~G4BertiniEvaporation()
+{
+  while ( !channelVector.empty() )
+    {
+      delete channelVector.back();
+      channelVector.pop_back();
+    }
+}
+
+
+void G4BertiniEvaporation::setVerboseLevel( const G4int verbose )
+{
+  verboseLevel = verbose;
+
+  // Update verbose level to all evaporation channels.
+  G4std::vector< G4BertiniEvaporationChannel * >::iterator iChannel = channelVector.begin();  
+  for ( ; iChannel != channelVector.end() ; *iChannel++ )                  
+    ( *iChannel )->setVerboseLevel( verboseLevel );
+}
+
+
+G4FragmentVector * G4BertiniEvaporation::BreakItUp( G4LayeredNucleus & nucleus )
+{
+  G4int nucleusA;
+  G4int nucleusZ;
+  G4int i;
+  G4double totalProbability;
+  G4double excE;
+  G4double newExcitation;
+  G4double nucleusTotalMomentum;
+  G4double nucleusKineticEnergy;
+  G4double mRes; // Mass of residual nucleus.
+  G4ThreeVector nucleusMomentumVector;
+  G4DynamicParticle *pEmittedParticle;
+  G4std::vector< G4DynamicParticle * > secondaryParticleVector;
+  G4FragmentVector * result = new G4FragmentVector;
+  
+  // Read properties of the nucleus.
+  nucleusA = ( G4int ) nucleus.GetN(); // GetN should in fact get GetA
+  nucleusZ = ( G4int ) nucleus.GetZ();
+  excE                  = nucleus.GetEnergyDeposit();
+  nucleusMomentumVector = nucleus.GetMomentum();
+
+  // Move to CMS frame, save initial velocity of the nucleus to boostToLab vector.
+  G4ThreeVector boostToLab( ( 1/G4NucleiProperties::GetAtomicMass( nucleusA, nucleusZ ) ) 
+			    * nucleusMomentumVector ); // xx mass ok?
+
+  if ( verboseLevel >= 10 )
+    G4cout << " G4BertiniEvaporation : initial kinematics : boostToLab vector = " << boostToLab << G4endl
+	   << "                     excitation energy  : " << excE<< G4endl;
+
+  if ( nucleusA == 8 && nucleusZ == 4 )
+    {
+      splitBe8( excE, boostToLab, secondaryParticleVector );
+      fillResult( secondaryParticleVector, result);
+      return result;
+    }
+  
+  // Initialize evaporation channels and calculate sum of emission
+  // probabilities.
+  G4std::vector< G4BertiniEvaporationChannel * >::iterator iChannel = channelVector.begin();  
+  totalProbability = 0;
+  for ( ; iChannel != channelVector.end() ; *iChannel++ )                  
+     {
+       ( *iChannel )->setNucleusA( nucleusA );
+       ( *iChannel )->setNucleusZ( nucleusZ );
+       ( *iChannel )->setExcitationEnergy( excE );
+       ( *iChannel )->setPairingCorrection( 1 );
+       ( *iChannel )->calculateProbability();
+       totalProbability += ( *iChannel )->getProbability();
+     }
+
+  // If no evaporation process is possible, try without pairing energy.
+  if ( totalProbability == 0 )
+    {
+      if ( verboseLevel >= 4 )
+	G4cout << "G4BertiniEvaporation : no emission possible with pairing correction, trying without it" << G4endl;
+      for ( iChannel = channelVector.begin() ; iChannel != channelVector.end() ; *iChannel++ )
+	{
+	  ( *iChannel )->setPairingCorrection(0);
+	  ( *iChannel )->calculateProbability();
+	  totalProbability += ( *iChannel )->getProbability();
+	}
+      if ( verboseLevel >= 4 )
+	G4cout << "                       probability without correction " << totalProbability << G4endl;
+
+    }
+
+  // Normal evaporation cycle follows.
+  // Particles are evaporated till all probabilities are zero.
+  while ( totalProbability > 0 )
+    {
+      G4BertiniEvaporationChannel *pSelectedChannel;
+
+      // Sample active emission channel.
+      G4double sampledProbability = G4UniformRand() * totalProbability;
+      if ( verboseLevel >= 10 ) G4cout << "          RandomProb : " << sampledProbability << G4endl;
+      for ( iChannel = channelVector.begin() ; iChannel != channelVector.end() ; *iChannel++ )
+	{
+	  sampledProbability -= ( *iChannel )->getProbability();
+	  if ( sampledProbability < 0 ) break;
+	}
+      pSelectedChannel = ( *iChannel );
+      if ( iChannel == channelVector.end() )
+	G4Exception( "G4BertiniEvaporation : Error while sampling evaporation particle" );
+
+      if ( verboseLevel >= 4 ) 
+	G4cout << "G4BertiniEvaporation : particle " << pSelectedChannel->getName() << " selected " << G4endl;
+
+      // Max 10 tries to get a physically acceptable particle energy
+      // in this emission channel.
+      i = 0;
+
+      do
+	{
+	  pEmittedParticle = pSelectedChannel->emit();
+	  // This loop checks that particle with too large energy is not emitted.
+	  // CMS frame is considered in this loop. Nonrelativistic treatment. xxx
+
+
+	  const G4int zRes = nucleusZ - pSelectedChannel->getParticleZ(); 
+	  const G4int aRes  = nucleusA - pSelectedChannel->getParticleA(); 
+	  const G4double eBind = G4NucleiProperties::GetBindingEnergy( aRes, zRes );  // Binding energy of the nucleus.
+	  mRes  = G4NucleiProperties::GetAtomicMass( aRes, zRes ); // Mass of the target nucleus
+	  //      In HETC88:
+	  //   	  eBind = Z * (-0.78244) + A * 8.36755 - cameron ( A , Z );
+	  //  	  mRes =  zRes * 938.79304 + ( aRes - zRes ) * 939.57548 - eBind; 
+	  //      where cameron ( A, Z ) is the mass excess by Cameron, see Canadian Journal of Physics,
+	  //      vol. 35, 1957, p.1022
+
+	  nucleusTotalMomentum = pEmittedParticle->GetTotalMomentum(); // CMS frame
+	  nucleusKineticEnergy = pow( nucleusTotalMomentum, 2 ) / ( 2 * mRes );
+	  newExcitation = excE - pEmittedParticle->GetKineticEnergy() - nucleusKineticEnergy - pSelectedChannel->getQ();
+
+ 	  if ( verboseLevel >= 10)
+	    G4cout << "G4BertiniEvaporation : Kinematics " << G4endl
+		   << "                    part kinetic E in CMS = " 
+		   << pEmittedParticle->GetKineticEnergy() << G4endl
+		   << "                    new excitation E      =  " 
+		   << newExcitation << G4endl;
+
+	  i++;
+	  if ( !( newExcitation > 0 ) && i < 10) delete pEmittedParticle;
+	} while ( !( newExcitation > 0 )  &&  i < 10 );
+
+      if ( i >= 10 ) 
+	{
+	  // No appropriate particle energy found.
+	  // Set probability of this channel to zero 
+	  // and try to sample another particle on the 
+	  // next round.
+	  delete pEmittedParticle;
+
+	  if ( verboseLevel >= 4 )
+	    G4cout << "G4BertiniEvaporation : No appropriate energy for particle " 
+		   << pSelectedChannel->getName() << " found." << G4endl;
+
+	  pSelectedChannel->setProbability( 0 );
+
+	  totalProbability = 0;
+	  for ( ; iChannel != channelVector.end() ; *iChannel++ )                  
+	    totalProbability += ( *iChannel )->getProbability();
+	} // Treatment of physically unacceptable particle ends.
+      else
+	{
+	  // Good particle found. 
+
+	  // Transform particle properties to lab frame and save it.
+	  G4LorentzVector particleFourVector = pEmittedParticle->Get4Momentum();
+	  G4LorentzVector nucleusFourVector(  - pEmittedParticle->GetMomentum(), // CMS Frame.
+					      nucleusKineticEnergy + mRes ); // Total energy.
+	  particleFourVector.boost( boostToLab );
+	  nucleusFourVector.boost(  boostToLab );
+	  G4DynamicParticle *pPartLab  = new G4DynamicParticle( pEmittedParticle->GetDefinition(),
+								particleFourVector.e(), // Total energy
+								particleFourVector.vect() ); // momentum vector
+	  secondaryParticleVector.push_back( pPartLab );
+
+	  // Update residual nucleus and boostToLab vector.
+	  nucleusA = nucleusA - pSelectedChannel->getParticleA();
+	  nucleusZ = nucleusZ - pSelectedChannel->getParticleZ();
+	  excE = newExcitation;
+	  boostToLab = G4ThreeVector ( ( 1/mRes ) * nucleusFourVector.vect() );
+
+	  if ( verboseLevel >= 10 )
+	    G4cout << "  particle mom in cms " << pEmittedParticle->GetMomentum() << G4endl 
+		   << "  particle mom in cms " << pEmittedParticle->GetTotalMomentum() << G4endl 
+		   << "          Etot in cms " << pEmittedParticle->GetTotalEnergy() << G4endl
+		   << "          Ekin in cms " << pEmittedParticle->GetKineticEnergy() << G4endl
+		   << "        particle mass " << pEmittedParticle->GetMass() << G4endl
+		   << "          boost  vect " << boostToLab << G4endl
+		   << "          boosted 4v  " << particleFourVector << G4endl
+		   << "          nucleus 4v  " << nucleusFourVector << G4endl
+		   << "          nucl cm mom " << nucleusTotalMomentum << G4endl
+		   << " particle k.e. in lab " << pPartLab->GetKineticEnergy() << G4endl
+		   << "     new boost vector " << boostToLab << G4endl;
+
+	  delete pEmittedParticle;
+
+	  // If the residual nucleus is Be8, split it.
+	  if ( nucleusA == 8 && nucleusZ == 4 )
+	    {
+	      splitBe8( excE, boostToLab, secondaryParticleVector );
+              fillResult( secondaryParticleVector, result);
+	      return result;
+	    }
+
+	  // Update evaporation channels and 
+	  // total emission probability.
+	  totalProbability = 0;
+	  for ( iChannel = channelVector.begin() ; iChannel != channelVector.end() ; *iChannel++ )  
+	    {
+	      ( *iChannel )->setNucleusA( nucleusA ); 
+	      ( *iChannel )->setNucleusZ( nucleusZ );
+	      ( *iChannel )->setExcitationEnergy( excE ); 
+	      ( *iChannel )->calculateProbability();
+	      totalProbability += ( *iChannel )->getProbability();
+	    }
+	} // Treatment of physically acceptable particle ends.
+    } // End of evaporation cycle.
+
+  // Gamma de-excitation.
+  G4BEGammaDeexcitation *pGammaChannel = new G4BEGammaDeexcitation;
+  pGammaChannel->setNucleusA( nucleusA );
+  pGammaChannel->setNucleusZ( nucleusZ );
+  pGammaChannel->setVerboseLevel( verboseLevel );
+  pGammaChannel->setExcitationEnergy( excE );
+
+  // Emit equally sampled photons until all the excitation energy is
+  // used; the last photon gets the remaining de-excitation energy.
+  // Change of momentum of the nucleus is neglected.
+  G4double gammaEnergy;
+  G4double totalDeExcEnergy = 0;
+
+  while ( excE > 0 )
+    {
+      pEmittedParticle = pGammaChannel->emit();
+      gammaEnergy = pEmittedParticle->GetKineticEnergy();
+      
+      if ( ( totalDeExcEnergy + gammaEnergy ) > excE ) 
+	{
+	  // All the remaining energy is used here.
+	  gammaEnergy = excE - totalDeExcEnergy;
+	  excE = 0;
+	}
+
+      totalDeExcEnergy += gammaEnergy; 
+
+      if ( verboseLevel >= 10 )
+	G4cout << " G4BertiniEvaporation : gamma de-excitation, g of " << gammaEnergy << " MeV " << G4endl;
+      
+      G4LorentzVector gammaFourVector( pEmittedParticle->GetMomentum(),
+				       pEmittedParticle->GetKineticEnergy() );
+      gammaFourVector.boost( boostToLab );
+      pEmittedParticle->SetKineticEnergy( gammaFourVector.e() );
+      pEmittedParticle->SetMomentumDirection( gammaFourVector.vect().unit() );
+
+      secondaryParticleVector.push_back( pEmittedParticle );
+
+      } 
+
+  delete pGammaChannel;
+
+  // Residual nucleus is not returned.
+
+  fillResult( secondaryParticleVector, result);
+  
+  return result;
+}
+
+
+void G4BertiniEvaporation::splitBe8( const G4double E,
+				     const G4ThreeVector boostToLab,
+				     G4std::vector< G4DynamicParticle * > & secondaryParticleVector )
+{
+  G4double kineticEnergy; 
+  G4double u;
+  G4double v;
+  G4double w;
+  const G4double Be8DecayEnergy = 0.093 * MeV; 
+
+  if ( E <= 0 ) G4Exception( "G4BertiniEvaporation : excitation energy < 0 " );
+  if ( verboseLevel >= 4 ) G4cout << "     Be8 split to 2 x He4" << G4endl;
+
+  kineticEnergy = 0.5 * ( E + Be8DecayEnergy ); 
+  
+  // Create two alpha particles in CMS frame.
+  isotropicCosines( u , v , w );
+  G4ThreeVector momentumDirectionCMS( u, v, w ); 
+
+  G4DynamicParticle *pP1Cms = new G4DynamicParticle( G4Alpha::Alpha(),
+						     momentumDirectionCMS,
+						     kineticEnergy );
+  G4DynamicParticle *pP2Cms = new G4DynamicParticle( G4Alpha::Alpha(),
+						     -momentumDirectionCMS,
+						     kineticEnergy );
+  G4LorentzVector fourVector1( pP1Cms->GetMomentum(), 
+			       pP1Cms->GetTotalEnergy() );
+  G4LorentzVector fourVector2( pP2Cms->GetMomentum(), 
+			       pP2Cms->GetTotalEnergy() );
+
+  // Transform into lab frame by transforming the four vectors. Then
+  // add to the vector of secondary particles.
+  fourVector1.boost( boostToLab );
+  fourVector2.boost( boostToLab );
+  G4DynamicParticle * pP1Lab  = new G4DynamicParticle( G4Alpha::Alpha(),
+						      fourVector1.vect(),
+						      fourVector1.e() );
+  G4DynamicParticle * pP2Lab  = new G4DynamicParticle( G4Alpha::Alpha(),
+						      fourVector2.vect(),
+						      fourVector2.e() );
+  secondaryParticleVector.push_back( pP1Lab );
+  secondaryParticleVector.push_back( pP2Lab );
+
+  delete pP1Cms;
+  delete pP2Cms;
+
+  return;
+}
+
+
+void G4BertiniEvaporation::fillResult( G4std::vector<G4DynamicParticle *> secondaryParticleVector,
+				      G4FragmentVector * aResult )
+{
+  // Fill the vector pParticleChange with secondary particles stored in vector.
+  for ( G4int i = 0 ; i < secondaryParticleVector.size() ; i++ )
+  {
+    G4int aZ = secondaryParticleVector[i]->GetDefinition()->GetPDGCharge();
+    G4int aA = secondaryParticleVector[i]->GetDefinition()->GetBaryonNumber();
+    G4LorentzVector aMomentum = secondaryParticleVector[i]->Get4Momentum();
+    if(aA>0) 
+    {
+      aResult->push_back( new G4Fragment(aA, aZ, aMomentum) ); 
+    }
+    else 
+    {
+      aResult->push_back( new G4Fragment(aMomentum, secondaryParticleVector[i]->GetDefinition()) ); 
+    }
+  }
+  return;
+}
+
+
+void G4BertiniEvaporation::isotropicCosines( G4double & u, G4double & v, G4double & w )
+{
+  // Samples isotropic random direction cosines.
+  G4double CosTheta = 1.0 - 2.0 * G4UniformRand();
+  G4double SinTheta = sqrt( 1.0 - CosTheta * CosTheta );
+  G4double Phi = twopi * G4UniformRand();
+
+  u = cos( Phi ) * SinTheta;
+  v = cos( Phi ) * CosTheta,
+  w = sin( Phi );
+
+  return;
+}

source/processes/hadronic/models/cascade/evaporation/src/G4BertiniEvaporationChannel.cc

@@ -0,0 +1,400 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// Implementation of the HETC88 code into Geant4.
+// Evaporation and De-excitation parts
+// T. Lampen, Helsinki Institute of Physics, May-2000
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include "Randomize.hh"
+#include "G4Neutron.hh"
+#include "G4Proton.hh"
+#include "G4Deuteron.hh"
+#include "G4Triton.hh"
+#include "G4Alpha.hh"
+#include "G4ParticleTable.hh"    
+#include "G4Nucleus.hh"  
+#include "G4BertiniEvaporationChannel.hh"
+
+
+G4BertiniEvaporationChannel::G4BertiniEvaporationChannel()
+{
+    verboseLevel = 0;
+}
+
+
+G4BertiniEvaporationChannel::~G4BertiniEvaporationChannel()
+{
+}
+
+
+void G4BertiniEvaporationChannel::setVerboseLevel( G4int level )
+{
+  verboseLevel = level;
+}
+
+
+void G4BertiniEvaporationChannel::setNucleusA( G4int a )
+{
+  nucleusA = a;
+}
+
+
+void G4BertiniEvaporationChannel::setNucleusZ( G4int z )
+{
+  nucleusZ = z;
+}
+
+
+G4int G4BertiniEvaporationChannel::getParticleA()
+{
+  return particleA;
+}
+
+
+G4int G4BertiniEvaporationChannel::getParticleZ()
+{
+  return particleZ;
+}
+
+
+void G4BertiniEvaporationChannel::setExcitationEnergy(G4double energy )
+{
+  excitationEnergy = energy;
+}
+
+
+void G4BertiniEvaporationChannel::setPairingCorrection( G4int isCorrection )
+{
+  G4int residualZ = nucleusZ - particleZ;
+  G4int residualA = nucleusA - particleA;
+
+  // Note: pairing energy is zero for odd nucleon number.
+
+  if ( isCorrection )  correction = pairingEnergyProtons( residualZ )
+	 + pairingEnergyNeutrons( residualA - residualZ );
+  else correction = 0;
+}
+
+
+G4double G4BertiniEvaporationChannel::getProbability()
+{
+  if ( verboseLevel >= 4 )
+    G4cout << "G4BerEvaporationChannel : probability of particle " << name 
+	   << " is " << emissionProbability << G4endl;
+
+  return emissionProbability;
+}
+
+
+G4String G4BertiniEvaporationChannel::getName()
+{
+  return name;
+}
+
+
+void G4BertiniEvaporationChannel::setProbability( G4double newProb )
+{
+  emissionProbability = newProb;
+  return;
+}
+
+
+G4double G4BertiniEvaporationChannel::getQ()
+{
+  // The reaction Q is calculated by using the excess masses of the
+  // secondary particle and the initial and residual nuclei
+  G4int residualZ = nucleusZ  - particleZ;
+  G4int residualA = nucleusA  - particleA;
+  G4int residualN = residualA - residualZ;
+  G4int  nucleusN = nucleusA  - nucleusZ;
+
+  // All the following are by default in MeV
+  const G4double e1 = G4NucleiProperties::GetMassExcess( residualA, residualZ );
+  const G4double e2 = G4NucleiProperties::GetMassExcess( nucleusA,  nucleusZ  );
+
+  return e1 - e2 + G4NucleiProperties::GetMassExcess( particleA, particleZ ); 
+  // In HETC88 : Mass excesses were calculated with the Cameron mass excess formula,
+  // see Cameron, Canadian Journal of Physics,
+  // vol. 35, 1957, p.1022
+  // Also mass excesses of particles were 
+  // 8.3675, 7.5851, 13.7279, 15.8381, 15.8195, 3.6092 for
+  // n, p, D, T, 3He, 4He
+}
+
+
+G4double G4BertiniEvaporationChannel::getThresh()
+{
+  G4double threshold = getQ() + getCoulomb();
+  return threshold;
+}
+
+
+G4double G4BertiniEvaporationChannel::getCoulomb()
+{
+  G4int residualZ = nucleusZ - particleZ;
+  G4int residualA = nucleusA - particleA;
+  const G4double factor = 0.84696; // = e / ( 4 pi epsilon_0 r0 ) * 10^-6, r0=1.7E-15
+  // In HETC88 this factor was 0.88235, perhaps due to different r0
+
+  G4double coulomb = factor *  particleZ * qmFactor() * residualZ / 
+         ( pow( residualA, 0.33333333 ) + rho ) * MeV;
+  
+  if ( verboseLevel >= 10 )
+    G4cout << " G4BertiniEvaporationChannel::getThresh() " << G4endl
+	   << "        residualZ " << residualZ << G4endl
+	   << "        residualA " << residualA << G4endl
+	   << "         qmFactor " << qmFactor() << G4endl
+	   << "               Q  " << getQ() << G4endl      
+	   << "             rho  " << rho << G4endl
+	   << "           part Z " << particleZ << G4endl
+	   << "     (correction) " << correction << G4endl;
+
+  return coulomb;
+}
+
+
+G4double G4BertiniEvaporationChannel::qmFactor()
+{
+  //  Coefficient k_p for empirical cross section
+  //  formula presented in Dostrovsky, Phys. Rev.,
+  //  vol. 116, 1959
+   return 0;
+}
+
+
+G4double G4BertiniEvaporationChannel::getLevelDensityParameter()
+{
+  G4int residualZ = nucleusZ - particleZ;
+  G4int residualA = nucleusA - particleA;
+  G4double b0 = 8;
+  G4double y0 = 1.5;
+
+  G4double temp = ( residualA - 2.0 * residualZ ) / residualA;
+  G4double smallA =  residualA * ( 1.0 + y0 * pow( temp, 2 ) ) / b0 / MeV; 
+
+  // In HETC98 b0 = b0(E).
+
+  return smallA;
+}
+
+
+void G4BertiniEvaporationChannel::isotropicCosines( G4double & u, G4double & v, G4double & w )
+{
+  // Samples isotropic random direction cosines.
+  G4double CosTheta = 1.0 - 2.0 * G4UniformRand();
+  G4double SinTheta = sqrt( 1.0 - CosTheta * CosTheta );
+  G4double Phi = twopi * G4UniformRand();
+
+  u = cos( Phi ) * SinTheta;
+  v = cos( Phi ) * CosTheta,
+  w = sin( Phi );
+
+  return;
+}
+
+
+G4double G4BertiniEvaporationChannel::pairingEnergyProtons(G4int Z)
+{
+  //  Pairing energy for protons P(Z), see 
+  //  Cameron, Nuclear Level Spacings, p. 1040
+  //  Canadian Journal of Physics, vol 36, 1958
+  G4double table [130] = {
+    0.00000000E+00, 0.54399996E+01, 0.00000000E+00, 0.27599993E+01, 0.00000000E+00,
+    0.33399992E+01, 0.00000000E+00, 0.26999998E+01, 0.00000000E+00, 0.18999996E+01,
+    0.00000000E+00, 0.21199999E+01, 0.00000000E+00, 0.21299992E+01, 0.00000000E+00,
+    0.15399990E+01, 0.00000000E+00, 0.14199991E+01, 0.00000000E+00, 0.15099993E+01,
+    0.00000000E+00, 0.17299995E+01, 0.00000000E+00, 0.14399996E+01, 0.00000000E+00,
+    0.14499998E+01, 0.00000000E+00, 0.13699999E+01, 0.00000000E+00, 0.10899992E+01,
+    0.00000000E+00, 0.13599997E+01, 0.00000000E+00, 0.14199991E+01, 0.00000000E+00,
+    0.13299990E+01, 0.00000000E+00, 0.11999998E+01, 0.00000000E+00, 0.99999988E+00,
+    0.00000000E+00, 0.11599998E+01, 0.00000000E+00, 0.12799997E+01, 0.00000000E+00,
+    0.13799992E+01, 0.00000000E+00, 0.13799992E+01, 0.00000000E+00, 0.13199997E+01,
+    0.00000000E+00, 0.10399990E+01, 0.00000000E+00, 0.11099997E+01, 0.00000000E+00,
+    0.11299992E+01, 0.00000000E+00, 0.12099991E+01, 0.00000000E+00, 0.14299994E+01,
+    0.00000000E+00, 0.11499996E+01, 0.00000000E+00, 0.98999995E+00, 0.00000000E+00,
+    0.90999997E+00, 0.00000000E+00, 0.91999996E+00, 0.00000000E+00, 0.99999988E+00,
+    0.00000000E+00, 0.11099997E+01, 0.00000000E+00, 0.12299995E+01, 0.00000000E+00,
+    0.84999996E+00, 0.00000000E+00, 0.97999996E+00, 0.00000000E+00, 0.71999997E+00,
+    0.00000000E+00, 0.79999995E+00, 0.00000000E+00, 0.76999998E+00, 0.00000000E+00,
+    0.88999999E+00, 0.00000000E+00, 0.91999996E+00, 0.00000000E+00, 0.79999995E+00,
+    0.00000000E+00, 0.80999994E+00, 0.00000000E+00, 0.69000000E+00, 0.00000000E+00,
+    0.69999999E+00, 0.00000000E+00, 0.75999999E+00, 0.00000000E+00, 0.72999996E+00,
+    0.00000000E+00, 0.79999995E+00, 0.00000000E+00, 0.73999995E+00, 0.00000000E+00,
+    0.72999996E+00, 0.00000000E+00, 0.71999997E+00, 0.00000000E+00, 0.71999997E+00,
+    0.00000000E+00, 0.71999997E+00, 0.00000000E+00, 0.70999998E+00, 0.00000000E+00,
+    0.69000000E+00, 0.00000000E+00, 0.67999995E+00, 0.00000000E+00, 0.65999997E+00,
+    0.00000000E+00, 0.60999995E+00, 0.00000000E+00, 0.41999996E+00, 0.00000000E+00,
+    0.35999995E+00, 0.00000000E+00, 0.40999997E+00, 0.00000000E+00, 0.48999995E+00
+  };
+  if ( Z>130 ) G4Exception( " G4BertiniEvaporationChannel: pairing energy for protons called with too large Z " ); 
+  return table[ Z-1 ]*MeV;
+}
+
+
+G4double G4BertiniEvaporationChannel::pairingEnergyNeutrons(G4int N)
+{
+//  Pairing energy for neutrons P(N), see 
+//  Cameron, Nuclear Level Spacings, p. 1040
+//  Canadian Journal of Physics, vol 36, 1958
+  G4double table[200] = {
+    0.00000000E+00, 0.59799995E+01, 0.00000000E+00, 0.27699995E+01, 0.00000000E+00,
+    0.31599998E+01, 0.00000000E+00, 0.30099993E+01, 0.00000000E+00, 0.16799994E+01,
+    0.00000000E+00, 0.17299995E+01, 0.00000000E+00, 0.21699991E+01, 0.00000000E+00,
+    0.17399998E+01, 0.00000000E+00, 0.17500000E+01, 0.00000000E+00, 0.17199993E+01,
+    0.00000000E+00, 0.16299992E+01, 0.00000000E+00, 0.14099998E+01, 0.00000000E+00,
+    0.12899990E+01, 0.00000000E+00, 0.14699993E+01, 0.00000000E+00, 0.13199997E+01,
+    0.00000000E+00, 0.14599991E+01, 0.00000000E+00, 0.14399996E+01, 0.00000000E+00,
+    0.14599991E+01, 0.00000000E+00, 0.15199995E+01, 0.00000000E+00, 0.15099993E+01,
+    0.00000000E+00, 0.14699993E+01, 0.00000000E+00, 0.14499998E+01, 0.00000000E+00,
+    0.12799997E+01, 0.00000000E+00, 0.12299995E+01, 0.00000000E+00, 0.12699995E+01,
+    0.00000000E+00, 0.61999995E+00, 0.00000000E+00, 0.75999999E+00, 0.00000000E+00,
+    0.12299995E+01, 0.00000000E+00, 0.12199993E+01, 0.00000000E+00, 0.13999996E+01,
+    0.00000000E+00, 0.13599997E+01, 0.00000000E+00, 0.12999992E+01, 0.00000000E+00,
+    0.12899990E+01, 0.00000000E+00, 0.12399998E+01, 0.00000000E+00, 0.12799997E+01,
+    0.00000000E+00, 0.12399998E+01, 0.00000000E+00, 0.11999998E+01, 0.00000000E+00,
+    0.94000000E+00, 0.00000000E+00, 0.99999988E+00, 0.00000000E+00, 0.10499992E+01,
+    0.00000000E+00, 0.53999996E+00, 0.00000000E+00, 0.59999996E+00, 0.00000000E+00,
+    0.75000000E+00, 0.00000000E+00, 0.75000000E+00, 0.00000000E+00, 0.84999996E+00,
+    0.00000000E+00, 0.96999997E+00, 0.00000000E+00, 0.10199995E+01, 0.00000000E+00,
+    0.10499992E+01, 0.00000000E+00, 0.10599995E+01, 0.00000000E+00, 0.10699997E+01,
+    0.00000000E+00, 0.10599995E+01, 0.00000000E+00, 0.10499992E+01, 0.00000000E+00,
+    0.10199995E+01, 0.00000000E+00, 0.96999997E+00, 0.00000000E+00, 0.90999997E+00,
+    0.00000000E+00, 0.82999998E+00, 0.00000000E+00, 0.73999995E+00, 0.00000000E+00,
+    0.65999997E+00, 0.00000000E+00, 0.60999995E+00, 0.00000000E+00, 0.60999995E+00,
+    0.00000000E+00, 0.89999998E+00, 0.00000000E+00, 0.51999998E+00, 0.00000000E+00,
+    0.80999994E+00, 0.00000000E+00, 0.67999995E+00, 0.00000000E+00, 0.71999997E+00,
+    0.00000000E+00, 0.76999998E+00, 0.00000000E+00, 0.67999995E+00, 0.00000000E+00,
+    0.66999996E+00, 0.00000000E+00, 0.79999995E+00, 0.00000000E+00, 0.67999995E+00,
+    0.00000000E+00, 0.63999999E+00, 0.00000000E+00, 0.57999998E+00, 0.00000000E+00,
+    0.54999995E+00, 0.00000000E+00, 0.56999993E+00, 0.00000000E+00, 0.56999993E+00,
+    0.00000000E+00, 0.54999995E+00, 0.00000000E+00, 0.59999996E+00, 0.00000000E+00,
+    0.57999998E+00, 0.00000000E+00, 0.57999998E+00, 0.00000000E+00, 0.60999995E+00,
+    0.00000000E+00, 0.63000000E+00, 0.00000000E+00, 0.64999998E+00, 0.00000000E+00,
+    0.65999997E+00, 0.00000000E+00, 0.64999998E+00, 0.00000000E+00, 0.64999998E+00,
+    0.00000000E+00, 0.63999999E+00, 0.00000000E+00, 0.63999999E+00, 0.00000000E+00,
+    0.63000000E+00, 0.00000000E+00, 0.60999995E+00, 0.00000000E+00, 0.58999997E+00,
+    0.00000000E+00, 0.54999995E+00, 0.00000000E+00, 0.38999999E+00, 0.00000000E+00,
+    0.35999995E+00, 0.00000000E+00, 0.39999998E+00, 0.00000000E+00, 0.39999998E+00,
+    0.00000000E+00, 0.39999998E+00, 0.00000000E+00, 0.39999998E+00, 0.00000000E+00,
+    0.39999998E+00, 0.00000000E+00, 0.39999998E+00, 0.00000000E+00, 0.39999998E+00
+  };
+  if ( N > 200 ) G4Exception( " G4BertiniEvaporationChannel: pairing energy for neutrons called with too large Z " ); 
+  return table[ N-1 ]*MeV;
+}
+
+
+G4double G4BertiniEvaporationChannel::cameronShellCorrectionP(G4int Z)
+{
+  // Gives the binding energy correction depending in Z
+  // due to shell correction and pairing energies in MeV
+  //
+  // see Cameron, Canadian Journal of Physics,
+  // vol. 35, 1957, p.1022
+  G4double table[130] = {
+    0.26169998E+02,  0.19250000E+02,  0.24209991E+02,  0.20919998E+02,  0.23149994E+02,
+    0.18009995E+02,  0.19549988E+02,  0.16939987E+02,  0.19729996E+02,  0.17069992E+02,
+    0.18209991E+02,  0.14990000E+02,  0.16009995E+02,  0.12040000E+02,  0.13270000E+02,
+    0.11089998E+02,  0.12169999E+02,  0.10259998E+02,  0.11040000E+02,  0.84099998E+01,
+    0.97899990E+01,  0.73599997E+01,  0.81499996E+01,  0.56299992E+01,  0.58799992E+01,
+    0.31699991E+01,  0.33199997E+01,  0.81999993E+00,  0.18299999E+01,  0.96999997E+00,
+    0.23299999E+01,  0.12699995E+01,  0.29199991E+01,  0.16099997E+01,  0.29099998E+01,
+    0.13499994E+01,  0.23999996E+01,  0.88999999E+00,  0.17399998E+01,  0.35999995E+00,
+    0.94999999E+00, -0.64999998E+00, -0.39999995E-01, -0.17299995E+01, -0.95999998E+00,
+    -0.28699999E+01, -0.20499992E+01, -0.40499992E+01, -0.33999996E+01, -0.57199993E+01,
+    -0.37499990E+01, -0.41299992E+01, -0.24199991E+01, -0.28499994E+01, -0.10099993E+01,
+    -0.13299990E+01,  0.53999996E+00, -0.20000000E-01,  0.17399998E+01,  0.75000000E+00,
+    0.22399998E+01,  0.99999988E+00,  0.19799995E+01,  0.78999996E+00,  0.15399990E+01,
+    0.38999999E+00,  0.10799999E+01,  0.00000000E+00,  0.77999997E+00, -0.34999996E+00,
+    0.57999998E+00, -0.54999995E+00,  0.58999997E+00, -0.60999995E+00,  0.58999997E+00,
+    -0.34999996E+00,  0.31999993E+00, -0.95999998E+00, -0.51999998E+00, -0.20799999E+01,
+    -0.24599991E+01, -0.36399994E+01, -0.15499992E+01, -0.95999998E+00,  0.96999997E+00,
+    0.88000000E+00,  0.23699999E+01,  0.17500000E+01,  0.27199993E+01,  0.18999996E+01,
+    0.25499992E+01,  0.14599991E+01,  0.19299994E+01,  0.85999995E+00,  0.11699991E+01,
+    0.79999983E-01,  0.38999999E+00, -0.75999999E+00, -0.38999999E+00, -0.15099993E+01,
+    -0.11699991E+01, -0.23599997E+01, -0.19499998E+01, -0.30599995E+01, -0.26199999E+01,
+    -0.35499992E+01, -0.29499998E+01, -0.37499990E+01, -0.30699997E+01, -0.37899990E+01,
+    -0.30599995E+01, -0.37699995E+01, -0.30499992E+01, -0.37799997E+01, -0.31199999E+01,
+    -0.38999996E+01, -0.33499994E+01, -0.42399998E+01, -0.38599997E+01, -0.49199991E+01,
+    -0.50599995E+01, -0.67699995E+01, -0.74099998E+01, -0.91799994E+01, -0.10160000E+02,
+    -0.11120000E+02, -0.97599993E+01, -0.92299995E+01, -0.79599991E+01, -0.76499996E+01,
+  };
+  if ( Z > 130 ) G4Exception( " G4BertiniEvaporationChannel: shell correction for protons called with too large Z " ); 
+  return table[ Z-1 ]*MeV;
+}
+
+
+G4double G4BertiniEvaporationChannel::cameronShellCorrectionN(G4int N)
+{
+  // Gives the binding energy correction depending in N
+  // due to shell correction and pairing energies in MeV
+  //
+  // see Cameron, Canadian Journal of Physics,
+  // vol. 35, 1957, p.1022
+  G4double table[200] = {
+    -0.83199997E+01, -0.15899999E+02, -0.11509999E+02, -0.14309999E+02, -0.11570000E+02,
+    -0.15899999E+02, -0.13909999E+02, -0.16029999E+02, -0.12129999E+02, -0.13869999E+02,
+    -0.12249998E+02, -0.14399999E+02, -0.13069999E+02, -0.15799998E+02, -0.13809999E+02,
+    -0.14980000E+02, -0.12629999E+02, -0.13759999E+02, -0.11369999E+02, -0.12379998E+02,
+    -0.92299995E+01, -0.96499996E+01, -0.76399994E+01, -0.91699991E+01, -0.80499992E+01,
+    -0.97199993E+01, -0.88699989E+01, -0.10759999E+02, -0.86399994E+01, -0.88899994E+01,
+    -0.65999994E+01, -0.71299992E+01, -0.47699995E+01, -0.53299990E+01, -0.30599995E+01,
+    -0.37899990E+01, -0.17199993E+01, -0.27899990E+01, -0.92999995E+00, -0.21899996E+01,
+    -0.51999998E+00, -0.18999996E+01, -0.44999999E+00, -0.21999998E+01, -0.12199993E+01,
+    -0.30699997E+01, -0.24199991E+01, -0.43699999E+01, -0.39399996E+01, -0.60799999E+01,
+    -0.44899998E+01, -0.45000000E+01, -0.31399994E+01, -0.29299994E+01, -0.10399990E+01,
+    -0.13599997E+01,  0.69000000E+00,  0.20999998E+00,  0.21099997E+01,  0.13299990E+01,
+    0.32900000E+01,  0.24599991E+01,  0.42999992E+01,  0.33199997E+01,  0.47899990E+01,
+    0.36199999E+01,  0.49699993E+01,  0.36399994E+01,  0.46299992E+01,  0.30699997E+01,
+    0.40599995E+01,  0.24899998E+01,  0.32999992E+01,  0.14599991E+01,  0.20599995E+01,
+    0.50999999E+00,  0.73999995E+00, -0.11799994E+01, -0.12599993E+01, -0.35399990E+01,
+    -0.39699993E+01, -0.52599993E+01, -0.41799994E+01, -0.37099991E+01, -0.20999994E+01,
+    -0.16999998E+01, -0.79999983E-01, -0.17999995E+00,  0.94000000E+00,  0.26999998E+00,
+    0.11299992E+01,  0.79999983E-01,  0.90999997E+00, -0.30999994E+00,  0.48999995E+00,
+    -0.77999997E+00,  0.79999983E-01, -0.11499996E+01, -0.22999996E+00, -0.14099998E+01,
+    -0.41999996E+00, -0.15499992E+01, -0.54999995E+00, -0.16599998E+01, -0.65999997E+00,
+    -0.17299995E+01, -0.75000000E+00, -0.17399998E+01, -0.77999997E+00, -0.16899996E+01,
+    -0.77999997E+00, -0.15999994E+01, -0.75000000E+00, -0.14599991E+01, -0.66999996E+00,
+    -0.12599993E+01, -0.50999999E+00, -0.10399990E+01, -0.52999997E+00, -0.18399992E+01,
+    -0.24199991E+01, -0.45199995E+01, -0.47599993E+01, -0.63299990E+01, -0.67599993E+01,
+    -0.78099995E+01, -0.57999992E+01, -0.53699999E+01, -0.36299992E+01, -0.33499994E+01,
+    -0.17500000E+01, -0.18799992E+01, -0.60999995E+00, -0.89999998E+00,  0.89999974E-01,
+    -0.31999993E+00,  0.54999995E+00, -0.13000000E+00,  0.69999999E+00, -0.59999999E-01,
+    0.48999995E+00, -0.19999999E+00,  0.39999998E+00, -0.21999997E+00,  0.35999995E+00,
+    -0.89999974E-01,  0.57999998E+00,  0.11999995E+00,  0.75000000E+00,  0.14999998E+00,
+    0.69999999E+00,  0.16999996E+00,  0.11099997E+01,  0.88999999E+00,  0.18499994E+01,
+    0.16199999E+01,  0.25399990E+01,  0.22899990E+01,  0.31999998E+01,  0.29099998E+01,
+    0.38399992E+01,  0.35299997E+01,  0.44799995E+01,  0.41499996E+01,  0.51199999E+01,
+    0.47799997E+01,  0.57500000E+01,  0.53899994E+01,  0.63099995E+01,  0.59099998E+01,
+    0.68699999E+01,  0.63299990E+01,  0.71299992E+01,  0.66099997E+01,  0.72999992E+01,
+    0.63099995E+01,  0.62699995E+01,  0.48299999E+01,  0.44899998E+01,  0.28499994E+01,
+    0.23199997E+01,  0.57999998E+00, -0.10999995E+00, -0.97999996E+00,  0.80999994E+00,
+    0.17699995E+01,  0.33699999E+01,  0.41299992E+01,  0.55999994E+01,  0.61499996E+01,
+    0.72899990E+01,  0.73499994E+01,  0.79499998E+01,  0.76699991E+01,  0.81599998E+01,
+    0.78299990E+01,  0.83099995E+01,  0.80099993E+01,  0.85299997E+01,  0.82699995E+01
+  };
+  if ( N > 130 ) G4Exception( " G4BertiniEvaporationChannel: shell correction for protons called with too large N " ); 
+  return table[ N-1 ]*MeV;
+}
+

source/processes/hadronic/models/cascade/utils/GNUmakefile

@@ -0,0 +1,32 @@
+# $Id: GNUmakefile,v 1.2 2001/11/16 14:22:37 hpw Exp $
+# -----------------------------------------------------------
+# GNUmakefile for hadronic library.  Gabriele Cosmo, 18/9/96.
+# -----------------------------------------------------------
+
+name := G4hadronic_hetcpp_utils
+
+ifndef G4INSTALL
+  G4INSTALL = ../../../../../..
+endif
+
+include $(G4INSTALL)/config/architecture.gmk
+
+CPPFLAGS += -I$(G4BASE)/global/management/include \
+            -I$(G4BASE)/global/HEPRandom/include \
+            -I$(G4BASE)/global/HEPGeometry/include \
+            -I$(G4BASE)/track/include \
+            -I$(G4BASE)/geometry/volumes/include \
+            -I$(G4BASE)/geometry/management/include \
+            -I$(G4BASE)/processes/management/include \
+            -I$(G4BASE)/processes/hadronic/management/include/ \
+            -I$(G4BASE)/processes/hadronic/util/include \
+            -I$(G4BASE)/processes/hadronic/cross_sections/include/ \
+            -I$(G4BASE)/particles/management/include \
+            -I$(G4BASE)/particles/leptons/include \
+            -I$(G4BASE)/particles/bosons/include \
+            -I$(G4BASE)/particles/hadrons/mesons/include \
+            -I$(G4BASE)/particles/hadrons/barions/include \
+            -I$(G4BASE)/particles/hadrons/ions/include \
+            -I$(G4BASE)/materials/include
+           
+include $(G4INSTALL)/config/common.gmk

source/processes/hadronic/models/cascade/utils/include/G4LayeredNucleus.hh

@@ -0,0 +1,64 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// original class G4Nucleus by H.P. Wellisch
+//   modified by J.L. Chuma, TRIUMF, 19-Nov-1996
+//   last modified: 27-Mar-1997
+//   Chr. Volcker, 10-Nov-1997: new methods and class variables.
+//   M.G. Pia, 2 Oct 1998: modified GetFermiMomentum (original design was
+//                       the source of memory leaks)
+// This class G4LayeredNucleus by T. Lampen 14.6.2000
+
+ 
+#ifndef G4LayeredNucleus_h
+#define G4LayeredNucleus_h 1
+ 
+#include "G4Nucleus.hh"
+ 
+class G4LayeredNucleus  : public G4Nucleus
+{
+public:
+  
+  G4LayeredNucleus() : G4Nucleus()
+  { 
+  }
+  
+  G4LayeredNucleus( const G4double A, const G4double Z ) : G4Nucleus ( A,  Z )
+  {
+  }
+
+  G4LayeredNucleus( const G4Material *aMaterial ) : G4Nucleus ( aMaterial )
+  {
+  }
+
+  G4ThreeVector GetMomentum();
+  void SetMomentum(const G4ThreeVector& mom);
+
+private:
+    
+  G4ThreeVector momentumVector;
+
+};
+ 
+#endif
+ 

source/processes/hadronic/models/cascade/utils/src/G4LayeredNucleus.cc

@@ -0,0 +1,56 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * GEANT4 collaboration.                                            *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+//
+// Modified version of the G4Nucleus class by T. Lampen, HIP, June 2000
+ // original G4Nucleusby H.P. Wellisch
+ // modified by J.L. Chuma, TRIUMF, 19-Nov-1996
+ // last modified: 27-Mar-1997
+ // J.P.Wellisch: 23-Apr-97: minor simplifications
+ // modified by J.L.Chuma 24-Jul-97  to set the total momentum in Cinema and
+ //                                  EvaporationEffects
+ // modified by J.L.Chuma 21-Oct-97  put abs() around the totalE^2-mass^2
+ //                                  in calculation of total momentum in
+ //                                  Cinema and EvaporationEffects
+ // Chr. Volcker, 10-Nov-1997: new methods and class variables.
+ // HPW added utilities for low energy neutron transport. (12.04.1998)
+ // M.G. Pia, 2 Oct 1998: modified GetFermiMomentum to avoid memory leaks
+ 
+#include "G4LayeredNucleus.hh"
+#include "Randomize.hh"
+
+G4ThreeVector G4LayeredNucleus::GetMomentum()
+{
+  return  momentumVector;
+}
+
+
+void G4LayeredNucleus::SetMomentum( const G4ThreeVector& mom )
+  {
+    momentumVector = mom;
+  }
+
+
+
+/* end of file */
+

source/processes/hadronic/models/chiral_inv_phase_space/GNUmakefile

@@ -0,0 +1,18 @@
+# --------------------------------------------------------------
+# GNUmakefile for chips library. HPW 20-Nov-99
+# --------------------------------------------------------------
+
+name := G4hadronic_chips
+
+SUBDIRS  =  body
+SUBDIRS  +=  interface
+
+SUBLIBS  = G4hadronic_body_ci
+SUBLIBS  += G4hadronic_interface_ci
+
+ifndef G4INSTALL
+  G4INSTALL = ../../../../..
+endif
+
+
+include $(G4INSTALL)/config/globlib.gmk

source/processes/hadronic/models/chiral_inv_phase_space/body/GNUmakefile

@@ -0,0 +1,32 @@
+# -----------------------------------------------------------
+# GNUmakefile for chips granular library.  HPW 20-Nov-99
+# -----------------------------------------------------------
+
+name := G4hadronic_body_ci
+
+ifndef G4INSTALL
+  G4INSTALL = ../../../../../..
+endif
+
+include $(G4INSTALL)/config/architecture.gmk
+
+CPPFLAGS += -I$(G4BASE)/global/management/include \
+            -I$(G4BASE)/global/HEPRandom/include \
+            -I$(G4BASE)/global/HEPGeometry/include \
+            -I$(G4BASE)/track/include \
+            -I$(G4BASE)/geometry/volumes/include \
+            -I$(G4BASE)/geometry/management/include \
+            -I$(G4BASE)/processes/management/include \
+            -I$(G4BASE)/processes/hadronic/management/include/ \
+            -I$(G4BASE)/processes/hadronic/util/include \
+            -I$(G4BASE)/processes/hadronic/cross_sections/include/ \
+            -I$(G4BASE)/processes/hadronic/models/generator/util/include \
+            -I$(G4BASE)/particles/management/include \
+            -I$(G4BASE)/particles/leptons/include \
+            -I$(G4BASE)/particles/bosons/include \
+            -I$(G4BASE)/particles/hadrons/mesons/include \
+            -I$(G4BASE)/particles/hadrons/barions/include \
+            -I$(G4BASE)/particles/hadrons/ions/include \
+            -I$(G4BASE)/materials/include 
+           
+include $(G4INSTALL)/config/common.gmk

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4Chips.hh

@@ -0,0 +1,47 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4Chips.hh,v 1.10 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4Chips ----------------
+//          by Mikhail Kossov, September 1999.
+//      namespace for constants of the CHIPS Model
+// ------------------------------------------------------------
+
+#ifndef G4Chips_h
+#define G4Chips_h 1
+
+// >>> D O E S   N O T   W O R K   -   N O T   U S E D    N O W <<<
+// Instead the "static const G4double" are used in the member functions
+
+namespace G4Chips
+{
+  // To have 3 quarks in Nucleon Temperature should be < M_N/4 (234 MeV)
+  const G4double  Temperature = 200.;  // Temperature of Quasmon (constant of the model)
+}
+
+// Now the same constants or types should be made global (if it is necessary)
+//
+const double& G4Chips::Temperature Temperature;
+// typedef G4Chips::NewType Newtype;

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QCHIPSWorld.hh

@@ -0,0 +1,84 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QCHIPSWorld.hh,v 1.10 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCHIPSWorld ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for CHIPS World of particles in CHIPS Model
+// ------------------------------------------------------------
+
+#ifndef G4QCHIPSWorld_h
+#define G4QCHIPSWorld_h 1
+
+#include "g4std/iostream"
+#include "globals.hh"
+#include "G4QParticleVector.hh"
+
+class G4QCHIPSWorld
+{
+public:
+  // Constructors
+  G4QCHIPSWorld(G4int nOfParts = 0);                // Construction with N particles
+  G4QCHIPSWorld(const G4QCHIPSWorld& right);        // Copy Constructor by value
+  G4QCHIPSWorld(G4QCHIPSWorld* right);              // Copy Constructor by pointer
+
+  ~G4QCHIPSWorld();                                 // Destructor
+
+  // Overloaded Operators
+  const G4QCHIPSWorld& operator=(const G4QCHIPSWorld& right);
+
+  // Selectors
+  G4QParticle* GetQParticle(G4int PDG)       const; // Get pointer to particle in CHIPS World
+  G4QParticle* GetQParticle(G4QPDGCode QPDG) const; // Get pointer to particle in CHIPS World
+  G4QParticle* GetQParticle(G4QPDGCode* pQP) const; // Get pointer to particle in CHIPS World
+  G4int        GetQPEntries()                const; // Get a#of particles in CHIPS World
+
+private:
+  G4QParticleVector* InitCHIPSWorld(G4int nOfParts);// nOfParts<0 kills the CHIPS World @@??
+
+// Body
+private:
+  G4QParticleVector* qWorld;                        // Pointer to the CHIPS World (C++ Hip)
+};
+
+ 
+inline G4QParticle* G4QCHIPSWorld::GetQParticle(G4int       PDG) const
+{
+  return (*qWorld)[G4QPDGCode(PDG).GetQCode()];
+}
+inline G4QParticle* G4QCHIPSWorld::GetQParticle(G4QPDGCode QPDG) const
+{
+  return (*qWorld)[QPDG.GetQCode()];
+}
+inline G4QParticle* G4QCHIPSWorld::GetQParticle(G4QPDGCode* pQP) const
+{
+  return (*qWorld)[pQP->GetQCode()];
+}
+inline G4int        G4QCHIPSWorld::GetQPEntries() const {return (*qWorld).size();}
+
+#endif
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QCandidate.hh

@@ -0,0 +1,136 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QCandidate.hh,v 1.13 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCandidate ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for Quasmon initiated Candidates used by the CHIPS Model
+// ----------------------------------------------------------------------
+
+#ifndef G4QCandidate_h
+#define G4QCandidate_h 1
+
+#include "G4QHadron.hh"
+#include "G4QParentClusterVector.hh"
+#include "g4std/algorithm"
+
+class G4QCandidate : public G4QHadron
+{
+public:
+  G4QCandidate();                                            // Default Constructor
+  G4QCandidate(G4int PDGcode);                               // Constructor by PDG Code
+  G4QCandidate(const G4QCandidate& right);                   // Copy Constructor by value
+  G4QCandidate(G4QCandidate* right);                         // Copy Constructor by pointer
+  ~G4QCandidate();                                           // Destructor
+  // Overloaded Operators
+  const G4QCandidate& operator=(const G4QCandidate& right);
+  G4int operator==(const G4QCandidate &right) const;
+  G4int operator!=(const G4QCandidate &right) const;
+  // Specific Selectors
+  G4QParentCluster* TakeParClust(G4int nPC);// Get pointer to Parent Cluster from ParClastVector
+  G4int    GetPClustEntries()    const;     // Get a number of Parent Clusters in ParClastVector
+  G4bool   GetPossibility()      const;     // Get possibility(true)/forbiding(false) to be a hadr./fragm.
+  G4bool   GetParPossibility()   const;     // Get possibility(true)/forbiding(false) to be a parent
+  G4double GetKMin()             const;     // Get k-minimal for the candidate
+  G4double GetEBMass()           const;     // Get bound mass in respect to Environment 
+  G4double GetNBMass()           const;     // Get bound mass in respect to TotalNucleus 
+  G4double GetDenseProbability() const;     // Get dense-probability for the candidate 
+  G4double GetPreProbability()   const;     // Get pre-probability for the candidate 
+  G4double GetRelProbability()   const;     // Get the relative probility of hadronization
+  G4double GetIntegProbability() const;     // Get integrated probability for randomization
+  G4double GetSecondRelProb()    const;     // Get 2nd relative probility of hadronization
+  G4double GetSecondIntProb()    const;     // Get 2nd integ. probability for randomization
+  // Specific Modifiers
+  void ClearParClustVector();               // Clear the Parent Claster Vector of the Candidate
+  void FillPClustVec(G4QParentCluster* pCl);// Fill pointer to Parent Cluster in ParClastVector
+  void SetPossibility(G4bool choice);       // Set possibility(true)/forbiding(false) to be a hadr./fragm.
+  void SetParPossibility(G4bool choice);    // Set possibility(true)/forbiding(false) to be a parent
+  void SetKMin(G4double kmin);              // Set k-minimal for the candidate
+  void SetDenseProbability(G4double prep);   // Set dense-probability for the candidate 
+  void SetPreProbability(G4double prep);    // Set pre-probability for the candidate 
+  void SetRelProbability(G4double relP);    // Set the relative probility of hadronization
+  void SetIntegProbability(G4double intP);  // Set integrated probability for randomization
+  void SetSecondRelProb(G4double relP);     // Set 2nd relative probility of hadronization
+  void SetSecondIntProb(G4double intP);     // Set 2nd integr. probability for randomization
+  void SetEBMass(G4double newMass);         // Set mass bounded to Environment
+  void SetNBMass(G4double newMass);         // Set mass bounded to Total Nucleus
+
+// Body  								   
+private:
+  G4bool   possible;                        // permission/forbiding preFlag to be a hadron/fragment
+  G4bool   parPossible;                     // permission/forbiding preFlag to be a parent
+  G4double kMin;                            // mu^2/2M (Q-case), ~BindingEnergy (Clust.-case)
+  G4double denseProbability;                // a#of clusters of the type in dense region
+  G4double preProbability;                  // a#of clusters of the type or Q-suppression
+  G4double relativeProbability;             // relative probability of hadronization
+  G4double integralProbability;             // integrated probability of randomization
+  G4double secondRelProbability;            // spare relative probability of hadronization
+  G4double secondIntProbability;            // spare integrated probability of randomization
+  G4QParentClusterVector thePClusters;      // vector of parent clusters for candid.-fragment
+  G4double EBMass;                          // Bound Mass of the cluster in the Environment
+  G4double NBMass;                          // Bound Mass of the cluster in the Total Nucleus
+};
+
+inline G4int G4QCandidate::operator==(const G4QCandidate &right) const  {return this==&right;}
+inline G4int G4QCandidate::operator!=(const G4QCandidate &right) const  {return this!=&right;}
+
+inline G4QParentCluster* G4QCandidate::TakeParClust(G4int nPC)  {return thePClusters[nPC];}
+inline G4int    G4QCandidate::GetPClustEntries()          const {return thePClusters.size();}
+inline G4bool   G4QCandidate::GetPossibility()            const {return possible;}
+inline G4bool   G4QCandidate::GetParPossibility()         const {return parPossible;}
+inline G4double G4QCandidate::GetKMin()                   const {return kMin;}
+inline G4double G4QCandidate::GetEBMass()                 const {return EBMass;}
+inline G4double G4QCandidate::GetNBMass()                 const {return NBMass;}
+inline G4double G4QCandidate::GetDenseProbability()       const {return denseProbability;}
+inline G4double G4QCandidate::GetPreProbability()         const {return preProbability;}
+inline G4double G4QCandidate::GetRelProbability()         const {return relativeProbability;}
+inline G4double G4QCandidate::GetIntegProbability()       const {return integralProbability;}
+inline G4double G4QCandidate::GetSecondRelProb()          const {return secondRelProbability;}
+inline G4double G4QCandidate::GetSecondIntProb()          const {return secondIntProbability;}
+
+inline void G4QCandidate::ClearParClustVector()                 
+{
+  G4std::for_each(thePClusters.begin(), thePClusters.end(), DeleteQParentCluster());
+  thePClusters.clear();
+}
+
+inline void G4QCandidate::FillPClustVec(G4QParentCluster* pCl)
+{
+  G4QParentCluster* npCl = new G4QParentCluster(pCl);
+  thePClusters.push_back(npCl);                              // Fill new instance of PCl
+}
+inline void G4QCandidate::SetPossibility(G4bool choice)         {possible=choice;}
+inline void G4QCandidate::SetParPossibility(G4bool choice)      {parPossible=choice;}
+inline void G4QCandidate::SetKMin(G4double kmin)                {kMin=kmin;}
+inline void G4QCandidate::SetDenseProbability(G4double prep)    {denseProbability=prep;}
+inline void G4QCandidate::SetPreProbability(G4double prep)      {preProbability=prep;}
+inline void G4QCandidate::SetRelProbability(G4double relP)      {relativeProbability=relP;}
+inline void G4QCandidate::SetIntegProbability(G4double intP)    {integralProbability=intP;}
+inline void G4QCandidate::SetSecondRelProb(G4double relP)       {secondRelProbability=relP;}
+inline void G4QCandidate::SetSecondIntProb(G4double intP)       {secondIntProbability=intP;}
+inline void G4QCandidate::SetEBMass(G4double newM)              {EBMass=newM;}
+inline void G4QCandidate::SetNBMass(G4double newM)              {NBMass=newM;}
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QCandidateVector.hh

@@ -0,0 +1,41 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QCandidateVector.hh,v 1.11 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCandidateVector ----------------
+//             by Mikhail Kossov, Sept 1999.
+// Type defenition for Quasmon initiated Candidates used by CHIPS model
+// -----------------------------------------------------------------
+
+#ifndef G4QCandidateVector_h
+#define G4QCandidateVector_h 1
+
+#include "G4QCandidate.hh"
+#include "g4std/vector"
+
+typedef G4std::vector<G4QCandidate *> G4QCandidateVector;
+struct DeleteQCandidate{ void operator()(G4QCandidate * aQ){delete aQ;}};
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QChipolino.hh

@@ -0,0 +1,112 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QChipolino.hh,v 1.9 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QChipolino ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for Chipolino (Double Hadron) in CHIPS Model
+// ----------------------------------------------------------
+
+#ifndef G4QChipolino_h
+#define G4QChipolino_h 1
+
+#include "globals.hh"
+//#include "G4QContent.hh"
+#include "G4QPDGCode.hh"
+
+class G4QChipolino
+{
+public:
+  // Constructors
+  G4QChipolino();                                      // Default Constructor
+  G4QChipolino(G4QContent& QContent);                  // Construction by Quark Content
+  G4QChipolino(const G4QChipolino& right);             // Copy constructor by value
+  G4QChipolino(G4QChipolino* right);                   // Copy constructor by pointer
+
+  ~G4QChipolino();                                     // Destructor
+
+  // Operators
+  const G4QChipolino& operator=(const G4QChipolino& right);
+  G4int              operator==(const G4QChipolino& right) const;
+  G4int              operator!=(const G4QChipolino& right) const;
+
+  // Selectors
+  G4double              GetMass();            // Get mass of the Chipolino (MinDoubleHadronMass)
+  G4double              GetMass2();           // Get mass^2 of the Chipolino
+  G4QPDGCode            GetQPDG1();           // Get 1-st QPDG of the Chipolino
+  G4QPDGCode            GetQPDG2();           // Get 2-nd QPDG of the Chipolino
+  G4QContent            GetQContent() const;  // Get private quark content of the Chipolino
+  G4QContent            GetQContent1() const; // Get 1-st quark content of the Chipolino
+  G4QContent            GetQContent2() const; // Get 2-st quark content of the Chipolino
+
+  // Modifiers
+  void SetHadronQPDG(const G4QPDGCode& QPDG); // Set QPDG of 1-st Hadron of the Chipolino
+  void SetHadronPDGCode(const G4int& PDGCode);// Set PDGCode of 1-st Hadron of the Chipolino
+  void SetHadronQCont(const G4QContent& QC);  // Set QContent of 1-st Hadron of the Chipolino
+
+private:  
+  G4QPDGCode            theQPDG1;             // QPDG of the 1-st Hadron of the Chipolino
+  G4QPDGCode            theQPDG2;             // QPDG of the 2-nd Hadron of the Chipolino
+  G4QContent            theQCont;             // Quark Content of the whole Chipolino
+  G4QContent            theQCont1;            // Quark Content of the 1-st Hadron of Chipolino
+  G4double              minM;                 // Minimal Mass of Chipolino
+};
+
+G4std::ostream& operator<<(G4std::ostream& lhs, G4QChipolino& rhs);
+//G4std::ostream& operator<<(G4std::ostream& lhs, const G4QChipolino& rhs);
+inline G4int G4QChipolino::operator==(const G4QChipolino& right) const {return this==&right;}
+inline G4int G4QChipolino::operator!=(const G4QChipolino& right) const {return this!=&right;}
+ 
+inline G4double   G4QChipolino::GetMass()      {return minM;}
+inline G4double   G4QChipolino::GetMass2()     {return minM*minM;}
+inline G4QPDGCode G4QChipolino::GetQPDG1()     {return theQPDG1;}
+inline G4QPDGCode G4QChipolino::GetQPDG2()     {return theQPDG2;}
+inline G4QContent G4QChipolino::GetQContent1() const {return theQCont1;}
+inline G4QContent G4QChipolino::GetQContent2() const {return theQCont - theQCont1;}
+inline G4QContent G4QChipolino::GetQContent()  const {return theQCont;}
+
+
+inline void G4QChipolino::SetHadronQPDG(const G4QPDGCode& newQPDG)
+{
+  theQPDG1  = newQPDG;
+  theQCont1 = theQPDG1.GetQuarkContent();
+  G4QContent theQCont2 = theQCont - theQCont1;
+  theQPDG2  = G4QPDGCode(theQCont2.GetSPDGCode());
+}
+
+inline void G4QChipolino::SetHadronPDGCode(const G4int& PDGCode)
+{
+  theQPDG1.SetPDGCode(PDGCode);
+  SetHadronQPDG(theQPDG1);
+}
+inline void G4QChipolino::SetHadronQCont(const G4QContent& QCont)
+                          {SetHadronPDGCode(QCont.GetSPDGCode());}
+
+#endif
+
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QContent.hh

@@ -0,0 +1,317 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QContent.hh,v 1.14 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QContent ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for Quasmon initiated Contents used by the CHIPS Model
+// ----------------------------------------------------------------------
+
+#ifndef G4QContent_h
+#define G4QContent_h 1
+
+#include "g4std/iostream"
+#include "globals.hh"
+#include "Randomize.hh"
+
+class G4QContent
+{
+public:
+  G4QContent(G4int d=0, G4int u=0, G4int s=0, G4int ad=0, G4int au=0, G4int as=0);
+  G4QContent(const G4QContent& rhs);     // Copy constructor by value
+  G4QContent(G4QContent* rhs);           // Copy constructor by pointer
+
+  ~G4QContent();
+
+  // Overloaded operators
+  const G4QContent& operator=(const G4QContent& rhs);
+  G4int             operator==(const G4QContent& rhs) const;
+  G4int             operator!=(const G4QContent& rhs) const;
+  G4QContent        operator+=(G4QContent& rhs);
+  G4QContent        operator-=(G4QContent& rhs);
+  G4QContent        operator*=(G4int& rhs);
+  G4QContent        operator+=(const G4QContent& rhs);
+  G4QContent        operator-=(const G4QContent& rhs);
+  G4QContent        operator*=(const G4int& rhs);
+
+  // Selectors  
+  G4int             GetCharge() const;
+  G4int             GetBaryonNumber() const;
+  G4int             GetStrangeness() const;
+  G4int             GetSPDGCode() const;
+  G4int             GetZNSPDGCode() const;
+  G4int             NOfCombinations(const G4QContent& rhs) const; //@@ can be an "operator/"
+  G4int             GetQ() const;
+  G4int             GetAQ() const;
+  G4int             GetTot() const; 
+  G4bool            CheckNegative() const;
+
+  G4int GetP() const;       // A#of protons
+  G4int GetN() const;       // A#of neutrons
+  G4int GetL() const;       // A#of lambdas
+  G4int GetAP() const;      // A#of anti-protons
+  G4int GetAN() const;      // A#of anti-neutrons
+  G4int GetAL() const;      // A#of anti-lambdas
+
+  G4int GetD() const;       // A#of d-quarks
+  G4int GetU() const;       // A#of u-quarks
+  G4int GetS() const;       // A#of s-quarks
+  G4int GetAD() const;      // A#of anti-d-quarks
+  G4int GetAU() const;      // A#of anti-u-quarks
+  G4int GetAS() const;      // A#of anti-s-quarks
+
+  G4int GetNetD() const;    // A net#of d-quarks
+  G4int GetNetU() const;    // A net#of u-quarks
+  G4int GetNetS() const;    // A net#of s-quarks
+  G4int GetNetAD() const;   // A net#of anti-d-quarks
+  G4int GetNetAU() const;   // A net#of anti-u-quarks
+  G4int GetNetAS() const;   // A net#of anti-s-quarks
+
+  G4int GetDD() const;      // A#of dd-di-quarks
+  G4int GetUU() const;      // A#of uu-di-quarks
+  G4int GetSS() const;      // A#of ss-di-quarks
+  G4int GetUD() const;      // A#of ud-di-quarks
+  G4int GetDS() const;      // A#of ds-di-quarks
+  G4int GetUS() const;      // A#of us-di-quarks
+  G4int GetADAD() const;    // A#of anti-dd-di-quarks
+  G4int GetAUAU() const;    // A#of anti-uu-di-quarks
+  G4int GetASAS() const;    // A#of anti-ss-di-quarks
+  G4int GetAUAD() const;    // A#of anti-ud-di-quarks
+  G4int GetADAS() const;    // A#of anti-ds-di-quarks
+  G4int GetAUAS() const;    // A#of anti-us-di-quarks
+
+  // Modifiers
+  void              Anti();
+  G4QContent        IndQ (G4int ind=0);
+  G4QContent        IndAQ(G4int ind=0);
+  G4QContent        SplitChipo(G4double mQ);
+  G4bool            SubtractHadron(G4QContent h);
+  G4bool            SubtractPi0();
+  G4bool            SubtractPion();
+  G4bool            SubtractKaon(G4double mQ);
+
+  void SetD (G4int n=0);
+  void SetU (G4int n=0);
+  void SetS (G4int n=0);
+  void SetAD(G4int n=0);
+  void SetAU(G4int n=0);
+  void SetAS(G4int n=0);
+
+  void IncD (G4int n=1);
+  void IncU (G4int n=1);
+  void IncS (G4int n=1);
+  void IncAD(G4int n=1);
+  void IncAU(G4int n=1);
+  void IncAS(G4int n=1);
+  void IncQAQ(const G4int& nQAQ=1, const G4double& sProb = 1.);
+
+  void DecD (G4int n=1);
+  void DecU (G4int n=1);
+  void DecS (G4int n=1);
+  void DecAD(G4int n=1);
+  void DecAU(G4int n=1);
+  void DecAS(G4int n=1);
+  G4int DecQAQ(const G4int& nQAQ=1);
+
+private:
+  G4QContent        GetThis() const;
+
+  // Body
+private:            //                       C    S
+  G4int nD;         // a#of      d-quarks (-1/3)( 0)
+  G4int nU;         // a#of      u-quarks (+2/3)( 0)
+  G4int nS;         // a#of      s-quarks (-1/3)(+1)
+  G4int nAD;        // a#of anti-d-quarks (+1/3)( 0)
+  G4int nAU;        // a#of anti-u-quarks (-2/3)( 0)
+  G4int nAS;        // a#of anti-s-quarks (+1/3)(-1)
+};
+
+// Not member operators
+G4std::ostream&   operator<<(G4std::ostream& lhs, G4QContent& rhs);
+G4std::ostream&   operator<<(G4std::ostream& lhs, const G4QContent& rhs);
+G4QContent operator+(const G4QContent& lhs, const G4QContent& rhs);
+G4QContent operator-(const G4QContent& lhs, const G4QContent& rhs);
+G4QContent operator*(const G4QContent& lhs, const G4int&      rhs);
+G4QContent operator*(const G4int&      lhs, const G4QContent& rhs);
+//G4int      operator/(const G4QContent& lhs, const G4QContent& rhs); // Combinations
+// Not member functions
+//----------------------------------------------------------------------------------------
+
+inline G4int      G4QContent::operator==(const G4QContent& rhs) const {return this==&rhs;}	
+inline G4int      G4QContent::operator!=(const G4QContent& rhs) const {return this!=&rhs;}
+inline G4int      G4QContent::GetQ() const {return nU+nD+nS;}
+inline G4int      G4QContent::GetAQ() const {return nAU+nAD+nAS;}
+inline G4int      G4QContent::GetTot() const {return nU+nD+nS+nAU+nAD+nAS;}
+inline G4int      G4QContent::GetStrangeness() const {return nS-nAS;}
+// @@ Temporary for tests
+inline G4bool G4QContent::CheckNegative() const{return nU<0||nD<0||nS<0||nAU<0||nAD<0||nAS<0;}
+
+inline G4int G4QContent::GetU() const{return nU;}
+inline G4int G4QContent::GetD() const{return nD;}
+inline G4int G4QContent::GetS() const{return nS;}
+inline G4int G4QContent::GetAU() const{return nAU;}
+inline G4int G4QContent::GetAD() const{return nAD;}
+inline G4int G4QContent::GetAS() const{return nAS;}
+
+inline G4int G4QContent::GetNetU() const{return nU-nAU;}
+inline G4int G4QContent::GetNetD() const{return nD-nAD;}
+inline G4int G4QContent::GetNetS() const{return nS-nAS;}
+inline G4int G4QContent::GetNetAU() const{return nAU-nU;}
+inline G4int G4QContent::GetNetAD() const{return nAD-nD;}
+inline G4int G4QContent::GetNetAS() const{return nAS-nS;}
+
+inline G4int G4QContent::GetUU() const{return nU*(nU-1)/2;}
+inline G4int G4QContent::GetDD() const{return nD*(nD-1)/2;}
+inline G4int G4QContent::GetSS() const{return nS*(nS-1)/2;}
+inline G4int G4QContent::GetUD() const{return nU*nD;}
+inline G4int G4QContent::GetUS() const{return nU*nS;}
+inline G4int G4QContent::GetDS() const{return nD*nS;}
+inline G4int G4QContent::GetAUAU() const{return nAU*(nAU-1)/2;}
+inline G4int G4QContent::GetADAD() const{return nAD*(nAD-1)/2;}
+inline G4int G4QContent::GetASAS() const{return nAS*(nAS-1)/2;}
+inline G4int G4QContent::GetAUAD() const{return nAU*nAD;}
+inline G4int G4QContent::GetAUAS() const{return nAU*nAS;}
+inline G4int G4QContent::GetADAS() const{return nAD*nAS;}
+
+// Convert particle to anti-particle
+inline G4int G4QContent::GetZNSPDGCode() const
+{
+  G4int kD=nD-nAD;                           // A net # of d quarks
+  G4int kU=nU-nAU;                           // A net # of u quarks
+  G4int kS=nS-nAS;                           // A net # of s quarks
+  // if(kD>=0&&kU>=0&&kS>=0&&kD+kU+kS>0)        // => "Normal nucleus" case
+  //{
+  //  G4int b=(kU+kD-kS-kS)/3;
+  //  G4int d=kU-kD;
+  //  G4int n=(b-d)/2;
+  //  return 90000000+1000*(1000*kS+n+d)+n;
+  //}
+  //else if(kD<=0&&kU<=0&&kS<=0&&kD+kU+kS<0)   // => "Normal anti-nucleus" case
+  //{
+  //  G4int b=(kS+kS-kD-kU)/3;
+  //  G4int d=kD-kU;
+  //  G4int n=(b-d)/2;
+  //  return -90000000-1000*(1000*kS+n+d)-n;   // @@ double notation for anti-nuclei
+  //}
+  //else
+  //{
+    G4int b=(kU+kD-kS-kS)/3;                 // Baryon number-n*{LAMBDA=kS)
+    G4int d=kU-kD;                           // Isotopic shift
+    G4int n=(b-d)/2;                         // A#of neutrons
+    return 90000000+1000*(1000*kS+n+d)+n;
+  //}
+  //return 0;
+}
+
+// Convert particle to anti-particle
+inline void G4QContent::Anti()
+{
+  G4int r=nD;
+  nD = nAD;
+  nAD= r;
+  r  = nU;
+  nU = nAU;
+  nAU= r;
+  r  = nS;
+  nS = nAS;
+  nAS= r;
+}
+
+// Add Quark Content
+inline G4QContent G4QContent::operator+=(const G4QContent& rhs)
+//     =======================================================
+{
+  nD += rhs.nD;
+  nU += rhs.nU;
+  nS += rhs.nS;
+  nAD+= rhs.nAD;
+  nAU+= rhs.nAU;
+  nAS+= rhs.nAS;
+  return *this;
+} 
+
+// Add Quark Content
+inline G4QContent G4QContent::operator+=(G4QContent& rhs)
+//     =======================================================
+{
+  nD += rhs.nD;
+  nU += rhs.nU;
+  nS += rhs.nS;
+  nAD+= rhs.nAD;
+  nAU+= rhs.nAU;
+  nAS+= rhs.nAS;
+  return *this;
+} 
+
+// Multiply Quark Content by integer number
+inline G4QContent G4QContent::operator*=(const G4int& rhs)
+//     ===================================================
+{
+  nU *= rhs;
+  nD *= rhs;
+  nS *= rhs;
+  nAU*= rhs;
+  nAD*= rhs;
+  nAS*= rhs;
+  return *this;
+} 
+
+// Multiply Quark Content by integer number
+inline G4QContent G4QContent::operator*=(G4int& rhs)
+//     ===================================================
+{
+  nU *= rhs;
+  nD *= rhs;
+  nS *= rhs;
+  nAU*= rhs;
+  nAD*= rhs;
+  nAS*= rhs;
+  return *this;
+} 
+
+inline void  G4QContent::SetU(G4int n) {nU=n;}
+inline void  G4QContent::SetD(G4int n) {nD=n;}
+inline void  G4QContent::SetS(G4int n) {nS=n;}
+inline void  G4QContent::SetAU(G4int n){nAU=n;}
+inline void  G4QContent::SetAD(G4int n){nAD=n;}
+inline void  G4QContent::SetAS(G4int n){nAS=n;}
+
+inline void  G4QContent::IncU(G4int n) {nU+=n;}
+inline void  G4QContent::IncD(G4int n) {nD+=n;}
+inline void  G4QContent::IncS(G4int n) {nS+=n;}
+inline void  G4QContent::IncAU(G4int n){nAU+=n;}
+inline void  G4QContent::IncAD(G4int n){nAD+=n;}
+inline void  G4QContent::IncAS(G4int n){nAS+=n;}
+
+inline void  G4QContent::DecU(G4int n) {nU-=n;}
+inline void  G4QContent::DecD(G4int n) {nD-=n;}
+inline void  G4QContent::DecS(G4int n) {nS-=n;}
+inline void  G4QContent::DecAU(G4int n){nAU-=n;}
+inline void  G4QContent::DecAD(G4int n){nAD-=n;}
+inline void  G4QContent::DecAS(G4int n){nAS-=n;}
+
+// Private member functions
+inline G4QContent G4QContent::GetThis()const{return G4QContent(nD,nU,nS,nAD,nAU,nAS);}
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QDecayChan.hh

@@ -0,0 +1,94 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QDecayChan.hh,v 1.9 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QDecayChan ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for Decay Channel definition in CHIPS Model
+// ------------------------------------------------------------
+
+#ifndef G4QDecayChan_h
+#define G4QDecayChan_h 1
+
+#include "g4std/iostream"
+#include "globals.hh"
+#include "G4QPDGCodeVector.hh"
+
+class G4QDecayChan
+{
+public:
+  // Constructors
+  G4QDecayChan();                                                    // Default Constructor
+  G4QDecayChan(G4QPDGCodeVector secHadr, G4double probLimit = 1.);   // General Constructor
+  G4QDecayChan(G4double pLev, G4int PDG1, G4int PDG2, G4int PDG3=0); // Detailed Constructor
+  G4QDecayChan(const G4QDecayChan& right);                           // Copy Constructor by value
+  G4QDecayChan(G4QDecayChan* right);                                 // Copy Constructor by pointer
+
+  ~G4QDecayChan();                                                   // Destructor
+
+  // Operators
+  const G4QDecayChan& operator=(const G4QDecayChan& right);
+  G4int               operator==(const G4QDecayChan& rhs) const;
+  G4int               operator!=(const G4QDecayChan& rhs) const;
+
+  // Selectors
+  G4double         GetDecayChanLimit() const;    // Get a Decay Channel Probability Limit
+  G4double         GetMinMass() const;           // Get a Minimum Mass for the Decay Channel
+  G4QPDGCodeVector GetVecOfSecHadrons();         // Get a Vector of secondary PDG-particles
+
+  // Modifiers
+  void SetDecayChanLimit(G4double newDecChanLim);// Set a Decay Channel Probability Limit
+  void SetMinMass(G4double newMinMass);          // Set a Minimum Mass for the Decay Channel
+  void SetVecOfSecHadrons(G4QPDGCodeVector hadV);// Set a Vector of secondary PDG-particles
+
+  //private:
+  // Encapsulated functions
+
+private:
+  // the Body
+  G4double aDecayChanLimit;
+  G4double theMinMass;
+  G4QPDGCodeVector aVecOfSecHadrons;
+};
+
+// Not member operators
+G4std::ostream&   operator<<(G4std::ostream& lhs, G4QDecayChan& rhs);
+//----------------------------------------------------------------------------------------
+
+inline G4int G4QDecayChan::operator==(const G4QDecayChan& rhs) const {return this==&rhs;}
+inline G4int G4QDecayChan::operator!=(const G4QDecayChan& rhs) const {return this!=&rhs;}
+ 
+inline G4double G4QDecayChan::GetDecayChanLimit() const    {return aDecayChanLimit;}
+inline G4double G4QDecayChan::GetMinMass() const           {return theMinMass;}
+inline G4QPDGCodeVector G4QDecayChan::GetVecOfSecHadrons() {return aVecOfSecHadrons;}
+
+inline void G4QDecayChan::SetDecayChanLimit(G4double DCL)          {aDecayChanLimit=DCL;}
+inline void G4QDecayChan::SetMinMass(G4double minMass)             {theMinMass=minMass;}
+inline void G4QDecayChan::SetVecOfSecHadrons(G4QPDGCodeVector VSH) {aVecOfSecHadrons=VSH;}
+
+#endif
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QDecayChanVector.hh

@@ -0,0 +1,41 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QDecayChanVector.hh,v 1.8 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCandidateVector ----------------
+//             by Mikhail Kossov, Sept 1999.
+// Type defenition for Decay Channel Vector in CHIPS model
+// --------------------------------------------------------------
+
+#ifndef G4QDecayChanVector_h
+#define G4QDecayChanVector_h 1
+
+#include "G4QDecayChan.hh"
+#include "g4std/vector"
+
+typedef G4std::vector<G4QDecayChan *> G4QDecayChanVector;
+struct DeleteQDecayChan{void operator()(G4QDecayChan *aQ){delete aQ;}};
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QEnvironment.hh

@@ -0,0 +1,107 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QEnvironment.hh,v 1.9 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QEnvironment ----------------
+//             by Mikhail Kossov, August 2000.
+//      header for Multy Quasmon Environment in the CHIPS Model
+// ------------------------------------------------------------
+
+#ifndef G4QEnvironment_h
+#define G4QEnvironment_h 1
+
+// Standard G4-headers
+#include "G4QuasmonVector.hh"
+
+class G4QEnvironment 
+{
+public:
+  G4QEnvironment(const G4QHadronVector& projHadrons, const G4int targPDG);
+  G4QEnvironment(const G4QEnvironment& right);         // copy QEnvironment by value
+  G4QEnvironment(G4QEnvironment* right);               // copy QEnvironment by pointer
+  ~G4QEnvironment();
+
+  // Overloaded operators
+  const G4QEnvironment& operator=(const G4QEnvironment& right);
+  int operator==(const G4QEnvironment &right) const;
+  int operator!=(const G4QEnvironment &right) const;
+
+  //Selectors
+  G4QNucleus       GetEnvironment() const;
+  G4QuasmonVector* GetQuasmons();
+  G4QHadronVector* GetQHadrons();
+  G4QHadronVector* Fragment();                        // Unresp. wrapper for HadronizeQEnvironment()
+
+  // Static functions
+  static void SetParameters( G4double solAn=0.4, G4bool efFlag=false, G4double piThresh=141.4,
+                            G4double mpisq=20000., G4double dinum=1880.);
+  // General functions
+  G4ThreeVector    RndmDir();                         // Randomize 3D direction (@@subst by libFunc)
+
+private:  
+  G4QHadronVector  HadronizeQEnvironment();           // Main HadronizationFunction used in Fragment
+  void             CreateQuasmon(const G4QContent& projQC, const G4LorentzVector& proj4M);
+  void             InitClustersVector(G4int maxC, G4int maxA); // Init.NucCclusters for 1st interact
+  void             CleanUp();                         // Makes theEnvironment=vacuum & kill Quasmons
+  void             PrepareInteractionProbabilities(const G4QContent& projQC, G4double AP);
+  void             EvaporateResidual(G4QHadron* evap, G4bool corFlag = false);// Final Evaporation
+  void             DecayDibaryon(G4QHadron* dB);      // Decay of any di-baryon (deuteron is kept)
+  void             DecayThreeBaryon(G4QHadron* dB);   // Decay of ppp, nnn or LLL states
+  void             DecayAntiStrange(G4QHadron* dB);   // Decay of the nucleus, containing K+/K0
+  void             DecayAlphaBar(G4QHadron* dB);      // Decay of alpha+p or alpha+n states
+  void             DecayAlphaDiN(G4QHadron* dB);      // Decay of alpha+p+p states
+  void             DecayAlphaAlpha(G4QHadron* dB);    // Decay of alpha+alpha state
+  G4bool           CheckGroundState(G4Quasmon* quasm, G4bool corFlag = false);// as G4Q for TotHadrV
+  G4bool           DecayInEnvQ(G4Quasmon* quasm);     // Use befor evaporation in PANIC case
+
+// Body
+private:
+  // Static Parameters
+  static G4bool      EnergyFlux;      // Flag for Energy Flux use instead of Multy Quasmon
+  static G4double    SolidAngle;      // Part of Solid Angle to capture secondaries (@@A-dep)
+  static G4double    PiPrThresh;      // Pion Production Threshold for gammas
+  static G4double    M2ShiftVir;      // Shift for M2=-Q2=m_pi^2 of the virtual gamma
+  static G4double    DiNuclMass;      // Double Nucleon Mass for virtual normalization
+  // Output hadrons
+  G4QHadronVector    theQHadrons;     // Vector of generated secondary hadrons
+  // Internal working parameters
+  G4QCHIPSWorld      theWorld;        // the CHIPS World
+  G4int              nBarClust;       // Maximum barion number of clusters (Calc. @ Interaction)
+  G4double           f2all;           // Ratio of free nucleons to free+dense nucleons (do we need it in Quasmon?)
+  G4QuasmonVector    theQuasmons;     // Intermediate vector of Quasmons before fragmentation (***delete***)
+  G4QCandidateVector theQCandidates;  // Vector of possible candidates to clusters (***delete***)
+  G4QNucleus         theEnvironment;  // Initial Nucleus & later Residual Nuclear Environment
+  G4LorentzVector    tot4Mom;         // Total 4-momentum in the reaction
+};
+
+inline int G4QEnvironment::operator==(const G4QEnvironment &right) const {return this == &right;}
+inline int G4QEnvironment::operator!=(const G4QEnvironment &right) const {return this != &right;}
+inline G4QNucleus G4QEnvironment::GetEnvironment()                 const {return theEnvironment;}
+#endif
+
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QHadron.hh

@@ -0,0 +1,192 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QHadron.hh,v 1.15 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QHadron ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for Hadrons generated by the CHIPS Model
+// ------------------------------------------------------
+
+#ifndef G4QHadron_h
+#define G4QHadron_h 1
+
+#include "globals.hh"
+#include "G4ThreeVector.hh"
+#include "G4LorentzVector.hh"
+#include "Randomize.hh"
+#include "G4QParticle.hh"
+
+class G4QHadron
+{
+public:
+  // Constructors
+  G4QHadron();                                      // Default Constructor
+  G4QHadron(G4LorentzVector p);                     // Kinematical Constructor
+  G4QHadron(G4int PDGcode, G4LorentzVector p=G4LorentzVector(0.,0.,0.,0.));// CHIPS World Hadron
+  G4QHadron(G4QPDGCode QPDG, G4LorentzVector p=G4LorentzVector(0.,0.,0.,0.));// CHIPS World Had.
+  G4QHadron(G4QContent QC, G4LorentzVector p=G4LorentzVector(0.,0.,0.,0.));// QC defined Hadron
+  G4QHadron(G4int PDG, G4double m, G4QContent QC);  // Constructor for a Chipolino or a Quasmon
+  G4QHadron(G4QPDGCode QPDG, G4double m, G4QContent QC);  // Con. for a Chipolino or a Quasmon
+  G4QHadron(G4int PDG, G4LorentzVector p, G4QContent QC);// Constructor for Chipolino or Quasmon
+  G4QHadron(G4QPDGCode QPDG, G4LorentzVector p, G4QContent QC);// Con. for Chipolino or Quasmon
+  G4QHadron(G4QParticle* pPart, G4double maxM);     // Constructor for a resonance with RANDOM m
+  G4QHadron(const G4QHadron& right);                // Copy constructor by object
+  G4QHadron(G4QHadron* right);                      // Copy constructor by pointer
+  ~G4QHadron();                                     // Destructor
+  // Operators
+  const G4QHadron& operator=(const G4QHadron& right);
+  G4int           operator==(const G4QHadron& right) const;
+  G4int           operator!=(const G4QHadron& right) const;
+  // Selectors
+  G4int                 GetPDGCode()      const;    // Get PDG code of the Hadron
+  G4int                 GetQCode()        const;    // Get Q code of the Hadron
+  G4QPDGCode            GetQPDG()         const;    // Get QPDG of the Hadron
+  G4LorentzVector       Get4Momentum()    const;    // Get 4-mom of the Hadron
+  G4QContent            GetQC()           const;    // Get private quark content
+  G4double              GetMass()         const;    // Get a mass of the Hadron
+  G4double              GetMass2()        const;    // Get an m^2 value for the Hadron
+  G4double              GetWidth()        const;    // Get Width of Hadron 
+  G4int                 GetNFragments()   const;    // Get a#of Fragments of this Hadron
+  G4int                 GetCharge()       const;    // Get Charge of the Hadron
+  G4int                 GetStrangeness()  const;    // Get Strangeness of the Hadron
+  G4int                 GetBaryonNumber() const;    // Get Baryon Number of the Hadron
+  // Modifiers
+  void SetQPDG(const G4QPDGCode& QPDG);             // Set QPDG of the Hadron
+  void Set4Momentum(const G4LorentzVector& aMom);   // Set 4-mom of the Hadron
+  void SetQC(const G4QContent& newQC);              // Set new private quark content
+  void SetNFragments(const G4int& nf);              // Set a#of Fragments of this Hadron
+  void   NegPDGCode();
+  void MakeAntiHadron();                            // Make AntiHadron of this Hadron
+  // General
+  G4double RandomizeMass(G4QParticle* pPart, G4double maxM); // Randomize a mass value
+  G4bool TestRealNeutral();
+  G4bool DecayIn2(G4LorentzVector& f4Mom, G4LorentzVector& s4Mom);
+  G4bool CorMDecayIn2(G4double corM, G4LorentzVector& fr4Mom);//->This(new mass corM)+fr4Mom(correct)
+  G4bool CorEDecayIn2(G4double corE, G4LorentzVector& fr4Mom);//->This(E+=corE,P)+fr4Mom(fE-=corE,fP)
+  G4bool RelDecayIn2(G4LorentzVector& f4Mom, G4LorentzVector& s4Mom, G4LorentzVector& dir,
+                  G4double maxCost, G4double minCost = -1.);
+  G4bool DecayIn3(G4LorentzVector& f4Mom, G4LorentzVector& s4Mom, G4LorentzVector& t4Mom);
+
+private:
+  // Private methods
+  void DefineQC(G4int PDGCode);
+
+private:  
+  G4QPDGCode            theQPDG;                    // Instance of QPDG for the Hadron
+  G4LorentzVector       theMomentum;                // The 4-mom of Hadron
+  G4QContent            valQ;                       // QC ( @@ ?? for Quasmon and Chipolino)
+  G4int                 nFragm;                     // =0 - stable, =N - decayed in N particles
+};
+
+inline G4int G4QHadron::operator==(const G4QHadron &right) const {return this==&right;}
+inline G4int G4QHadron::operator!=(const G4QHadron &right) const {return this!=&right;}
+ 
+inline G4int           G4QHadron::GetPDGCode()      const   {return theQPDG.GetPDGCode();}
+inline G4int           G4QHadron::GetQCode()        const   {return theQPDG.GetQCode();}
+inline G4QPDGCode      G4QHadron::GetQPDG()         const   {return theQPDG;}
+inline G4QContent      G4QHadron::GetQC()           const   {return valQ;}
+inline G4LorentzVector G4QHadron::Get4Momentum()    const   {return theMomentum;}
+inline G4int           G4QHadron::GetNFragments()   const   {return nFragm;}
+//@@ This is an example how to make other inline selectors for the 4-Momentum of the Hadron
+inline G4double        G4QHadron::GetMass()         const   {return theMomentum.m();}
+inline G4double        G4QHadron::GetMass2()        const   {return theMomentum.m2();}
+//@@ This is an example how to make other inline selectors for the Hadron
+inline G4int           G4QHadron::GetCharge()       const   {return valQ.GetCharge();}
+inline G4int           G4QHadron::GetStrangeness()  const   {return valQ.GetStrangeness();}
+inline G4int           G4QHadron::GetBaryonNumber() const   {return valQ.GetBaryonNumber();}
+
+inline void            G4QHadron::MakeAntiHadron()          {if(TestRealNeutral()) NegPDGCode();}
+inline void            G4QHadron::SetQPDG(const G4QPDGCode& newQPDG)
+{
+  theQPDG  = newQPDG;
+  G4int PDG= newQPDG.GetPDGCode();
+  G4int Q  = newQPDG.GetQCode();
+  //G4cout<<"G4QHadron::SetQPDG is called with PDGCode="<<PDG<<", QCode="<<Q<<G4endl;
+  if     (Q>-1) valQ=theQPDG.GetQuarkContent();
+  else if(PDG>80000000)DefineQC(PDG);
+  else
+  {
+    G4cerr<<"***G4QHadron::SetQPDG: QPDG="<<newQPDG<<G4endl;
+    G4Exception("***G4QHadron::SetQPDG: Impossible QPDG");
+  }
+}
+inline void   G4QHadron::SetQC(const G4QContent& newQC)              {valQ=newQC;}
+inline void   G4QHadron::Set4Momentum(const G4LorentzVector& aMom)   {theMomentum=aMom;}
+inline void   G4QHadron::SetNFragments(const G4int& nf)              {nFragm=nf;}
+inline void   G4QHadron::NegPDGCode()                   {theQPDG.NegPDGCode(); valQ.Anti();}
+inline G4bool G4QHadron::TestRealNeutral()              { return theQPDG.TestRealNeutral();}
+inline void   G4QHadron::DefineQC(G4int PDGCode)
+{
+  //G4cout<<"G4QHadron::DefineQC is called with PDGCode="<<PDGCode<<G4endl;
+  G4int szn=PDGCode-90000000;
+  G4int ds=0;
+  G4int dz=0;
+  G4int dn=0;
+  if(szn<-100000)
+  {
+    G4int ns=(-szn)/1000000+1;
+    szn+=ns*1000000;
+    ds+=ns;
+  }
+  else if(szn<-100)
+  {
+    G4int nz=(-szn)/1000+1;
+    szn+=nz*1000;
+    dz+=nz;
+  }
+  else if(szn<0)
+  {
+    G4int nn=-szn;
+    szn=0;
+    dn+=nn;
+  }
+  G4int sz =szn/1000;
+  G4int n  =szn%1000;
+  if(n>700)
+  {
+    n-=1000;
+    dz--;
+  }
+  G4int z  =sz%1000-dz;
+  if(z>700)
+  {
+    z-=1000;
+    ds--;
+  }
+  G4int Sq =sz/1000-ds;
+  G4int zns=z+n+Sq;
+  G4int Dq=n+zns;
+  G4int Uq=z+zns;
+  if      (Dq<0&&Uq<0&&Sq<0)valQ=G4QContent(0 ,0 ,0 ,-Dq,-Uq,-Sq);
+  else if (Uq<0&&Sq<0)      valQ=G4QContent(Dq,0 ,0 ,0  ,-Uq,-Sq);
+  else if (Dq<0&&Sq<0)      valQ=G4QContent(0 ,Uq,0 ,-Dq,0  ,-Sq);
+  else if (Dq<0&&Uq<0)      valQ=G4QContent(0 ,0 ,Sq,-Dq,-Uq,0  );
+  else if (Uq<0)            valQ=G4QContent(Dq,0 ,Sq,0  ,-Uq,0  );
+  else if (Sq<0)            valQ=G4QContent(Dq,Uq,0 ,0  ,0  ,-Sq);
+  else if (Dq<0)            valQ=G4QContent(0 ,Uq,Sq,-Dq,0  ,0  );
+  else                      valQ=G4QContent(Dq,Uq,Sq,0  ,0  ,0  );
+}
+#endif
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QHadronVector.hh

@@ -0,0 +1,41 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QHadronVector.hh,v 1.10 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCandidateVector ----------------
+//             by Mikhail Kossov, Sept 1999.
+// Type defenition for a Vector of Hadrons - output of CHIPS model
+// ---------------------------------------------------------------
+
+#ifndef G4QHadronVector_h
+#define G4QHadronVector_h 1
+
+#include "G4QHadron.hh"
+#include "g4std/vector"
+
+typedef G4std::vector<G4QHadron *> G4QHadronVector;
+struct DeleteQHadron { void operator()(G4QHadron * aQ){delete aQ;}};
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QNucleus.hh

@@ -0,0 +1,212 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QNucleus.hh,v 1.12 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QNucleus ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for Quasmon initiated Candidates used by the CHIPS Model
+// ----------------------------------------------------------------------
+
+#ifndef G4QNucleus_h
+#define G4QNucleus_h 1
+
+#include "G4QCandidateVector.hh"
+
+class G4QNucleus : public G4QHadron
+{
+public:
+  G4QNucleus();                                            // Default Constructor
+  G4QNucleus(G4int nucPDG);                                // At Rest PDG-Constructor
+  G4QNucleus(G4LorentzVector p, G4int nucPDG);             // Full PDG-Constructor
+  G4QNucleus(G4QContent nucQC);                            // At Rest QuarkCont-Constructor
+  G4QNucleus(G4QContent nucQC, G4LorentzVector p);         // Full QuarkCont-Constructor
+  G4QNucleus(G4int z, G4int n, G4int s);                   // At Rest ZNS-Constructor
+  G4QNucleus(G4int z, G4int n, G4int s, G4LorentzVector p);// Full ZNS-Constructor
+  G4QNucleus(const G4QNucleus& right);                     // Copy Constructor by value
+  G4QNucleus(G4QNucleus* right);                           // Copy Constructor by pointer
+  ~G4QNucleus();                                           // Destructor
+  // Overloaded Operators
+  const G4QNucleus & operator=(const G4QNucleus &right);
+  G4int operator==(const G4QNucleus &right) const;
+  G4int operator!=(const G4QNucleus &right) const;
+  // Specific Selectors
+  G4int      GetPDG()      const;                          // Get a PDG Code of the nucleus
+  G4int      GetZ()        const;                          // Get a#of protons
+  G4int      GetN()        const;                          // Get a#of neutrons
+  G4int      GetS()        const;                          // Get a#of lambdas
+  G4int      GetA()        const;                          // Get A of the nucleus
+  G4int      GetDZ()       const;                          // Get a#of protons in dense region
+  G4int      GetDN()       const;                          // Get a#of neutrons in dense region
+  G4int      GetDS()       const;                          // Get a#of lambdas in dense region
+  G4int      GetDA()       const;                          // Get A of the dense part of nucleus
+  G4int      GetMaxClust() const;                          // Get Max BarNum of Clusters
+  G4double   GetProbability(G4int bn=0) const;             // probab. for the cluster with BarN
+  G4double   GetMZNS()     const;                          // Get GS mass of Nucleus(not H || Q)
+  G4double   GetGSMass()   const;                          // Get GS mass of Nucleus(not Hadron)
+  G4QContent GetQCZNS()    const;                          // Get ZNS quark content of Nucleus
+
+  // Specific Modifiers
+  G4bool     EvaporateBaryon(G4QHadron* h1,G4QHadron* h2); // Evaporate one Baryon from Nucleus
+  G4bool     SplitBaryon();                                // Is it possible to split a baryon/alpha
+  G4bool     Split2Baryons();                              // Is it possible to split two baryons?
+  void       InitByPDG(G4int newPDG);                      // Init existing nucleus by new PDG
+  void       InitByQC(G4QContent newQC);                   // Init existing nucleus by new QCont
+  void       IncProbability(G4int bn);                     // Add one cluster to probability
+  void       Increase(G4int PDG, G4LorentzVector LV = G4LorentzVector(0.,0.,0.,0.));
+  void       Increase(G4QContent QC, G4LorentzVector LV = G4LorentzVector(0.,0.,0.,0.));
+  void       Reduce(G4int PDG);                            // Reduce Nucleus by PDG fragment
+  void       CalculateMass();                              // Recalculate (calculate) the mass
+  void       SetMaxClust(G4int maxC);                      // Set Max BarNum of Clusters
+  void       PrepareCandidates(G4QCandidateVector& theQCandidates, G4bool piF, G4bool gaF);
+  G4int      UpdateClusters(G4bool din);                   // Return a#of clusters & calc. probab's
+  G4QNucleus operator+=(const G4QNucleus& rhs);            // Add a cluster to the  nucleus
+  G4QNucleus operator-=(const G4QNucleus& rhs);            // Subtract a cluster from a nucleus
+  G4QNucleus operator*=(const G4int& rhs);                 // Multiplication of the Nucleus
+  // Static functions
+  static void SetParameters(G4double fN, G4double fD, G4double cP, G4double mR=1.);
+  // Specific General Functions
+  G4int RandomizeBinom(G4double p,G4int N);                // Randomize according to Binomial Law
+  G4double CoulombBarrier(const G4double& cZ, const G4double& cA, G4double dZ=0., G4double dA=0.);
+  G4double BindingEnergy(const G4double& cZ, const G4double& cA, G4double dZ=0., G4double dA=0.);
+  G4double CoulBarPenProb(const G4double& CB, const G4double& E, const G4int& C, const G4int& B);
+
+private:  
+  // Specific Encapsulated Functions
+  void       SetZNSQC(G4int z, G4int n, G4int s);          // Set QC, using Z,N,S
+  G4QNucleus GetThis() const;                              // @@ Check for memory leak
+
+// Body
+private:
+  // Static Parameters
+  static G4double freeNuc;      // probability of the quasi-free baryon on surface
+  static G4double freeDib;      // probability of the quasi-free dibaryon on surface
+  static G4double clustProb;    // clusterization probability in dense region
+  static G4double mediRatio;    // relative vacuum hadronization probability
+  // The basic  
+  G4int Z;                      // Z of the Nucleus
+  G4int N;                      // N of the Nucleus
+  G4int S;                      // S of the Nucleus
+  // The secondaries
+  G4int dZ;                     // Z of the dense region of the nucleus
+  G4int dN;                     // N of the dense region of the nucleus
+  G4int dS;                     // S of the dense region of the nucleus
+  G4int maxClust;               // Baryon Number of the last calculated cluster
+  G4double probVect[256];       // Cluster probability ("a#of issues" can be real) Vector
+};
+
+G4std::ostream& operator<<(G4std::ostream& lhs, G4QNucleus& rhs);
+G4std::ostream& operator<<(G4std::ostream& lhs, const G4QNucleus& rhs);
+
+inline G4int G4QNucleus::operator==(const G4QNucleus &right) const  {return this==&right;}
+inline G4int G4QNucleus::operator!=(const G4QNucleus &right) const  {return this!=&right;}
+
+inline G4int    G4QNucleus::GetPDG()const {return 90000000+1000*(1000*S+Z)+N;}
+inline G4int    G4QNucleus::GetZ()  const {return Z;}
+inline G4int    G4QNucleus::GetN()  const {return N;}
+inline G4int    G4QNucleus::GetS()  const {return S;}
+inline G4int    G4QNucleus::GetA()  const {return Z+N+S;}
+inline G4int    G4QNucleus::GetDZ() const {return dZ;}
+inline G4int    G4QNucleus::GetDN() const {return dN;}
+inline G4int    G4QNucleus::GetDS() const {return dS;}
+inline G4int    G4QNucleus::GetDA() const {return dZ+dN+dS;}
+inline G4int    G4QNucleus::GetMaxClust() const {return maxClust;}
+inline G4double G4QNucleus::GetProbability(G4int bn) const {return probVect[bn];}
+
+// Init existing nucleus by new Quark Content
+inline void G4QNucleus::InitByQC(G4QContent newQC)
+{//  =============================================
+  G4int PDG=G4QPDGCode(newQC).GetPDGCode();
+  InitByPDG(PDG);
+}
+
+inline G4double   G4QNucleus::GetMZNS()   const {return GetQPDG().GetNuclMass(Z,N,S);}
+inline G4double   G4QNucleus::GetGSMass() const {return GetQPDG().GetMass();}
+inline G4QContent G4QNucleus::GetQCZNS()  const
+{
+  if(S>=0) return G4QContent(Z+N+N+S,Z+Z+N+S,S,0,0,0);
+  else     return G4QContent(Z+N+N+S,Z+Z+N+S,0,0,0,-S);
+}
+inline void       G4QNucleus::SetMaxClust(G4int maxC) {maxClust=maxC;}
+inline void       G4QNucleus::CalculateMass()
+                    {Set4Momentum(G4LorentzVector(0.,0.,0.,GetGSMass()));}
+// Add Cluster
+inline G4QNucleus G4QNucleus::operator+=(const G4QNucleus& rhs)
+//     =======================================================
+{
+  Z+=rhs.Z;
+  N+=rhs.N;
+  S+=rhs.S;
+  // Atributes of aHadron
+  G4int           newPDG= GetPDGCode()   + rhs.GetPDGCode() - 90000000;
+  SetQPDG        (newPDG);
+  G4QContent      newQC = GetQC()        + rhs.GetQC();
+  SetQC          (newQC);
+  G4LorentzVector newLV = Get4Momentum() + rhs.Get4Momentum();
+  Set4Momentum   (newLV);
+  return *this;
+} 
+
+// Subtract Cluster
+inline G4QNucleus G4QNucleus::operator-=(const G4QNucleus& rhs)
+//     =======================================================
+{
+  Z-=rhs.Z;
+  N-=rhs.N;
+  S-=rhs.S;
+  // Atributes of aHadron
+  G4int           newPDG= GetPDGCode()   - rhs.GetPDGCode() + 90000000;
+  SetQPDG        (newPDG);
+  G4QContent      newQC = GetQC()        - rhs.GetQC();
+  SetQC          (newQC);
+  G4LorentzVector newLV = Get4Momentum() - rhs.Get4Momentum();
+  Set4Momentum   (newLV);
+  return *this;
+} 
+
+// Multiply Nucleus by integer value
+inline G4QNucleus G4QNucleus::operator*=(const G4int& rhs)
+//     ===================================================
+{
+  Z*=rhs;
+  N*=rhs;
+  S*=rhs;
+  // Atributes of aHadron
+  G4int           newPDG= rhs*(GetPDGCode() - 90000000) + 90000000;
+  SetQPDG        (newPDG);
+  G4QContent      newQC = rhs*GetQC();
+  SetQC          (newQC);
+  G4LorentzVector newLV = rhs*Get4Momentum();
+  Set4Momentum   (newLV);
+  return *this;
+} 
+
+// Private member functions
+inline G4QNucleus G4QNucleus::GetThis()const{return G4QNucleus(Z,N,S);}
+
+#endif
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QPDGCode.hh

@@ -0,0 +1,256 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QPDGCode.hh,v 1.11 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QPDGCode ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for Hadron definition in CHIPS Model
+// ------------------------------------------------------------
+
+#ifndef G4QPDGCode_h
+#define G4QPDGCode_h 1
+
+#include "g4std/iostream"
+#include "globals.hh"
+#include "G4ParticleTable.hh"
+#include "G4NucleiProperties.hh"
+#include "G4NucleiPropertiesTable.hh"
+#include "G4QContent.hh"
+
+class G4QPDGCode
+{
+public:
+  // Constructors
+  G4QPDGCode(G4int PDGCode = 0);                     // Construction by PDGCode
+  G4QPDGCode(G4QContent QCont);                      // Construction by Quark Content
+  G4QPDGCode(const G4QPDGCode& rhs);                 // Copy Constructor by value
+  G4QPDGCode(G4QPDGCode* rhs);                       // Copy Constructor by pointer
+
+  ~G4QPDGCode();                                     // Destructor
+
+  // Operators
+  const G4QPDGCode& operator=(const G4QPDGCode& rhs);
+  G4int             operator==(const G4QPDGCode& rhs) const;
+  G4int             operator==(const G4int& rhs) const;
+  G4int             operator!=(const G4QPDGCode& rhs) const;
+  G4int             operator!=(const G4int& rhs) const;
+  G4QPDGCode        operator+=(const G4int& rhs);
+  G4QPDGCode        operator+=(const G4QPDGCode& rhs);
+  G4QPDGCode        operator-=(const G4int& rhs);
+  G4QPDGCode        operator-=(const G4QPDGCode& rhs);
+  G4QPDGCode        operator*=(const G4int& rhs);
+  G4QPDGCode        operator/=(const G4int& rhs);
+
+  // Selectors
+  G4double   GetMass();                                // GS Mass for the QHadron
+  G4double   GetMass2();                               // Squared GS Mass for the QHadron
+  G4double   GetWidth();                               // Width for the QHadron
+  G4double   GetNuclMass(G4int Z, G4int N, G4int S);   // Wrapper for nuclear mass calculation
+  G4double   GetNuclMass(G4int PDGCode);               // Wrapper for nuclear mass calculation
+  G4QContent GetQuarkContent()                  const; // Get QC for the particle
+  G4int      GetBaryNum()                       const; // Get Baryon Number of the Hadron
+  G4int      GetSpin()                          const; // Returns 2s+1 for hadrons or 1 for nuclei
+  G4int      GetCharge()                        const; // Get Charge of the Hadron
+  G4int      GetPDGCode()                       const; // Get PDG code of the Hadron
+  G4int      GetQCode()                         const; // Get Q code of the Hadron
+  G4QContent GetExQContent(G4int i, G4int o)    const; // Get Q Content for the Quark Exchange  
+  G4int      GetRelCrossIndex(G4int i, G4int o) const; // Relative Cross Index for q_i->q_o
+  G4int      GetNumOfComb(G4int i, G4int o)     const; // Get number of Combinations for q_i->q_o
+  G4int      GetTotNumOfComb(G4int i)           const; // Get a total # of Combinations for q_i 
+
+  // Modifiers
+  void  SetPDGCode(G4int newPDGCode);               // Set PDG code of the Hadron
+  void  InitByQCont(G4QContent QCont);              // Init existing QPDG by Quark Content
+  void  InitByQCode(G4int QCode);                   // Init existing QPDG by Q Code
+
+  // General
+  G4bool     TestRealNeutral();
+  void       NegPDGCode();
+
+private:
+  // Encapsulated functions
+  G4bool   TestRealNeutral(const G4int& PDGCode);
+  G4int    MakeQCode(const G4int& PDGCode);         // Make Q Code, using PDG Code
+  G4int    MakePDGCode(const G4int& QCode);         // Make PDG Code, using Q Code
+
+private:
+  // the Body
+  G4int              thePDGCode;
+  G4int              theQCode;
+};
+
+// Not member operators
+G4std::ostream&   operator<<(G4std::ostream& lhs, G4QPDGCode& rhs);
+G4std::ostream&   operator<<(G4std::ostream& lhs, const G4QPDGCode& rhs);
+G4int      operator+(const G4QPDGCode& lhs, const G4QPDGCode& rhs);
+G4int      operator+(const G4QPDGCode& lhs, const G4int&      rhs);
+G4int      operator+(const G4int&      lhs, const G4QPDGCode& rhs);
+G4int      operator-(const G4QPDGCode& lhs, const G4QPDGCode& rhs);
+G4int      operator-(const G4QPDGCode& lhs, const G4int&      rhs);
+G4int      operator-(const G4int&      lhs, const G4QPDGCode& rhs);
+G4int      operator*(const G4QPDGCode& lhs, const G4QPDGCode& rhs);
+G4int      operator*(const G4QPDGCode& lhs, const G4int&      rhs);
+G4int      operator*(const G4int&      lhs, const G4QPDGCode& rhs);
+G4int      operator/(const G4QPDGCode& lhs, const G4QPDGCode& rhs);
+G4int      operator/(const G4QPDGCode& lhs, const G4int&      rhs);
+G4int      operator/(const G4int&      lhs, const G4QPDGCode& rhs);
+G4int      operator%(const G4QPDGCode& lhs, const G4int&      rhs);
+// Not member functions
+//----------------------------------------------------------------------------------------
+
+inline G4int G4QPDGCode::operator==(const G4QPDGCode& rhs) const {return this==&rhs;}
+inline G4int G4QPDGCode::operator==(const G4int&      rhs) const {return thePDGCode==rhs;}
+inline G4int G4QPDGCode::operator!=(const G4QPDGCode& rhs) const {return this!=&rhs;}
+inline G4int G4QPDGCode::operator!=(const G4int&      rhs) const {return thePDGCode!=rhs;}
+
+inline G4QPDGCode G4QPDGCode::operator+=(const G4QPDGCode& rhs)
+{
+  thePDGCode+=rhs.GetPDGCode();
+  if(!thePDGCode) theQCode = -2;
+  else theQCode = MakeQCode(thePDGCode);
+  return *this;
+}
+inline G4QPDGCode G4QPDGCode::operator+=(const G4int& rhs)
+{
+  thePDGCode+=rhs;
+  if(!thePDGCode) theQCode = -2;
+  else theQCode = MakeQCode(thePDGCode);
+  return *this;
+}
+inline G4QPDGCode G4QPDGCode::operator-=(const G4QPDGCode& rhs)
+{
+  thePDGCode-=rhs.GetPDGCode();
+  if(!thePDGCode) theQCode = -2;
+  else theQCode = MakeQCode(thePDGCode);
+  return *this;
+}
+inline G4QPDGCode G4QPDGCode::operator-=(const G4int& rhs)
+{
+  thePDGCode-=rhs;
+  if(!thePDGCode) theQCode = -2;
+  else theQCode = MakeQCode(thePDGCode);
+  return *this;
+}
+inline G4QPDGCode G4QPDGCode::operator*=(const G4int& rhs)
+{
+  thePDGCode*=rhs;
+  if(!thePDGCode) theQCode = -2;
+  else theQCode = MakeQCode(thePDGCode);
+  return *this;
+}
+inline G4QPDGCode G4QPDGCode::operator/=(const G4int& rhs)
+{
+  thePDGCode/=rhs;
+  if(!thePDGCode) theQCode = -2;
+  else theQCode = MakeQCode(thePDGCode);
+  return *this;
+}
+ 
+inline G4double G4QPDGCode::GetMass2() {G4double m=GetMass(); return m*m;}
+inline G4double G4QPDGCode::GetNuclMass(G4int PDG)
+{
+  if(PDG>80000000)
+  {
+    G4int szn=PDG-90000000;
+    G4int ds=0;
+    G4int dz=0;
+    G4int dn=0;
+    if(szn<-100000)
+    {
+      G4int ns=(-szn)/1000000+1;
+      szn+=ns*1000000;
+      ds+=ns;
+    }
+    else if(szn<-100)
+    {
+      G4int nz=(-szn)/1000+1;
+      szn+=nz*1000;
+      dz+=nz;
+    }
+    else if(szn<0)
+    {
+      G4int nn=-szn;
+      szn=0;
+      dn+=nn;
+    }
+    G4int sz =szn/1000;
+    G4int n  =szn%1000;
+    if(n>700)
+    {
+      n-=1000;
+      dz--;
+    }
+    G4int z  =sz%1000-dz;
+    if(z>700)
+    {
+      z-=1000;
+      ds--;
+    }
+    G4int s  =sz/1000-ds;
+    return GetNuclMass(z,n,s);
+  }
+  return 0.;
+}
+inline G4int    G4QPDGCode::GetPDGCode() const {return thePDGCode;}
+inline G4int    G4QPDGCode::GetQCode()   const {return theQCode;}
+inline G4int    G4QPDGCode::GetCharge()  const {return GetQuarkContent().GetCharge();}
+inline G4int    G4QPDGCode::GetBaryNum() const {return GetQuarkContent().GetBaryonNumber();}
+inline G4int    G4QPDGCode::GetSpin()    const 
+{
+  if(thePDGCode<80000000)               return thePDGCode%10;
+  else if(GetQuarkContent().GetTot()%2) return 3;
+  else                                  return 1;
+}
+inline void     G4QPDGCode::NegPDGCode()     {thePDGCode=-thePDGCode;}
+inline G4bool   G4QPDGCode::TestRealNeutral(){return TestRealNeutral(thePDGCode);}
+
+// Redefinition of the PDG instance
+inline void  G4QPDGCode::SetPDGCode(G4int newPDGCode)
+//           ========================================
+{
+  thePDGCode=newPDGCode;
+  if(!thePDGCode) theQCode = -2;
+  else theQCode = MakeQCode(newPDGCode);
+}
+
+// Init existing QPDG by Quark Content
+inline void  G4QPDGCode::InitByQCont(G4QContent QCont)
+{//          =========================================
+  thePDGCode = QCont.GetSPDGCode();
+  if(!thePDGCode) theQCode = -2;
+  else theQCode   = MakeQCode(thePDGCode);
+}
+
+// Init existing QPDG by Quark Content
+inline void  G4QPDGCode::InitByQCode(G4int QCode)
+{//          ====================================
+  theQCode   = QCode;
+  thePDGCode = MakePDGCode(QCode);
+}
+
+#endif
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QPDGCodeVector.hh

@@ -0,0 +1,44 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QPDGCodeVector.hh,v 1.8 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCandidateVector ----------------
+//             by Mikhail Kossov, Sept 1999.
+// Type defenition for Hadron definition in CHIPS model
+// ---------------------------------------------------------------
+
+#ifndef G4QPDGCodeVector_h
+#define G4QPDGCodeVector_h 1
+
+#include "G4QPDGCode.hh"
+#include "g4std/vector"
+
+typedef G4std::vector<G4QPDGCode *> G4QPDGCodeVector;
+struct DeleteQPDGCode{ void operator()(G4QPDGCode *aN){delete aN;} };
+
+
+#endif
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QParentCluster.hh

@@ -0,0 +1,131 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QParentCluster.hh,v 1.10 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QParentCluster ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for a Parent nuclear cluster in the CHIPS Model
+// -------------------------------------------------------------
+
+#ifndef G4QParentCluster_h
+#define G4QParentCluster_h 1
+
+#include "g4std/iostream"
+#include "globals.hh"
+#include "G4QContent.hh"
+
+class G4QParentCluster
+{
+public:
+  // Constructors
+  G4QParentCluster(G4int PDGCode = 0);               // Construction by PDGCode
+  G4QParentCluster(G4int PDGCode, G4double prob);    // Construction by PDGCode & Probab
+  G4QParentCluster(const G4QParentCluster& rhs);     // Copy Constructor by value
+  G4QParentCluster(G4QParentCluster* rhs);           // Copy Constructor by pointer
+
+  ~G4QParentCluster();                               // Destructor
+
+  // Operators
+  const G4QParentCluster& operator=(const G4QParentCluster& rhs);
+  G4int                   operator==(const G4QParentCluster& rhs) const;
+  G4int                   operator!=(const G4QParentCluster& rhs) const;
+
+  // Selectors
+  G4int      GetPDGCode()      const;   // Get PDG code of the Parent Cluster
+  G4double   GetProbability()  const;   // Get a probability of hadronization on it
+  G4int      GetNQPart2()      const;   // Get n-2 for the fragment
+  G4QContent GetTransQC()      const;   // Get QuarkCont of a Pseudo Exchange Meson
+  G4double   GetLow()          const;   // Get a low limit for randomization
+  G4double   GetHigh()         const;   // Get a high limit for randomization
+  G4double   GetEBMass()       const;   // Get a Nuclear Bounded mass of the parent cluster
+  G4double   GetEBind()        const;   // Get Environment Binding energy for the parent cluster
+  G4double   GetNBMass()       const;   // Get an Environmental bounded mass of the parent cluster
+  G4double   GetNBind()        const;   // Get Total Nucleus Binding energy for the parent cluster
+
+  // Modifiers
+  void  SetPDGCode(G4int newPDGCode);                // Set PDG code of the Parent Cluster
+  void  SetProbability(G4double probab);             // Set probab. to hadronize on this cluster
+  void  SetNQPart2(G4int nm2);                       // Get n-2 for the fragment
+  void  SetTransQC(G4QContent newTrans);             // Set QuarkCont of a Pseudo Exchange Meson
+  void  SetLow(G4double loLim);                      // Set a low limit for hadronization
+  void  SetHigh(G4double hiLim);                     // Set a high limit for hadronization
+  void  SetEBMass(G4double bMass);                   // Set a bounded mass of the parent cluster in E
+  void  SetEBind(G4double bEn);                      // Set binding energy of the parent cluster in E
+  void  SetNBMass(G4double bMass);                   // Set a bounded mass of the parent cluster in N
+  void  SetNBind(G4double bEn);                      // Set binding energy of the parent cluster in N
+
+  // General
+
+private:
+  // Encapsulated functions
+
+private:
+  // the Body
+  G4int               thePDGCode;
+  G4double            theProbability;
+  // Secondary
+  G4int               nQPart2;
+  G4QContent          transQC;                         // Quark Content of pseudo exchange meson
+  G4double            lowLimit;
+  G4double            highLimit;
+  G4double            theEnvBoundedMass;
+  G4double            theEnvBindingEnergy;
+  G4double            theNucBoundedMass;
+  G4double            theNucBindingEnergy;
+};
+
+// Not member operators
+G4std::ostream&   operator<<(G4std::ostream& lhs, G4QParentCluster& rhs);
+G4std::ostream&   operator<<(G4std::ostream& lhs, const G4QParentCluster& rhs);
+
+inline G4int G4QParentCluster::operator==(const G4QParentCluster& rhs) const {return this==&rhs;}
+inline G4int G4QParentCluster::operator!=(const G4QParentCluster& rhs) const {return this!=&rhs;}
+ 
+inline G4int      G4QParentCluster::GetPDGCode()     const {return thePDGCode;}
+inline G4double   G4QParentCluster::GetProbability() const {return theProbability;}
+inline G4int      G4QParentCluster::GetNQPart2()     const {return nQPart2;}
+inline G4QContent G4QParentCluster::GetTransQC()     const {return transQC;}
+inline G4double   G4QParentCluster::GetHigh()        const {return highLimit;}
+inline G4double   G4QParentCluster::GetLow()         const {return lowLimit;}
+inline G4double   G4QParentCluster::GetEBMass()      const {return theEnvBoundedMass;}
+inline G4double   G4QParentCluster::GetEBind()       const {return theEnvBindingEnergy;}
+inline G4double   G4QParentCluster::GetNBMass()      const {return theNucBoundedMass;}
+inline G4double   G4QParentCluster::GetNBind()       const {return theNucBindingEnergy;}
+
+inline void  G4QParentCluster::SetPDGCode(G4int newPDGCode)    {thePDGCode      = newPDGCode;}
+inline void  G4QParentCluster::SetProbability(G4double prob)   {theProbability  = prob;}
+inline void  G4QParentCluster::SetNQPart2(G4int nm2)           {nQPart2         = nm2;}
+inline void  G4QParentCluster::SetTransQC(G4QContent newTrans) {transQC=newTrans;}
+inline void  G4QParentCluster::SetHigh(G4double hiLim)         {highLimit       = hiLim;}
+inline void  G4QParentCluster::SetLow(G4double loLim)          {lowLimit        = loLim;}
+inline void  G4QParentCluster::SetEBMass(G4double bMass)       {theEnvBoundedMass  = bMass;}
+inline void  G4QParentCluster::SetNBMass(G4double bMass)       {theNucBoundedMass  = bMass;}
+inline void  G4QParentCluster::SetEBind(G4double bEn)          {theEnvBindingEnergy= bEn;}
+inline void  G4QParentCluster::SetNBind(G4double bEn)          {theNucBindingEnergy= bEn;}
+
+#endif
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QParentClusterVector.hh

@@ -0,0 +1,43 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QParentClusterVector.hh,v 1.8 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCandidateVector ----------------
+//             by Mikhail Kossov, Sept 1999.
+// Type defenition of Parent nuclear cluster Vector in CHIPS model
+// ---------------------------------------------------------------
+
+#ifndef G4QParentClusterVector_h
+#define G4QParentClusterVector_h 1
+
+#include "G4QParentCluster.hh"
+#include "g4std/vector"
+
+typedef G4std::vector<G4QParentCluster *> G4QParentClusterVector;
+struct DeleteQParentCluster{ void operator()(G4QParentCluster *aN){delete aN;} };
+
+#endif
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QParticle.hh

@@ -0,0 +1,129 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QParticle.hh,v 1.10 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QParticle ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for Particles in the CHIPS Model
+// ---------------------------------------------------
+
+#ifndef G4QParticle_h
+#define G4QParticle_h 1
+
+#include "g4std/iostream"
+#include "globals.hh"
+#include "G4QDecayChanVector.hh"
+
+class G4QParticle
+{
+public:
+  // Constructors
+  G4QParticle();                                // Default Constructor
+  G4QParticle(G4int thePDG);                    // PDGCode Constructor
+  G4QParticle(const G4QParticle& right);        // Copy Constructor by value
+  G4QParticle(G4QParticle* right);              // Copy Constructor by pointer
+
+  ~G4QParticle();                               // Destructor
+
+  // Operators
+  const G4QParticle& operator=(const G4QParticle& right);
+  G4int              operator==(const G4QParticle& rhs) const;
+  G4int              operator!=(const G4QParticle& rhs) const;
+
+  // Selectors
+  G4QPDGCode          GetQPDG() const;          // Get a PDG-Particle of the Particle
+  G4int               GetPDGCode() const;       // Get a PDG Code of the Particle
+  G4int               GetQCode() const;         // Get a Q Code of the Particle
+  G4int               GetSpin() const;          // Get 2s+1 of the Particle
+  G4int               GetCharge() const;        // Get a Charge of the Particle
+  G4int               GetStrange() const;       // Get a Strangeness of the Particle
+  G4int               GetBaryNum() const;       // Get a Baryon Number of the Particle
+  G4QContent          GetQContent();            // Get Quark Content of the Particle
+  G4QDecayChanVector  GetDecayVector();         // Get a Decay Vector for the Particle
+  G4double            GetMass();                // Get a mass value for the Particle
+  G4double            GetWidth();               // Get a width value for the Particle
+
+  // Modifiers
+  G4QDecayChanVector InitDecayVector(G4int Q);  // Init Decay Vector in the CHIPS World by Q code
+  void InitPDGParticle(G4int thePDGCode);
+  void InitQParticle(G4int theQCode);
+
+  // General
+  G4double MinMassOfFragm();                    // Minimal mass of decaing fragments
+
+private:
+  // Encapsulated functions
+
+private:
+  // the Body
+  G4QPDGCode          aQPDG;
+  G4QDecayChanVector  aDecay;
+  G4QContent          aQuarkCont;               // @@ Secondary (added for acceleration - check)
+};
+
+// Not member operators
+G4std::ostream&   operator<<(G4std::ostream& lhs, G4QParticle& rhs);
+// Not member functions
+//----------------------------------------------------------------------------------------
+
+inline G4int G4QParticle::operator==(const G4QParticle& rhs) const {return this==&rhs;}
+inline G4int G4QParticle::operator!=(const G4QParticle& rhs) const {return this!=&rhs;}
+ 
+inline G4QPDGCode         G4QParticle::GetQPDG()    const {return aQPDG;}
+inline G4int              G4QParticle::GetPDGCode() const {return aQPDG.GetPDGCode();}
+inline G4int              G4QParticle::GetSpin()    const {return aQPDG.GetSpin();}
+inline G4int              G4QParticle::GetCharge()  const {return aQuarkCont.GetCharge();}
+inline G4int              G4QParticle::GetStrange() const {return aQuarkCont.GetStrangeness();}
+inline G4int              G4QParticle::GetBaryNum() const {return aQuarkCont.GetBaryonNumber();}
+inline G4QContent         G4QParticle::GetQContent()      {return aQuarkCont;}
+inline G4QDecayChanVector G4QParticle::GetDecayVector()   {return aDecay;}
+inline G4double           G4QParticle::GetMass()          {return aQPDG.GetMass();}
+inline G4double           G4QParticle::GetWidth()         {return aQPDG.GetWidth();}
+
+inline G4double G4QParticle::MinMassOfFragm()
+{
+  G4int nCh=aDecay.size();
+  G4double m=GetMass();
+  G4double min=m;
+  if(nCh)
+  {
+    min=aDecay[0]->GetMinMass();
+    if(nCh>1) for(G4int j=1; j<nCh; j++)
+	{
+      G4double next=aDecay[j]->GetMinMass();
+      if(next<min) min=next;
+	}
+  }
+  G4double w=GetWidth();
+  G4double lim=m+.001;
+  if(w)   lim-=1.5*w;
+  if(min<lim) min=lim;
+  return min;
+}
+
+#endif
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QParticleVector.hh

@@ -0,0 +1,43 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QParticleVector.hh,v 1.8 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCandidateVector ----------------
+//             by Mikhail Kossov, Sept 1999.
+// Type defenition for Decay Channel Vector in CHIPS model
+// ---------------------------------------------------------------
+
+#ifndef G4QParticleVector_h
+#define G4QParticleVector_h 1
+
+#include "G4QParticle.hh"
+#include "g4std/vector"
+
+typedef G4std::vector<G4QParticle *> G4QParticleVector;
+struct DeleteQParticle{ void operator()(G4QParticle *aN){delete aN;} };
+
+#endif
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QSelector.hh

@@ -0,0 +1,66 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QSelector.hh,v 1.7 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QSelector ----------------
+//             by Mikhail Kossov, Sept 1999.
+//  class header for decay Selection for Hadrons of CHIPS Model
+// ------------------------------------------------------------
+
+#ifndef G4QSelector_h
+#define G4QSelector_h 1
+
+//#include "globals.hh"
+#include "G4QHadronVector.hh"
+#include "G4QPDGCodeVector.hh"
+
+class G4QSelector
+{
+public:
+  // Constructors
+  G4QSelector();                                      // Default Constructor
+  G4QSelector(G4QHadronVector hadronVec);             // Constructor for the Hadrons Set
+  ~G4QSelector();                                     // Destructor
+  // Operators
+  const G4QSelector& operator=(const G4QSelector& right);
+  G4int operator==(const G4QSelector& right) const;
+  G4int operator!=(const G4QSelector& right) const;
+  // Selectors
+  G4QHadronVector GetHadrons()    const;              // Get PDG code of the Hadron
+  // Modifiers
+  void   SetHadrons(G4QHadronVector hadronVec);       // Get PDG code of the Hadron
+  G4bool SelectPDGSet(G4QPDGCodeVector thePDGCodes);  // Select event with the PDGCode Set
+private:  
+  G4QHadronVector theHadrons;                         // Vector of Hadron
+};
+
+inline G4int G4QSelector::operator==(const G4QSelector& right) const {return this==&right;}
+inline G4int G4QSelector::operator!=(const G4QSelector& right) const {return this!=&right;}
+ 
+inline G4QHadronVector G4QSelector::GetHadrons()             const   {return theHadrons;}
+
+inline void G4QSelector::SetHadrons(G4QHadronVector hadronVec)       {theHadrons=hadronVec;}
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4Quasmon.hh

@@ -0,0 +1,179 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4Quasmon.hh,v 1.19 2001/11/26 14:11:45 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4Quasmon ----------------
+//             by Mikhail Kossov, July 1999.
+//      class for a Quasmon used by the CHIPS Model
+// ------------------------------------------------------------
+
+#ifndef G4Quasmon_h
+#define G4Quasmon_h 1
+
+// Standard G4-headers
+#include "G4ios.hh"
+#include "globals.hh"
+#include "G4ThreeVector.hh"
+#include "G4LorentzVector.hh"
+#include "G4LorentzRotation.hh"
+//CHIPS-headers
+#include "G4QCHIPSWorld.hh"
+#include "G4QChipolino.hh"
+#include "G4QHadronVector.hh"
+#include "G4QNucleus.hh"
+
+class G4Quasmon 
+{
+public:
+  G4Quasmon(G4QContent qQCont    = G4QContent(0,0,0,0,0,0),
+            G4LorentzVector q4M  = G4LorentzVector(0.,0.,0.,0.),
+            G4LorentzVector ph4M = G4LorentzVector(0.,0.,0.,0.));// Direct Constructor
+  G4Quasmon(const G4Quasmon& right);                             // Copy Quasmon by object
+  G4Quasmon(G4Quasmon* right);                                   // Copy Quasmon by pointer
+
+  ~G4Quasmon();
+
+  // Overloaded Operators
+  const G4Quasmon& operator=(const G4Quasmon& right);
+  int operator==(const G4Quasmon &right) const;
+  int operator!=(const G4Quasmon &right) const;
+
+  // Static functions
+  static void SetParameters(G4double temperature, G4double ssin2g, G4double etaetap);
+  static void SetTemper(G4double temperature);
+  static void SetSOverU(G4double ssin2g);
+  static void SetEtaSup(G4double etaetap);
+
+  //Selectors
+  G4double          GetTemper()    const;
+  G4double          GetSOverU()    const;
+  G4double          GetEtaSup()    const;
+  G4LorentzVector   Get4Momentum() const;
+  G4QContent        GetQC()        const;
+  G4QPDGCode        GetQPDG()      const;
+  G4int             GetStatus()    const;
+
+  //Modifiers
+  G4QHadronVector*  Fragment(G4QNucleus& nucEnviron, G4int nQ); // Pub-wrapper for "HadronizeQuasmon(,)"
+  void              ClearOutput();                    // Clear but not destroy the output
+  void              InitQuasmon(const G4QContent& qQCont, const G4LorentzVector& q4M);
+  void              IncreaseBy(const G4Quasmon* pQuasm); // as operator+= but by pointer
+  void              KillQuasmon();                    // Kill Quasmon (status=0)
+
+private:  
+  G4QHadronVector  HadronizeQuasmon(G4QNucleus& qEnv, G4int nQ); // Return new neuclear environment
+  G4double         GetRandomMass(G4int PDGCode, G4double maxM);
+  void             ModifyInMatterCandidates();
+  void             InitCandidateVector(G4int maxMes, G4int maxBar, G4int maxClust);
+  void             CalculateNumberOfQPartons(G4double qMass);
+  void             CalculateHadronizationProbabilities(G4double excE, G4double kQ, G4double kLS,
+                                                       G4bool piF, G4bool gaF);
+  void             FillHadronVector(G4QHadron* qHadron);
+  G4int            RandomPoisson(G4double meanValue);
+  G4double         GetQPartonMomentum(G4double mMinResidual2, G4double mCandidate2);
+  G4bool           DecayOutHadron(G4QHadron* qHadron, G4int DFlag=0);
+  G4bool           CheckGroundState(G4bool corFlag = false); // Forbid correction by default
+  void             KillEnvironment(); // Kill Environment (Z,N,S=0,LV=0)
+
+// Body
+private:
+  // Static Parameters
+  static G4double    Temperature;     // Quasmon Temperature
+  static G4double    SSin2Gluons;     // Percent of ssbar sea in a constituen gluon
+  static G4double    EtaEtaprime;     // Part of eta-prime in all etas
+  // Hadronic input
+  G4LorentzVector    q4Mom;           // 4-momentum of the Quasmon +++++
+  G4QContent         valQ;            // Quark Content of the Quasmon  +++++
+  G4QNucleus         theEnvironment;  // Nuclear (or Vacuum) Environment around the Quasmon
+  // Output
+  G4int status; // -1-Panic,0-Done,1-FilledSomething,2-DidNothing,3-StopedByCB,4-JustBorn
+  G4QHadronVector    theQHadrons;     // Vector of generated secondary hadrons +++++
+  // Internal working objects (@@ it is possible to sacrifice some of them in future)
+  G4QCHIPSWorld      theWorld;        // Pointer to the CHIPS World
+  G4LorentzVector    phot4M;          // Gamma 4-momentum for interaction with a quark-parton
+  G4int              nBarClust;       // Maximum barion number of clusters in the Environment @@ ??
+  G4int              nOfQ;            // number of quark-partons in the Quasmon (just to accelerate)
+  G4QCandidateVector theQCandidates;  // Vector of possible secondary hadrons/clusters (**delete!**)
+  G4double           f2all;           // Ratio of free nucleons to free+freeInDense nucleons @@ ??
+  G4double           rEP;             // E+p for the Residual Coloured Quasmon im LS +++++
+  G4double           rMo;             // p for the Residual Coloured Quasmon im LS +++++
+  G4double           totMass;         // Mass of total compound system curQuasmon+curEnvironment
+  G4int              bEn;             // BaryoNumber of the Limit Active Nuclear Environment
+  G4double           mbEn;            // Mass of the LimActNucEnv
+  G4LorentzVector    bEn4M;           // 4-momentum of the LimitActiveNuclearEnviron
+  G4QContent         bEnQC;           // QuarkContent of the LimitActiveNuclEnv
+};
+
+inline int G4Quasmon::operator==(const G4Quasmon &right) const {return this == &right;}
+inline int G4Quasmon::operator!=(const G4Quasmon &right) const {return this != &right;}
+inline G4double        G4Quasmon::GetTemper()    const {return Temperature;}
+inline G4double        G4Quasmon::GetSOverU()    const {return SSin2Gluons;}
+inline G4double        G4Quasmon::GetEtaSup()    const {return EtaEtaprime;}
+inline G4LorentzVector G4Quasmon::Get4Momentum() const {return q4Mom;}
+inline G4QContent      G4Quasmon::GetQC()        const {return valQ;}
+inline G4QPDGCode      G4Quasmon::GetQPDG()      const {return G4QPDGCode(valQ);}
+inline G4int           G4Quasmon::GetStatus()    const {return status;}
+inline void            G4Quasmon::ClearOutput()        
+      {G4std::for_each(theQHadrons.begin(), theQHadrons.end(), DeleteQHadron());
+       theQHadrons.clear();
+      }
+inline void            G4Quasmon::KillEnvironment()
+                                    {theEnvironment=G4QNucleus(0,0,0,G4LorentzVector(0.,0.,0.,0.));}
+inline G4double        G4Quasmon::GetRandomMass(G4int PDG, G4double maxM)
+{
+  G4QParticle* part = theWorld.GetQParticle(PDG);
+  return G4QHadron(part, maxM).GetMass();
+}
+
+inline void G4Quasmon::IncreaseBy(const G4Quasmon* pQuasm)
+{
+  valQ  += pQuasm->GetQC();
+  q4Mom += pQuasm->Get4Momentum();
+  status= 3;
+}
+
+inline void G4Quasmon::InitQuasmon(const G4QContent& qQCont, const G4LorentzVector& q4M)
+{
+  valQ  = qQCont;
+  q4Mom = q4M;
+  status= 3;
+}
+
+inline void G4Quasmon::KillQuasmon()
+{
+  static const G4QContent zeroQC(0,0,0,0,0,0);
+  static const G4LorentzVector nothing(0.,0.,0.,0.);
+  phot4M= nothing;
+  valQ  = zeroQC;
+  q4Mom = nothing;
+  status= 0;
+}
+
+#endif
+
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/include/G4QuasmonVector.hh

@@ -0,0 +1,41 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QuasmonVector.hh,v 1.9 2001/11/26 14:11:46 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QuasmonVector ----------------
+//             by Mikhail Kossov, Sept 1999.
+// Type definition for a Vector of Quasmons - output of CHIPS model
+// ----------------------------------------------------------------
+
+#ifndef G4QuasmonVector_h
+#define G4QuasmonVector_h 1
+
+#include "G4Quasmon.hh"
+#include "g4std/vector"
+
+typedef G4std::vector<G4Quasmon *> G4QuasmonVector;
+struct DeleteQuasmon{ void operator()(G4Quasmon *aN){delete aN;} };
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/body/src/G4QCHIPSWorld.cc

@@ -0,0 +1,122 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QCHIPSWorld.cc,v 1.17 2001/11/26 14:11:46 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCHIPSWorld ----------------
+//             by Mikhail Kossov, Sept 1999.
+//      class for the CHIPS World definition in CHIPS Model
+// -------------------------------------------------------------------
+
+//#define debug
+//#define pdebug
+
+#include "G4QCHIPSWorld.hh"
+
+G4QCHIPSWorld::G4QCHIPSWorld(G4int nOfParts)
+{
+  qWorld = InitCHIPSWorld(nOfParts); // Initialization of the CHIPS World with N particles
+}
+
+G4QCHIPSWorld::G4QCHIPSWorld(const G4QCHIPSWorld& right)
+{
+  qWorld = right.qWorld;
+}
+
+G4QCHIPSWorld::G4QCHIPSWorld(G4QCHIPSWorld* right)
+{
+  qWorld = right->qWorld;
+}
+
+G4QCHIPSWorld::~G4QCHIPSWorld() {}
+
+const G4QCHIPSWorld& G4QCHIPSWorld::operator=(const G4QCHIPSWorld &right)
+{//   ===================================================================
+  qWorld = right.qWorld;
+
+  return *this;
+}
+
+// Standard output for CHIPS World
+G4std::ostream& operator<<(G4std::ostream& lhs, G4QCHIPSWorld& rhs)
+//       ============================================
+{
+  // @@ Later make a list of activated particles and clusters
+  lhs << "[ a#of particles in the CHIPS World =" << rhs.GetQPEntries() << "]";
+  return lhs;
+}
+
+//Initialize the CHIPS World of Quasmons
+G4QParticleVector* G4QCHIPSWorld::InitCHIPSWorld(G4int nOfParts)
+//                 =============================================
+{
+  static G4int mnofParts = 486;                 // max number of particles (up to A=80)
+  static G4QParticleVector theWorld;            // *** A body of the CHIPS World *** 
+  static int init = 0;                          // Initialization counter (private)
+#ifdef debug
+  G4cout<<"G4QCHIPSWorld::InitCHIPSWorld: n="<<nOfParts<<" particles, init="<<init<<G4endl;
+#endif
+  if(nOfParts>0)
+  {
+#ifdef debug
+    G4cout<<"G4QCHIPSWorld::InitCHIPSWorld: Creating CHIPS World of nP="<<nOfParts<<G4endl;
+#endif
+    G4int curNP=theWorld.size();
+    if(curNP<0) curNP=0;
+    if(!init++||nOfParts>curNP)                 // Initialize for increasing CHIPS World
+    {
+      if (nOfParts>mnofParts)
+      {
+        nOfParts=mnofParts;
+        G4cerr<<"***G4QCHIPSWorld::InitCHIPSWorld: nOfParts="<<nOfParts<<" >"<<mnofParts<<G4endl;
+      }
+      if (nOfParts<10) nOfParts=10;             // Minimal number of particles for Vacuum
+#ifdef debug
+      G4cerr<<"G4QCHIPSWorld::InitCHIPSWorld:Should be once, i="<<init<<",n="<<nOfParts<<",c="<<curNP<<G4endl;
+#endif
+      for (G4int i=curNP; i<nOfParts; i++) 
+      {
+        G4QParticle* curPart = new G4QParticle; // Created
+        curPart->InitQParticle(i);              //   ||
+        theWorld.push_back(curPart);               // Filled (forever but once)
+#ifdef debug
+        G4cout<<"G4QCHIPSWorld::InitCHIPSWorld: Particle#"<<i<<"(of "<<nOfParts<<") done"<<endl;
+#endif
+      }
+    }
+    else if (nOfParts<0)
+	{
+      G4std::for_each(theWorld.begin(), theWorld.end(), DeleteQParticle());
+      theWorld.clear();
+      init=0;
+	}
+    else init--;
+  }
+  return &theWorld;
+}
+
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/src/G4QCandidate.cc

@@ -0,0 +1,141 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QCandidate.cc,v 1.18 2001/12/13 12:04:17 gunter Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QCandidate ----------------
+//             by Mikhail Kossov, Sept 1999.
+//      class for Quasmon initiated Candidates used by CHIPS Model
+// ------------------------------------------------------------------
+
+//#define debug
+
+#include "G4QCandidate.hh"
+#include "g4std/algorithm"
+
+G4QCandidate::G4QCandidate() : relativeProbability(0.),integralProbability(0.)
+{
+}
+
+G4QCandidate::G4QCandidate(G4int PDGcode) :
+  relativeProbability(0.),integralProbability(0.)
+{
+  G4LorentzVector cur4Mom(0.,0.,0.,0.);
+  G4QPDGCode QPDG(PDGcode);
+  SetQPDG(QPDG);
+  G4double vacMass  = QPDG.GetMass();
+  cur4Mom.setE(vacMass);
+  Set4Momentum(cur4Mom);
+  SetQC(QPDG.GetQuarkContent());
+}
+
+G4QCandidate::G4QCandidate(const G4QCandidate& right)
+{
+  Set4Momentum         (right.Get4Momentum());
+  SetQPDG              (right.GetQPDG());
+  SetQC                (right.GetQC());
+  SetNFragments        (right.GetNFragments());
+  possible            = right.possible;
+  parPossible         = right.parPossible;
+  kMin                = right.kMin;
+  denseProbability    = right.denseProbability;
+  preProbability      = right.preProbability;
+  relativeProbability = right.relativeProbability;
+  integralProbability = right.integralProbability;
+  secondRelProbability= right.secondRelProbability;
+  secondIntProbability= right.secondIntProbability;
+  // thePClusters
+  G4int nParCl        = right.thePClusters.size();
+  if(nParCl) for(G4int ip=0; ip<nParCl; ip++)
+  {
+    G4QParentCluster* curPC = new G4QParentCluster(right.thePClusters[ip]);
+    thePClusters.push_back(curPC);
+  }
+}
+
+G4QCandidate::G4QCandidate(G4QCandidate* right)
+{
+  Set4Momentum         (right->Get4Momentum());
+  SetQPDG              (right->GetQPDG());
+  SetQC                (right->GetQC());
+  SetNFragments        (right->GetNFragments());
+  possible            = right->possible;
+  parPossible         = right->parPossible;
+  kMin                = right->kMin;
+  denseProbability    = right->denseProbability;
+  preProbability      = right->preProbability;
+  relativeProbability = right->relativeProbability;
+  integralProbability = right->integralProbability;
+  secondRelProbability= right->secondRelProbability;
+  secondIntProbability= right->secondIntProbability;
+  // thePClusters
+  G4int nParCl        = right->thePClusters.size();
+  if(nParCl) for(G4int ip=0; ip<nParCl; ip++)
+  {
+    G4QParentCluster* curPC = new G4QParentCluster(right->thePClusters[ip]);
+    thePClusters.push_back(curPC);
+  }
+}
+
+G4QCandidate::~G4QCandidate()
+{
+#ifdef debug
+  G4cout<<"~G4QCandidate: before thePClusters nC="<<thePClusters.entries()<<G4endl;
+#endif
+  G4std::for_each(thePClusters.begin(), thePClusters.end(), DeleteQParentCluster());
+#ifdef debug
+  G4cout<<"~G4QCandidate: === DONE ==="<<G4endl;
+#endif
+}
+
+// Assignment operator
+const G4QCandidate& G4QCandidate::operator=(const G4QCandidate &right)
+{
+  Set4Momentum         (right.Get4Momentum());
+  SetQPDG              (right.GetQPDG());
+  SetQC                (right.GetQC());
+  SetNFragments        (right.GetNFragments());
+  possible            = right.possible;
+  parPossible         = right.parPossible;
+  kMin                = right.kMin;
+  denseProbability    = right.denseProbability;
+  preProbability      = right.preProbability;
+  relativeProbability = right.relativeProbability;
+  integralProbability = right.integralProbability;
+  secondRelProbability= right.secondRelProbability;
+  secondIntProbability= right.secondIntProbability;
+  // thePClusters (Vector)
+  G4int nParCl        = right.thePClusters.size();
+  if(nParCl) for(G4int ip=0; ip<nParCl; ip++)
+  {
+    G4QParentCluster* curPC = new G4QParentCluster(right.thePClusters[ip]);
+    thePClusters.push_back(curPC);
+  }
+
+  return *this;
+}
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/src/G4QChipolino.cc

@@ -0,0 +1,512 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QChipolino.cc,v 1.14 2001/11/26 14:11:46 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QChipolino ----------------
+//             by Mikhail Kossov, Sept 1999.
+//      class for Quasmon initiated Chipolinos generated by CHIPS Model
+// ------------------------------------------------------------------
+
+//#define debug
+//#define pdebug
+
+#include "G4QChipolino.hh"
+
+G4QChipolino::G4QChipolino(G4QContent& QCont)
+{
+  // @@ Does not work as static const ??
+  G4QPDGCode Pi0(111);
+  G4double   mPi0  = Pi0.GetMass();
+  G4QContent Pi0QC = Pi0.GetQuarkContent();
+  G4int ban =QCont.GetBaryonNumber();
+  G4int tban=abs(3*ban);
+  G4int tot=QCont.GetTot();   // Initial total number of quarks in QC
+  G4int tod=tot%2;            // tot is even - meson or dibaryon-nucleus
+  if(!tod&&(tot<4||ban&&tot<tban)||tod&&tot<tban+2) QCont.IncQAQ(1,0.); // Add quark-pair
+  G4QContent rQC=QCont;       // Copy for possible reduction ("annihilation" of q-qbar pairs)
+  tot=rQC.GetTot();           // New total number of quarks in QC  (temporary)
+  if   (tot%2)rQC.DecQAQ(-tban-2); // Reduce pairs, keep only 5 quarks  (baryon case)
+  else if(ban)rQC.DecQAQ(-tban); // Reduce pairs, keep only 6 quarks  (dibaryon case)
+  else        rQC.DecQAQ(-4); // Reduce pairs, keep only 4 quarks  (meson case)
+  tot=rQC.GetTot();           // Final total number of quarks      (updated)
+#ifdef debug
+  cout<<"G4QChipolino is called with QC="<<QCont<<",rQC="<<rQC<<",tot="<<tot<<G4endl;
+#endif
+  minM=1000000.;              // Prototype of minimal mass         (@@ just a big number)
+  theQPDG1   = Pi0;
+  theQPDG2   = Pi0;
+  theQCont1  = Pi0QC;
+  if      (!tot)              // Should not be here, just in case     (strange input)
+  {
+    G4cerr<<"***G4QChipolino: shouldn't be here 1 QC="<<rQC<<G4endl;
+    G4Exception("G4QChipolino cannot be constructed as n_tot=0");
+  }
+  else if (tot==2 || tot==3)  // Should not be here (basic octet/singlet states)
+  {
+    G4cerr<<"***G4QChipolino: shouldn't be here 2 QC="<<rQC<<G4endl;
+    theQCont1= rQC;
+    theQPDG1.InitByQCont(rQC);
+    theQCont = rQC+Pi0QC;
+  }
+  else if (tot==4)                 // Two possible combinations for the meson
+  {
+    G4QContent bQC=rQC.IndQ();
+#ifdef debug
+    cout<<"G4QChipolino: tot=4,rQC="<<rQC<<",bQC="<<bQC<<G4endl;
+#endif
+    for(int j=0; j<2; j++)
+    {
+      G4QContent aQC=rQC.IndAQ(j);
+      G4QContent cQC=bQC+aQC;
+      G4QPDGCode cQPDG(cQC);
+      G4double                    M1=cQPDG.GetMass(); 
+      if(cQPDG.GetPDGCode()==221) M1=mPi0;
+      G4QContent oQC=rQC-cQC;
+#ifdef debug
+	  cout<<"G4QChipolino: aQC="<<aQC<<", cQC="<<cQC<<", oQC="<<oQC<<G4endl;
+#endif
+      G4QPDGCode oQPDG(oQC);
+      G4double                    M2=oQPDG.GetMass();
+      if(oQPDG.GetPDGCode()==221) M2=mPi0;
+      G4double m=M1+M2;
+#ifdef debug
+	  cout<<"G4QChipolino: c="<<cQPDG<<",cM="<<M1<<",o="<<oQPDG<<",oM="<<M2
+          <<",cM+0M="<<m<<", curMinM="<<minM<<G4endl;
+#endif
+      if(m<minM)
+      {
+        minM=m;
+        theQPDG1  = cQPDG;
+        theQCont1 = cQC;
+        theQPDG2  = oQPDG;
+      }
+    }
+  }
+  else if (tot==5)                 // Four possible combinations for the baryon
+  {
+    G4int nQ=rQC.GetQ();
+    G4int nA=rQC.GetAQ();
+    G4bool fl=nA>nQ;               // Flag of antibaryon case
+#ifdef pdebug
+	cout<<"G4QChipolino: Baryon case nQ="<<nQ<<",nA="<<nA<<",QC="<<rQC
+        <<",fl="<<fl<<G4endl;
+#endif
+    G4QContent bQC;
+    if (fl) bQC=rQC.IndQ();       // Antibaryon case
+    else    bQC=rQC.IndAQ();      // Baryon case - QC of antiquark
+    for (int i=0; i<4; i++)
+    {
+      G4QContent cQC;
+      if (fl) cQC=bQC+rQC.IndAQ(i);
+      else    cQC=bQC+rQC.IndQ(i);// Make mesonout of anti-quark
+      G4QPDGCode cQPDG(cQC);      // Make QPDG particle
+      G4double                    M1=cQPDG.GetMass(); // Get meson mass
+      if(cQPDG.GetPDGCode()==221) M1=mPi0; // Make pi0 out of eta
+      G4QContent oQC=rQC-cQC;     // Make residual baryon
+      G4QPDGCode oQPDG(oQC);      // Make QPDG of residual baryon
+      G4double                    M2=oQPDG.GetMass(); // Get baryon mass
+      if(oQPDG.GetPDGCode()==221) M2=mPi0; // @@ Never !!
+      G4double m=M1+M2;
+      if(m<minM)
+      {
+        minM=m;
+        theQPDG1  = cQPDG;
+        theQCont1 = cQC;
+        theQPDG2  = oQPDG;
+      }
+    }
+#ifdef pdebug
+	cout<<"G4QChipolino: Baryon case minM="<<minM<<", M="<<theQCont1<<theQPDG1
+        <<", B="<<theQPDG2<<G4endl;
+#endif
+  }
+  else if (tot==6)                 // Four possible combinations for the di-baryon
+  {
+    if(ban)
+	{
+      G4int nQ=rQC.GetQ();
+      G4int nA=rQC.GetAQ();
+      G4bool fl=nA>nQ;             // Flag of anti-dibaryon case
+#ifdef debug
+	  cout<<"G4QChipolino: Di-Baryon case nQ="<<nQ<<",nA="<<nA<<",QC="<<rQC<<",fl="<<fl<<G4endl;
+#endif
+      for (int i=0; i<4; i++)
+      {
+        G4QContent aQC;
+        if (fl) aQC=rQC.IndAQ(i);
+        else    aQC=rQC.IndQ(i);
+        for (int j=i+1; j<5; j++)
+        {
+          G4QContent bQC;
+          if (fl) bQC=aQC+rQC.IndAQ(j);
+          else    bQC=aQC+rQC.IndQ(j);
+          for (int k=j+1; k<6; k++)
+          {
+            G4QContent cQC;
+            if (fl) cQC=bQC+rQC.IndAQ(k);
+            else    cQC=bQC+rQC.IndQ(k);
+            G4QPDGCode cQPDG(cQC);
+            G4double                    M1=cQPDG.GetMass();
+            if(cQPDG.GetPDGCode()==221) M1=mPi0;
+            G4QContent oQC=rQC-cQC;
+            G4QPDGCode oQPDG=(oQC);
+            G4double                    M2=oQPDG.GetMass();
+            if(oQPDG.GetPDGCode()==221) M2=mPi0;
+            G4double m=M1+M2;
+            if(m<minM)
+            {
+              minM=m;
+              theQPDG1  = cQPDG;
+              theQCont1 = cQC;
+              theQPDG2  = oQPDG;
+            }
+		  }
+	    }
+      }
+    }
+    else                       // Baryon-AntiBaryon
+	{
+      theQCont1 = rQC.IndQ(0)+rQC.IndQ(1)+rQC.IndQ(2);
+      theQPDG1.InitByQCont(theQCont1);
+      theQPDG2.InitByQCont(rQC.IndAQ(0)+rQC.IndAQ(1)+rQC.IndAQ(2));
+	}
+  }
+  else if(((rQC.GetU() )>(rQC.GetS() -4) && (rQC.GetD() )>(rQC.GetS() -4)) ||
+          ((rQC.GetAU())>(rQC.GetAS()-4) && (rQC.GetAD())>(rQC.GetAS()-4)) )
+  {
+    G4int kD=rQC.GetD();
+    G4int kU=rQC.GetU();
+    G4int kS=rQC.GetS();
+    G4int mD=rQC.GetAD();
+    G4int mU=rQC.GetAU();
+    G4int mS=rQC.GetAS();
+    G4int nQ=rQC.GetQ();
+    G4int nA=rQC.GetAQ();
+    G4bool fl=nA>nQ;           // Flag of anti-fragment case
+#ifdef debug
+	cout<<"G4QChipolino: NucFragment case nQ="<<nQ<<",nAQ="<<nA<<", QC="<<rQC<<",fl="<<fl<<G4endl;
+#endif
+	if((fl&&kS>1)||(!fl&&mS>1))
+    {
+      G4cerr<<"***G4QChipolino: ***Overfowed by strange quarks*** rQC="<<rQC<<G4endl;
+	  G4Exception("G4QChipolino: Nuclear Fragment-Chipolino is overflowed by strange quarks");
+    }
+    else if(fl)                // ===> Anti-fragment
+	{
+      //G4cerr<<"***G4QChipolino: ***Anti-nuclear fragments*** rQC="<<rQC<<G4endl;
+	  //G4Exception("G4QChipolino: Antinuclear fragments are not yet supported");
+      if(!mS)                                                           // No strange quarks
+	  {
+        G4int nI=mU-mD;                                                 // Isotopic shift
+        G4int nN=(mU+mD-nI*3)/6;
+        if(!kS)                                                         // No kaons
+		{
+          if((nI>=0&&nN>=0)||(nI<0&&nN>=-nI))                           // Delta isn't necessary
+          {
+            if(nI>0)                                                    // Excess of antiprotons
+            {
+              theQPDG1 = G4QPDGCode(-(90000000+1000*(nN+nI-1)+nN));     // A Fragment-AProton
+              theQPDG2 = G4QPDGCode(-2212);                             // An Anti-Proton
+            }
+            else                                                        // Excess of a-neutrons
+            {
+              theQPDG1 = G4QPDGCode(-(90000000+1000*(nN+nI)+nN-1));     // A Fragment-ANeutron
+              theQPDG2 = G4QPDGCode(-2112);                             // An Anti-Neutron
+            }
+	      }
+          else if((nI>=0&&nN>-2)||(nI<0&&nN>-nI-2))                     // Delta can be a part
+		  {
+            if(nI>0)                                                    // Excess of au-quarks
+            {
+              theQPDG1=G4QPDGCode(-(90000000+1000*(nN+nI-2)+nN+1));     // A Fragment-AProton
+              theQPDG2=G4QPDGCode(-2224);                               // An Anti-Delta++
+            }
+            else                                                        // Excess of ad-quarks
+            {
+              theQPDG1=G4QPDGCode(-(90000000+1000*(nN+nI+1)+nN-2));     // A Fragment-ANeutron
+              theQPDG2=G4QPDGCode(-1114);                               // An Anti-Delta-
+            }
+		  }
+          else
+		  {
+            G4cerr<<"***G4QChipolino: **A**Isotopic asymmetry (without S)*** rQC="<<rQC<<G4endl;
+	        G4Exception("G4QChipolino: Exotic Isotopic asymmety of AntiMultyBaryon Quasmon");
+		  }
+        }
+        else if(kS<2)                                                   // NucFrag+K is possible
+		{
+          G4int    nN =(mU+mD-4-nI*3)/6;
+          if(nI>0)                                                      // Excess of au-quarks
+          {
+            nN+=1;
+            theQPDG1 = G4QPDGCode(-(90000000+1000*(nN+nI-1)+nN));       // An Anti-Fragment
+            theQPDG2 = G4QPDGCode(-321);                                // A K- meson
+		  }
+          else
+		  {
+            theQPDG1 = G4QPDGCode(-(90000000+1000*(nN+nI+1)+nN));       // An AntiFragment
+            theQPDG2 = G4QPDGCode(-311);                                // An Anti-K0 meson
+          }
+		}
+        else
+	    {
+          G4cerr<<"***G4QChipolino: ***Too many kaons are needed*** rQC="<<rQC<<G4endl;
+	      G4Exception("G4QChipolino: Too much Kaons are needed together with AntiNuclearFragm");
+		}
+	  }
+      else                     // Fragment with strangeness
+	  {
+        if(mS<=mU&&mS<=mD)     // Fragment consisting of Neutrons, Protons & Lambrdas only
+		{
+          G4int nI=mU-mD;                                               // Isotopic shift
+          G4int nN=(mU+mD-mS-mS-nI*3)/6;
+          if((nI>=0&&nN>=0)||(nI<0&&nN>=-nI))                           // Delta isn't necessary
+          {
+            if(nI>0)                                                    // Excess of protons
+            {
+              theQPDG1 = G4QPDGCode(-(90000000+1000*(kS*1000+nN+nI-1)+nN));// A Fragment-AProton
+              theQPDG2 = G4QPDGCode(-2212);                             // An Anti-Proton
+            }
+            else                                                        // Excess of neutrons
+            {
+              theQPDG1 = G4QPDGCode(-(90000000+1000*(kS*1000+nN+nI)+nN-1));//A Fragment-ANeutron
+              theQPDG2 = G4QPDGCode(-2112);                             // An Anti-Neutron
+            }
+		  }
+          else if((nI>=0&&nN>-2)||(nI<0&&nN>-nI-2))                     // Delta can be a part
+		  {
+            if(nI>0)                                                    // Excess of au-quarks
+            {
+              theQPDG1=G4QPDGCode(-(90000000+1000*(kS*1000+nN+nI-2)+nN+1));// A Fragment-AProton
+              theQPDG2=G4QPDGCode(-2224);                               // An Anti-Delta++
+            }
+            else                                                        // Excess of ad-quarks
+            {
+              theQPDG1=G4QPDGCode(-(90000000+1000*(kS*1000+nN+nI+1)+nN-2));//A Fragment-ANeutron
+              theQPDG2=G4QPDGCode(-1114);                               // An Anti-Delta-
+            }
+		  }
+          else
+		  {
+            G4cerr<<"***G4QChipolino: **A**Isotopic assimetry (with S)*** rQC="<<rQC<<G4endl;
+	        G4Exception("G4QChipolino:Exotic Isotopics of Strange AntiMultyBaryon Quasmon");
+		  }
+		}
+        else                                                            // Excess of s-quarks
+		{
+          G4int       lam=mU;                                           // A#of Anti-Lambdas
+          if (lam>mD) lam=mD;
+          G4int lD=mD-lam;                                              // Residual ad-quarks
+          G4int lU=mU-lam;                                              // Residual au-quarks
+          G4int lS=mS-lam;                                              // Residual as-quarks
+          if(lD+lU+lS!=3||lD<0||lU<0||lS<0)
+		  {
+            G4cerr<<"***G4QChipolino:*AntiFragm* rQC="<<rQC<<",s="<<lS<<",u="<<lU<<",d"<<lD<<G4endl;
+	        G4Exception("G4QChipolino: Exotic superstrange AntiMultyBaryon");
+		  }
+          if     ( !lD && lU==2) theQPDG2=G4QPDGCode(-3222);            // Anti-Sigma+
+          else if( !lU && lD==2) theQPDG2=G4QPDGCode(-3112);            // Anti-Sigma-
+          else if( !lD && lU==1) theQPDG2=G4QPDGCode(-3322);            // Anti-Ksi0
+          else if( !lU && lD==1) theQPDG2=G4QPDGCode(-3312);            // Anti-Ksi-
+          else                   theQPDG2=G4QPDGCode(-3334);            // Anti-Omega-
+          theQPDG1=G4QPDGCode(-(90+lam)*1000000);                       // Anti Strange Matter
+		}
+        theQCont1  = rQC-theQPDG2.GetQuarkContent();                    // QCont of Fragment-H
+        theQCont   = rQC;                                               // QCont of Chipolino
+	  }
+	}
+	else                       // ===> Nuclear Fragment
+	{
+      if(!kS)                                                           // No strange quarks
+	  {
+        G4int nI=kU-kD;                                                 // Isotopic shift
+        G4int nN=(kU+kD-nI*3)/6;
+        if(!mS)                                                         // No kaons
+		{
+          if((nI>=0&&nN>=0)||(nI<0&&nN>=-nI))                           // Delta isn't necessary
+          {
+            if(nI>0)                                                    // Excess of protons
+            {
+              theQPDG1 = G4QPDGCode(90000000+1000*(nN+nI-1)+nN);        // A Fragment-Proton
+              theQPDG2 = G4QPDGCode(2212);                              // A Proton
+            }
+            else                                                        // Excess of neutrons
+            {
+              theQPDG1 = G4QPDGCode(90000000+1000*(nN+nI)+nN-1);        // A Fragment-Neutron
+              theQPDG2 = G4QPDGCode(2112);                              // A Neutron
+            }
+	      }
+          else if((nI>=0&&nN>-2)||(nI<0&&nN>-nI-2))                     // Delta can be a part
+		  {
+            if(nI>0)                                                    // Excess of u-quarks
+            {
+              theQPDG1=G4QPDGCode(90000000+1000*(nN+nI-2)+nN+1);        // A Fragment-Proton
+              theQPDG2=G4QPDGCode(2224);                                // A Delta++
+            }
+            else                                                        // Excess of d-quarks
+            {
+              theQPDG1=G4QPDGCode(90000000+1000*(nN+nI+1)+nN-2);        // A Fragment-Neutron
+              theQPDG2=G4QPDGCode(1114);                                // A Delta-
+            }
+		  }
+          else
+		  {
+            G4cerr<<"***G4QChipolino: ***Isotopic assimetry (without S)*** rQC="<<rQC<<G4endl;
+	        G4Exception("G4QChipolino: Exotic Isotopic assimety of MultyBaryon Quasmon");
+		  }
+        }
+        else if(mS<2)                                                   // NucFrag+K is possible
+		{
+          G4int    nN =(kU+kD-4-nI*3)/6;
+          if(nI>0)                                                      // Excess of u-quarks
+          {
+            nN+=1;
+            theQPDG1 = G4QPDGCode(90000000+1000*(nN+nI-1)+nN);          // A Fragment
+            theQPDG2 = G4QPDGCode(321);                                 // A K+ meson
+		  }
+          else
+		  {
+            theQPDG1 = G4QPDGCode(90000000+1000*(nN+nI+1)+nN);            // A Fragment
+            theQPDG2 = G4QPDGCode(311);                                 // A K0 meson
+          }
+		}
+        else
+	    {
+          G4cerr<<"***G4QChipolino: ***Too many kaons are needed*** rQC="<<rQC<<G4endl;
+	      G4Exception("G4QChipolino: More than one Kaon is needed together with Nuclear Fragm");
+		}
+	  }
+      else                     // Fragment with strangeness
+	  {
+        if(kS<=kU&&kS<=kD)     // Fragment consisting of Neutrons, Protons & Lambrdas only
+		{
+          G4int nI=kU-kD;                                               // Isotopic shift
+          G4int nN=(kU+kD-kS-kS-nI*3)/6;
+          if((nI>=0&&nN>=0)||(nI<0&&nN>=-nI))                           // Delta isn't necessary
+          {
+            if(nI>0)                                                    // Excess of protons
+            {
+              theQPDG1 = G4QPDGCode(90000000+1000*(kS*1000+nN+nI-1)+nN);// A Fragment-Proton
+              theQPDG2 = G4QPDGCode(2212);                              // A Proton
+            }
+            else                                                        // Excess of neutrons
+            {
+              theQPDG1 = G4QPDGCode(90000000+1000*(kS*1000+nN+nI)+nN-1);// A Fragment-Neutron
+              theQPDG2 = G4QPDGCode(2112);                              // A Neutron
+            }
+		  }
+          else if((nI>=0&&nN>-2)||(nI<0&&nN>-nI-2))                     // Delta can be a part
+		  {
+            if(nI>0)                                                    // Excess of u-quarks
+            {
+              theQPDG1=G4QPDGCode(90000000+1000*(kS*1000+nN+nI-2)+nN+1);// A Fragment-Proton
+              theQPDG2=G4QPDGCode(2224);                                // A Delta++
+            }
+            else                                                        // Excess of d-quarks
+            {
+              theQPDG1=G4QPDGCode(90000000+1000*(kS*1000+nN+nI+1)+nN-2);// A Fragment-Neutron
+              theQPDG2=G4QPDGCode(1114);                                // A Delta-
+            }
+		  }
+          else
+		  {
+            G4cerr<<"***G4QChipolino: ***Isotopic assimetry (with S)*** rQC="<<rQC<<G4endl;
+	        G4Exception("G4QChipolino:Exotic Isotopic Assimety of Strange MultyBaryon Quasmon");
+		  }
+		}
+        else                                                            // Excess of s-quarks
+		{
+          G4int       lam=kU;                                           // A#of Lambda
+          if (lam>kD) lam=kD;
+          G4int lD=kD-lam;                                              // Residual d-quarks
+          G4int lU=kU-lam;                                              // Residual u-quarks
+          G4int lS=kS-lam;                                              // Residual s-quarks
+          if(lD+lU+lS!=3||lD<0||lU<0||lS<0)
+		  {
+            G4cerr<<"***G4QChipolino: *Fragment* rQC="<<rQC<<",s="<<lS<<",u="<<lU<<",d"<<lD<<G4endl;
+	        G4Exception("G4QChipolino: Exotic superstrange Multy Baryon");
+		  }
+          if     ( !lD && lU==2) theQPDG2=G4QPDGCode(3222);             // Sigma+
+          else if( !lU && lD==2) theQPDG2=G4QPDGCode(3112);             // Sigma-
+          else if( !lD && lU==1) theQPDG2=G4QPDGCode(3322);             // Ksi0
+          else if( !lU && lD==1) theQPDG2=G4QPDGCode(3312);             // Ksi-
+          else                   theQPDG2=G4QPDGCode(3334);             // Omega-
+          theQPDG1=G4QPDGCode((90+lam)*1000000);                        // A Strange Matter
+		}
+        theQCont1  = rQC-theQPDG2.GetQuarkContent();                    // QCont of Fragment-H
+        theQCont   = rQC;                                               // QCont of Chipolino
+	  }
+	}
+  }
+  else
+  {
+    G4cerr<<"***G4QChipolino: ***Exotics*** rQC="<<rQC<<G4endl;
+	G4Exception("G4QChipolino: can not be constructed for the exotic baryon or meson");
+  }
+}
+
+G4QChipolino::G4QChipolino(const G4QChipolino& right)
+{
+  theQPDG1  = right.theQPDG1;
+  theQPDG2  = right.theQPDG2;
+  theQCont  = right.theQCont;
+  theQCont1 = right.theQCont1;
+  minM      = right.minM;
+}
+
+G4QChipolino::G4QChipolino(G4QChipolino* right)
+{
+  theQPDG1  = right->theQPDG1;
+  theQPDG2  = right->theQPDG2;
+  theQCont  = right->theQCont;
+  theQCont1 = right->theQCont1;
+  minM      = right->minM;
+}
+
+const G4QChipolino& G4QChipolino::operator=(const G4QChipolino &right)
+{
+  theQPDG1  = right.theQPDG1;
+  theQPDG2  = right.theQPDG2;
+  theQCont  = right.theQCont;
+  theQCont1 = right.theQCont1;
+  minM      = right.minM;
+
+  return *this;
+}
+
+G4QChipolino::~G4QChipolino() {}
+
+// Standard output for G4QChipolino
+G4std::ostream& operator<<(G4std::ostream& lhs, G4QChipolino& rhs)
+{//      ===========================================
+  lhs<<"{1="<<rhs.GetQPDG1()<<",2="<<rhs.GetQPDG2()<< "}";
+  return lhs;
+}
+
+
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/src/G4QDecayChan.cc

@@ -0,0 +1,129 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QDecayChan.cc,v 1.14 2001/11/26 14:11:46 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QDecayChan ----------------
+//             by Mikhail Kossov, Sept 1999.
+//      class for Decay Channels of Hadrons in CHIPS Model
+// -------------------------------------------------------------------
+ 
+//#define debug
+//#define pdebug
+
+#include "G4QDecayChanVector.hh"
+#include "g4std/algorithm"
+
+G4QDecayChan::G4QDecayChan(){}
+
+G4QDecayChan::G4QDecayChan(G4double pLev, G4int PDG1, G4int PDG2, G4int PDG3):
+  aDecayChanLimit(pLev)
+{
+  G4QPDGCode* firstPDG = new G4QPDGCode(PDG1);
+  theMinMass =firstPDG->GetMass();
+  aVecOfSecHadrons.push_back(firstPDG);
+  G4QPDGCode* secondPDG = new G4QPDGCode(PDG2);
+  theMinMass+=secondPDG->GetMass();
+  aVecOfSecHadrons.push_back(secondPDG);
+  if(PDG3) 
+  {
+    G4QPDGCode* thirdPDG = new G4QPDGCode(PDG3);
+    theMinMass+=thirdPDG->GetMass();
+    aVecOfSecHadrons.push_back(thirdPDG);
+  }
+#ifdef debug
+  cout<<"G4QDecayChan is defined with pL="<<pLev<<",1="<<PDG1<<",2="<<PDG2<<",3="<<PDG3
+      <<",m1="<<firstPDG->GetMass()<<",m2="<<secondPDG->GetMass()<<",minM="<<theMinMass<<endl;
+#endif
+}
+
+G4QDecayChan::G4QDecayChan(const G4QDecayChan& right)
+{
+  aDecayChanLimit     = right.aDecayChanLimit;
+  theMinMass          = right.theMinMass;
+  //aVecOfSecHadrons (Vector)
+  G4int nSH           = right.aVecOfSecHadrons.size();
+  if(nSH) for(G4int ih=0; ih<nSH; ih++)
+  {
+    G4QPDGCode* curPC = new G4QPDGCode(right.aVecOfSecHadrons[ih]);
+    aVecOfSecHadrons.push_back(curPC);
+  }
+}
+
+G4QDecayChan::G4QDecayChan(G4QDecayChan* right)
+{
+  aDecayChanLimit     = right->aDecayChanLimit;
+  theMinMass          = right->theMinMass;
+  //aVecOfSecHadrons (Vector)
+  G4int nSH           = right->aVecOfSecHadrons.size();
+  if(nSH) for(G4int ih=0; ih<nSH; ih++)
+  {
+    G4QPDGCode* curPC = new G4QPDGCode(right->aVecOfSecHadrons[ih]);
+    aVecOfSecHadrons.push_back(curPC);
+  }
+}
+
+G4QDecayChan::~G4QDecayChan() 
+{
+  G4std::for_each(aVecOfSecHadrons.begin(), aVecOfSecHadrons.end(), DeleteQPDGCode());
+}
+
+// Assignment operator
+const G4QDecayChan& G4QDecayChan::operator=(const G4QDecayChan& right)
+{
+  aDecayChanLimit     = right.aDecayChanLimit;
+  theMinMass          = right.theMinMass;
+  //aVecOfSecHadrons (Vector)
+  G4int nSH           = right.aVecOfSecHadrons.size();
+  if(nSH) for(G4int ih=0; ih<nSH; ih++)
+  {
+    G4QPDGCode* curPC = new G4QPDGCode(right.aVecOfSecHadrons[ih]);
+    aVecOfSecHadrons.push_back(curPC);
+  }
+
+  return *this;
+}
+
+// Standard output for QDecayChan
+G4std::ostream& operator<<(G4std::ostream& lhs, G4QDecayChan& rhs)
+//       =========================================
+{
+  lhs << "[L=" << rhs.GetDecayChanLimit(); 
+  G4QPDGCodeVector VSH = rhs.GetVecOfSecHadrons();
+  G4int n = VSH.size();
+  lhs << ", N=" << n << ": ";
+  for (int i=0; i<n; i++)
+  {
+    if(!i) lhs << ":";
+    else   lhs << ",";
+    lhs << VSH[i]->GetPDGCode();
+  }
+  lhs << "]";
+  return lhs;
+}
+
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/src/G4QHadron.cc

@@ -0,0 +1,536 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QHadron.cc,v 1.22 2001/11/26 14:11:46 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QHadron ----------------
+//             by Mikhail Kossov, Sept 1999.
+//      class for Quasmon initiated Hadrons generated by CHIPS Model
+// ------------------------------------------------------------------
+
+//#define debug
+//#define pdebug
+//#define sdebug
+
+#include "G4QHadron.hh"
+
+G4QHadron::G4QHadron() :
+  theQPDG(0),theMomentum(0.,0.,0.,0.),valQ(0,0,0,0,0,0),nFragm(0)
+{}
+
+G4QHadron::G4QHadron(G4LorentzVector p) :
+  theQPDG(0),theMomentum(p),valQ(0,0,0,0,0,0),nFragm(0)
+{}
+
+// For Chipolino or Quasmon doesn't make any sense
+G4QHadron::G4QHadron(G4int PDGCode, G4LorentzVector p) :
+  theQPDG(PDGCode),theMomentum(p),nFragm(0)
+{
+  if(GetQCode()>-1)
+  {
+    if(theMomentum.e()==0.) theMomentum.setE(theQPDG.GetMass());
+    valQ=theQPDG.GetQuarkContent();
+  }
+  else if(PDGCode>80000000) DefineQC(PDGCode);
+  else G4cerr<<"***G4QHaron:(P) PDG="<<PDGCode<<", use other constructor"<<G4endl;
+}
+
+// For Chipolino or Quasmon doesn't make any sense
+G4QHadron::G4QHadron(G4QPDGCode QPDG, G4LorentzVector p) :
+  theQPDG(QPDG),theMomentum(p),nFragm(0)
+{
+  if(theQPDG.GetQCode()>-1)
+  {
+    if(theMomentum.e()==0.) theMomentum.setE(theQPDG.GetMass());
+    valQ=theQPDG.GetQuarkContent();
+  }
+  else
+  {
+    G4cerr<<"***G4QHaron:(QP) PDG="<<theQPDG.GetPDGCode()<<", use other constructor"<<G4endl;
+#ifdef sdebug
+	G4Exception("***G4QHadron: QPDG Constructor failed");
+#endif
+  }
+
+}
+
+// Make sense Chipolino or Quasmon
+G4QHadron::G4QHadron(G4QContent QC, G4LorentzVector p) :
+  theMomentum(p),valQ(QC),nFragm(0)
+{
+  G4int curPDG=valQ.GetSPDGCode();
+  if(curPDG&&curPDG!=10) theQPDG.SetPDGCode(curPDG);
+}
+
+G4QHadron::G4QHadron(G4int PDGCode, G4double aMass, G4QContent QC) :
+  theQPDG(PDGCode),theMomentum(0.,0.,0., aMass),valQ(QC),nFragm(0)
+{}
+
+G4QHadron::G4QHadron(G4QPDGCode QPDG, G4double aMass, G4QContent QC) :
+  theQPDG(QPDG),theMomentum(0.,0.,0., aMass),valQ(QC),nFragm(0)
+{}
+
+G4QHadron::G4QHadron(G4int PDGCode, G4LorentzVector p, G4QContent QC) :
+  theQPDG(PDGCode),theMomentum(p),valQ(QC),nFragm(0)
+{}
+
+G4QHadron::G4QHadron(G4QPDGCode QPDG, G4LorentzVector p, G4QContent QC) :
+  theQPDG(QPDG),theMomentum(p),valQ(QC),nFragm(0)
+{}
+
+G4QHadron::G4QHadron(G4QParticle* pPart, G4double maxM) :
+  theQPDG(pPart->GetQPDG()),theMomentum(0.,0.,0.,0.),nFragm(0)
+{
+#ifdef debug
+  G4cout<<"G4QHadron is created & randomized with maxM="<<maxM<<G4endl;
+#endif
+  G4int PDGCode = theQPDG.GetPDGCode();
+  if(PDGCode<2) G4cerr<<"***G4QHaron:(M) PDGC="<<PDGCode<<", use other constructor"<<G4endl;
+  valQ=theQPDG.GetQuarkContent();
+  theMomentum.setE(RandomizeMass(pPart, maxM));
+}
+
+G4QHadron::G4QHadron(const G4QHadron& right)
+{
+  theMomentum         = right.theMomentum;
+  theQPDG             = right.theQPDG;
+  valQ                = right.valQ;
+  nFragm              = right.nFragm;
+}
+
+G4QHadron::G4QHadron(G4QHadron* right)
+{
+  theMomentum         = right->theMomentum;
+  theQPDG             = right->theQPDG;
+  valQ                = right->valQ;
+  nFragm              = right->nFragm;
+}
+
+const G4QHadron& G4QHadron::operator=(const G4QHadron &right)
+{
+  theMomentum         = right.theMomentum;
+  theQPDG             = right.theQPDG;
+  valQ                = right.valQ;
+  nFragm              = right.nFragm;
+
+  return *this;
+}
+
+G4QHadron::~G4QHadron() {}
+
+// Decay of the Hadron in 2 particles (f + s) in respect to the direction of refference particle
+G4bool G4QHadron::RelDecayIn2(G4LorentzVector& f4Mom, G4LorentzVector& s4Mom,
+       G4LorentzVector& dir, G4double maxCost, G4double minCost)
+{//    ===================================================================
+  G4double fM2 = f4Mom.m2();
+  G4double fM  = sqrt(fM2);                // Mass of the 1st Hadron
+  G4double sM2 = s4Mom.m2();
+  G4double sM  = sqrt(sM2);                // Mass of the 2nd Hadron
+  G4double iM2 = theMomentum.m2();
+  G4double iM  = sqrt(iM2);                // Mass of the decaying hadron
+  G4ThreeVector ltb = theMomentum.boostVector(); // Boost vector for backward Lorentz Trans.
+  G4ThreeVector ltf = -ltb;                      // Boost vector for forward Lorentz Trans.
+  G4LorentzVector cdir = dir;              // A copy to make a transformation to CMS
+  cdir.boost(ltf);                         // Direction transpormed to CMS of the Momentum
+  G4ThreeVector vdir = cdir.vect();        // 3-Vector of the direction-particle
+#ifdef debug
+  G4cout<<"G4QHadron::RelDecayIn2: dir="<<dir<<",ltf="<<ltf<<",cdir="<<cdir<<",vdir="<<vdir<<G4endl;
+#endif
+  G4ThreeVector vx(0.,0.,1.);              // Ort in the direction of the reference particle
+  G4ThreeVector vy(0.,1.,0.);              // First ort orthogonal to the direction
+  G4ThreeVector vz(1.,0.,0.);              // Second ort orthoganal to the direction
+  if(vdir.mag2() > 0.)                     // the refference particle isn't at rest in CMS
+  {
+    vx = vdir.unit();                      // Ort in the direction of the reference particle
+    G4ThreeVector vv= vx.orthogonal();     // Not normed orthogonal vector (!)
+    vy = vv.unit();                        // First ort orthogonal to the direction
+    vz = vx.cross(vy);                     // Second ort orthoganal to the direction
+  }
+#ifdef debug
+  G4cout<<"G4QHadron::RelDecayIn2:iM="<<iM<<" => fM="<<fM<<" + sM="<<sM<<",ob="<<vx<<vy<<vz<<G4endl;
+#endif
+  if(maxCost>1.) maxCost=1.;
+  if (abs(iM-fM-sM)<.001)
+  {
+    G4double fR=fM/iM;
+    G4double sR=sM/iM;
+    f4Mom=fR*theMomentum;
+    s4Mom=sR*theMomentum;
+    return true;
+  }
+  else if (iM+.001<fM+sM || iM==0. || maxCost<-1.)
+  {//@@ Later on make a quark content check for the decay
+    G4cerr<<"***G4QHadron::RelDecayIn2:fM="<<fM<<"+sM="<<sM<<">iM="<<iM<<",d="<<iM-fM-sM<<",mC="
+          <<maxCost<<G4endl;
+    return false;
+  }
+  G4double d2 = iM2-fM2-sM2;
+  G4double p2 = (d2*d2/4.-fM2*sM2)/iM2;    // Decay momentum(^2) in CMS of Quasmon
+  if(p2<0.)
+  {
+#ifdef debug
+    G4cout<<"***G4QHadr:RelDecIn2:p2="<<p2<<"<0,d2^2="<<d2*d2/4.<<"<4*fM2*sM2="<<4*fM2*sM2<<G4endl;
+#endif
+    p2=0.;
+  }
+  G4double p  = sqrt(p2);
+  G4double ct = maxCost;
+  if(maxCost>minCost&&minCost>=-1.)
+  {
+    G4double dcost=maxCost-minCost;
+    ct = minCost+dcost*G4UniformRand();
+  }
+  G4double phi= 360.*deg*G4UniformRand();  // @@ Change 360.*deg to M_TWOPI (?)
+  G4double ps = p * sqrt(1.-ct*ct);
+  G4ThreeVector pVect=(ps*sin(phi))*vz+(ps*cos(phi))*vy+p*ct*vx;
+#ifdef debug
+  G4cout<<"G4QHadron::RelDecayIn2:ct="<<ct<<",p="<<p<<",ps="<<ps<<",ph="<<phi<<",v="<<pVect<<G4endl;
+#endif
+
+  f4Mom.setVect(pVect);
+  f4Mom.setE(sqrt(fM2+p2));
+  s4Mom.setVect((-1)*pVect);
+  s4Mom.setE(sqrt(sM2+p2));
+  
+#ifdef debug
+  G4cout<<"G4QHadron::RelDecayIn2: p2="<<p2<<",v="<<ltb<<",f4Mom="<<f4Mom<<",s4Mom="<<s4Mom<<G4endl;
+#endif
+  f4Mom.boost(ltb);                        // Lor.Trans. of 1st hadron back to LS
+  s4Mom.boost(ltb);                        // Lor.Trans. of 2nd hadron back to LS
+#ifdef debug
+  G4cout<<"G4QHadron::RelDecayIn2: ROOT OUTPUT f4Mom="<<f4Mom<<", s4Mom="<<s4Mom<<G4endl;
+#endif
+  return true;
+} // End of "RelDecayIn2"
+
+// Decay of the Hadron in 2 particles (f + s)
+G4bool G4QHadron::DecayIn2(G4LorentzVector& f4Mom, G4LorentzVector& s4Mom)
+{//    ===================================================================
+  G4double fM  = f4Mom.m();                // Mass of the 1st Hadron
+  G4double fM2 = f4Mom.m2();
+  G4double sM  = s4Mom.m();                // Mass of the 2nd Hadron
+  G4double sM2 = s4Mom.m2();
+  G4double iM  = theMomentum.m();          // Mass of the decaying hadron
+  G4double iM2 = theMomentum.m2();
+#ifdef pdebug
+  G4cout<<"G4QHadron::DecayIn2: iM="<<iM<<theMomentum<<" => fM="<<fM<<" + sM="<<sM<<G4endl;
+#endif
+  //@@ Later on make a quark content check for the decay
+  if (abs(iM-fM-sM)<.001)
+  {
+    G4double fR=fM/iM;
+    G4double sR=sM/iM;
+    f4Mom=fR*theMomentum;
+    s4Mom=sR*theMomentum;
+    return true;
+  }
+#ifdef pdebug
+  else if (iM+.001<fM+sM || iM==0.)
+  {
+    G4cerr<<"***G4QHadron::DecayIn2*** fM="<<fM<<" + sM="<<sM<<"="<<fM+sM<<" > iM="<<iM<<", d="
+          <<iM-fM-sM<<G4endl;
+    return false;
+  }
+#endif
+  G4double d2 = iM2-fM2-sM2;
+  G4double p2 = (d2*d2/4.-fM2*sM2)/iM2;    // Decay momentum(^2) in CMS of Quasmon
+  if (p2<0.)
+  {
+#ifdef pdebug
+    G4cerr<<"***G4QHadr::DecayIn2:p2="<<p2<<"<0,d2^2="<<d2*d2/4.<<"<4*fM2*sM2="<<4*fM2*sM2<<G4endl;
+#endif
+    p2=0.;
+  }
+  G4double p  = sqrt(p2);
+  G4double ct = 1.-2*G4UniformRand();
+#ifdef debug
+  G4cout<<"G4QHadron::DecayIn2: ct="<<ct<<", p="<<p<<G4endl;
+#endif
+  G4double phi= 360.*deg*G4UniformRand();  // @@ Change 360.*deg to M_TWOPI (?)
+  G4double ps = p * sqrt(1.-ct*ct);
+  G4ThreeVector pVect(ps*sin(phi),ps*cos(phi),p*ct);
+
+  f4Mom.setVect(pVect);
+  f4Mom.setE(sqrt(fM2+p2));
+  s4Mom.setVect((-1)*pVect);
+  s4Mom.setE(sqrt(sM2+p2));
+  
+  G4ThreeVector ltb = theMomentum.boostVector(); // Boost vector for backward Lor.Trans.
+#ifdef pdebug
+  G4cout<<"G4QHadron::DecayIn2: LorTransform v="<<ltb<<", f4Mom="<<f4Mom<<", s4Mom="<<s4Mom<<G4endl;
+#endif
+  f4Mom.boost(ltb);                        // Lor.Trans. of 1st hadron back to LS
+  s4Mom.boost(ltb);                        // Lor.Trans. of 2nd hadron back to LS
+#ifdef pdebug
+  G4cout<<"G4QHadron::DecayIn2: ROOT OUTPUT f4Mom="<<f4Mom<<", s4Mom="<<s4Mom<<G4endl;
+#endif
+  return true;
+} // End of "DecayIn2"
+
+// Correction for the Hadron + fr decay in case of the new corM mass of the Hadron
+G4bool G4QHadron::CorMDecayIn2(G4double corM, G4LorentzVector& fr4Mom)
+{//    ===============================================================
+  G4double fM  = fr4Mom.m();                // Mass of the Fragment
+  G4LorentzVector comp=theMomentum+fr4Mom;  // 4Mom of the decaying compound system
+  G4double iM  = comp.m();                  // mass of the decaying compound system
+#ifdef pdebug
+  G4cout<<"G4QHadr::CorMDecayIn2: iM="<<iM<<comp<<"=>fM="<<fM<<"+corM="<<corM<<"="<<fM+corM<<G4endl;
+#endif
+  G4double dE=iM-fM-corM;
+  //@@ Later on make a quark content check for the decay
+  if (abs(dE)<.001)
+  {
+    G4double fR=fM/iM;
+    G4double cR=corM/iM;
+    fr4Mom=fR*comp;
+    theMomentum=cR*comp;
+    return true;
+  }
+  else if (dE<-.001 || iM==0.)
+  {
+    G4cerr<<"***G4QHadron::CorMDecayIn2***fM="<<fM<<" + cM="<<corM<<" > iM="<<iM<<",d="<<dE<<G4endl;
+    return false;
+  }
+  G4double corM2= corM*corM;
+  G4double fM2 = fM*fM;
+  G4double iM2 = iM*iM;
+  G4double d2 = iM2-fM2-corM2;
+  G4double p2 = (d2*d2/4.-fM2*corM2)/iM2;    // Decay momentum(^2) in CMS of Quasmon
+  if (p2<0.)
+  {
+#ifdef pdebug
+    G4cerr<<"***G4QH::CorMDecayIn2:p2="<<p2<<"<0, d="<<d2*d2/4.<<"<4*fM2*hM2="<<4*fM2*corM2<<G4endl;
+#endif
+    p2=0.;
+  }
+  G4double p  = sqrt(p2);
+  G4ThreeVector ltb = comp.boostVector();        // Boost vector for backward Lor.Trans.
+  G4ThreeVector ltf = -ltb;                      // Boost vector for forward Lorentz Trans.
+  G4LorentzVector cm4Mom=fr4Mom;                 // Copy of fragment 4Mom to transform to CMS
+  cm4Mom.boost(ltf);                             // Now it is in CMS (Forward Lor.Trans.)
+  G4double pfx= cm4Mom.px();
+  G4double pfy= cm4Mom.py();
+  G4double pfz= cm4Mom.pz();
+  G4double pt2= pfx*pfx+pfy*pfy;
+  G4double tx=0.;
+  G4double ty=0.;
+  if(pt2<=0.)
+  {
+    G4double phi= 360.*deg*G4UniformRand();  // @@ Change 360.*deg to M_TWOPI (?)
+    tx=sin(phi);
+    ty=cos(phi);
+  }
+  else
+  {
+    G4double pt=sqrt(pt2);
+    tx=pfx/pt;
+    ty=pfy/pt;
+  }
+  G4double pc2=pt2+pfz*pfz;
+  G4double ct=0.;
+  if(pc2<=0.)
+  {
+    G4double rnd= G4UniformRand();
+    ct=1.-rnd-rnd;
+  }
+  else
+  {
+    G4double pc=sqrt(pc2);
+    ct=pfz/pc;
+  }
+#ifdef debug
+  G4cout<<"G4QHadron::CorMDecayIn2: ct="<<ct<<", p="<<p<<G4endl;
+#endif
+  G4double ps = p * sqrt(1.-ct*ct);
+  G4ThreeVector pVect(ps*tx,ps*ty,p*ct);
+  fr4Mom.setVect(pVect);
+  fr4Mom.setE(sqrt(fM2+p2));
+  theMomentum.setVect((-1)*pVect);
+  theMomentum.setE(sqrt(corM2+p2));
+#ifdef pdebug
+  G4LorentzVector dif2=comp-fr4Mom-Momentum;
+  G4cout<<"G4QHadron::CorMDecayIn2:vBLT="<<ltb<<",f4M="<<fr4Mom<<",h4M="<<theMomentum<<dif1<<G4endl;
+#endif
+  fr4Mom.boost(ltb);                        // Lor.Trans. of the Fragment back to LS
+  theMomentum.boost(ltb);                  // Lor.Trans. of the Hadron back to LS
+#ifdef pdebug
+  G4LorentzVector dif2=comp-fr4Mom-Momentum;
+  G4cout<<"G4QHadr::CorMDecayIn2:OUTPUT:f4Mom="<<fr4Mom<<",h4Mom="<<theMomentum<<"d="<<dif2<<G4endl;
+#endif
+  return true;
+} // End of "CorMDecayIn2"
+
+
+// Fragment fr4Mom louse energy corE and transfer it to This Hadron 
+G4bool G4QHadron::CorEDecayIn2(G4double corE, G4LorentzVector& fr4Mom)
+{//    ===============================================================
+  G4double fE  = fr4Mom.m();                // Energy of the Fragment
+#ifdef pdebug
+  G4cout<<"G4QHadron::CorEDecayIn2:fE="<<fE<<fr4Mom<<" > corE="<<corE<<",h4M="<<theMomentum<<G4endl;
+#endif
+  if (fE+.001<=corE)
+  {
+#ifdef pdebug
+    G4cerr<<"***G4QHadron::CorEDecayIn2*** fE="<<fE<<" < corE="<<corE<<", d="<<corE-fE<<G4endl;
+#endif
+    return false;
+  }
+  G4double fM2=fr4Mom.m2();                 // Squared Mass of the Fragment
+  G4double iPx=fr4Mom.px();                 // Initial Px of the Fragment
+  G4double iPy=fr4Mom.py();                 // Initial Py of the Fragment
+  G4double iPz=fr4Mom.pz();                 // Initial Pz of the Fragment
+  G4double fP2=iPx*iPx+iPy*iPy+iPz*iPz;     // Initial Squared 3-momentum of the Fragment
+  G4double finE = fE - corE;                // Final energy of the fragment
+  G4double rP = sqrt((finE*finE-fM2)/fP2);  // Reduction factor for the momentum
+  G4double fPx=iPx*rP;
+  G4double fPy=iPy*rP;
+  G4double fPz=iPz*rP;
+  fr4Mom= G4LorentzVector(fPx,fPy,fPz,finE);
+  G4double Px=theMomentum.px()+iPx-fPx;
+  G4double Py=theMomentum.py()+iPy-fPy;
+  G4double Pz=theMomentum.pz()+iPz-fPz;
+  G4double mE=theMomentum.e();
+  ///////////G4double mM2=theMomentum.m2();
+  theMomentum= G4LorentzVector(Px,Py,Pz,mE+corE);
+#ifdef pdebug
+  G4double difF=fr4Mom.m2()-fM2;
+  G4double difM=theMomentum.m2()-mM2;
+  G4cout<<"G4QHadr::CorEDecayIn2:dmM2="<<difM<<",dfM2="<<difF<<",out:"<<theMomentum<<fr4Mom<<G4endl;
+#endif
+  return true;
+} // End of "CorEDecayIn2"
+
+// Decay of the hadron in 3 particles i=>r+s+t
+G4bool G4QHadron::DecayIn3(G4LorentzVector& f4Mom,G4LorentzVector& s4Mom,G4LorentzVector& t4Mom)
+{//    =========================================================================================
+#ifdef debug
+  G4cout<<"G4QHadron::DecayIn3:"<<theMomentum<<"=>pf="<<f4Mom<<"+ps="<<s4Mom<<"+pt="<<t4Mom<<G4endl;
+#endif
+  G4double iM  = theMomentum.m();  // Mass of the decaying hadron
+  G4double fM  = f4Mom.m();        // Mass of the 1st hadron
+  G4double sM  = s4Mom.m();        // Mass of the 2nd hadron
+  G4double tM  = t4Mom.m();        // Mass of the 3rd hadron
+  if (iM+.001<fM+sM+tM)
+  {
+    G4cerr<<"***G4QHadron::DecayIn3:fM="<<fM<<" + sM="<<sM<<" + tM="<<tM<<" > iM="<<iM<<",d="
+          <<iM-fM-sM-tM<<G4endl;
+    return false;
+  }
+  G4double fM2 = fM*fM;
+  G4double sM2 = sM*sM;
+  G4double tM2 = tM*tM;
+  G4double iM2 = iM*iM;
+  G4double m13sBase=(iM-sM)*(iM-sM)-(fM+tM)*(fM+tM);
+  G4double m12sMin =(fM+sM)*(fM+sM);
+  G4double m12sBase=(iM-tM)*(iM-tM)-m12sMin;
+  G4double rR = 0.;
+  G4double rnd= 1.;
+  /////////////G4int    tr = 0;                 //@@ Comment if "cout" below is skiped @@
+  G4double m12s = 0.;              // Fake definition before the Loop
+  while (rnd > rR)
+  {
+    m12s = m12sMin + m12sBase*G4UniformRand();
+    G4double e1=m12s-fM2-sM2;
+    G4double e2=iM2-m12s-tM2;
+    G4double four12=4*m12s;
+    G4double m13sRange=sqrt((e1*e1-four12*fM2)*(e2*e2-four12*tM2))/m12s;
+    rR = m13sRange/m13sBase;
+    rnd= G4UniformRand();
+#ifdef debug
+    G4cout<<"G4QHadron::DecayIn3: try to decay #"<<++tr<<", rR="<<rR<<", rnd="<<rnd<<G4endl;
+#endif
+  }
+  G4double m12 = sqrt(m12s);       // Mass of the H1+H2 system
+  G4LorentzVector dh4Mom(0.,0.,0.,m12);
+  
+  if(!DecayIn2(t4Mom,dh4Mom))
+  {
+    G4cerr<<"***G4QHadron::DecayIn3: Exception1"<<G4endl;
+	//G4Exception("***G4QHadron::DecayIn3(): DecayIn2 did not succeed");
+    return false;
+  }
+#ifdef debug
+  G4cout<<"G4QHadron::DecayIn3: Now the last decay of m12="<<dh4Mom.m()<<G4endl;
+#endif
+  if(!G4QHadron(dh4Mom).DecayIn2(f4Mom,s4Mom))
+  {
+    G4cerr<<"***G4QHadron::DecayIn3: Exception2"<<G4endl;
+	//G4Exception("G4QHadron::DecayIn3(): DecayIn2 did not succeed");
+    return false;
+  }
+  return true;
+}
+
+// Randomize particle mass taking into account the width
+G4double G4QHadron::RandomizeMass(G4QParticle* pPart, G4double maxM)
+//       ===========================================================
+{
+  G4double meanM = theQPDG.GetMass();
+  G4double width = theQPDG.GetWidth()/2.;
+#ifdef debug
+  G4cout<<"G4QHadron::RandomizeMass: meanM="<<meanM<<", halfWidth="<<width<<G4endl;
+#endif
+  if(maxM<meanM-3*width) 
+  {
+#ifdef debug
+    G4cerr<<"***G4QHadron::RandMass: maxM="<<maxM<<" < meanM="<<meanM<<" - 3*halfW="<<width<<G4endl;
+#endif
+    return 0.;
+  }
+  ///////////////G4double theMass  = 0.;
+  if(width==0.)
+  {
+#ifdef debug
+	if(meanM>maxM) G4cerr<<"***G4QHadron::RandomizeMass:Stable m="<<meanM<<" > maxM="<<maxM<<G4endl;
+#endif
+    return meanM;
+    //return 0.;
+  }
+  else if(width<0.)
+  {
+	G4cerr<<"***G4QHadron::RandomizeMass: width="<<width<<"<0, PDGC="<<theQPDG.GetPDGCode()<<G4endl;
+	G4Exception("G4QHadron::RandomizeMass: width of the Hadron < 0");
+  }
+  G4double minM = pPart->MinMassOfFragm();
+  if(minM>maxM)
+  {
+#ifdef debug
+	G4cerr<<"***G4QHadron::RandomizeMass:for PDG="<<theQPDG.GetPDGCode()<<" minM="<<minM
+          <<" > maxM="<<maxM<<G4endl;
+#endif
+    return 0.;
+  }
+  //Now calculate the Breit-Wigner distribution with two cuts
+  G4double v1=atan((minM-meanM)/width);
+  G4double v2=atan((maxM-meanM)/width);
+  G4double dv=v2-v1;
+#ifdef debug
+  G4cout<<"G4QHadron::RandomizeMass:Mi="<<minM<<",i="<<v1<<",Ma="<<maxM<<",a="<<v2<<","<<dv<<G4endl;
+#endif
+  return meanM+width*tan(v1+dv*G4UniformRand());
+}
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/src/G4QParentCluster.cc

@@ -0,0 +1,105 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QParentCluster.cc,v 1.13 2001/11/26 14:11:46 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QParentCluster ----------------
+//             by Mikhail Kossov, Sept 1999.
+//      class fora Parent nuclear cluster in the CHIPS Model
+// ----------------------------------------------------------
+
+//#define debug
+//#define pdebug
+
+#include "G4QParentClusterVector.hh"
+
+G4QParentCluster::G4QParentCluster(G4int PDGCode): thePDGCode(PDGCode), theProbability(0.){}
+
+G4QParentCluster::G4QParentCluster(G4int PDGCode, G4double prob): 
+  thePDGCode(PDGCode), theProbability(prob){}
+
+G4QParentCluster::G4QParentCluster(const G4QParentCluster& rhs)
+{
+  thePDGCode          = rhs.thePDGCode;
+  theProbability      = rhs.theProbability;
+  nQPart2             = rhs.nQPart2;
+  transQC             = rhs.transQC;
+  lowLimit            = rhs.lowLimit;
+  highLimit           = rhs.highLimit;
+  theEnvBoundedMass   = rhs.theEnvBoundedMass;
+  theEnvBindingEnergy = rhs.theEnvBindingEnergy;
+  theNucBoundedMass   = rhs.theNucBoundedMass;
+  theNucBindingEnergy = rhs.theNucBindingEnergy;
+}
+
+G4QParentCluster::G4QParentCluster(G4QParentCluster* rhs)
+{
+  thePDGCode          = rhs->thePDGCode;
+  theProbability      = rhs->theProbability;
+  nQPart2             = rhs->nQPart2;
+  transQC             = rhs->transQC;
+  lowLimit            = rhs->lowLimit;
+  highLimit           = rhs->highLimit;
+  theEnvBoundedMass   = rhs->theEnvBoundedMass;
+  theEnvBindingEnergy = rhs->theEnvBindingEnergy;
+  theNucBoundedMass   = rhs->theNucBoundedMass;
+  theNucBindingEnergy = rhs->theNucBindingEnergy;
+}
+
+const G4QParentCluster& G4QParentCluster::operator=(const G4QParentCluster& rhs)
+{
+  thePDGCode          = rhs.thePDGCode;
+  theProbability      = rhs.theProbability;
+  nQPart2             = rhs.nQPart2;
+  transQC             = rhs.transQC;
+  lowLimit            = rhs.lowLimit;
+  highLimit           = rhs.highLimit;
+  theEnvBoundedMass   = rhs.theEnvBoundedMass;
+  theEnvBindingEnergy = rhs.theEnvBindingEnergy;
+  theNucBoundedMass   = rhs.theNucBoundedMass;
+  theNucBindingEnergy = rhs.theNucBindingEnergy;
+
+  return *this;
+}
+
+G4QParentCluster::~G4QParentCluster() {}
+
+// Standard output for G4QParentCluster
+G4std::ostream& operator<<(G4std::ostream& lhs, G4QParentCluster& rhs)
+{//      ===============================================
+  lhs << "[ParClPDG=" << rhs.GetPDGCode() << ", probab=" << rhs.GetProbability() << "]";
+  return lhs;
+}
+
+// Standard output for const G4QParentCluster
+G4std::ostream& operator<<(G4std::ostream& lhs, const G4QParentCluster& rhs)
+{//      ===============================================
+  lhs << "[ParClPDG=" << rhs.GetPDGCode() << ", probab=" << rhs.GetProbability() << "]";
+  return lhs;
+}
+
+
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/src/G4QParticle.cc

@@ -0,0 +1,698 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QParticle.cc,v 1.17 2001/11/26 14:11:47 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QParticle ----------------
+//             by Mikhail Kossov, Sept 1999.
+//      class for Particles in the CHIPS Model
+// -------------------------------------------------------------------
+ 
+//#define debug
+//#define pdebug
+
+#include "G4QParticleVector.hh"
+
+G4QParticle::G4QParticle() {}
+
+G4QParticle::G4QParticle(G4int thePDG)
+{
+  aQPDG      = G4QPDGCode(thePDG);
+  aQuarkCont = aQPDG.GetQuarkContent();
+  aDecay     = InitDecayVector(aQPDG.GetQCode());
+}
+
+G4QParticle::G4QParticle(const G4QParticle& right)
+{
+  aQPDG                = right.aQPDG;
+  //aDecay (Vector)
+  G4int nD             = right.aDecay.size(); 
+  if(nD) for(G4int id=0; id<nD; id++)
+  {
+    G4QDecayChan* curD = new G4QDecayChan(right.aDecay[id]);
+    aDecay.push_back(curD);
+  }
+
+  aQuarkCont           = right.aQuarkCont;
+}
+
+G4QParticle::G4QParticle(G4QParticle* right)
+{
+  aQPDG                = right->aQPDG;
+  //aDecay (Vector)
+  G4int nD             = right->aDecay.size();
+  if(nD) for(G4int id=0; id<nD; id++)
+  {
+    G4QDecayChan* curD = new G4QDecayChan(right->aDecay[id]);
+    aDecay.push_back(curD);
+  }
+
+  aQuarkCont           = right->aQuarkCont;
+}
+
+G4QParticle::~G4QParticle() 
+{
+  G4std::for_each(aDecay.begin(), aDecay.end(), DeleteQDecayChan());
+}
+
+// Assignment operator
+const G4QParticle& G4QParticle::operator=(const G4QParticle &right)
+{
+  aQPDG                = right.aQPDG;
+  //aDecay (Vector)
+  G4int nD             = right.aDecay.size();
+  if(nD) for(G4int id=0; id<nD; id++)
+  {
+    G4QDecayChan* curD = new G4QDecayChan(right.aDecay[id]);
+    aDecay.push_back(curD);
+  }
+
+  aQuarkCont           = right.aQuarkCont;
+
+  return *this;
+}
+
+// Standard output for QParticle
+G4std::ostream& operator<<(G4std::ostream& lhs, G4QParticle& rhs)
+//       =========================================
+{
+  G4QPDGCode rhsQPDG = rhs.GetQPDG();
+  lhs << G4endl << "Particle with PDG=" << rhsQPDG << ", Spin=" << rhs.GetSpin()
+      << ", mass=" << rhs.GetMass() << ", width=" << rhs.GetWidth() << G4endl;
+  lhs << " Quark Content of the Particle=" << rhs.GetQContent() << ", Decay Channels:" << G4endl;
+  G4QDecayChanVector DCV = rhs.GetDecayVector();
+  G4int n = DCV.size();
+  for (int i=0; i<n; i++)
+  {
+    lhs << DCV[i]->GetDecayChanLimit() << "PDG codes";
+    G4QPDGCodeVector PCV=DCV[i]->GetVecOfSecHadrons();
+    G4int m = PCV.size();
+    for (int j=0; j<m; j++)
+    {
+      if(!j) lhs << ":";
+      else   lhs << ",";
+      lhs << PCV[j]->GetPDGCode() ;
+	}
+  }
+  return lhs;
+}
+
+// Initialize the PDG-Particle by QCode @@ Can be improved, using PDG.DATA file
+G4QDecayChanVector G4QParticle::InitDecayVector(G4int nQ)
+//    ===================================================
+{
+  //static G4int nP = 486;                  // Up to A=80
+  static G4int nP = 494;                  // Up to A=80 "Isonuclear revision"
+  static G4QDecayChanVector* DecayDB = new G4QDecayChanVector[nP];
+  static int limit= 0;
+  if(nQ>=limit && nQ<nP)
+  {
+    // *** Secondary PDG-particles should be ordered in a Channel by increasing width ***!!!***
+    // *** Channels should be ordered by increasing minimum mass of the secondary particles ***
+    //if(limit<=  0 && nQ>=  0)DecayDB[  0] = NULL;    // gamma
+    if(limit<=  1 && nQ>=  1)    // Low sigma=pi,pi S-wave : f_0 (800)
+	{
+      DecayDB[  1].push_back(new G4QDecayChan(.333,211,-211));
+      DecayDB[  1].push_back(new G4QDecayChan(1.00,111, 111));
+	}
+    if(limit<=  2 && nQ>=  2)    // Midle Regeon-Pomeron   : f_0 (980)
+	{
+      DecayDB[  2].push_back(new G4QDecayChan(.333,211,-211));
+      DecayDB[  2].push_back(new G4QDecayChan(1.00,111, 111));
+	}
+    if(limit<=  3 && nQ>=  3)    // High Regeon-Pomeron    : f_0 (1500)
+	{
+      DecayDB[  3].push_back(new G4QDecayChan(.300,221, 331));
+      DecayDB[  3].push_back(new G4QDecayChan(.600,221, 221));
+      DecayDB[  3].push_back(new G4QDecayChan(.650,311,-311));
+      DecayDB[  3].push_back(new G4QDecayChan(.700,321,-321));
+      DecayDB[  3].push_back(new G4QDecayChan(.800,211,-211));
+      DecayDB[  3].push_back(new G4QDecayChan(1.00,111, 111));
+	}
+    //if(limit<=  4 && nQ>=  4)DecayDB[  4].push_back(new G4QDecayChan(1.00, 22,  22));//Pi 0
+    //if(limit<=  5 && nQ>=  5)DecayDB[  5] = NULL;    // Pi +
+    if(limit<=  6 && nQ>=  6)    // eta
+	{
+      DecayDB[  6].push_back(new G4QDecayChan(.231,211,-211,111));
+      DecayDB[  6].push_back(new G4QDecayChan(.553,111, 111,111));
+      DecayDB[  6].push_back(new G4QDecayChan(.603,211,-211, 22));
+      DecayDB[  6].push_back(new G4QDecayChan(1.00, 22,  22));
+	}
+    //if(limit<=  7 && nQ>=  7)    // K 0 (K_short - probab 1/2) @@@@@@@@@@@@
+	//{
+    //  DecayDB[  7].push_back(new G4QDecayChan(.6861,211,-211));
+    //  DecayDB[  7].push_back(new G4QDecayChan(1.00, 111, 111));
+	//}
+    //if(limit<=  8 && nQ>=  8)DecayDB[  8] = NULL;    // K +
+    if(limit<=  9 && nQ>=  9)    // eta'
+	{
+      DecayDB[  9].push_back(new G4QDecayChan(.438,211,-211,221));
+      DecayDB[  9].push_back(new G4QDecayChan(.645,111, 111,221));
+      DecayDB[  9].push_back(new G4QDecayChan(.675, 22, 223));
+      DecayDB[  9].push_back(new G4QDecayChan(.677,111, 111,111));
+      DecayDB[  9].push_back(new G4QDecayChan(.979, 22, 113));
+      DecayDB[  9].push_back(new G4QDecayChan(1.00, 22,  22));
+	}
+    //if(limit<= 10 && nQ>= 10)DecayDB[ 10] = NULL;    // n
+    //if(limit<= 11 && nQ>= 11)DecayDB[ 11] = NULL;    // p
+    //if(limit<= 12 && nQ>= 12)    // Lambda ===>>> all week decays are closed at this time
+	//{
+    //  DecayDB[ 12].push_back(new G4QDecayChan(.640,2212,-211));
+    //  DecayDB[ 12].push_back(new G4QDecayChan(1.00,2112, 111));
+	//}
+    //if(limit<= 13 && nQ>= 13)DecayDB[ 13].push_back(new G4QDecayChan(1.00,2112,-211)); // Sigma -
+    if(limit<= 14 && nQ>= 14)DecayDB[ 14].push_back(new G4QDecayChan(1.00,3122,  22));//Sigma 0(EM)
+    //if(limit<= 15 && nQ>= 15)    // Sigma +
+	//{
+    //  DecayDB[ 15].push_back(new G4QDecayChan(.484,2112, 211));
+    //  DecayDB[ 15].push_back(new G4QDecayChan(1.00,2212, 111));
+	//}
+    //if(limit<= 16 && nQ>= 16)DecayDB[ 16].push_back(new G4QDecayChan(1.00,3122,-211));   // Ksi -
+    //if(limit<= 17 && nQ>= 17)DecayDB[ 17].push_back(new G4QDecayChan(1.00,3122, 111));   // Ksi 0
+    if(limit<= 18 && nQ>= 18)DecayDB[ 18].push_back(new G4QDecayChan(1.00, 211,-211));   // rho 0
+    if(limit<= 19 && nQ>= 19)DecayDB[ 19].push_back(new G4QDecayChan(1.00, 211, 111));   // rho +
+    if(limit<= 20 && nQ>= 20)    // omega
+	{
+      DecayDB[ 20].push_back(new G4QDecayChan(.892, 211,-211,111));
+      DecayDB[ 20].push_back(new G4QDecayChan(.914, 211,-211));
+      DecayDB[ 20].push_back(new G4QDecayChan(1.00,  22, 111));
+	}
+    if(limit<= 21 && nQ>= 21)    // K* 0
+	{
+      DecayDB[ 21].push_back(new G4QDecayChan(.667,-211, 321));
+      DecayDB[ 21].push_back(new G4QDecayChan(1.00, 111, 311));
+	}
+    if(limit<= 22 && nQ>= 22)    // K* +
+	{
+      DecayDB[ 22].push_back(new G4QDecayChan(.667, 211, 311));
+      DecayDB[ 22].push_back(new G4QDecayChan(1.00, 111, 321));
+	}
+    if(limit<= 23 && nQ>= 23)    // phi
+	{
+      DecayDB[ 23].push_back(new G4QDecayChan(.341, 311,-311));
+      DecayDB[ 23].push_back(new G4QDecayChan(.832, 321,-321));
+      DecayDB[ 23].push_back(new G4QDecayChan(.850,  22, 221));
+      DecayDB[ 23].push_back(new G4QDecayChan(.900, 211,-213));
+      DecayDB[ 23].push_back(new G4QDecayChan(.950,-211, 213));
+      DecayDB[ 23].push_back(new G4QDecayChan(1.00, 111, 113));
+	}
+    if(limit<= 24 && nQ>= 24)DecayDB[ 24].push_back(new G4QDecayChan(1.00,2112,-211)); // Delta -
+    if(limit<= 25 && nQ>= 25)    // Delta 0
+	{
+      DecayDB[ 25].push_back(new G4QDecayChan(.333,2212,-211));
+      DecayDB[ 25].push_back(new G4QDecayChan(1.00,2112, 111));
+	}
+    if(limit<= 26 && nQ>= 26)    // Delta +
+	{
+      DecayDB[ 26].push_back(new G4QDecayChan(.333,2112, 211));
+      DecayDB[ 26].push_back(new G4QDecayChan(1.00,2212, 111));
+	}
+    if(limit<= 27 && nQ>= 27)DecayDB[ 27].push_back(new G4QDecayChan(1.00,2212, 211)); // Delta ++
+    if(limit<= 28 && nQ>= 28)    // Lambda* (1520)
+	{
+      DecayDB[ 28].push_back(new G4QDecayChan(.230,3112,-311));
+      DecayDB[ 28].push_back(new G4QDecayChan(.460,3222,-321));
+      DecayDB[ 28].push_back(new G4QDecayChan(.463,3112,211,111));
+      DecayDB[ 28].push_back(new G4QDecayChan(.466,3212,211,-211));
+      DecayDB[ 28].push_back(new G4QDecayChan(.467,3212,111,111));
+      DecayDB[ 28].push_back(new G4QDecayChan(.470,3222,-211,111));
+      DecayDB[ 28].push_back(new G4QDecayChan(.540,3122,211,-211));
+      DecayDB[ 28].push_back(new G4QDecayChan(.570,3122,111,111));
+      DecayDB[ 28].push_back(new G4QDecayChan(.710,3222,-211));
+      DecayDB[ 28].push_back(new G4QDecayChan(.850,3212, 111));
+      DecayDB[ 28].push_back(new G4QDecayChan(.990,3112, 211));
+      DecayDB[ 28].push_back(new G4QDecayChan(1.00,3122,  22));
+	}
+    if(limit<= 29 && nQ>= 29)    // Sigma* -
+	{
+      DecayDB[ 29].push_back(new G4QDecayChan(.060,3112, 111));
+      DecayDB[ 29].push_back(new G4QDecayChan(.120,3212,-211));
+      DecayDB[ 29].push_back(new G4QDecayChan(1.00,3122,-211));
+	}
+    if(limit<= 30 && nQ>= 30)    // Sigma* 0
+	{
+      DecayDB[ 30].push_back(new G4QDecayChan(.040,3112, 211));
+      DecayDB[ 30].push_back(new G4QDecayChan(.080,3222,-211));
+      DecayDB[ 30].push_back(new G4QDecayChan(.120,3212, 111));
+      DecayDB[ 30].push_back(new G4QDecayChan(1.00,3122, 111));
+	}
+    if(limit<= 31 && nQ>= 31)    // Sigma* +
+	{
+      DecayDB[ 31].push_back(new G4QDecayChan(.060,3212, 211));
+      DecayDB[ 31].push_back(new G4QDecayChan(.120,3222, 111));
+      DecayDB[ 31].push_back(new G4QDecayChan(1.00,3122, 211));
+	}
+    if(limit<= 32 && nQ>= 32)    // Ksi* -
+	{
+      DecayDB[ 32].push_back(new G4QDecayChan(.667,3322,-211));
+      DecayDB[ 32].push_back(new G4QDecayChan(1.00,3312, 111));
+	}
+    if(limit<= 33 && nQ>= 33)    // Ksi* 0
+	{
+      DecayDB[ 33].push_back(new G4QDecayChan(.667,3312, 211));
+      DecayDB[ 33].push_back(new G4QDecayChan(1.00,3322, 111));
+	}
+    //if(limit<= 34 && nQ>= 34)    // OMEGA - (Weak)
+	//{
+    //  DecayDB[ 34].push_back(new G4QDecayChan(.678,3122, 321));
+    //  DecayDB[ 34].push_back(new G4QDecayChan(.914,3322,-211));
+    //  DecayDB[ 34].push_back(new G4QDecayChan(1.00,3312, 111));
+	//}
+    if(limit<= 35 && nQ>= 35)    // a_2 0
+	{
+      DecayDB[ 35].push_back(new G4QDecayChan(.068, 211,-211,223));
+      DecayDB[ 35].push_back(new G4QDecayChan(.102, 111, 111,223));
+      DecayDB[ 35].push_back(new G4QDecayChan(.126, 321,-321));
+      DecayDB[ 35].push_back(new G4QDecayChan(.150, 311,-311));
+      DecayDB[ 35].push_back(new G4QDecayChan(.298, 111, 221));
+      DecayDB[ 35].push_back(new G4QDecayChan(.532,-211, 213));
+      DecayDB[ 35].push_back(new G4QDecayChan(.766, 211,-213));
+      DecayDB[ 35].push_back(new G4QDecayChan(1.00, 111, 113));
+	}
+    if(limit<= 36 && nQ>= 36)    // a_2 +
+	{
+      DecayDB[ 36].push_back(new G4QDecayChan(.102,111,211,223));
+      DecayDB[ 36].push_back(new G4QDecayChan(.150, 321,-311));
+      DecayDB[ 36].push_back(new G4QDecayChan(.298, 211, 221));
+      DecayDB[ 36].push_back(new G4QDecayChan(.649, 211, 113));
+      DecayDB[ 36].push_back(new G4QDecayChan(1.00, 111, 213));
+	}
+    if(limit<= 37 && nQ>= 37)    // f_2 0
+	{
+      DecayDB[ 37].push_back(new G4QDecayChan(.005, 221, 221));
+      DecayDB[ 37].push_back(new G4QDecayChan(.028, 311,-311));
+      DecayDB[ 37].push_back(new G4QDecayChan(.051, 321,-321));
+      DecayDB[ 37].push_back(new G4QDecayChan(.123, 111, 113));
+      DecayDB[ 37].push_back(new G4QDecayChan(.126, 111, 221));
+      DecayDB[ 37].push_back(new G4QDecayChan(.154, 211,-211,113));
+      DecayDB[ 37].push_back(new G4QDecayChan(.718, 211,-211));
+      DecayDB[ 37].push_back(new G4QDecayChan(1.00, 111, 111));
+	}
+    if(limit<= 38 && nQ>= 38)    // K_2 0
+	{
+      DecayDB[ 38].push_back(new G4QDecayChan(.028, 311, 223));
+      DecayDB[ 38].push_back(new G4QDecayChan(.074, 211,-211,313));
+      DecayDB[ 38].push_back(new G4QDecayChan(.143,111,-211,323));
+      DecayDB[ 38].push_back(new G4QDecayChan(.166,111, 111,313));
+      DecayDB[ 38].push_back(new G4QDecayChan(.190,-211, 323));
+      DecayDB[ 38].push_back(new G4QDecayChan(.314, 111, 313));
+      DecayDB[ 38].push_back(new G4QDecayChan(.357, 311, 113));
+      DecayDB[ 38].push_back(new G4QDecayChan(.500, 321,-213));
+      DecayDB[ 38].push_back(new G4QDecayChan(.750,-211, 321));
+      DecayDB[ 38].push_back(new G4QDecayChan(1.00, 111, 311));
+	}
+    if(limit<= 39 && nQ>= 39)    // K_2 +
+	{
+      DecayDB[ 39].push_back(new G4QDecayChan(.028, 321, 223));
+      DecayDB[ 39].push_back(new G4QDecayChan(.074,211,-211,323));
+      DecayDB[ 39].push_back(new G4QDecayChan(.143,111, 211,313));
+      DecayDB[ 39].push_back(new G4QDecayChan(.166,111, 111,323));
+      DecayDB[ 39].push_back(new G4QDecayChan(.190, 211, 313));
+      DecayDB[ 39].push_back(new G4QDecayChan(.314, 111, 323));
+      DecayDB[ 39].push_back(new G4QDecayChan(.357, 311, 213));
+      DecayDB[ 39].push_back(new G4QDecayChan(.500, 321, 113));
+      DecayDB[ 39].push_back(new G4QDecayChan(.750, 211, 311));
+      DecayDB[ 39].push_back(new G4QDecayChan(1.00, 111, 321));
+	}
+    if(limit<= 40 && nQ>= 40)    // f_2' 0
+	{
+      DecayDB[ 40].push_back(new G4QDecayChan(.103, 221, 221));
+      DecayDB[ 40].push_back(new G4QDecayChan(.547, 311,-311));
+      DecayDB[ 40].push_back(new G4QDecayChan(.991, 321,-321));
+      DecayDB[ 40].push_back(new G4QDecayChan(.997, 211,-211));
+      DecayDB[ 40].push_back(new G4QDecayChan(1.00, 111, 111));
+	}
+    if(limit<= 41 && nQ>= 41)    // N_5/2 0
+	{
+      DecayDB[ 41].push_back(new G4QDecayChan(.040, 211, 1114));
+      DecayDB[ 41].push_back(new G4QDecayChan(.080, 111, 2114));
+      DecayDB[ 41].push_back(new G4QDecayChan(.120,-211, 2214));
+      DecayDB[ 41].push_back(new G4QDecayChan(.180, 2112, 113));
+      DecayDB[ 41].push_back(new G4QDecayChan(.210, 2212,-213));
+      DecayDB[ 41].push_back(new G4QDecayChan(.340, 2112, 110));
+      DecayDB[ 41].push_back(new G4QDecayChan(.780, 2212,-211));
+      DecayDB[ 41].push_back(new G4QDecayChan(1.00, 2112, 111));
+	}
+    if(limit<= 42 && nQ>= 42)    // N_5/2 +
+	{
+      DecayDB[ 42].push_back(new G4QDecayChan(.040,-211, 2224));
+      DecayDB[ 42].push_back(new G4QDecayChan(.080, 211, 2114));
+      DecayDB[ 42].push_back(new G4QDecayChan(.120, 111, 2214));
+      DecayDB[ 42].push_back(new G4QDecayChan(.180, 2112, 213));
+      DecayDB[ 42].push_back(new G4QDecayChan(.210, 2212, 113));
+      DecayDB[ 42].push_back(new G4QDecayChan(.340, 2212, 229));
+      DecayDB[ 42].push_back(new G4QDecayChan(.780, 2112, 211));
+      DecayDB[ 42].push_back(new G4QDecayChan(1.00, 2212, 111));
+	}
+    if(limit<= 43 && nQ>= 43)    // LAMBDA_5/2
+	{
+      DecayDB[ 43].push_back(new G4QDecayChan(.350, 2112,-311));
+      DecayDB[ 43].push_back(new G4QDecayChan(.700, 2212,-321));
+      DecayDB[ 43].push_back(new G4QDecayChan(.740, 211, 3114));
+      DecayDB[ 43].push_back(new G4QDecayChan(.780,-211, 3224));
+      DecayDB[ 43].push_back(new G4QDecayChan(.820, 111, 3214));
+      DecayDB[ 43].push_back(new G4QDecayChan(.880, 3112, 211));
+      DecayDB[ 43].push_back(new G4QDecayChan(.940, 3222,-211));
+      DecayDB[ 43].push_back(new G4QDecayChan(1.00, 3212, 111));
+	}
+    if(limit<= 44 && nQ>= 44)    // SIGMA_5/2 -
+	{
+      DecayDB[ 44].push_back(new G4QDecayChan(.600, 2112,-321));
+      DecayDB[ 44].push_back(new G4QDecayChan(.660,-211, 3214));
+      DecayDB[ 44].push_back(new G4QDecayChan(.720, 111, 3114));
+      DecayDB[ 44].push_back(new G4QDecayChan(.810, 3212,-211));
+      DecayDB[ 44].push_back(new G4QDecayChan(.900, 3112, 111));
+      DecayDB[ 44].push_back(new G4QDecayChan(1.00, 3122,-211));
+	}
+    if(limit<= 45 && nQ>= 45)    // SIGMA_5/2 0
+	{
+      DecayDB[ 45].push_back(new G4QDecayChan(.300, 2112,-311));
+      DecayDB[ 45].push_back(new G4QDecayChan(.600, 2212,-321));
+      DecayDB[ 45].push_back(new G4QDecayChan(.640, 211, 3114));
+      DecayDB[ 45].push_back(new G4QDecayChan(.680,-211, 3224));
+      DecayDB[ 45].push_back(new G4QDecayChan(.720, 111, 3214));
+      DecayDB[ 45].push_back(new G4QDecayChan(.780, 3112, 211));
+      DecayDB[ 45].push_back(new G4QDecayChan(.840, 3222,-211));
+      DecayDB[ 45].push_back(new G4QDecayChan(.900, 3212, 111));
+      DecayDB[ 45].push_back(new G4QDecayChan(1.00, 3122, 111));
+	}
+    if(limit<= 46 && nQ>= 46)    // SIGMA_5/2 +
+	{
+      DecayDB[ 46].push_back(new G4QDecayChan(.600, 2212,-311));
+      DecayDB[ 46].push_back(new G4QDecayChan(.660, 211, 3214));
+      DecayDB[ 46].push_back(new G4QDecayChan(.720, 111, 3224));
+      DecayDB[ 46].push_back(new G4QDecayChan(.810, 3212, 211));
+      DecayDB[ 46].push_back(new G4QDecayChan(.900, 3222, 111));
+      DecayDB[ 46].push_back(new G4QDecayChan(1.00, 3122, 211));
+	}
+    if(limit<= 47 && nQ>= 47)    // KSI_5/2 -
+	{
+      DecayDB[ 47].push_back(new G4QDecayChan(.400, 3112,-311));
+      DecayDB[ 47].push_back(new G4QDecayChan(.800, 3212,-321));
+      DecayDB[ 47].push_back(new G4QDecayChan(1.00, 3122,-321));
+	}
+    if(limit<= 48 && nQ>= 48)    // KSI_5/2 0
+	{
+      DecayDB[ 48].push_back(new G4QDecayChan(.400, 3212,-311));
+      DecayDB[ 48].push_back(new G4QDecayChan(.800, 3222,-321));
+      DecayDB[ 48].push_back(new G4QDecayChan(1.00, 3122,-311));
+	}
+    if(limit<= 49 && nQ>= 49)    // rho_3 0
+	{
+      DecayDB[ 49].push_back(new G4QDecayChan(.019,311,-313));
+      DecayDB[ 49].push_back(new G4QDecayChan(.038,321,-323));
+      DecayDB[ 49].push_back(new G4QDecayChan(.046,311,-311));
+      DecayDB[ 49].push_back(new G4QDecayChan(.054,321,-321));
+      DecayDB[ 49].push_back(new G4QDecayChan(.224,111, 223));
+      DecayDB[ 49].push_back(new G4QDecayChan(.404,111,-211,213));
+      DecayDB[ 49].push_back(new G4QDecayChan(.584,111, 211,-213));
+      DecayDB[ 49].push_back(new G4QDecayChan(.764,111, 111,113));
+      DecayDB[ 49].push_back(new G4QDecayChan(1.00,211,-211));
+	}
+    if(limit<= 50 && nQ>= 50)    // rho_3 +
+	{
+      DecayDB[ 50].push_back(new G4QDecayChan(.019, 321,-313));
+      DecayDB[ 50].push_back(new G4QDecayChan(.038,-311, 323));
+      DecayDB[ 50].push_back(new G4QDecayChan(.054, 321,-311));
+      DecayDB[ 50].push_back(new G4QDecayChan(.224, 211, 223));
+      DecayDB[ 50].push_back(new G4QDecayChan(.404,211,-211,213));
+      DecayDB[ 50].push_back(new G4QDecayChan(.584,211,211,-213));
+      DecayDB[ 50].push_back(new G4QDecayChan(.764,211,111,113));
+      DecayDB[ 50].push_back(new G4QDecayChan(1.00, 211, 111));
+	}
+    if(limit<= 51 && nQ>= 51)    // omega_3
+	{
+      DecayDB[ 51].push_back(new G4QDecayChan(.020,211,-211,223));
+      DecayDB[ 51].push_back(new G4QDecayChan(.040,111, 111,223));
+      DecayDB[ 51].push_back(new G4QDecayChan(.060, 211,-213));
+      DecayDB[ 51].push_back(new G4QDecayChan(.080,-211, 213));
+      DecayDB[ 51].push_back(new G4QDecayChan(1.00, 111, 113));
+	}
+    if(limit<= 52 && nQ>= 52)    // K_3 0
+	{
+      DecayDB[ 52].push_back(new G4QDecayChan(.030, 111, 315));
+      DecayDB[ 52].push_back(new G4QDecayChan(.060,-211, 325));
+      DecayDB[ 52].push_back(new G4QDecayChan(.340, 311, 331));
+      DecayDB[ 52].push_back(new G4QDecayChan(.400, 111, 313));
+      DecayDB[ 52].push_back(new G4QDecayChan(.520,-211, 323));
+      DecayDB[ 52].push_back(new G4QDecayChan(.620, 311, 113));
+      DecayDB[ 52].push_back(new G4QDecayChan(.820, 321,-213));
+      DecayDB[ 52].push_back(new G4QDecayChan(.940,-211, 321));
+      DecayDB[ 52].push_back(new G4QDecayChan(1.00, 111, 311));
+	}
+    if(limit<= 53 && nQ>= 53)    // K_3 +
+	{
+      DecayDB[ 53].push_back(new G4QDecayChan(.030, 211, 315));
+      DecayDB[ 53].push_back(new G4QDecayChan(.060, 111, 325));
+      DecayDB[ 53].push_back(new G4QDecayChan(.340, 321, 331));
+      DecayDB[ 53].push_back(new G4QDecayChan(.400, 211, 313));
+      DecayDB[ 53].push_back(new G4QDecayChan(.520, 111, 323));
+      DecayDB[ 53].push_back(new G4QDecayChan(.620, 311, 213));
+      DecayDB[ 53].push_back(new G4QDecayChan(.820, 321, 113));
+      DecayDB[ 53].push_back(new G4QDecayChan(.940, 211, 311));
+      DecayDB[ 53].push_back(new G4QDecayChan(1.00, 111, 321));
+	}
+    if(limit<= 54 && nQ>= 54)    // phi_3
+	{
+      DecayDB[ 54].push_back(new G4QDecayChan(.250, 321,-321));
+      DecayDB[ 54].push_back(new G4QDecayChan(.500, 311,-311));
+      DecayDB[ 54].push_back(new G4QDecayChan(.625, 321,-323));
+      DecayDB[ 54].push_back(new G4QDecayChan(.750,-321, 323));
+      DecayDB[ 54].push_back(new G4QDecayChan(.875, 311,-313));
+      DecayDB[ 54].push_back(new G4QDecayChan(1.00,-311, 313));
+	}
+    if(limit<= 55 && nQ>= 55)    // DELTA_7/2 -
+	{
+      DecayDB[ 55].push_back(new G4QDecayChan(.200, 2112,-213 ));
+      DecayDB[ 55].push_back(new G4QDecayChan(.320,-211 , 2114));
+      DecayDB[ 55].push_back(new G4QDecayChan(.500, 111 , 1114));
+      DecayDB[ 55].push_back(new G4QDecayChan(1.00, 2112,-211 ));
+	}
+    if(limit<= 56 && nQ>= 56)    // DELTA_7/2 0
+	{
+      DecayDB[ 56].push_back(new G4QDecayChan(.133, 2112, 113 ));
+      DecayDB[ 56].push_back(new G4QDecayChan(.200, 2212,-213 ));
+      DecayDB[ 56].push_back(new G4QDecayChan(.360,-211 , 2214));
+      DecayDB[ 56].push_back(new G4QDecayChan(.480, 211 , 1114));
+      DecayDB[ 56].push_back(new G4QDecayChan(.500, 111 , 2114));
+      DecayDB[ 56].push_back(new G4QDecayChan(.666, 2212,-211 ));
+      DecayDB[ 56].push_back(new G4QDecayChan(1.00, 2112, 111 ));
+	}
+    if(limit<= 57 && nQ>= 57)    // DELTA_7/2 +
+	{
+      DecayDB[ 57].push_back(new G4QDecayChan(.133, 2112, 213 ));
+      DecayDB[ 57].push_back(new G4QDecayChan(.200, 2212, 113 ));
+      DecayDB[ 57].push_back(new G4QDecayChan(.360,-211 , 2224));
+      DecayDB[ 57].push_back(new G4QDecayChan(.480, 211 , 2114));
+      DecayDB[ 57].push_back(new G4QDecayChan(.500, 111 , 2214));
+      DecayDB[ 57].push_back(new G4QDecayChan(.666, 2112, 211 ));
+      DecayDB[ 57].push_back(new G4QDecayChan(1.00, 2212, 111 ));
+	}
+    if(limit<= 58 && nQ>= 58)    // DELTA_7/2 ++
+	{
+      DecayDB[ 58].push_back(new G4QDecayChan(.200, 2212, 213 ));
+      DecayDB[ 58].push_back(new G4QDecayChan(.320, 211 , 2214));
+      DecayDB[ 58].push_back(new G4QDecayChan(.500, 111 , 2224));
+      DecayDB[ 58].push_back(new G4QDecayChan(1.00, 2212, 211 ));
+	}
+    if(limit<= 59 && nQ>= 59)     // LAMBDA_7/2
+	{
+      DecayDB[ 59].push_back(new G4QDecayChan(.160, 3122, 223 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.260, 2112,-313 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.360, 2212,-323 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.400, 3312, 321 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.440, 3322, 311 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.480, 3122, 221 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.520, 2112,-311 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.560, 2212,-321 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.600, 3112, 211 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(.800, 3222,-211 ));
+      DecayDB[ 59].push_back(new G4QDecayChan(1.00, 3212, 111 ));
+	}
+    if(limit<= 60 && nQ>= 60)    // SIGMA_7/2 -
+	{
+      DecayDB[ 60].push_back(new G4QDecayChan(.030, 2112,-323 ));
+      DecayDB[ 60].push_back(new G4QDecayChan(.165,-311 , 1114));
+      DecayDB[ 60].push_back(new G4QDecayChan(.210,-321 , 2114));
+      DecayDB[ 60].push_back(new G4QDecayChan(.390,-211 , 3124));
+      DecayDB[ 60].push_back(new G4QDecayChan(.450,-211 , 3214));
+      DecayDB[ 60].push_back(new G4QDecayChan(.510, 111 , 3114));
+      DecayDB[ 60].push_back(new G4QDecayChan(.540, 311 , 3314));
+      DecayDB[ 60].push_back(new G4QDecayChan(.570,-211 , 3212));
+      DecayDB[ 60].push_back(new G4QDecayChan(.600, 111 , 3112));
+      DecayDB[ 60].push_back(new G4QDecayChan(.780,-321 , 2112));
+      DecayDB[ 60].push_back(new G4QDecayChan(1.00,-211 , 3122));
+	}
+    if(limit<= 61 && nQ>= 61)    // SIGMA_7/2 0
+	{
+      DecayDB[ 61].push_back(new G4QDecayChan(.015, 2112,-313 ));
+      DecayDB[ 61].push_back(new G4QDecayChan(.030, 2212,-321 ));
+      DecayDB[ 61].push_back(new G4QDecayChan(.120,-311 , 2114));
+      DecayDB[ 61].push_back(new G4QDecayChan(.210,-321 , 2214));
+      DecayDB[ 61].push_back(new G4QDecayChan(.390, 111 , 3124));
+      DecayDB[ 61].push_back(new G4QDecayChan(.450,-211 , 3224));
+      DecayDB[ 61].push_back(new G4QDecayChan(.510, 211 , 3114));
+      DecayDB[ 61].push_back(new G4QDecayChan(.525, 311 , 3324));
+      DecayDB[ 61].push_back(new G4QDecayChan(.540, 321 , 3314));
+      DecayDB[ 61].push_back(new G4QDecayChan(.570,-211 , 3222));
+      DecayDB[ 61].push_back(new G4QDecayChan(.600, 211 , 3112));
+      DecayDB[ 61].push_back(new G4QDecayChan(.690,-311 , 2112));
+      DecayDB[ 61].push_back(new G4QDecayChan(.780,-321 , 2212));
+      DecayDB[ 61].push_back(new G4QDecayChan(1.00, 111 , 3122));
+	}
+    if(limit<= 62 && nQ>= 62)    // SIGMA_7/2 +
+	{
+      DecayDB[ 62].push_back(new G4QDecayChan(.030, 2212,-313 ));
+      DecayDB[ 62].push_back(new G4QDecayChan(.165,-321 , 2224));
+      DecayDB[ 62].push_back(new G4QDecayChan(.210,-311 , 2214));
+      DecayDB[ 62].push_back(new G4QDecayChan(.390, 211 , 3124));
+      DecayDB[ 62].push_back(new G4QDecayChan(.450, 211 , 3214));
+      DecayDB[ 62].push_back(new G4QDecayChan(.510, 111 , 3224));
+      DecayDB[ 62].push_back(new G4QDecayChan(.540, 321 , 3324));
+      DecayDB[ 62].push_back(new G4QDecayChan(.570, 211 , 3212));
+      DecayDB[ 62].push_back(new G4QDecayChan(.600, 111 , 3222));
+      DecayDB[ 62].push_back(new G4QDecayChan(.780,-311 , 2212));
+      DecayDB[ 62].push_back(new G4QDecayChan(1.00, 211 , 3122));
+	}
+    if(limit<= 63 && nQ>= 63)    // KSI_7/2 -
+	{
+      DecayDB[ 63].push_back(new G4QDecayChan(.400, 3112,-311));
+      DecayDB[ 63].push_back(new G4QDecayChan(.800, 3212,-321));
+      DecayDB[ 63].push_back(new G4QDecayChan(1.00, 3122,-321));
+	}
+    if(limit<= 64 && nQ>= 64)    // KSI_7/2 0
+	{
+      DecayDB[ 64].push_back(new G4QDecayChan(.400, 3212,-311));
+      DecayDB[ 64].push_back(new G4QDecayChan(.800, 3222,-321));
+      DecayDB[ 64].push_back(new G4QDecayChan(1.00, 3122,-311));
+	}
+    if(limit<= 65 && nQ>= 65)    // OMEGA_7/2 -
+	{
+      DecayDB[ 65].push_back(new G4QDecayChan(.250,-311 , 3314));
+      DecayDB[ 65].push_back(new G4QDecayChan(.500,-321 , 3324));
+      DecayDB[ 65].push_back(new G4QDecayChan(.750, 3312,-313 ));
+      DecayDB[ 65].push_back(new G4QDecayChan(1.00, 3322,-323 ));
+	}
+    if(limit<= 66 && nQ>= 66)    // a_4 0
+	{
+      DecayDB[ 66].push_back(new G4QDecayChan(.200, 311,-311));
+      DecayDB[ 66].push_back(new G4QDecayChan(.400, 321,-321));
+      DecayDB[ 66].push_back(new G4QDecayChan(.600, 111, 221));
+      DecayDB[ 66].push_back(new G4QDecayChan(1.00, 111, 211,-211));
+	}
+    if(limit<= 67 && nQ>= 67)    // a_4 +
+	{
+      DecayDB[ 67].push_back(new G4QDecayChan(.400, 321,-311));
+      DecayDB[ 67].push_back(new G4QDecayChan(.600, 211, 221));
+      DecayDB[ 67].push_back(new G4QDecayChan(.800, 211, 211,-211));
+      DecayDB[ 67].push_back(new G4QDecayChan(1.00, 211, 111, 111));
+	}
+    if(limit<= 68 && nQ>= 68)    // f_4 0
+	{
+      DecayDB[ 68].push_back(new G4QDecayChan(.020, 333, 333));
+      DecayDB[ 68].push_back(new G4QDecayChan(.340, 223, 223));
+      DecayDB[ 68].push_back(new G4QDecayChan(.350, 221, 221));
+      DecayDB[ 68].push_back(new G4QDecayChan(.360, 311,-311));
+      DecayDB[ 68].push_back(new G4QDecayChan(.370, 321,-321));
+      DecayDB[ 68].push_back(new G4QDecayChan(.670, 213,-213));
+      DecayDB[ 68].push_back(new G4QDecayChan(.820, 113, 113));
+      DecayDB[ 68].push_back(new G4QDecayChan(.940, 211,-211));
+      DecayDB[ 68].push_back(new G4QDecayChan(1.00, 111, 111));
+	}
+    if(limit<= 69 && nQ>= 69)    // K_4 0
+	{
+      DecayDB[ 69].push_back(new G4QDecayChan(.060, 333, 313));
+      DecayDB[ 69].push_back(new G4QDecayChan(.260, 223, 313));
+      DecayDB[ 69].push_back(new G4QDecayChan(.380, 313, 113));
+      DecayDB[ 69].push_back(new G4QDecayChan(.400, 323,-213));
+      DecayDB[ 69].push_back(new G4QDecayChan(.500, 223, 311));
+      DecayDB[ 69].push_back(new G4QDecayChan(.550, 311, 113));
+      DecayDB[ 69].push_back(new G4QDecayChan(.600, 321,-213));
+      DecayDB[ 69].push_back(new G4QDecayChan(.700, 311, 113));
+      DecayDB[ 69].push_back(new G4QDecayChan(.800, 321,-213));
+      DecayDB[ 69].push_back(new G4QDecayChan(.900, 311, 111));
+      DecayDB[ 69].push_back(new G4QDecayChan(1.00, 321,-211));
+	}
+    if(limit<= 70 && nQ>= 70)    // K_4 +
+	{
+      DecayDB[ 70].push_back(new G4QDecayChan(.060, 333, 323));
+      DecayDB[ 70].push_back(new G4QDecayChan(.260, 223, 323));
+      DecayDB[ 70].push_back(new G4QDecayChan(.380, 313, 213));
+      DecayDB[ 70].push_back(new G4QDecayChan(.400, 323, 113));
+      DecayDB[ 70].push_back(new G4QDecayChan(.500, 223, 321));
+      DecayDB[ 70].push_back(new G4QDecayChan(.550, 321, 113));
+      DecayDB[ 70].push_back(new G4QDecayChan(.600, 311, 213));
+      DecayDB[ 70].push_back(new G4QDecayChan(.700, 311, 211));
+      DecayDB[ 70].push_back(new G4QDecayChan(.800, 321, 111));
+      DecayDB[ 70].push_back(new G4QDecayChan(.900, 311, 211));
+      DecayDB[ 70].push_back(new G4QDecayChan(1.00, 321, 111));
+	}
+    if(limit<= 71 && nQ>= 71)DecayDB[ 71].push_back(new G4QDecayChan(1.00, 333, 333));//phi_4(2300)
+    if(limit<= 72 && nQ>= 72)DecayDB[ 72].push_back(new G4QDecayChan(1.00, 2212, 2224)); //pDelta++
+    if(limit<= 73 && nQ>= 73)DecayDB[ 73].push_back(new G4QDecayChan(1.00, 2112, 1114)); //nDelta-
+    if(limit<= 74 && nQ>= 74)DecayDB[ 74].push_back(new G4QDecayChan(1.00, 2224, 2224)); //D++D++
+    if(limit<= 75 && nQ>= 75)DecayDB[ 75].push_back(new G4QDecayChan(1.00, 1114, 1114)); //Del-Del-
+    if(limit<= 76 && nQ>= 76)DecayDB[ 76].push_back(new G4QDecayChan(1.,2212,2212,2224));//ppDelta++
+    if(limit<= 77 && nQ>= 77)DecayDB[ 77].push_back(new G4QDecayChan(1.,2112,2112,1114));//nnDelta-
+    if(limit<= 78 && nQ>= 78)DecayDB[ 78].push_back(new G4QDecayChan(1.,2212,2224,2224));//pD++D++
+    if(limit<= 79 && nQ>= 79)DecayDB[ 79].push_back(new G4QDecayChan(1.,2112,1114,1114));//nDel-Del-
+    if(limit<= 83 && nQ>= 83)DecayDB[ 83].push_back(new G4QDecayChan(1.00, 2112, 2112)); //nn
+    if(limit<= 84 && nQ>= 84)DecayDB[ 84].push_back(new G4QDecayChan(1.00, 2212, 2112)); //pn
+    if(limit<= 85 && nQ>= 85)DecayDB[ 85].push_back(new G4QDecayChan(1.00, 2212, 2212)); //pp
+    // ------- Nuclear fragments
+    //if(limit<= 80 && nQ>=80)
+	//{
+    //  if(limit<80) limit=80;
+    //  for (int i=limit; i<nQ; i++) DecayDB[i] = NULL;
+    //}
+
+	//Update the limit
+    limit=nQ+1;
+#ifdef debug
+	G4cout<<"G4QParticle::InitDecayVector: limit is set to "<<limit<<G4endl;
+#endif
+  }
+  return DecayDB[abs(nQ)];
+}
+
+// Initialize the Particle by a Q Code
+void G4QParticle::InitQParticle(G4int theQCode)
+//    =============================================
+{
+  aQPDG.InitByQCode(theQCode);
+  aQuarkCont = aQPDG.GetQuarkContent();
+  aDecay     = InitDecayVector(aQPDG.GetQCode());
+}
+
+// Initialize the Particle by a PDG Code
+void G4QParticle::InitPDGParticle(G4int thePDGCode)
+//    =============================================
+{
+  aQPDG      = G4QPDGCode(thePDGCode);
+  aQuarkCont = aQPDG.GetQuarkContent();
+  aDecay     = InitDecayVector(aQPDG.GetQCode());
+}
+
+
+

source/processes/hadronic/models/chiral_inv_phase_space/body/src/G4QSelector.cc

@@ -0,0 +1,52 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+//
+// $Id: G4QSelector.cc,v 1.14 2001/11/26 14:11:47 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
+//
+//      ---------------- G4QSelector ----------------
+//             by Mikhail Kossov, Sept 1999.
+//      class for decay Selection for Hadrons generated by CHIPS Model
+// -------------------------------------------------------------------
+#include "G4QSelector.hh"
+
+G4QSelector::G4QSelector(){}
+
+G4QSelector::G4QSelector(G4QHadronVector hadronVec) : theHadrons(hadronVec){}
+
+G4bool G4QSelector::SelectPDGSet(G4QPDGCodeVector thePDGCodes)
+{
+  G4int  ind;
+  G4int  tNH = theHadrons.size();
+  G4int* yes = new int[tNH];
+  //for (ind=0; ind<tNH; ind++)
+  for (ind=tNH-1; ind>=0; ind--) // A Loop to fill
+  {
+    ////////G4int c=theHadrons[ind]->GetPDGCode(); // PDGCode
+  }
+
+  delete yes;
+  return false;
+}
+
+G4QSelector::~G4QSelector() {}

source/processes/hadronic/models/chiral_inv_phase_space/interface/GNUmakefile

@@ -0,0 +1,35 @@
+# -----------------------------------------------------------
+# GNUmakefile for chips granular library.  HPW 20-Nov-99
+# -----------------------------------------------------------
+
+name := G4hadronic_interface_ci
+
+ifndef G4INSTALL
+  G4INSTALL = ../../../../../..
+endif
+
+include $(G4INSTALL)/config/architecture.gmk
+
+CPPFLAGS += -I$(G4BASE)/global/management/include \
+            -I$(G4BASE)/global/HEPRandom/include \
+            -I$(G4BASE)/global/HEPGeometry/include \
+            -I$(G4BASE)/track/include \
+            -I$(G4BASE)/geometry/volumes/include \
+            -I$(G4BASE)/geometry/management/include \
+            -I$(G4BASE)/processes/management/include \
+            -I$(G4BASE)/processes/hadronic/management/include/ \
+            -I$(G4BASE)/processes/hadronic/util/include \
+            -I$(G4BASE)/processes/hadronic/cross_sections/include/ \
+            -I$(G4BASE)/processes/hadronic/models/generator/util/include \
+            -I$(G4BASE)/processes/hadronic/models/generator/management/include \
+            -I$(G4BASE)/processes/hadronic/models/chiral_inv_phase_space/interface/include \
+            -I$(G4BASE)/processes/hadronic/models/chiral_inv_phase_space/body/include \
+            -I$(G4BASE)/particles/management/include \
+            -I$(G4BASE)/particles/leptons/include \
+            -I$(G4BASE)/particles/bosons/include \
+            -I$(G4BASE)/particles/hadrons/mesons/include \
+            -I$(G4BASE)/particles/hadrons/barions/include \
+            -I$(G4BASE)/particles/hadrons/ions/include \
+            -I$(G4BASE)/materials/include
+           
+include $(G4INSTALL)/config/common.gmk

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4ChiralInvariantPhaseSpace.hh

@@ -0,0 +1,161 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4ChiralInvariantPhaseSpace_h
+#define G4ChiralInvariantPhaseSpace_h
+
+//#define CHIPSdebug
+
+#include "globals.hh"
+#include "G4HadronicInteraction.hh"
+#include "G4ParticleTable.hh"
+#include "G4QEnvironment.hh"
+//#include "G4Quasmon.hh"
+#include "G4QNucleus.hh"
+#include "G4QHadronVector.hh"
+#include "G4ParticleChange.hh"
+#include "G4LorentzVector.hh"
+#include "G4DynamicParticle.hh"
+#include "G4IonTable.hh"
+#include "G4Neutron.hh"
+
+class G4ChiralInvariantPhaseSpace 
+{
+  public: 
+    G4VParticleChange * ApplyYourself(const G4Track& aTrack, 
+                                      G4Nucleus& aTargetNucleus, 
+				      G4ParticleChange * aChange = 0);
+
+  private:
+    G4ParticleChange theResult;
+};
+
+inline
+G4VParticleChange * G4ChiralInvariantPhaseSpace::
+ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus, G4ParticleChange * aChange)
+{
+  G4ParticleChange * aResult;
+  if(aChange != 0)
+  {
+    aResult = aChange;
+  }
+  else
+  {
+    aResult = & theResult;
+    aResult->Initialize(aTrack);
+    aResult->SetStatusChange(fStopAndKill);
+  }
+  //projectile properties needed in constructor of quasmon
+  G4LorentzVector proj4Mom;
+  proj4Mom = aTrack.GetDynamicParticle()->Get4Momentum();
+  G4int projectilePDGCode = aTrack.GetDynamicParticle()
+                                  ->GetDefinition()
+				  ->GetPDGEncoding();
+  
+  //target properties needed in constructor of quasmon
+  G4int targetZ = G4int(aTargetNucleus.GetZ()+0.5);
+  G4int targetA = G4int(aTargetNucleus.GetN()+0.5);
+  G4int targetPDGCode = 90000000 + 1000*targetZ + (targetA-targetZ);
+  // NOT NECESSARY ______________
+  G4double targetMass = G4ParticleTable::GetParticleTable()->GetIonTable()
+                                                           ->GetIonMass(targetZ, targetA);
+  G4LorentzVector targ4Mom(0.,0.,0.,targetMass);  
+  // END OF NOT NECESSARY^^^^^^^^
+
+  G4int nop = 164; // nuclear clusters up to A=21
+  G4double fractionOfSingleQuasiFreeNucleons = 0.4;
+  G4double fractionOfPairedQuasiFreeNucleons = 0.0;
+  if(targetA>27) fractionOfPairedQuasiFreeNucleons = 0.04;
+  G4double clusteringCoefficient = 4.;
+  G4double temperature = 180.;
+  G4double halfTheStrangenessOfSee = 0.1; // = s/d = s/u
+  G4double etaToEtaPrime = 0.3;
+  
+  // construct and fragment the quasmon
+  G4QCHIPSWorld aWorld(nop);              // Create CHIPS World of nop particles
+  G4QNucleus::SetParameters(fractionOfSingleQuasiFreeNucleons,
+                            fractionOfPairedQuasiFreeNucleons,
+			                clusteringCoefficient);
+  G4Quasmon::SetParameters(temperature,
+                           halfTheStrangenessOfSee,
+			               etaToEtaPrime);
+//  G4cout << "Input info "<< projectilePDGCode << " " 
+//         << targetPDGCode <<" "
+//	 << 1./MeV*proj4Mom<<" "
+//	 << 1./MeV*targ4Mom << " "
+//	 << nop << G4endl;
+  G4QHadronVector projHV;
+  G4QHadron* iH = new G4QHadron(projectilePDGCode, 1./MeV*proj4Mom);
+  projHV.push_back(iH);
+  G4QEnvironment* pan= new G4QEnvironment(projHV, targetPDGCode);
+  G4std::for_each(projHV.begin(), projHV.end(), DeleteQHadron());
+  projHV.clear();
+  //G4Quasmon* pan= new G4Quasmon(projectilePDGCode, targetPDGCode, 1./MeV*proj4Mom, 1./MeV*targ4Mom, nop);
+  G4QHadronVector* output = pan->Fragment();
+  delete pan;
+  
+  // Fill the particle change.
+  aResult->SetNumberOfSecondaries(output->size());
+  G4DynamicParticle * theSec;
+#ifdef CHIPSdebug
+  G4cout << "G4ChiralInvariantPhaseSpace: NEW EVENT #ofHadrons="<<output->size()<<endl;
+#endif
+  unsigned int particle;
+  for( particle = 0; particle < output->size(); particle++)
+  {
+    if(output->operator[](particle)->GetNFragments() != 0) 
+    {
+      delete output->operator[](particle);
+      continue;
+    }
+    theSec = new G4DynamicParticle;  
+    G4int pdgCode = output->operator[](particle)->GetPDGCode();
+#ifdef CHIPSdebug
+    G4cout << "G4ChiralInvariantPhaseSpace: h#"<<particle<<", PDG="<<pdgCode<<endl;
+#endif
+    G4ParticleDefinition * theDefinition;
+    // Note that I still have to take care of strange nuclei
+    // For this I need the mass calculation, and a changed interface
+    // for ion-tablel ==> work for Hisaya @@@@@@@
+    // Then I can sort out the pdgCode. I also need a decau process 
+    // for strange nuclei; may be another chips interface
+    if(pdgCode>90000000) 
+    {
+      G4int aZ = (pdgCode-90000000)/1000;
+      G4int anN = pdgCode-90000000-1000*aZ;
+      theDefinition = G4ParticleTable::GetParticleTable()->FindIon(aZ,anN+aZ,0,aZ);
+      if(aZ == 0 && anN == 1) theDefinition = G4Neutron::Neutron();
+    }
+    else
+    {
+      theDefinition = G4ParticleTable::GetParticleTable()->FindParticle(output->operator[](particle)->GetPDGCode());
+    }
+    theSec->SetDefinition(theDefinition);
+    theSec->SetMomentum(output->operator[](particle)->Get4Momentum().vect());
+    aResult->AddSecondary(theSec); 
+    delete output->operator[](particle);
+  }
+  delete output;
+  return aResult;
+}
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4ElectroNuclearReaction.hh

@@ -0,0 +1,98 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4ElectroNuclearReaction_h
+#define G4ElectroNuclearReaction_h
+
+#include "globals.hh"
+#include "G4HadronicInteraction.hh"
+#include "G4ChiralInvariantPhaseSpace.hh"
+#include "G4ElectroNuclearCrossSection.hh"
+#include "G4Electron.hh"
+#include "G4Positron.hh"
+
+class G4ElectroNuclearReaction : public G4HadronicInteraction
+{
+  public: 
+    virtual ~G4ElectroNuclearReaction()
+    {
+    }
+    
+    G4VParticleChange * ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus);
+
+  private:
+    G4ChiralInvariantPhaseSpace theModel;
+    G4ElectroNuclearCrossSection theData;
+    G4ParticleChange theResult;
+};
+
+inline
+G4VParticleChange * G4ElectroNuclearReaction::
+ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus)
+{
+  const G4ParticleDefinition* aD = aTrack.GetDynamicParticle()->GetDefinition();
+  if((aD != G4Electron::ElectronDefinition()) && (aD != G4Positron::PositronDefinition()))
+  {
+    G4Exception("Called G4ElectroNuclearReaction for particle other than electron or positron");
+  }
+  
+  theResult.Initialize(aTrack);
+
+  const G4ElementTable* aTab = G4Element::GetElementTable();
+  G4Element * anElement = 0;
+  G4int aZ = static_cast<G4int>(aTargetNucleus.GetZ()+.1);
+  for(size_t ii=0; ii<aTab->size(); ii++)
+  {
+    if ( abs((*aTab)[ii]->GetZ()-aZ) < .1)
+    {
+      anElement = (*aTab)[ii];
+      break;
+    }
+  }
+  if(0==anElement) 
+  {
+    G4cout << "G4ElectroNuclearReaction::ApplyYourself - trying to react on an element"<<G4endl;
+    G4cout << "that is not in the table of elements. Z="<<aTargetNucleus.GetZ()<<G4endl;
+    G4Exception("Folding with error.");
+  }
+  G4double photonEnergy = 10*GeV;  
+  G4double xSec;
+  while(photonEnergy>3.*GeV)
+  {
+    xSec = theData.GetCrossSection(aTrack.GetDynamicParticle(), anElement);
+    photonEnergy = theData.GetEffectivePhotonEnergy();
+  }
+  if(aTrack.GetDynamicParticle()->GetKineticEnergy() - photonEnergy < 0)
+  {
+    G4Exception("G4ElectroNuclearReaction: photonEnergy above electron energy");
+  }
+  theResult.SetEnergyChange(aTrack.GetDynamicParticle()->GetKineticEnergy() - photonEnergy);
+  
+  G4ThreeVector photonDirection = aTrack.GetMomentumDirection();
+  G4DynamicParticle localGamma(G4Gamma::GammaDefinition(), photonDirection, photonEnergy);
+  G4ThreeVector position(0,0,0);
+  G4Track localTrack(&localGamma, 0., position);
+  G4VParticleChange * result = theModel.ApplyYourself(localTrack, aTargetNucleus, &theResult);
+  return result;
+}
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4GammaNuclearReaction.hh

@@ -0,0 +1,55 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4GammaNuclearReaction_h
+#define G4GammaNuclearReaction_h
+
+#include "globals.hh"
+#include "G4HadronicInteraction.hh"
+#include "G4ChiralInvariantPhaseSpace.hh"
+#include "G4Gamma.hh"
+
+class G4GammaNuclearReaction : public G4HadronicInteraction
+{
+  public: 
+    virtual ~G4GammaNuclearReaction()
+    {
+    }
+    
+    G4VParticleChange * ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus);
+
+  private:
+    G4ChiralInvariantPhaseSpace theModel;
+};
+
+inline
+G4VParticleChange * G4GammaNuclearReaction::
+ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus)
+{
+  if(aTrack.GetDynamicParticle()->GetDefinition() != G4Gamma::GammaDefinition())
+  {
+    G4Exception("Called G4GammaNuclearReaction for particle other than gamma");
+  }
+  return theModel.ApplyYourself(aTrack, aTargetNucleus);
+}
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4PionMinusNuclearAtRestChips.hh

@@ -0,0 +1,104 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4PionMinusNuclearAtRestChips_h
+#define G4PionMinusNuclearAtRestChips_h
+
+#include "globals.hh"
+#include "G4VRestProcess.hh"
+#include "G4StopElementSelector.hh"
+#include "G4PionMinus.hh"
+#include "G4ChiralInvariantPhaseSpace.hh"
+
+class G4PionMinusNuclearAtRestChips : public G4VRestProcess
+{
+  private:
+  // hide assignment operator as private 
+      G4PionMinusNuclearAtRestChips& operator=(const G4PionMinusNuclearAtRestChips &right);
+      G4PionMinusNuclearAtRestChips(const G4PionMinusNuclearAtRestChips& );
+   
+  public:
+ 
+     G4PionMinusNuclearAtRestChips(const G4String& processName ="PionMinusAnnihilationAtRest")
+      : G4VRestProcess (processName) {}
+ 
+    ~G4PionMinusNuclearAtRestChips() {}
+
+     G4bool IsApplicable(const G4ParticleDefinition& aParticle)
+     {
+       return ( &aParticle == G4PionMinus::PionMinusDefinition() );
+     }
+
+  // null physics table
+     void BuildPhysicsTable(const G4ParticleDefinition&){}
+
+     G4double AtRestGetPhysicalInteractionLength(const G4Track&track,
+						 G4ForceCondition*condition);
+
+  // zero mean lifetime
+     G4double GetMeanLifeTime(const G4Track& aTrack,
+			      G4ForceCondition* condition) {return 0.0;}
+
+     G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&); 
+
+  private:
+    G4ChiralInvariantPhaseSpace theModel;
+    G4StopElementSelector theSelector; // Assume identical laws as for muons
+};
+
+inline
+G4VParticleChange * G4PionMinusNuclearAtRestChips::
+AtRestDoIt(const G4Track& aTrack, const G4Step&aStep)
+{
+  if(aTrack.GetDynamicParticle()->GetDefinition() != G4PionMinus::PionMinus())
+  {
+    G4Exception("Calling G4PionMinusNuclearAtRestChips with particle other than pi-!!!");
+  }
+  
+  // Create target
+  G4Element * theTarget = theSelector.GetElement(aTrack.GetMaterial());
+  G4Nucleus aTargetNucleus(theTarget->GetN() ,theTarget->GetZ());
+  
+  // Call chips
+  return theModel.ApplyYourself(aTrack, aTargetNucleus);
+}
+
+G4double G4PionMinusNuclearAtRestChips::
+AtRestGetPhysicalInteractionLength(const G4Track&track,
+				   G4ForceCondition*condition)
+{
+  ResetNumberOfInteractionLengthLeft();
+  *condition = NotForced;
+  currentInteractionLength = GetMeanLifeTime(track, condition);
+#ifdef CHIPSdebug
+  if ((currentInteractionLength <0.0) || (verboseLevel>2))
+  {
+    G4cout << "G4PionMinusNuclearAtRestChips::AtRestGetPhysicalInteractionLength ";
+    G4cout << "[ " << GetProcessName() << "]" <<G4endl;
+    track.GetDynamicParticle()->DumpInfo();
+    G4cout << " in Material  " << track.GetMaterial()->GetName() <<G4endl;
+    G4cout << "MeanLifeTime = " << currentInteractionLength/ns << "[ns]" <<G4endl;
+  }
+#endif
+  return theNumberOfInteractionLengthLeft * currentInteractionLength;
+}
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4PionMinusNuclearReaction.hh

@@ -0,0 +1,51 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4PionMinusNuclearReaction_h
+#define G4PionMinusNuclearReaction_h
+
+#include "globals.hh"
+#include "G4HadronicInteraction.hh"
+#include "G4ChiralInvariantPhaseSpace.hh"
+#include "G4PionMinus.hh"
+
+class G4PionMinusNuclearReaction : public G4HadronicInteraction
+{
+  public: 
+    G4VParticleChange * ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus);
+
+  private:
+    G4ChiralInvariantPhaseSpace theModel;
+};
+
+inline
+G4VParticleChange * G4PionMinusNuclearReaction::
+ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus)
+{
+//  if(aTrack.GetDynamicParticle()->GetDefinition() != G4PionMinus::PionMinusDefinition())
+//  {
+//    G4Exception("Called G4PionMinusNuclearReaction for particle other than PionMinus");
+//  }
+  return theModel.ApplyYourself(aTrack, aTargetNucleus);
+}
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4ProtonAntiProtonAtRestChips.hh

@@ -0,0 +1,117 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4ProtonAntiProtonAtRestChips_h
+#define G4ProtonAntiProtonAtRestChips_h
+
+#include "globals.hh"
+#include "G4VRestProcess.hh"
+#include "G4ParticleTable.hh"
+#include "G4Quasmon.hh"
+#include "G4QHadronVector.hh"
+#include "G4ParticleChange.hh"
+#include "G4LorentzVector.hh"
+#include "G4DynamicParticle.hh"
+#include "G4IonTable.hh"
+#include "G4Neutron.hh"
+#include "G4StopElementSelector.hh"
+#include "G4ChiralInvariantPhaseSpace.hh"
+
+class G4ProtonAntiProtonAtRestChips : public G4VRestProcess
+{
+  private:
+  // hide assignment operator as private 
+      G4ProtonAntiProtonAtRestChips& operator=(const G4ProtonAntiProtonAtRestChips &right);
+      G4ProtonAntiProtonAtRestChips(const G4ProtonAntiProtonAtRestChips& );
+   
+  public:
+ 
+     G4ProtonAntiProtonAtRestChips(const G4String& processName ="AntiProtonAnnihilationAtRest")
+      : G4VRestProcess (processName) {}
+ 
+    ~G4ProtonAntiProtonAtRestChips() {}
+
+     G4bool IsApplicable(const G4ParticleDefinition& aParticle)
+     {
+       return ( &aParticle == G4AntiProton::AntiProtonDefinition() );
+     }
+
+  // null physics table
+     void BuildPhysicsTable(const G4ParticleDefinition&){}
+
+     G4double AtRestGetPhysicalInteractionLength(const G4Track&track,
+						 G4ForceCondition*condition);
+
+  // zero mean lifetime
+     G4double GetMeanLifeTime(const G4Track& aTrack,
+			      G4ForceCondition* condition) {return 0.0;}
+
+     G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&); 
+
+  private:
+    G4ChiralInvariantPhaseSpace theModel;
+    G4StopElementSelector theSelector; // Assume identical laws as for muons
+};
+
+inline
+G4VParticleChange * G4ProtonAntiProtonAtRestChips::
+AtRestDoIt(const G4Track& aTrack, const G4Step&aStep)
+{
+  // Create target
+  G4Element * theTarget = theSelector.GetElement(aTrack.GetMaterial());
+  G4Nucleus aTargetNucleus(theTarget->GetN() ,theTarget->GetZ());
+
+  // Check model validity - note this will be a sub-branch in the ordinary stopping @@@@@@
+  // in the long haul. @@@@@@
+  if(aTrack.GetDynamicParticle()->GetDefinition() != G4AntiProton::AntiProton())
+  {
+    G4Exception("Calling G4ProtonAntiProtonAtRestChips with particle other than p-bar!!!");
+  }
+  if(aTargetNucleus.GetZ() != 1)
+  {
+    G4Exception("Calling G4ProtonAntiProtonAtRestChips for target other than Hydrogen!!!");
+  }
+  
+  // Call chips
+  return theModel.ApplyYourself(aTrack, aTargetNucleus);
+}
+
+G4double G4ProtonAntiProtonAtRestChips::
+AtRestGetPhysicalInteractionLength(const G4Track&track,
+				   G4ForceCondition*condition)
+{
+  ResetNumberOfInteractionLengthLeft();
+  *condition = NotForced;
+  currentInteractionLength = GetMeanLifeTime(track, condition);
+#ifdef CHIPSdebug
+  if ((currentInteractionLength <0.0) || (verboseLevel>2))
+  {
+    G4cout << "G4ProtonAntiProtonAtRestChips::AtRestGetPhysicalInteractionLength ";
+    G4cout << "[ " << GetProcessName() << "]" <<G4endl;
+    track.GetDynamicParticle()->DumpInfo();
+    G4cout << " in Material  " << track.GetMaterial()->GetName() <<G4endl;
+    G4cout << "MeanLifeTime = " << currentInteractionLength/ns << "[ns]" <<G4endl;
+  }
+#endif
+  return theNumberOfInteractionLengthLeft * currentInteractionLength;
+}
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4ProtonAntiProtonReaction.hh

@@ -0,0 +1,55 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4ProtonAntiProtonReaction_h
+#define G4ProtonAntiProtonReaction_h
+
+#include "globals.hh"
+#include "G4HadronicInteraction.hh"
+#include "G4ChiralInvariantPhaseSpace.hh"
+#include "G4AntiProton.hh"
+
+class G4ProtonAntiProtonReaction : public G4HadronicInteraction
+{
+  public: 
+    G4VParticleChange * ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus);
+
+  private:
+    G4ChiralInvariantPhaseSpace theModel;
+};
+
+inline
+G4VParticleChange * G4ProtonAntiProtonReaction::
+ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus)
+{
+  if(aTrack.GetDynamicParticle()->GetDefinition() != G4AntiProton::AntiProton())
+  {
+    G4Exception("Calling G4ProtonAntiProtonReaction with particle other than p-bar!!!");
+  }
+  if(aTargetNucleus.GetZ() != 1)
+  {
+    G4Exception("Calling G4ProtonAntiProtonReaction for target other than Hydrogen!!!");
+  }
+  return theModel.ApplyYourself(aTrack, aTargetNucleus);
+}
+
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4StringChipsInterface.hh

@@ -0,0 +1,43 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4StringChipsInterface_h
+#define G4StringChipsInterface_h
+
+#include "G4VIntraNuclearTransportModel.hh"
+#include "G4ChiralInvariantPhaseSpace.hh"
+
+class G4StringChipsInterface : public G4VIntraNuclearTransportModel
+{
+  public:
+    G4StringChipsInterface();
+    virtual G4VParticleChange* ApplyYourself(const G4Track& aTrack, 
+                                             G4Nucleus& theNucleus);
+
+    virtual G4ReactionProductVector* Propagate(G4KineticTrackVector* theSecondaries,
+                                               G4V3DNucleus* theNucleus); 
+  private:
+  
+    G4ChiralInvariantPhaseSpace theModel;
+    G4double theEnergyLossPerFermi;
+};
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4StringChipsParticleLevelInterface.hh

@@ -0,0 +1,54 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#ifndef G4StringChipsParticleLevelInterface_h
+#define G4StringChipsParticleLevelInterface_h
+
+#include "G4VIntraNuclearTransportModel.hh"
+#include "G4ChiralInvariantPhaseSpace.hh"
+
+class G4StringChipsParticleLevelInterface : public G4VIntraNuclearTransportModel
+{
+  public:
+    G4StringChipsParticleLevelInterface();
+    virtual G4VParticleChange* ApplyYourself(const G4Track& aTrack, 
+                                             G4Nucleus& theNucleus);
+
+    virtual G4ReactionProductVector* Propagate(G4KineticTrackVector* theSecondaries,
+                                               G4V3DNucleus* theNucleus); 
+  private:
+  
+    G4ChiralInvariantPhaseSpace theModel;
+    G4double theEnergyLossPerFermi;
+    
+    G4double theInnerCoreDensityCut;
+    
+    G4double fractionOfSingleQuasiFreeNucleons;
+    G4double fractionOfPairedQuasiFreeNucleons;
+    G4double clusteringCoefficient;
+    G4double temperature;
+    G4double halfTheStrangenessOfSee;
+    G4double etaToEtaPrime;
+    G4double fusionToExchange;
+    G4int nop;
+};
+#endif

source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4StringChipsInterface.cc

@@ -0,0 +1,419 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#include "G4StringChipsInterface.hh"
+#include "globals.hh"
+#include "G4Pair.hh"
+#include "g4std/list"
+#include "G4KineticTrackVector.hh"
+#include "G4Nucleon.hh"
+#include "G4LorentzRotation.hh"
+
+G4StringChipsInterface::G4StringChipsInterface()
+{
+#ifdef CHIPSdebug
+  G4cout << "Please enter the energy loss per fermi in GeV"<<G4endl;
+  G4cin >> theEnergyLossPerFermi;
+#endif
+
+  theEnergyLossPerFermi *= GeV;
+  // theEnergyLossPerFermi = 1.*GeV;
+}
+
+G4VParticleChange* G4StringChipsInterface::
+ApplyYourself(const G4Track& aTrack, G4Nucleus& theNucleus)
+{
+  return theModel.ApplyYourself(aTrack, theNucleus);
+}
+
+G4ReactionProductVector* G4StringChipsInterface::
+Propagate(G4KineticTrackVector* theSecondaries, G4V3DNucleus* theNucleus)
+{
+  // Protection for non physical conditions
+  
+  if(theSecondaries->size() == 1) 
+    G4Exception("G4StringChipsInterface: Only one particle from String models!");
+  
+  // Calculate the mean energy lost
+  G4Pair<G4double, G4double> theImpact = theNucleus->RefetchImpactXandY();
+  G4double impactX = theImpact.first;
+  G4double impactY = theImpact.second;
+  G4double inpactPar2 = impactX*impactX + impactY*impactY;
+  
+  G4double radius2 = theNucleus->GetNuclearRadius(5*perCent);
+  radius2 *= radius2;
+  G4double pathlength = 0;
+  if(radius2 - inpactPar2>0) pathlength = 2.*sqrt(radius2 - inpactPar2);
+  G4double theEnergyLostInFragmentation = theEnergyLossPerFermi*pathlength/fermi;
+  
+  // now select all particles in range
+  G4std::list<G4Pair<G4double, G4KineticTrack *> > theSorted;
+  G4std::list<G4Pair<G4double, G4KineticTrack *> >::iterator current;
+  for(unsigned int secondary = 0; secondary<theSecondaries->size(); secondary++)
+  {
+    G4LorentzVector a4Mom = theSecondaries->operator[](secondary)->Get4Momentum();
+
+#ifdef CHIPSdebug
+    G4cout <<"ALL STRING particles "<<theSecondaries->operator[](secondary)->GetDefinition()->GetPDGCharge()<<" "
+           << theSecondaries->operator[](secondary)->GetDefinition()->GetPDGEncoding()<<" "
+	   << a4Mom <<G4endl; 
+#endif
+
+    G4double toSort = a4Mom.rapidity();
+    G4Pair<G4double, G4KineticTrack *> it;
+    it.first = toSort;
+    it.second = theSecondaries->operator[](secondary);
+    G4bool inserted = false;
+    for(current = theSorted.begin(); current!=theSorted.end(); current++)
+    {
+      if((*current).first > toSort)
+      {
+	theSorted.insert(current, it);
+	inserted = true;
+	break;
+      }
+    }
+    if(!inserted)
+    {
+      theSorted.push_front(it);
+    }
+  }
+  
+  G4LorentzVector proj4Mom(0.,0.,0.,0.);
+  // @@ Use the G4QContent class, which is exactly (nD,nU,nS,nAD,nAU,nAS) !
+  // The G4QContent class is a basic clas in CHIPS (not PDG Code as in GEANT4),
+  // so in CHIPS on can has a hadronic obgect (Quasmon) with any Quark Content.
+  // As a simple extantion for the hadron (which is a special case for Hadron)
+  // there is a clas G4QChipolino, which is a Quasmon, which can decay in two
+  // hadrons. In future the three-hadron class can be added...
+  G4int nD  = 0;
+  G4int nU  = 0;
+  G4int nS  = 0;
+  G4int nAD = 0;
+  G4int nAU = 0;
+  G4int nAS = 0;
+  G4std::list<G4Pair<G4double, G4KineticTrack *> >::iterator firstEscaping = theSorted.begin();
+  G4double runningEnergy = 0;
+  G4int particleCount = 0;
+  G4LorentzVector theLow = (*(theSorted.begin())).second->Get4Momentum();
+  G4LorentzVector theHigh;
+
+#ifdef CHIPSdebug
+  G4cout << "CHIPS ENERGY LOST "<<theEnergyLostInFragmentation<<G4endl;
+  G4cout << "sorted rapidities event start"<<G4endl;
+#endif 
+
+  G4ReactionProductVector * theResult = new G4ReactionProductVector;
+  G4ReactionProduct * theSec;
+  G4KineticTrackVector * secondaries;
+  
+  // first decay and add all escaping particles.
+  for(current = theSorted.begin(); current!=theSorted.end(); current++)
+  {
+    firstEscaping = current;
+    if((*current).second->GetDefinition()->GetQuarkContent(3)!=0 ||
+       (*current).second->GetDefinition()->GetAntiQuarkContent(3) !=0)
+    {
+      G4KineticTrack * aResult = (*current).second;
+      G4ParticleDefinition * pdef=aResult->GetDefinition();
+      secondaries = NULL;
+      if ( pdef->GetPDGWidth() > 0 && pdef->GetPDGLifeTime() < 5E-17*s )
+      {
+        secondaries = aResult->Decay();
+      }
+      if ( secondaries == NULL )
+      {
+        theSec = new G4ReactionProduct(aResult->GetDefinition());
+        G4LorentzVector current4Mom = aResult->Get4Momentum();
+        theSec->SetTotalEnergy(current4Mom.t());
+        theSec->SetMomentum(current4Mom.vect());
+        theResult->push_back(theSec);
+      } 
+      else
+      {
+        for (unsigned int aSecondary=0; aSecondary<secondaries->size(); aSecondary++)
+        {
+          theSec = new G4ReactionProduct(secondaries->operator[](aSecondary)->GetDefinition());
+          G4LorentzVector current4Mom = secondaries->operator[](aSecondary)->Get4Momentum();
+          theSec->SetTotalEnergy(current4Mom.t());
+          theSec->SetMomentum(current4Mom.vect());
+          theResult->push_back(theSec);
+        }
+        G4std::for_each(secondaries->begin(), secondaries->end(), DeleteKineticTrack());
+        delete secondaries;
+      }
+      continue;
+    }
+    runningEnergy += (*current).second->Get4Momentum().t();
+    if(runningEnergy > theEnergyLostInFragmentation) break;
+    
+#ifdef CHIPSdebug
+    G4cout <<"ABSORBED STRING particles "<<current->second->GetDefinition()->GetPDGCharge()<<" "
+           << current->second->GetDefinition()->GetPDGEncoding()<<" "
+	   << current->second->Get4Momentum() <<G4endl; 
+#endif
+
+    // projectile 4-momentum needed in constructor of quasmon
+    particleCount++;
+    theHigh = (*current).second->Get4Momentum(); 
+    proj4Mom += (*current).second->Get4Momentum(); 
+
+#ifdef CHIPSdebug
+    G4cout << "sorted rapidities "<<current->second->Get4Momentum().rapidity()<<G4endl;
+#endif
+    
+     // projectile quark contents needed for G4QContent construction (@@ ? -> G4QContent class)
+    nD  += (*current).second->GetDefinition()->GetQuarkContent(1);
+    nU  += (*current).second->GetDefinition()->GetQuarkContent(2);
+    nS  += (*current).second->GetDefinition()->GetQuarkContent(3);
+    nAD += (*current).second->GetDefinition()->GetAntiQuarkContent(1);
+    nAU += (*current).second->GetDefinition()->GetAntiQuarkContent(2);
+    nAS += (*current).second->GetDefinition()->GetAntiQuarkContent(3);
+  }
+  // construct G4QContent
+
+#ifdef CHIPSdebug
+  G4cout << "Quark content: d="<<nD<<", u="<<nU<< ", s="<< nS << G4endl;
+  G4cout << "Anti-quark content: anit-d="<<nAD<<", anti-u="<<nAU<< ", anti-s="<< nAS << G4endl;
+#endif
+
+  G4QContent theProjectiles(nD, nU, nS, nAD, nAU, nAS);
+
+#ifdef CHIPSdebug
+  G4cout << "G4QContent is constructed"<<endl;
+#endif
+  
+  // target properties needed in constructor of quasmon
+  // remove all hit nucleons to get Target code
+  theNucleus->StartLoop();
+  G4Nucleon * aNucleon;
+  G4int resA = 0;
+  G4int resZ = 0;
+  G4ThreeVector hitMomentum(0,0,0);
+  G4double hitMass = 0;
+  G4int hitCount = 0;
+  while((aNucleon = theNucleus->GetNextNucleon()))
+  {
+    if(!aNucleon->AreYouHit())
+    {
+      resA++;
+      resZ+=G4int (aNucleon->GetDefinition()->GetPDGCharge());
+    }
+    else
+    {
+      hitMomentum += aNucleon->GetMomentum().vect();
+      hitMass += aNucleon->GetMomentum().m();
+      hitCount ++;
+    }
+  }
+  G4int targetPDGCode = 90000000 + 1000*resZ + (resA-resZ);
+  G4double targetMass = theNucleus->GetMass();
+  targetMass -= hitMass;
+  G4double targetEnergy = sqrt(hitMomentum.mag2()+targetMass*targetMass);
+  // !! @@ Target should be at rest: hitMomentum=(0,0,0) @@ !! M.K.
+  G4LorentzVector targ4Mom(-1.*hitMomentum, targetEnergy);
+  
+  // construct the quasmon
+  G4int nop = 223; // ??????
+  G4double fractionOfSingleQuasiFreeNucleons = 0.15;
+  G4double fractionOfPairedQuasiFreeNucleons = 0.01;
+  G4double clusteringCoefficient = 5.;
+  G4double temperature = 180.;
+  G4double halfTheStrangenessOfSee = 0.1; // = s/d = s/u
+  G4double etaToEtaPrime = 0.3;
+
+  G4QNucleus::SetParameters(fractionOfSingleQuasiFreeNucleons,
+                            fractionOfPairedQuasiFreeNucleons,
+			                clusteringCoefficient);
+  G4Quasmon::SetParameters(temperature,
+                           halfTheStrangenessOfSee,
+			               etaToEtaPrime);
+
+#ifdef CHIPSdebug
+  G4cout << "G4QNucleus parameters "<< fractionOfSingleQuasiFreeNucleons << " "
+         << fractionOfPairedQuasiFreeNucleons << " "<< clusteringCoefficient << G4endl;
+  G4cout << "G4Quasmon parameters "<< temperature << " "<< halfTheStrangenessOfSee << " "
+         <<etaToEtaPrime << G4endl;
+  G4cout << "The Target PDG code = "<<targetPDGCode<<G4endl;
+  G4cout << "The projectile momentum = "<<1./MeV*proj4Mom<<G4endl;
+  G4cout << "The target momentum = "<<1./MeV*targ4Mom<<G4endl;
+#endif
+
+  
+  // Chips expects all in target rest frame, along z.
+  G4QCHIPSWorld aWorld(nop);              // Create CHIPS World of nop particles
+  G4QHadronVector projHV;
+  // target rest frame
+  proj4Mom.boost(-1.*targ4Mom.boostVector());
+  // now go along z
+  G4LorentzRotation toZ;
+  toZ.rotateZ(-1*proj4Mom.phi());
+  toZ.rotateY(-1*proj4Mom.theta());
+  proj4Mom = toZ*proj4Mom;
+  G4LorentzRotation toLab(toZ.inverse());
+
+#ifdef CHIPSdebug
+  G4cout << "a Boosted projectile vector along z"<<proj4Mom<<" "<<proj4Mom.mag()<<G4endl;
+#endif
+  
+  G4QHadron* iH = new G4QHadron(theProjectiles, 1./MeV*proj4Mom);
+  projHV.push_back(iH);
+
+  // now call chips with this info in place
+  G4QHadronVector * output = 0;
+  if (particleCount!=0)
+  {
+    G4QEnvironment* pan= new G4QEnvironment(projHV, targetPDGCode);
+    G4std::for_each(projHV.begin(), projHV.end(), DeleteQHadron());
+    projHV.clear();
+    output = pan->Fragment();
+    delete pan;
+  }
+  else 
+  {
+    output = new G4QHadronVector;
+  }
+   
+  // Fill the result.
+#ifdef CHIPSdebug
+  G4cout << "NEXT EVENT"<<endl;
+#endif
+  
+  // first decay and add all escaping particles.
+  for(current = firstEscaping; current!=theSorted.end(); current++)
+  {
+    G4KineticTrack * aResult = (*current).second;
+    G4ParticleDefinition * pdef=aResult->GetDefinition();
+    secondaries = NULL;
+    if ( pdef->GetPDGWidth() > 0 && pdef->GetPDGLifeTime() < 5E-17*s )
+    {
+      secondaries = aResult->Decay();
+    }
+    if ( secondaries == NULL )
+    {
+      theSec = new G4ReactionProduct(aResult->GetDefinition());
+      G4LorentzVector current4Mom = aResult->Get4Momentum();
+      current4Mom = toLab*current4Mom;
+      current4Mom.boost(targ4Mom.boostVector());
+      theSec->SetTotalEnergy(current4Mom.t());
+      theSec->SetMomentum(current4Mom.vect());
+      theResult->push_back(theSec);
+    } 
+    else
+    {
+      for (unsigned int aSecondary=0; aSecondary<secondaries->size(); aSecondary++)
+      {
+        theSec = new G4ReactionProduct(secondaries->operator[](aSecondary)->GetDefinition());
+        G4LorentzVector current4Mom = secondaries->operator[](aSecondary)->Get4Momentum();
+        current4Mom = toLab*current4Mom;
+        current4Mom.boost(targ4Mom.boostVector());
+        theSec->SetTotalEnergy(current4Mom.t());
+        theSec->SetMomentum(current4Mom.vect());
+        theResult->push_back(theSec);
+      }
+      G4std::for_each(secondaries->begin(), secondaries->end(), DeleteKineticTrack());
+      delete secondaries;
+    }
+  }
+  G4std::for_each(theSecondaries->begin(), theSecondaries->end(), DeleteKineticTrack());
+  delete theSecondaries;
+    
+  // now add the quasmon output
+#ifdef CHIPSdebug
+  G4cout << "Number of particles from string"<<theResult->size()<<G4endl;
+  G4cout << "Number of particles from chips"<<output->size()<<G4endl;
+#endif
+
+  for(unsigned int particle = 0; particle < output->size(); particle++)
+  {
+    if(output->operator[](particle)->GetNFragments() != 0) 
+    {
+      delete output->operator[](particle);
+      continue;
+    }
+    theSec = new G4ReactionProduct;  
+    G4int pdgCode = output->operator[](particle)->GetPDGCode();
+    G4ParticleDefinition * theDefinition;
+    // Note that I still have to take care of strange nuclei
+    // For this I need the mass calculation, and a changed interface
+    // for ion-table ==> work for Hisaya @@@@@@@
+    // Then I can sort out the pdgCode. I also need a decau process 
+    // for strange nuclei; may be another chips interface
+    if(pdgCode>90000000) 
+    {
+      G4int aZ = (pdgCode-90000000)/1000;
+      if (aZ>1000) aZ=aZ%1000;  // patch for strange nuclei, to be repaired @@@@
+      G4int anN = pdgCode-90000000-1000*aZ;
+      if(anN>1000) anN=anN%1000; // patch for strange nuclei, to be repaired @@@@
+      if(pdgCode==91000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==92000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==93000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==94000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==95000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==96000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==97000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==98000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(aZ == 0 && anN == 1) theDefinition = G4Neutron::Neutron();
+      else theDefinition = G4ParticleTable::GetParticleTable()->FindIon(aZ,anN+aZ,0,aZ);
+    }    
+    else
+    {
+      theDefinition = G4ParticleTable::GetParticleTable()->FindParticle(output->operator[](particle)->GetPDGCode());
+    }
+#ifdef CHIPSdebug
+    G4cout << "Particle code produced = "<< pdgCode <<G4endl;
+#endif
+
+    theSec = new G4ReactionProduct(theDefinition);
+    G4LorentzVector current4Mom = output->operator[](particle)->Get4Momentum();
+    current4Mom = toLab*current4Mom;
+    current4Mom.boost(targ4Mom.boostVector());
+    theSec->SetTotalEnergy(current4Mom.t());
+    theSec->SetMomentum(current4Mom.vect());
+    theResult->push_back(theSec);
+    
+#ifdef CHIPSdebug
+    G4cout <<"CHIPS particles "<<theDefinition->GetPDGCharge()<<" "
+           << theDefinition->GetPDGEncoding()<<" "
+	   << current4Mom <<G4endl; 
+#endif
+
+    delete output->operator[](particle);
+  }
+  delete output;
+#ifdef CHIPSdebug
+  G4cout << "Number of particles"<<theResult->size()<<G4endl;
+  G4cout << G4endl;
+  // @@ G4QContent has even the out option!
+  G4cout << "QUASMON preparation info "
+         << 1./MeV*proj4Mom<<" "
+	 << 1./MeV*targ4Mom<<" "
+	 << nD<<" "<<nU<<" "<<nS<<" "<<nAD<<" "<<nAU<<" "<<nAS<<" "
+	 << hitCount<<" "
+	 << particleCount<<" "
+	 << theLow<<" "
+	 << theHigh<<" "
+	 << G4endl;
+#endif
+
+  return theResult;
+} 

source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4StringChipsParticleLevelInterface.cc

@@ -0,0 +1,486 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+#include "G4StringChipsParticleLevelInterface.hh"
+#include "globals.hh"
+#include "G4Pair.hh"
+#include "g4std/list"
+#include "g4std/vector"
+#include "G4KineticTrackVector.hh"
+#include "G4Nucleon.hh"
+#include "G4Proton.hh"
+#include "G4Neutron.hh"
+#include "G4LorentzRotation.hh"
+// #define CHIPSdebug
+// #define CHIPSdebug_1
+
+G4StringChipsParticleLevelInterface::G4StringChipsParticleLevelInterface()
+{
+  theEnergyLossPerFermi = 0.7*GeV;
+  nop = 164; // ??????
+  fractionOfSingleQuasiFreeNucleons = 0.1;
+  fractionOfPairedQuasiFreeNucleons = 0.;
+  clusteringCoefficient = 2.7;
+  temperature = 180.;
+  halfTheStrangenessOfSee = 0.3; // = s/d = s/u
+  etaToEtaPrime = 0.3;
+  fusionToExchange = 100.;
+  theInnerCoreDensityCut = 50.;
+  
+  if(getenv("ChipsParameterTuning"))
+  {
+    G4cout << "Please enter the energy loss per fermi in GeV"<<G4endl;
+    G4cin >> theEnergyLossPerFermi;
+    theEnergyLossPerFermi *= GeV;
+    G4cout << "Please enter nop"<<G4endl;
+    G4cin >> nop;
+    G4cout << "Please enter the fractionOfSingleQuasiFreeNucleons"<<G4endl;
+    G4cin >> fractionOfSingleQuasiFreeNucleons;
+    G4cout << "Please enter the fractionOfPairedQuasiFreeNucleons"<<G4endl;
+    G4cin >> fractionOfPairedQuasiFreeNucleons;
+    G4cout << "Please enter the clusteringCoefficient"<<G4endl;
+    G4cin >> clusteringCoefficient;
+    G4cout << "Please enter the temperature"<<G4endl;
+    G4cin >> temperature;
+    G4cout << "Please enter halfTheStrangenessOfSee"<<G4endl;
+    G4cin >> halfTheStrangenessOfSee;
+    G4cout << "Please enter the etaToEtaPrime"<<G4endl;
+    G4cin >> etaToEtaPrime;
+    G4cout << "Please enter the fusionToExchange"<<G4endl;
+    G4cin >> fusionToExchange;
+    G4cout << "Please enter the cut-off for calculating the nuclear radius in percent"<<G4endl;
+    G4cin >> theInnerCoreDensityCut;
+  }
+}
+
+G4VParticleChange* G4StringChipsParticleLevelInterface::
+ApplyYourself(const G4Track& aTrack, G4Nucleus& theNucleus)
+{
+  return theModel.ApplyYourself(aTrack, theNucleus);
+}
+
+G4ReactionProductVector* G4StringChipsParticleLevelInterface::
+Propagate(G4KineticTrackVector* theSecondaries, G4V3DNucleus* theNucleus)
+{
+  // Protection for non physical conditions
+  
+  if(theSecondaries->size() == 1) 
+  {
+    G4ReactionProductVector * theFastResult = new G4ReactionProductVector;
+    G4ReactionProduct * theFastSec;
+    theFastSec = new G4ReactionProduct((*theSecondaries)[0]->GetDefinition());
+    G4LorentzVector current4Mom = (*theSecondaries)[0]->Get4Momentum();
+    theFastSec->SetTotalEnergy(current4Mom.t());
+    theFastSec->SetMomentum(current4Mom.vect());
+    theFastResult->push_back(theFastSec);
+    return theFastResult;
+//    G4Exception("G4StringChipsParticleLevelInterface: Only one particle from String models!");
+  }
+  
+  // target properties needed in constructor of quasmon, and for boosting to
+  // target rest frame
+  // remove all hit nucleons to get Target code
+  theNucleus->StartLoop();
+  G4Nucleon * aNucleon;
+  G4int resA = 0;
+  G4int resZ = 0;
+  G4ThreeVector hitMomentum(0,0,0);
+  G4double hitMass = 0;
+  unsigned int hitCount = 0;
+  while((aNucleon = theNucleus->GetNextNucleon()))
+  {
+    if(!aNucleon->AreYouHit())
+    {
+      resA++;
+      resZ+=G4int (aNucleon->GetDefinition()->GetPDGCharge());
+    }
+    else
+    {
+      hitMomentum += aNucleon->GetMomentum().vect();
+      hitMass += aNucleon->GetMomentum().m();
+      hitCount ++;
+    }
+  }
+  G4int targetPDGCode = 90000000 + 1000*resZ + (resA-resZ);
+  G4double targetMass = theNucleus->GetMass();
+  targetMass -= hitMass;
+  G4double targetEnergy = sqrt(hitMomentum.mag2()+targetMass*targetMass);
+  // !! @@ Target should be at rest: hitMomentum=(0,0,0) @@ !! M.K.
+  G4LorentzVector targ4Mom(-1.*hitMomentum, targetEnergy);
+  
+  // Calculate the mean energy lost
+  G4Pair<G4double, G4double> theImpact = theNucleus->RefetchImpactXandY();
+  G4double impactX = theImpact.first;
+  G4double impactY = theImpact.second;
+  G4double inpactPar2 = impactX*impactX + impactY*impactY;
+  
+  G4double radius2 = theNucleus->GetNuclearRadius(theInnerCoreDensityCut*perCent);
+  radius2 *= radius2;
+  G4double pathlength = 0;
+  if(radius2 - inpactPar2>0) pathlength = 2.*sqrt(radius2 - inpactPar2);
+  G4double theEnergyLostInFragmentation = theEnergyLossPerFermi*pathlength/fermi;
+  
+  // now select all particles in range
+  G4std::list<G4Pair<G4double, G4KineticTrack *> > theSorted;
+  G4std::list<G4Pair<G4double, G4KineticTrack *> >::iterator current;
+  for(unsigned int secondary = 0; secondary<theSecondaries->size(); secondary++)
+  {
+    G4LorentzVector a4Mom = theSecondaries->operator[](secondary)->Get4Momentum();
+#ifdef CHIPSdebug
+    G4cout <<"ALL STRING particles "<<theSecondaries->operator[](secondary)->GetDefinition()->GetPDGCharge()<<" "
+           << theSecondaries->operator[](secondary)->GetDefinition()->GetPDGEncoding()<<" "
+	   << a4Mom <<G4endl; 
+#endif
+    G4double toSort = a4Mom.rapidity();
+    G4Pair<G4double, G4KineticTrack *> it;
+    it.first = toSort;
+    it.second = theSecondaries->operator[](secondary);
+    G4bool inserted = false;
+    for(current = theSorted.begin(); current!=theSorted.end(); current++)
+    {
+      if((*current).first > toSort)
+      {
+	theSorted.insert(current, it);
+	inserted = true;
+	break;
+      }
+    }
+    if(!inserted)
+    {
+      theSorted.push_back(it);
+    }
+  }
+  
+  G4LorentzVector proj4Mom(0.,0.,0.,0.);
+  G4int nD  = 0;
+  G4int nU  = 0;
+  G4int nS  = 0;
+  G4int nAD = 0;
+  G4int nAU = 0;
+  G4int nAS = 0;
+  G4std::list<G4Pair<G4double, G4KineticTrack *> >::iterator firstEscaping = theSorted.begin();
+  G4double runningEnergy = 0;
+  G4int particleCount = 0;
+  G4LorentzVector theLow = (*(theSorted.begin())).second->Get4Momentum();
+  G4LorentzVector theHigh;
+
+#ifdef CHIPSdebug
+  G4cout << "CHIPS ENERGY LOST "<<theEnergyLostInFragmentation<<G4endl;
+  G4cout << "sorted rapidities event start"<<G4endl;
+#endif
+
+  G4QHadronVector projHV;
+  G4std::vector<G4QContent> theContents;
+  G4std::vector<G4LorentzVector *> theMomenta;
+  G4ReactionProductVector * theResult = new G4ReactionProductVector;
+  G4ReactionProduct * theSec;
+  G4KineticTrackVector * secondaries;
+  
+  for(current = theSorted.begin(); current!=theSorted.end(); current++)
+  {
+    firstEscaping = current;
+    if((*current).second->GetDefinition()->GetQuarkContent(3)!=0 ||
+       (*current).second->GetDefinition()->GetAntiQuarkContent(3) !=0)
+    {
+      G4KineticTrack * aResult = (*current).second;
+      G4ParticleDefinition * pdef=aResult->GetDefinition();
+      secondaries = NULL;
+      if ( pdef->GetPDGWidth() > 0 && pdef->GetPDGLifeTime() < 5E-17*s )
+      {
+        secondaries = aResult->Decay();
+      }
+      if ( secondaries == NULL )
+      {
+        theSec = new G4ReactionProduct(aResult->GetDefinition());
+        G4LorentzVector current4Mom = aResult->Get4Momentum();
+        current4Mom.boost(targ4Mom.boostVector());
+        theSec->SetTotalEnergy(current4Mom.t());
+        theSec->SetMomentum(current4Mom.vect());
+        theResult->push_back(theSec);
+      } 
+      else
+      {
+        for (unsigned int aSecondary=0; aSecondary<secondaries->size(); aSecondary++)
+        {
+          theSec = new G4ReactionProduct(secondaries->operator[](aSecondary)->GetDefinition());
+          G4LorentzVector current4Mom = secondaries->operator[](aSecondary)->Get4Momentum();
+          current4Mom.boost(targ4Mom.boostVector());
+          theSec->SetTotalEnergy(current4Mom.t());
+          theSec->SetMomentum(current4Mom.vect());
+          theResult->push_back(theSec);
+        }
+        G4std::for_each(secondaries->begin(), secondaries->end(), DeleteKineticTrack());
+        delete secondaries;
+      }
+    }
+
+    runningEnergy += (*current).second->Get4Momentum().t();
+    if((*current).second->GetDefinition() == G4Proton::Proton())
+      runningEnergy-=G4Proton::Proton()->GetPDGMass();
+    if((*current).second->GetDefinition() == G4Neutron::Neutron())
+      runningEnergy-=G4Neutron::Neutron()->GetPDGMass();
+
+#ifdef CHIPSdebug
+      G4cout << "sorted rapidities "<<(*current).second->Get4Momentum().rapidity()<<G4endl;  
+#endif
+
+    if(runningEnergy > theEnergyLostInFragmentation) break;
+    
+#ifdef CHIPSdebug
+     G4cout <<"ABSORBED STRING particles "<<(*current).second->GetDefinition()->GetPDGCharge()<<" "
+           << (*current).second->GetDefinition()->GetPDGEncoding()<<" "
+	   << (*current).second->Get4Momentum() <<G4endl; 
+#endif
+
+   // projectile 4-momentum in target rest frame needed in constructor of QHadron
+    particleCount++;
+    theHigh = (*current).second->Get4Momentum(); 
+    proj4Mom = (*current).second->Get4Momentum(); 
+    proj4Mom.boost(-1.*targ4Mom.boostVector());  
+    nD = (*current).second->GetDefinition()->GetQuarkContent(1);
+    nU = (*current).second->GetDefinition()->GetQuarkContent(2);
+    nS = (*current).second->GetDefinition()->GetQuarkContent(3);
+    nAD = (*current).second->GetDefinition()->GetAntiQuarkContent(1);
+    nAU = (*current).second->GetDefinition()->GetAntiQuarkContent(2);
+    nAS = (*current).second->GetDefinition()->GetAntiQuarkContent(3);
+    G4QContent aProjectile(nD, nU, nS, nAD, nAU, nAS);
+
+#ifdef CHIPSdebug_1
+    G4cout << G4endl;
+    G4cout << "Quark content: d="<<nD<<", u="<<nU<< ", s="<< nS << G4endl;
+    G4cout << "Anti-quark content: anit-d="<<nAD<<", anti-u="<<nAU<< ", anti-s="<< nAS << G4endl;
+    G4cout << "G4QContent is constructed"<<endl;
+#endif
+
+    theContents.push_back(aProjectile);
+    G4LorentzVector * aVec = new G4LorentzVector(1./MeV*proj4Mom);
+
+#ifdef CHIPSdebug_1
+    G4cout << "projectile momentum = "<<*aVec<<G4endl;
+    G4cout << G4endl;
+#endif
+   
+    theMomenta.push_back(aVec);
+  }
+  G4std::vector<G4QContent> theFinalContents;
+  G4std::vector<G4LorentzVector*> theFinalMomenta;
+  if(theContents.size()<hitCount || 1)
+  {
+    for(unsigned int hp = 0; hp<theContents.size(); hp++)
+    {
+      G4QHadron* aHadron = new G4QHadron(theContents[hp], *(theMomenta[hp]) );
+      projHV.push_back(aHadron);
+    }
+  }
+  else
+  {
+    unsigned int hp;
+    for(hp=0; hp<hitCount; hp++) 
+    {
+      G4QContent co(0, 0, 0, 0, 0, 0);
+      theFinalContents.push_back(co);
+      G4LorentzVector * mo = new G4LorentzVector(0,0,0,0);
+      theFinalMomenta.push_back(mo);
+    }
+    unsigned int running = 0;
+    while (running<theContents.size())
+    {
+      for(hp = 0; hp<hitCount; hp++)
+      {
+        theFinalContents[hp] +=theContents[running];
+	*(theFinalMomenta[hp])+=*(theMomenta[running]);
+	running++;
+	if(running == theContents.size()) break;
+      }
+    }
+    for(hp = 0; hp<hitCount; hp++)
+    {
+      G4QHadron* aHadron = new G4QHadron(theFinalContents[hp], *theFinalMomenta[hp]);
+      projHV.push_back(aHadron);
+    }
+  }
+  // construct the quasmon
+  size_t i;
+  for (i=0; i<theFinalMomenta.size(); i++) delete theFinalMomenta[i];
+  for (i=0; i<theMomenta.size();      i++) delete theMomenta[i];
+  theFinalMomenta.clear();
+  theMomenta.clear();
+
+  G4QNucleus::SetParameters(fractionOfSingleQuasiFreeNucleons,
+                            fractionOfPairedQuasiFreeNucleons,
+			                clusteringCoefficient, 
+					fusionToExchange);
+  G4Quasmon::SetParameters(temperature,
+                           halfTheStrangenessOfSee,
+			               etaToEtaPrime);
+
+#ifdef CHIPSdebug
+  G4cout << "G4QNucleus parameters "<< fractionOfSingleQuasiFreeNucleons << " "
+         << fractionOfPairedQuasiFreeNucleons << " "<< clusteringCoefficient << G4endl;
+  G4cout << "G4Quasmon parameters "<< temperature << " "<< halfTheStrangenessOfSee << " "
+         << etaToEtaPrime << G4endl;
+  G4cout << "The Target PDG code = "<<targetPDGCode<<G4endl;
+  G4cout << "The projectile momentum = "<<1./MeV*proj4Mom<<G4endl;
+  G4cout << "The target momentum = "<<1./MeV*targ4Mom<<G4endl;
+#endif
+
+  // now call chips with this info in place
+  G4QHadronVector * output = 0;
+  if (particleCount!=0 && resA!=0)
+  {
+    G4QCHIPSWorld aWorld(nop);              // Create CHIPS World of nop particles
+    G4QEnvironment* pan= new G4QEnvironment(projHV, targetPDGCode);
+    // clean up particles
+    G4std::for_each(projHV.begin(), projHV.end(), DeleteQHadron());
+    projHV.clear();
+    output = pan->Fragment();
+    delete pan;
+  }
+  else 
+  {
+    output = new G4QHadronVector;
+  }
+   
+  // Fill the result.
+#ifdef CHIPSdebug
+  G4cout << "NEXT EVENT"<<endl;
+#endif
+
+  // first decay and add all escaping particles.
+  for(current = firstEscaping; current!=theSorted.end(); current++)
+  {
+    G4KineticTrack * aResult = (*current).second;
+    G4ParticleDefinition * pdef=aResult->GetDefinition();
+    secondaries = NULL;
+    if ( pdef->GetPDGWidth() > 0 && pdef->GetPDGLifeTime() < 5E-17*s )
+    {
+      secondaries = aResult->Decay();
+    }
+    if ( secondaries == NULL )
+    {
+      theSec = new G4ReactionProduct(aResult->GetDefinition());
+      G4LorentzVector current4Mom = aResult->Get4Momentum();
+      current4Mom.boost(targ4Mom.boostVector());
+      theSec->SetTotalEnergy(current4Mom.t());
+      theSec->SetMomentum(current4Mom.vect());
+      theResult->push_back(theSec);
+    } 
+    else
+    {
+      for (unsigned int aSecondary=0; aSecondary<secondaries->size(); aSecondary++)
+      {
+        theSec = new G4ReactionProduct(secondaries->operator[](aSecondary)->GetDefinition());
+        G4LorentzVector current4Mom = secondaries->operator[](aSecondary)->Get4Momentum();
+        current4Mom.boost(targ4Mom.boostVector());
+        theSec->SetTotalEnergy(current4Mom.t());
+        theSec->SetMomentum(current4Mom.vect());
+        theResult->push_back(theSec);
+      }
+      G4std::for_each(secondaries->begin(), secondaries->end(), DeleteKineticTrack());
+      delete secondaries;
+    }
+  }
+  G4std::for_each(theSecondaries->begin(), theSecondaries->end(), DeleteKineticTrack());
+  delete theSecondaries;
+    
+  // now add the quasmon output
+  G4int maxParticle=output->size();
+#ifdef CHIPSdebug
+  G4cout << "Number of particles from string"<<theResult->size()<<G4endl;
+  G4cout << "Number of particles from chips"<<maxParticle<<G4endl;
+#endif
+  for(G4int particle = 0; particle < maxParticle; particle++)
+  {
+    if(output->operator[](particle)->GetNFragments() != 0) 
+    {
+      delete output->operator[](particle);
+      continue;
+    }
+    G4int pdgCode = output->operator[](particle)->GetPDGCode();
+
+
+#ifdef CHIPSdebug
+    G4cerr << "PDG code of chips particle = "<<pdgCode<<G4endl;
+#endif
+
+    G4ParticleDefinition * theDefinition;
+    // Note that I still have to take care of strange nuclei
+    // For this I need the mass calculation, and a changed interface
+    // for ion-table ==> work for Hisaya @@@@@@@
+    // Then I can sort out the pdgCode. I also need a decau process 
+    // for strange nuclei; may be another chips interface
+    if(pdgCode>90000000) 
+    {
+      G4int aZ = (pdgCode-90000000)/1000;
+      if (aZ>1000) aZ=aZ%1000;  // patch for strange nuclei, to be repaired @@@@
+      G4int anN = pdgCode-90000000-1000*aZ;
+      if(anN>1000) anN=anN%1000; // patch for strange nuclei, to be repaired @@@@
+      if(pdgCode==91000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==92000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==93000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==94000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==95000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==96000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==97000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(pdgCode==98000000) theDefinition = G4Lambda::LambdaDefinition();
+      else if(aZ == 0 && anN == 1) theDefinition = G4Neutron::Neutron();
+      else theDefinition = G4ParticleTable::GetParticleTable()->FindIon(aZ,anN+aZ,0,aZ);
+    }    
+    else theDefinition = G4ParticleTable::GetParticleTable()->FindParticle(pdgCode);
+
+#ifdef CHIPSdebug
+    G4cout << "Particle code produced = "<< pdgCode <<G4endl;
+#endif
+
+    theSec = new G4ReactionProduct(theDefinition);
+    G4LorentzVector current4Mom = output->operator[](particle)->Get4Momentum();
+    current4Mom.boost(targ4Mom.boostVector());
+    theSec->SetTotalEnergy(current4Mom.t());
+    theSec->SetMomentum(current4Mom.vect());
+    theResult->push_back(theSec);
+    
+#ifdef CHIPSdebug
+    G4cout <<"CHIPS particles "<<theDefinition->GetPDGCharge()<<" "
+           << theDefinition->GetPDGEncoding()<<" "
+	   << current4Mom <<G4endl; 
+#endif
+
+    delete output->operator[](particle);
+  }
+  delete output;
+
+#ifdef CHIPSdebug
+  G4cout << "Number of particles"<<theResult->size()<<G4endl;
+  G4cout << G4endl;
+  G4cout << "QUASMON preparation info "
+         << 1./MeV*proj4Mom<<" "
+	 << 1./MeV*targ4Mom<<" "
+	 << nD<<" "<<nU<<" "<<nS<<" "<<nAD<<" "<<nAU<<" "<<nAS<<" "
+	 << hitCount<<" "
+	 << particleCount<<" "
+	 << theLow<<" "
+	 << theHigh<<" "
+	 << G4endl;
+#endif
+
+  return theResult;
+} 

source/processes/hadronic/models/coherent_elastic/GNUmakefile

@@ -0,0 +1,36 @@
+# $Id: GNUmakefile,v 1.2 2001/10/11 08:53:58 fjones Exp $
+# -----------------------------------------------------------
+# GNUmakefile for hadronic library.  Gabriele Cosmo, 18/9/96.
+# -----------------------------------------------------------
+
+name := G4hadronic_coherent_elastic
+
+ifndef G4INSTALL
+  G4INSTALL = ../../../../..
+endif
+
+include $(G4INSTALL)/config/architecture.gmk
+
+CPPFLAGS += -I$(G4BASE)/global/management/include \
+            -I$(G4BASE)/global/HEPRandom/include \
+            -I$(G4BASE)/global/HEPGeometry/include \
+            -I$(G4BASE)/global/HEPNumerics/include \
+            -I$(G4BASE)/track/include \
+            -I$(G4BASE)/geometry/volumes/include \
+            -I$(G4BASE)/geometry/management/include \
+            -I$(G4BASE)/processes/management/include \
+            -I$(G4BASE)/processes/hadronic/management/include/ \
+            -I$(G4BASE)/processes/hadronic/util/include \
+            -I$(G4BASE)/processes/hadronic/cross_sections/include/ \
+            -I$(G4BASE)/particles/management/include \
+            -I$(G4BASE)/particles/leptons/include \
+            -I$(G4BASE)/particles/bosons/include \
+            -I$(G4BASE)/particles/hadrons/mesons/include \
+            -I$(G4BASE)/particles/hadrons/barions/include \
+            -I$(G4BASE)/particles/hadrons/ions/include \
+            -I$(G4BASE)/materials/include \
+            -I$(G4BASE)/myexample/include
+           
+   CPPFLAGS+=-I$(G4INSTALL)/tests/tools/include -DMAKEHBOOK -DMAKEBOOK
+
+include $(G4INSTALL)/config/common.gmk

source/processes/hadronic/models/coherent_elastic/include/G4LEnp.hh

@@ -0,0 +1,70 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+ //
+ // G4 Low energy model: n-n or p-p scattering
+ // F.W. Jones, L.G. Greeniaus, H.P. Wellisch
+ //  
+ // For further comments see G4LEnpData.hh and G4LEnp.cc
+ //
+
+#ifndef G4LEnp_h
+#define G4LEnp_h 1
+ 
+#include "globals.hh"
+#include "Randomize.hh"
+#include "G4Element.hh"
+#include "G4ElementVector.hh"
+#include "G4ElementTable.hh"
+#include "G4PhysicsTable.hh"
+#include "G4PhysicsVector.hh"
+#include "G4LPhysicsFreeVector.hh"
+#include "G4Gamma.hh"
+#include "G4Step.hh"
+#include "G4TrackStatus.hh"
+#include "G4HadronicInteraction.hh"
+
+class G4LEnp : public G4HadronicInteraction
+{
+ private:
+
+   enum { NENERGY=22, NANGLE=180 };
+
+ public:
+
+   G4LEnp();
+
+   ~G4LEnp();
+ 
+   G4VParticleChange* ApplyYourself(const G4Track& aTrack,
+                                    G4Nucleus& targetNucleus);
+
+   void SetCoulombSuppression(G4int State);
+  
+ private:
+
+   static G4float sig[NENERGY][NANGLE];
+   static G4float pcm[NENERGY], elab[NENERGY], 
+     dsigmax[NENERGY], sigtot[NENERGY];
+};
+
+#endif

source/processes/hadronic/models/coherent_elastic/include/G4LEnpData.hh

@@ -0,0 +1,637 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+
+ // G4 Low energy model: n-p scattering -- Data
+ // THIS FILE contains static array initialization
+ // F.W. Jones, L.G. Greeniaus, H.P. Wellisch
+
+
+// Table of Cumulative np Scattering Probabilities
+// To be used for generation as a function of cos(theta cm)
+// NOTE: Assumes angle range to be generated is 0-180 degrees
+//       This allows tracking of
+//       well-defined GEANT4 particles and generation of secondary
+// Range of validity of tables: 10 - 1200 MeV
+// Results are extracted from RA Arndt"s PSA of 1998
+// CM Angle range: 0.5 - 179.5 degrees in 1 degree steps
+// Data written 8 values/line, delimited by commas
+// Appended at end: cm momentum (GeV/c), Lab Energy (GeV), max 
+// dsigma/domega-CM (mb/sr), total cross section 
+
+ G4float G4LEnp::sig[NENERGY][NANGLE] = {
+   //------------  0.01 GeV
+   0.00007,   0.00030,   0.00066,   0.00118,   0.00184,   0.00265,   0.00360,
+   0.00471,   0.00595,   0.00735,   0.00888,   0.01057,   0.01239,   0.01436,
+   0.01648,   0.01874,   0.02113,   0.02367,   0.02635,   0.02917,   0.03213,
+   0.03523,   0.03847,   0.04184,   0.04534,   0.04899,   0.05276,   0.05667,
+   0.06071,   0.06488,   0.06917,   0.07360,   0.07815,   0.08283,   0.08763,
+   0.09255,   0.09760,   0.10276,   0.10805,   0.11345,   0.11896,   0.12459,
+   0.13033,   0.13618,   0.14214,   0.14821,   0.15438,   0.16066,   0.16704,
+   0.17352,   0.18009,   0.18677,   0.19353,   0.20039,   0.20734,   0.21438,
+   0.22151,   0.22871,   0.23601,   0.24338,   0.25083,   0.25835,   0.26595,
+   0.27362,   0.28136,   0.28917,   0.29704,   0.30497,   0.31297,   0.32102,
+   0.32913,   0.33729,   0.34550,   0.35376,   0.36207,   0.37042,   0.37881,
+   0.38724,   0.39570,   0.40420,   0.41273,   0.42129,   0.42988,   0.43848,
+   0.44711,   0.45576,   0.46443,   0.47310,   0.48179,   0.49049,   0.49919,
+   0.50789,   0.51659,   0.52530,   0.53399,   0.54268,   0.55136,   0.56003,
+   0.56868,   0.57731,   0.58592,   0.59451,   0.60307,   0.61161,   0.62011,
+   0.62858,   0.63701,   0.64540,   0.65376,   0.66206,   0.67032,   0.67853,
+   0.68669,   0.69480,   0.70285,   0.71083,   0.71876,   0.72662,   0.73442,
+   0.74214,   0.74979,   0.75737,   0.76487,   0.77230,   0.77964,   0.78689,
+   0.79407,   0.80115,   0.80814,   0.81504,   0.82184,   0.82854,   0.83515,
+   0.84165,   0.84805,   0.85434,   0.86052,   0.86659,   0.87255,   0.87840,
+   0.88413,   0.88974,   0.89523,   0.90060,   0.90584,   0.91096,   0.91595,
+   0.92081,   0.92554,   0.93014,   0.93460,   0.93892,   0.94311,   0.94716,
+   0.95107,   0.95484,   0.95847,   0.96195,   0.96528,   0.96847,   0.97151,
+   0.97440,   0.97714,   0.97973,   0.98217,   0.98445,   0.98658,   0.98856,
+   0.99038,   0.99204,   0.99355,   0.99490,   0.99610,   0.99713,   0.99801,
+   0.99872,   0.99928,   0.99968,   0.99992,   1.00000,
+   //---------  0.02 GeV
+   0.00008,   0.00030,   0.00068,   0.00120,   0.00188,   0.00271,   0.00368,
+   0.00480,   0.00608,   0.00750,   0.00906,   0.01078,   0.01264,   0.01465,
+   0.01680,   0.01909,   0.02153,   0.02411,   0.02684,   0.02970,   0.03270,
+   0.03584,   0.03912,   0.04254,   0.04609,   0.04977,   0.05359,   0.05753,
+   0.06161,   0.06582,   0.07015,   0.07461,   0.07919,   0.08390,   0.08873,
+   0.09367,   0.09874,   0.10392,   0.10922,   0.11463,   0.12015,   0.12578,
+   0.13152,   0.13737,   0.14332,   0.14937,   0.15553,   0.16178,   0.16813,
+   0.17458,   0.18112,   0.18775,   0.19447,   0.20128,   0.20817,   0.21515,
+   0.22221,   0.22935,   0.23657,   0.24386,   0.25123,   0.25866,   0.26617,
+   0.27374,   0.28138,   0.28908,   0.29685,   0.30467,   0.31255,   0.32048,
+   0.32846,   0.33650,   0.34458,   0.35271,   0.36088,   0.36909,   0.37734,
+   0.38563,   0.39395,   0.40231,   0.41069,   0.41911,   0.42754,   0.43600,
+   0.44448,   0.45298,   0.46150,   0.47003,   0.47857,   0.48712,   0.49568,
+   0.50424,   0.51280,   0.52136,   0.52992,   0.53848,   0.54703,   0.55557,
+   0.56409,   0.57260,   0.58110,   0.58957,   0.59803,   0.60645,   0.61486,
+   0.62323,   0.63157,   0.63988,   0.64815,   0.65639,   0.66458,   0.67273,
+   0.68083,   0.68889,   0.69689,   0.70484,   0.71274,   0.72057,   0.72835,
+   0.73607,   0.74372,   0.75130,   0.75881,   0.76625,   0.77362,   0.78090,
+   0.78811,   0.79524,   0.80228,   0.80924,   0.81611,   0.82289,   0.82957,
+   0.83616,   0.84265,   0.84904,   0.85533,   0.86151,   0.86759,   0.87356,
+   0.87942,   0.88516,   0.89079,   0.89630,   0.90168,   0.90695,   0.91209,
+   0.91711,   0.92200,   0.92675,   0.93138,   0.93587,   0.94022,   0.94443,
+   0.94851,   0.95244,   0.95623,   0.95987,   0.96336,   0.96670,   0.96989,
+   0.97293,   0.97582,   0.97854,   0.98111,   0.98352,   0.98578,   0.98786,
+   0.98979,   0.99155,   0.99315,   0.99459,   0.99585,   0.99695,   0.99788,
+   0.99864,   0.99924,   0.99966,   0.99992,   1.00000,
+   //---------  0.03 GeV
+   0.00008,   0.00032,   0.00073,   0.00129,   0.00201,   0.00289,   0.00393,
+   0.00513,   0.00649,   0.00801,   0.00968,   0.01150,   0.01348,   0.01561,
+   0.01790,   0.02033,   0.02291,   0.02564,   0.02852,   0.03154,   0.03470,
+   0.03801,   0.04145,   0.04503,   0.04875,   0.05261,   0.05659,   0.06071,
+   0.06495,   0.06932,   0.07382,   0.07844,   0.08318,   0.08804,   0.09302,
+   0.09811,   0.10331,   0.10863,   0.11405,   0.11958,   0.12522,   0.13096,
+   0.13679,   0.14273,   0.14876,   0.15489,   0.16111,   0.16742,   0.17382,
+   0.18030,   0.18687,   0.19352,   0.20025,   0.20705,   0.21394,   0.22089,
+   0.22792,   0.23501,   0.24218,   0.24941,   0.25670,   0.26405,   0.27147,
+   0.27894,   0.28646,   0.29404,   0.30167,   0.30935,   0.31708,   0.32486,
+   0.33268,   0.34054,   0.34844,   0.35638,   0.36435,   0.37236,   0.38040,
+   0.38848,   0.39658,   0.40471,   0.41286,   0.42104,   0.42924,   0.43746,
+   0.44569,   0.45395,   0.46221,   0.47049,   0.47878,   0.48708,   0.49538,
+   0.50369,   0.51201,   0.52032,   0.52863,   0.53694,   0.54524,   0.55354,
+   0.56183,   0.57010,   0.57837,   0.58662,   0.59485,   0.60306,   0.61125,
+   0.61942,   0.62756,   0.63568,   0.64377,   0.65182,   0.65984,   0.66783,
+   0.67577,   0.68368,   0.69155,   0.69937,   0.70714,   0.71486,   0.72253,
+   0.73015,   0.73772,   0.74522,   0.75267,   0.76005,   0.76737,   0.77462,
+   0.78180,   0.78891,   0.79594,   0.80290,   0.80978,   0.81658,   0.82329,
+   0.82993,   0.83647,   0.84292,   0.84928,   0.85554,   0.86171,   0.86777,
+   0.87374,   0.87960,   0.88535,   0.89099,   0.89652,   0.90194,   0.90724,
+   0.91242,   0.91747,   0.92241,   0.92721,   0.93188,   0.93643,   0.94083,
+   0.94510,   0.94923,   0.95322,   0.95706,   0.96075,   0.96429,   0.96767,
+   0.97091,   0.97398,   0.97689,   0.97964,   0.98222,   0.98464,   0.98688,
+   0.98896,   0.99086,   0.99258,   0.99413,   0.99550,   0.99669,   0.99770,
+   0.99853,   0.99917,   0.99963,   0.99991,   1.00000,
+   //---------  0.05 GeV
+   0.00010,   0.00040,   0.00089,   0.00157,   0.00245,   0.00352,   0.00478,
+   0.00623,   0.00787,   0.00970,   0.01170,   0.01389,   0.01626,   0.01880,
+   0.02151,   0.02439,   0.02744,   0.03065,   0.03402,   0.03754,   0.04122,
+   0.04505,   0.04902,   0.05313,   0.05738,   0.06176,   0.06628,   0.07092,
+   0.07568,   0.08057,   0.08557,   0.09068,   0.09590,   0.10123,   0.10666,
+   0.11219,   0.11781,   0.12353,   0.12933,   0.13522,   0.14119,   0.14725,
+   0.15337,   0.15957,   0.16585,   0.17218,   0.17859,   0.18505,   0.19157,
+   0.19816,   0.20479,   0.21148,   0.21821,   0.22499,   0.23182,   0.23869,
+   0.24560,   0.25255,   0.25953,   0.26655,   0.27361,   0.28069,   0.28781,
+   0.29495,   0.30212,   0.30932,   0.31654,   0.32378,   0.33105,   0.33834,
+   0.34565,   0.35298,   0.36032,   0.36769,   0.37507,   0.38247,   0.38988,
+   0.39731,   0.40476,   0.41221,   0.41968,   0.42717,   0.43466,   0.44217,
+   0.44969,   0.45722,   0.46476,   0.47231,   0.47987,   0.48744,   0.49501,
+   0.50260,   0.51019,   0.51778,   0.52539,   0.53300,   0.54061,   0.54823,
+   0.55584,   0.56347,   0.57109,   0.57871,   0.58633,   0.59395,   0.60157,
+   0.60918,   0.61678,   0.62438,   0.63197,   0.63955,   0.64711,   0.65467,
+   0.66221,   0.66973,   0.67723,   0.68472,   0.69218,   0.69961,   0.70702,
+   0.71440,   0.72175,   0.72907,   0.73635,   0.74360,   0.75080,   0.75796,
+   0.76508,   0.77215,   0.77918,   0.78615,   0.79306,   0.79992,   0.80672,
+   0.81346,   0.82013,   0.82674,   0.83328,   0.83974,   0.84613,   0.85244,
+   0.85867,   0.86482,   0.87088,   0.87685,   0.88273,   0.88851,   0.89420,
+   0.89978,   0.90526,   0.91063,   0.91589,   0.92103,   0.92605,   0.93095,
+   0.93572,   0.94036,   0.94487,   0.94923,   0.95345,   0.95751,   0.96143,
+   0.96518,   0.96876,   0.97218,   0.97542,   0.97849,   0.98136,   0.98405,
+   0.98654,   0.98884,   0.99093,   0.99281,   0.99448,   0.99593,   0.99717,
+   0.99819,   0.99898,   0.99955,   0.99989,   1.00000,
+   //---------  0.07 GeV
+   0.00012,   0.00048,   0.00108,   0.00191,   0.00298,   0.00427,   0.00580,
+   0.00755,   0.00952,   0.01171,   0.01412,   0.01673,   0.01954,   0.02256,
+   0.02577,   0.02916,   0.03274,   0.03649,   0.04041,   0.04450,   0.04874,
+   0.05314,   0.05768,   0.06237,   0.06719,   0.07214,   0.07722,   0.08241,
+   0.08772,   0.09313,   0.09865,   0.10426,   0.10996,   0.11575,   0.12162,
+   0.12757,   0.13359,   0.13968,   0.14583,   0.15204,   0.15830,   0.16462,
+   0.17098,   0.17738,   0.18382,   0.19029,   0.19679,   0.20333,   0.20988,
+   0.21646,   0.22306,   0.22968,   0.23630,   0.24294,   0.24959,   0.25625,
+   0.26291,   0.26958,   0.27625,   0.28291,   0.28958,   0.29625,   0.30292,
+   0.30958,   0.31624,   0.32290,   0.32955,   0.33620,   0.34284,   0.34948,
+   0.35612,   0.36275,   0.36939,   0.37601,   0.38264,   0.38927,   0.39589,
+   0.40252,   0.40915,   0.41578,   0.42241,   0.42905,   0.43570,   0.44235,
+   0.44901,   0.45568,   0.46237,   0.46906,   0.47576,   0.48248,   0.48922,
+   0.49597,   0.50274,   0.50952,   0.51633,   0.52315,   0.53000,   0.53686,
+   0.54375,   0.55066,   0.55759,   0.56454,   0.57152,   0.57851,   0.58553,
+   0.59257,   0.59963,   0.60671,   0.61381,   0.62093,   0.62807,   0.63523,
+   0.64239,   0.64958,   0.65677,   0.66398,   0.67119,   0.67841,   0.68564,
+   0.69286,   0.70009,   0.70731,   0.71453,   0.72174,   0.72894,   0.73613,
+   0.74329,   0.75044,   0.75757,   0.76467,   0.77174,   0.77879,   0.78579,
+   0.79276,   0.79968,   0.80656,   0.81340,   0.82018,   0.82690,   0.83357,
+   0.84018,   0.84672,   0.85320,   0.85960,   0.86593,   0.87218,   0.87835,
+   0.88443,   0.89042,   0.89632,   0.90212,   0.90782,   0.91341,   0.91890,
+   0.92426,   0.92950,   0.93462,   0.93960,   0.94443,   0.94913,   0.95366,
+   0.95804,   0.96225,   0.96628,   0.97012,   0.97377,   0.97722,   0.98045,
+   0.98347,   0.98625,   0.98880,   0.99111,   0.99316,   0.99495,   0.99648,
+   0.99774,   0.99873,   0.99943,   0.99986,   1.00000,
+   //---------  0.10 GeV
+   0.00015,   0.00060,   0.00133,   0.00235,   0.00366,   0.00524,   0.00710,
+   0.00923,   0.01162,   0.01427,   0.01716,   0.02030,   0.02366,   0.02724,
+   0.03104,   0.03503,   0.03922,   0.04360,   0.04815,   0.05287,   0.05775,
+   0.06278,   0.06795,   0.07325,   0.07868,   0.08423,   0.08988,   0.09563,
+   0.10148,   0.10742,   0.11343,   0.11951,   0.12567,   0.13187,   0.13813,
+   0.14444,   0.15078,   0.15716,   0.16357,   0.17000,   0.17644,   0.18290,
+   0.18936,   0.19582,   0.20228,   0.20874,   0.21519,   0.22162,   0.22803,
+   0.23442,   0.24080,   0.24714,   0.25346,   0.25974,   0.26600,   0.27222,
+   0.27841,   0.28456,   0.29068,   0.29676,   0.30280,   0.30881,   0.31478,
+   0.32071,   0.32661,   0.33247,   0.33830,   0.34410,   0.34987,   0.35560,
+   0.36131,   0.36700,   0.37266,   0.37830,   0.38392,   0.38953,   0.39512,
+   0.40070,   0.40628,   0.41185,   0.41741,   0.42298,   0.42856,   0.43414,
+   0.43973,   0.44533,   0.45095,   0.45659,   0.46226,   0.46795,   0.47367,
+   0.47942,   0.48520,   0.49102,   0.49689,   0.50279,   0.50874,   0.51474,
+   0.52078,   0.52688,   0.53303,   0.53924,   0.54550,   0.55181,   0.55819,
+   0.56462,   0.57111,   0.57766,   0.58427,   0.59094,   0.59767,   0.60445,
+   0.61129,   0.61819,   0.62514,   0.63215,   0.63920,   0.64631,   0.65346,
+   0.66065,   0.66789,   0.67516,   0.68246,   0.68980,   0.69717,   0.70455,
+   0.71196,   0.71938,   0.72681,   0.73425,   0.74169,   0.74913,   0.75656,
+   0.76398,   0.77138,   0.77876,   0.78611,   0.79344,   0.80072,   0.80797,
+   0.81517,   0.82232,   0.82942,   0.83646,   0.84343,   0.85034,   0.85718,
+   0.86395,   0.87063,   0.87724,   0.88375,   0.89017,   0.89650,   0.90273,
+   0.90885,   0.91485,   0.92074,   0.92650,   0.93213,   0.93762,   0.94297,
+   0.94815,   0.95316,   0.95800,   0.96264,   0.96707,   0.97129,   0.97528,
+   0.97902,   0.98250,   0.98570,   0.98861,   0.99122,   0.99351,   0.99547,
+   0.99708,   0.99835,   0.99927,   0.99982,   1.00000,
+   //---------  0.14 GeV
+   0.00018,   0.00069,   0.00154,   0.00271,   0.00421,   0.00603,   0.00816,
+   0.01058,   0.01329,   0.01628,   0.01953,   0.02304,   0.02678,   0.03075,
+   0.03494,   0.03933,   0.04391,   0.04867,   0.05360,   0.05868,   0.06391,
+   0.06928,   0.07478,   0.08039,   0.08611,   0.09193,   0.09784,   0.10383,
+   0.10989,   0.11602,   0.12220,   0.12843,   0.13470,   0.14101,   0.14734,
+   0.15369,   0.16005,   0.16642,   0.17279,   0.17915,   0.18550,   0.19183,
+   0.19815,   0.20443,   0.21069,   0.21690,   0.22309,   0.22922,   0.23532,
+   0.24136,   0.24736,   0.25330,   0.25919,   0.26502,   0.27079,   0.27651,
+   0.28217,   0.28777,   0.29331,   0.29879,   0.30421,   0.30958,   0.31489,
+   0.32015,   0.32536,   0.33051,   0.33562,   0.34068,   0.34569,   0.35067,
+   0.35561,   0.36051,   0.36538,   0.37022,   0.37504,   0.37984,   0.38462,
+   0.38939,   0.39414,   0.39890,   0.40365,   0.40840,   0.41316,   0.41794,
+   0.42273,   0.42754,   0.43237,   0.43723,   0.44213,   0.44706,   0.45204,
+   0.45706,   0.46213,   0.46725,   0.47243,   0.47768,   0.48298,   0.48836,
+   0.49380,   0.49933,   0.50492,   0.51060,   0.51636,   0.52221,   0.52814,
+   0.53416,   0.54027,   0.54647,   0.55277,   0.55915,   0.56563,   0.57221,
+   0.57887,   0.58563,   0.59248,   0.59941,   0.60644,   0.61355,   0.62075,
+   0.62803,   0.63538,   0.64281,   0.65031,   0.65788,   0.66551,   0.67320,
+   0.68094,   0.68873,   0.69656,   0.70443,   0.71233,   0.72025,   0.72819,
+   0.73614,   0.74409,   0.75205,   0.75999,   0.76792,   0.77583,   0.78370,
+   0.79155,   0.79935,   0.80710,   0.81480,   0.82244,   0.83001,   0.83752,
+   0.84495,   0.85230,   0.85956,   0.86674,   0.87382,   0.88080,   0.88769,
+   0.89446,   0.90113,   0.90769,   0.91412,   0.92043,   0.92660,   0.93263,
+   0.93852,   0.94424,   0.94978,   0.95514,   0.96030,   0.96524,   0.96994,
+   0.97438,   0.97854,   0.98240,   0.98593,   0.98912,   0.99193,   0.99435,
+   0.99636,   0.99794,   0.99908,   0.99977,   1.00000,
+   //---------  0.18 GeV
+   0.00019,   0.00073,   0.00162,   0.00286,   0.00444,   0.00635,   0.00857,
+   0.01110,   0.01391,   0.01701,   0.02036,   0.02396,   0.02779,   0.03185,
+   0.03610,   0.04055,   0.04518,   0.04998,   0.05494,   0.06004,   0.06528,
+   0.07065,   0.07613,   0.08172,   0.08741,   0.09319,   0.09906,   0.10499,
+   0.11099,   0.11705,   0.12316,   0.12931,   0.13550,   0.14171,   0.14794,
+   0.15419,   0.16045,   0.16670,   0.17296,   0.17920,   0.18543,   0.19163,
+   0.19781,   0.20396,   0.21008,   0.21615,   0.22219,   0.22817,   0.23411,
+   0.24000,   0.24584,   0.25162,   0.25734,   0.26300,   0.26861,   0.27415,
+   0.27963,   0.28505,   0.29041,   0.29571,   0.30094,   0.30612,   0.31124,
+   0.31630,   0.32131,   0.32627,   0.33117,   0.33603,   0.34084,   0.34560,
+   0.35033,   0.35502,   0.35968,   0.36430,   0.36890,   0.37348,   0.37804,
+   0.38258,   0.38711,   0.39163,   0.39615,   0.40067,   0.40520,   0.40974,
+   0.41429,   0.41886,   0.42345,   0.42808,   0.43273,   0.43742,   0.44215,
+   0.44693,   0.45175,   0.45663,   0.46156,   0.46656,   0.47163,   0.47676,
+   0.48197,   0.48725,   0.49261,   0.49806,   0.50359,   0.50921,   0.51493,
+   0.52074,   0.52664,   0.53265,   0.53875,   0.54496,   0.55127,   0.55768,
+   0.56420,   0.57082,   0.57755,   0.58439,   0.59132,   0.59836,   0.60550,
+   0.61274,   0.62008,   0.62751,   0.63503,   0.64264,   0.65033,   0.65810,
+   0.66594,   0.67385,   0.68182,   0.68985,   0.69793,   0.70606,   0.71422,
+   0.72240,   0.73061,   0.73884,   0.74706,   0.75529,   0.76350,   0.77170,
+   0.77987,   0.78800,   0.79609,   0.80412,   0.81210,   0.82001,   0.82785,
+   0.83561,   0.84329,   0.85087,   0.85836,   0.86575,   0.87303,   0.88021,
+   0.88727,   0.89422,   0.90105,   0.90776,   0.91435,   0.92080,   0.92712,
+   0.93329,   0.93931,   0.94517,   0.95086,   0.95636,   0.96165,   0.96672,
+   0.97153,   0.97607,   0.98030,   0.98420,   0.98774,   0.99088,   0.99360,
+   0.99587,   0.99766,   0.99895,   0.99974,   1.00000,
+   //---------  0.24 GeV
+   0.00019,   0.00074,   0.00163,   0.00288,   0.00445,   0.00635,   0.00855,
+   0.01104,   0.01381,   0.01683,   0.02010,   0.02360,   0.02732,   0.03123,
+   0.03534,   0.03962,   0.04408,   0.04869,   0.05346,   0.05837,   0.06341,
+   0.06858,   0.07388,   0.07929,   0.08480,   0.09042,   0.09613,   0.10192,
+   0.10780,   0.11374,   0.11976,   0.12583,   0.13196,   0.13813,   0.14434,
+   0.15058,   0.15686,   0.16315,   0.16945,   0.17577,   0.18208,   0.18840,
+   0.19470,   0.20099,   0.20727,   0.21352,   0.21974,   0.22593,   0.23208,
+   0.23819,   0.24426,   0.25029,   0.25626,   0.26219,   0.26805,   0.27387,
+   0.27962,   0.28532,   0.29095,   0.29653,   0.30205,   0.30750,   0.31290,
+   0.31824,   0.32351,   0.32873,   0.33390,   0.33901,   0.34407,   0.34907,
+   0.35403,   0.35895,   0.36382,   0.36865,   0.37344,   0.37820,   0.38294,
+   0.38764,   0.39232,   0.39698,   0.40163,   0.40626,   0.41089,   0.41551,
+   0.42013,   0.42475,   0.42939,   0.43403,   0.43869,   0.44337,   0.44807,
+   0.45280,   0.45757,   0.46236,   0.46720,   0.47208,   0.47701,   0.48199,
+   0.48703,   0.49213,   0.49729,   0.50251,   0.50781,   0.51318,   0.51862,
+   0.52415,   0.52976,   0.53545,   0.54124,   0.54712,   0.55309,   0.55916,
+   0.56532,   0.57159,   0.57796,   0.58443,   0.59101,   0.59769,   0.60448,
+   0.61137,   0.61837,   0.62547,   0.63267,   0.63997,   0.64737,   0.65486,
+   0.66245,   0.67012,   0.67788,   0.68571,   0.69362,   0.70159,   0.70962,
+   0.71770,   0.72583,   0.73400,   0.74220,   0.75041,   0.75864,   0.76687,
+   0.77509,   0.78329,   0.79146,   0.79960,   0.80768,   0.81571,   0.82368,
+   0.83157,   0.83937,   0.84708,   0.85470,   0.86220,   0.86960,   0.87688,
+   0.88403,   0.89106,   0.89797,   0.90474,   0.91138,   0.91788,   0.92425,
+   0.93048,   0.93656,   0.94249,   0.94827,   0.95387,   0.95929,   0.96451,
+   0.96950,   0.97424,   0.97870,   0.98284,   0.98662,   0.99001,   0.99296,
+   0.99544,   0.99741,   0.99884,   0.99971,   1.00000,
+   //---------  0.34 GeV
+   0.00019,   0.00072,   0.00159,   0.00279,   0.00431,   0.00612,   0.00823,
+   0.01060,   0.01322,   0.01608,   0.01917,   0.02247,   0.02598,   0.02969,
+   0.03359,   0.03768,   0.04195,   0.04641,   0.05104,   0.05584,   0.06082,
+   0.06596,   0.07126,   0.07673,   0.08235,   0.08811,   0.09403,   0.10008,
+   0.10626,   0.11257,   0.11900,   0.12554,   0.13219,   0.13893,   0.14576,
+   0.15267,   0.15965,   0.16669,   0.17379,   0.18094,   0.18812,   0.19533,
+   0.20257,   0.20981,   0.21706,   0.22430,   0.23153,   0.23874,   0.24592,
+   0.25307,   0.26017,   0.26724,   0.27424,   0.28120,   0.28808,   0.29491,
+   0.30166,   0.30834,   0.31494,   0.32147,   0.32791,   0.33427,   0.34055,
+   0.34674,   0.35285,   0.35888,   0.36483,   0.37069,   0.37647,   0.38217,
+   0.38779,   0.39334,   0.39882,   0.40422,   0.40956,   0.41483,   0.42004,
+   0.42519,   0.43028,   0.43532,   0.44031,   0.44525,   0.45015,   0.45501,
+   0.45984,   0.46463,   0.46940,   0.47414,   0.47886,   0.48356,   0.48825,
+   0.49292,   0.49759,   0.50226,   0.50693,   0.51160,   0.51629,   0.52098,
+   0.52568,   0.53041,   0.53516,   0.53994,   0.54474,   0.54958,   0.55446,
+   0.55937,   0.56434,   0.56935,   0.57441,   0.57953,   0.58471,   0.58996,
+   0.59527,   0.60065,   0.60611,   0.61165,   0.61727,   0.62297,   0.62877,
+   0.63465,   0.64063,   0.64670,   0.65287,   0.65914,   0.66552,   0.67199,
+   0.67857,   0.68525,   0.69202,   0.69890,   0.70588,   0.71295,   0.72011,
+   0.72736,   0.73469,   0.74209,   0.74957,   0.75711,   0.76470,   0.77233,
+   0.78001,   0.78771,   0.79542,   0.80314,   0.81086,   0.81855,   0.82621,
+   0.83383,   0.84140,   0.84889,   0.85631,   0.86365,   0.87088,   0.87800,
+   0.88500,   0.89188,   0.89864,   0.90525,   0.91173,   0.91806,   0.92425,
+   0.93030,   0.93621,   0.94197,   0.94758,   0.95304,   0.95835,   0.96348,
+   0.96843,   0.97316,   0.97766,   0.98188,   0.98579,   0.98932,   0.99244,
+   0.99508,   0.99719,   0.99874,   0.99968,   1.00000,
+   //---------  0.42 GeV
+   0.00020,   0.00075,   0.00165,   0.00289,   0.00445,   0.00633,   0.00849,
+   0.01094,   0.01364,   0.01660,   0.01979,   0.02322,   0.02688,   0.03077,
+   0.03487,   0.03920,   0.04375,   0.04852,   0.05350,   0.05870,   0.06411,
+   0.06973,   0.07556,   0.08159,   0.08782,   0.09423,   0.10084,   0.10761,
+   0.11456,   0.12167,   0.12893,   0.13633,   0.14386,   0.15152,   0.15928,
+   0.16715,   0.17510,   0.18313,   0.19123,   0.19938,   0.20757,   0.21580,
+   0.22404,   0.23229,   0.24054,   0.24877,   0.25698,   0.26515,   0.27328,
+   0.28135,   0.28937,   0.29732,   0.30519,   0.31298,   0.32068,   0.32829,
+   0.33580,   0.34320,   0.35051,   0.35771,   0.36479,   0.37177,   0.37864,
+   0.38539,   0.39204,   0.39857,   0.40499,   0.41131,   0.41751,   0.42362,
+   0.42962,   0.43551,   0.44132,   0.44702,   0.45264,   0.45816,   0.46361,
+   0.46896,   0.47424,   0.47945,   0.48458,   0.48964,   0.49464,   0.49958,
+   0.50446,   0.50928,   0.51405,   0.51878,   0.52345,   0.52809,   0.53269,
+   0.53725,   0.54178,   0.54628,   0.55076,   0.55521,   0.55965,   0.56407,
+   0.56847,   0.57287,   0.57726,   0.58165,   0.58604,   0.59044,   0.59484,
+   0.59925,   0.60368,   0.60813,   0.61260,   0.61710,   0.62163,   0.62620,
+   0.63080,   0.63545,   0.64015,   0.64490,   0.64970,   0.65457,   0.65950,
+   0.66450,   0.66958,   0.67473,   0.67997,   0.68529,   0.69070,   0.69620,
+   0.70179,   0.70749,   0.71328,   0.71917,   0.72516,   0.73126,   0.73745,
+   0.74374,   0.75014,   0.75662,   0.76320,   0.76987,   0.77661,   0.78343,
+   0.79032,   0.79727,   0.80427,   0.81131,   0.81839,   0.82548,   0.83258,
+   0.83967,   0.84675,   0.85380,   0.86081,   0.86776,   0.87464,   0.88144,
+   0.88815,   0.89475,   0.90125,   0.90762,   0.91386,   0.91997,   0.92594,
+   0.93177,   0.93746,   0.94301,   0.94842,   0.95368,   0.95880,   0.96376,
+   0.96855,   0.97316,   0.97757,   0.98173,   0.98560,   0.98913,   0.99227,
+   0.99495,   0.99711,   0.99870,   0.99967,   1.00000,
+   //---------  0.50 GeV
+   0.00023,   0.00086,   0.00190,   0.00333,   0.00513,   0.00729,   0.00979,
+   0.01261,   0.01574,   0.01917,   0.02288,   0.02688,   0.03115,   0.03570,
+   0.04053,   0.04562,   0.05098,   0.05661,   0.06251,   0.06866,   0.07507,
+   0.08173,   0.08863,   0.09577,   0.10314,   0.11072,   0.11851,   0.12650,
+   0.13468,   0.14303,   0.15154,   0.16020,   0.16900,   0.17791,   0.18693,
+   0.19605,   0.20524,   0.21449,   0.22379,   0.23312,   0.24247,   0.25182,
+   0.26117,   0.27048,   0.27977,   0.28900,   0.29818,   0.30728,   0.31630,
+   0.32523,   0.33406,   0.34278,   0.35138,   0.35987,   0.36823,   0.37645,
+   0.38454,   0.39250,   0.40031,   0.40798,   0.41551,   0.42289,   0.43013,
+   0.43723,   0.44419,   0.45101,   0.45769,   0.46424,   0.47065,   0.47694,
+   0.48310,   0.48913,   0.49505,   0.50085,   0.50654,   0.51212,   0.51759,
+   0.52297,   0.52824,   0.53342,   0.53852,   0.54352,   0.54845,   0.55329,
+   0.55806,   0.56276,   0.56739,   0.57195,   0.57645,   0.58089,   0.58528,
+   0.58961,   0.59390,   0.59814,   0.60233,   0.60648,   0.61060,   0.61468,
+   0.61873,   0.62275,   0.62675,   0.63072,   0.63467,   0.63861,   0.64253,
+   0.64645,   0.65035,   0.65426,   0.65816,   0.66207,   0.66598,   0.66991,
+   0.67385,   0.67781,   0.68180,   0.68581,   0.68985,   0.69393,   0.69806,
+   0.70222,   0.70644,   0.71071,   0.71505,   0.71944,   0.72391,   0.72844,
+   0.73306,   0.73776,   0.74254,   0.74741,   0.75237,   0.75742,   0.76257,
+   0.76782,   0.77317,   0.77862,   0.78416,   0.78980,   0.79553,   0.80136,
+   0.80727,   0.81327,   0.81934,   0.82548,   0.83168,   0.83794,   0.84423,
+   0.85056,   0.85690,   0.86325,   0.86960,   0.87592,   0.88222,   0.88846,
+   0.89465,   0.90076,   0.90678,   0.91271,   0.91853,   0.92424,   0.92982,
+   0.93528,   0.94061,   0.94580,   0.95086,   0.95579,   0.96058,   0.96523,
+   0.96973,   0.97408,   0.97825,   0.98221,   0.98592,   0.98933,   0.99238,
+   0.99500,   0.99713,   0.99871,   0.99967,   1.00000,
+   //---------  0.58 GeV
+   0.00029,   0.00110,   0.00243,   0.00427,   0.00660,   0.00938,   0.01260,
+   0.01623,   0.02027,   0.02469,   0.02948,   0.03464,   0.04015,   0.04601,
+   0.05222,   0.05876,   0.06564,   0.07283,   0.08034,   0.08815,   0.09626,
+   0.10465,   0.11331,   0.12223,   0.13138,   0.14077,   0.15037,   0.16017,
+   0.17014,   0.18027,   0.19055,   0.20096,   0.21147,   0.22207,   0.23275,
+   0.24347,   0.25423,   0.26500,   0.27577,   0.28652,   0.29723,   0.30789,
+   0.31847,   0.32897,   0.33938,   0.34967,   0.35984,   0.36987,   0.37975,
+   0.38948,   0.39905,   0.40845,   0.41767,   0.42671,   0.43556,   0.44423,
+   0.45271,   0.46099,   0.46909,   0.47699,   0.48471,   0.49223,   0.49957,
+   0.50673,   0.51371,   0.52051,   0.52714,   0.53360,   0.53989,   0.54603,
+   0.55201,   0.55785,   0.56354,   0.56908,   0.57450,   0.57978,   0.58494,
+   0.58997,   0.59489,   0.59970,   0.60440,   0.60900,   0.61350,   0.61790,
+   0.62221,   0.62644,   0.63059,   0.63465,   0.63865,   0.64257,   0.64643,
+   0.65022,   0.65395,   0.65763,   0.66125,   0.66483,   0.66836,   0.67184,
+   0.67529,   0.67870,   0.68208,   0.68543,   0.68876,   0.69206,   0.69534,
+   0.69860,   0.70185,   0.70509,   0.70832,   0.71155,   0.71478,   0.71802,
+   0.72126,   0.72451,   0.72777,   0.73105,   0.73436,   0.73769,   0.74105,
+   0.74444,   0.74787,   0.75134,   0.75486,   0.75843,   0.76206,   0.76575,
+   0.76949,   0.77331,   0.77720,   0.78116,   0.78520,   0.78933,   0.79354,
+   0.79784,   0.80222,   0.80670,   0.81128,   0.81594,   0.82070,   0.82555,
+   0.83049,   0.83552,   0.84064,   0.84583,   0.85110,   0.85643,   0.86182,
+   0.86726,   0.87274,   0.87825,   0.88378,   0.88931,   0.89484,   0.90034,
+   0.90581,   0.91122,   0.91657,   0.92185,   0.92703,   0.93212,   0.93710,
+   0.94196,   0.94671,   0.95132,   0.95582,   0.96018,   0.96443,   0.96855,
+   0.97254,   0.97640,   0.98011,   0.98366,   0.98701,   0.99011,   0.99290,
+   0.99532,   0.99731,   0.99878,   0.99969,   1.00000,
+   //---------  0.62 GeV
+   0.00033,   0.00125,   0.00277,   0.00487,   0.00752,   0.01069,   0.01436,
+   0.01850,   0.02311,   0.02815,   0.03361,   0.03949,   0.04576,   0.05243,
+   0.05948,   0.06691,   0.07469,   0.08283,   0.09130,   0.10010,   0.10920,
+   0.11860,   0.12828,   0.13822,   0.14841,   0.15881,   0.16943,   0.18023,
+   0.19119,   0.20230,   0.21354,   0.22488,   0.23630,   0.24779,   0.25931,
+   0.27086,   0.28241,   0.29393,   0.30542,   0.31686,   0.32821,   0.33948,
+   0.35063,   0.36166,   0.37255,   0.38329,   0.39387,   0.40427,   0.41448,
+   0.42451,   0.43433,   0.44395,   0.45335,   0.46254,   0.47151,   0.48026,
+   0.48880,   0.49711,   0.50520,   0.51307,   0.52073,   0.52818,   0.53541,
+   0.54245,   0.54928,   0.55592,   0.56236,   0.56862,   0.57470,   0.58061,
+   0.58635,   0.59192,   0.59734,   0.60260,   0.60772,   0.61270,   0.61754,
+   0.62225,   0.62684,   0.63131,   0.63566,   0.63990,   0.64404,   0.64808,
+   0.65203,   0.65588,   0.65965,   0.66334,   0.66695,   0.67049,   0.67396,
+   0.67736,   0.68071,   0.68399,   0.68723,   0.69042,   0.69356,   0.69666,
+   0.69973,   0.70276,   0.70576,   0.70874,   0.71169,   0.71462,   0.71753,
+   0.72043,   0.72332,   0.72620,   0.72908,   0.73195,   0.73483,   0.73772,
+   0.74062,   0.74353,   0.74645,   0.74939,   0.75236,   0.75535,   0.75838,
+   0.76143,   0.76453,   0.76767,   0.77085,   0.77408,   0.77736,   0.78070,
+   0.78410,   0.78756,   0.79110,   0.79470,   0.79838,   0.80214,   0.80598,
+   0.80990,   0.81391,   0.81801,   0.82220,   0.82648,   0.83086,   0.83532,
+   0.83988,   0.84452,   0.84925,   0.85406,   0.85895,   0.86392,   0.86894,
+   0.87403,   0.87916,   0.88433,   0.88952,   0.89474,   0.89995,   0.90515,
+   0.91032,   0.91546,   0.92054,   0.92555,   0.93049,   0.93533,   0.94007,
+   0.94470,   0.94921,   0.95360,   0.95786,   0.96201,   0.96603,   0.96993,
+   0.97371,   0.97737,   0.98090,   0.98427,   0.98746,   0.99043,   0.99312,
+   0.99546,   0.99738,   0.99881,   0.99970,   1.00000,
+   //---------  0.68 GeV
+   0.00038,   0.00148,   0.00327,   0.00575,   0.00888,   0.01263,   0.01698,
+   0.02189,   0.02733,   0.03330,   0.03977,   0.04672,   0.05414,   0.06201,
+   0.07032,   0.07906,   0.08819,   0.09771,   0.10760,   0.11783,   0.12839,
+   0.13924,   0.15038,   0.16178,   0.17340,   0.18524,   0.19725,   0.20943,
+   0.22173,   0.23415,   0.24665,   0.25920,   0.27179,   0.28438,   0.29697,
+   0.30951,   0.32199,   0.33439,   0.34669,   0.35887,   0.37091,   0.38279,
+   0.39449,   0.40600,   0.41732,   0.42841,   0.43928,   0.44992,   0.46031,
+   0.47046,   0.48034,   0.48997,   0.49934,   0.50844,   0.51728,   0.52586,
+   0.53418,   0.54223,   0.55003,   0.55758,   0.56489,   0.57195,   0.57877,
+   0.58536,   0.59173,   0.59789,   0.60383,   0.60957,   0.61511,   0.62047,
+   0.62564,   0.63064,   0.63546,   0.64013,   0.64464,   0.64901,   0.65323,
+   0.65732,   0.66128,   0.66512,   0.66884,   0.67245,   0.67596,   0.67937,
+   0.68269,   0.68592,   0.68907,   0.69215,   0.69515,   0.69809,   0.70097,
+   0.70379,   0.70656,   0.70928,   0.71196,   0.71460,   0.71721,   0.71978,
+   0.72233,   0.72486,   0.72737,   0.72986,   0.73234,   0.73481,   0.73728,
+   0.73974,   0.74221,   0.74467,   0.74715,   0.74963,   0.75212,   0.75463,
+   0.75715,   0.75970,   0.76227,   0.76486,   0.76748,   0.77013,   0.77282,
+   0.77554,   0.77830,   0.78110,   0.78395,   0.78685,   0.78980,   0.79281,
+   0.79587,   0.79899,   0.80218,   0.80544,   0.80877,   0.81217,   0.81565,
+   0.81921,   0.82286,   0.82659,   0.83040,   0.83431,   0.83831,   0.84240,
+   0.84658,   0.85085,   0.85521,   0.85966,   0.86419,   0.86881,   0.87350,
+   0.87825,   0.88307,   0.88794,   0.89285,   0.89779,   0.90274,   0.90771,
+   0.91266,   0.91760,   0.92249,   0.92733,   0.93211,   0.93681,   0.94141,
+   0.94592,   0.95031,   0.95459,   0.95874,   0.96278,   0.96669,   0.97048,
+   0.97416,   0.97772,   0.98115,   0.98444,   0.98757,   0.99048,   0.99313,
+   0.99546,   0.99737,   0.99881,   0.99970,   1.00000,
+   //---------  0.74 GeV
+   0.00043,   0.00168,   0.00373,   0.00655,   0.01012,   0.01440,   0.01935,
+   0.02495,   0.03117,   0.03798,   0.04537,   0.05330,   0.06176,   0.07073,
+   0.08018,   0.09010,   0.10045,   0.11121,   0.12235,   0.13386,   0.14569,
+   0.15782,   0.17022,   0.18285,   0.19570,   0.20873,   0.22190,   0.23519,
+   0.24856,   0.26200,   0.27546,   0.28892,   0.30236,   0.31574,   0.32905,
+   0.34225,   0.35532,   0.36824,   0.38099,   0.39355,   0.40591,   0.41803,
+   0.42992,   0.44155,   0.45292,   0.46401,   0.47482,   0.48533,   0.49555,
+   0.50547,   0.51509,   0.52440,   0.53341,   0.54212,   0.55052,   0.55863,
+   0.56645,   0.57398,   0.58123,   0.58821,   0.59492,   0.60137,   0.60757,
+   0.61353,   0.61925,   0.62475,   0.63002,   0.63509,   0.63996,   0.64464,
+   0.64913,   0.65345,   0.65761,   0.66160,   0.66545,   0.66915,   0.67272,
+   0.67616,   0.67948,   0.68269,   0.68580,   0.68880,   0.69171,   0.69454,
+   0.69729,   0.69997,   0.70258,   0.70512,   0.70762,   0.71006,   0.71246,
+   0.71482,   0.71714,   0.71943,   0.72170,   0.72395,   0.72618,   0.72840,
+   0.73060,   0.73280,   0.73500,   0.73720,   0.73941,   0.74162,   0.74384,
+   0.74607,   0.74831,   0.75057,   0.75286,   0.75516,   0.75748,   0.75983,
+   0.76221,   0.76461,   0.76705,   0.76952,   0.77202,   0.77456,   0.77713,
+   0.77975,   0.78240,   0.78510,   0.78784,   0.79063,   0.79348,   0.79637,
+   0.79932,   0.80232,   0.80538,   0.80851,   0.81170,   0.81497,   0.81830,
+   0.82170,   0.82519,   0.82875,   0.83240,   0.83613,   0.83995,   0.84386,
+   0.84785,   0.85194,   0.85612,   0.86038,   0.86474,   0.86918,   0.87370,
+   0.87829,   0.88296,   0.88769,   0.89247,   0.89730,   0.90216,   0.90704,
+   0.91193,   0.91682,   0.92168,   0.92650,   0.93127,   0.93598,   0.94061,
+   0.94514,   0.94957,   0.95389,   0.95809,   0.96217,   0.96613,   0.96997,
+   0.97368,   0.97728,   0.98075,   0.98409,   0.98726,   0.99022,   0.99293,
+   0.99531,   0.99728,   0.99877,   0.99969,   1.00000,
+   //---------  0.80 GeV
+   0.00048,   0.00187,   0.00414,   0.00728,   0.01125,   0.01601,   0.02152,
+   0.02775,   0.03467,   0.04225,   0.05046,   0.05928,   0.06868,   0.07863,
+   0.08910,   0.10007,   0.11150,   0.12335,   0.13560,   0.14821,   0.16114,
+   0.17435,   0.18782,   0.20150,   0.21536,   0.22936,   0.24347,   0.25764,
+   0.27186,   0.28608,   0.30027,   0.31440,   0.32844,   0.34237,   0.35615,
+   0.36976,   0.38318,   0.39638,   0.40935,   0.42206,   0.43450,   0.44666,
+   0.45851,   0.47006,   0.48128,   0.49218,   0.50275,   0.51298,   0.52287,
+   0.53242,   0.54164,   0.55052,   0.55906,   0.56728,   0.57518,   0.58275,
+   0.59002,   0.59699,   0.60366,   0.61005,   0.61617,   0.62202,   0.62761,
+   0.63296,   0.63808,   0.64296,   0.64764,   0.65210,   0.65637,   0.66046,
+   0.66436,   0.66811,   0.67169,   0.67512,   0.67841,   0.68157,   0.68461,
+   0.68753,   0.69035,   0.69306,   0.69568,   0.69822,   0.70068,   0.70307,
+   0.70539,   0.70766,   0.70987,   0.71204,   0.71417,   0.71626,   0.71833,
+   0.72037,   0.72239,   0.72440,   0.72639,   0.72838,   0.73037,   0.73236,
+   0.73436,   0.73636,   0.73838,   0.74041,   0.74246,   0.74452,   0.74661,
+   0.74873,   0.75086,   0.75303,   0.75523,   0.75745,   0.75971,   0.76200,
+   0.76433,   0.76669,   0.76909,   0.77153,   0.77400,   0.77651,   0.77907,
+   0.78166,   0.78429,   0.78697,   0.78969,   0.79245,   0.79526,   0.79812,
+   0.80103,   0.80399,   0.80700,   0.81007,   0.81320,   0.81639,   0.81964,
+   0.82296,   0.82635,   0.82981,   0.83334,   0.83696,   0.84066,   0.84444,
+   0.84831,   0.85226,   0.85630,   0.86044,   0.86466,   0.86896,   0.87336,
+   0.87783,   0.88238,   0.88701,   0.89170,   0.89644,   0.90123,   0.90605,
+   0.91089,   0.91575,   0.92059,   0.92542,   0.93020,   0.93493,   0.93959,
+   0.94417,   0.94865,   0.95303,   0.95729,   0.96143,   0.96545,   0.96935,
+   0.97312,   0.97677,   0.98030,   0.98369,   0.98691,   0.98994,   0.99271,
+   0.99516,   0.99719,   0.99872,   0.99968,   1.00000,
+   //---------  0.90 GeV
+   0.00056,   0.00217,   0.00482,   0.00847,   0.01308,   0.01861,   0.02502,
+   0.03227,   0.04031,   0.04912,   0.05865,   0.06887,   0.07974,   0.09123,
+   0.10329,   0.11587,   0.12895,   0.14246,   0.15636,   0.17061,   0.18515,
+   0.19995,   0.21495,   0.23011,   0.24538,   0.26072,   0.27608,   0.29143,
+   0.30673,   0.32194,   0.33703,   0.35195,   0.36668,   0.38120,   0.39547,
+   0.40947,   0.42318,   0.43658,   0.44965,   0.46238,   0.47475,   0.48676,
+   0.49839,   0.50964,   0.52050,   0.53098,   0.54108,   0.55078,   0.56011,
+   0.56906,   0.57764,   0.58586,   0.59372,   0.60123,   0.60840,   0.61525,
+   0.62178,   0.62800,   0.63392,   0.63957,   0.64494,   0.65004,   0.65490,
+   0.65952,   0.66392,   0.66809,   0.67206,   0.67584,   0.67943,   0.68285,
+   0.68611,   0.68921,   0.69217,   0.69499,   0.69768,   0.70026,   0.70273,
+   0.70511,   0.70739,   0.70958,   0.71170,   0.71376,   0.71575,   0.71768,
+   0.71958,   0.72142,   0.72324,   0.72502,   0.72679,   0.72853,   0.73026,
+   0.73199,   0.73371,   0.73543,   0.73715,   0.73889,   0.74063,   0.74239,
+   0.74417,   0.74597,   0.74779,   0.74964,   0.75151,   0.75342,   0.75535,
+   0.75732,   0.75933,   0.76137,   0.76345,   0.76556,   0.76771,   0.76990,
+   0.77213,   0.77440,   0.77671,   0.77905,   0.78144,   0.78386,   0.78632,
+   0.78882,   0.79135,   0.79393,   0.79654,   0.79919,   0.80188,   0.80461,
+   0.80739,   0.81020,   0.81306,   0.81596,   0.81891,   0.82191,   0.82497,
+   0.82808,   0.83125,   0.83448,   0.83778,   0.84115,   0.84459,   0.84811,
+   0.85170,   0.85538,   0.85914,   0.86299,   0.86693,   0.87095,   0.87507,
+   0.87927,   0.88355,   0.88792,   0.89236,   0.89687,   0.90145,   0.90608,
+   0.91075,   0.91545,   0.92017,   0.92489,   0.92960,   0.93427,   0.93890,
+   0.94346,   0.94794,   0.95233,   0.95661,   0.96078,   0.96484,   0.96877,
+   0.97257,   0.97626,   0.97982,   0.98324,   0.98651,   0.98960,   0.99244,
+   0.99495,   0.99706,   0.99866,   0.99966,   1.00000,
+   //---------  1.00 GeV
+   0.00064,   0.00248,   0.00552,   0.00970,   0.01498,   0.02132,   0.02865,
+   0.03694,   0.04614,   0.05619,   0.06706,   0.07870,   0.09105,   0.10406,
+   0.11768,   0.13184,   0.14650,   0.16159,   0.17704,   0.19281,   0.20883,
+   0.22505,   0.24140,   0.25784,   0.27431,   0.29076,   0.30714,   0.32342,
+   0.33955,   0.35548,   0.37119,   0.38664,   0.40181,   0.41666,   0.43117,
+   0.44532,   0.45910,   0.47248,   0.48546,   0.49803,   0.51018,   0.52191,
+   0.53321,   0.54408,   0.55453,   0.56457,   0.57418,   0.58339,   0.59220,
+   0.60062,   0.60867,   0.61634,   0.62365,   0.63062,   0.63725,   0.64356,
+   0.64957,   0.65527,   0.66069,   0.66583,   0.67071,   0.67534,   0.67973,
+   0.68389,   0.68784,   0.69158,   0.69512,   0.69848,   0.70167,   0.70468,
+   0.70755,   0.71027,   0.71285,   0.71530,   0.71764,   0.71987,   0.72201,
+   0.72405,   0.72601,   0.72789,   0.72971,   0.73147,   0.73319,   0.73485,
+   0.73649,   0.73809,   0.73967,   0.74123,   0.74278,   0.74432,   0.74586,
+   0.74740,   0.74894,   0.75050,   0.75206,   0.75365,   0.75525,   0.75687,
+   0.75852,   0.76020,   0.76190,   0.76363,   0.76539,   0.76719,   0.76902,
+   0.77088,   0.77278,   0.77472,   0.77669,   0.77871,   0.78076,   0.78284,
+   0.78497,   0.78713,   0.78932,   0.79156,   0.79382,   0.79613,   0.79846,
+   0.80083,   0.80322,   0.80565,   0.80811,   0.81060,   0.81311,   0.81566,
+   0.81824,   0.82085,   0.82349,   0.82617,   0.82889,   0.83164,   0.83444,
+   0.83728,   0.84017,   0.84311,   0.84611,   0.84916,   0.85228,   0.85547,
+   0.85872,   0.86205,   0.86546,   0.86895,   0.87252,   0.87618,   0.87992,
+   0.88376,   0.88768,   0.89169,   0.89578,   0.89995,   0.90420,   0.90852,
+   0.91289,   0.91732,   0.92179,   0.92627,   0.93077,   0.93526,   0.93973,
+   0.94415,   0.94851,   0.95279,   0.95699,   0.96108,   0.96506,   0.96892,
+   0.97267,   0.97630,   0.97980,   0.98319,   0.98642,   0.98949,   0.99233,
+   0.99486,   0.99700,   0.99863,   0.99965,   1.00000,
+   //---------  1.10 GeV
+   0.00072,   0.00280,   0.00623,   0.01096,   0.01693,   0.02409,   0.03237,
+   0.04173,   0.05210,   0.06342,   0.07565,   0.08870,   0.10253,   0.11705,
+   0.13220,   0.14790,   0.16408,   0.18067,   0.19759,   0.21477,   0.23214,
+   0.24964,   0.26719,   0.28474,   0.30223,   0.31961,   0.33682,   0.35382,
+   0.37056,   0.38702,   0.40315,   0.41893,   0.43433,   0.44933,   0.46390,
+   0.47804,   0.49173,   0.50497,   0.51774,   0.53005,   0.54190,   0.55328,
+   0.56421,   0.57468,   0.58471,   0.59431,   0.60348,   0.61224,   0.62059,
+   0.62856,   0.63616,   0.64339,   0.65028,   0.65683,   0.66306,   0.66897,
+   0.67460,   0.67993,   0.68499,   0.68979,   0.69434,   0.69865,   0.70273,
+   0.70659,   0.71025,   0.71370,   0.71696,   0.72004,   0.72295,   0.72570,
+   0.72830,   0.73076,   0.73309,   0.73529,   0.73738,   0.73937,   0.74127,
+   0.74308,   0.74481,   0.74648,   0.74809,   0.74964,   0.75116,   0.75264,
+   0.75410,   0.75554,   0.75696,   0.75837,   0.75978,   0.76120,   0.76262,
+   0.76405,   0.76550,   0.76697,   0.76845,   0.76996,   0.77150,   0.77306,
+   0.77465,   0.77627,   0.77792,   0.77961,   0.78133,   0.78308,   0.78487,
+   0.78669,   0.78855,   0.79045,   0.79238,   0.79435,   0.79636,   0.79840,
+   0.80047,   0.80258,   0.80472,   0.80690,   0.80910,   0.81133,   0.81358,
+   0.81586,   0.81816,   0.82049,   0.82283,   0.82519,   0.82757,   0.82997,
+   0.83238,   0.83482,   0.83727,   0.83974,   0.84224,   0.84476,   0.84730,
+   0.84988,   0.85249,   0.85514,   0.85782,   0.86056,   0.86334,   0.86617,
+   0.86906,   0.87201,   0.87502,   0.87811,   0.88127,   0.88450,   0.88782,
+   0.89121,   0.89469,   0.89826,   0.90191,   0.90565,   0.90947,   0.91337,
+   0.91734,   0.92138,   0.92547,   0.92961,   0.93377,   0.93795,   0.94213,
+   0.94628,   0.95040,   0.95446,   0.95845,   0.96235,   0.96616,   0.96986,
+   0.97345,   0.97693,   0.98029,   0.98355,   0.98667,   0.98964,   0.99241,
+   0.99489,   0.99700,   0.99862,   0.99965,   1.00000,
+   //---------  1.20 GeV
+   0.00080,   0.00312,   0.00693,   0.01219,   0.01884,   0.02680,   0.03601,
+   0.04640,   0.05791,   0.07047,   0.08400,   0.09841,   0.11364,   0.12959,
+   0.14617,   0.16331,   0.18089,   0.19885,   0.21709,   0.23553,   0.25408,
+   0.27268,   0.29125,   0.30973,   0.32804,   0.34614,   0.36398,   0.38151,
+   0.39868,   0.41547,   0.43184,   0.44777,   0.46324,   0.47822,   0.49272,
+   0.50672,   0.52021,   0.53319,   0.54567,   0.55765,   0.56914,   0.58014,
+   0.59067,   0.60074,   0.61035,   0.61953,   0.62829,   0.63665,   0.64461,
+   0.65220,   0.65943,   0.66631,   0.67286,   0.67909,   0.68501,   0.69065,
+   0.69600,   0.70108,   0.70589,   0.71046,   0.71479,   0.71889,   0.72276,
+   0.72642,   0.72988,   0.73314,   0.73621,   0.73910,   0.74183,   0.74439,
+   0.74681,   0.74908,   0.75123,   0.75325,   0.75516,   0.75697,   0.75869,
+   0.76033,   0.76190,   0.76341,   0.76486,   0.76628,   0.76766,   0.76902,
+   0.77036,   0.77169,   0.77301,   0.77434,   0.77568,   0.77704,   0.77841,
+   0.77980,   0.78121,   0.78266,   0.78413,   0.78563,   0.78717,   0.78873,
+   0.79034,   0.79197,   0.79364,   0.79535,   0.79710,   0.79888,   0.80069,
+   0.80255,   0.80444,   0.80636,   0.80833,   0.81033,   0.81236,   0.81443,
+   0.81653,   0.81866,   0.82082,   0.82301,   0.82522,   0.82746,   0.82971,
+   0.83198,   0.83427,   0.83656,   0.83887,   0.84118,   0.84350,   0.84582,
+   0.84815,   0.85047,   0.85280,   0.85514,   0.85747,   0.85982,   0.86217,
+   0.86453,   0.86690,   0.86929,   0.87171,   0.87414,   0.87661,   0.87910,
+   0.88163,   0.88421,   0.88683,   0.88950,   0.89223,   0.89502,   0.89788,
+   0.90080,   0.90380,   0.90688,   0.91003,   0.91328,   0.91660,   0.92001,
+   0.92349,   0.92705,   0.93068,   0.93437,   0.93811,   0.94189,   0.94568,
+   0.94948,   0.95326,   0.95701,   0.96071,   0.96434,   0.96789,   0.97135,
+   0.97472,   0.97798,   0.98115,   0.98421,   0.98717,   0.98999,   0.99263,
+   0.99502,   0.99707,   0.99865,   0.99965,   1.00000
+ };
+
+ // CM momentum (GeV/c)
+ G4float G4LEnp::pcm[NENERGY] = {
+   0.685E-01, 0.969E-01, 0.119, 0.153, 0.181, 0.217, 0.256,
+   0.291, 0.336, 0.399, 0.444, 0.484, 0.522, 0.539,
+   0.565, 0.589, 0.613, 0.650, 0.685, 0.718, 0.750
+ };
+
+ // Lab energy (GeV)
+ G4float G4LEnp::elab[NENERGY] = {
+   0.100E-01, 0.200E-01, 0.300E-01, 0.500E-01, 0.700E-01, 0.100, 0.140,
+   0.180, 0.240, 0.340, 0.420, 0.500, 0.580, 0.620,
+   0.680, 0.740, 0.800, 0.900,  1.00,  1.10,  1.20    
+ };
+
+ // Max dsigma/domega-CM (mb/sr)
+ G4float G4LEnp::dsigmax[NENERGY] = {
+   79.0,  43.0,  29.8,  20.0,  16.3,  14.5,  13.3,
+   12.6,  11.9,  11.3,  11.1,  10.7,  9.69,  10.1,
+   11.4,  12.5,  13.3,  14.5,  15.6,  16.9,  18.3    
+ };
+
+ // Total cross section
+ G4float G4LEnp::sigtot[NENERGY] = {
+   947.,  485.,  310.,  168.,  110.,  75.7,  55.2,
+   45.9,  39.1,  34.1,  32.3,  31.3,  30.1,  29.5,
+   28.4,  27.4,  26.4,  24.8,  23.4,  22.4,  21.9    
+ };

source/processes/hadronic/models/coherent_elastic/include/G4LEpp.hh

@@ -0,0 +1,85 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+ //
+ // G4 Low energy model: n-n or p-p scattering
+ // F.W. Jones, L.G. Greeniaus, H.P. Wellisch
+ //  
+ // For further comments see G4LEppData.hh and G4LEpp.cc
+ //
+
+#ifndef G4LEpp_h
+#define G4LEpp_h 1
+ 
+#include "globals.hh"
+#include "Randomize.hh"
+#include "G4Element.hh"
+#include "G4ElementVector.hh"
+#include "G4ElementTable.hh"
+#include "G4PhysicsTable.hh"
+#include "G4PhysicsVector.hh"
+#include "G4LPhysicsFreeVector.hh"
+#include "G4Gamma.hh"
+#include "G4Step.hh"
+#include "G4TrackStatus.hh"
+#include "G4HadronicInteraction.hh"
+
+
+class G4LEpp : public G4HadronicInteraction
+{
+ private:
+
+   enum { NENERGY=22, NANGLE=180 };
+
+ public:
+
+   G4LEpp();
+
+   ~G4LEpp();
+ 
+   G4VParticleChange* ApplyYourself(const G4Track& aTrack,
+                                    G4Nucleus& targetNucleus);
+
+   void SetCoulombSuppression(G4int State);
+  
+ private:
+
+  G4float * sig[NANGLE];
+  G4float * elab;
+
+ // The following arrays are declared static to allow the use of initializers.
+ // They are initialized in G4LEppData.hh
+
+ // Coulomb effects suppressed:
+   static G4float Sig[NENERGY][NANGLE];
+   static G4float Pcm[NENERGY], Elab[NENERGY], 
+     dSigmax[NENERGY], Sigtot[NENERGY];
+
+ // Coulomb effects not suppressed:
+   static G4float SigCoul[NENERGY][NANGLE];
+   static G4float PcmCoul[NENERGY], ElabCoul[NENERGY], 
+     dSigmaxCoul[NENERGY], SigtotCoul[NENERGY];
+
+
+};
+
+#endif

source/processes/hadronic/models/coherent_elastic/src/G4LEnp.cc

@@ -0,0 +1,343 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+
+ // G4 Low energy model: n-p scattering
+ // F.W. Jones, L.G. Greeniaus, H.P. Wellisch
+
+
+#include "G4LEnp.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+
+// Initialization of static data arrays:
+#include "G4LEnpData.hh"
+#include "Randomize.hh"
+
+
+G4LEnp::G4LEnp() :
+  G4HadronicInteraction()
+{
+  //    theParticleChange.SetNumberOfSecondaries(1);
+  
+  //    SetMinEnergy(10.*MeV);
+  //    SetMaxEnergy(1200.*MeV);
+  SetMinEnergy(0.);
+  SetMaxEnergy(1200.*GeV);
+}
+
+G4LEnp::~G4LEnp()
+{
+  //    theParticleChange.Clear();
+}
+
+G4VParticleChange*
+G4LEnp::ApplyYourself(const G4Track& aTrack, G4Nucleus& targetNucleus)
+{
+    theParticleChange.Initialize(aTrack);
+
+    const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
+
+    G4double P = aParticle->GetTotalMomentum();
+    G4double Px = aParticle->GetMomentum().x();
+    G4double Py = aParticle->GetMomentum().y();
+    G4double Pz = aParticle->GetMomentum().z();
+    G4double ek = aParticle->GetKineticEnergy();
+    G4ThreeVector theInitial = aParticle->GetMomentum();
+
+    if (verboseLevel > 1) {
+      G4double E = aParticle->GetTotalEnergy();
+      G4double E0 = aParticle->GetDefinition()->GetPDGMass();
+      G4double Q = aParticle->GetDefinition()->GetPDGCharge();
+      G4double N = targetNucleus.GetN();
+      G4double Z = targetNucleus.GetZ();
+      G4cout << "G4LEnp:ApplyYourself: incident particle: "
+             << aParticle->GetDefinition()->GetParticleName() << G4endl;
+      G4cout << "P = " << P/GeV << " GeV/c"
+             << ", Px = " << Px/GeV << " GeV/c"
+             << ", Py = " << Py/GeV << " GeV/c"
+             << ", Pz = " << Pz/GeV << " GeV/c" << G4endl;
+      G4cout << "E = " << E/GeV << " GeV"
+             << ", kinetic energy = " << ek/GeV << " GeV"
+             << ", mass = " << E0/GeV << " GeV"
+             << ", charge = " << Q << G4endl;
+      G4cout << "G4LEnp:ApplyYourself: material:" << G4endl;
+      G4cout << "A = " << N
+             << ", Z = " << Z
+             << ", atomic mass " 
+             <<  G4Proton::Proton()->GetPDGMass()/GeV << "GeV" 
+             << G4endl;
+      //
+      // GHEISHA ADD operation to get total energy, mass, charge
+      //
+      E += G4Proton::Proton()->GetPDGMass();
+      G4double E02 = E*E - P*P;
+      E0 = sqrt(abs(E02));
+      if (E02 < 0)E0 *= -1;
+      Q += Z;
+      G4cout << "G4LEnp:ApplyYourself: total:" << G4endl;
+      G4cout << "E = " << E/GeV << " GeV"
+             << ", mass = " << E0/GeV << " GeV"
+             << ", charge = " << Q << G4endl;
+    }
+
+    // Find energy bin
+
+    G4int je1 = 0;
+    G4int je2 = NENERGY - 1;
+    ek = ek/GeV;
+    do {
+      G4int midBin = (je1 + je2)/2;
+      if (ek < elab[midBin])
+        je2 = midBin;
+      else
+        je1 = midBin;
+    } while (je2 - je1 > 1); 
+    //    G4int j;
+    //abs(ek-elab[je1]) < abs(ek-elab[je2]) ? j = je1 : j = je2;
+    G4double delab = elab[je2] - elab[je1];
+
+    // Sample the angle
+
+    G4float sample = G4UniformRand();
+    G4int ke1 = 0;
+    G4int ke2 = NANGLE - 1;
+    G4double dsig = sig[je2][0] - sig[je1][0];
+    G4double rc = dsig/delab;
+    G4double b = sig[je1][0] - rc*elab[je1];
+    G4double sigint1 = rc*ek + b;
+    G4double sigint2 = 0.;
+
+    if (verboseLevel > 1) G4cout << "sample=" << sample << G4endl
+                                 << ke1 << " " << ke2 << " " 
+                                 << sigint1 << " " << sigint2 << G4endl;
+
+    do {
+      G4int midBin = (ke1 + ke2)/2;
+      dsig = sig[je2][midBin] - sig[je1][midBin];
+      rc = dsig/delab;
+      b = sig[je1][midBin] - rc*elab[je1];
+      G4double sigint = rc*ek + b;
+      if (sample < sigint) {
+        ke2 = midBin;
+        sigint2 = sigint;
+      }
+      else {
+        ke1 = midBin;
+        sigint1 = sigint;
+      }
+      if (verboseLevel > 1)G4cout << ke1 << " " << ke2 << " " 
+                                  << sigint1 << " " << sigint2 << G4endl;
+    } while (ke2 - ke1 > 1); 
+
+    // sigint1 and sigint2 should be recoverable from above loop
+
+    //    G4double dsig = sig[je2][ke1] - sig[je1][ke1];
+    //    G4double rc = dsig/delab;
+    //    G4double b = sig[je1][ke1] - rc*elab[je1];
+    //    G4double sigint1 = rc*ek + b;
+
+    //    G4double dsig = sig[je2][ke2] - sig[je1][ke2];
+    //    G4double rc = dsig/delab;
+    //    G4double b = sig[je1][ke2] - rc*elab[je1];
+    //    G4double sigint2 = rc*ek + b;
+
+    dsig = sigint2 - sigint1;
+    rc = 1./dsig;
+    b = ke1 - rc*sigint1;
+    G4double kint = rc*sample + b;
+    G4double theta = (0.5 + kint)*pi/180.;
+
+    //    G4int k;
+    //abs(sample-sig[j][ke1]) < abs(sample-sig[j][ke2]) ? k = ke1 : k = ke2;
+    //    G4double theta = (0.5 + k)*pi/180.;
+
+    if (verboseLevel > 1) {
+      G4cout << "   energy bin " << je1 << " energy=" << elab[je1] << G4endl;
+      G4cout << "   angle bin " << kint << " angle=" << theta/degree << G4endl;
+    }
+
+
+    // Get the target particle
+
+    G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
+
+    G4double E1 = aParticle->GetTotalEnergy();
+    G4double M1 = aParticle->GetDefinition()->GetPDGMass();
+    G4double E2 = targetParticle->GetTotalEnergy();
+    G4double M2 = targetParticle->GetDefinition()->GetPDGMass();
+    G4double totalEnergy = E1 + E2;
+    G4double pseudoMass = sqrt(totalEnergy*totalEnergy - P*P);
+    // pseudoMass also = sqrt(M1*M1 + M2*M2 + 2*M2*E1)
+
+    // Transform into centre of mass system
+
+    G4double px = (M2/pseudoMass)*Px;
+    G4double py = (M2/pseudoMass)*Py;
+    G4double pz = (M2/pseudoMass)*Pz;
+    G4double p = sqrt(px*px + py*py + pz*pz);
+
+    if (verboseLevel > 1) {
+      G4cout << "  E1, M1 (GeV) " << E1/GeV << " " << M1/GeV << G4endl;
+      G4cout << "  E2, M2 (GeV) " << E2/GeV << " " << M2/GeV << G4endl;
+      G4cout << "  particle  1 momentum in CM " << px/GeV << " " << py/GeV << " "
+           << pz/GeV << " " << p/GeV << G4endl;
+    }
+
+    // First scatter w.r.t. Z axis
+    G4double phi = G4UniformRand()*twopi;
+    G4double pxnew = p*sin(theta)*cos(phi);
+    G4double pynew = p*sin(theta)*sin(phi);
+    G4double pznew = p*cos(theta);
+
+    // Rotate according to the direction of the incident particle
+    if (px*px + py*py > 0) {
+      G4double cost, sint, ph, cosp, sinp, a, b, c;
+      cost = pz/p;
+      sint = (sqrt(abs((1-cost)*(1+cost))) + sqrt(px*px+py*py)/p)/2;
+      py < 0 ? ph = 3*halfpi : ph = halfpi;
+      if (abs(px) > 0.000001*GeV) ph = atan2(py,px);
+      cosp = cos(ph);
+      sinp = sin(ph);
+      px = (cost*cosp*pxnew - sinp*pynew + sint*cosp*pznew);
+      py = (cost*sinp*pxnew + cosp*pynew + sint*sinp*pznew);
+      pz = (-sint*pxnew                  + cost*pznew);
+      //      G4ThreeVector it(a,b,c);
+      //      p0->SetMomentum(it);
+      //      G4ThreeVector aTargetMom = theInitial - it;
+      //      targetParticle->SetMomentum(aTargetMom);
+    }
+    else {
+      px = pxnew;
+      py = pynew;
+      pz = pznew;
+    }
+
+    if (verboseLevel > 1) {
+      G4cout << "  AFTER SCATTER..." << G4endl;
+      G4cout << "  particle 1 momentum in CM " << px/GeV << " " << py/GeV << " "
+           << pz/GeV << " " << p/GeV << G4endl;
+    }
+
+    // Transform to lab system
+
+    G4double E1pM2 = E1 + M2;
+    G4double betaCM  = P/E1pM2;
+    G4double betaCMx = Px/E1pM2;
+    G4double betaCMy = Py/E1pM2;
+    G4double betaCMz = Pz/E1pM2;
+    G4double gammaCM = E1pM2/sqrt(E1pM2*E1pM2 - P*P);
+
+    if (verboseLevel > 1) {
+      G4cout << "  betaCM " << betaCMx << " " << betaCMy << " "
+             << betaCMz << " " << betaCM << G4endl;
+      G4cout << "  gammaCM " << gammaCM << G4endl;
+    }
+
+    // Now following GLOREN...
+
+    G4double BETA[5], PA[5], PB[5];
+    BETA[1] = -betaCMx;
+    BETA[2] = -betaCMy;
+    BETA[3] = -betaCMz;
+    BETA[4] = gammaCM;
+
+    //The incident particle...
+
+    PA[1] = px;
+    PA[2] = py;
+    PA[3] = pz;
+    PA[4] = sqrt(M1*M1 + p*p);
+
+    G4double BETPA  = BETA[1]*PA[1] + BETA[2]*PA[2] + BETA[3]*PA[3];
+    G4double BPGAM  = (BETPA * BETA[4]/(BETA[4] + 1.) - PA[4]) * BETA[4];
+
+    PB[1] = PA[1] + BPGAM  * BETA[1];
+    PB[2] = PA[2] + BPGAM  * BETA[2];
+    PB[3] = PA[3] + BPGAM  * BETA[3];
+    PB[4] = (PA[4] - BETPA) * BETA[4];
+
+    G4DynamicParticle* newP = new G4DynamicParticle;
+    newP->SetDefinition(aParticle->GetDefinition());
+    newP->SetMomentum(G4ThreeVector(PB[1], PB[2], PB[3]));
+
+    //The target particle...
+
+    PA[1] = -px;
+    PA[2] = -py;
+    PA[3] = -pz;
+    PA[4] = sqrt(M2*M2 + p*p);
+
+    BETPA  = BETA[1]*PA[1] + BETA[2]*PA[2] + BETA[3]*PA[3];
+    BPGAM  = (BETPA * BETA[4]/(BETA[4] + 1.) - PA[4]) * BETA[4];
+
+    PB[1] = PA[1] + BPGAM  * BETA[1];
+    PB[2] = PA[2] + BPGAM  * BETA[2];
+    PB[3] = PA[3] + BPGAM  * BETA[3];
+    PB[4] = (PA[4] - BETPA) * BETA[4];
+
+    targetParticle->SetMomentum(G4ThreeVector(PB[1], PB[2], PB[3]));
+
+    if (verboseLevel > 1) {
+      G4cout << "  particle 1 momentum in LAB " 
+           << newP->GetMomentum()*(1./GeV) 
+           << " " << newP->GetTotalMomentum()/GeV << G4endl;
+      G4cout << "  particle 2 momentum in LAB " 
+           << targetParticle->GetMomentum()*(1./GeV) 
+           << " " << targetParticle->GetTotalMomentum()/GeV << G4endl;
+      G4cout << "  TOTAL momentum in LAB " 
+           << (newP->GetMomentum()+targetParticle->GetMomentum())*(1./GeV) 
+           << " " 
+           << (newP->GetMomentum()+targetParticle->GetMomentum()).mag()/GeV
+           << G4endl;
+    }
+
+    // charge symmetry....
+    if(G4UniformRand()<.5)
+    {
+      theParticleChange.SetNumberOfSecondaries(1);
+      theParticleChange.SetMomentumChange(newP->GetMomentumDirection());
+      theParticleChange.SetEnergyChange(newP->GetKineticEnergy());
+      delete newP;
+      G4DynamicParticle* p1 = new G4DynamicParticle;
+      p1->SetDefinition(targetParticle->GetDefinition());
+      p1->SetMomentum(targetParticle->GetMomentum());
+      theParticleChange.AddSecondary(p1);    
+    }
+    else
+    {
+      theParticleChange.SetNumberOfSecondaries(2);
+      theParticleChange.SetStatusChange(fStopAndKill);
+      G4DynamicParticle * pA = new G4DynamicParticle;
+      pA->SetDefinition(targetParticle->GetDefinition());
+      pA->SetMomentum(newP->GetMomentum());
+      G4DynamicParticle * pB = new G4DynamicParticle;
+      pB->SetDefinition(newP->GetDefinition());
+      pB->SetMomentum(targetParticle->GetMomentum());
+      delete newP;
+      theParticleChange.AddSecondary(pA);    
+      theParticleChange.AddSecondary(pB);    
+    }
+    return &theParticleChange;
+}
+
+ // end of file

source/processes/hadronic/models/coherent_elastic/src/G4LEpp.cc

@@ -0,0 +1,372 @@
+//
+// ********************************************************************
+// * DISCLAIMER                                                       *
+// *                                                                  *
+// * The following disclaimer summarizes all the specific disclaimers *
+// * of contributors to this software. The specific disclaimers,which *
+// * govern, are listed with their locations in:                      *
+// *   http://cern.ch/geant4/license                                  *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.                                                             *
+// *                                                                  *
+// * This  code  implementation is the  intellectual property  of the *
+// * authors in the GEANT4 collaboration.                             *
+// * By copying,  distributing  or modifying the Program (or any work *
+// * based  on  the Program)  you indicate  your  acceptance of  this *
+// * statement, and all its terms.                                    *
+// ********************************************************************
+//
+
+ // G4 Low energy model: n-n or p-p scattering
+ // F.W. Jones, L.G. Greeniaus, H.P. Wellisch
+
+
+#include "G4LEpp.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+
+// Initialization of static data arrays:
+#include "G4LEppData.hh"
+
+G4LEpp::G4LEpp() :
+  G4HadronicInteraction()
+{
+  //    theParticleChange.SetNumberOfSecondaries(1);
+  //    SetMinEnergy(10.*MeV);
+  //    SetMaxEnergy(1200.*MeV);
+
+  SetCoulombSuppression(1);
+
+  SetMinEnergy(0.);
+  SetMaxEnergy(1200.*GeV);
+}
+
+G4LEpp::~G4LEpp()
+{
+  //    theParticleChange.Clear();
+}
+
+
+void
+G4LEpp::SetCoulombSuppression(G4int State)
+{
+  if (State) {
+    for(G4int i=0; i<NANGLE; i++)
+    {
+      sig[i] = Sig[i];
+    }
+    elab = Elab;
+  }
+  else {
+    for(G4int i=0; i<NANGLE; i++)
+    {
+      sig[i] = SigCoul[i];
+    }
+    elab = ElabCoul;
+  }
+}
+
+
+G4VParticleChange*
+G4LEpp::ApplyYourself(const G4Track& aTrack, G4Nucleus& targetNucleus)
+{
+    theParticleChange.Initialize(aTrack);
+
+    const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
+
+    G4double P = aParticle->GetTotalMomentum();
+    G4double Px = aParticle->GetMomentum().x();
+    G4double Py = aParticle->GetMomentum().y();
+    G4double Pz = aParticle->GetMomentum().z();
+    G4double ek = aParticle->GetKineticEnergy();
+    G4ThreeVector theInitial = aParticle->GetMomentum();
+
+    if (verboseLevel > 1) {
+      G4double E = aParticle->GetTotalEnergy();
+      G4double E0 = aParticle->GetDefinition()->GetPDGMass();
+      G4double Q = aParticle->GetDefinition()->GetPDGCharge();
+      G4double N = targetNucleus.GetN();
+      G4double Z = targetNucleus.GetZ();
+      G4cout << "G4LEpp:ApplyYourself: incident particle: "
+             << aParticle->GetDefinition()->GetParticleName() << G4endl;
+      G4cout << "P = " << P/GeV << " GeV/c"
+             << ", Px = " << Px/GeV << " GeV/c"
+             << ", Py = " << Py/GeV << " GeV/c"
+             << ", Pz = " << Pz/GeV << " GeV/c" << G4endl;
+      G4cout << "E = " << E/GeV << " GeV"
+             << ", kinetic energy = " << ek/GeV << " GeV"
+             << ", mass = " << E0/GeV << " GeV"
+             << ", charge = " << Q << G4endl;
+      G4cout << "G4LEpp:ApplyYourself: material:" << G4endl;
+      G4cout << "A = " << N
+             << ", Z = " << Z
+             << ", atomic mass " 
+             <<  G4Proton::Proton()->GetPDGMass()/GeV << "GeV" 
+             << G4endl;
+      //
+      // GHEISHA ADD operation to get total energy, mass, charge
+      //
+      E += G4Proton::Proton()->GetPDGMass();
+      G4double E02 = E*E - P*P;
+      E0 = sqrt(abs(E02));
+      if (E02 < 0)E0 *= -1;
+      Q += Z;
+      G4cout << "G4LEpp:ApplyYourself: total:" << G4endl;
+      G4cout << "E = " << E/GeV << " GeV"
+             << ", mass = " << E0/GeV << " GeV"
+             << ", charge = " << Q << G4endl;
+    }
+
+    // Find energy bin
+
+    G4int je1 = 0;
+    G4int je2 = NENERGY - 1;
+    ek = ek/GeV;
+    do {
+      G4int midBin = (je1 + je2)/2;
+      if (ek < elab[midBin])
+        je2 = midBin;
+      else
+        je1 = midBin;
+    } while (je2 - je1 > 1); 
+    //    G4int j;
+    //abs(ek-elab[je1]) < abs(ek-elab[je2]) ? j = je1 : j = je2;
+    G4double delab = elab[je2] - elab[je1];
+
+    // Sample the angle
+
+    G4float sample = G4UniformRand();
+    G4int ke1 = 0;
+    G4int ke2 = NANGLE - 1;
+    G4double dsig = sig[je2][0] - sig[je1][0];
+    G4double rc = dsig/delab;
+    G4double b = sig[je1][0] - rc*elab[je1];
+    G4double sigint1 = rc*ek + b;
+    G4double sigint2 = 0.;
+
+    if (verboseLevel > 1) G4cout << "sample=" << sample << G4endl
+                                 << ke1 << " " << ke2 << " " 
+                                 << sigint1 << " " << sigint2 << G4endl;
+
+    do {
+      G4int midBin = (ke1 + ke2)/2;
+      dsig = sig[je2][midBin] - sig[je1][midBin];
+      rc = dsig/delab;
+      b = sig[je1][midBin] - rc*elab[je1];
+      G4double sigint = rc*ek + b;
+      if (sample < sigint) {
+        ke2 = midBin;
+        sigint2 = sigint;
+      }
+      else {
+        ke1 = midBin;
+        sigint1 = sigint;
+      }
+      if (verboseLevel > 1)G4cout << ke1 << " " << ke2 << " " 
+                                  << sigint1 << " " << sigint2 << G4endl;
+    } while (ke2 - ke1 > 1); 
+
+    // sigint1 and sigint2 should be recoverable from above loop
+
+    //    G4double dsig = sig[je2][ke1] - sig[je1][ke1];
+    //    G4double rc = dsig/delab;
+    //    G4double b = sig[je1][ke1] - rc*elab[je1];
+    //    G4double sigint1 = rc*ek + b;
+
+    //    G4double dsig = sig[je2][ke2] - sig[je1][ke2];
+    //    G4double rc = dsig/delab;
+    //    G4double b = sig[je1][ke2] - rc*elab[je1];
+    //    G4double sigint2 = rc*ek + b;
+
+    dsig = sigint2 - sigint1;
+    rc = 1./dsig;
+    b = ke1 - rc*sigint1;
+    G4double kint = rc*sample + b;
+    G4double theta = (0.5 + kint)*pi/180.;
+
+    //    G4int k;
+    //abs(sample-sig[j][ke1]) < abs(sample-sig[j][ke2]) ? k = ke1 : k = ke2;
+    //    G4double theta = (0.5 + k)*pi/180.;
+
+    if (verboseLevel > 1) {
+      G4cout << "   energy bin " << je1 << " energy=" << elab[je1] << G4endl;
+      G4cout << "   angle bin " << kint << " angle=" << theta/degree << G4endl;
+    }
+
+
+    // Get the target particle
+
+    G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
+
+    G4double E1 = aParticle->GetTotalEnergy();
+    G4double M1 = aParticle->GetDefinition()->GetPDGMass();
+    G4double E2 = targetParticle->GetTotalEnergy();
+    G4double M2 = targetParticle->GetDefinition()->GetPDGMass();
+    G4double totalEnergy = E1 + E2;
+    G4double pseudoMass = sqrt(totalEnergy*totalEnergy - P*P);
+    // pseudoMass also = sqrt(M1*M1 + M2*M2 + 2*M2*E1)
+
+    // Transform into centre of mass system
+
+    G4double px = (M2/pseudoMass)*Px;
+    G4double py = (M2/pseudoMass)*Py;
+    G4double pz = (M2/pseudoMass)*Pz;
+    G4double p = sqrt(px*px + py*py + pz*pz);
+
+    if (verboseLevel > 1) {
+      G4cout << "  E1, M1 (GeV) " << E1/GeV << " " << M1/GeV << G4endl;
+      G4cout << "  E2, M2 (GeV) " << E2/GeV << " " << M2/GeV << G4endl;
+      G4cout << "  particle  1 momentum in CM " << px/GeV << " " << py/GeV << " "
+           << pz/GeV << " " << p/GeV << G4endl;
+    }
+
+    // First scatter w.r.t. Z axis
+    G4double phi = G4UniformRand()*twopi;
+    G4double pxnew = p*sin(theta)*cos(phi);
+    G4double pynew = p*sin(theta)*sin(phi);
+    G4double pznew = p*cos(theta);
+
+    // Rotate according to the direction of the incident particle
+    if (px*px + py*py > 0) {
+      G4double cost, sint, ph, cosp, sinp, a, b, c;
+      cost = pz/p;
+      sint = (sqrt(abs((1-cost)*(1+cost))) + sqrt(px*px+py*py)/p)/2;
+      py < 0 ? ph = 3*halfpi : ph = halfpi;
+      if (abs(px) > 0.000001*GeV) ph = atan2(py,px);
+      cosp = cos(ph);
+      sinp = sin(ph);
+      px = (cost*cosp*pxnew - sinp*pynew + sint*cosp*pznew);
+      py = (cost*sinp*pxnew + cosp*pynew + sint*sinp*pznew);
+      pz = (-sint*pxnew                  + cost*pznew);
+      //      G4ThreeVector it(a,b,c);
+      //      p0->SetMomentum(it);
+      //      G4ThreeVector aTargetMom = theInitial - it;
+      //      targetParticle->SetMomentum(aTargetMom);
+    }
+    else {
+      px = pxnew;
+      py = pynew;
+      pz = pznew;
+    }
+
+    if (verboseLevel > 1) {
+      G4cout << "  AFTER SCATTER..." << G4endl;
+      G4cout << "  particle 1 momentum in CM " << px/GeV << " " << py/GeV << " "
+           << pz/GeV << " " << p/GeV << G4endl;
+    }
+
+    // Transform to lab system
+
+    G4double E1pM2 = E1 + M2;
+    G4double betaCM  = P/E1pM2;
+    G4double betaCMx = Px/E1pM2;
+    G4double betaCMy = Py/E1pM2;
+    G4double betaCMz = Pz/E1pM2;
+    G4double gammaCM = E1pM2/sqrt(E1pM2*E1pM2 - P*P);
+
+    if (verboseLevel > 1) {
+      G4cout << "  betaCM " << betaCMx << " " << betaCMy << " "
+             << betaCMz << " " << betaCM << G4endl;
+      G4cout << "  gammaCM " << gammaCM << G4endl;
+    }
+
+    // Now following GLOREN...
+
+    G4double BETA[5], PA[5], PB[5];
+    BETA[1] = -betaCMx;
+    BETA[2] = -betaCMy;
+    BETA[3] = -betaCMz;
+    BETA[4] = gammaCM;
+
+    //The incident particle...
+
+    PA[1] = px;
+    PA[2] = py;
+    PA[3] = pz;
+    PA[4] = sqrt(M1*M1 + p*p);
+
+    G4double BETPA  = BETA[1]*PA[1] + BETA[2]*PA[2] + BETA[3]*PA[3];
+    G4double BPGAM  = (BETPA * BETA[4]/(BETA[4] + 1.) - PA[4]) * BETA[4];
+
+    PB[1] = PA[1] + BPGAM  * BETA[1];
+    PB[2] = PA[2] + BPGAM  * BETA[2];
+    PB[3] = PA[3] + BPGAM  * BETA[3];
+    PB[4] = (PA[4] - BETPA) * BETA[4];
+
+    G4DynamicParticle* newP = new G4DynamicParticle;
+    newP->SetDefinition(aParticle->GetDefinition());
+    newP->SetMomentum(G4ThreeVector(PB[1], PB[2], PB[3]));
+
+
+    //The target particle...
+
+    PA[1] = -px;
+    PA[2] = -py;
+    PA[3] = -pz;
+    PA[4] = sqrt(M2*M2 + p*p);
+
+    BETPA  = BETA[1]*PA[1] + BETA[2]*PA[2] + BETA[3]*PA[3];
+    BPGAM  = (BETPA * BETA[4]/(BETA[4] + 1.) - PA[4]) * BETA[4];
+
+    PB[1] = PA[1] + BPGAM  * BETA[1];
+    PB[2] = PA[2] + BPGAM  * BETA[2];
+    PB[3] = PA[3] + BPGAM  * BETA[3];
+    PB[4] = (PA[4] - BETPA) * BETA[4];
+
+    targetParticle->SetMomentum(G4ThreeVector(PB[1], PB[2], PB[3]));
+
+    G4double ektotal = newP->GetKineticEnergy() + 
+                       targetParticle->GetKineticEnergy();
+
+    if (verboseLevel > 1) {
+      G4cout << "  particle 1 momentum in LAB " 
+           << newP->GetMomentum()*(1./GeV) 
+           << " " << newP->GetTotalMomentum()/GeV << G4endl;
+      G4cout << "  particle 2 momentum in LAB " 
+           << targetParticle->GetMomentum()*(1./GeV) 
+           << " " << targetParticle->GetTotalMomentum()/GeV << G4endl;
+      G4cout << "  TOTAL momentum in LAB " 
+           << (newP->GetMomentum()+targetParticle->GetMomentum())*(1./GeV) 
+           << " " 
+           << (newP->GetMomentum()+targetParticle->GetMomentum()).mag()/GeV
+           << G4endl;
+    }
+
+    //    if (theta < pi/2.) {
+      theParticleChange.SetNumberOfSecondaries(1);
+      //  G4double p = newP->GetMomentum().mag();
+      //      G4ThreeVector m = newP->GetMomentum();
+      //      if (p > DBL_MIN)
+      //        theParticleChange.SetMomentumChange(m.x()/p, m.y()/p, m.z()/p);
+      //      else
+      //        theParticleChange.SetMomentumChange(0., 0., 0.);
+
+      theParticleChange.SetMomentumDirectionChange(
+                                              newP->GetMomentumDirection());
+      theParticleChange.SetEnergyChange(newP->GetKineticEnergy());
+      delete newP;
+
+      //    }
+      //    else {
+      //      // charge exchange
+      //      theParticleChange.SetNumberOfSecondaries(2);
+      //      theParticleChange.AddSecondary(newP);
+      //      theParticleChange.SetStatusChange(fStopAndKill);
+      //      //      theParticleChange.SetEnergyChange(0.0);
+      //    }
+
+    // Recoil particle
+    G4DynamicParticle* p1 = new G4DynamicParticle;
+    p1->SetDefinition(targetParticle->GetDefinition());
+    p1->SetMomentum(targetParticle->GetMomentum());
+    theParticleChange.AddSecondary(p1);    
+    
+
+    return &theParticleChange;
+}
+
+ // end of file

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4AlphaCoulombBarrier.hh,v 1.2.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4AlphaCoulombBarrier.hh,v 1.4 2001/08/01 17:04:07 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Dec 1999)

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4AlphaEvaporationChannel.hh,v 1.2.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4AlphaEvaporationChannel.hh,v 1.4 2001/08/01 17:04:07 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4AlphaEvaporationProbability.hh,v 1.2.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4AlphaEvaporationProbability.hh,v 1.4 2001/08/01 17:04:08 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov 1999) 

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4B9FermiFragment.hh,v 1.3.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4B9FermiFragment.hh,v 1.5 2001/08/01 17:04:08 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov 1998)

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4Be8FermiFragment.hh,v 1.3.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4Be8FermiFragment.hh,v 1.5 2001/08/01 17:04:09 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov 1998)

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4CameronGilbertPairingCorrections.hh,v 1.3.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4CameronGilbertPairingCorrections.hh,v 1.5 2001/08/01 17:04:09 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4CameronGilbertShellCorrections.hh,v 1.3.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4CameronGilbertShellCorrections.hh,v 1.5 2001/08/01 17:04:09 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4CameronShellPlusPairingCorrections.hh,v 1.3.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4CameronShellPlusPairingCorrections.hh,v 1.5 2001/08/01 17:04:09 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4CameronTruranHilfPairingCorrections.hh,v 1.3.2.1 2001/06/28 19:12:58 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4CameronTruranHilfPairingCorrections.hh,v 1.5 2001/08/01 17:04:10 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4CameronTruranHilfShellCorrections.hh,v 1.3.2.1 2001/06/28 19:12:59 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4CameronTruranHilfShellCorrections.hh,v 1.5 2001/08/01 17:04:10 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4CompetitiveFission.hh,v 1.4.2.1 2001/06/28 19:12:59 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4CompetitiveFission.hh,v 1.6 2001/08/01 17:04:11 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4ConstantLevelDensityParameter.hh,v 1.3.2.1 2001/06/28 19:12:59 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4ConstantLevelDensityParameter.hh,v 1.5 2001/08/01 17:04:11 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations (photon evaporation)
 // by C. Dallapiccola (Nov 1998) 

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

@@ -14,7 +14,7 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *

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

@@ -14,7 +14,7 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4CoulombBarrier.hh,v 1.2.2.1 2001/06/28 19:13:00 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4CoulombBarrier.hh,v 1.5 2001/10/08 17:15:48 larazb Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Dec 1999)
@@ -58,7 +58,9 @@ private:
 
   virtual G4double BarrierPenetrationFactor(const G4double aZ) const {return 1.0;}
 
-
+  virtual G4double CalcCompoundRadius(const G4double ZRes) const 
+  {
+    return 2.173*fermi*(1.0+0.006103*G4double(GetZ())*ZRes)/(1.0+0.009443*G4double(GetZ())*ZRes);
+  }
 };
-
 #endif

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4DeuteronCoulombBarrier.hh,v 1.1.8.1 2001/06/28 19:13:00 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4DeuteronCoulombBarrier.hh,v 1.3 2001/08/01 17:04:13 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Dec 1999)

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

@@ -14,15 +14,15 @@
 // * use.                                                             *
 // *                                                                  *
 // * This  code  implementation is the  intellectual property  of the *
-// * GEANT4 collaboration.                                            *
+// * authors in the GEANT4 collaboration.                             *
 // * By copying,  distributing  or modifying the Program (or any work *
 // * based  on  the Program)  you indicate  your  acceptance of  this *
 // * statement, and all its terms.                                    *
 // ********************************************************************
 //
 //
-// $Id: G4DeuteronEvaporationChannel.hh,v 1.2.2.1 2001/06/28 19:13:00 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G4DeuteronEvaporationChannel.hh,v 1.4 2001/08/01 17:04:14 hpw Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)