Import Geant4 0.0.0 source tree

2016-06-01 15:25:35 +02:00
parent 54d6b71f95
commit b97f8d0df7
3237 changed files with 807095 additions and 0 deletions
@@ -0,0 +1,52 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4V3DNucleus.hh,v 1.2 1998/10/30 16:36:36 gunter Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4V3DNucleus_h
+#define G4V3DNucleus_h 1
+
+#include "G4Nucleon.hh"
+#include "G4DynamicParticle.hh"
+
+class G4V3DNucleus 
+{
+
+  public:
+      G4V3DNucleus();
+      virtual ~G4V3DNucleus();
+
+  private:
+      G4V3DNucleus(const G4V3DNucleus &right);
+      const G4V3DNucleus & operator=(const G4V3DNucleus &right);
+      int operator==(const G4V3DNucleus &right) const;
+      int operator!=(const G4V3DNucleus &right) const;
+
+  public:
+      virtual void Init(G4double theA, G4double theZ) = 0;
+      virtual G4bool StartLoop() = 0;
+      virtual G4Nucleon * GetNextNucleon() = 0;
+      virtual G4int GetMassNumber() = 0;
+      virtual G4double GetMass() = 0;
+      virtual G4int GetCharge() = 0;
+      virtual G4double GetNuclearRadius() = 0;
+      virtual G4double GetNuclearRadius(const G4double maxRelativeDensity) = 0;
+      virtual G4double GetOuterRadius() = 0;
+      virtual void DoLorentzBoost(const G4LorentzVector & theBoost) = 0;
+      virtual void DoLorentzBoost(const G4ThreeVector & theBeta) = 0;
+      virtual void DoLorentzContraction(const G4LorentzVector & theBoost) = 0;
+      virtual void DoLorentzContraction(const G4ThreeVector & theBeta) = 0;
+      virtual void DoTranslation(const G4ThreeVector & theShift) = 0;
+
+  private:
+
+};
+
+#endif
+
+
@@ -0,0 +1,18 @@
+#ifndef G4VAnnihilator_h
+#define G4VAnnihilator_h 1
+
+#include "G4KineticTrackVector.hh"
+
+
+class G4VAnnihilator 
+{
+public:
+   G4VAnnihilator();
+  virtual ~G4VAnnihilator();
+public:
+    virtual G4KineticTrackVector* Scatter(const G4KineticTrack &aProjectile, const G4KineticTrack &aTarget) = 0;
+};
+
+#endif 
+
+
@@ -0,0 +1,30 @@
+#ifndef G4VCrossSectionBase_h
+#define G4VCrossSectionBase_h 1
+
+#include "globals.hh"
+
+const G4int maxpsig = 13;
+const G4int maxreac = 14;
+
+//****************************************************************************************
+
+class G4VCrossSectionBase 
+   {
+public:
+   //Constructors
+   G4VCrossSectionBase();
+  ~G4VCrossSectionBase();
+
+public:   
+   virtual G4double GetTotCrossSection(G4int ProjectileEncoding, G4int TargetEncoding, G4double Energy)=0;
+   virtual G4double GetElCrossSection (G4int ProjectileEncoding, G4int TargetEncoding, G4double Energy)=0;
+   virtual G4double GetInCrossSection (G4int ProjectileEncoding, G4int TargetEncoding, G4double Energy)=0;   
+   virtual G4double GetAnnihCrossSection(G4int ProjectileEncoding, G4int TargetEncoding, G4double
+   Energy) = 0;
+   };
+
+//****************************************************************************************
+#endif
+
+
+
@@ -0,0 +1,17 @@
+#ifndef G4VElasticScatterer_h
+#define G4VElasticScatterer_h 1
+
+#include "G4KineticTrackVector.hh"
+
+class G4VElasticScatterer 
+   {
+public:
+    G4VElasticScatterer();
+   ~G4VElasticScatterer();
+public:
+    virtual G4KineticTrackVector* Scatter(const G4KineticTrack &aProjectile, const G4KineticTrack &aTarget)= 0;
+};
+  
+#endif 
+
+
@@ -0,0 +1,42 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VHighEnergyGenerator.hh,v 1.1 1998/08/22 08:55:44 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4VHighEnergyGenerator_h
+#define G4VHighEnergyGenerator_h 1
+
+#include "G4Nucleus.hh"
+#include "G4Track.hh"
+#include "G4KineticTrackVector.hh"
+#include "G4ReactionProduct.hh"
+#include "G4V3DNucleus.hh"
+
+class G4VHighEnergyGenerator 
+{
+  public:
+      G4VHighEnergyGenerator();
+      virtual ~G4VHighEnergyGenerator();
+
+  private:
+      G4VHighEnergyGenerator(const G4VHighEnergyGenerator &right);
+      const G4VHighEnergyGenerator & operator=(const G4VHighEnergyGenerator &right);
+      int operator==(const G4VHighEnergyGenerator &right) const;
+      int operator!=(const G4VHighEnergyGenerator &right) const;
+
+ public:
+      virtual G4V3DNucleus * GetWoundedNucleus() const = 0;
+      virtual G4KineticTrackVector * Scatter(const G4Nucleus &theNucleus, 
+                                             const G4DynamicParticle &thePrimary) = 0;
+
+  private:
+
+};
+#endif
+
+
@@ -0,0 +1,20 @@
+#ifndef G4VInElasticScatterer_h
+#define G4VInElasticScatterer_h 1
+
+#include "G4KineticTrackVector.hh"
+
+class G4VInElasticScatterer 
+   {
+public:
+
+   G4VInElasticScatterer();
+   virtual ~G4VInElasticScatterer();
+    
+public:    
+    virtual G4KineticTrackVector* Scatter(const G4KineticTrack &aProjectile, const G4KineticTrack &aTarget) = 0;
+
+};
+  
+#endif 
+
+
@@ -0,0 +1,105 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VIntraNuclearTransportModel.hh,v 1.2 1998/11/27 08:26:52 pavliouk Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+// $Id: G4IntraNuclearTransportMode.hh,v 1.0 1998/06/30
+// -----------------------------------------------------------------------------
+//      GEANT 4 class header file
+//
+//      For information related to this code contact:
+//      CERN, CN Division, ASD group
+//      History: first implementation, A. Feliciello, 30th June 1998
+//      A.Pavliouk 26.11.98
+//          In Set...() methods a pointer is deleted now before new
+//          value will be asigned.
+// -----------------------------------------------------------------------------
+
+#ifndef G4VIntraNuclearTransportModel_h
+#define G4VIntraNuclearTransportModel_h 1
+
+#include "G4V3DNucleus.hh"
+#include "G4VPreCompoundModel.hh"
+#include "G4HadronicInteraction.hh"
+#include "G4DynamicParticleVector.hh"
+#include "G4Track.hh"
+
+
+
+class G4VIntraNuclearTransportModel : public G4HadronicInteraction
+
+{
+  public:
+
+      G4VIntraNuclearTransportModel();
+
+      G4VIntraNuclearTransportModel(const G4VIntraNuclearTransportModel& right);
+
+      virtual ~G4VIntraNuclearTransportModel();
+
+      const G4VIntraNuclearTransportModel& operator=(const G4VIntraNuclearTransportModel &right);
+
+      int operator==(const G4VIntraNuclearTransportModel& right) const;
+
+      int operator!=(const G4VIntraNuclearTransportModel& right) const;
+
+      virtual G4VParticleChange* ApplyYourself(const G4Track& aTrack, 
+                                              G4Nucleus& theNucleus) = 0;
+
+      virtual G4DynamicParticleVector* Propagate(G4KineticTrackVector* theSecondaries,
+                                                 G4V3DNucleus* theNucleus) = 0;
+
+      void SetDeExcitation(G4VPreCompoundModel* const  value);
+      void Set3DNucleus(G4V3DNucleus* const value);
+
+
+  protected:
+
+      G4V3DNucleus* Get3DNucleus() const;
+
+      G4VPreCompoundModel* GetDeExcitation() const;
+
+
+
+  protected:
+
+      G4V3DNucleus* the3DNucleus;
+
+      G4VPreCompoundModel* theDeExcitation;
+};
+
+
+
+// Class G4VIntraNuclearTransportModel 
+
+
+inline G4V3DNucleus* G4VIntraNuclearTransportModel::Get3DNucleus() const
+{
+  return the3DNucleus;
+}
+
+inline void G4VIntraNuclearTransportModel::Set3DNucleus(G4V3DNucleus* const value)
+{
+   delete the3DNucleus;  the3DNucleus = value;
+}
+
+
+
+inline G4VPreCompoundModel* G4VIntraNuclearTransportModel::GetDeExcitation() const
+{
+  return theDeExcitation;
+}
+
+inline void G4VIntraNuclearTransportModel::SetDeExcitation(G4VPreCompoundModel* const  value)
+{
+   delete theDeExcitation; theDeExcitation = value;
+}
+
+#endif
+
+
@@ -0,0 +1,75 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VLongitudinalStringDecay.hh,v 1.4 1998/12/01 15:40:47 maxim Exp $
+// GEANT4 tag $Name: geant4-00 $
+// Maxim Komogorov
+//
+// -----------------------------------------------------------------------------
+//      GEANT 4 class implementation file
+//
+//      For information related to this code contact:
+//      CERN, CN Division, ASD Group
+//      History: first implementation, Maxim Komogorov, 1-Jul-1998
+// -----------------------------------------------------------------------------
+#ifndef G4VLongitudinalStringDecay_h
+#define G4VLongitudinalStringDecay_h 1
+#include "G4VStringFragmentation.hh"
+#include "G4DynamicParticle.hh"
+
+//**********************************************************************************************
+
+class G4VLongitudinalStringDecay: public G4VStringFragmentation 
+   {
+public:
+   G4VLongitudinalStringDecay();     
+  ~G4VLongitudinalStringDecay();
+
+private:
+//  G4VLongitudinalStringDecay(const G4VLongitudinalStringDecay &right);
+//  const G4VLongitudinalStringDecay & operator=(const G4VLongitudinalStringDecay &right);
+
+   int operator==(const G4VLongitudinalStringDecay &right) const;
+   int operator!=(const G4VLongitudinalStringDecay &right) const;
+
+public:
+   G4KineticTrackVector* FragmentString(const G4ExcitedString& theString);
+   G4bool FragmentString(G4KineticTrackVector* aHadrons, const G4ExcitedString* theString);
+   G4KineticTrackVector* DecayResonans (G4KineticTrackVector* aHadrons);
+
+   G4int SampleQuarkFlavor(void);
+   void  SampleQuarkPt(G4double* thePx, G4double* thePy);
+
+protected:
+   // Additional protected declarations 
+   virtual G4double GetLightConeZ(G4double zmin, G4double zmax, G4int PartonEncoding,  G4ParticleDefinition* pHadron, G4double Px, G4double Py) = 0;      
+   G4ParticleDefinition* CreateHadron(G4int id1, G4int id2, G4bool theGivenSpin, G4int theSpin); 
+   void CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector *);
+   G4ParticleDefinition* FindParticle(G4int Encoding); 
+   void Sample4Momentum(G4LorentzVector* Mom, G4double Mass, G4LorentzVector* AntiMom, G4double AntiMass, G4double InitialMass); 
+
+   // Additional Implementation Declarations
+
+private:  
+   G4double  MassCut;
+   G4double  ClusterMass;
+   G4double  SigmaQT;          // sigma_q_t is quark transverse momentum distribution parameter 
+   G4double  DiquarkSuppress;  // is Diquark suppression parameter  
+   G4double  DiquarkBreakProb; // is Diquark breaking probability 
+   G4double  SmoothParam;      // model parameter
+   G4double  StrangeSuppress ;
+   G4int     StringLoopInterrupt;
+   G4int     ClusterLoopInterrupt;
+
+   void ConstructParticle();
+};
+
+//**********************************************************************************************
+// Class G4VLongitudinalStringDecay 
+#endif
+
+
@@ -0,0 +1,43 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VNuclearDensity.hh,v 1.2 1998/10/30 16:35:21 gunter Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4VNuclearDensity_h
+#define G4VNuclearDensity_h 1
+
+#include "globals.hh"
+#include "G4ThreeVector.hh"
+
+
+class G4VNuclearDensity 
+{
+
+  public:
+    G4VNuclearDensity();
+    virtual ~G4VNuclearDensity();
+    
+    inline G4double GetDensity(G4ThreeVector aPosition)
+    {
+	return rho0*GetRelativeDensity(aPosition);
+    };
+    
+    virtual G4double GetRelativeDensity(G4ThreeVector aPosition) = 0;
+   
+    virtual G4double GetRadius(const G4double maxRelativeDenisty) = 0 ;
+
+  protected:    
+    inline void Setrho0(G4double arho0) { rho0=arho0; };
+   
+  private:
+  
+    G4double rho0;
+};
+
+#endif
+
@@ -0,0 +1,80 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VParticipants.hh,v 1.1 1998/08/22 08:55:46 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+
+#ifndef G4VParticipants_h
+#define G4VParticipants_h 1
+
+// ------------------------------------------------------------
+//      GEANT 4 class header file
+//
+//      For information related to this code contact:
+//      CERN, CN Division, ASD group
+//      ---------------- G4VParticipants ----------------
+//             by Gunter Folger, May 1998.
+//      abstract class finding participants in a hadron Nucleus collision
+//       in Parton String Models.
+// ------------------------------------------------------------
+#include "globals.hh"
+
+class G4V3DNucleus;
+
+#include "G4Fancy3DNucleus.hh"
+
+
+class G4VParticipants 
+{
+
+  public:
+      G4VParticipants();
+      G4VParticipants(const G4VParticipants &right);
+      virtual ~G4VParticipants();
+
+      const G4VParticipants & operator=(const G4VParticipants &right);
+      int operator==(const G4VParticipants &right) const;
+      int operator!=(const G4VParticipants &right) const;
+
+      void Init(G4double theZ, G4double theA);
+      
+      void SetNucleus(G4V3DNucleus * aNucleus);
+      G4V3DNucleus * GetWoundedNucleus() const;
+
+
+  protected:
+
+  
+      G4V3DNucleus *theNucleus;
+      
+  private:
+  
+};
+
+// Class G4VParticipants 
+
+inline G4V3DNucleus * G4VParticipants::GetWoundedNucleus() const
+{
+  return theNucleus;
+}
+
+inline void G4VParticipants::SetNucleus(G4V3DNucleus * aNucleus)
+{
+  theNucleus = aNucleus;
+}
+
+inline void G4VParticipants::Init(G4double theA, G4double theZ)
+{
+	if ( theNucleus == NULL ) theNucleus = new G4Fancy3DNucleus();
+	theNucleus->Init(theA, theZ);
+}
+
+
+#endif
+
+
@@ -0,0 +1,73 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VPreCompoundModel.hh,v 1.5 1998/11/13 17:27:29 larazb Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+
+#ifndef G4VPreCompoundModel_h
+#define G4VPreCompoundModel_h 1
+
+#include "G4HadronicInteraction.hh"
+#include "G4DynamicParticleVector.hh"
+class G4Track;
+class G4VParticleChange;
+class G4Nucleus;
+class G4Fragment;
+class G4ExcitationHandler;
+
+class G4VPreCompoundModel : public G4HadronicInteraction
+{
+public:
+
+  G4VPreCompoundModel(G4ExcitationHandler *const value);
+  virtual ~G4VPreCompoundModel() {};
+  
+protected:
+  // default constructor
+  G4VPreCompoundModel() {};
+private:
+  // copy constructor
+  G4VPreCompoundModel(const G4VPreCompoundModel &right) {};
+  // operators
+  const G4VPreCompoundModel& operator=(const G4VPreCompoundModel &right);
+  G4bool operator==(const G4VPreCompoundModel &right) const;
+  G4bool operator!=(const G4VPreCompoundModel &right) const;
+
+public:
+  virtual G4VParticleChange * 
+          ApplyYourself(const G4Track & thePrimary, G4Nucleus & theNucleus) = 0;
+  
+  virtual G4DynamicParticleVector* 
+          DeExcite(const G4Fragment& aFragment) const = 0;
+
+  void SetExcitationHandler(G4ExcitationHandler *const  value);
+    
+protected:
+
+  const G4ExcitationHandler * GetExcitationHandler() const;
+  
+private:
+  G4ExcitationHandler *theExcitationHandler;
+};
+
+
+
+inline const G4ExcitationHandler* G4VPreCompoundModel::GetExcitationHandler() const
+{
+  return theExcitationHandler;
+}
+
+inline void G4VPreCompoundModel::SetExcitationHandler(G4ExcitationHandler *const  value)
+{
+  theExcitationHandler = value;
+}
+
+
+
+
+#endif
@@ -0,0 +1,131 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VSplitableHadron.hh,v 1.6 1998/11/06 10:02:54 gunter Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+
+#ifndef G4VSplitableHadron_h
+#define G4VSplitableHadron_h 1
+
+// ------------------------------------------------------------
+//      GEANT 4 class header file
+//
+//      For information related to this code contact:
+//      CERN, CN Division, ASD group
+//      ---------------- G4VSplitableHadron----------------
+//             by Gunter Folger, June 1998.
+//       class storing an interacting particle. Used by Parton String Models.
+// ------------------------------------------------------------
+
+#include "globals.hh"
+class G4ParticleDefinition;
+#include "G4ParticleDefinition.hh"
+#include "G4ReactionProduct.hh"
+#include "G4Nucleon.hh"
+#include "G4ThreeVector.hh"
+#include "G4LorentzVector.hh"
+#include "G4Parton.hh"
+
+#include <rw/tpordvec.h>
+
+class G4VSplitableHadron 
+{
+
+  public:
+      G4VSplitableHadron();
+      G4VSplitableHadron(const G4ReactionProduct & aPrimary);
+      G4VSplitableHadron(const G4Nucleon & aNucleon);
+      G4VSplitableHadron(const G4VKineticNucleon * aNucleon);
+
+      virtual ~G4VSplitableHadron();
+
+
+      int operator==(const G4VSplitableHadron &right) const;
+      int operator!=(const G4VSplitableHadron &right) const;
+
+      void Set4Momentum(const G4LorentzVector &a4Momentum);
+      const G4LorentzVector & Get4Momentum() const;
+
+      void SetDefinition(G4ParticleDefinition *aDefinition);
+      G4ParticleDefinition * GetDefinition() const;
+      
+      void IncrementCollisionCount(G4int aCount);
+
+      void SetPosition(const G4ThreeVector &aPosition);
+      const G4ThreeVector & GetPosition() const;
+
+      virtual void SplitUp() = 0;
+      virtual G4Parton * GetNextParton() = 0 ;
+      virtual G4Parton * GetNextAntiParton() = 0 ;
+
+
+  protected:
+      G4int GetSoftCollisionCount();
+      
+  private:
+
+      G4VSplitableHadron(const G4VSplitableHadron &right);
+      const G4VSplitableHadron & operator=(const G4VSplitableHadron &right);
+
+  private:
+
+      G4ParticleDefinition *theDefinition;
+
+      G4LorentzVector the4Momentum;
+
+      G4ThreeVector thePosition;
+      G4int theCollisionCount;
+
+};
+
+inline G4int G4VSplitableHadron::GetSoftCollisionCount()
+{
+return theCollisionCount;
+}
+
+inline void G4VSplitableHadron::Set4Momentum(const G4LorentzVector &a4Momentum)
+{
+	the4Momentum=a4Momentum;
+}
+
+inline const G4LorentzVector & G4VSplitableHadron::Get4Momentum() const
+{
+	return the4Momentum;
+}
+
+inline void G4VSplitableHadron::SetDefinition(G4ParticleDefinition *aDefinition)
+{
+	theDefinition=aDefinition;
+}
+
+inline G4ParticleDefinition * G4VSplitableHadron::GetDefinition() const
+{
+	return theDefinition;
+}
+
+inline void G4VSplitableHadron::IncrementCollisionCount(G4int aCount)
+{
+	theCollisionCount += aCount;
+}
+
+
+inline void G4VSplitableHadron::SetPosition(const G4ThreeVector &aPosition)
+{
+	thePosition=aPosition;
+}
+
+inline const G4ThreeVector & G4VSplitableHadron::GetPosition() const
+{
+	return thePosition;
+}
+
+
+
+#endif
+
+
@@ -0,0 +1,40 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4VStringFragmentation.hh,v 1.1 1998/08/22 08:55:48 hpw Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+#ifndef G4VStringFragmentation_h
+#define G4VStringFragmentation_h 1
+
+#include "G4ExcitedString.hh"
+//GF#include "G4ReactionProductVector.hh"
+#include "G4KineticTrackVector.hh"
+
+class G4VStringFragmentation 
+{
+  public:
+      G4VStringFragmentation();
+      ~G4VStringFragmentation();
+
+  private:
+      G4VStringFragmentation(const G4VStringFragmentation &right);
+      const G4VStringFragmentation & operator=(const G4VStringFragmentation &right);
+      int operator==(const G4VStringFragmentation &right) const;
+      int operator!=(const G4VStringFragmentation &right) const;
+
+  public:
+//      virtual G4ReactionProductVector * FragmentString(const G4ExcitedString &theString)=0;
+      virtual G4KineticTrackVector * FragmentString(const G4ExcitedString &theString)=0;
+
+  private:
+
+};
+
+#endif
+
+