Changeset 962 for trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4VLongitudinalStringDecay.cc

Timestamp:

Apr 6, 2009, 12:30:29 PM (15 years ago)

Author:

garnier

Message:

update processes

File:

• trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4VLongitudinalStringDecay.cc (modified) (15 diffs)

trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4VLongitudinalStringDecay.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4VLongitudinalStringDecay.cc,v 1.8 2007/04/24 14:55:23 gunter Exp $
-// GEANT4 tag $Name: geant4-09-01-patch-02 $
+// $Id: G4VLongitudinalStringDecay.cc,v 1.13 2008/06/23 08:35:55 vuzhinsk Exp $
+// GEANT4 tag $Name: geant4-09-02-ref-02 $
 //
 // -----------------------------------------------------------------------------
@@ -75 +75 @@
    
    StrangeSuppress  = 0.44;    //  27 % strange quarks produced, ie. u:d:s=1:1:0.27
-   DiquarkSuppress  = 0.1;
+   DiquarkSuppress  = 0.07;
    DiquarkBreakProb = 0.1;
    
@@ -106 +106 @@
    hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
                                 scalarMesonMix,vectorMesonMix);
+   Kappa = 1.0 * GeV/fermi;
+
+
 }
    
@@ -114 +117 @@
    }
 
-//=============================================================================================-------------
+//=============================================================================
 
 // Operators
@@ -122 +125 @@
 //    }
 
-//----------------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
 
 int G4VLongitudinalStringDecay::operator==(const G4VLongitudinalStringDecay &) const
@@ -130 +133 @@
     }
 
-//----------------------------------------------------------------------------------------------------------
+//-------------------------------------------------------------------------------------
 
 int G4VLongitudinalStringDecay::operator!=(const G4VLongitudinalStringDecay &) const
@@ -138 +141 @@
     }
 
