#include <G4QGSMFragmentation.hh>

Inheritance diagram for G4QGSMFragmentation:

Collaboration diagram for G4QGSMFragmentation:

Public Member Functions
	G4QGSMFragmentation ()

	~G4QGSMFragmentation ()

virtual G4KineticTrackVector *	FragmentString (const G4ExcitedString &theString)

Public Member Functions inherited from G4VLongitudinalStringDecay
	G4VLongitudinalStringDecay ()

virtual	~G4VLongitudinalStringDecay ()

G4int	SampleQuarkFlavor (void)

G4ThreeVector	SampleQuarkPt (G4double ptMax=-1.)

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)

void	SetScalarMesonMixings (std::vector< G4double > aVector)

void	SetVectorMesonMixings (std::vector< G4double > aVector)

void	SetStringTensionParameter (G4double aValue)

Private Member Functions
	G4QGSMFragmentation (const G4QGSMFragmentation &right)

const G4QGSMFragmentation &	operator= (const G4QGSMFragmentation &right)

int	operator== (const G4QGSMFragmentation &right) const

int	operator!= (const G4QGSMFragmentation &right) const

virtual G4double	GetLightConeZ (G4double zmin, G4double zmax, G4int PartonEncoding, G4ParticleDefinition *pHadron, G4double Px, G4double Py)

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 G4LorentzVector *	SplitEandP (G4ParticleDefinition pHadron, G4FragmentingString string, G4FragmentingString *newString)

virtual G4bool	SplitLast (G4FragmentingString string, G4KineticTrackVector LeftVector, G4KineticTrackVector *RightVector)

virtual G4ParticleDefinition *	DiQuarkSplitup (G4ParticleDefinition decay, G4ParticleDefinition &created)

Private Attributes
const G4double	arho

const G4double	aphi

const G4double	an

const G4double	ala

const G4double	aksi

const G4double	alft

Additional Inherited Members
Protected Types inherited from G4VLongitudinalStringDecay
typedef std::pair< G4ParticleDefinition , G4ParticleDefinition >	pDefPair

typedef G4ParticleDefinition (G4HadronBuilder::	Pcreate) (G4ParticleDefinition , G4ParticleDefinition )

Protected Member Functions inherited from G4VLongitudinalStringDecay
virtual void	SetMassCut (G4double aValue)

G4KineticTrackVector *	LightFragmentationTest (const G4ExcitedString *const theString)

G4double	FragmentationMass (const G4FragmentingString const string, Pcreate build=0, pDefPair pdefs=0)

G4ParticleDefinition *	FindParticle (G4int Encoding)

G4ExcitedString *	CPExcited (const G4ExcitedString &string)

G4KineticTrack *	Splitup (G4FragmentingString string, G4FragmentingString &newString)

G4ParticleDefinition *	QuarkSplitup (G4ParticleDefinition decay, G4ParticleDefinition &created)

pDefPair	CreatePartonPair (G4int NeedParticle, G4bool AllowDiquarks=true)

void	CalculateHadronTimePosition (G4double theInitialStringMass, G4KineticTrackVector *)

void	ConstructParticle ()

G4ParticleDefinition *	CreateHadron (G4int id1, G4int id2, G4bool theGivenSpin, G4int theSpin)

G4double	GetDiquarkSuppress ()

G4double	GetDiquarkBreakProb ()

G4double	GetStrangeSuppress ()

G4double	GetClusterMass ()

G4int	GetClusterLoopInterrupt ()

G4double	GetStringTensionParameter ()

Protected Attributes inherited from G4VLongitudinalStringDecay
G4double	MassCut

G4double	ClusterMass

G4double	SigmaQT

G4double	DiquarkSuppress

G4double	DiquarkBreakProb

G4double	SmoothParam

G4double	StrangeSuppress

G4int	StringLoopInterrupt

G4int	ClusterLoopInterrupt

G4HadronBuilder *	hadronizer

G4double	pspin_meson

G4double	pspin_barion

std::vector< G4double >	vectorMesonMix

std::vector< G4double >	scalarMesonMix

G4bool	PastInitPhase

G4double	Kappa

Detailed Description

Definition at line 40 of file G4QGSMFragmentation.hh.

Constructor & Destructor Documentation

