Import Geant4 10.5.0 source tree

source/processes/hadronic/models/parton_string/hadronization/include/G4ExcitedStringDecay.hh

@@ -24,7 +24,6 @@
 // ********************************************************************
 //
 //
-// $Id: G4ExcitedStringDecay.hh 102048 2016-12-19 09:02:38Z gcosmo $
 //
 #ifndef G4ExcitedStringDecay_h
 #define G4ExcitedStringDecay_h 1

source/processes/hadronic/models/parton_string/hadronization/include/G4FragmentingString.hh

@@ -24,7 +24,6 @@
 // ********************************************************************
 //
 //
-// $Id: G4FragmentingString.hh 107869 2017-12-07 14:46:39Z gcosmo $
 //
 
 #ifndef G4FragmentingString_h
@@ -49,7 +48,6 @@ class G4ExcitedString;
 
 class G4FragmentingString 
 {
-
   public:
      
       G4FragmentingString(const G4FragmentingString &right);
@@ -96,16 +94,15 @@ class G4FragmentingString
       G4bool    StableIsQuark();
       G4bool    FourQuarkString(void) const;
 
-G4LorentzVector   GetPstring();
-G4LorentzVector   GetPleft();
-void              SetPleft(G4LorentzVector a4momentum);
-G4LorentzVector   GetPright();
-void              SetPright(G4LorentzVector a4momentum);
-void              LorentzRotate(const G4LorentzRotation & rotation);
-G4LorentzRotation TransformToCenterOfMass();
-G4LorentzRotation TransformToAlignedCms();
-void              Boost(G4ThreeVector& Velocity);
-
+      G4LorentzVector   GetPstring();
+      G4LorentzVector   GetPleft();
+      void              SetPleft(G4LorentzVector a4momentum);
+      G4LorentzVector   GetPright();
+      void              SetPright(G4LorentzVector a4momentum);
+      void              LorentzRotate(const G4LorentzRotation & rotation);
+      G4LorentzRotation TransformToCenterOfMass();
+      G4LorentzRotation TransformToAlignedCms();
+      void              Boost(G4ThreeVector& Velocity);
 
   private:
 
@@ -164,10 +161,10 @@ void G4FragmentingString::LorentzRotate(const G4LorentzRotation & rotation)
      SetPleft(rotation*Pleft);
      SetPright(rotation*Pright);
      Pstring = Pleft+Pright;
-Ptleft =Pleft.vect();  Ptleft.setZ(0.);
-Ptright=Pright.vect(); Ptright.setZ(0.);
-Pplus =Pstring.plus();
-Pminus=Pstring.minus();
+     Ptleft =Pleft.vect();  Ptleft.setZ(0.);
+     Ptright=Pright.vect(); Ptright.setZ(0.);
+     Pplus =Pstring.plus();
+     Pminus=Pstring.minus();
 }
 
 inline
@@ -179,10 +176,10 @@ G4LorentzRotation G4FragmentingString::TransformToCenterOfMass()
      Pleft   *= toCMS;
      Pright  *= toCMS;
      Pstring *= toCMS;
-Ptleft =Pleft.vect();  Ptleft.setZ(0.);
-Ptright=Pright.vect(); Ptright.setZ(0.);
-Pplus =Pstring.plus();
-Pminus=Pstring.minus();
+     Ptleft =Pleft.vect();  Ptleft.setZ(0.);
+     Ptright=Pright.vect(); Ptright.setZ(0.);
+     Pplus =Pstring.plus();
+     Pminus=Pstring.minus();
      return toCMS;
 }
 
@@ -200,10 +197,10 @@ G4LorentzRotation G4FragmentingString::TransformToAlignedCms()
      Pright  *= toAlignedCms;
      Pstring *= toAlignedCms;
 
-Ptleft  = G4ThreeVector(0.,0.,0.);
-Ptright = G4ThreeVector(0.,0.,0.);
-Pplus  = Pstring.plus();
-Pminus = Pstring.minus();
+     Ptleft  = G4ThreeVector(0.,0.,0.);
+     Ptright = G4ThreeVector(0.,0.,0.);
+     Pplus  = Pstring.plus();
+     Pminus = Pstring.minus();
 
      return toAlignedCms;
 }

