Import Geant4 0.0.0 source tree

source/processes/hadronic/models/neutron_hp/include/G4InterpolationIterator.hh

@@ -0,0 +1,62 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4InterpolationIterator.hh,v 2.1 1998/11/07 11:20:54 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4InterpolationIterator_h
+#define G4InterpolationIterator_h 1
+
+#include "G4InterpolationManager.hh"
+
+class G4InterpolationIterator
+{
+   private:   
+   G4InterpolationIterator() {}
+   
+   public:
+   G4InterpolationIterator(G4InterpolationManager * aManager)
+   {
+     started = false;
+     theManager = aManager;
+   }
+   
+   ~G4InterpolationIterator(){}
+   
+   inline G4bool Fetch() 
+   {
+     if(!started) 
+     {
+       started = true;
+       counter=-1;
+       current = 0;
+     }
+     G4bool result = true;
+     if(++counter==nEntries)
+       started = false;
+       result = false;
+     else if(current != nRanges-1&&counter==theManager->start[current+1])
+       current++;
+     return result;
+   }
+   
+   inline G4InterpolationScheme Current() 
+   {
+     if(!started) G4Exception("G4InterpolationIterator not started yet");
+     return aManager->scheme[current];
+   }
+   
+   private:
+   G4InterpolationManager * theManager;
+   G4int current;
+   G4int counter;
+   G4bool started;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4InterpolationManager.hh

@@ -0,0 +1,178 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4InterpolationManager.hh,v 2.4 1998/11/07 11:20:55 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4InterpolationManager_h
+#define G4InterpolationManager_h 1
+
+#include "globals.hh"
+#include "G4InterpolationScheme.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+
+class G4InterpolationManager
+{
+   public:
+   
+   friend class G4InterpolationIterator;
+   
+   G4InterpolationManager()
+   {
+     nRanges = 1;
+     start = new G4int[1];
+     start[0] = 0;
+     range = new G4int[1];
+     range [0] = 100000;
+     scheme = new G4InterpolationScheme[1];
+     scheme[0] = LINLIN;
+     nEntries = 0;
+   }
+   
+   ~G4InterpolationManager()
+   {
+     if(start!=NULL) delete [] start;
+     if(range!=NULL) delete [] range;
+     if(scheme!=NULL) delete [] scheme;
+   }
+   
+   G4InterpolationManager & operator= (const G4InterpolationManager & aManager)
+   {
+     if(this != &aManager)
+     {
+       nRanges = aManager.nRanges;
+       nEntries = aManager.nEntries;
+       if(scheme!=NULL) delete [] scheme;
+       if(start!=NULL) delete [] start;
+       if(range!=NULL) delete [] range;
+       scheme = new G4InterpolationScheme[nRanges];
+       start = new G4int[nRanges];
+       range = new G4int[nRanges];
+       for(G4int i=0; i<nRanges; i++)
+       {
+	 scheme[i]=aManager.scheme[i];
+	 start[i]=aManager.start[i];
+	 range[i]=aManager.range[i];
+       }
+     }
+     return *this;
+   }
+   
+   inline void Init(G4int aScheme, G4int aRange)
+   {
+     nRanges = 1;
+     start[0] = 0;
+     range [0] = aRange;
+     scheme[0] = MakeScheme(aScheme);
+     nEntries = aRange;
+   }
+   inline void Init(G4InterpolationScheme aScheme, G4int aRange)
+   {
+     nRanges = 1;
+     start[0] = 0;
+     range [0] = aRange;
+     scheme[0] = aScheme;
+     nEntries = aRange;
+   }
+   
+   inline void Init(ifstream & aDataFile)
+   {
+     delete [] start;
+     delete [] range;
+     delete [] scheme;
+     aDataFile >> nRanges;
+     start = new G4int[nRanges];
+     range = new G4int[nRanges];
+     scheme = new G4InterpolationScheme[nRanges];
+     start[0] = 0;
+     G4int it;
+     for(G4int i=0; i<nRanges; i++)
+     {
+       aDataFile>>range[i];
+       if(i!=0) start[i] = start[i-1]+range[i-1];
+       aDataFile>>it;
+       scheme[i] = MakeScheme(it);
+     }
+     nEntries = start[nRanges-1]+range[nRanges-1];
+   }
+   
+   G4InterpolationScheme MakeScheme(G4int it);
+   
+   inline G4InterpolationScheme GetScheme(G4int index)
+   {
+     G4int it = 0;
+     for(G4int i=1; i<nRanges; i++)
+     {
+       if(index<start[i]) break;
+       it = i;
+     }
+     return scheme[it];
+   }
+   
+   inline void CleanUp()
+   {
+     nRanges = 0;
+     nEntries = 0;
+   }
+   
+   inline G4InterpolationScheme GetInverseScheme(G4int index)
+   {
+     G4InterpolationScheme result = GetScheme(index);
+     if(result == HISTO) 
+     {
+       result = RANDOM;
+     }
+     else if(result == LINLOG)  
+     {
+       result = LOGLIN;
+     }
+     else if(result == LOGLIN)  
+     {
+       result = LINLOG;
+     }
+     else if(result == CHISTO) 
+     {
+       result = CRANDOM;
+     }
+     else if(result == CLINLOG) 
+     {
+       result = CLOGLIN;
+     }
+     else if(result == CLOGLIN) 
+     {
+       result = CLINLOG;
+     }
+     else if(result == UHISTO) 
+     {
+       result = URANDOM;
+     }
+     else if(result == ULINLOG) 
+     {
+       result = ULOGLIN;
+     }
+     else if(result == ULOGLIN) 
+     {
+       result = ULINLOG;
+     }
+     return result;
+   }
+   
+   void AppendScheme(G4int aPoint, const G4InterpolationScheme & aScheme);
+   
+   private:
+   
+   G4int nRanges;
+   G4InterpolationScheme * scheme;
+   G4int * start;
+   G4int * range;  
+   G4int nEntries;
+    
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4InterpolationScheme.hh

@@ -0,0 +1,29 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4InterpolationScheme.hh,v 2.1 1998/11/07 11:20:56 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4InterpolationScheme_h
+#define G4InterpolationScheme_h 1
+
+#include "globals.hh"
+
+// carthesian interpolation
+// unit base interpolation
+// corresponding point interpolation
+
+enum G4InterpolationScheme 
+{
+  START,  HISTO,  LINLIN,  LINLOG,  LOGLIN,  LOGLOG, RANDOM, 
+  CSTART, CHISTO, CLINLIN, CLINLOG, CLOGLIN, CLOGLOG, CRANDOM, 
+  USTART, UHISTO, ULINLIN, ULINLOG, ULOGLIN, ULOGLOG, URANDOM 
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP2AInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP2AInelasticFS.hh,v 2.2 1998/12/04 15:07:58 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP2AInelasticFS_h
+#define G4NeutronHP2AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP2AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP2AInelasticFS(){}
+  ~G4NeutronHP2AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP2AInelasticFS * theNew = new G4NeutronHP2AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP2N2AInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP2N2AInelasticFS.hh,v 2.2 1998/12/04 15:07:58 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP2N2AInelasticFS_h
+#define G4NeutronHP2N2AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP2N2AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP2N2AInelasticFS(){}
+  ~G4NeutronHP2N2AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP2N2AInelasticFS * theNew = new G4NeutronHP2N2AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP2NAInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP2NAInelasticFS.hh,v 2.2 1998/12/04 15:07:59 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP2NAInelasticFS_h
+#define G4NeutronHP2NAInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP2NAInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP2NAInelasticFS(){}
+  ~G4NeutronHP2NAInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP2NAInelasticFS * theNew = new G4NeutronHP2NAInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP2NDInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP2NDInelasticFS.hh,v 2.2 1998/12/04 15:07:59 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP2NDInelasticFS_h
+#define G4NeutronHP2NDInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP2NDInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP2NDInelasticFS(){}
+  ~G4NeutronHP2NDInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP2NDInelasticFS * theNew = new G4NeutronHP2NDInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP2NInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP2NInelasticFS.hh,v 2.2 1998/12/04 15:07:59 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP2NInelasticFS_h
+#define G4NeutronHP2NInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP2NInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP2NInelasticFS(){}
+  ~G4NeutronHP2NInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP2NInelasticFS * theNew = new G4NeutronHP2NInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP2NPInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP2NPInelasticFS.hh,v 2.2 1998/12/04 15:07:59 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP2NPInelasticFS_h
+#define G4NeutronHP2NPInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP2NPInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP2NPInelasticFS(){}
+  ~G4NeutronHP2NPInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP2NPInelasticFS * theNew = new G4NeutronHP2NPInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP2PInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP2PInelasticFS.hh,v 2.2 1998/12/04 15:07:59 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP2PInelasticFS_h
+#define G4NeutronHP2PInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP2PInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP2PInelasticFS(){}
+  ~G4NeutronHP2PInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP2PInelasticFS * theNew = new G4NeutronHP2PInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP3AInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP3AInelasticFS.hh,v 2.2 1998/12/04 15:07:59 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP3AInelasticFS_h
+#define G4NeutronHP3AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP3AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP3AInelasticFS(){}
+  ~G4NeutronHP3AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP3AInelasticFS * theNew = new G4NeutronHP3AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP3NAInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP3NAInelasticFS.hh,v 2.2 1998/12/04 15:07:59 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP3NAInelasticFS_h
+#define G4NeutronHP3NAInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP3NAInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP3NAInelasticFS(){}
+  ~G4NeutronHP3NAInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP3NAInelasticFS * theNew = new G4NeutronHP3NAInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP3NInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP3NInelasticFS.hh,v 2.2 1998/12/04 15:07:59 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP3NInelasticFS_h
+#define G4NeutronHP3NInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP3NInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP3NInelasticFS(){}
+  ~G4NeutronHP3NInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP3NInelasticFS * theNew = new G4NeutronHP3NInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP3NPInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP3NPInelasticFS.hh,v 2.2 1998/12/04 15:08:00 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP3NPInelasticFS_h
+#define G4NeutronHP3NPInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP3NPInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP3NPInelasticFS(){}
+  ~G4NeutronHP3NPInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP3NPInelasticFS * theNew = new G4NeutronHP3NPInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHP4NInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHP4NInelasticFS.hh,v 2.2 1998/12/04 15:08:00 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHP4NInelasticFS_h
+#define G4NeutronHP4NInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHP4NInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHP4NInelasticFS(){}
+  ~G4NeutronHP4NInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHP4NInelasticFS * theNew = new G4NeutronHP4NInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPAInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPAInelasticFS.hh,v 2.2 1998/12/04 15:08:00 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPAInelasticFS_h
+#define G4NeutronHPAInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticCompFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPAInelasticFS : public G4NeutronHPInelasticCompFS
+{
+  public:
+  
+  G4NeutronHPAInelasticFS(){}
+  ~G4NeutronHPAInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPAInelasticFS * theNew = new G4NeutronHPAInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPAngular.hh

@@ -0,0 +1,70 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPAngular.hh,v 2.2 1998/11/07 11:21:01 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPAngular_h
+#define G4NeutronHPAngular_h 1
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4ReactionProduct.hh"
+#include "Randomize.hh"
+#include "G4NeutronHPLegendreStore.hh"
+#include "G4NeutronHPPartial.hh"
+
+class G4NeutronHPAngular
+{
+    public:
+    
+  G4NeutronHPAngular()
+  {
+    theAngularDistributionType = 0;
+    theIsoFlag = false;
+  } 
+  ~G4NeutronHPAngular(){}
+  
+  void Init(ifstream & aDataFile);
+  
+  void SampleAndUpdate(G4ReactionProduct & aNeutron);
+    
+  void SetTarget(const G4ReactionProduct & aTarget) { theTarget = aTarget; }
+
+  void SetNeutron(const G4ReactionProduct & aNeutron) { theNeutron = aNeutron; }
+
+  inline G4double GetTargetMass() { return targetMass; }
+
+  private:
+  
+  // the type of distribution; currently 
+  // isotropic (0), 
+  // and legendre representation (1)
+  // probability distribution (2)
+  // are supported
+  
+  G4int theAngularDistributionType;
+  G4int frameFlag; // 1=Lab, 2=CMS
+    
+  G4bool theIsoFlag; // isotropic or not?
+  
+  G4NeutronHPLegendreStore * theCoefficients; // the legendre coefficients
+
+  G4NeutronHPPartial * theProbArray; // the probability array p,costh for energy
+
+  private:
+  
+  G4double targetMass;
+
+  G4ReactionProduct theTarget;
+  G4ReactionProduct theNeutron;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPAngularP.hh

@@ -0,0 +1,93 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPAngularP.hh,v 2.1 1998/11/07 11:21:02 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPAngularP_h
+#define G4NeutronHPAngularP_h 1
+
+#include "globals.hh"
+#include "G4InterpolationManager.hh"
+
+class G4NeutronHPAngularP
+{
+  public:
+  
+  G4NeutronHPAngularP()
+  {
+    theCosTh = NULL;
+    theProb = NULL;
+  }
+  ~G4NeutronHPAngularP()
+  {
+    if(theCosTh!=NULL) delete [] theCosTh;
+    if(theProb!=NULL) delete [] theProb;
+  }
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    G4double eNeu, cosTheta, probDist;
+    G4int nProb;
+    aDataFile >> eNeu >> nProb;
+    theManager.Init(aDataFile);
+    eNeu *= eV;
+    Init(eNeu, nProb);
+    for (G4int iii=0; iii<nProb; iii++)
+    {
+      aDataFile >> cosTheta >> probDist;
+      SetCosTh(iii, cosTheta);
+      SetProb(iii,probDist);
+    }  
+  }
+  
+  inline void Init(G4double e, G4int n)
+  {
+    theCosTh = new G4double[n];
+    theProb = new G4double[n];
+    theEnergy = e;
+    nCoeff = n;
+  }
+  
+  inline void SetEnergy(G4double energy){ theEnergy = energy; }
+  inline void SetCosTh(G4int l, G4double coeff) {theCosTh[l]=coeff;}
+  inline void SetProb(G4int l, G4double coeff) {theProb[l]=coeff;}
+  
+  inline G4double GetCosTh(G4int l) {return theCosTh[l];}
+  inline G4double GetProb(G4int l) {return theProb[l];}
+  inline G4double GetEnergy(){return theEnergy;}
+  inline G4int GetNumberOfPoints(){ return nCoeff; }
+  inline G4double GetCosTh()
+  {
+    G4int i;
+    G4double rand = G4UniformRand();
+    G4double run=0, runo=0;
+    for (i=0; i<GetNumberOfPoints(); i++)
+    {
+      runo=run;
+      run += GetProb(i);
+      if(run>rand) break;
+    }
+    if(i == GetNumberOfPoints()) i--;
+    G4double costh = theInt.Interpolate(theManager.GetScheme(i), rand, 
+                                        runo, run, GetCosTh(i-1), GetCosTh(i));
+    return costh;
+  }
+  
+  private:
+  
+  G4double theEnergy; // neutron energy
+  G4NeutronHPInterpolator theInt; // knows tointerpolate
+  G4int nCoeff;
+  G4InterpolationManager theManager; // knows the interpolation between stores
+  G4double * theCosTh;
+  G4double * theProb; // probability distribution as fcn of theta
+                      // integral normalised to 1.
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPArbitaryTab.hh

@@ -0,0 +1,72 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPArbitaryTab.hh,v 2.4 1998/11/07 11:21:02 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPArbitaryTab_h
+#define G4NeutronHPArbitaryTab_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4VNeutronHPEDis.hh"
+#include "G4InterpolationManager.hh"
+
+// we will need a List of these .... one per term.
+
+class G4NeutronHPArbitaryTab : public G4VNeutronHPEDis
+{
+  public:
+  G4NeutronHPArbitaryTab()
+  {
+   theDistFunc = NULL;
+  }
+  ~G4NeutronHPArbitaryTab()
+  {
+   if(theDistFunc!=NULL) delete [] theDistFunc;
+  }
+  
+  inline void Init(ifstream & theData)
+  {
+    G4int i, total;
+    theFractionalProb.Init(theData, eV);
+    theData >> nDistFunc; // = number of incoming n energy points
+    theDistFunc = new G4NeutronHPVector [nDistFunc];
+    theManager.Init(theData);
+    G4double currentEnergy;
+    for(i=0; i<nDistFunc; i++)
+    {
+      theData >> currentEnergy;
+      theDistFunc[i].SetLabel(currentEnergy*eV);
+      theDistFunc[i].Init(theData, eV);
+      theDistFunc[i].ThinOut(0.02); // @@@ optimization to be finished.
+    }
+  }
+  
+  inline G4double GetFractionalProbability(G4double anEnergy)
+  {
+    return theFractionalProb.GetY(anEnergy);
+  }
+  
+  G4double Sample(G4double anEnergy) ;
+  
+  private:
+  
+  G4NeutronHPVector theFractionalProb;
+  G4int nDistFunc;
+  G4InterpolationManager theManager; // knows the interpolation between stores
+  G4NeutronHPVector * theDistFunc; // one per incoming energy
+  G4NeutronHPVector theBuffer;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPCapture.hh

@@ -0,0 +1,43 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPCapture.hh,v 2.1 1998/11/07 11:21:02 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: Very Low Energy Neutron X-Sections
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Builds and has the Cross-section data for one material.
+ 
+#ifndef G4NeutronHPCapture_h
+#define G4NeutronHPCapture_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPChannel.hh"
+#include "G4HadronicInteraction.hh"
+
+class G4NeutronHPCapture : public G4HadronicInteraction
+{
+  public: 
+  
+  G4NeutronHPCapture();
+
+  ~G4NeutronHPCapture();
+
+  G4VParticleChange * ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus);
+
+  private:
+  
+  G4double * xSec;
+  G4NeutronHPChannel * theCapture;
+  G4String dirName;
+  G4int numEle;
+  G4int it;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPCaptureData.hh

@@ -0,0 +1,43 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPCaptureData.hh,v 2.1 1998/11/07 11:21:03 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPCaptureData_h
+#define G4NeutronHPCaptureData_h 1
+
+#include "G4VCrossSectionDataSet.hh"
+#include "G4DynamicParticle.hh"
+#include "G4Element.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4PhysicsTable.hh"
+
+class G4NeutronHPCaptureData : public G4VCrossSectionDataSet
+{
+   public:
+   
+   G4NeutronHPCaptureData();
+   
+   ~G4NeutronHPCaptureData();
+   
+   G4bool IsApplicable(const G4DynamicParticle*, const G4Element*);
+
+   G4double GetCrossSection(const G4DynamicParticle*, const G4Element*);
+
+   void BuildPhysicsTable(const G4ParticleDefinition&);
+
+   void DumpPhysicsTable(const G4ParticleDefinition&);
+   
+   private:
+   
+   G4PhysicsTable * theCrossSections;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPCaptureFS.hh

@@ -0,0 +1,53 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPCaptureFS.hh,v 2.2 1998/12/04 15:08:00 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPCaptureFS_h
+#define G4NeutronHPCaptureFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPFinalState.hh"
+#include "G4ReactionProductVector.hh"
+#include "G4NeutronHPNames.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPCaptureFS : public G4NeutronHPFinalState
+{
+  public:
+  
+  G4NeutronHPCaptureFS()
+  {
+    hasXsec = false; 
+  }
+  
+  ~G4NeutronHPCaptureFS()
+  {
+  }
+  
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPCaptureFS * theNew = new G4NeutronHPCaptureFS;
+   return theNew;
+  }
+  
+  private:
+  
+  G4double targetMass;
+  
+  G4NeutronHPPhotonDist theFinalStatePhotons;
+  
+  G4NeutronHPNames theNames;
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPChannel.hh

@@ -0,0 +1,121 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPChannel.hh,v 2.2 1998/12/04 15:08:00 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: Very Low Energy Neutron X-Sections
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Builds and has the Cross-section data for one element and channel.
+ 
+#ifndef G4NeutronHPChannel_h
+#define G4NeutronHPChannel_h 1
+#include "globals.hh"
+#include "G4NeutronHPIsoData.hh"
+#include "G4NeutronHPVector.hh"
+#include "G4Material.hh"
+#include "G4Track.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4HadronElasticProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4StableIsotopes.hh"
+#include "G4NeutronHPCaptureFS.hh"
+#include "G4NeutronHPFinalState.hh"
+#include "G4Element.hh"
+
+class G4NeutronHPChannel
+{
+public:
+
+  G4NeutronHPChannel()
+  {
+    theChannelData = new G4NeutronHPVector; 
+    theBuffer = NULL;
+    theIsotopeWiseData = NULL;
+    theFinalStates = NULL;
+    active = NULL;
+    registerCount = -1;
+  }
+  
+  ~G4NeutronHPChannel()
+  {
+    delete theChannelData; 
+    G4int i;
+    if(theBuffer != NULL) delete theBuffer; 
+    if(theIsotopeWiseData != NULL) delete [] theIsotopeWiseData;
+    if(theFinalStates != NULL)
+    {
+      for(i=0; i<niso; i++)
+      {
+        delete theFinalStates[i];
+      }
+      delete [] theFinalStates;
+    }
+    if(active!=NULL) delete [] active;
+    
+  }
+  
+  G4double GetXsec(G4double energy);
+  
+  G4double GetWeightedXsec(G4double energy, G4int isoNumber);
+  
+  G4double GetFSCrossSection(G4double energy, G4int isoNumber);
+  
+  inline G4bool IsActive(G4int isoNumber) { return active[isoNumber]; }
+  
+  inline G4bool HasFSData(G4int isoNumber) { return theFinalStates[isoNumber]->HasFSData(); }
+  
+  inline G4bool HasAnyData(G4int isoNumber) { return theFinalStates[isoNumber]->HasAnyData(); }
+  
+  G4bool Register(G4NeutronHPFinalState *theFS);
+  
+  void Init(G4Element * theElement, const G4String dirName); 
+
+  void Init(G4Element * theElement, const G4String dirName, const G4String fsType); 
+  
+  void UpdateData(G4int A, G4int Z, G4int index, G4double abundance);
+  
+  void Harmonise(G4NeutronHPVector *& theStore, G4NeutronHPVector * theNew);
+
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack, G4int isoNumber=-1);
+    
+  inline G4int GetNiso() {return niso;}
+  
+  inline G4bool HasDataInAnyFinalState()
+  {
+    G4bool result = false;
+    G4int i;
+    for(i=0; i<niso; i++)
+    {
+      if(theFinalStates[i]->HasAnyData()) result = true;
+    }
+    return result;
+  }
+  
+private:
+  G4NeutronHPVector * theChannelData;  // total (element) cross-section for this channel
+  G4NeutronHPVector * theBuffer;
+  
+  G4NeutronHPIsoData * theIsotopeWiseData; // these are the isotope-wise cross-sections for each final state.
+  G4NeutronHPFinalState ** theFinalStates; // also these are isotope-wise pionters, parallel to the above.
+  G4bool * active;
+  G4int niso;
+
+  G4StableIsotopes theStableOnes;
+  
+  G4String theDir;
+  G4String theFSType;
+  G4Element * theElement;
+  
+  G4int registerCount;
+    
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPChannelList.hh

@@ -0,0 +1,91 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPChannelList.hh,v 2.2 1998/11/07 11:21:04 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: Very Low Energy Neutron X-Sections
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Builds and has the Cross-section data for one material.
+ 
+#ifndef G4NeutronHPChannelList_h
+#define G4NeutronHPChannelList_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPChannel.hh"
+#include "G4StableIsotopes.hh"
+
+class G4Element;
+class G4ParticleChange;
+class G4Track;
+class G4NeutronHPFinalState;
+
+class G4NeutronHPChannelList
+{      
+
+  public:
+  
+  G4NeutronHPChannelList(G4int n);
+  
+  G4NeutronHPChannelList();
+  
+  void Init(G4int n);
+
+  ~G4NeutronHPChannelList();
+  
+  G4ParticleChange * ApplyYourself(const G4Element * theElement, const G4Track & aTrack);
+      
+  void Init(G4Element * anElement, const G4String & dirName);
+    
+  void Register(G4NeutronHPFinalState *theFS, const G4String &aName);
+  
+  inline G4double GetXsec(G4double anEnergy)
+  {
+    G4double result=0;
+    G4int i;
+    for(i=0; i<nChannels; i++)
+    {
+      result+=theChannels[i]->GetXsec(anEnergy);
+    }
+    return result;
+  }
+  
+  inline G4int GetNumberOfChannels() { return nChannels; }
+      
+  inline G4bool HasDataInAnyFinalState()
+  {
+    G4bool result = false;
+    G4int i;
+    for(i=0; i<nChannels; i++)
+    {
+      if(theChannels[i]->HasDataInAnyFinalState()) result = true;
+    }
+    return result;
+  }
+  inline void RestartRegistration()
+  {
+    allChannelsCreated = true;
+    theInitCount = 0;
+  }
+  private:
+
+  static G4int trycounter;
+  G4NeutronHPChannel ** theChannels;
+  G4int nChannels;
+  G4String theDir;
+  G4Element * theElement; 
+  
+  G4bool allChannelsCreated;
+  G4int theInitCount;
+
+  G4StableIsotopes theStableOnes;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPContAngularPar.hh

@@ -0,0 +1,134 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPContAngularPar.hh,v 2.5 1998/11/07 11:21:04 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPContAngularPar_h
+#define G4NeutronHPContAngularPar_h 1
+
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4NeutronHPList.hh"
+#include "G4ReactionProduct.hh"
+#include "G4NeutronHPInterpolator.hh"
+#include "G4InterpolationManager.hh"
+
+class G4NeutronHPContAngularPar
+{
+  public:
+  
+  G4NeutronHPContAngularPar()
+  {
+    theAngular = NULL;
+    currentMeanEnergy = -2;
+  }
+  ~G4NeutronHPContAngularPar()
+  {
+    if(theAngular!=NULL) delete [] theAngular;
+  }
+  
+  void Init(ifstream & aDataFile);
+  
+  G4ReactionProduct * Sample(G4double anEnergy, G4double massCode, G4double mass, 
+                             G4int angularRep, G4int interpol);
+  
+  G4double GetEnergy() { return theEnergy; }
+  
+  void SetPrimary(G4ReactionProduct * aPrimary)
+  {
+    thePrimary = aPrimary;
+  }
+  
+  void SetTarget(G4ReactionProduct * aTarget)
+  {
+    theTarget = aTarget;
+  }
+  
+  void SetTargetCode(G4double aTargetCode) { theTargetCode = aTargetCode; }
+  
+  void SetInterpolation(G4int theInterpolation)
+  {
+    theManager.Init(theInterpolation, nEnergies); // one range only
+  }
+
+  void Merge(G4double anEnergy, G4InterpolationScheme & aScheme, 
+             G4NeutronHPContAngularPar & store1, 
+             G4NeutronHPContAngularPar & store2) // hmmmm, this interpolates legendre coefficients. Dangerous @@@
+  {
+    nDiscreteEnergies = store1.nDiscreteEnergies;
+    nAngularParameters = store1.nAngularParameters;
+    nEnergies = store1.nEnergies;
+    theManager = store1.theManager;
+    theEnergy = anEnergy;
+    if(theAngular != NULL) delete [] theAngular;
+    theAngular = new G4NeutronHPList[nEnergies];
+    G4int i, ii;
+    G4double value;
+    for(i=0; i<nEnergies; i++)
+    {
+      theAngular[i].SetLabel(store1.theAngular[i].GetLabel());
+      for(ii=0; ii<nAngularParameters; ii++)
+      {
+//        G4cout <<"test "<<i<<" "<<store1.theEnergy<<" "<<store2.theEnergy<<" "
+//             << store1.theAngular[i].GetValue(ii)<<" "<<
+//             store2.theAngular[i].GetValue(ii)<<endl;
+        value = theInt.Interpolate(aScheme, anEnergy, 
+                                   store1.theEnergy, store2.theEnergy,
+                                   store1.theAngular[i].GetValue(ii),
+                                   store2.theAngular[i].GetValue(ii));
+        theAngular[i].SetValue(ii, value);
+      }
+    }
+  };
+  
+  G4double MeanEnergyOfThisInteraction()
+  {
+    G4double result;
+    if(currentMeanEnergy<-1)
+    {
+      return 0;
+      // G4Exception("G4NeutronHPContAngularPar: Logical error in Product class");
+    }
+    else
+    {
+      result = currentMeanEnergy;
+    }
+    currentMeanEnergy = -2;
+    return result;
+  }
+  
+  private:
+  
+  // incoming particle
+  G4double theEnergy; 
+  
+  // number of exit channel energies
+  G4int nEnergies; 
+  // number of discrete exit channels
+  G4int nDiscreteEnergies;
+  // number of angular paramerers per channel
+  G4int nAngularParameters;
+  // knows the interpolation between List labels
+  G4InterpolationManager theManager; 
+  // on per exit-channel energy
+  G4NeutronHPList * theAngular; 
+  
+  private:
+  
+  G4NeutronHPInterpolator theInt;
+  
+  G4double theTargetCode;
+  G4ReactionProduct * theTarget;
+  G4ReactionProduct * thePrimary;
+  
+  G4double currentMeanEnergy;
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPContEnergyAngular.hh

@@ -0,0 +1,70 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPContEnergyAngular.hh,v 2.2 1998/11/07 11:21:05 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPContEnergyAngular_h
+#define G4NeutronHPContEnergyAngular_h 1
+
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4VNeutronHPEnergyAngular.hh"
+#include "G4NeutronHPContAngularPar.hh"
+#include "G4InterpolationManager.hh"
+
+// we will need one of these per product.
+
+class G4NeutronHPContEnergyAngular : public G4VNeutronHPEnergyAngular
+{
+  public:
+  
+  G4NeutronHPContEnergyAngular()
+  {
+    theAngular = NULL;
+    currentMeanEnergy = -2;
+  }
+  
+  ~G4NeutronHPContEnergyAngular()
+  {
+    if(theAngular!=NULL) delete [] theAngular;
+  }
+  
+  public:
+  
+  void Init(ifstream & aDataFile)
+  {
+    aDataFile >> theTargetCode >> theAngularRep >> theInterpolation >> nEnergy;
+    theAngular = new G4NeutronHPContAngularPar[nEnergy];
+    theManager.Init(aDataFile);
+    for(G4int i=0; i<nEnergy; i++)
+    {
+      theAngular[i].Init(aDataFile);
+      theAngular[i].SetInterpolation(theInterpolation);
+    }
+  }
+G4double MeanEnergyOfThisInteraction();
+G4ReactionProduct * Sample(G4double anEnergy, G4double massCode, G4double mass);
+  
+  private:
+  
+  G4double theTargetCode;
+  G4int theAngularRep;
+  G4int nEnergy;
+  
+  G4int theInterpolation;
+
+  G4InterpolationManager theManager; // knows the interpolation between stores
+  G4NeutronHPContAngularPar * theAngular;
+  
+  G4double currentMeanEnergy;
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPD2AInelasticFS.hh

@@ -0,0 +1,37 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPD2AInelasticFS.hh,v 2.2 1998/12/04 15:08:01 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPD2AInelasticFS_h
+#define G4NeutronHPD2AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+
+class G4NeutronHPD2AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPD2AInelasticFS(){}
+  ~G4NeutronHPD2AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPD2AInelasticFS * theNew = new G4NeutronHPD2AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPDAInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPDAInelasticFS.hh,v 2.2 1998/12/04 15:08:01 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPDAInelasticFS_h
+#define G4NeutronHPDAInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPDAInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPDAInelasticFS(){}
+  ~G4NeutronHPDAInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPDAInelasticFS * theNew = new G4NeutronHPDAInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPDInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPDInelasticFS.hh,v 2.2 1998/12/04 15:08:02 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPDInelasticFS_h
+#define G4NeutronHPDInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticCompFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPDInelasticFS : public G4NeutronHPInelasticCompFS
+{
+  public:
+  
+  G4NeutronHPDInelasticFS(){}
+  ~G4NeutronHPDInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPDInelasticFS * theNew = new G4NeutronHPDInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPData.hh

@@ -0,0 +1,71 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPData.hh,v 2.4 1998/11/07 11:21:07 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: Very Low Energy Neutron X-Sections
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Has the Cross-section data for all materials.
+ 
+#ifndef G4NeutronHPData_h
+#define G4NeutronHPData_h 1
+#include "globals.hh"
+#include "G4Element.hh"
+#include "G4NeutronHPElasticData.hh"
+#include "G4NeutronHPInelasticData.hh"
+#include "G4NeutronHPFissionData.hh"
+#include "G4NeutronHPCaptureData.hh"
+#include "G4NeutronHPElementData.hh"
+
+class G4NeutronHPData
+{
+public:
+
+  G4NeutronHPData();
+
+  ~G4NeutronHPData();
+
+  inline G4PhysicsVector * MakePhysicsVector(G4Element * thE, G4NeutronHPFissionData * theP)
+  {
+     return DoPhysicsVector(theData[thE->GetIndex()].GetData(theP));
+  }
+  inline G4PhysicsVector * MakePhysicsVector(G4Element * thE, G4NeutronHPCaptureData * theP)
+  {
+     return DoPhysicsVector(theData[thE->GetIndex()].GetData(theP));
+  }
+  inline G4PhysicsVector * MakePhysicsVector(G4Element * thE, G4NeutronHPElasticData * theP)
+  {
+     return DoPhysicsVector(theData[thE->GetIndex()].GetData(theP));
+  }
+  inline G4PhysicsVector * MakePhysicsVector(G4Element * thE, G4NeutronHPInelasticData * theP)
+  {
+//     G4cout << "entered G4NeutronHPData::MakePhysicsVector!!!"<<endl;
+//     G4cout << "thE->GetIndex()="<<thE->GetIndex()<<endl;
+     return DoPhysicsVector(theData[thE->GetIndex()].GetData(theP));
+  }
+
+  G4PhysicsVector * DoPhysicsVector(G4NeutronHPVector * theVector);
+  
+  static G4NeutronHPData * Instance()
+  {
+    if(theCrossSectionData==NULL) theCrossSectionData = new G4NeutronHPData;
+    return theCrossSectionData;
+  }
+  
+private:
+
+  G4NeutronHPElementData * theData;
+  G4int numEle;
+  
+  static G4NeutronHPData * theCrossSectionData;
+
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPDataPoint.hh

@@ -0,0 +1,56 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPDataPoint.hh,v 2.2 1998/11/07 11:21:07 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPDataPoint_h
+#define G4NeutronHPDataPoint_h 1
+
+#include "globals.hh"
+
+class G4NeutronHPDataPoint
+{
+  public:
+  
+  G4NeutronHPDataPoint(){energy = 0; xSec = 0;}
+  G4NeutronHPDataPoint(G4double e, G4double x){ energy = e; xSec = x;}
+  
+  void operator= (const G4NeutronHPDataPoint & aSet)
+  {
+    if(&aSet!=this)
+    {
+      energy = aSet.GetEnergy();
+      xSec   = aSet.GetXsection();
+    }
+  }
+
+//  ~G4NeutronHPDataPoint(){}
+  
+  inline G4double GetEnergy() const   {return energy;}
+  inline G4double GetXsection() const {return xSec;}
+  
+  inline void SetEnergy(G4double e)  {energy = e;}
+  inline void SetXsection(G4double x){xSec = x;}
+  
+  inline G4double GetX() const {return energy;}
+  inline G4double GetY() const {return xSec;}
+  
+  inline void SetX(G4double e)  {energy = e;}
+  inline void SetY(G4double x)  {xSec = x;}
+  
+  inline void SetData(G4double e, G4double x) {energy = e; xSec = x;}
+  
+  private:
+  
+  G4double energy;
+  G4double xSec;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPDataUsed.hh

@@ -0,0 +1,32 @@
+#ifndef G4NeutronHPDataUsed_h
+#define G4NeutronHPDataUsed_h 1
+
+#include "globals.hh"
+
+class G4NeutronHPDataUsed
+{
+  public:
+  
+  G4NeutronHPDataUsed()
+  {
+    theName = "";
+    theA = 0;
+    theZ = 0;
+  }
+  
+  void SetA(G4double anA){theA = anA;}
+  void SetZ(G4int aZ){theZ = aZ;}
+  void SetName(G4String aName){theName = aName;}
+
+  G4int GetZ() {return theZ;}
+  G4double GetA() {return theA;}
+  G4String GetName() {return theName;}
+  
+  private:
+  
+  G4String theName;
+  G4double theA;
+  G4int theZ;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPDeExGammas.hh

@@ -0,0 +1,95 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPDeExGammas.hh,v 2.3 1998/12/09 21:21:19 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPDeExGammas_h
+#define G4NeutronHPDeExGammas_h 1
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4ReactionProductVector.hh"
+#include "G4Gamma.hh"
+#include "G4NeutronHPLevel.hh"
+#include "G4NeutronHPGamma.hh"
+#include "G4ReactionProduct.hh"
+
+class G4NeutronHPDeExGammas
+{
+  public:
+  
+  G4NeutronHPDeExGammas() 
+  {
+    levelStart = NULL;
+    levelSize = NULL;
+    nLevels = 0;
+    theLevels = NULL;
+  }
+  ~G4NeutronHPDeExGammas() 
+  {
+    if(levelStart!=NULL) delete [] levelStart;
+    if(levelSize!=NULL) delete [] levelSize;
+    if(theLevels!=NULL) delete [] theLevels;
+  }
+  
+  void Init(ifstream & aDataFile);
+
+  inline G4ReactionProductVector * GetDecayGammas(G4int aLevel)
+  {
+    if(aLevel>nLevels-1 || aLevel<0) return NULL;
+    if(nLevels==0) return new G4ReactionProductVector();
+    G4ReactionProductVector * result = new G4ReactionProductVector;
+    G4DynamicParticleVector * theResult;
+
+    theResult = theLevels[aLevel]. GetDecayGammas();
+    G4ReactionProduct * theCurrent;
+    G4int i;
+    for(i=0; i<theResult->length(); i++)
+    {
+      theCurrent = new G4ReactionProduct;
+      *theCurrent = *(theResult->at(i));
+      delete theResult->at(i);
+      G4double costheta = 2.*G4UniformRand()-1;
+      G4double theta = acos(costheta);
+      G4double phi = twopi*G4UniformRand();
+      G4double sinth = sin(theta);
+      G4double en = theCurrent->GetTotalMomentum();
+      G4ThreeVector temp(en*sinth*cos(phi), en*sinth*sin(phi), en*costheta );
+      theCurrent->SetMomentum( temp ) ;
+      result->insert(theCurrent);
+    }
+    delete theResult;
+    return result;
+  }
+  
+  inline G4NeutronHPLevel * GetLevel(G4int i)
+  {
+    if(i>nLevels-1) return NULL;
+    return theLevels+i;
+  }
+  
+  inline G4int GetNumberOfLevels() { return nLevels; }
+  
+  inline G4double GetLevelEnergy(G4int aLevel)
+  {
+    if(aLevel>nLevels-1 || aLevel<0) return 0;
+    G4double result = theLevels[aLevel].GetLevelEnergy();
+    return result;
+  }
+  private:
+  
+  G4int * levelStart;
+  G4int * levelSize;
+  G4int nLevels;
+  G4NeutronHPLevel * theLevels;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPDiscreteTwoBody.hh

@@ -0,0 +1,75 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPDiscreteTwoBody.hh,v 2.3 1998/11/07 11:21:08 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPDiscreteTwoBody_h
+#define G4NeutronHPDiscreteTwoBody_h 1
+
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4VNeutronHPEnergyAngular.hh"
+#include "G4NeutronHPLegendreTable.hh"
+#include "G4NeutronHPInterpolator.hh"
+#include "G4InterpolationManager.hh"
+
+class G4NeutronHPDiscreteTwoBody : public G4VNeutronHPEnergyAngular
+{
+  public:
+  
+  G4NeutronHPDiscreteTwoBody()
+  {
+    theCoeff = NULL;
+  }
+  ~G4NeutronHPDiscreteTwoBody()
+  {
+    if(theCoeff!=NULL) delete [] theCoeff;
+  }
+  
+  void Init(ifstream & aDataFile)
+  {
+    aDataFile >> nEnergy;
+    theManager.Init(aDataFile);
+    theCoeff = new G4NeutronHPLegendreTable[nEnergy];
+    for(G4int i=0; i<nEnergy; i++)
+    {
+      G4double energy;
+      G4int aRep, nCoeff;
+      aDataFile >> energy >> aRep >> nCoeff;
+      energy*=eV;
+      G4int nPoints=nCoeff;
+      if(aRep>0) nPoints*=2;
+      theCoeff[i].Init(energy, nPoints);
+      theCoeff[i].SetRepresentation(aRep);
+      for(G4int ii=0; ii<nPoints; ii++)
+      {
+        G4double y;
+        aDataFile >> y;
+        theCoeff[i].SetCoeff(ii, y);
+      }
+    }
+  }
+    
+  G4ReactionProduct * Sample(G4double anEnergy, G4double massCode, G4double mass);
+  G4double MeanEnergyOfThisInteraction() { return -1; }
+  
+  private:
+  
+  G4int nEnergy;
+  G4InterpolationManager theManager; // knows the interpolation between stores
+  G4NeutronHPLegendreTable * theCoeff;
+    
+  private:
+  
+  G4NeutronHPInterpolator theInt;
+
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPElastic.hh

@@ -0,0 +1,43 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPElastic.hh,v 2.1 1998/11/07 11:21:08 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: High Precision low E neutron tracking
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Builds and has the Cross-section data for one material.
+ 
+#ifndef G4NeutronHPElastic_h
+#define G4NeutronHPElastic_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPChannel.hh"
+#include "G4HadronicInteraction.hh"
+
+class G4NeutronHPElastic : public G4HadronicInteraction
+{
+  public: 
+  
+  G4NeutronHPElastic();
+  
+  ~G4NeutronHPElastic();
+  
+  G4VParticleChange * ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus);
+
+  G4int GetNiso() {return theElastic[0].GetNiso();}
+  private:
+  
+  G4double * xSec;
+  G4NeutronHPChannel * theElastic;
+  G4String dirName;
+  G4int numEle;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPElasticData.hh

@@ -0,0 +1,43 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPElasticData.hh,v 2.1 1998/11/07 11:21:09 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPElasticData_h
+#define G4NeutronHPElasticData_h 1
+
+#include "G4VCrossSectionDataSet.hh"
+#include "G4DynamicParticle.hh"
+#include "G4Element.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4PhysicsTable.hh"
+
+class G4NeutronHPElasticData : public G4VCrossSectionDataSet
+{
+   public:
+   
+   G4NeutronHPElasticData();
+   
+   ~G4NeutronHPElasticData();
+   
+   G4bool IsApplicable(const G4DynamicParticle*, const G4Element*);
+
+   G4double GetCrossSection(const G4DynamicParticle*, const G4Element*);
+
+   void BuildPhysicsTable(const G4ParticleDefinition&);
+
+   void DumpPhysicsTable(const G4ParticleDefinition&);
+   
+   private:
+   
+   G4PhysicsTable * theCrossSections;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPElasticFS.hh

@@ -0,0 +1,60 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPElasticFS.hh,v 2.2 1998/12/04 15:08:02 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPElasticFS_h
+#define G4NeutronHPElasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPFinalState.hh"
+#include "G4NeutronHPLegendreStore.hh"
+#include "G4NeutronHPPartial.hh"
+#include "G4NeutronHPFastLegendre.hh"
+#include "G4NeutronHPInterpolator.hh"
+#include "G4NeutronHPNames.hh"
+
+class G4NeutronHPElasticFS : public G4NeutronHPFinalState
+{
+  public:
+  
+  G4NeutronHPElasticFS()
+  {
+    hasXsec = false; 
+    theCoefficients = NULL;
+    theProbArray = NULL;
+  }
+  ~G4NeutronHPElasticFS()
+  {
+    if(theCoefficients!=NULL) delete theCoefficients;
+    if(theProbArray!=NULL) delete theProbArray;
+  }
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPElasticFS * theNew = new G4NeutronHPElasticFS;
+   return theNew;
+  }
+  
+  private:
+  G4int repFlag;    // Legendre coeff(1), or probability array(2), or isotropic(0).
+  G4double targetMass; // in neutronmass units.
+  G4int frameFlag;  // CMS or Lab system.
+  
+  G4NeutronHPLegendreStore * theCoefficients; // the legendre coefficients
+  G4NeutronHPPartial * theProbArray; // the probability array p,costh for energy
+  G4NeutronHPInterpolator theInt; // interpolation
+  
+  G4NeutronHPFastLegendre theLegend; // fast look-up for leg-integrals
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPElementData.hh

@@ -0,0 +1,89 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPElementData.hh,v 2.1 1998/11/07 11:21:09 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: Very Low Energy Neutron X-Sections
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Builds and has the Cross-section data for one material.
+ 
+#ifndef G4NeutronHPElementData_h
+#define G4NeutronHPElementData_h 1
+#include "globals.hh"
+#include "G4NeutronHPIsoData.hh"
+#include "G4NeutronHPVector.hh"
+#include "G4Material.hh"
+#include "G4HadronCrossSections.hh"
+#include "G4NeutronInelasticProcess.hh"
+#include "G4HadronFissionProcess.hh"
+#include "G4HadronCaptureProcess.hh"
+#include "G4NeutronHPElasticData.hh"
+#include "G4NeutronHPFissionData.hh"
+#include "G4NeutronHPCaptureData.hh"
+#include "G4NeutronHPInelasticData.hh"
+#include "G4StableIsotopes.hh"
+
+class G4NeutronHPElementData : public G4HadronCrossSections
+{
+public:
+
+  G4NeutronHPElementData();
+  
+  ~G4NeutronHPElementData();
+  
+  void Init(G4Element * theElement);
+  
+  void UpdateData(G4int A, G4int Z, G4int index, G4double abundance);
+  
+  void Harmonise(G4NeutronHPVector *& theStore, G4NeutronHPVector * theNew);
+  
+  inline G4NeutronHPVector * GetData(G4NeutronHPFissionData * theP)
+    {return theFissionData;}
+  inline G4NeutronHPVector * GetData(G4NeutronHPCaptureData * theP)
+    {return theCaptureData;}
+  inline G4NeutronHPVector * GetData(G4NeutronHPElasticData * theP)
+    {return theElasticData;}
+  inline G4NeutronHPVector * GetData(G4NeutronHPInelasticData * theP)
+    {return theInelasticData;}
+
+  G4NeutronHPVector * MakePhysicsVector(G4Element * theElement,
+                                      G4ParticleDefinition * theP,
+                                      G4NeutronHPFissionData* theSet);
+
+  G4NeutronHPVector * MakePhysicsVector(G4Element * theElement,
+                                      G4ParticleDefinition * theP,
+                                      G4NeutronHPCaptureData * theSet);
+
+  G4NeutronHPVector * MakePhysicsVector(G4Element * theElement,
+                                      G4ParticleDefinition * theP,
+                                      G4NeutronHPElasticData * theSet);
+
+  G4NeutronHPVector * MakePhysicsVector(G4Element * theElement,
+                                      G4ParticleDefinition * theP,
+                                      G4NeutronHPInelasticData * theSet);
+
+private:
+
+  G4NeutronHPVector * theFissionData;
+  G4NeutronHPVector * theCaptureData;
+  G4NeutronHPVector * theElasticData;
+  G4NeutronHPVector * theInelasticData;
+  
+  G4NeutronHPVector * theBuffer;
+  
+  G4NeutronHPIsoData * theIsotopeWiseData;
+
+  G4StableIsotopes theStableOnes;
+  
+  G4String filename;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPEnAngCorrelation.hh

@@ -0,0 +1,100 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPEnAngCorrelation.hh,v 2.2 1998/11/07 11:21:10 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPEnAngCorrelation_h
+#define G4NeutronHPEnAngCorrelation_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4NeutronHPProduct.hh"
+#include "G4ReactionProduct.hh"
+
+class G4NeutronHPEnAngCorrelation
+{
+  public:
+  G4NeutronHPEnAngCorrelation()
+  {
+    theProducts = NULL;
+    inCharge = false;
+    theTotalMeanEnergy = -1.;
+  }
+  ~G4NeutronHPEnAngCorrelation()
+  {
+    if(theProducts!=NULL) delete [] theProducts;
+  }
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    inCharge = true;
+    aDataFile>>targetMass>>frameFlag>>nProducts;
+    theProducts = new G4NeutronHPProduct[nProducts];
+    for(G4int i=0; i<nProducts; i++)
+    {
+      theProducts[i].Init(aDataFile);
+    }
+  }
+  
+  G4ReactionProduct * SampleOne(G4double anEnergy);
+
+  G4ReactionProductVector * Sample(G4double anEnergy);
+  
+  inline void SetTarget(G4ReactionProduct & aTarget)
+  {
+    theTarget = aTarget;
+    for(G4int i=0;i<nProducts;i++)theProducts[i].SetTarget(&theTarget);
+  }
+  
+  inline void SetNeutron(G4ReactionProduct & aNeutron)
+  {
+    theNeutron = aNeutron;
+    for(G4int i=0;i<nProducts;i++)theProducts[i].SetNeutron(&theNeutron);
+  }
+  
+  inline G4bool InCharge()
+  {
+    return inCharge;
+  }
+  
+  inline G4double GetTargetMass() { return targetMass; }
+  
+  G4double GetTotalMeanEnergy()
+  {
+     // cashed in 'sample' call
+    return theTotalMeanEnergy; 
+  }
+  
+  private:
+   
+  // data members
+  
+  G4double targetMass;
+  G4int frameFlag; // =1: Target rest frame; =2: CMS system; incident always in lab
+  G4int nProducts;
+  G4NeutronHPProduct * theProducts;
+  G4bool inCharge;
+    
+  // Utility quantities
+  
+  G4ReactionProduct theTarget;
+  G4ReactionProduct theNeutron;
+  
+  // cashed values
+  
+  G4double theTotalMeanEnergy;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPEnergyDistribution.hh

@@ -0,0 +1,120 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPEnergyDistribution.hh,v 2.5 1998/11/07 11:21:10 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPEnergyDistribution_h
+#define G4NeutronHPEnergyDistribution_h 1
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4NeutronHPArbitaryTab.hh"
+#include "G4NeutronHPEvapSpectrum.hh"
+#include "G4NeutronHPSimpleEvapSpectrum.hh"
+#include "G4NeutronHPFissionSpectrum.hh"
+#include "G4NeutronHPWattSpectrum.hh"
+#include "G4NeutronHPMadlandNixSpectrum.hh"
+#include "G4VNeutronHPEDis.hh"
+#include "Randomize.hh"
+
+// we will need a List of these .... one per term.
+
+class G4NeutronHPEnergyDistribution
+{
+  public:
+  G4NeutronHPEnergyDistribution()
+  {
+    theEnergyDistribution = NULL;
+    theNumberOfPartials = 0;
+    theRepresentationType = 0;
+  }
+  ~G4NeutronHPEnergyDistribution()
+  {
+    if(theEnergyDistribution != NULL)
+    {
+      for(G4int i=0; i<theNumberOfPartials; i++) 
+      {
+        delete theEnergyDistribution[i];
+      }
+      delete [] theEnergyDistribution;
+    }
+  }
+  
+  inline void Init(ifstream & theData)
+  {
+    G4double dummy;
+    theData >> dummy >> theNumberOfPartials;
+    theEnergyDistribution = new G4VNeutronHPEDis * [theNumberOfPartials];
+    for(G4int i=0; i<theNumberOfPartials; i++) 
+    {
+      theData >> theRepresentationType;
+      switch(theRepresentationType)
+      {
+	case 1:
+          theEnergyDistribution[i] = new G4NeutronHPArbitaryTab;
+          break;
+	case 5:        
+          theEnergyDistribution[i] = new G4NeutronHPEvapSpectrum;
+          break;
+	case 7:
+          theEnergyDistribution[i] = new G4NeutronHPFissionSpectrum;
+          break;
+	case 9:
+          theEnergyDistribution[i] = new G4NeutronHPSimpleEvapSpectrum;
+          break;
+	case 11:
+          theEnergyDistribution[i] = new G4NeutronHPWattSpectrum;
+          break;
+	case 12:
+          theEnergyDistribution[i] = new G4NeutronHPMadlandNixSpectrum;
+          break;
+      }
+      theEnergyDistribution[i]->Init(theData);
+    }
+  }
+  
+  inline G4double Sample(G4double anEnergy, G4int & it) 
+  {
+    G4double result = 0;
+    it = 0;
+    if (theNumberOfPartials != 0)
+    {
+      G4double sum=0;
+      G4double * running = new G4double[theNumberOfPartials];
+      running[0] = 0;
+      G4int i;
+      for (i=0; i<theNumberOfPartials; i++)
+      {	
+	if (i!=0) running[i]=running[i-1];
+	running[i]+=theEnergyDistribution[i]->GetFractionalProbability(anEnergy);
+      }
+      sum = running[theNumberOfPartials-1];
+      G4double random = G4UniformRand();
+      for(i=0; i<theNumberOfPartials; i++)
+      {
+	it = i;
+	if(running[i]/sum>random) break;
+      }
+      delete [] running;
+      if(it==theNumberOfPartials) it--;
+      result = theEnergyDistribution[it]->Sample(anEnergy);
+    }
+    return result;
+  }
+  
+  private:
+  
+  G4int theNumberOfPartials;
+  G4int theRepresentationType;
+  G4VNeutronHPEDis ** theEnergyDistribution;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPEvapSpectrum.hh

@@ -0,0 +1,65 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPEvapSpectrum.hh,v 2.3 1998/11/07 11:21:11 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPEvapSpectrum_h
+#define G4NeutronHPEvapSpectrum_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4VNeutronHPEDis.hh"
+
+// we will need a List of these .... one per term.
+
+class G4NeutronHPEvapSpectrum : public G4VNeutronHPEDis
+{
+  public:
+  G4NeutronHPEvapSpectrum()
+  {
+  }
+  ~G4NeutronHPEvapSpectrum()
+  {
+  }
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    theFractionalProb.Init(aDataFile);
+    theThetaDist.Init(aDataFile);
+    theXDist.Init(aDataFile);
+  }
+  
+  inline G4double GetFractionalProbability(G4double anEnergy)
+  {
+    return theFractionalProb.GetY(anEnergy);
+  }
+  
+  inline G4double Sample(G4double anEnergy) 
+  {
+    // when this is called, theFractionalProb was used, and 'k' is sorted out already.
+    G4double x = theXDist.Sample();
+    G4double theta = theThetaDist.GetY(anEnergy);
+    G4double result = x*theta;
+    return result*eV;
+  }
+  
+  private:
+  
+  G4NeutronHPVector theFractionalProb;
+  
+  G4NeutronHPVector theThetaDist;
+  G4NeutronHPVector theXDist;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFCFissionFS.hh

@@ -0,0 +1,39 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFCFissionFS.hh,v 2.5 1998/12/04 15:08:03 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFCFissionFS_h
+#define G4NeutronHPFCFissionFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4DynamicParticleVector.hh"
+#include "G4NeutronHPFissionBaseFS.hh"
+
+class G4NeutronHPFCFissionFS : public G4NeutronHPFissionBaseFS
+{
+  public:
+  
+  G4NeutronHPFCFissionFS(){ hasXsec = false; }
+  ~G4NeutronHPFCFissionFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4DynamicParticleVector * ApplyYourself(G4int nNeutrons);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPFCFissionFS * theNew = new G4NeutronHPFCFissionFS;
+   return theNew;
+  }
+  
+  private:
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack) { return NULL; }
+    
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFSFissionFS.hh

@@ -0,0 +1,94 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFSFissionFS.hh,v 2.4 1998/12/04 15:08:03 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFSFissionFS_h
+#define G4NeutronHPFSFissionFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4DynamicParticleVector.hh"
+#include "G4NeutronHPFinalState.hh"
+#include "G4NeutronHPNames.hh"
+#include "G4NeutronHPNeutronYield.hh"
+#include "G4NeutronHPVector.hh"
+#include "G4NeutronHPFissionERelease.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPPhotonDist.hh"
+#include "G4NeutronHPAngular.hh"
+
+class G4NeutronHPFSFissionFS : public G4NeutronHPFinalState
+{
+  public:
+  
+  G4NeutronHPFSFissionFS(){ hasXsec = true; }
+  ~G4NeutronHPFSFissionFS(){}
+  
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  
+  G4DynamicParticleVector * ApplyYourself(G4int Prompt, G4int delayed, G4double *decayconst);
+  
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPFSFissionFS * theNew = new G4NeutronHPFSFissionFS;
+   return theNew;
+  }
+  
+  inline G4double GetMass(){ return targetMass; }
+  
+  void SampleNeutronMult(G4int&all, 
+	  		 G4int&Prompt, 
+			 G4int&delayed, 
+			 G4double energy,
+			 G4int off);
+						 
+  inline void SetNeutron(const G4ReactionProduct & aNeutron)
+                        { 
+                          theNeutron = aNeutron;
+                          theNeutronAngularDis.SetNeutron(aNeutron);
+                        }
+  
+  inline void SetTarget(const G4ReactionProduct & aTarget)
+                        { 
+                          theTarget = aTarget; 
+                          theNeutronAngularDis.SetTarget(aTarget);
+                        }
+    
+  G4DynamicParticleVector * GetPhotons();
+  
+  inline G4NeutronHPFissionERelease * GetEnergyRelease()
+  {
+    return &theEnergyRelease;
+  }
+  
+  private:
+
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack) { return NULL; }
+  
+  G4double targetMass;
+  
+  G4NeutronHPNeutronYield theFinalStateNeutrons;
+  G4NeutronHPEnergyDistribution thePromptNeutronEnDis;
+  G4NeutronHPEnergyDistribution theDelayedNeutronEnDis;
+  G4NeutronHPAngular theNeutronAngularDis;
+  
+  G4NeutronHPPhotonDist theFinalStatePhotons;
+  G4NeutronHPFissionERelease theEnergyRelease;
+  
+  G4ReactionProduct theNeutron;
+  G4ReactionProduct theTarget;
+  
+  private:
+  
+  G4NeutronHPNames theNames;
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFastLegendre.hh

@@ -0,0 +1,216 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFastLegendre.hh,v 2.3 1998/11/07 11:21:12 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFastLegendre_h
+#define G4NeutronHPFastLegendre_h 1
+
+#include "globals.hh"
+
+class G4NeutronHPFastLegendre
+{
+  public:
+  
+  G4NeutronHPFastLegendre()
+  {
+    value = new G4double * [31];
+    value[0] = l0;
+    value[1] = l1;
+    value[2] = l2;
+    value[3] = l3;
+    value[4] = l4;
+    value[5] = l5;
+    value[6] = l6;
+    value[7] = l7;
+    value[8] = l8;
+    value[9] = l9;
+    value[10] = l10;
+    value[11] = l11;
+    value[12] = l12;
+    value[13] = l13;
+    value[14] = l14;
+    value[15] = l15;
+    value[16] = l16;
+    value[17] = l17;
+    value[18] = l18;
+    value[19] = l19;
+    value[20] = l20;
+    value[21] = l21;
+    value[22] = l22;
+    value[23] = l23;
+    value[24] = l24;
+    value[25] = l25;
+    value[26] = l26;
+    value[27] = l27;
+    value[28] = l28;
+    value[29] = l29;
+    value[30] = l30;
+    integral = new G4double * [31];
+    integral[0] = i0;
+    integral[1] = i1;
+    integral[2] = i2;
+    integral[3] = i3;
+    integral[4] = i4;
+    integral[5] = i5;
+    integral[6] = i6;
+    integral[7] = i7;
+    integral[8] = i8;
+    integral[9] = i9;
+    integral[10] = i10;
+    integral[11] = i11;
+    integral[12] = i12;
+    integral[13] = i13;
+    integral[14] = i14;
+    integral[15] = i15;
+    integral[16] = i16;
+    integral[17] = i17;
+    integral[18] = i18;
+    integral[19] = i19;
+    integral[20] = i20;
+    integral[21] = i21;
+    integral[22] = i22;
+    integral[23] = i23;
+    integral[24] = i24;
+    integral[25] = i25;
+    integral[26] = i26;
+    integral[27] = i27;
+    integral[28] = i28;
+    integral[29] = i29;
+    integral[30] = i30;
+    
+    G4int i;
+    for(i=0;i<31;i++) theNbin[i]=1+200*(i+1);
+  }
+  
+  ~G4NeutronHPFastLegendre()
+  {
+    delete [] value;
+    delete [] integral;
+  }
+  
+  G4double Integrate(G4int l, G4double costh)
+  {
+    G4int bin = GetBin(l, costh);
+    G4double y1, y2;
+//    G4cout <<"Testhpw G4NeutronHPFastLegendre::Integrate "<<l<<" "<<bin<<endl;
+    y1 = integral[l][bin];
+    y2 = integral[l][bin+1];
+//    G4cout <<"Testhpw G4NeutronHPFastLegendre::Integrate exit"<<endl;
+    return Interpolate(bin, l, y1, y2, costh);
+  }
+  
+  inline G4double Evaluate(G4int l, G4double costh)
+  {
+    G4double result;
+    G4int bin = GetBin(l, costh);
+    if(bin != theNbin[l]-1)
+    {
+      G4double y1, y2;
+      y1 = value[l][bin];
+      y2 = value[l][bin+1];
+      result = Interpolate(bin, l, y1, y2, costh);
+    }
+    else
+    {
+      result = value[l][bin];
+    }
+    return result;
+  }
+  private:
+  
+  inline G4int GetBin(G4int l, G4double costh)
+  {
+    G4int bin=0;
+    bin = (theNbin[l]-1)*(costh+1)/2.;
+    if(bin == theNbin[l]-1) bin--;
+    return bin;
+  }
+  
+  inline G4double Interpolate(G4int bin, G4int l, G4double y1, G4double y2, G4double x)
+  {
+    G4double slope = 0, off = 0, x1=0, x2=0, x1mx2;
+    G4int half = (theNbin[l]-1)/2;
+//    x1 = (bin-half)/G4double(half);
+    x2 = (bin+1-half)/G4double(half);
+    x1mx2 = 1./G4double( (theNbin[l]-1)/2 );
+//    slope = (y2-y1)/(x2-x1);
+    slope = (y2-y1)/x1mx2;
+    off = y2-x2*slope;
+    return x*slope+off;
+  }
+  
+  G4double ** value;
+  G4double ** integral;
+  G4int theNbin[31];
+  static G4double l0[201];
+  static G4double i0[201];
+  static G4double l1[401];
+  static G4double i1[401];
+  static G4double l2[601];
+  static G4double i2[601];
+  static G4double l3[801];
+  static G4double i3[801];
+  static G4double l4[1001];
+  static G4double i4[1001];
+  static G4double l5[1201];
+  static G4double i5[1201];
+  static G4double l6[1401];
+  static G4double i6[1401];
+  static G4double l7[1601];
+  static G4double i7[1601];
+  static G4double l8[1801];
+  static G4double i8[1801];
+  static G4double l9[2001];
+  static G4double i9[2001];
+  static G4double l10[2201];
+  static G4double i10[2201];
+  static G4double l11[2401];
+  static G4double i11[2401];
+  static G4double l12[2601];
+  static G4double i12[2601];
+  static G4double l13[2801];
+  static G4double i13[2801];
+  static G4double l14[3001];
+  static G4double i14[3001];
+  static G4double l15[3201];
+  static G4double i15[3201];
+  static G4double l16[3401];
+  static G4double i16[3401];
+  static G4double l17[3601];
+  static G4double i17[3601];
+  static G4double l18[3801];
+  static G4double i18[3801];
+  static G4double l19[4001];
+  static G4double i19[4001];
+  static G4double l20[4201];
+  static G4double i20[4201];
+  static G4double l21[4401];
+  static G4double i21[4401];
+  static G4double l22[4601];
+  static G4double i22[4601];
+  static G4double l23[4801];
+  static G4double i23[4801];
+  static G4double l24[5001];
+  static G4double i24[5001];
+  static G4double l25[5201];
+  static G4double i25[5201];
+  static G4double l26[5401];
+  static G4double i26[5401];
+  static G4double l27[5601];
+  static G4double i27[5601];
+  static G4double l28[5801];
+  static G4double i28[5801];
+  static G4double l29[6001];
+  static G4double i29[6001];
+  static G4double l30[6201];
+  static G4double i30[6201];
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPField.hh

@@ -0,0 +1,72 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPField.hh,v 2.1 1998/11/07 11:21:13 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPField_h
+#define G4NeutronHPField_h 1
+
+#include "G4NeutronHPFieldPoint.hh"
+#include "G4PhysicsVector.hh"
+
+class G4NeutronHPField
+{
+  public:
+  
+  G4NeutronHPField();
+  
+  ~G4NeutronHPField();
+  
+  inline void InitY(G4int i, G4int n)
+  {
+    Check(i);
+    theData[i].InitY(n);
+  }
+  inline void SetData(G4int i, G4double x, G4int j, G4double y) 
+  { 
+    Check(i);
+    theData[i].SetData(x, j, y);
+  }
+  inline void SetEnergy(G4int i, G4double e)
+  {
+    Check(i);
+    theData[i].SetX(e);
+  }
+  inline void SetX(G4int i, G4double e)
+  {
+    Check(i);
+    theData[i].SetX(e);
+  }
+  inline void SetY(G4int i, G4int j, G4double x)
+  {
+    Check(i);
+    theData[i].SetY(j, x);
+  }
+  inline G4double GetEnergy(G4int i) { return theData[i].GetX(); }
+  inline G4double GetX(G4int i) { return theData[i].GetX(); }
+  inline G4double GetY(G4int i, G4int j) { return theData[i].GetY(j); }
+  inline G4NeutronHPFieldPoint & GetPoint(G4int i) { return theData[i]; }
+  
+  G4double GetY(G4double e, G4int j);
+
+  inline G4int GetFieldLength() {return nEntries;}
+
+  void Dump();
+
+  private:
+  
+  void Check(G4int i);
+  
+  G4NeutronHPFieldPoint * theData;
+  G4int nEntries;
+  G4int nPoints;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFieldPoint.hh

@@ -0,0 +1,53 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFieldPoint.hh,v 2.2 1998/11/07 11:21:13 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFieldPoint_h
+#define G4NeutronHPFieldPoint_h 1
+
+#include "globals.hh"
+
+class G4NeutronHPFieldPoint
+{
+  public:
+  
+  G4NeutronHPFieldPoint()
+  {
+    X = 0;
+    nP = 0;
+    Y = NULL;
+  }
+  
+  G4NeutronHPFieldPoint(G4int n);
+  
+  void operator= (const G4NeutronHPFieldPoint & aSet);
+
+  ~G4NeutronHPFieldPoint();
+    
+  void InitY(G4int n);
+
+  inline G4int GetDepth() const {return nP;}
+  inline G4double GetX() const {return X;}
+  inline G4double GetY(G4int i) const {return Y[i];}
+  
+  inline void SetX(G4double e) {X = e;}
+  inline void SetY(G4int i, G4double x) {Y[i] = x;}
+  
+  inline void SetData(G4double e, G4int i, G4double x) {X = e; Y[i] = x;}
+  
+  private:
+  
+  G4double X;
+  G4double * Y;
+  G4int nP;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFinalState.hh

@@ -0,0 +1,74 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFinalState.hh,v 2.4 1998/12/04 15:08:03 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFinalState_h
+#define G4NeutronHPFinalState_h
+
+#include "G4Material.hh"
+#include "G4FastVector.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPNames.hh"
+#include "G4NeutronHPVector.hh"
+
+class G4NeutronHPFinalState
+{
+public:
+
+  G4NeutronHPFinalState()
+  { 
+    hasFSData = true; 
+    hasXsec = true;
+    hasAnyData = true;
+    theBaseZ = 0;
+    theBaseA = 0;
+  };
+  
+  virtual ~G4NeutronHPFinalState(){};
+
+  virtual void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType) = 0;
+  virtual G4ParticleChange * ApplyYourself(const G4Track & theTrack) 
+  {
+    G4Exception("G4ParticleChange * ApplyYourself(const G4Track & theTrack) needs implementation");
+    return NULL;
+  }
+  
+  // of course this would better be Done templating G4NeutronHPChannel..., 
+  // but due to peculiarities of the DEC compiler, this way it
+  // is easier to maintain.
+  virtual G4NeutronHPFinalState * New() = 0;
+  
+  G4bool HasXsec() {return hasXsec;}
+  G4bool HasFSData() {return hasFSData;}
+  G4bool HasAnyData() {return hasAnyData;}
+  
+  virtual G4double GetXsec(G4double anEnergy) { return 0; }
+  virtual G4NeutronHPVector * GetXsec() { return NULL; }
+  
+  G4double GetZ() { return theBaseZ; }
+  G4double GetN() { return theBaseA; }
+  
+  protected:
+  
+  G4bool hasXsec;
+  G4bool hasFSData;
+  G4bool hasAnyData;
+  G4NeutronHPNames theNames;
+  
+  G4ParticleChange theResult;
+  
+  G4double theBaseA;
+  G4double theBaseZ;
+
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFission.hh

@@ -0,0 +1,49 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFission.hh,v 2.2 1998/11/07 11:21:14 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: High Precision low E neutron tracking
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Builds and has the Cross-section data for one material.
+  
+#ifndef G4NeutronHPFission_h
+#define G4NeutronHPFission_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPChannel.hh"
+#include "G4HadronicInteraction.hh"
+
+#include "G4NeutronHPFissionFS.hh"
+
+class G4NeutronHPFission : public G4HadronicInteraction
+{
+  public: 
+  
+  G4NeutronHPFission();
+
+  ~G4NeutronHPFission();
+  
+  G4VParticleChange * ApplyYourself(const G4Track& aTrack, G4Nucleus& aTargetNucleus);
+
+  private:
+  
+  G4NeutronHPFissionFS theFS;
+  
+  private:
+  
+  G4double * xSec;
+  G4NeutronHPChannel * theFission;
+  G4String dirName;
+  G4int numEle;
+  static G4String theNames[3];
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFissionBaseFS.hh

@@ -0,0 +1,75 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFissionBaseFS.hh,v 2.4 1998/12/04 15:08:03 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFissionBaseFS_h
+#define G4NeutronHPFissionBaseFS_h 1
+
+#include "globals.hh"
+#include "G4ReactionProduct.hh"
+#include "G4DynamicParticleVector.hh"
+#include "G4NeutronHPFinalState.hh"
+#include "G4NeutronHPNames.hh"
+#include "G4NeutronHPVector.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPAngular.hh"
+
+class G4NeutronHPFissionBaseFS : public G4NeutronHPFinalState
+{
+  public:
+  
+  G4NeutronHPFissionBaseFS()
+  { 
+    hasXsec = true; 
+    theXsection = new G4NeutronHPVector;
+  }
+  virtual ~G4NeutronHPFissionBaseFS()
+  {
+    delete theXsection;
+  }
+
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & bit);
+
+  G4DynamicParticleVector * ApplyYourself(G4int Prompt);
+
+  virtual G4double GetXsec(G4double anEnergy)
+  {
+    return theXsection->GetY(anEnergy);
+  }
+  virtual G4NeutronHPVector * GetXsec() { return theXsection; }
+
+  inline void SetNeutron(const G4ReactionProduct & aNeutron)
+                        { 
+                          theNeutron = aNeutron;
+                          theAngularDistribution.SetNeutron(aNeutron);
+                        }
+  
+  inline void SetTarget(const G4ReactionProduct & aTarget)
+                        { 
+                          theTarget = aTarget; 
+                          theAngularDistribution.SetTarget(aTarget);
+                        }
+  
+  private:
+  
+  G4ParticleChange * ApplyYourself(const G4Track & aTrack) {return NULL;}
+  
+  G4NeutronHPVector * theXsection;
+  G4NeutronHPEnergyDistribution theEnergyDistribution;
+  G4NeutronHPAngular theAngularDistribution;
+  
+  G4ReactionProduct theNeutron;
+  G4ReactionProduct theTarget;
+
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFissionData.hh

@@ -0,0 +1,43 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFissionData.hh,v 2.1 1998/11/07 11:21:15 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFissionData_h
+#define G4NeutronHPFissionData_h 1
+
+#include "G4VCrossSectionDataSet.hh"
+#include "G4DynamicParticle.hh"
+#include "G4Element.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4PhysicsTable.hh"
+
+class G4NeutronHPFissionData : public G4VCrossSectionDataSet
+{
+   public:
+   
+   G4NeutronHPFissionData();
+   
+   ~G4NeutronHPFissionData();
+   
+   G4bool IsApplicable(const G4DynamicParticle*, const G4Element*);
+
+   G4double GetCrossSection(const G4DynamicParticle*, const G4Element*);
+
+   void BuildPhysicsTable(const G4ParticleDefinition&);
+
+   void DumpPhysicsTable(const G4ParticleDefinition&);
+   
+   private:
+   
+   G4PhysicsTable * theCrossSections;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFissionERelease.hh

@@ -0,0 +1,115 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFissionERelease.hh,v 2.2 1998/11/07 11:21:15 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFissionERelease_h
+#define G4NeutronHPFissionERelease_h 1
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+
+class G4NeutronHPFissionERelease
+{
+  public:
+  G4NeutronHPFissionERelease(){}
+  ~G4NeutronHPFissionERelease(){}
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    G4double dummy;
+    
+    aDataFile >>dummy
+              >>fragmentKinetic
+              >>promptNeutronKinetic
+              >>delayedNeutronKinetic
+              >>promptGammaEnergy
+              >>delayedGammaEnergy
+              >>delayedBetaEnergy
+              >>neutrinoEnergy
+              >>reducedTotalEnergy
+              >>totalEnergy;
+            
+    fragmentKinetic*=eV;
+    promptNeutronKinetic*=eV;
+    delayedNeutronKinetic*=eV;
+    promptGammaEnergy*=eV;
+    delayedGammaEnergy*=eV;
+    delayedBetaEnergy*=eV;
+    neutrinoEnergy*=eV;
+    reducedTotalEnergy*=eV;
+    totalEnergy*=eV;
+  }
+  
+  inline G4double GetTotalEnergy(G4double deltaNNeu, G4double anEnergy) 
+  {
+     G4double result, delta, energy;
+     energy = anEnergy/eV;
+     delta = -(1.057*energy - 8.07*deltaNNeu);
+     result = totalEnergy - delta*eV;
+     return result;
+  }
+  inline G4double GetFragmentKinetic() 
+  {
+     return fragmentKinetic;
+  }
+  inline G4double GetPromptNeutronKinetic(G4double deltaNNeu, G4double anEnergy)
+  {
+     G4double result, delta, energy;
+     energy = anEnergy/eV;
+     delta = -(1.307*energy - 8.07*deltaNNeu);
+     result = totalEnergy - delta*eV;
+     return result;
+  }
+  inline G4double GetDelayedNeutronKinetic()
+  {
+    return delayedNeutronKinetic;
+  }
+  inline G4double GetPromptGammaEnergy()
+  {
+    return promptGammaEnergy;
+  }
+  inline G4double GetDelayedGammaEnergy(G4double anEnergy)
+  {
+    G4double delta = 0.075*anEnergy;
+    G4double result = delayedGammaEnergy-delta;
+    return result;
+  }
+  inline G4double GetDelayedBetaEnergy(G4double anEnergy)
+  {
+    G4double delta = 0.075*anEnergy;
+    G4double result = delayedBetaEnergy-delta;
+    return result;
+  }
+  inline G4double GetNeutrinoEnergy(G4double anEnergy)
+  {
+    G4double delta = 0.1*anEnergy;
+    G4double result = neutrinoEnergy-delta;
+    return result;
+  }
+  inline G4double GetReducedTotal(G4double deltaNNeu, G4double anEnergy)
+  {
+    return GetTotalEnergy(deltaNNeu, anEnergy) - GetNeutrinoEnergy(anEnergy);
+  }
+  private:
+  
+  G4double totalEnergy;
+  G4double fragmentKinetic;
+  G4double promptNeutronKinetic;
+  G4double delayedNeutronKinetic;
+  G4double promptGammaEnergy;
+  G4double delayedGammaEnergy;
+  G4double delayedBetaEnergy;
+  G4double neutrinoEnergy;
+  G4double reducedTotalEnergy;  // total - neutrino
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFissionFS.hh

@@ -0,0 +1,51 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFissionFS.hh,v 2.2 1998/12/04 15:08:03 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFissionFS_h
+#define G4NeutronHPFissionFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPFinalState.hh"
+#include "G4NeutronHPNames.hh"
+
+#include "G4NeutronHPFCFissionFS.hh"
+#include "G4NeutronHPSCFissionFS.hh"
+#include "G4NeutronHPTCFissionFS.hh"
+#include "G4NeutronHPLCFissionFS.hh"
+#include "G4NeutronHPFSFissionFS.hh"
+
+class G4NeutronHPFissionFS : public G4NeutronHPFinalState
+{
+  public:
+  
+  G4NeutronHPFissionFS(){ hasXsec = false; }
+  ~G4NeutronHPFissionFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPFissionFS * theNew = new G4NeutronHPFissionFS;
+   return theNew;
+  }
+        
+  private:
+  
+  G4NeutronHPFSFissionFS theFS;
+  G4NeutronHPFCFissionFS theFC;
+  G4NeutronHPSCFissionFS theSC;
+  G4NeutronHPTCFissionFS theTC;
+  G4NeutronHPLCFissionFS theLC;
+    
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPFissionSpectrum.hh

@@ -0,0 +1,85 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPFissionSpectrum.hh,v 2.4 1998/11/07 11:21:16 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPFissionSpectrum_h
+#define G4NeutronHPFissionSpectrum_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4VNeutronHPEDis.hh"
+
+// we will need a List of these .... one per term.
+
+class G4NeutronHPFissionSpectrum : public G4VNeutronHPEDis
+{
+  public:
+  G4NeutronHPFissionSpectrum()
+  {
+    expm1 = exp(-1.);
+  }
+  ~G4NeutronHPFissionSpectrum()
+  {
+  }
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    theFractionalProb.Init(aDataFile, eV);
+    theThetaDist.Init(aDataFile, eV);
+  }
+  
+  inline G4double GetFractionalProbability(G4double anEnergy)
+  {
+    return theFractionalProb.GetY(anEnergy);
+  }
+  
+  inline G4double Sample(G4double anEnergy) 
+  {
+    G4double theta = theThetaDist.GetY(anEnergy);
+    // here we need to sample Maxwells distribution, if 
+    // need be.
+    G4double result, cut;
+    G4double range =50*MeV;
+    G4double max = Maxwell((theta*eV)/2., theta);
+    G4double value;
+    do
+    {
+      result = range*G4UniformRand();
+      value = Maxwell(result, theta);
+      cut = G4UniformRand();
+    }
+    while(cut > value/max);
+    return result;
+  }
+  
+  private:
+ 
+  // this is the function to sample from. 
+  inline G4double Maxwell(G4double anEnergy, G4double theta)
+  {
+    G4double result = sqrt(anEnergy/eV)*exp(-anEnergy/eV/theta);
+    return result;
+  }
+  
+  private:
+  
+  G4double expm1;
+  
+  G4NeutronHPVector theFractionalProb;
+  
+  G4NeutronHPVector theThetaDist;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPGamma.hh

@@ -0,0 +1,83 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPGamma.hh,v 2.2 1998/11/07 11:21:17 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPGamma_h
+#define G4NeutronHPGamma_h 1
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4DynamicParticleVector.hh"
+#include "G4DynamicParticle.hh"
+#include "G4Gamma.hh"
+#include "G4NeutronHPLevel.hh"
+
+class G4NeutronHPGamma
+{
+  public:
+  
+  G4NeutronHPGamma() 
+  {
+    next = NULL;
+  }
+  ~G4NeutronHPGamma() {}
+  
+  G4bool Init(ifstream & aDataFile);
+  
+  inline void SetNext(G4NeutronHPLevel * aLevel)
+  {
+    next = aLevel;
+  }
+  
+  G4DynamicParticleVector * GetDecayGammas()
+  {
+    G4DynamicParticleVector * theResult;
+    if(next == NULL)
+    {
+      theResult = new G4DynamicParticleVector;
+    }
+    else
+    {
+      theResult = next->GetDecayGammas();
+    }
+    G4DynamicParticle * theNew = new G4DynamicParticle;
+    theNew->SetDefinition(G4Gamma::Gamma());
+    theNew->SetKineticEnergy(gammaEnergy);
+    theResult->insert(theNew);
+    return theResult;
+  }
+  
+  inline G4double GetLevelEnergy()
+  {
+    return levelEnergy;
+  }
+
+  inline G4double GetGammaEnergy()
+  {
+    return gammaEnergy;
+  }
+  
+  inline G4double GetWeight()
+  {
+    return probability;
+  }
+
+  private:
+  
+  G4double levelEnergy;
+  G4double gammaEnergy;
+  G4double probability;
+  
+  G4NeutronHPLevel * next;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPHe3InelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPHe3InelasticFS.hh,v 2.2 1998/12/04 15:08:03 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPHe3InelasticFS_h
+#define G4NeutronHPHe3InelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticCompFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPHe3InelasticFS : public G4NeutronHPInelasticCompFS
+{
+  public:
+  
+  G4NeutronHPHe3InelasticFS(){}
+  ~G4NeutronHPHe3InelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPHe3InelasticFS * theNew = new G4NeutronHPHe3InelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPInelastic.hh

@@ -0,0 +1,119 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPInelastic.hh,v 2.3 1998/11/07 11:21:17 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: High Precision low E neutron tracking
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Builds and has the Cross-section data for one material.
+ 
+#ifndef G4NeutronHPInelastic_h
+#define G4NeutronHPInelastic_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPChannel.hh"
+#include "G4HadronicInteraction.hh"
+#include "G4NeutronHPChannelList.hh"
+
+#include "G4NeutronHP2AInelasticFS.hh"
+#include "G4NeutronHP2N2AInelasticFS.hh"
+#include "G4NeutronHP2NAInelasticFS.hh"
+#include "G4NeutronHP2NDInelasticFS.hh"
+#include "G4NeutronHP2NInelasticFS.hh"
+#include "G4NeutronHP2NPInelasticFS.hh"
+#include "G4NeutronHP2PInelasticFS.hh"
+#include "G4NeutronHP3AInelasticFS.hh"
+#include "G4NeutronHP3NAInelasticFS.hh"
+#include "G4NeutronHP3NInelasticFS.hh"
+#include "G4NeutronHP3NPInelasticFS.hh"
+#include "G4NeutronHP4NInelasticFS.hh"
+#include "G4NeutronHPAInelasticFS.hh"
+#include "G4NeutronHPD2AInelasticFS.hh"
+#include "G4NeutronHPDAInelasticFS.hh"
+#include "G4NeutronHPDInelasticFS.hh"
+#include "G4NeutronHPHe3InelasticFS.hh"
+#include "G4NeutronHPN2AInelasticFS.hh"
+#include "G4NeutronHPN2PInelasticFS.hh"
+#include "G4NeutronHPN3AInelasticFS.hh"
+#include "G4NeutronHPNAInelasticFS.hh"
+#include "G4NeutronHPND2AInelasticFS.hh"
+#include "G4NeutronHPNDInelasticFS.hh"
+#include "G4NeutronHPNHe3InelasticFS.hh"
+#include "G4NeutronHPNInelasticFS.hh"
+#include "G4NeutronHPNPAInelasticFS.hh"
+#include "G4NeutronHPNPInelasticFS.hh"
+#include "G4NeutronHPNT2AInelasticFS.hh"
+#include "G4NeutronHPNTInelasticFS.hh"
+#include "G4NeutronHPNXInelasticFS.hh"
+#include "G4NeutronHPPAInelasticFS.hh"
+#include "G4NeutronHPPDInelasticFS.hh"
+#include "G4NeutronHPPInelasticFS.hh"
+#include "G4NeutronHPPTInelasticFS.hh"
+#include "G4NeutronHPT2AInelasticFS.hh"
+#include "G4NeutronHPTInelasticFS.hh"
+
+class G4NeutronHPInelastic : public G4HadronicInteraction
+{
+  public: 
+  
+  G4NeutronHPInelastic();
+
+  ~G4NeutronHPInelastic();
+  
+  G4VParticleChange * ApplyYourself(const G4Track & aTrack, G4Nucleus & aTargetNucleus);
+
+  private:
+  
+  G4double * xSec;
+  G4NeutronHPChannelList * theInelastic; // one List per element
+  G4String dirName;
+  G4int numEle;
+  
+  private:
+  
+   G4NeutronHP2AInelasticFS the2AFS;
+   G4NeutronHP2N2AInelasticFS the2N2AFS;
+   G4NeutronHP2NAInelasticFS the2NAFS;
+   G4NeutronHP2NDInelasticFS the2NDFS;
+   G4NeutronHP2NInelasticFS the2NFS;
+   G4NeutronHP2NPInelasticFS the2NPFS;
+   G4NeutronHP2PInelasticFS the2PFS;
+   G4NeutronHP3AInelasticFS the3AFS;
+   G4NeutronHP3NAInelasticFS the3NAFS;
+   G4NeutronHP3NInelasticFS the3NFS;
+   G4NeutronHP3NPInelasticFS the3NPFS;
+   G4NeutronHP4NInelasticFS the4NFS;
+   G4NeutronHPAInelasticFS theAFS;
+   G4NeutronHPD2AInelasticFS theD2AFS;
+   G4NeutronHPDAInelasticFS theDAFS;
+   G4NeutronHPDInelasticFS theDFS;
+   G4NeutronHPHe3InelasticFS theHe3FS;
+   G4NeutronHPN2AInelasticFS theN2AFS;
+   G4NeutronHPN2PInelasticFS theN2PFS;
+   G4NeutronHPN3AInelasticFS theN3AFS;
+   G4NeutronHPNAInelasticFS theNAFS;
+   G4NeutronHPND2AInelasticFS theND2AFS;
+   G4NeutronHPNDInelasticFS theNDFS;
+   G4NeutronHPNHe3InelasticFS theNHe3FS;
+   G4NeutronHPNInelasticFS theNFS;
+   G4NeutronHPNPAInelasticFS theNPAFS;
+   G4NeutronHPNPInelasticFS theNPFS;
+   G4NeutronHPNT2AInelasticFS theNT2AFS;
+   G4NeutronHPNTInelasticFS theNTFS;
+   G4NeutronHPNXInelasticFS theNXFS;
+   G4NeutronHPPAInelasticFS thePAFS;
+   G4NeutronHPPDInelasticFS thePDFS;
+   G4NeutronHPPInelasticFS thePFS;
+   G4NeutronHPPTInelasticFS thePTFS;
+   G4NeutronHPT2AInelasticFS theT2AFS;
+   G4NeutronHPTInelasticFS theTFS;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPInelasticBaseFS.hh

@@ -0,0 +1,74 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPInelasticBaseFS.hh,v 2.3 1998/12/04 15:08:04 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPInelasticBaseFS_h
+#define G4NeutronHPInelasticBaseFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPFinalState.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+#include "G4NeutronHPDeExGammas.hh"
+
+class G4NeutronHPInelasticBaseFS : public G4NeutronHPFinalState
+{
+  public:
+    
+  G4NeutronHPInelasticBaseFS()
+  {
+    hasXsec = true; 
+    theXsection = new G4NeutronHPVector;
+    
+    theEnergyDistribution = NULL;
+    theFinalStatePhotons = NULL;
+    theEnergyAngData = NULL;
+    theAngularDistribution = NULL;
+  }
+  virtual ~G4NeutronHPInelasticBaseFS()
+  {
+    delete theXsection;
+    if(theEnergyDistribution!=NULL) delete theEnergyDistribution;
+    if(theFinalStatePhotons!=NULL) delete theFinalStatePhotons;
+    if(theEnergyAngData!=NULL) delete theEnergyAngData;
+    if(theAngularDistribution!=NULL) delete theAngularDistribution;
+  }
+  
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & bit);
+  void BaseApply(const G4Track & theTrack, G4ParticleDefinition ** theDefs, G4int nDef);
+  void InitGammas(G4double AR, G4double ZR);
+  virtual G4ParticleChange * ApplyYourself(const G4Track & theTrack) = 0;
+  virtual G4NeutronHPFinalState * New() = 0;
+  
+  virtual G4double GetXsec(G4double anEnergy)
+  {
+    return theXsection->GetY(anEnergy);
+  }
+  virtual G4NeutronHPVector * GetXsec() { return theXsection; }
+
+  protected:
+  
+  G4NeutronHPVector * theXsection;
+  G4NeutronHPEnergyDistribution * theEnergyDistribution;
+  G4NeutronHPAngular * theAngularDistribution;
+  G4NeutronHPEnAngCorrelation * theEnergyAngData;
+  
+  G4NeutronHPPhotonDist * theFinalStatePhotons;
+  G4double theNuclearMassDifference;
+  G4NeutronHPDeExGammas theGammas;
+  G4String gammaPath;
+
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPInelasticCompFS.hh

@@ -0,0 +1,92 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPInelasticCompFS.hh,v 2.3 1998/12/04 15:08:04 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPInelasticCompFS_h
+#define G4NeutronHPInelasticCompFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPFinalState.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+#include "G4NeutronHPDeExGammas.hh"
+
+class G4NeutronHPInelasticCompFS : public G4NeutronHPFinalState
+{
+  public:
+  
+  G4NeutronHPInelasticCompFS()
+  {
+    for(G4int i=0; i<51; i++)
+    {
+      hasXsec = true; 
+      theXsection[i] = NULL;
+      theEnergyDistribution[i] = NULL;
+      theAngularDistribution[i] = NULL;
+      theEnergyAngData[i] = NULL;
+      theFinalStatePhotons[i] = NULL;
+    }
+  }
+  virtual ~G4NeutronHPInelasticCompFS()
+  {
+    for(G4int i=0; i<51; i++)
+    {
+      if(theXsection[i] != NULL) delete theXsection[i];
+      if(theEnergyDistribution[i] != NULL) delete theEnergyDistribution[i];
+      if(theAngularDistribution[i] != NULL) delete theAngularDistribution[i];
+      if(theEnergyAngData[i] != NULL) delete theEnergyAngData[i];
+      if(theFinalStatePhotons[i] != NULL) delete theFinalStatePhotons[i];
+    }
+  }
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aSFType);
+  void InitGammas(G4double AR, G4double ZR);
+  virtual G4ParticleChange * ApplyYourself(const G4Track & theTrack) = 0;
+  virtual G4NeutronHPFinalState * New() = 0;
+  virtual G4double GetXsec(G4double anEnergy)
+  {
+    return theXsection[50]->GetY(anEnergy);
+  }
+  virtual G4NeutronHPVector * GetXsec() { return theXsection[50]; }
+  G4int SelectExitChannel(G4double eKinetic);
+  void CompositeApply(const G4Track & theTrack, G4ParticleDefinition * aHadron);
+  inline void InitDistributionInitialState(G4ReactionProduct & aNeutron, 
+                                           G4ReactionProduct & aTarget, 
+                                           G4int it)
+  {
+    if(theAngularDistribution[it]!=NULL) 
+    {
+      theAngularDistribution[it]->SetTarget(aTarget);
+      theAngularDistribution[it]->SetNeutron(aNeutron);
+    }
+    if(theEnergyAngData[it]!=NULL)
+    {
+      theEnergyAngData[it]->SetTarget(aTarget);
+      theEnergyAngData[it]->SetNeutron(aNeutron);
+    }
+  }
+  
+  protected:
+  
+  G4NeutronHPVector * theXsection[51];
+  G4NeutronHPEnergyDistribution * theEnergyDistribution[51];
+  G4NeutronHPAngular * theAngularDistribution[51];
+  G4NeutronHPEnAngCorrelation * theEnergyAngData[51];
+  
+  G4NeutronHPPhotonDist * theFinalStatePhotons[51];
+  
+  G4NeutronHPDeExGammas theGammas;
+  G4String gammaPath;
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPInelasticData.hh

@@ -0,0 +1,43 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPInelasticData.hh,v 2.1 1998/11/07 11:21:19 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPInelasticData_h
+#define G4NeutronHPInelasticData_h 1
+
+#include "G4VCrossSectionDataSet.hh"
+#include "G4DynamicParticle.hh"
+#include "G4Element.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4PhysicsTable.hh"
+
+class G4NeutronHPInelasticData : public G4VCrossSectionDataSet
+{
+   public:
+   
+   G4NeutronHPInelasticData();
+   
+   ~G4NeutronHPInelasticData();
+   
+   G4bool IsApplicable(const G4DynamicParticle*, const G4Element*);
+
+   G4double GetCrossSection(const G4DynamicParticle*, const G4Element*);
+
+   void BuildPhysicsTable(const G4ParticleDefinition&);
+
+   void DumpPhysicsTable(const G4ParticleDefinition&);
+   
+   private:
+   
+   G4PhysicsTable * theCrossSections;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPInterpolator.hh

@@ -0,0 +1,151 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPInterpolator.hh,v 2.5 1998/11/07 11:21:19 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPInterpolator_h
+#define G4NeutronHPInterpolator_h 1
+
+#include "globals.hh"
+#include "G4InterpolationScheme.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+
+
+class G4NeutronHPInterpolator
+{
+  public:
+  
+  G4NeutronHPInterpolator(){}
+  ~G4NeutronHPInterpolator()
+   {
+    //  G4cout <<"deleted the interpolator"<<endl;
+   }
+  
+  inline G4double Lin(G4double x,G4double x1,G4double x2,G4double y1,G4double y2)
+  {
+    G4double slope=0, off=0;
+    slope = (y2-y1)/(x2-x1);
+    off = y2-x2*slope;
+    G4double y = x*slope+off;
+    return y;
+  }
+  
+  inline G4double Interpolate(G4InterpolationScheme aScheme,
+                              G4double x, G4double x1, G4double x2,
+                                          G4double y1, G4double y2);       
+  
+  G4double 
+  GetBinIntegral(const G4InterpolationScheme & aScheme, 
+                const G4double x1,const G4double x2,const G4double y1,const G4double y2);
+
+  G4double 
+  GetWeightedBinIntegral(const G4InterpolationScheme & aScheme, 
+                const G4double x1,const G4double x2,const G4double y1,const G4double y2);
+
+  private:
+  
+  inline G4double Histogram(G4double x, G4double x1, G4double x2, G4double y1, G4double y2);
+  inline G4double LinearLinear(G4double x, G4double x1, G4double x2, G4double y1, G4double y2);
+  inline G4double LinearLogarithmic(G4double x, G4double x1, G4double x2, G4double y1, G4double y2);
+  inline G4double LogarithmicLinear(G4double x, G4double x1, G4double x2, G4double y1, G4double y2);
+  inline G4double LogarithmicLogarithmic(G4double x, G4double x1, G4double x2, G4double y1, G4double y2);
+  inline G4double Random(G4double x, G4double x1, G4double x2, G4double y1, G4double y2);
+
+};
+
+inline G4double G4NeutronHPInterpolator::
+Interpolate(G4InterpolationScheme aScheme,
+            G4double x, G4double x1, G4double x2, G4double y1, G4double y2)
+{
+  G4double result;
+  G4int theScheme = aScheme;
+  theScheme = theScheme%CSTART;
+  switch(theScheme)
+  {
+    case 1:
+      result = Histogram(x, x1, x2, y1, y2);
+      break;
+    case 2:
+      result = LinearLinear(x, x1, x2, y1, y2);
+      break;
+    case 3:
+      result = LinearLogarithmic(x, x1, x2, y1, y2);
+      break;
+    case 4:
+      result = LogarithmicLinear(x, x1, x2, y1, y2);
+      break;
+    case 5:
+      result = LogarithmicLogarithmic(x, x1, x2, y1, y2);
+      break;
+    case 6:
+      result = Random(x, x1, x2, y1, y2);
+      break;
+    default:
+      G4cout << "theScheme = "<<theScheme<<endl;
+      G4Exception("G4NeutronHPInterpolator::Carthesian Invalid InterpolationScheme");
+      break;
+  }
+  return result;
+}
+
+inline G4double G4NeutronHPInterpolator::
+Histogram(G4double x, G4double x1, G4double x2, G4double y1, G4double y2)
+{
+  G4double result;
+  result = y1;
+  return result;
+}
+
+inline G4double G4NeutronHPInterpolator::
+LinearLinear(G4double x, G4double x1, G4double x2, G4double y1, G4double y2)
+{
+  G4double slope=0, off=0;
+  slope = (y2-y1)/(x2-x1);
+  off = y2-x2*slope;
+  G4double y = x*slope+off;
+  return y;
+}
+
+inline G4double G4NeutronHPInterpolator::
+LinearLogarithmic(G4double x, G4double x1, G4double x2, G4double y1, G4double y2)
+{
+  G4double result;
+  result = LinearLinear(log(x), log(x1), log(x2), y1, y2);
+  return result;
+}
+  
+inline G4double G4NeutronHPInterpolator::
+LogarithmicLinear(G4double x, G4double x1, G4double x2, G4double y1, G4double y2)
+{
+  G4double result;
+  result = LinearLinear(x, x1, x2, log(y1), log(y2));
+  result = exp(result);
+  return result;
+}
+  
+inline G4double G4NeutronHPInterpolator::
+LogarithmicLogarithmic(G4double x, G4double x1, G4double x2, G4double y1, G4double y2)
+{
+  G4double result;
+  result = LinearLinear(log(x), log(x1), log(x2), log(y1), log(y2));
+  result = exp(result);
+  return result;
+}
+
+inline G4double G4NeutronHPInterpolator::
+Random(G4double x, G4double x1, G4double x2, G4double y1, G4double y2)
+{
+  G4double result;
+  result = y1+G4UniformRand()*(y2-y1);
+  return result;
+}
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPIsoData.hh

@@ -0,0 +1,83 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPIsoData.hh,v 2.4 1998/12/04 15:08:04 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPIsoData_h
+#define G4NeutronHPIsoData_h 1
+
+ // Hadronic Process: Very Low Energy Neutron X-Sections
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ // Has the Cross-section data for on isotope.
+ 
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#ifdef WIN32
+  #include <strstrea.h>
+#else
+  #include <strstream.h>
+#endif
+#include <stdlib.h>
+#include "G4NeutronHPVector.hh"
+#include "G4NeutronHPNames.hh"
+
+class G4NeutronHPIsoData
+{
+public:
+
+  G4NeutronHPIsoData(){theChannelData = NULL;}
+  
+  ~G4NeutronHPIsoData(){if(theChannelData!=NULL) delete theChannelData;}
+  
+  inline G4double GetXsec(G4double energy)
+  {
+    return theChannelData->GetXsec(energy);
+  }
+  G4bool Init(G4int A, G4int Z, G4double abun, G4String dirName, G4String aFSType);
+  
+  void Init(G4int A, G4int Z, G4double abun); //fill PhysicsVector for this Isotope
+  
+  inline G4NeutronHPVector * MakeElasticData()
+    {return theElasticData;}
+  inline G4NeutronHPVector * MakeFissionData()
+    {return theFissionData;}
+  inline G4NeutronHPVector * MakeCaptureData()
+    {return theCaptureData;}
+  inline G4NeutronHPVector * MakeInelasticData()
+    {return theInelasticData;}
+  inline G4NeutronHPVector * MakeChannelData()
+    {return theChannelData;}
+
+  G4String GetName(G4int A, G4int Z, G4String base, G4String rest);
+  
+  inline void FillChannelData(G4NeutronHPVector * aBuffer)
+  {
+    if(theChannelData!=NULL) G4Exception("IsoData has channel full already!!!");
+    theChannelData = new G4NeutronHPVector;
+    for(G4int i=0; i<aBuffer->GetVectorLength(); i++)
+    {
+      theChannelData->SetPoint(i, aBuffer->GetPoint(i));
+    }
+  }
+  
+private:
+
+  G4NeutronHPVector * theFissionData;
+  G4NeutronHPVector * theCaptureData;
+  G4NeutronHPVector * theElasticData;
+  G4NeutronHPVector * theInelasticData;
+  G4NeutronHPVector * theChannelData;
+
+  G4String theFileName;
+  G4NeutronHPNames theNames;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPIsotropic.hh

@@ -0,0 +1,41 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPIsotropic.hh,v 2.2 1998/11/07 11:21:20 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPIsotropic_h
+#define G4NeutronHPIsotropic_h 1
+
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4ReactionProduct.hh"
+#include "G4VNeutronHPEnergyAngular.hh"
+
+class G4NeutronHPIsotropic : public G4VNeutronHPEnergyAngular
+{
+  public:
+  
+  G4NeutronHPIsotropic(){}
+  
+  ~G4NeutronHPIsotropic(){}
+  
+  public:
+  
+  void Init(ifstream & aDataFile);
+  G4ReactionProduct * Sample(G4double anEnergy, G4double massCode, G4double mass);
+  G4double MeanEnergyOfThisInteraction()
+  {
+    return -1.;
+  }
+  private:
+
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPKallbachMannSyst.hh

@@ -0,0 +1,68 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPKallbachMannSyst.hh,v 2.1 1998/11/07 11:21:20 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPKallbachMannSyst_h
+#define G4NeutronHPKallbachMannSyst_h 1
+
+#include "globals.hh"
+
+class G4NeutronHPKallbachMannSyst
+{
+  public:
+  
+   G4NeutronHPKallbachMannSyst(G4double aCompoundFraction,
+                               G4double anIncidentEnergy, G4double anIncidentMass,
+                               G4double aProductEnergy, G4double aProductMass,
+                               G4double aResidualMass, G4int aResidualA, G4int aResidualZ,
+                               G4double aTargetMass, G4int aTargetA, G4int aTargetZ)
+  {
+    theCompoundFraction = aCompoundFraction;
+    theIncidentEnergy = anIncidentEnergy;
+    theIncidentMass = anIncidentMass;
+    theProductEnergy = aProductEnergy;
+    theProductMass = aProductMass;
+    theResidualMass = aResidualMass;
+    theResidualA = aResidualA;
+    theResidualZ = aResidualZ;
+    theTargetMass = aTargetMass;
+    theTargetA = aTargetA;
+    theTargetZ = aTargetZ;
+  }
+  
+  ~G4NeutronHPKallbachMannSyst() {};
+  
+  G4double Sample(G4double anEnergy);
+  
+  G4double Kallbach(G4double cosTh, G4double anEnergy);
+  
+  G4double GetKallbachZero(G4double anEnergy);
+  
+  G4double A(G4double anEnergy);
+  
+  G4double SeparationEnergy(G4int Ac, G4int Nc, G4int AA, G4int ZA);
+  
+  private:
+  
+  G4double theCompoundFraction;
+  G4double theIncidentEnergy;
+  G4double theIncidentMass;
+  G4double theProductEnergy;
+  G4double theProductMass;
+  G4double theResidualMass;
+  G4double theTargetMass;
+  G4int theResidualA;
+  G4int theResidualZ;
+  G4int theTargetA;
+  G4int theTargetZ;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPLCFissionFS.hh

@@ -0,0 +1,39 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPLCFissionFS.hh,v 2.4 1998/12/04 15:08:04 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPLCFissionFS_h
+#define G4NeutronHPLCFissionFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4DynamicParticleVector.hh"
+#include "G4NeutronHPFissionBaseFS.hh"
+
+class G4NeutronHPLCFissionFS : public G4NeutronHPFissionBaseFS
+{
+  public:
+  
+  G4NeutronHPLCFissionFS(){ hasXsec = false; }
+  ~G4NeutronHPLCFissionFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4DynamicParticleVector * ApplyYourself(G4int NNeutrons);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPLCFissionFS * theNew = new G4NeutronHPLCFissionFS;
+   return theNew;
+  }
+  
+  private:
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack) { return NULL; }
+    
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPLabAngularEnergy.hh

@@ -0,0 +1,81 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPLabAngularEnergy.hh,v 2.3 1998/11/26 12:39:21 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPLabAngularEnergy_h
+#define G4NeutronHPLabAngularEnergy_h 1
+
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4Neutron.hh"
+#include "G4NeutronHPInterpolator.hh"
+#include "G4NeutronHPVector.hh"
+#include "G4VNeutronHPEnergyAngular.hh"
+#include "G4ReactionProduct.hh"
+#include "G4InterpolationManager.hh"
+
+class G4NeutronHPLabAngularEnergy : public G4VNeutronHPEnergyAngular
+{
+  public:
+  
+  G4NeutronHPLabAngularEnergy()
+  {
+    theEnergies = NULL;
+    theData = NULL;
+    nCosTh = NULL;
+    theSecondManager = NULL;
+  }
+  ~G4NeutronHPLabAngularEnergy()
+  {
+    if(theEnergies != NULL) delete [] theEnergies;
+    if(nCosTh != NULL) delete [] nCosTh;
+    if(theData != NULL) 
+    {
+      for(G4int i=0; i<nEnergies; i++)
+        delete [] theData[i];
+      delete [] theData;
+    }
+    if(theSecondManager != NULL) delete [] theSecondManager;
+  }
+  
+  public:
+  
+  void Init(ifstream & aDataFile);
+     G4ReactionProduct * Sample(G4double anEnergy, G4double massCode, G4double mass);
+  G4double MeanEnergyOfThisInteraction()
+  {
+    return currentMeanEnergy;
+  }
+  
+  
+  private:
+  
+  // number of incoming neutron energies
+  G4int nEnergies;
+  // Interpol between neutron energies
+  G4InterpolationManager theManager; 
+  // Incoming neutron energies
+  G4double * theEnergies; 
+  // number of directioncosines; parallel to theEnergies
+  G4int * nCosTh; 
+  // knows the interpolation between these stores
+  G4InterpolationManager * theSecondManager; 
+  // vectors of secondary energy, haufigkeit; parallel to theEnergies
+  G4NeutronHPVector ** theData; 
+
+  // utility interpolator
+  G4NeutronHPInterpolator theInt;
+  
+  // cashed value of mean secondary energy in this event.
+  G4double currentMeanEnergy;
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPLegendreStore.hh

@@ -0,0 +1,78 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPLegendreStore.hh,v 2.4 1998/11/07 11:21:21 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPLegendreStore_h
+#define G4NeutronHPLegendreStore_h 1
+
+#include "G4NeutronHPLegendreTable.hh"
+#include "G4InterpolationManager.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+
+class G4NeutronHPLegendreStore
+{
+  public:
+  
+  G4NeutronHPLegendreStore(G4int n)
+  {
+    theCoeff = new G4NeutronHPLegendreTable[n];
+    nEnergy = n;
+  }
+  
+  ~G4NeutronHPLegendreStore()
+  {
+    delete [] theCoeff;
+  }
+  
+  inline void Init(G4int i, G4double e, G4int n)
+  {
+    theCoeff[i].Init(e, n);
+  }
+  inline void SetNPoints(G4int n) { nEnergy = n; }
+  inline void SetEnergy(G4int i, G4double energy) { theCoeff[i].SetEnergy(energy); }
+  inline void SetTemperature(G4int i, G4double temp) { theCoeff[i].SetTemperature(temp); }
+  inline void SetCoeff(G4int i, G4int l, G4double coeff) {theCoeff[i].SetCoeff(l, coeff); }
+  inline void SetCoeff(G4int i, G4NeutronHPLegendreTable * theTable)
+  {
+    if(i>nEnergy) G4Exception("LegendreTableIndex out of range");
+    theCoeff[i] = *theTable;
+// not here -- see G4NeutronHPPhotonDist.cc line 275
+//    delete theTable;
+  }
+  
+  inline G4double GetCoeff(G4int i, G4int l) {return theCoeff[i].GetCoeff(l);}
+  inline G4double GetEnergy(G4int i){return theCoeff[i].GetEnergy();}
+  inline G4double GetTemperature(G4int i){return theCoeff[i].GetTemperature();}
+  inline G4int GetNumberOfPoly(G4int i) {return theCoeff[i].GetNumberOfPoly();}
+  
+  G4double SampleElastic (G4double anEnergy);
+  G4double Sample (G4double energy);
+  G4double SampleMax (G4double energy);
+  G4double Integrate(G4int k, G4double costh);
+  
+  void InitInterpolation(ifstream & aDataFile)
+  {
+    theManager.Init(aDataFile);
+  }
+  
+  void SetManager(G4InterpolationManager & aManager)
+  {
+    theManager = aManager;
+  }
+
+  private:
+  
+  G4int nEnergy;
+  G4NeutronHPLegendreTable * theCoeff;
+  G4InterpolationManager theManager; // interpolate between different Tables
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPLegendreTable.hh

@@ -0,0 +1,92 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPLegendreTable.hh,v 2.5 1998/11/07 11:21:22 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPLegendreTable_h
+#define G4NeutronHPLegendreTable_h 1
+
+#include "globals.hh"
+#include <fstream.h>
+#include "G4ios.hh"
+#include "G4InterpolationManager.hh"
+
+class G4NeutronHPLegendreTable
+{
+  public:
+  G4NeutronHPLegendreTable()
+  {
+    nCoeff=0; 
+    theCoeff = NULL;
+  }
+  ~G4NeutronHPLegendreTable(){if(theCoeff!=NULL) delete [] theCoeff;}
+  
+  void operator= (const G4NeutronHPLegendreTable & aSet)
+  {
+    if(&aSet!=this)
+    {
+      theRep = aSet.theRep;
+      theEnergy = aSet.theEnergy;
+      theTemp = aSet.theTemp;
+      theManager = aSet.theManager;
+      nCoeff = aSet.nCoeff;
+      if(theCoeff!=NULL) delete [] theCoeff;
+      theCoeff = new G4double[nCoeff];
+      for(G4int i=0; i<nCoeff; i++)
+      {
+        theCoeff[i] = aSet.theCoeff[i];
+      }
+    }
+  }
+  
+  inline void Init(ifstream & aDataFile) 
+  {
+    G4double eNeu, coeff;
+    G4int nPoly;
+    aDataFile >> eNeu >> nPoly;
+    eNeu *= eV;
+    Init(eNeu, nPoly);
+    for(G4int l=0; l<nPoly; l++)
+    {
+      aDataFile >> coeff;
+      SetCoeff(l+1, coeff);
+    }
+  }
+  
+  inline void Init(G4double e, G4int n)
+  {
+    theCoeff = new G4double[n+1];
+    theCoeff[0]=1.;
+    theEnergy = e;
+    nCoeff = n+1;
+//    G4cout << "G4NeutronHPLegendreTable::Init called "<<e<<" "<<n<<endl;
+  }
+  inline void SetEnergy(G4double energy){ theEnergy = energy; }
+  inline void SetTemperature(G4double temp){ theTemp = temp; }
+  inline void SetCoeff(G4int l, G4double coeff) {theCoeff[l]=coeff;}
+  inline void SetRepresentation(G4int aRep) {theRep = aRep;}
+  
+  inline G4double GetCoeff(G4int l) {return theCoeff[l];}
+  inline G4double GetEnergy(){return theEnergy;}
+  inline G4double GetTemperature(){return theTemp;}
+  inline G4int GetNumberOfPoly() {return nCoeff;}
+  inline G4int GetRepresentation() {return theRep;}
+  inline const G4InterpolationManager & GetManager() {return theManager;}
+  private:
+  
+  G4int theRep;
+  G4double theEnergy;
+  G4double theTemp;
+  G4int nCoeff;
+  G4InterpolationManager theManager; // knows the interpolation between stores
+  G4double * theCoeff;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPLevel.hh

@@ -0,0 +1,62 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPLevel.hh,v 2.3 1998/11/07 11:21:22 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPLevel_h
+#define G4NeutronHPLevel_h 1
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4DynamicParticleVector.hh"
+#include "Randomize.hh"
+#include "G4Gamma.hh"
+class G4NeutronHPGamma;
+
+class G4NeutronHPLevel
+{
+  public:
+  
+  G4NeutronHPLevel() 
+  {
+    nGammas = 0;
+    theGammas = NULL;
+  }
+
+  ~G4NeutronHPLevel();
+  
+  void SetNumberOfGammas(G4int aGammas);
+  
+  void SetGamma(G4int i, G4NeutronHPGamma * aGamma);
+  
+  G4DynamicParticleVector * GetDecayGammas();
+    
+  inline void SetLevelEnergy(G4double anEnergy)
+  {
+    levelEnergy = anEnergy;
+  }
+  
+  inline G4double GetLevelEnergy()
+  {
+    return levelEnergy;
+  }
+
+  G4double GetGammaEnergy(G4int i);
+  
+  private:
+  
+  G4double levelEnergy;  
+
+  G4int nGammas;
+  G4NeutronHPGamma ** theGammas;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPList.hh

@@ -0,0 +1,66 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPList.hh,v 2.2 1998/11/07 11:21:23 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPList_h
+#define G4NeutronHPList_h 1
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+
+class G4NeutronHPList
+{
+  public:
+  
+  G4NeutronHPList()
+  {
+    theData = new G4double[100]; 
+    nPoints=100;
+    nEntries=0;
+  }
+  
+  ~G4NeutronHPList()
+  {
+    delete [] theData;
+  }
+  
+  inline void SetValue(G4int i, G4double y) 
+  { 
+    Check(i);
+    theData[i]=y;
+  }
+  G4double GetValue(G4int i);
+  
+  inline G4int GetListLength() {return nEntries;}
+
+  void Dump();
+  
+  void Init(ifstream & aDataFile, G4int nPar, G4double unit=1.);
+  
+  void Init(ifstream & aDataFile, G4double unit=1.);
+
+  inline void SetLabel(G4double aLabel) { theLabel = aLabel; }
+  
+  inline G4double GetLabel() { return theLabel; }
+
+  private:
+  
+  void Check(G4int i);
+ 
+  G4double theLabel;
+
+  G4double * theData;
+  G4int nEntries;
+  G4int nPoints;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPMadlandNixSpectrum.hh

@@ -0,0 +1,135 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPMadlandNixSpectrum.hh,v 2.4 1998/11/07 11:21:23 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPMadlandNixSpectrum_h
+#define G4NeutronHPMadlandNixSpectrum_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include <math.h>
+#include "G4VNeutronHPEDis.hh"
+
+//     #include <nag.h> @
+//     #include <nags.h> @
+
+
+// we will need a List of these .... one per term.
+
+class G4NeutronHPMadlandNixSpectrum : public G4VNeutronHPEDis
+{
+  public:
+  G4NeutronHPMadlandNixSpectrum()
+  {
+    expm1 = exp(-1.);
+  }
+  ~G4NeutronHPMadlandNixSpectrum()
+  {
+  }
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    theFractionalProb.Init(aDataFile);
+    aDataFile>> theAvarageKineticPerNucleonForLightFragments;
+    theAvarageKineticPerNucleonForLightFragments*=eV;
+    aDataFile>> theAvarageKineticPerNucleonForHeavyFragments;
+    theAvarageKineticPerNucleonForHeavyFragments*=eV;
+    theMaxTemp.Init(aDataFile);
+  }
+  
+  inline G4double GetFractionalProbability(G4double anEnergy)
+  {
+    return theFractionalProb.GetY(anEnergy);
+  }
+  
+  G4double Sample(G4double anEnergy);
+    
+  private:
+  
+  G4double Madland(G4double aSecEnergy, G4double tm);
+  
+  inline G4double FissionIntegral(G4double tm, G4double anEnergy)
+  {
+    return 0.5*(  GIntegral(tm, anEnergy, theAvarageKineticPerNucleonForLightFragments) 
+                       +GIntegral(tm, anEnergy, theAvarageKineticPerNucleonForHeavyFragments) );
+  }
+  
+  G4double GIntegral(G4double tm, G4double anEnergy, G4double aMean);
+  
+  inline G4double Gamma05(G4double aValue)
+  {
+    G4double result;
+    // gamma(1.2,x*X) = sqrt(pi)*Erf(x)
+    G4double x = sqrt(aValue);
+    G4double t = 1./(1+0.47047*x);
+    result = 1- (0.3480242*t - 0.0958798*t*t + 0.7478556*t*t*t)*exp(-aValue); // @ check
+    result *= sqrt(pi);
+    return result;
+  }
+  
+  inline G4double Gamma15(G4double aValue)
+  {
+    G4double result;
+    // gamma(a+1, x) = a*gamma(a,x)-x**a*exp(-x)
+    result = 0.5*Gamma05(aValue) - sqrt(aValue)*exp(-aValue); // @ check
+    return result;
+  }
+  
+  inline G4double Gamma25(G4double aValue)
+  {
+    G4double result;
+    result = 1.5*Gamma15(aValue) - pow(aValue,1.5)*exp(aValue); // @ check
+    return result;
+  }
+  
+  inline G4double E1(G4double aValue)
+  {
+  // good only for rather low aValue @@@ replace by the corresponding NAG function for the
+  // exponential integral. (<5 seems ok.
+    G4double gamma = 0.577216;
+    G4double precision = 0.000001;
+    G4double result =-gamma - log(aValue);
+    G4double term = -aValue;
+    G4double last;
+    G4int count = 1;
+    result -= term;
+    for(;;)
+    {
+      count++;
+      last = result;
+      term = -term*aValue*(count-1)/(count*count);
+      result -=term;
+      if(fabs(term)/fabs(result)<precision) break;
+    }
+//    NagError *fail; @
+//    result = nag_exp_integral(aValue, fail); @
+    return result;
+  }
+  
+  private:
+  
+  G4double expm1;
+  
+  private: 
+  
+  G4NeutronHPVector theFractionalProb;
+  
+  G4double theAvarageKineticPerNucleonForLightFragments;
+  G4double theAvarageKineticPerNucleonForHeavyFragments;
+
+  G4NeutronHPVector theMaxTemp;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPN2AInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPN2AInelasticFS.hh,v 2.2 1998/12/04 15:08:04 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPN2AInelasticFS_h
+#define G4NeutronHPN2AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPN2AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPN2AInelasticFS(){}
+  ~G4NeutronHPN2AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPN2AInelasticFS * theNew = new G4NeutronHPN2AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPN2PInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPN2PInelasticFS.hh,v 2.2 1998/12/04 15:08:04 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPN2PInelasticFS_h
+#define G4NeutronHPN2PInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPN2PInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPN2PInelasticFS(){}
+  ~G4NeutronHPN2PInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPN2PInelasticFS * theNew = new G4NeutronHPN2PInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPN3AInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPN3AInelasticFS.hh,v 2.2 1998/12/04 15:08:05 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPN3AInelasticFS_h
+#define G4NeutronHPN3AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPN3AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPN3AInelasticFS(){}
+  ~G4NeutronHPN3AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPN3AInelasticFS * theNew = new G4NeutronHPN3AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNAInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNAInelasticFS.hh,v 2.2 1998/12/04 15:08:05 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNAInelasticFS_h
+#define G4NeutronHPNAInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNAInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPNAInelasticFS(){}
+  ~G4NeutronHPNAInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNAInelasticFS * theNew = new G4NeutronHPNAInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNBodyPhaseSpace.hh

@@ -0,0 +1,82 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNBodyPhaseSpace.hh,v 2.3 1998/12/04 15:08:05 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNBodyPhaseSpace_h
+#define G4NeutronHPNBodyPhaseSpace_h 1
+
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4Neutron.hh"
+#include "G4VNeutronHPEnergyAngular.hh"
+#include "G4ReactionProduct.hh"
+
+class G4NeutronHPNBodyPhaseSpace : public G4VNeutronHPEnergyAngular
+{
+  public:
+  
+  G4NeutronHPNBodyPhaseSpace(){}
+  ~G4NeutronHPNBodyPhaseSpace(){}
+  
+  public:
+  
+  void Init(G4double aMass, G4int aCount)
+  {
+    theTotalMass=aMass;
+    theTotalCount=aCount;
+  }
+
+  void Init(ifstream & aDataFile)
+  {
+    aDataFile >> theTotalMass >> theTotalCount;
+    theTotalMass *= G4Neutron::Neutron()->GetPDGMass();
+  }
+   
+  G4ReactionProduct * Sample(G4double anEnergy, G4double massCode, G4double mass);
+    
+  private:
+  
+  inline G4double Prob(G4double anEnergy, G4double eMax, G4int n)
+  {
+    G4double result;
+    result = sqrt(anEnergy)*pow(eMax-anEnergy, 3.*n/2.-4.);
+    return result;
+  }
+  
+  inline G4double C(G4double anEnergy, G4double mass)
+  {
+    G4double result;
+    if(theTotalCount==3) result = 4./pi/pow(GetEmax(anEnergy, mass),2);
+    if(theTotalCount==4) result = 105./32./pow(GetEmax(anEnergy, mass), 3.5);
+    if(theTotalCount==5) result = 256./14./pi/pow(GetEmax(anEnergy, mass), 5.);
+    return result;
+  }
+  
+  inline G4double GetEmax(G4double anEnergy, G4double mass)
+  {
+    G4double result;
+    G4double tMass = GetTarget()->GetMass();
+    G4double pMass = GetNeutron()->GetMass();
+    G4double availableEnergy = GetQValue() + anEnergy*tMass/(pMass+tMass);
+    result = availableEnergy*(theTotalMass-mass)/theTotalMass;
+    return result;
+  }
+  
+  G4double MeanEnergyOfThisInteraction() {return -1; }
+  
+  private:
+  
+  G4double theTotalMass; 
+  G4int theTotalCount;
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPND2AInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPND2AInelasticFS.hh,v 2.2 1998/12/04 15:08:05 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPND2AInelasticFS_h
+#define G4NeutronHPND2AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPND2AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPND2AInelasticFS(){}
+  ~G4NeutronHPND2AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPND2AInelasticFS * theNew = new G4NeutronHPND2AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNDInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNDInelasticFS.hh,v 2.2 1998/12/04 15:08:05 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNDInelasticFS_h
+#define G4NeutronHPNDInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNDInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPNDInelasticFS(){}
+  ~G4NeutronHPNDInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNDInelasticFS * theNew = new G4NeutronHPNDInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNHe3InelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNHe3InelasticFS.hh,v 2.2 1998/12/04 15:08:05 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNHe3InelasticFS_h
+#define G4NeutronHPNHe3InelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNHe3InelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPNHe3InelasticFS(){}
+  ~G4NeutronHPNHe3InelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNHe3InelasticFS * theNew = new G4NeutronHPNHe3InelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNInelasticFS.hh,v 2.2 1998/12/04 15:08:05 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNInelasticFS_h
+#define G4NeutronHPNInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticCompFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNInelasticFS : public G4NeutronHPInelasticCompFS
+{
+  public:
+  
+  G4NeutronHPNInelasticFS(){}
+  ~G4NeutronHPNInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNInelasticFS * theNew = new G4NeutronHPNInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNPAInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNPAInelasticFS.hh,v 2.2 1998/12/04 15:08:06 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNPAInelasticFS_h
+#define G4NeutronHPNPAInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNPAInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPNPAInelasticFS(){}
+  ~G4NeutronHPNPAInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNPAInelasticFS * theNew = new G4NeutronHPNPAInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNPInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNPInelasticFS.hh,v 2.2 1998/12/04 15:08:06 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNPInelasticFS_h
+#define G4NeutronHPNPInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNPInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPNPInelasticFS(){}
+  ~G4NeutronHPNPInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNPInelasticFS * theNew = new G4NeutronHPNPInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNT2AInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNT2AInelasticFS.hh,v 2.2 1998/12/04 15:08:06 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNT2AInelasticFS_h
+#define G4NeutronHPNT2AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNT2AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPNT2AInelasticFS(){}
+  ~G4NeutronHPNT2AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNT2AInelasticFS * theNew = new G4NeutronHPNT2AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNTInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNTInelasticFS.hh,v 2.2 1998/12/04 15:08:06 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNTInelasticFS_h
+#define G4NeutronHPNTInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNTInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPNTInelasticFS(){}
+  ~G4NeutronHPNTInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNTInelasticFS * theNew = new G4NeutronHPNTInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNXInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNXInelasticFS.hh,v 2.2 1998/12/04 15:08:06 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNXInelasticFS_h
+#define G4NeutronHPNXInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPNXInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPNXInelasticFS(){}
+  ~G4NeutronHPNXInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPNXInelasticFS * theNew = new G4NeutronHPNXInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNames.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNames.hh,v 2.7 1998/12/10 11:55:07 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNames_h
+#define G4NeutronHPNames_h 1
+
+#include "G4ios.hh"
+#include <fstream.h>
+#ifdef WIN32
+  #include <strstrea.h>
+#else
+  #include <strstream.h>
+#endif
+#include <stdlib.h>
+#include "globals.hh"
+#include "G4NeutronHPDataUsed.hh"
+
+class G4NeutronHPNames
+{
+  public:
+  
+  G4NeutronHPNames(){}
+  ~G4NeutronHPNames(){}
+  
+  G4NeutronHPDataUsed GetName(G4int A, G4int Z, G4String base, G4String rest, G4bool & active);
+  G4String GetName(G4int i) { return theString[i]; }
+  
+  private:
+  
+  static const G4String theString[99];
+
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPNeutronYield.hh

@@ -0,0 +1,139 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPNeutronYield.hh,v 2.2 1998/11/07 11:21:31 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPNeutronYield_h
+#define G4NeutronHPNeutronYield_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "G4NeutronHPPolynomExpansion.hh"
+#include "G4NeutronHPList.hh"
+
+class G4NeutronHPNeutronYield
+{
+  public:
+  G4NeutronHPNeutronYield()
+  {
+    simpleMean = true;
+    spontPrompt = true;
+    hasPromptData = false;
+    hasDelayedData = false;
+  }
+  ~G4NeutronHPNeutronYield(){}
+  
+  G4double GetTargetMass() { return targetMass; }
+  
+  void InitMean(ifstream & aDataFile)
+  {
+    G4int iflag;
+    aDataFile >> targetMass >>iflag;
+    if(iflag == 1) simpleMean=false;
+    if(simpleMean)
+    {
+      theSimpleMean.Init(aDataFile, eV);
+    }
+    else
+    {
+      theMean.Init(aDataFile);
+    }
+  }
+
+  void InitPrompt(ifstream & aDataFile)
+  { 
+    hasPromptData = true;
+    G4int iflag;
+    aDataFile >> targetMass >>iflag;
+    if(iflag == 2) spontPrompt = false;
+    if(spontPrompt)
+    {
+      aDataFile >> theSpontPrompt;
+    }
+    else
+    {
+      thePrompt.Init(aDataFile, eV);
+    }
+  }
+ 
+  void InitDelayed(ifstream & aDataFile)
+  {
+    hasDelayedData = true;
+    G4int iflag;
+    aDataFile >> targetMass >>iflag;
+    thePrecursorDecayConstants.Init(aDataFile, 1./s); // s is the CLHEP unit second
+    if(iflag == 2) spontDelayed = false;
+    if(spontDelayed)
+    {
+      aDataFile >> theSpontDelayed;
+    }
+    else
+    {
+      theDelayed.Init(aDataFile, eV);
+    }
+  }
+  
+  G4double GetMean(G4double anEnergy)
+  {
+    if(simpleMean)
+    {
+    return theSimpleMean.GetY(anEnergy);
+    }
+    return theMean.GetValue(anEnergy);
+  }
+  
+  G4double GetPrompt(G4double anEnergy)
+  {
+    if(!hasPromptData) return 0;
+    if(spontPrompt)
+    {
+      return theSpontPrompt;
+    }
+    return thePrompt.GetY(anEnergy);
+  }
+  
+  G4double GetDelayed(G4double anEnergy)
+  {
+    if(!hasDelayedData) return 0;
+    if(spontDelayed)
+    {
+      return theSpontDelayed;
+    }
+    return theDelayed.GetY(anEnergy);
+  }
+  
+  inline G4double GetDecayConstant(G4int i)
+  {
+    return thePrecursorDecayConstants.GetValue(i);
+  }
+  
+  private:
+  
+  G4double targetMass;
+  // total mean
+  G4bool simpleMean;
+  G4NeutronHPPolynomExpansion theMean;
+  G4NeutronHPVector theSimpleMean;
+  
+  // Prompt neutrons
+  G4bool hasPromptData;
+  G4bool spontPrompt;
+  G4NeutronHPVector thePrompt;
+  G4double theSpontPrompt;
+  
+  // delayed neutrons
+  G4bool hasDelayedData;
+  G4bool spontDelayed;
+  G4NeutronHPList thePrecursorDecayConstants;
+  G4NeutronHPVector theDelayed;
+  G4double theSpontDelayed;
+
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPPAInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPPAInelasticFS.hh,v 2.2 1998/12/04 15:08:07 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPPAInelasticFS_h
+#define G4NeutronHPPAInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPPAInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPPAInelasticFS(){}
+  ~G4NeutronHPPAInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPPAInelasticFS * theNew = new G4NeutronHPPAInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPPDInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPPDInelasticFS.hh,v 2.2 1998/12/04 15:08:07 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPPDInelasticFS_h
+#define G4NeutronHPPDInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPPDInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPPDInelasticFS(){}
+  ~G4NeutronHPPDInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPPDInelasticFS * theNew = new G4NeutronHPPDInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPPInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPPInelasticFS.hh,v 2.2 1998/12/04 15:08:07 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPPInelasticFS_h
+#define G4NeutronHPPInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticCompFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPPInelasticFS : public G4NeutronHPInelasticCompFS
+{
+  public:
+  
+  G4NeutronHPPInelasticFS(){}
+  ~G4NeutronHPPInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPPInelasticFS * theNew = new G4NeutronHPPInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPPTInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPPTInelasticFS.hh,v 2.2 1998/12/04 15:08:07 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPPTInelasticFS_h
+#define G4NeutronHPPTInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPPTInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPPTInelasticFS(){}
+  ~G4NeutronHPPTInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPPTInelasticFS * theNew = new G4NeutronHPPTInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPPartial.hh

@@ -0,0 +1,114 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPPartial.hh,v 2.1 1998/11/07 11:21:33 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPPartial_h
+#define G4NeutronHPPartial_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "G4InterpolationManager.hh"
+#include "G4NeutronHPInterpolator.hh"
+
+class G4NeutronHPPartial
+{
+  public:
+  
+  G4NeutronHPPartial(G4int n)
+  { 
+    X = new G4double[n];
+    data = new G4NeutronHPVector[n];
+    nData = n;
+    T=NULL;
+  }
+  
+  G4NeutronHPPartial(G4int n1, G4int n2)
+  {
+    T = new G4double[n2];
+    X = new G4double[n1];
+    data = new G4NeutronHPVector[n1];
+    nData = max(n1,n2);
+  }  
+  
+  void InitInterpolation(G4int i, ifstream & aDataFile)
+  {
+    data[i].InitInterpolation(aDataFile);
+  }
+  
+  void InitInterpolation(ifstream & aDataFile)
+  {
+    theManager.Init(aDataFile);
+  }
+  
+  void Init(ifstream & aDataFile)
+  {
+    G4int i;
+    G4double e;
+    G4int neg;
+    for( i=0; i<nData; i++)
+    {
+      aDataFile >> e;
+      e *= eV;
+      SetX(i,e);
+      InitData(i, aDataFile, eV); // energy and probability for gammas
+    }  
+  }
+  
+  void InitData(G4int i, ifstream & aDataFile, G4double unit=1.)
+  {
+    G4int ii;
+    G4double eg, pg;
+    G4int neg;
+    aDataFile >> neg;
+    data[i].InitInterpolation(aDataFile);
+    for (ii=0; ii<neg; ii++)
+    { 
+      aDataFile >> eg >> pg;
+      eg *= unit;
+      SetX(i,ii,eg);
+      SetY(i,ii,pg);
+    }          
+  }
+  
+  ~G4NeutronHPPartial()
+  {
+    delete [] X;
+    if(T!=NULL) delete [] T;
+    delete [] data;
+  }
+  inline G4int GetNumberOfEnergies() {return nData;}
+  
+  inline void SetX(G4int i, G4double x) {X[i]=x;}
+  inline void SetT(G4int i, G4double x) {T[i]=x;}
+  inline void SetX(G4int i, G4int j, G4double x) {data[i].SetX(j,x);}
+  inline void SetY(G4int i, G4int j, G4double y) {data[i].SetY(j,y);}
+  
+  inline G4double GetX(G4int i) {return X[i];}
+  inline G4double GetT(G4int i) {return T[i];}
+  inline G4double GetX(G4int i, G4int j) {return data[i].GetX(j);}
+  inline G4double GetY(G4int i, G4int j) {return data[i].GetY(j);}
+  inline G4double GetY(G4int i, G4double e) {return data[i].GetY(e);}
+  inline G4int GetNEntries(G4int i) {return data[i].GetVectorLength();}
+  G4NeutronHPVector * GetY(G4double e1);
+  G4double Sample(G4double x);
+  
+  private:
+  
+  G4double * X;
+  G4double * T;
+  G4NeutronHPVector * data;
+  G4NeutronHPVector * theBuffer;
+  G4int nData;
+  G4InterpolationManager theManager; // interpolate between different data[i]
+  G4NeutronHPInterpolator theInt;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPPhotonDist.hh

@@ -0,0 +1,141 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPPhotonDist.hh,v 2.4 1998/12/10 10:12:35 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+ // Hadronic Process: Very Low Energy Neutron X-Sections
+ // original by H.P. Wellisch, TRIUMF, 14-Feb-97
+ 
+#ifndef G4NeutronHPPhotonDist_h
+#define G4NeutronHPPhotonDist_h 1
+#include "globals.hh"
+#include <fstream.h>
+#include "G4ios.hh"
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "G4NeutronHPLegendreTable.hh"
+#include "G4NeutronHPAngularP.hh"
+#include "G4NeutronHPPartial.hh"
+#include "G4NeutronHPFastLegendre.hh"
+#include "G4NeutronHPInterpolator.hh"
+#include "G4ReactionProductVector.hh"
+#include "G4ReactionProduct.hh"
+#include "G4Gamma.hh"
+#include "G4InterpolationManager.hh"
+
+class G4NeutronHPPhotonDist
+{
+public:
+
+  G4NeutronHPPhotonDist()
+  {
+     disType = NULL;
+     energy = NULL;
+     theYield = NULL;
+     thePartialXsec = NULL;
+     isPrimary = NULL;
+     theShells = NULL;
+     theGammas = NULL;
+     nNeu = NULL;
+     theLegendre = NULL;
+     theAngular = NULL;
+     distribution = NULL;
+     probs = NULL;
+     partials = NULL;
+     actualMult = NULL;
+
+     theLevelEnergies = NULL;
+     theTransitionProbabilities = NULL;
+     thePhotonTransitionFraction = NULL;
+  }
+
+  ~G4NeutronHPPhotonDist()
+  {
+     if(disType != NULL) delete [] disType;
+     if(energy != NULL) delete [] energy;
+     if(theYield != NULL) delete [] theYield;
+     if(thePartialXsec != NULL) delete [] thePartialXsec;
+     if(isPrimary != NULL) delete [] isPrimary;
+     if(theShells != NULL) delete [] theShells;
+     if(theGammas != NULL) delete [] theGammas;
+     if(nNeu != NULL) delete [] nNeu;
+     if(theLegendre != NULL) delete [] theLegendre;
+     if(theAngular != NULL) delete [] theAngular;
+     if(distribution != NULL) delete [] distribution;
+     if(probs != NULL) delete [] probs;
+     if(partials != NULL) delete [] partials;
+     if(actualMult != NULL) delete [] actualMult;
+
+     if(theLevelEnergies != NULL) delete theLevelEnergies;
+     if(theTransitionProbabilities != NULL) delete theTransitionProbabilities;
+     if(thePhotonTransitionFraction != NULL) delete thePhotonTransitionFraction;
+  }
+  
+  G4bool InitMean(ifstream & aDataFile);
+    
+  void InitAngular(ifstream & aDataFile);
+  
+  void InitEnergies(ifstream & aDataFile);
+  
+  void InitPartials(ifstream & aDataFile);
+  
+  G4ReactionProductVector * GetPhotons(G4double anEnergy);
+  
+  inline G4double GetTargetMass() {return targetMass;}
+  
+  inline G4bool NeedsCascade() {return repFlag==2;}
+  
+  inline G4double GetLevelEnergy() {return theBaseEnergy;}
+
+private:
+
+   G4int repFlag;  //representation as multiplicities or transition probability arrays.
+   G4double targetMass;
+   
+   G4int nDiscrete;  //number of discrete photons 
+   G4int * disType;  // discrete, or continuum photons
+   G4double * energy;  // photon energies
+   G4NeutronHPVector * theYield; // multiplicity as a function of neutron energy.
+   G4NeutronHPVector theTotalXsec;
+   G4NeutronHPVector * thePartialXsec;
+   G4int * isPrimary;
+  
+   G4int isoFlag; // isotropic or not?
+   G4int tabulationType;
+   G4int nDiscrete2;
+   G4int nIso;
+   G4double * theShells;
+   G4double * theGammas;
+   G4int * nNeu;
+   G4InterpolationManager theLegendreManager;
+   G4NeutronHPLegendreTable ** theLegendre;
+   G4NeutronHPAngularP ** theAngular;
+   
+   G4int * distribution; // not used for the moment.                                 
+   G4int nPartials;
+   G4NeutronHPVector *  probs; // probabilities for the partial distributions.
+   G4NeutronHPPartial ** partials; // the partials, parallel to the above
+
+   G4int * actualMult;
+   
+    // for transition prob arrays start
+   G4int theInternalConversionFlag;
+   G4int nGammaEnergies;
+   G4double theBaseEnergy;
+   G4double * theLevelEnergies;
+   G4double * theTransitionProbabilities;
+   G4double * thePhotonTransitionFraction;
+    // for transition prob arrays end
+
+   G4NeutronHPFastLegendre theLegend; // fast look-up for leg-integrals
+   G4NeutronHPInterpolator theInt; // interpolation
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPPhotonXSection.hh

@@ -0,0 +1,90 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPPhotonXSection.hh,v 2.3 1998/11/07 11:21:34 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPPhotonXSection_h
+#define G4NeutronHPPhotonXSection_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4VNeutronVector.hh"
+
+// we will need a List of these .... one per term.
+
+class G4NeutronHPPhotonXSection 
+{
+  public:
+  G4NeutronHPPhotonXSection()
+  {
+    theExclusive = NULL;
+    theExShell = NULL;
+    theExEnergy = NULL;
+    theExFlag = NULL;
+    theExDisFlag = NULL;
+  }
+  ~G4NeutronHPPhotonXSection()
+  {
+    if(theExclusive!=NULL) delete [] theExclusive;
+    if(theExShell != NULL) delete [] theExShell;
+    if(theExEnergy != NULL) delete [] theExEnergy;
+    if(theExFlag != NULL) delete [] theExFlag;
+    if(theExDisFlag != NULL) delete [] theExDisFlag;
+  }
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    aDataFile  >> nChannels >> targetMass;
+    if(nChannels!=1) 
+    {
+      aDataFile >> theIncEnergy>>theIncShell>>theIncFlag>>theIncDisFlag;
+      theaDataFileInclusive.Init(aDataFile, eV);
+    }
+    theExclusive = new G4NeutronHPVector[nChannels];
+    theExShell = new G4double[nChannels];
+    theExEnergy = new G4double[nChannels];
+    theExFlag = new G4int[nChannels];
+    theExDisFlag = new G4int[nChannels];   
+    for(G4int i=0; i<nChannels; i++)
+    {
+      aDataFile>>theExEnergy[i]>>theExShell[i]>>theExFlag[i]>>theExDisFlag[i];
+      theExclusive[i].Init(aDataFile,eV);
+    }
+  }
+  
+  G4double Sample(G4double anEnergy)
+  {
+    return -1;
+  }
+  
+  private:
+   
+  G4double targetMass;
+  
+  G4double theIncShell;
+  G4double theIncEnergy;
+  G4int theIncFlag
+  G4int theIncDisFlag;
+  G4NeutronHPVector theInclusive;
+  
+  G4int nChannels;
+  G4double * theExShell;
+  G4double * theExEnergy;
+  G4int * theExFlag
+  G4int * theExDisFlag;
+  G4NeutronHPVector * theExclusive;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPPolynomExpansion.hh

@@ -0,0 +1,63 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPPolynomExpansion.hh,v 2.2 1998/11/07 11:21:34 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPPolynomExpansion_h
+#define G4NeutronHPPolynomExpansion_h 1
+
+#include "globals.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+
+class G4NeutronHPPolynomExpansion
+{
+  public:
+  G4NeutronHPPolynomExpansion()
+  {
+    theCoeff = NULL;
+    nPoly=0;
+  }
+  ~G4NeutronHPPolynomExpansion()
+  {
+    if(theCoeff!=NULL) delete [] theCoeff;
+  }
+  
+  inline void Init(ifstream & theData)
+  {
+    theData >> nPoly;
+    theCoeff = new G4double[nPoly];
+    G4int i;
+    for(i=0;i<nPoly;i++)
+    {
+      theData >> theCoeff[i];
+    }
+  }
+  
+  inline G4double GetValue(G4double anEnergy) 
+  {
+    G4int i;
+    G4double result=0;
+    G4double base = anEnergy/eV;
+    G4double running = 1;
+    for(i=0; i<nPoly; i++)
+    {
+      result+=theCoeff[i]*running;
+      running *= base;
+    }
+    return result;
+  }
+  private:
+  
+  G4int nPoly;
+  G4double * theCoeff;
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPProduct.hh

@@ -0,0 +1,167 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPProduct.hh,v 2.2 1998/11/07 11:21:35 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPProduct_h
+#define G4NeutronHPProduct_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "globals.hh"
+#include "G4VNeutronHPEnergyAngular.hh"
+#include "G4ReactionProductVector.hh"
+
+#include "G4NeutronHPContEnergyAngular.hh"
+#include "G4NeutronHPDiscreteTwoBody.hh"
+#include "G4NeutronHPIsotropic.hh"
+#include "G4NeutronHPNBodyPhaseSpace.hh"
+#include "G4NeutronHPLabAngularEnergy.hh"
+
+class G4NeutronHPProduct
+{
+  public:
+  G4NeutronHPProduct()
+  {
+    theDist = NULL;
+  }
+  ~G4NeutronHPProduct()
+  {
+    if(theDist != NULL) delete theDist;
+  }
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    aDataFile >> theMassCode>>theMass>>theIsomerFlag>>theDistLaw
+              >> theGroundStateQValue>>theActualStateQValue;
+    theGroundStateQValue*= eV;
+    theActualStateQValue*= eV;
+    theYield.Init(aDataFile, eV);
+    if(theDistLaw==0)
+    {
+      // distribution not known, use E-independent, isotropic angular distribution
+      theDist = new G4NeutronHPIsotropic;
+    }
+    else if(theDistLaw == 1)
+    {
+      // Continuum energy-angular distribution
+      theDist = new G4NeutronHPContEnergyAngular;
+    }
+    else if(theDistLaw == 2)
+    {
+      // Discrete 2-body scattering
+      theDist = new G4NeutronHPDiscreteTwoBody;
+    }
+    else if(theDistLaw == 3)
+    {
+      // Isotropic emission
+      theDist = new G4NeutronHPIsotropic;
+    }
+    else if(theDistLaw == 4)
+    {
+      // Discrete 2-body recoil modification
+      // not used for now. @@@@
+      theDist = new G4NeutronHPDiscreteTwoBody; 
+      // the above is only temporary;
+      // recoils need to be addressed
+      // properly
+      delete theDist;
+      theDist = NULL;
+    }
+    else if(theDistLaw == 5)
+    {
+      // charged particles only, to be used in a later stage. @@@@
+    }
+    else if(theDistLaw == 6)
+    {
+      // N-Body phase space
+      theDist = new G4NeutronHPNBodyPhaseSpace;
+    }
+    else if(theDistLaw == 7)
+    {
+      // Laboratory angular energy paraetrisation
+      theDist = new G4NeutronHPLabAngularEnergy;
+    }
+    else
+    {
+      G4Exception("distribution law unknown to G4NeutronHPProduct");
+    }
+    if(theDist!=NULL)
+    {
+      theDist->SetQValue(theActualStateQValue);      
+      theDist->Init(aDataFile);
+    }
+  }
+  
+  G4ReactionProductVector * Sample(G4double anEnergy);
+  
+  G4double GetMeanYield(G4double anEnergy)
+  {
+    return theYield.GetY(anEnergy);
+  }
+  
+  void SetNeutron(G4ReactionProduct * aNeutron) 
+  { 
+    theNeutron = aNeutron; 
+  }
+  
+  void SetTarget(G4ReactionProduct * aTarget)
+  { 
+    theTarget = aTarget; 
+  }
+  
+  inline G4ReactionProduct * GetTarget() { return theTarget; }
+  
+  inline G4ReactionProduct * GetNeutron() { return theNeutron; }
+  
+  inline G4double MeanEnergyOfThisInteraction() 
+  { 
+    G4double result;
+    if(theDist == NULL)
+    {
+      result = 0;
+    }
+    else
+    {
+      result=theDist->MeanEnergyOfThisInteraction();
+      result *= theCurrentMultiplicity;
+    }
+    return result;
+  }
+  
+  inline G4double GetQValue() { return theActualStateQValue; }
+  private:
+   
+   // data members
+
+   G4double theMassCode;
+   G4double theMass;
+   G4int theIsomerFlag;
+   G4double theGroundStateQValue;
+   G4double theActualStateQValue;
+   G4int theDistLaw;  // redundant
+   G4NeutronHPVector theYield;
+   G4VNeutronHPEnergyAngular *  theDist;
+   
+   // Utility quantities
+   
+   G4ReactionProduct * theTarget;
+   G4ReactionProduct * theNeutron;
+
+   // cashed values
+   
+   G4int theCurrentMultiplicity;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPSCFissionFS.hh

@@ -0,0 +1,39 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPSCFissionFS.hh,v 2.4 1998/12/04 15:08:07 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPSCFissionFS_h
+#define G4NeutronHPSCFissionFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4DynamicParticleVector.hh"
+#include "G4NeutronHPFissionBaseFS.hh"
+
+class G4NeutronHPSCFissionFS : public G4NeutronHPFissionBaseFS
+{
+  public:
+  
+  G4NeutronHPSCFissionFS(){ hasXsec = false; }
+  ~G4NeutronHPSCFissionFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4DynamicParticleVector * ApplyYourself(G4int NNeutrons);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPSCFissionFS * theNew = new G4NeutronHPSCFissionFS;
+   return theNew;
+  }
+  
+  private:
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack) { return NULL; }
+    
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPSimpleEvapSpectrum.hh

@@ -0,0 +1,80 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPSimpleEvapSpectrum.hh,v 2.4 1998/11/07 11:21:35 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPSimpleEvapSpectrum_h
+#define G4NeutronHPSimpleEvapSpectrum_h 1
+
+#include "globals.hh"
+#include "G4NeutronHPVector.hh"
+#include "Randomize.hh"
+#include "G4ios.hh"
+#include <fstream.h>
+#include "G4VNeutronHPEDis.hh"
+
+// we will need a List of these .... one per term.
+
+class G4NeutronHPSimpleEvapSpectrum : public G4VNeutronHPEDis
+{
+  public:
+  G4NeutronHPSimpleEvapSpectrum()
+  {
+    expm1 = exp(-1.);
+  }
+  ~G4NeutronHPSimpleEvapSpectrum()
+  {
+  }
+  
+  inline void Init(ifstream & aDataFile)
+  {
+    theFractionalProb.Init(aDataFile,eV);
+    theThetaDist.Init(aDataFile, eV);
+  }
+  
+  inline G4double GetFractionalProbability(G4double anEnergy)
+  {
+    return theFractionalProb.GetY(anEnergy);
+  }
+  
+  inline G4double Sample(G4double anEnergy) 
+  {
+    G4double theta = theThetaDist.GetY(anEnergy)*eV;
+    G4double random, cut, max, result;
+    max = 10.*theta;
+    do
+    {
+      random = G4UniformRand();
+      result = -theta*log(random); 
+      cut = G4UniformRand();
+    }
+    while(cut>result/max); 
+    return result;
+  }
+  
+  private:
+  
+  inline G4double Evapo(G4double anEnergy, G4double theta)
+  {
+    G4double result = (anEnergy*eV)*exp(-anEnergy*eV/theta);
+    return result;
+  }
+  
+  private:
+  
+  G4double expm1;
+  
+  G4NeutronHPVector theFractionalProb;
+  
+  G4NeutronHPVector theThetaDist;
+  
+};
+
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPT2AInelasticFS.hh

@@ -0,0 +1,37 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPT2AInelasticFS.hh,v 2.2 1998/12/04 15:08:08 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPT2AInelasticFS_h
+#define G4NeutronHPT2AInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticBaseFS.hh"
+
+class G4NeutronHPT2AInelasticFS : public G4NeutronHPInelasticBaseFS
+{
+  public:
+  
+  G4NeutronHPT2AInelasticFS(){}
+  ~G4NeutronHPT2AInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPT2AInelasticFS * theNew = new G4NeutronHPT2AInelasticFS;
+   return theNew;
+  }
+  
+  private:
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPTCFissionFS.hh

@@ -0,0 +1,39 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPTCFissionFS.hh,v 2.4 1998/12/04 15:08:08 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPTCFissionFS_h
+#define G4NeutronHPTCFissionFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4DynamicParticleVector.hh"
+#include "G4NeutronHPFissionBaseFS.hh"
+
+class G4NeutronHPTCFissionFS : public G4NeutronHPFissionBaseFS
+{
+  public:
+  
+  G4NeutronHPTCFissionFS(){ hasXsec = false; }
+  ~G4NeutronHPTCFissionFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4DynamicParticleVector * ApplyYourself(G4int NNeutrons);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPTCFissionFS * theNew = new G4NeutronHPTCFissionFS;
+   return theNew;
+  }
+  
+  private:
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack) { return NULL; }
+    
+};
+#endif

source/processes/hadronic/models/neutron_hp/include/G4NeutronHPTInelasticFS.hh

@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// neutron_hp -- header file
+// J.P. Wellisch, Nov-1996
+// A prototype of the low energy neutron transport model.
+//
+// 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: G4NeutronHPTInelasticFS.hh,v 2.2 1998/12/04 15:08:08 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4NeutronHPTInelasticFS_h
+#define G4NeutronHPTInelasticFS_h 1
+
+#include "globals.hh"
+#include "G4Track.hh"
+#include "G4ParticleChange.hh"
+#include "G4NeutronHPInelasticCompFS.hh"
+#include "G4NeutronHPAngular.hh"
+#include "G4NeutronHPEnergyDistribution.hh"
+#include "G4NeutronHPEnAngCorrelation.hh"
+#include "G4NeutronHPPhotonDist.hh"
+
+class G4NeutronHPTInelasticFS : public G4NeutronHPInelasticCompFS
+{
+  public:
+  
+  G4NeutronHPTInelasticFS(){}
+  ~G4NeutronHPTInelasticFS(){}
+  void Init (G4double A, G4double Z, G4String & dirName, G4String & aFSType);
+  G4ParticleChange * ApplyYourself(const G4Track & theTrack);
+  G4NeutronHPFinalState * New() 
+  {
+   G4NeutronHPTInelasticFS * theNew = new G4NeutronHPTInelasticFS;
+   return theNew;
+  }
+  
+  private:
+  
+};
+#endif