-//==========================================================================================================
+//***********************************************************************************
+
+// For changing Mass Cut used for selection of very small mass strings
+void G4VLongitudinalStringDecay::SetMassCut(G4double aValue){MassCut=aValue;}
+
+//-----------------------------------------------------------------------------
+
+// For handling a string with very low mass
+
+G4KineticTrackVector* G4VLongitudinalStringDecay::LightFragmentationTest(const
+                G4ExcitedString * const string)
+{
+   // Check string decay threshold
+                
+        G4KineticTrackVector * result=0;  // return 0 when string exceeds the mass cut
+        
+        pDefPair hadrons((G4ParticleDefinition *)0,(G4ParticleDefinition *)0);
+
+        G4FragmentingString aString(*string);
+
+        if ( sqr(FragmentationMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
+                return 0;
+        }
+
+// The string mass is very low ---------------------------
+        
+        result=new G4KineticTrackVector;
+        
+        if ( hadrons.second ==0 )
+        {
+// Substitute string by light hadron, Note that Energy is not conserved here!
+
+/*               
+#ifdef DEBUG_LightFragmentationTest
+               G4cout << "VlongSF Warning replacing string by single hadron " <<G4endl;
+               G4cout << hadrons.first->GetParticleName() 
+                      << "string .. " << string->Get4Momentum() << " " 
+                      << string->Get4Momentum().m() << G4endl;
+#endif                
+G4cout << "VlongSF Warning replacing string by single hadron " <<G4endl;
+G4cout << hadrons.first->GetParticleName() << " string .. " <<G4endl;
+G4cout << string->Get4Momentum() << " " << string->Get4Momentum().m() << G4endl;
+*/
+               G4ThreeVector   Mom3 = string->Get4Momentum().vect();
+               G4LorentzVector Mom(Mom3, 
+                                   std::sqrt(Mom3.mag2() + 
+                                             sqr(hadrons.first->GetPDGMass())));
+               result->push_back(new G4KineticTrack(hadrons.first, 0, 
+                                                  string->GetPosition(),
+                                                          Mom));
+        } else 
+        {
+//... string was qq--qqbar type: Build two stable hadrons,
+
+#ifdef DEBUG_LightFragmentationTest
+               G4cout << "VlongSF Warning replacing qq-qqbar string by TWO hadrons " 
+                      << hadrons.first->GetParticleName() << " / " 
+                      << hadrons.second->GetParticleName()
+                      << "string .. " << string->Get4Momentum() << " " 
+                      << string->Get4Momentum().m() << G4endl;
+#endif                
+
+// Uzhi Formation time in the case???
+
+               G4LorentzVector  Mom1, Mom2;
+               Sample4Momentum(&Mom1, hadrons.first->GetPDGMass(), 
+                               &Mom2,hadrons.second->GetPDGMass(),
+                               string->Get4Momentum().mag());
+
+               result->push_back(new G4KineticTrack(hadrons.first, 0, 
+                                                    string->GetPosition(), 
+                                                            Mom1));
+               result->push_back(new G4KineticTrack(hadrons.second, 0, 
+                                                    string->GetPosition(), 
+                                                    Mom2));
+
+               G4ThreeVector Velocity = string->Get4Momentum().boostVector();
+               result->Boost(Velocity);          
+        }
+
+        return result;
+        
+}
+
+//----------------------------------------------------------------------------------------
+
+G4double G4VLongitudinalStringDecay::FragmentationMass(
+            const G4FragmentingString * const string,
+                Pcreate build, pDefPair * pdefs       )
+{
+        
+        G4double mass;
+        static G4bool NeedInit(true);
+        static std::vector<double> nomix;
+        static G4HadronBuilder * minMassHadronizer;
+        if ( NeedInit ) 
+        {
+           NeedInit = false;
+           nomix.resize(6);
+           for ( G4int i=0; i<6 ; i++ ) nomix[i]=0;
+
+//         minMassHadronizer=new G4HadronBuilder(pspin_meson,pspin_barion,nomix,nomix);
+           minMassHadronizer=hadronizer;
+        }
+
+        if ( build==0 ) build=&G4HadronBuilder::BuildLowSpin;
+
+        G4ParticleDefinition *Hadron1, *Hadron2=0;
+
+        if (!string->FourQuarkString() )
+        {
+           // spin 0 meson or spin 1/2 barion will be built
+
+           Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
+                                                 string->GetRightParton());
+           mass= (Hadron1)->GetPDGMass();
+        } else
+        {
+           //... string is qq--qqbar: Build two stable hadrons,
+           //...    with extra uubar or ddbar quark pair
+           G4int iflc = (G4UniformRand() < 0.5)? 1 : 2;
+           if (string->GetLeftParton()->GetPDGEncoding() < 0) iflc = -iflc;
+
+           //... theSpin = 4; spin 3/2 baryons will be built
+           Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
+                                                 FindParticle(iflc)       );
+           Hadron2 = (minMassHadronizer->*build)(string->GetRightParton(),
+                                                 FindParticle(-iflc)      );
+           mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
+        }
+        
+        if ( pdefs != 0 ) 
+        { // need to return hadrons as well....
+           pdefs->first  = Hadron1;
+           pdefs->second = Hadron2;
+        }
+           
+        return mass;
+}
+
+//----------------------------------------------------------------------------
+
+G4ParticleDefinition* G4VLongitudinalStringDecay::FindParticle(G4int Encoding) 
+   {
+   G4ParticleDefinition* ptr = G4ParticleTable::GetParticleTable()->FindParticle(Encoding);
+      if (ptr == NULL)
+       {
+       G4cout << "Particle with encoding "<<Encoding<<" does not exist!!!"<<G4endl;
+       throw G4HadronicException(__FILE__, __LINE__, "Check your particle table");
+       }
+   return ptr;    
+   }
+
+//-----------------------------------------------------------------------------
+//   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;
+
+//   If a string can not fragment, make last break into 2 hadrons
+//   virtual G4bool SplitLast(G4FragmentingString * string, 
+//                            G4KineticTrackVector * LeftVector,
+//                            G4KineticTrackVector * RightVector)=0;
+//-----------------------------------------------------------------------------
+//
+//   If a string fragments, do the following
+//
+//   For transver of a string to its CMS frame
+//-----------------------------------------------------------------------------
+
+G4ExcitedString *G4VLongitudinalStringDecay::CPExcited(const G4ExcitedString & in)
+{
+        G4Parton *Left=new G4Parton(*in.GetLeftParton());
+        G4Parton *Right=new G4Parton(*in.GetRightParton());
+        return new G4ExcitedString(Left,Right,in.GetDirection());
+}
+
+//-----------------------------------------------------------------------------
+
+G4KineticTrack * G4VLongitudinalStringDecay::Splitup(
+                        G4FragmentingString *string, 
+                        G4FragmentingString *&newString)
+{
+//G4cout<<"In G4VLong String Dec######################"<<G4endl;
+
+       //... random choice of string end to use for creating the hadron (decay)   
+       SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
+       if (SideOfDecay < 0)
+       {
+          string->SetLeftPartonStable();
+       } else
+       {
+          string->SetRightPartonStable();
+       }
+
+       G4ParticleDefinition *newStringEnd;
+       G4ParticleDefinition * HadronDefinition;
+       if (string->DecayIsQuark())
+       {
+           HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
+       } else {
+           HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
+       }      
+// create new String from old, ie. keep Left and Right order, but replace decay
+
+       newString=new G4FragmentingString(*string,newStringEnd); // To store possible
+                                                                // quark containt of new string
+       G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
+
+       delete newString; newString=0;                          // Uzhi 20.06.08
+        
+       G4KineticTrack * Hadron =0;
+       if ( HadronMomentum != 0 ) {    
+
+           G4ThreeVector   Pos;
+           Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
+ 
+           newString=new G4FragmentingString(*string,newStringEnd,
+                                        HadronMomentum);
+
+//G4cout<<"Out G4VLong String Dec######################"<<G4endl;          
+//G4cout<<"newString 4Mom"<<newString->Get4Momentum()<<G4endl;
+//G4cout<<"newString Pl  "<<newString->LightConePlus()<<G4endl;
+//G4cout<<"newString Mi  "<<newString->LightConeMinus()<<G4endl;
+//G4cout<<"newString Pts "<<newString->StablePt()<<G4endl;
+//G4cout<<"newString Ptd "<<newString->DecayPt()<<G4endl;
+//G4cout<<"newString M2  "<<newString->Mass2()<<G4endl;
+//G4cout<<"newString M2  "<<newString->Mass()<<G4endl;
+           delete HadronMomentum;
+       }      
+       return Hadron;
+}
+
+//--------------------------------------------------------------------------------------
+
+G4ParticleDefinition *
+                G4VLongitudinalStringDecay::QuarkSplitup(G4ParticleDefinition*
+                decay, G4ParticleDefinition *&created)
+{
+    G4int IsParticle=(decay->GetPDGEncoding()>0) ? -1 : +1; // if we have a quark, 
+                                                            // we need antiquark 
+                                                            // (or diquark)
+    pDefPair QuarkPair = CreatePartonPair(IsParticle);
+    created = QuarkPair.second;
+    return hadronizer->Build(QuarkPair.first, decay);
+    
+}
+
+//-----------------------------------------------------------------------------
+
+G4ParticleDefinition *G4VLongitudinalStringDecay::DiQuarkSplitup(
+                                                        G4ParticleDefinition* decay,
+                                                        G4ParticleDefinition *&created)
+{
+   //... can Diquark break or not? 
+   if (G4UniformRand() < DiquarkBreakProb ){
+   //... Diquark break
+
+      G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
+      G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
+      if (G4UniformRand() < 0.5)
+         {
+         G4int Swap = stableQuarkEncoding;
+         stableQuarkEncoding = decayQuarkEncoding;
+         decayQuarkEncoding = Swap;
+         }
+
+      G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1; 
+                        // if we have a quark, we need antiquark)
+      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
+      //... Build new Diquark
+      G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
+      G4int i10  = std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
+      G4int i20  = std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
+      G4int spin = (i10 != i20 && G4UniformRand() <= 0.5)? 1 : 3;
+      G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
+      created = FindParticle(NewDecayEncoding);
+      G4ParticleDefinition * decayQuark=FindParticle(decayQuarkEncoding);
+      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decayQuark);
+      return had;
+//      return hadronizer->Build(QuarkPair.first, decayQuark);
+   
+   } else {
+   //... Diquark does not break
+ 
+      G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1; 
+                        // if we have a diquark, we need quark)
+      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
+      created = QuarkPair.second;
+
+      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
+      return had;
+//      return G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
+   }
+}
+
+//-----------------------------------------------------------------------------
 
 G4int G4VLongitudinalStringDecay::SampleQuarkFlavor(void)