source/processes/hadronic/models/parton_string/hadronization/include/G4HadronBuilder.hh

@@ -24,7 +24,6 @@
 // ********************************************************************
 //
 //
-// $Id: G4HadronBuilder.hh 102048 2016-12-19 09:02:38Z gcosmo $
 //
 // -----------------------------------------------------------------------------
 //      GEANT 4 class header file

source/processes/hadronic/models/parton_string/hadronization/include/G4LundStringFragmentation.hh

@@ -24,7 +24,6 @@
 // ********************************************************************
 //
 //
-// $Id: G4LundStringFragmentation.hh 107869 2017-12-07 14:46:39Z gcosmo $
 //
 // -----------------------------------------------------------------------------
 //      GEANT 4 class implementation file
@@ -56,7 +55,7 @@ private:
     int operator!=(const G4LundStringFragmentation &right) const;
 
 private:
-   void SetMinMasses();   // Uzhi 23 Dec. 2016
+   void SetMinMasses();
    void SetMinimalStringMass(const G4FragmentingString  * const string);
    void SetMinimalStringMass2(const G4double aValue);	
 
@@ -89,9 +88,8 @@ private:
                                          G4ParticleDefinition *&created);
 
 private:
-   // Internal methods introduced to improve the code structure (AR Nov 2011)
 