◆ G4QGSMFragmentation() [1/2]

G4QGSMFragmentation::G4QGSMFragmentation ( )

Definition at line 49 of file G4QGSMFragmentation.cc.

                                          :
 arho(0.5), aphi(0.), an(-0.5), ala(-0.75), aksi(-1.), alft(0.5)
    {
     SetStrangenessSuppression(0.41); // 0.47 0.447                        Uzhi 27.09.2014 0.43 last 0.425
     SetDiquarkSuppression(0.25);      // 0.087    std 0.07                Uzhi 0.25 Last
     SetDiquarkBreakProbability(0.4); // 0.05     std 0.1                  Uzhi 27.09.2014
    }

Here is the call graph for this function:

◆ ~G4QGSMFragmentation()

G4QGSMFragmentation::~G4QGSMFragmentation ( )

Definition at line 57 of file G4QGSMFragmentation.cc.

58 {

59 }

◆ G4QGSMFragmentation() [2/2]

G4QGSMFragmentation::G4QGSMFragmentation ( const G4QGSMFragmentation & right )

private

Member Function Documentation

◆ DiQuarkSplitup()

G4ParticleDefinition * G4QGSMFragmentation::DiQuarkSplitup	(	G4ParticleDefinition *	decay,
		G4ParticleDefinition *&	created
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 582 of file G4QGSMFragmentation.cc.

 {
    //... 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)
 
       G4double StrSup=GetStrangeSuppress();  // for changing s-sbar production, Uzhi Oct. 2014
       StrangeSuppress=0.41;                          // was 0.47
       pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
       StrangeSuppress=StrSup;
 
       //... 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)
       G4double StrSup=GetStrangeSuppress();  // for changing s-sbar production, Uzhi Oct. 2014
       StrangeSuppress=0.41; //0.41; 0.47
       pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
       StrangeSuppress=StrSup;
 
       created = QuarkPair.second;
 
       G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
       return had;
 //      return G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
    }
 }

Here is the call graph for this function:

◆ FragmentString()

G4KineticTrackVector * G4QGSMFragmentation::FragmentString ( const G4ExcitedString & theString )

virtual

Implements G4VLongitudinalStringDecay.