@@ -145 +449 @@
    }
 
-//----------------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
 
 G4VLongitudinalStringDecay::pDefPair G4VLongitudinalStringDecay::CreatePartonPair(G4int NeedParticle,G4bool AllowDiquarks)
@@ -170 +474 @@
 }
 
-//----------------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
 
 // G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt()
@@ -180 +484 @@
 //    return G4ThreeVector(Pt * std::cos(phi),Pt * std::sin(phi),0);
 //    }
+
 G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt()
    {
@@ -188 +493 @@
    }
 
-//----------------------------------------------------------------------------------------------------------
+//******************************************************************************
 
 void G4VLongitudinalStringDecay::CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector* Hadrons)
    {
+
    // `yo-yo` formation time
-   const G4double kappa = 1.0 * GeV/fermi;
+//   const G4double kappa = 1.0 * GeV/fermi/4.;      // Uzhi String tension 1.06.08
+     G4double kappa = GetStringTensionParameter();
+//G4cout<<"Kappa "<<kappa<<G4endl;                   // Uzhi 20.06.08
+//G4int Uzhi; G4cin>>Uzhi;                           // Uzhi 20.06.08
    for(size_t c1 = 0; c1 < Hadrons->size(); c1++)
       {
@@ -211 +520 @@
    }
 
-//----------------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
 
 /*
@@ -237 +546 @@
 */
 
+
+//*****************************************************************************
+
+void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum(G4double aValue)
+{
+        if ( PastInitPhase ) {
+                throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
+        } else {
+                SigmaQT = aValue;
+        }
+}
+
 //----------------------------------------------------------------------------------------------------------
 
-G4ParticleDefinition *
-                G4VLongitudinalStringDecay::QuarkSplitup(G4ParticleDefinition*
-                decay, G4ParticleDefinition *&created)
-{
-    G4int IsParticle=(decay->GetPDGEncoding()>0) ? -1 : +1; // if we have a quark, we need antiquark (or diquark)
-    pDefPair QuarkPair = CreatePartonPair(IsParticle);
-    created = QuarkPair.second;
-    return hadronizer->Build(QuarkPair.first, decay);
-    
+void G4VLongitudinalStringDecay::SetStrangenessSuppression(G4double aValue)
+{
+        if ( PastInitPhase ) {
+                throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetStrangenessSuppression after FragmentString() not allowed");
+        } else {
+                StrangeSuppress = aValue;
+        }
 }
 
 //----------------------------------------------------------------------------------------------------------
 
-G4ParticleDefinition *G4VLongitudinalStringDecay::DiQuarkSplitup(
-                                                        G4ParticleDefinition* decay,
-                                                        G4ParticleDefinition *&created)
-{
-   //... can Diquark break or not? 
-   if (G4UniformRand() < DiquarkBreakProb ){
-   //... Diquark break
-
-      G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
-      G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
-      if (G4UniformRand() < 0.5)
-         {
-         G4int Swap = stableQuarkEncoding;
-         stableQuarkEncoding = decayQuarkEncoding;
-         decayQuarkEncoding = Swap;
-         }
-
-      G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1; 
-                        // if we have a quark, we need antiquark)
-      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
-      //... Build new Diquark
-      G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
-      G4int i10  = std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
-      G4int i20  = std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
-      G4int spin = (i10 != i20 && G4UniformRand() <= 0.5)? 1 : 3;
-      G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
-      created = FindParticle(NewDecayEncoding);
-      G4ParticleDefinition * decayQuark=FindParticle(decayQuarkEncoding);
-      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decayQuark);
-      return had;
-//      return hadronizer->Build(QuarkPair.first, decayQuark);
-   
-   } else {
-   //... Diquark does not break
- 
-      G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1; 
-                        // if we have a diquark, we need quark)
-      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
-      created = QuarkPair.second;
-
-      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
-      return had;
-//      return G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
-   }
-}
-
-//-----------------------------------------------------------------------------------------
-
-G4KineticTrack * G4VLongitudinalStringDecay::Splitup(
-                        G4FragmentingString *string, 
-                        G4FragmentingString *&newString)
-{
-
-       //... random choice of string end to use for creating the hadron (decay)   
-       SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
-       if (SideOfDecay < 0)
-       {
-          string->SetLeftPartonStable();
-       } else
-       {
-          string->SetRightPartonStable();
-       }
-
-       G4ParticleDefinition *newStringEnd;
-       G4ParticleDefinition * HadronDefinition;
-       if (string->DecayIsQuark())
-       {
-           HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
-       } else {
-           HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
-       }      
-// create new String from old, ie. keep Left and Right order, but replace decay
-       G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string);
-        
-       G4KineticTrack * Hadron =0;
-       if ( HadronMomentum != 0 ) {    
-
-           G4ThreeVector   Pos;
-           Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
- 
-           newString=new G4FragmentingString(*string,newStringEnd,
-                                        HadronMomentum);
-           
-           delete HadronMomentum;
-       }      
-       return Hadron;
-}
-
-//----------------------------------------------------------------------------------------------------------
-
-G4ExcitedString *G4VLongitudinalStringDecay::CPExcited(const G4ExcitedString & in)
-{
-        G4Parton *Left=new G4Parton(*in.GetLeftParton());
-        G4Parton *Right=new G4Parton(*in.GetRightParton());
-        return new G4ExcitedString(Left,Right,in.GetDirection());
-}
-
-G4double G4VLongitudinalStringDecay::FragmentationMass(
-                const G4FragmentingString *
-                const string,
-                Pcreate build,
-                pDefPair * pdefs)
-{
-        
-        G4double mass;
-        static G4bool NeedInit(true);
-        static std::vector<double> nomix;
-        static G4HadronBuilder * minMassHadronizer;
-        if ( NeedInit ) 
-        {
-           NeedInit = false;
-           nomix.resize(6);
-           for ( G4int i=0; i<6 ; i++ ) nomix[i]=0;
-//         minMassHadronizer=new G4HadronBuilder(pspin_meson,pspin_barion,nomix,nomix);
-           minMassHadronizer=hadronizer;
-        }
-
-        if ( build==0 ) build=&G4HadronBuilder::BuildLowSpin;
-
-        G4ParticleDefinition *Hadron1, *Hadron2=0;
-
-        if (!string->FourQuarkString() )
-        {
-           // spin 0 meson or spin 1/2 barion will be built
-
-           Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
-                                      string->GetRightParton());
-           mass= (Hadron1)->GetPDGMass();
-        } else
-        {
-           //... string is qq--qqbar: Build two stable hadrons,
-           //...    with extra uubar or ddbar quark pair
-           G4int iflc = (G4UniformRand() < 0.5)? 1 : 2;
-           if (string->GetLeftParton()->GetPDGEncoding() < 0) iflc = -iflc;
-
-           //... theSpin = 4; spin 3/2 baryons will be built
-           Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),FindParticle(iflc));
-           Hadron2 =(minMassHadronizer->*build)(string->GetRightParton(),FindParticle(-iflc));
-           mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
-        }
-        
-        if ( pdefs != 0 ) 
-        { // need to return hadrons as well....
-           pdefs->first  = Hadron1;
-           pdefs->second = Hadron2;
-        }
-           
-        return mass;
-}
-
-G4KineticTrackVector* G4VLongitudinalStringDecay::LightFragmentationTest(const
-                G4ExcitedString * const string)
-{
-   // Check string decay threshold
-                
-        G4KineticTrackVector * result=0;  // return 0 when string exceeds the mass cut
-        
-        pDefPair hadrons((G4ParticleDefinition *)0,(G4ParticleDefinition *)0);
-        G4FragmentingString aString(*string);
-        if ( sqr(FragmentationMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
-                return 0;
-        }
-        
-        result=new G4KineticTrackVector;
-        
-        if ( hadrons.second ==0 )
-        {
-                 // Substitute string by light hadron, Note that Energy is not conserved here!
-                 
-#ifdef DEBUG_LightFragmentationTest
-               G4cout << "VlongSF Warning replacing string by single hadron " 
-                      << hadrons.first->GetParticleName() 
-                      << "string .. " << string->Get4Momentum() << " " 
-                      << string->Get4Momentum().m() << G4endl;
-#endif                
-
-               G4ThreeVector Mom3 = string->Get4Momentum().vect();
-               G4LorentzVector Mom(Mom3, 
-                                   std::sqrt(Mom3.mag2() + sqr(hadrons.first->GetPDGMass())));
-               result->push_back(new G4KineticTrack(hadrons.first, 0, string->GetPosition(), Mom));
-        } else 
-        {
-           //... string was qq--qqbar type: Build two stable hadrons,
-
-#ifdef DEBUG_LightFragmentationTest
-               G4cout << "VlongSF Warning replacing qq-qqbar string by TWO hadrons " 
-                      << hadrons.first->GetParticleName() << " / " 
-                      << hadrons.second->GetParticleName()
-                      << "string .. " << string->Get4Momentum() << " " 
-                      << string->Get4Momentum().m() << G4endl;
-#endif                
-
-               G4LorentzVector  Mom1, Mom2;
-               Sample4Momentum(&Mom1, hadrons.first->GetPDGMass(), 
-                               &Mom2,hadrons.second->GetPDGMass(),
-                                string->Get4Momentum().mag());
-               result->push_back(new G4KineticTrack(hadrons.first, 0, string->GetPosition(), Mom1));
-               result->push_back(new G4KineticTrack(hadrons.second, 0, string->GetPosition(), Mom2));
-               G4ThreeVector Velocity = string->Get4Momentum().boostVector();
-               result->Boost(Velocity);          
-        }
-
-        return result;
-        
-}
-
-//----------------------------------------------------------------------------------------------------------
-
-G4ParticleDefinition* G4VLongitudinalStringDecay::FindParticle(G4int Encoding) 
-   {
-   G4ParticleDefinition* ptr = G4ParticleTable::GetParticleTable()->FindParticle(Encoding);
-      if (ptr == NULL)
-       {
-       G4cout << "Particle with encoding "<<Encoding<<" does not exist!!!"<<G4endl;
-       throw G4HadronicException(__FILE__, __LINE__, "Check your particle table");
-       }
-   return ptr;    
-   }
-
-//----------------------------------------------------------------------------------------------------------
-
-void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum(G4double aValue)
-{
-        if ( PastInitPhase ) {
-                throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
-        } else {
-                SigmaQT = aValue;
-        }
-}
-
-//----------------------------------------------------------------------------------------------------------
-
-void G4VLongitudinalStringDecay::SetStrangenessSuppression(G4double aValue)
-{
-        if ( PastInitPhase ) {
-                throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetStrangenessSuppression after FragmentString() not allowed");
-        } else {
-                StrangeSuppress = aValue;
-        }
-}
-
-//----------------------------------------------------------------------------------------------------------
-
 void G4VLongitudinalStringDecay::SetDiquarkSuppression(G4double aValue)
 {
@@ -503 +579 @@
         }
 }
+
+//----------------------------------------------------------------------------------------
 
 void G4VLongitudinalStringDecay::SetDiquarkBreakProbability(G4double aValue)
@@ -582 +660 @@
   
         }
+}
+
+//-------------------------------------------------------------------------------------------
+void G4VLongitudinalStringDecay::SetStringTensionParameter(G4double aValue)// Uzhi 20 June 08
+{
+          Kappa = aValue * GeV/fermi;
 }       
-//*******************************************************************************************************
+//**************************************************************************************
+