-   G4bool Loop_toFragmentString(const G4ExcitedString & theStringInCMS, // * &
+   G4bool Loop_toFragmentString(const G4ExcitedString & theStringInCMS,
                                 G4KineticTrackVector * & LeftVector, 
                                 G4KineticTrackVector * & RightVector);
 
@@ -114,7 +112,7 @@ private:
    G4int SampleState(void); 
 
 private:
-// ------ For estimation of a minimal string mass ---------------
+   // ------ For estimation of a minimal string mass ---------------
    G4double Mass_of_light_quark;
    G4double Mass_of_heavy_quark;
    G4double Mass_of_string_junction;
@@ -122,11 +120,9 @@ private:
    G4double minMassQQbarStr[3][3];
    G4double minMassQDiQStr[3][3][3];
 
-// ------ An estimated minimal string mass ----------------------
+   // ------ An estimated minimal string mass ----------------------
    G4double MinimalStringMass;
    G4double MinimalStringMass2;
-// ------ Minimal invariant mass used at a string fragmentation -
-   G4double WminLUND;		    
 
    G4int          Meson[3][3][6];
    G4double MesonWeight[3][3][6];
@@ -136,7 +132,7 @@ private:
 
    G4double Prob_QQbar[3];
 
-// ------ To improve the code structure
+   // ------ To improve the code structure
    G4ParticleDefinition * FS_LeftHadron[35], * FS_RightHadron[35];
    G4double FS_Weight[35];
    G4int NumberOf_FS;
@@ -145,6 +141,6 @@ private:
 
 //**************************************************************************************************************
 // Class G4LundStringFragmentation 
+
 #endif
 
-

source/processes/hadronic/models/parton_string/hadronization/include/G4QGSMFragmentation.hh

@@ -24,7 +24,6 @@
 // ********************************************************************
 //
 //
-// $Id: G4QGSMFragmentation.hh 107869 2017-12-07 14:46:39Z gcosmo $
 //
 // -----------------------------------------------------------------------------
 //      GEANT 4 class implementation file
@@ -38,40 +37,60 @@
 
 //******************************************************************************
 class G4QGSMFragmentation:public G4VLongitudinalStringDecay
-   {
-public:
-      G4QGSMFragmentation();
-      ~G4QGSMFragmentation();
-      virtual G4KineticTrackVector* FragmentString(const G4ExcitedString& theString);
+{
+  public:
+    G4QGSMFragmentation();
+    ~G4QGSMFragmentation();
+    virtual G4KineticTrackVector* FragmentString(const G4ExcitedString& theString);
 
   private:
-     // not implemented to protect/forbid use
-   G4QGSMFragmentation(const G4QGSMFragmentation &right);
-   const G4QGSMFragmentation & operator=(const G4QGSMFragmentation &right);
-   int operator==(const G4QGSMFragmentation &right) const;
-   int operator!=(const G4QGSMFragmentation &right) const;
+    // not implemented to protect/forbid use
+    G4QGSMFragmentation(const G4QGSMFragmentation &right);
+    const G4QGSMFragmentation & operator=(const G4QGSMFragmentation &right);
+    int operator==(const G4QGSMFragmentation &right) const;
+    int operator!=(const G4QGSMFragmentation &right) const;
 
   private:
-   virtual G4double GetLightConeZ(G4double zmin, G4double zmax, G4int PartonEncoding,  G4ParticleDefinition* pHadron, G4double Px, G4double Py);      
+    void SetMinMasses();
+    void SetMinimalStringMass(const G4FragmentingString  * const string);
+    void SetMinimalStringMass2(const G4double aValue);	
 
-   virtual void Sample4Momentum(G4LorentzVector* Mom, G4double Mass, G4LorentzVector* AntiMom, G4double AntiMass, G4double InitialMass); 
-   virtual G4bool StopFragmenting(const G4FragmentingString  * const string);
-   virtual G4bool IsFragmentable(const G4FragmentingString * const string);
+    virtual G4bool StopFragmenting(const G4FragmentingString  * const string);
+    virtual G4bool IsFragmentable(const G4FragmentingString * const string);
 
-   virtual G4KineticTrack * Splitup(G4FragmentingString *string,              // Uzhi 28 June 2016
-                            G4FragmentingString *&newString);
+    virtual G4bool SplitLast(G4FragmentingString * string, 
+	 	             G4KineticTrackVector * LeftVector, 
+                             G4KineticTrackVector * RightVector);
 
-   virtual G4LorentzVector * SplitEandP(G4ParticleDefinition * pHadron, 
-                                        G4FragmentingString * string,     // Uzhi
-                                        G4FragmentingString * newString); // Uzhi
-   virtual G4bool SplitLast(G4FragmentingString * string, 
-		    G4KineticTrackVector * LeftVector,
-		    G4KineticTrackVector * RightVector);
+    virtual void Sample4Momentum(G4LorentzVector* Mom, G4double Mass, G4LorentzVector* AntiMom,
+                                 G4double AntiMass, G4double InitialMass); 
 
-   virtual G4ParticleDefinition * DiQuarkSplitup(G4ParticleDefinition* decay, // Uzhi June 2014
-                                         G4ParticleDefinition *&created);
+    virtual G4KineticTrack * Splitup(G4FragmentingString *string, 
+                                     G4FragmentingString *&newString);
+
+    virtual G4LorentzVector * SplitEandP(G4ParticleDefinition * pHadron, 
+                                         G4FragmentingString * string, 
+                                         G4FragmentingString * newString);
+
+    virtual G4double GetLightConeZ(G4double zmin, G4double zmax, G4int PartonEncoding, 
+                                   G4ParticleDefinition* pHadron, G4double Px, G4double Py);
+
+    virtual G4ParticleDefinition * DiQuarkSplitup(G4ParticleDefinition* decay,
+                                                  G4ParticleDefinition *&created);
 
   private:
+    // ------ For estimation of a minimal string mass ---------------
+    G4double Mass_of_light_quark;
+    G4double Mass_of_heavy_quark;
+    G4double Mass_of_string_junction;
+
+    G4double minMassQQbarStr[3][3];
+    G4double minMassQDiQStr[3][3][3];
+
+    // ------ An estimated minimal string mass ----------------------
+    G4double MinimalStringMass;
+    G4double MinimalStringMass2;
+
     // model parameters
     const G4double arho; 
     const G4double aphi;  
@@ -85,4 +104,3 @@ public:
 // Class G4QGSMFragmentation 
 #endif
 
-

source/processes/hadronic/models/parton_string/hadronization/include/G4VKinkyStringDecay.hh

@@ -24,7 +24,6 @@
 // ********************************************************************
 //
 //
-// $Id: G4VKinkyStringDecay.hh 102048 2016-12-19 09:02:38Z gcosmo $
 //  Maxim Komogorov
 //
 // -----------------------------------------------------------------------------

source/processes/hadronic/models/parton_string/hadronization/include/G4VLongitudinalStringDecay.hh

@@ -24,7 +24,6 @@
 // ********************************************************************
 //
 //
-// $Id: G4VLongitudinalStringDecay.hh 107869 2017-12-07 14:46:39Z gcosmo $
 // Maxim Komogorov
 //
 // -----------------------------------------------------------------------------
@@ -44,159 +43,155 @@ class G4FragmentingString;
 //**************************************************************************************
 
 class G4VLongitudinalStringDecay 
-   {
-public:
-            G4VLongitudinalStringDecay();     
-   virtual ~G4VLongitudinalStringDecay();
+{
+  public:
+             G4VLongitudinalStringDecay();     
+    virtual ~G4VLongitudinalStringDecay();
 
-private:
-   // not implemented to protect/forbid use
-   G4VLongitudinalStringDecay(const G4VLongitudinalStringDecay &right);
-   const G4VLongitudinalStringDecay & operator=(const G4VLongitudinalStringDecay &right);
-   int operator==(const G4VLongitudinalStringDecay &right) const;
-   int operator!=(const G4VLongitudinalStringDecay &right) const;
+  private:
+    // not implemented to protect/forbid use
+    G4VLongitudinalStringDecay(const G4VLongitudinalStringDecay &right);
+    const G4VLongitudinalStringDecay & operator=(const G4VLongitudinalStringDecay &right);
+    int operator==(const G4VLongitudinalStringDecay &right) const;
+    int operator!=(const G4VLongitudinalStringDecay &right) const;
 
-public:
-   virtual G4KineticTrackVector* FragmentString(const G4ExcitedString& theString)=0;
+  public:
+    virtual G4KineticTrackVector* FragmentString(const G4ExcitedString& theString)=0;
 
-protected: 
+  protected: 
 
-// For changing Mass Cut used for selection of very small mass strings
-   virtual void SetMassCut(G4double aValue);
-   G4double GetMassCut();
+    // For changing Mass Cut used for selection of very small mass strings
+    virtual void SetMassCut(G4double aValue);
+    G4double GetMassCut();
 
-// For handling a string with very low mass
-   G4KineticTrackVector * LightFragmentationTest(const G4ExcitedString * const theString);
+    // For handling a string with very low mass
+    G4KineticTrackVector * LightFragmentationTest(const G4ExcitedString * const theString);
 
-// To store created quarks or 2 last hadrons
-   typedef std::pair<G4ParticleDefinition*, G4ParticleDefinition*> pDefPair;
+    // To store created quarks or 2 last hadrons
+    typedef std::pair<G4ParticleDefinition*, G4ParticleDefinition*> pDefPair;
 
-// For creation of hadrons from given quark pair 
-   typedef G4ParticleDefinition * (G4HadronBuilder::*Pcreate)
-		   			(G4ParticleDefinition*, G4ParticleDefinition*);
+    // For creation of hadrons from given quark pair 
+    typedef G4ParticleDefinition * (G4HadronBuilder::*Pcreate)
+		   		     (G4ParticleDefinition*, G4ParticleDefinition*);
 
-//-----------------------------------------------------------------------------
-// Used by LightFragmentationTest for estimation of lowest possible mass of
-// given quark system
-   G4double FragmentationMass(const G4FragmentingString * const string,
-		              Pcreate build=0,
-		              pDefPair * pdefs=0);
+    // Used by LightFragmentationTest for estimation of lowest possible mass of
+    // given quark system
+    G4double FragmentationMass(const G4FragmentingString * const string,
+	 	               Pcreate build=0, pDefPair * pdefs=0);
 
-   G4ParticleDefinition* FindParticle(G4int Encoding); 
+    G4ParticleDefinition* FindParticle(G4int Encoding); 
 
-   virtual void Sample4Momentum(G4LorentzVector* Mom,     G4double Mass, 
-                                G4LorentzVector* AntiMom, G4double AntiMass, 
-                                G4double InitialMass)=0; 
-//-----------------------------------------------------------------------------
-// For decision on continue or stop string fragmentation
-   virtual G4bool StopFragmenting(const G4FragmentingString  * const string)=0;
-   virtual G4bool IsFragmentable(const G4FragmentingString * const string)=0;
+    virtual void Sample4Momentum(G4LorentzVector* Mom,     G4double Mass, 
+                                 G4LorentzVector* AntiMom, G4double AntiMass, 
+                                 G4double InitialMass)=0; 
 
-// If a string can not fragment, make last break into 2 hadrons
-   virtual G4bool SplitLast(G4FragmentingString * string, 
-		    G4KineticTrackVector * LeftVector,
-		    G4KineticTrackVector * RightVector)=0;
-//-----------------------------------------------------------------------------
+    // For decision on continue or stop string fragmentation
+    virtual G4bool StopFragmenting(const G4FragmentingString  * const string)=0;
+    virtual G4bool IsFragmentable(const G4FragmentingString * const string)=0;
 
-// If a string fragments, do the following
+    // If a string can not fragment, make last break into 2 hadrons
+    virtual G4bool SplitLast(G4FragmentingString * string, 
+	   	             G4KineticTrackVector * LeftVector,
+		             G4KineticTrackVector * RightVector)=0;
 
-// To make a copy of a string
-   G4ExcitedString *CopyExcited(const G4ExcitedString& string);
+    // If a string fragments, do the following
 
-   G4ParticleDefinition * QuarkSplitup(G4ParticleDefinition* decay,
-		   		       G4ParticleDefinition *&created);
+    // To make a copy of a string
+    G4ExcitedString *CopyExcited(const G4ExcitedString& string);
 
-   virtual G4ParticleDefinition * DiQuarkSplitup(G4ParticleDefinition* decay,
-		   			 G4ParticleDefinition *&created)=0;
+    G4ParticleDefinition * QuarkSplitup(G4ParticleDefinition* decay,
+	  	   		        G4ParticleDefinition *&created);
+
+    virtual G4ParticleDefinition * DiQuarkSplitup(G4ParticleDefinition* decay,
+		   			          G4ParticleDefinition *&created)=0;
 					
-   pDefPair CreatePartonPair(G4int NeedParticle, G4bool AllowDiquarks=true);
+    pDefPair CreatePartonPair(G4int NeedParticle, G4bool AllowDiquarks=true);
 
-public:
-//   used by G4VKinkyStringDecy..
-   G4int SampleQuarkFlavor(void);
-   G4ThreeVector SampleQuarkPt(G4double ptMax=-1.); // -1. no limit on maxpt.
+  public:
+    // used by G4VKinkyStringDecy..
+    G4int SampleQuarkFlavor(void);
+    G4ThreeVector SampleQuarkPt(G4double ptMax=-1.); // -1. no limit on maxpt.
 
-protected:
+  protected:
 
-//-----------------------------------------------------------------------------
-// For determination of kinematical properties of created hadron
-//   virtual G4LorentzVector * SplitEandP(G4ParticleDefinition * pHadron,    
-//                                        G4FragmentingString * string  )=0; 
-   virtual G4KineticTrack * Splitup(G4FragmentingString *string,              // Uzhi 28 June 2016
-                            G4FragmentingString *&newString)=0;
+    // For determination of kinematical properties of created hadron
+    // virtual G4LorentzVector * SplitEandP(G4ParticleDefinition * pHadron,    
+    //                                      G4FragmentingString * string  )=0; 
+    virtual G4KineticTrack * Splitup(G4FragmentingString *string,
+                                     G4FragmentingString *&newString)=0;
 
-   virtual G4LorentzVector * SplitEandP(G4ParticleDefinition * pHadron,      
-                                        G4FragmentingString * string,        
-                                        G4FragmentingString * newString  )=0;
+    virtual G4LorentzVector * SplitEandP(G4ParticleDefinition * pHadron,      
+                                         G4FragmentingString * string,        
+                                         G4FragmentingString * newString  )=0;
 
-   virtual G4double GetLightConeZ(G4double zmin, G4double zmax, 
-                                  G4int PartonEncoding,  
-                                  G4ParticleDefinition* pHadron, 
-                                  G4double Px, G4double Py       ) = 0;      
+    virtual G4double GetLightConeZ(G4double zmin, G4double zmax, 
+                                   G4int PartonEncoding,  
+                                   G4ParticleDefinition* pHadron, 
+                                   G4double Px, G4double Py       ) = 0;      
 
-   void CalculateHadronTimePosition(G4double theInitialStringMass, 
-                                    G4KineticTrackVector *);
+    void CalculateHadronTimePosition(G4double theInitialStringMass, 
+                                     G4KineticTrackVector *);
 
-// Used for some test purposes ------------------------------------------------ 
-   void ConstructParticle();
+    // Used for some test purposes 
+    void ConstructParticle();
 
-   G4ParticleDefinition* CreateHadron(G4int id1, G4int id2, 
-                                      G4bool theGivenSpin, G4int theSpin); 
+    G4ParticleDefinition* CreateHadron(G4int id1, G4int id2, 
+                                       G4bool theGivenSpin, G4int theSpin); 
+
+  public:
+
+    G4KineticTrackVector* DecayResonans (G4KineticTrackVector* aHadrons);
+
+    void SetSigmaTransverseMomentum(G4double aQT);
+    void SetStrangenessSuppression(G4double aValue);
+    void SetDiquarkSuppression(G4double aValue);
+    void SetDiquarkBreakProbability(G4double aValue);
+
+    void SetVectorMesonProbability(G4double aValue);
+    void SetSpinThreeHalfBarionProbability(G4double aValue);
    
-//-----------------------------------------------------------------------------
-public:
+    void SetScalarMesonMixings( std::vector<G4double> aVector);
+    void SetVectorMesonMixings( std::vector<G4double> aVector);
 
-   G4KineticTrackVector* DecayResonans (G4KineticTrackVector* aHadrons);
+    void SetStringTensionParameter(G4double aValue);            
 
-   void SetSigmaTransverseMomentum(G4double aQT);
-   void SetStrangenessSuppression(G4double aValue);
-   void SetDiquarkSuppression(G4double aValue);
-   void SetDiquarkBreakProbability(G4double aValue);
+    // G4LorentzVector RestMomentum;
 
-   void SetVectorMesonProbability(G4double aValue);
-   void SetSpinThreeHalfBarionProbability(G4double aValue);
+  //private:
+  protected:  
+    G4double GetDiquarkSuppress()	{return DiquarkSuppress;};
+    G4double GetDiquarkBreakProb()	{return DiquarkBreakProb;};
+    G4double GetStrangeSuppress()	{return StrangeSuppress;};
+    G4double GetClusterMass()		{return ClusterMass;};
+    G4int    GetClusterLoopInterrupt()   {return ClusterLoopInterrupt;};
+
+    G4double GetStringTensionParameter() {return Kappa;};
    
-   void SetScalarMesonMixings( std::vector<G4double> aVector);
-   void SetVectorMesonMixings( std::vector<G4double> aVector);
+  //private:
+  protected:  
+    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;
+    G4HadronBuilder *hadronizer;
 
-   void SetStringTensionParameter(G4double aValue);            
-
-//   G4LorentzVector RestMomentum;                 // Uzhi June 2016
-//private:
-protected:  
-   G4double GetDiquarkSuppress()	{return DiquarkSuppress;};
-   G4double GetDiquarkBreakProb()	{return DiquarkBreakProb;};
-   G4double GetStrangeSuppress()	{return StrangeSuppress;};
-   G4double GetClusterMass()		{return ClusterMass;};
-   G4int    GetClusterLoopInterrupt()   {return ClusterLoopInterrupt;};
-
-   G4double GetStringTensionParameter() {return Kappa;};
+    G4double pspin_meson;
+    G4double pspin_barion;
+    std::vector<G4double> vectorMesonMix;
+    std::vector<G4double> scalarMesonMix;
    
-//private:
-protected:  
-   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;
-   G4HadronBuilder *hadronizer;
+    G4bool    PastInitPhase;
 
-   G4double pspin_meson;
-   G4double pspin_barion;
-   std::vector<G4double> vectorMesonMix;
-   std::vector<G4double> scalarMesonMix;
-   
-   G4bool    PastInitPhase;
+    G4double Kappa; // String tension parameter
 
-   G4double Kappa; // String tension parameter
-
-//   G4double MinFragmentationMass(G4ExcitedString * theString,
-//				G4ParticleDefinition*& Hadron1,
-//				G4ParticleDefinition*& Hadron2);
+    // G4double MinFragmentationMass(G4ExcitedString * theString,
+    //				    G4ParticleDefinition*& Hadron1,
+    //				    G4ParticleDefinition*& Hadron2);
 
 };