Definition at line 63 of file G4QGSMFragmentation.cc.

 {
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<G4endl<<"QGSM StringFragm: String Mass "
                              <<theString.Get4Momentum().mag()<<" Pz "
                              <<theString.Get4Momentum().pz()
                              <<"------------------------------------"<<G4endl;
   G4cout<<"String ends Direct "<<theString.GetLeftParton()->GetPDGcode()<<" "
                                <<theString.GetRightParton()->GetPDGcode()<<" "
                                <<theString.GetDirection()<< G4endl;
   G4cout<<"Left  mom "<<theString.GetLeftParton()->Get4Momentum()<<G4endl;
   G4cout<<"Right mom "<<theString.GetRightParton()->Get4Momentum()<<G4endl;
   G4cout<<"Check for Fragmentation "<<G4endl;
 #endif
 
 //    Can no longer modify Parameters for Fragmentation.
     PastInitPhase=true;
     
 //  check if string has enough mass to fragment...
 
     G4KineticTrackVector * LeftVector=LightFragmentationTest(&theString);
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   if ( LeftVector != 0 ) G4cout<<"Non fragmentable - the string is converted to one hadron "<<G4endl;
 #endif
 
     if ( LeftVector != 0 ) return LeftVector;
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"The string will be fragmented. "<<G4endl;
 #endif
     
     LeftVector = new G4KineticTrackVector;
     G4KineticTrackVector * RightVector=new G4KineticTrackVector;
 
 // this should work but its only a semi deep copy. %GF  G4ExcitedString theStringInCMS(theString);
         G4ExcitedString *theStringInCMS=CPExcited(theString);
     G4LorentzRotation toCms=theStringInCMS->TransformToAlignedCms();
 
     G4bool success=false, inner_sucess=true;
     G4int attempt=0;
     while ( !success && attempt++ < StringLoopInterrupt )  /* Loop checking, 07.08.2015, A.Ribon */
     {
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"Loop_toFrag "<<theStringInCMS->GetLeftParton()->GetPDGcode()<<" "
                         <<theStringInCMS->GetRightParton()->GetPDGcode()<<" "
                         <<theStringInCMS->GetDirection()<< G4endl;
 #endif
 
         G4FragmentingString *currentString=new G4FragmentingString(*theStringInCMS);
 
         std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
         LeftVector->clear();
         std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
         RightVector->clear();
         
         inner_sucess=true;  // set false on failure..
                 const G4int maxNumberOfLoops = 1000;
                 G4int loopCounter = -1;
         while (! StopFragmenting(currentString) && ++loopCounter < maxNumberOfLoops )   /* Loop checking, 07.08.2015, A.Ribon */
         {  // Split current string into hadron + new string
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"The string can fragment. "<<G4endl;;
 #endif
             G4FragmentingString *newString=0;  // used as output from SplitUp...
             G4KineticTrack * Hadron=Splitup(currentString,newString);
 
             if ( Hadron != 0 ) // && IsFragmentable(newString))   // Closed by Uzhi, Oct. 2014
             {
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"Hadron prod at fragm. "<<Hadron->GetDefinition()->GetParticleName()<<G4endl;
 #endif
                if ( currentString->GetDecayDirection() > 0 )
                    LeftVector->push_back(Hadron);
                    else
                    RightVector->push_back(Hadron);
 
                delete currentString;
                currentString=newString;
 
             } else {
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"abandon ... start from the beginning ---------------"<<G4endl;
 #endif
 
              // abandon ... start from the beginning
                if (newString) delete newString;
                inner_sucess=false;
                break;
             }
         }
                 if ( loopCounter >= maxNumberOfLoops ) {
                   inner_sucess=false;
                 }
 
         // Split current string into 2 final Hadrons
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"Split remaining string into 2 final hadrons."<<G4endl;
 #endif
 
         if ( inner_sucess &&                                    //true)  // Uzhi -- No Last Splitting
              SplitLast(currentString,LeftVector, RightVector) ) 
         {
             success=true;
         }
         delete currentString;
     }
     
     delete theStringInCMS;
     
     if ( ! success )
     {
         std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
         LeftVector->clear();
         std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
         delete RightVector;
         return LeftVector;
     }
         
     // Join Left- and RightVector into LeftVector in correct order.
     while(!RightVector->empty())  /* Loop checking, 07.08.2015, A.Ribon */
     {
         LeftVector->push_back(RightVector->back());
         RightVector->erase(RightVector->end()-1);
     }
     delete RightVector;
 
     CalculateHadronTimePosition(theString.Get4Momentum().mag(), LeftVector);
 
     G4LorentzRotation toObserverFrame(toCms.inverse());
 
     for(size_t C1 = 0; C1 < LeftVector->size(); C1++)
     {
        G4KineticTrack* Hadron = LeftVector->operator[](C1);
        G4LorentzVector Momentum = Hadron->Get4Momentum();
        Momentum = toObserverFrame*Momentum;
        Hadron->Set4Momentum(Momentum);
        G4LorentzVector Coordinate(Hadron->GetPosition(), Hadron->GetFormationTime());
        Momentum = toObserverFrame*Coordinate;
        Hadron->SetFormationTime(Momentum.e());
        G4ThreeVector aPosition(Momentum.vect());
        Hadron->SetPosition(theString.GetPosition()+aPosition);
     }
     return LeftVector;
         
 
 
 }

Here is the call graph for this function:

◆ GetLightConeZ()

G4double G4QGSMFragmentation::GetLightConeZ	(	G4double	zmin,
		G4double	zmax,
		G4int	PartonEncoding,
		G4ParticleDefinition *	pHadron,
		G4double	Px,
		G4double	Py
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 216 of file G4QGSMFragmentation.cc.

 {    
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"GetLightConeZ zmin zmax Parton pHadron "<<zmin<<" "<<zmax<<" "<<PartonEncoding<<" "<<pHadron->GetParticleName()<<G4endl;
 #endif
   G4double z;    
   G4double d1, d2, yf;
   G4double invD1(0.),invD2(0.), r1(0.),r2(0.),r12(0.);
 
   G4int absCode = std::abs( PartonEncoding );
   G4int absHadronCode=std::abs(pHadron->GetPDGEncoding());
 
   G4int q1, q2, q3;
   q1 = absHadronCode/1000; q2 = (absHadronCode % 1000)/100; q3 = (absHadronCode % 100)/10;
 
   G4bool StrangeHadron = (q1 == 3) || (q2 == 3) || (q3 == 3);
 
   if (absCode < 10)
   {                                              // A quark fragmentation ----------------------------
     if(absCode == 1 || absCode == 2) 
     {
       if(absHadronCode < 1000) 
       {                        // Meson  produced
         if( !StrangeHadron )  {d1=2.0;        d2 = -arho + alft;}
         else                  {d1=1.0;        d2 = -aphi + alft;}
       } else                 
       {                        // Baryon produced
         if( !StrangeHadron )  {d1=0.0;        d2 =      arho - 2.0*an        + alft;}
         else                  {d1=0.0;        d2 =  2.0*arho - 2.0*an - aphi + alft;} 
       }
     } 
     else if(absCode == 3)  
     {
       if(absHadronCode < 1000){d1=1.0 - aphi; d2 =  -arho          + alft;}  // Meson  produced s->K + u/d
       else                    {d1=1.0 - aphi; d2 =   arho - 2.0*an + alft;}  // Baryon produced 
 
     } else throw G4HadronicException(__FILE__, __LINE__, "Unknown PDGencoding in G4QGSMFragmentation::G4LightConeZ");
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"d1 d2 "<<d1<<" "<<d2<<G4endl;
 #endif
 
     d1+=1.0; d2+=1.0;
 
     invD1=1./d1; invD2=1./d2;
 
     const G4int maxNumberOfLoops = 10000;
     G4int loopCounter = 0;
     do
     {
      r1=G4Pow::GetInstance()->powA(G4UniformRand(),invD1);
      r2=G4Pow::GetInstance()->powA(G4UniformRand(),invD2);
      r12=r1+r2;
      z=r1/r12;
     } while( ( (r12 > 1.0) || !((zmin <= z)&&(z <= zmax))) && ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */
     if ( loopCounter >= maxNumberOfLoops ) {
       z = 0.5*(zmin + zmax);  // Just a value between zmin and zmax, no physics considerations at all! 
     }
 
     return z;
   }
   else
   {                                              // A di-quark fragmentation -------------------------
     if(absCode == 1103 || absCode == 2101 || 
        absCode == 2203 || absCode == 2103)
     {
      if(absHadronCode < 1000)                                                // Meson production
      {
         if( !StrangeHadron )  {d1=1.0; d2=     arho - 2.0*an        + alft;} 
         else                  {d1=1.0; d2 = 2.*arho - 2.0*an - aphi + alft;}
      } else                                                                 // Baryon production
      {
         if( !StrangeHadron )  {d1=2.0*(arho - an); d2= -arho         + alft;}
         else                  {d1=2.0*(arho - an); d2 =-aphi         + alft;} 
      }
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"d1 d2 "<<d1<<" "<<d2<<G4endl;
 #endif
 
      d1+=1.0; d2+=1.0;
      invD1=1./d1; invD2=1./d2;
 
      const G4int maxNumberOfLoops = 10000;
      G4int loopCounter = 0;
      do
      {
       r1=G4Pow::GetInstance()->powA(G4UniformRand(),invD1);
       r2=G4Pow::GetInstance()->powA(G4UniformRand(),invD2);
       r12=r1+r2;
       z=r1/r12;
      } while( ( (r12 > 1.0) || !((zmin <= z)&&(z <= zmax))) && ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */ 
      if ( loopCounter >= maxNumberOfLoops ) {
        z = 0.5*(zmin + zmax);  // Just a value between zmin and zmax, no physics considerations at all! 
      }
 
      return z;
     }
     else if(absCode == 3101 || absCode == 3103 ||           // For strange d-quarks
             absCode == 3201 || absCode == 3203)
     {
       d2 =  (alft - (2.*ala - arho));
 
     }
     else
     {
       d2 =  (alft - (2.*aksi - arho));
     }
 
     const G4int maxNumberOfLoops = 1000;
     G4int loopCounter = 0;
     do  
     {
       z = zmin + G4UniformRand() * (zmax - zmin);
       d1 =  (1. - z);
       yf = G4Pow::GetInstance()->powA(d1, d2);
     } 
     while( (G4UniformRand() > yf) && ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */   
   }
 
   return z;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsFragmentable()

G4bool G4QGSMFragmentation::IsFragmentable ( const G4FragmentingString *const string )

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 537 of file G4QGSMFragmentation.cc.

 {
     return sqr(FragmentationMass(string)+MassCut) <
             string->Mass2();
 }

Here is the call graph for this function:

◆ operator!=()

int G4QGSMFragmentation::operator!= ( const G4QGSMFragmentation & right ) const

private

◆ operator=()

const G4QGSMFragmentation& G4QGSMFragmentation::operator= ( const G4QGSMFragmentation & right )

private

◆ operator==()

int G4QGSMFragmentation::operator== ( const G4QGSMFragmentation & right ) const

private

◆ Sample4Momentum()

void G4QGSMFragmentation::Sample4Momentum	(	G4LorentzVector *	Mom,
		G4double	Mass,
		G4LorentzVector *	AntiMom,
		G4double	AntiMass,
		G4double	InitialMass
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 556 of file G4QGSMFragmentation.cc.

     {
     G4double r_val = sqr(InitialMass*InitialMass - Mass*Mass - AntiMass*AntiMass) - sqr(2.*Mass*AntiMass);
     G4double Pabs = (r_val > 0.)? std::sqrt(r_val)/(2.*InitialMass) : 0;
 
     //... sample unit vector       
     G4double pz = 1. - 2.*G4UniformRand();  
     G4double st     = std::sqrt(1. - pz * pz)*Pabs;
     G4double phi    = 2.*pi*G4UniformRand();
     G4double px = st*std::cos(phi);
     G4double py = st*std::sin(phi);
     pz *= Pabs;
     
     Mom->setPx(px); Mom->setPy(py); Mom->setPz(pz);
     Mom->setE(std::sqrt(Pabs*Pabs + Mass*Mass));
 
     AntiMom->setPx(-px); AntiMom->setPy(-py); AntiMom->setPz(-pz);
     AntiMom->setE (std::sqrt(Pabs*Pabs + AntiMass*AntiMass));
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SplitEandP()

G4LorentzVector * G4QGSMFragmentation::SplitEandP	(	G4ParticleDefinition *	pHadron,
		G4FragmentingString *	string,
		G4FragmentingString *	newString
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 341 of file G4QGSMFragmentation.cc.

 {
        G4double HadronMass = pHadron->GetPDGMass();
 
 //       G4double MinimalStringMass= FragmentationMass(NewString,&G4HadronBuilder::BuildHighSpin);
        G4double MinimalStringMass= 
        FragmentationMass(NewString,&G4HadronBuilder::Build); // Uzhi 03.06.2015
 //       FragmentationMass(NewString,&G4HadronBuilder::BuildLowSpin); // Uzhi 03.06.2015
 // Uzhi 03.06.2015 It would be well to sample randomly HighSpin
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"G4QGSMFragmentation::SplitEandP "<<pHadron->GetParticleName()<<G4endl;
   G4cout<<"String 4 mom, String M "<<string->Get4Momentum()<<" "<<string->Mass()<<G4endl;
   G4cout<<"HadM MinimalStringMassLeft StringM hM+sM "<<HadronMass<<" "<<MinimalStringMass<<" "
         <<string->Mass()<<" "<<HadronMass+MinimalStringMass<<G4endl;
 #endif
 
         if(HadronMass + MinimalStringMass > string->Mass())
     {
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"Mass of the string is not sufficient to produce the hadron!"<<G4endl;
 #endif
      return 0;
     }// have to start all over!
 
        // calculate and assign hadron transverse momentum component HadronPx andHadronPy
        G4double StringMT2 = string->MassT2();
        G4double StringMT  = std::sqrt(StringMT2);
 
        G4LorentzVector String4Momentum = string->Get4Momentum();
        String4Momentum.setPz(0.);
        G4ThreeVector StringPt = String4Momentum.vect();
 
        G4ThreeVector HadronPt    , RemSysPt;
        G4double      HadronMassT2, ResidualMassT2;
 
        //...  sample Pt of the hadron
        G4int attempt=0;
        do
        {
         attempt++; if(attempt > StringLoopInterrupt) return 0;
 
         HadronPt =SampleQuarkPt()  + string->DecayPt(); 
         HadronPt.setZ(0);
         RemSysPt = StringPt - HadronPt;
 
         HadronMassT2 = sqr(HadronMass) + HadronPt.mag2();
         ResidualMassT2=sqr(MinimalStringMass) + RemSysPt.mag2();
 
        } while(std::sqrt(HadronMassT2) + std::sqrt(ResidualMassT2) > StringMT);  /* Loop checking, 07.08.2015, A.Ribon */
 
        //...  sample z to define hadron longitudinal momentum and energy
        //... but first check the available phase space
 
     G4double Pz2 = (sqr(StringMT2 - HadronMassT2 - ResidualMassT2) -
             4*HadronMassT2 * ResidualMassT2)/4./StringMT2;
 
     if(Pz2 < 0 ) {return 0;}          // have to start all over!
 
     //... then compute allowed z region  z_min <= z <= z_max
 
     G4double Pz = std::sqrt(Pz2);
     G4double zMin = (std::sqrt(HadronMassT2+Pz2) - Pz)/std::sqrt(StringMT2);
     G4double zMax = (std::sqrt(HadronMassT2+Pz2) + Pz)/std::sqrt(StringMT2);
 
 /*  close by Uzhi, Oct. 2014
        G4double DecayQuarkMass2  = sqr(string->GetDecayParton()->GetPDGMass());
        G4double HadronMass2T = sqr(HadronMass) + HadronPt.mag2();
 
        if (DecayQuarkMass2 + HadronMass2T >= SmoothParam*(string->Mass2()) ) 
           return 0;     // have to start all over!
 
        //... then compute allowed z region  z_min <= z <= z_max 
  
 //       G4double zMin = HadronMass2T/(string->Mass2());
 //       G4double zMax = 1. - DecayQuarkMass2/(string->Mass2());
 */
        if (zMin >= zMax) return 0;      // have to start all over!
     
        G4double z = GetLightConeZ(zMin, zMax,
                string->GetDecayParton()->GetPDGEncoding(), pHadron,
                HadronPt.x(), HadronPt.y());      
 
        //... now compute hadron longitudinal momentum and energy
        // longitudinal hadron momentum component HadronPz
 
         HadronPt.setZ(0.5* string->GetDecayDirection() *
             (z * string->LightConeDecay() - 
              HadronMassT2/(z * string->LightConeDecay())));
         G4double HadronE  = 0.5* (z * string->LightConeDecay() + 
                   HadronMassT2/(z * string->LightConeDecay()));
 
        G4LorentzVector * a4Momentum= new G4LorentzVector(HadronPt,HadronE);
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"string->GetDecayDirection() string->LightConeDecay() "
         <<string->GetDecayDirection()<<" "<<string->LightConeDecay()<<G4endl;
   G4cout<<"HadronPt,HadronE "<<HadronPt<<" "<<HadronE<<G4endl;
 //  G4cout<<"String4Momentum "<<String4Momentum<<G4endl;
 //G4int Uzhi; G4cin>>Uzhi;
   G4cout<<"Out of QGSM SplitEandP "<<G4endl;
 #endif
 
        return a4Momentum;
 }

Here is the call graph for this function:

◆ SplitLast()

G4bool G4QGSMFragmentation::SplitLast	(	G4FragmentingString *	string,
		G4KineticTrackVector *	LeftVector,
		G4KineticTrackVector *	RightVector
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 451 of file G4QGSMFragmentation.cc.

 {
     //... perform last cluster decay
 
     G4ThreeVector ClusterVel =string->Get4Momentum().boostVector();
     G4double ResidualMass    =string->Mass(); 
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<"Split last-----------------------------------------"<<G4endl;
   G4cout<<"StrMass "<<ResidualMass<<" q's "
         <<string->GetLeftParton()->GetParticleName()<<" "
         <<string->GetRightParton()->GetParticleName()<<G4endl;
 #endif
 
     G4double ClusterMassCut = ClusterMass;            // Taken from G4VLongitudinalStringDecay
     G4int cClusterInterrupt = 0;
     G4ParticleDefinition * LeftHadron, * RightHadron;
     const G4int maxNumberOfLoops = 1000;
     G4int loopCounter = 0;
     do
     {
         if (cClusterInterrupt++ >= ClusterLoopInterrupt)
         {
           return false;
         }
 
     G4ParticleDefinition * quark = NULL;
     string->SetLeftPartonStable(); // to query quark contents..
 
     if (string->DecayIsQuark() && string->StableIsQuark() ) 
     {
        //... there are quarks on cluster ends
         LeftHadron= QuarkSplitup(string->GetLeftParton(), quark);
     } else {
        //... there is a Diquark on cluster ends
         G4int IsParticle;
         if ( string->StableIsQuark() ) {
           IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? -1 : +1; 
         } else {
           IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? +1 : -1;
         }
 
             pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
             quark = QuarkPair.second;
             LeftHadron=hadronizer->Build(QuarkPair.first, string->GetLeftParton());
     }
 
         RightHadron = hadronizer->Build(string->GetRightParton(), quark);
 
        //... repeat procedure, if mass of cluster is too low to produce hadrons
        //... ClusterMassCut = 0.15*GeV model parameter
     if ( quark->GetParticleSubType()== "quark" ) {ClusterMassCut = 0.;}
     else {ClusterMassCut = ClusterMass;}
     } 
     while ( (ResidualMass <= LeftHadron->GetPDGMass() + RightHadron->GetPDGMass() + ClusterMassCut)
             && ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */
 
     if ( loopCounter >= maxNumberOfLoops ) {
       return false;
     }
 
     //... compute hadron momenta and energies   
     G4LorentzVector  LeftMom, RightMom;
     G4ThreeVector    Pos;
     Sample4Momentum(&LeftMom , LeftHadron->GetPDGMass() , 
                     &RightMom, RightHadron->GetPDGMass(), ResidualMass);
     LeftMom.boost(ClusterVel);
     RightMom.boost(ClusterVel);
 
 #ifdef debug_QGSMfragmentation                          // Uzhi Oct. 2014
   G4cout<<LeftHadron->GetParticleName()<<" "<<RightHadron->GetParticleName()<<G4endl;
   G4cout<<"Left  Hadrom P M "<<LeftMom<<" "<<LeftMom.mag()<<G4endl;
   G4cout<<"Right Hadrom P M "<<RightMom<<" "<<RightMom.mag()<<G4endl;
 #endif
 
     LeftVector->push_back(new G4KineticTrack(LeftHadron, 0, Pos, LeftMom));
     RightVector->push_back(new G4KineticTrack(RightHadron, 0, Pos, RightMom));
 
     return true;
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StopFragmenting()

G4bool G4QGSMFragmentation::StopFragmenting ( const G4FragmentingString *const string )

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 545 of file G4QGSMFragmentation.cc.

 {
     return
          sqr(FragmentationMass(string,&G4HadronBuilder::BuildHighSpin)+MassCut) >
          string->Get4Momentum().mag2();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ aksi

const G4double G4QGSMFragmentation::aksi

private

Definition at line 76 of file G4QGSMFragmentation.hh.

◆ ala

const G4double G4QGSMFragmentation::ala

private

Definition at line 75 of file G4QGSMFragmentation.hh.

◆ alft

const G4double G4QGSMFragmentation::alft

private

Definition at line 77 of file G4QGSMFragmentation.hh.

◆ an

const G4double G4QGSMFragmentation::an

private

Definition at line 74 of file G4QGSMFragmentation.hh.

◆ aphi

const G4double G4QGSMFragmentation::aphi

private

Definition at line 73 of file G4QGSMFragmentation.hh.

◆ arho

const G4double G4QGSMFragmentation::arho

private

Definition at line 72 of file G4QGSMFragmentation.hh.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4QGSMFragmentation() [1/2]

◆ ~G4QGSMFragmentation()

◆ G4QGSMFragmentation() [2/2]

Member Function Documentation

◆ DiQuarkSplitup()

◆ FragmentString()

◆ GetLightConeZ()

◆ IsFragmentable()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ Sample4Momentum()

◆ SplitEandP()

◆ SplitLast()

◆ StopFragmenting()

Member Data Documentation

◆ aksi

◆ ala

◆ alft

◆ an

◆ aphi

◆ arho