96 #ifdef debug_LUNDfragmentation
97 G4cout<<
G4endl<<
"LUND StringFragmentation ------------------------------------"<<
G4endl;
98 G4cout<<G4endl<<
"LUND StringFragm: String Mass "
101 <<
"------------------------------------"<<
G4endl;
114 #ifdef debug_LUNDfragmentation
115 G4cout<<
"Non fragmentable - the string is converted to one hadron "<<
G4endl;
126 LeftVector->operator[](0)->SetPosition(theString.
GetPosition());
128 if(LeftVector->size() > 1)
132 LeftVector->operator[](1)->SetPosition(theString.
GetPosition());
137 #ifdef debug_LUNDfragmentation
157 while(!RightVector->empty())
159 LeftVector->push_back(RightVector->back());
160 RightVector->erase(RightVector->end()-1);
181 #ifdef debug_LUNDfragmentation
189 G4bool final_success=
false;
190 G4bool inner_success=
true;
207 RightVector->clear();
211 const G4int maxNumberOfLoops = 1000;
212 G4int loopCounter = -1;
214 while ( (!
StopFragmenting(currentString)) && ++loopCounter < maxNumberOfLoops )
216 #ifdef debug_LUNDfragmentation
223 toObserverFrame= toCms.
inverse();
224 #ifdef debug_LUNDfragmentation
234 #ifdef debug_LUNDfragmentation
248 Hadron->
SetPosition(PositionOftheStringCreation+aPosition);
253 LeftVector->push_back(Hadron);
256 RightVector->push_back(Hadron);
258 delete currentString;
259 currentString=newString;
261 if ( newString )
delete newString;
267 if ( loopCounter >= maxNumberOfLoops ) {
272 #ifdef debug_LUNDfragmentation
273 if(inner_success)
G4cout<<
"Split remaining string into 2 final hadrons."<<
G4endl;
275 if ( inner_success &&
SplitLast(currentString, LeftVector, RightVector) )
277 final_success =
true;
280 delete currentString;
282 return final_success;
296 #ifdef debug_LUNDfragmentation
309 #ifdef debug_LUNDfragmentation
311 G4cout<<
"Start SplitUP (G4VLongitudinalStringDecay) ========================="<<
G4endl;
312 G4cout<<
"String partons: " <<
string->GetLeftParton()->GetPDGEncoding()<<
" "
313 <<
string->GetRightParton()->GetPDGEncoding()<<
" "
314 <<
"Direction " <<
string->GetDecayDirection()<<
G4endl;
321 string->SetLeftPartonStable();
324 string->SetRightPartonStable();
333 G4int Iter(0), MaxIter(1);
339 #ifdef debug_LUNDfragmentation
343 G4int NumberOfpossibleBaryons = 2;
349 ActualProb *= (1.0-
sqr(NumberOfpossibleBaryons*1400.0/StringMass));
354 if ( NumberOfpossibleBaryons == 3 ){Mth = 2000.0;}
355 else if( NumberOfpossibleBaryons == 4 ){Mth = 2550.0;}
361 if( ActualProb < 0.0 ) ActualProb = 0.0;
364 #ifdef debug_LUNDfragmentation
378 #ifdef debug_LUNDfragmentation
380 G4cout<<
"The parton "<<
string->GetDecayParton()->GetPDGEncoding()<<
" "
383 G4cout<<
"The side of the string decay Left/Right (1/-1) "<<SideOfDecay<<
G4endl;
387 if ( newString )
delete newString;
400 }
while(HadronMass + MinMass > StringMass);
405 #ifdef debug_LUNDfragmentation
406 G4cout<<
"An attempt to determine its energy (SplitEandP)"<<
G4endl;
410 delete newString; newString=0;
413 if ( HadronMomentum != 0 ) {
415 #ifdef debug_LUNDfragmentation
419 Hadron =
new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
421 if ( newString )
delete newString;
425 delete HadronMomentum;
430 #ifdef debug_LUNDfragmentation
435 #ifdef debug_LUNDfragmentation
436 G4cout<<
"End SplitUP (G4VLongitudinalStringDecay) ====================="<<
G4endl;
456 G4int Swap = stableQuarkEncoding;
457 stableQuarkEncoding = decayQuarkEncoding;
458 decayQuarkEncoding = Swap;
461 G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1;
469 G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
470 G4int i10 =
std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
471 G4int i20 =
std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
473 G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
488 created = QuarkPair.second;
501 G4double StringMT2=
string->MassT2();
502 G4double StringMT =std::sqrt(StringMT2);
508 #ifdef debug_LUNDfragmentation
510 G4cout<<
"String 4 mom, String M and Mt "<<String4Momentum<<
" "<<String4Momentum.
mag()<<
" "<<std::sqrt(StringMT2)<<
G4endl;
518 #ifdef debug_LUNDfragmentation
519 G4cout<<
"Mass of the string is not sufficient to produce the hadron!"<<
G4endl;
524 String4Momentum.
setPz(0.);
529 G4double HadronMassT2, ResidualMassT2;
538 Pt2 =
sqr(HadronMt)-
sqr(HadronMass); Pt=std::sqrt(Pt2);
542 HadronPt =SampleQuarkPtw +
string->DecayPt();
544 RemSysPt = StringPt - HadronPt;
546 HadronMassT2 =
sqr(HadronMass) + HadronPt.mag2();
549 }
while(std::sqrt(HadronMassT2) + std::sqrt(ResidualMassT2) > StringMT);
554 G4double Pz2 = (
sqr(StringMT2 - HadronMassT2 - ResidualMassT2) -
555 4*HadronMassT2 * ResidualMassT2)/4./StringMT2;
557 if(Pz2 < 0 ) {
return 0;}
562 G4double zMin = (std::sqrt(HadronMassT2+Pz2) - Pz)/std::sqrt(StringMT2);
564 G4double zMax = (std::sqrt(HadronMassT2+Pz2) + Pz)/std::sqrt(StringMT2);
566 if (zMin >= zMax)
return 0;
570 HadronPt.
x(), HadronPt.
y());
576 (z *
string->LightConeDecay() -
577 HadronMassT2/(z *
string->LightConeDecay())));
578 G4double HadronE = 0.5* (z *
string->LightConeDecay() +
579 HadronMassT2/(z *
string->LightConeDecay()));
583 #ifdef debug_LUNDfragmentation
584 G4cout<<G4endl<<
" string->GetDecayDirection() "<<
string->GetDecayDirection()<<G4endl<<
G4endl;
585 G4cout<<
"string->LightConeDecay() "<<
string->LightConeDecay()<<
G4endl;
586 G4cout<<
"HadronPt,HadronE "<<HadronPt<<
" "<<HadronE<<
G4endl;
596 G4int PDGEncodingOfDecayParton,
603 G4double Mt2 = Px*Px + Py*Py + Mass*Mass;
606 G4double zOfMaxyf(0.), maxYf(1.),
z(0.), yf(1.);
609 if(!((std::abs(PDGEncodingOfDecayParton) > 1000) && (HadronEncoding > 1000)) )
616 zOfMaxyf=BMt2/(Blund*Mt2 + 1.);}
618 zOfMaxyf = ((1.0+BMt2) - std::sqrt(
sqr(1.0-BMt2) + 4.0*BMt2*Alund))/2.0/(1.-Alund);
621 if(zOfMaxyf < zmin) {zOfMaxyf=zmin;}
622 if(zOfMaxyf > zmax) {zOfMaxyf=zmax;}
623 maxYf=(1-zOfMaxyf)/zOfMaxyf *
G4Exp(-Blund*Mt2/zOfMaxyf);
625 const G4int maxNumberOfLoops = 1000;
626 G4int loopCounter = 0;
633 while ( (
G4UniformRand()*maxYf > yf) && ++loopCounter < maxNumberOfLoops );
634 if ( loopCounter >= maxNumberOfLoops ) {
635 z = 0.5*(zmin + zmax);
641 if(std::abs(PDGEncodingOfDecayParton) > 1000)
663 #ifdef debug_LUNDfragmentation
665 G4cout<<
"Left "<<
string->GetLeftParton()->GetPDGEncoding()<<
" "<<
string->GetPleft()<<
G4endl;
666 G4cout<<
"Right "<<
string->GetRightParton()->GetPDGEncoding()<<
" "<<
string->GetPright()<<
G4endl;
667 G4cout<<
"String4mom "<<
string->GetPstring()<<
" "<<
string->GetPstring().mag()<<
G4endl;
682 G4int sampledState = 0;
684 #ifdef debug_LUNDfragmentation
685 G4cout<<
"StrMass "<<StringMass<<
" q's "
686 <<
string->GetLeftParton()->GetParticleName()<<
" "
687 <<
string->GetRightParton()->GetParticleName()<<
G4endl;
690 string->SetLeftPartonStable();
723 #ifdef debug_LUNDfragmentation
741 #ifdef debug_LUNDfragmentation
763 #ifdef debug_LUNDfragmentation
767 G4LorentzVector P_left =
string->GetPleft(), P_right =
string->GetPright();
779 if(!(string->
DecayIsQuark() &&
string->StableIsQuark() ))
792 LeftMom *=toObserverFrame;
793 RightMom*=toObserverFrame;
795 LeftVector->push_back(
new G4KineticTrack(LeftHadron, 0, Pos, LeftMom));
796 RightVector->push_back(
new G4KineticTrack(RightHadron, 0, Pos, RightMom));
798 string->LorentzRotate(toObserverFrame);
809 G4double StringMass =
string->Mass();
811 G4int cClusterInterrupt = 0;
819 G4int LeftQuark1=
string->GetLeftParton()->GetPDGEncoding()/1000;
820 G4int LeftQuark2=(
string->GetLeftParton()->GetPDGEncoding()/100)%10;
822 G4int RightQuark1=
string->GetRightParton()->GetPDGEncoding()/1000;
823 G4int RightQuark2=(
string->GetRightParton()->GetPDGEncoding()/100)%10;
842 while ((StringMass <= LeftHadron->GetPDGMass() + RightHadron->
GetPDGMass()));
855 G4double StringMass =
string->Mass();
862 Anti_Di_Quark =
string->GetLeftParton();
863 Di_Quark=
string->GetRightParton();
866 Anti_Di_Quark =
string->GetRightParton();
867 Di_Quark=
string->GetLeftParton();
871 G4int AbsIDAnti_di_quark =std::abs(IDAnti_di_quark);
873 G4int AbsIDdi_quark =std::abs(IDdi_quark);
875 G4int ADi_q1=AbsIDAnti_di_quark/1000;
876 G4int ADi_q2=(AbsIDAnti_di_quark-ADi_q1*1000)/100;
878 G4int Di_q1=AbsIDdi_quark/1000;
879 G4int Di_q2=(AbsIDdi_quark-Di_q1*1000)/100;
882 for(
G4int ProdQ=1; ProdQ < 4; ProdQ++)
885 const G4int maxNumberOfLoops = 1000;
886 G4int loopCounter = 0;
890 -
Baryon[ADi_q1-1][ADi_q2-1][ProdQ-1][StateADiQ]);
894 const G4int maxNumberOfInternalLoops = 1000;
895 G4int internalLoopCounter = 0;
899 +
Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]);
903 if(StringMass > LeftHadronMass + RightHadronMass)
908 G4Exception(
"G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting ",
914 sqr(RightHadronMass));
928 }
while( (
Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]!=0) &&
929 ++internalLoopCounter < maxNumberOfInternalLoops );
930 if ( internalLoopCounter >= maxNumberOfInternalLoops ) {
935 }
while( (
Baryon[ADi_q1-1][ADi_q2-1][ProdQ-1][StateADiQ]!=0) &&
936 ++loopCounter < maxNumberOfLoops );
937 if ( loopCounter >= maxNumberOfLoops ) {
951 G4double StringMass =
string->Mass();
959 Quark =
string->GetLeftParton();
960 Di_Quark=
string->GetRightParton();
963 Quark =
string->GetRightParton();
964 Di_Quark=
string->GetLeftParton();
968 G4int AbsIDquark =std::abs(IDquark);
970 G4int AbsIDdi_quark=std::abs(IDdi_quark);
971 G4int Di_q1=AbsIDdi_quark/1000;
972 G4int Di_q2=(AbsIDdi_quark-Di_q1*1000)/100;
975 if(IDdi_quark < 0) SignDiQ=-1;
978 for(
G4int ProdQ=1; ProdQ < 4; ProdQ++)
983 if(IDquark == 2) SignQ= 1;
984 if((IDquark == 1) && (ProdQ == 3)) SignQ= 1;
985 if((IDquark == 3) && (ProdQ == 1)) SignQ=-1;
989 if(IDquark == -2) SignQ=-1;
990 if((IDquark ==-1) && (ProdQ == 3)) SignQ=-1;
991 if((IDquark ==-3) && (ProdQ == 1)) SignQ= 1;
994 if(AbsIDquark == ProdQ) SignQ= 1;
997 const G4int maxNumberOfLoops = 1000;
998 G4int loopCounter = 0;
1002 Meson[AbsIDquark-1][ProdQ-1][StateQ]);
1006 const G4int maxNumberOfInternalLoops = 1000;
1007 G4int internalLoopCounter = 0;
1011 Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]);
1014 if(StringMass > LeftHadronMass + RightHadronMass)
1019 G4Exception(
"G4LundStringFragmentation::Quark_Diquark_lastSplitting ",
1025 sqr(RightHadronMass));
1039 }
while( (
Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]!=0) &&
1040 ++internalLoopCounter < maxNumberOfInternalLoops );
1041 if ( internalLoopCounter >= maxNumberOfInternalLoops ) {
1046 }
while( (
Meson[AbsIDquark-1][ProdQ-1][StateQ]!=0) &&
1047 ++loopCounter < maxNumberOfLoops );
1049 if ( loopCounter >= maxNumberOfLoops ) {
1063 G4double StringMass =
string->Mass();
1071 Quark =
string->GetLeftParton();
1072 Anti_Quark=
string->GetRightParton();
1075 Quark =
string->GetRightParton();
1076 Anti_Quark=
string->GetLeftParton();
1080 G4int AbsIDquark =std::abs(IDquark);
1082 G4int AbsIDanti_quark=std::abs(IDanti_quark);
1085 for(
G4int ProdQ=1; ProdQ < 4; ProdQ++)
1088 if(IDquark == 2) SignQ= 1;
1089 if((IDquark == 1) && (ProdQ == 3)) SignQ= 1;
1090 if((IDquark == 3) && (ProdQ == 1)) SignQ=-1;
1091 if(IDquark == ProdQ) SignQ= 1;
1094 if(IDanti_quark == -2) SignAQ=-1;
1095 if((IDanti_quark ==-1) && (ProdQ == 3)) SignAQ=-1;
1096 if((IDanti_quark ==-3) && (ProdQ == 1)) SignAQ= 1;
1097 if(AbsIDanti_quark == ProdQ) SignAQ= 1;
1100 const G4int maxNumberOfLoops = 1000;
1101 G4int loopCounter = 0;
1105 Meson[AbsIDquark-1][ProdQ-1][StateQ]);
1109 const G4int maxNumberOfInternalLoops = 1000;
1110 G4int internalLoopCounter = 0;
1114 Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]);
1117 if(StringMass > LeftHadronMass + RightHadronMass)
1122 G4Exception(
"G4LundStringFragmentation::Quark_AntiQuark_lastSplitting ",
1128 sqr(RightHadronMass));
1150 }
while( (
Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]!=0) &&
1151 ++internalLoopCounter < maxNumberOfInternalLoops );
1152 if ( internalLoopCounter >= maxNumberOfInternalLoops ) {
1157 }
while( (
Meson[AbsIDquark-1][ProdQ-1][StateQ]!=0) &&
1158 ++loopCounter < maxNumberOfLoops );
1159 if ( loopCounter >= maxNumberOfLoops ) {
1183 G4int indexPosition = 0;
1189 if(Sum >= ksi)
break;
1191 return indexPosition;
1202 G4double AvailablePz, AvailablePz2;
1204 #ifdef debug_LUNDfragmentation
1205 G4cout<<
"Sampling of momenta of 2 last produced hadrons ----------------"<<
G4endl;
1206 G4cout<<
"Init Mass "<<InitialMass<<
" FirstM "<<Mass<<
" SecondM "<<AntiMass<<
" ProbIsotropy "<<
G4endl;
1209 G4double r_val =
sqr(InitialMass*InitialMass - Mass*Mass - AntiMass*AntiMass) -
1210 sqr(2.*Mass*AntiMass);
1211 G4double Pabs = (r_val > 0.)? std::sqrt(r_val)/(2.*InitialMass) : 0;
1233 const G4int maxNumberOfLoops = 1000;
1235 if(Mass > 930. || AntiMass > 930.)
SigmaQT *=(1.0-0.55*
sqr((Mass+AntiMass)/InitialMass));
1237 G4int loopCounter = 0;
1243 MassMt = std::sqrt( Mass * Mass + Pt2);
1244 AntiMassMt= std::sqrt(AntiMass * AntiMass + Pt2);
1246 while( (InitialMass < MassMt + AntiMassMt) && ++loopCounter < maxNumberOfLoops );
1248 if(Mass > 930. || AntiMass > 930.)
SigmaQT=SigmaQTw;;
1250 if ( loopCounter >= maxNumberOfLoops ) {
1254 AvailablePz2=
sqr(InitialMass*InitialMass -
sqr(MassMt) -
sqr(AntiMassMt)) -
1255 4.*
sqr(MassMt*AntiMassMt);
1257 AvailablePz2 /=(4.*InitialMass*InitialMass);
1258 AvailablePz = std::sqrt(AvailablePz2);
1264 Mom->
setE(std::sqrt(
sqr(MassMt)+AvailablePz2));
1266 AntiMom->
setPx(-Px); AntiMom->
setPy(-Py); AntiMom->
setPz(-AvailablePz);
1267 AntiMom->
setE (std::sqrt(
sqr(AntiMassMt)+AvailablePz2));
1269 #ifdef debug_LUNDfragmentation
1290 G4double minMQQbarStr[3][3] ={ {350.0, 350.0, 710.0},
1291 {350.0, 350.0, 710.0},
1292 {710.0, 710.0,1070.0 }};
1296 G4double minMQDiQStr[3][3][3] = {{{1160., 1160., 1340.}, {1160., 1160., 1340.}, {1340., 1340., 1540.},},
1297 {{1160., 1160., 1340.}, {1160., 1160., 1340.}, {1340., 1340., 1540.},},
1298 {{1520., 1520., 1690.}, {1520., 1520., 1690.}, {1690., 1690., 1890. }}};
1306 for(
G4int i=0; i<3; i++)
1307 {
for(
G4int j=0; j<3; j++)
1308 {
for(
G4int k=0; k<6; k++)
1400 for(
G4int i=0; i<3; i++)
1401 {
for(
G4int j=0; j<3; j++)
1402 {
for(
G4int k=0; k<3; k++)
1403 {
for(
G4int l=0; l<4; l++)
1631 for (
G4int i=0 ; i<35 ; i++ ) {
1653 if((Qleft < 4) && (Qright < 4)) {
1660 if((Qleft < 4) && (Qright > 1000)) {
1661 G4int q1=Qright/1000;
1662 G4int q2=(Qright/100)%10;
1669 if((Qleft > 1000) && (Qright < 4)) {
1670 G4int q1=Qleft/1000;
1671 G4int q2=(Qleft/100)%10;
1679 G4int Number_of_quarks=0;
1680 G4int Number_of_squarks=0;
1682 G4double StringM=
string->Get4Momentum().mag();
1684 #ifdef debug_LUNDfragmentation
1690 Number_of_quarks+=2;
1691 G4int q1=Qleft/1000;
1695 G4int q2=(Qleft/100)%10;
1701 #ifdef debug_LUNDfragmentation
1708 Number_of_quarks+=2;
1709 G4int q1=Qright/1000;
1713 G4int q2=(Qright/100)%10;
1719 #ifdef debug_LUNDfragmentation
1724 if(Number_of_quarks==4)
1726 if(StringM > 1880.) {
1727 if(Number_of_squarks==0) {EstimatedMass += 1320.*
MeV;}
1728 else if(Number_of_squarks==1) {EstimatedMass += 1150.*
MeV;}
1729 else if(Number_of_squarks==2) {EstimatedMass += 960.*
MeV;}
1730 else if(Number_of_squarks==3) {EstimatedMass += 800.*
MeV;}
1731 else if(Number_of_squarks==4) {EstimatedMass += 640.*
MeV;}
1742 if(Number_of_squarks < 3) {EstimatedMass -= 200.*
MeV;}
1743 else if(Number_of_squarks==3) {EstimatedMass -= 50.*
MeV;}
1744 else if(Number_of_squarks==4) {EstimatedMass -= 40.*
MeV;}
1749 #ifdef debug_LUNDfragmentation
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
G4LorentzVector GetPleft()
G4bool Quark_Diquark_lastSplitting(G4FragmentingString *&string, G4ParticleDefinition *&LeftHadron, G4ParticleDefinition *&RightHadron)
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
G4LorentzVector GetPright()
ParticleList decay(Cluster *const c)
Carries out a cluster decay.
T max(const T t1, const T t2)
brief Return the largest of the two arguments
G4Parton * GetRightParton(void) const
void LorentzRotate(const G4LorentzRotation &rotation)
G4ParticleDefinition * FS_LeftHadron[35]
G4ParticleDefinition * Build(G4ParticleDefinition *black, G4ParticleDefinition *white)
CLHEP::Hep3Vector G4ThreeVector
const G4ThreeVector & GetPosition() const
std::ostringstream G4ExceptionDescription
const G4LorentzVector & Get4Momentum() const
virtual G4ParticleDefinition * DiQuarkSplitup(G4ParticleDefinition *decay, G4ParticleDefinition *&created)
static G4ParticleTable * GetParticleTable()
static constexpr double MeV
void SetDiquarkSuppression(G4double aValue)
G4ParticleDefinition * GetRightParton(void) const
virtual void SetMassCut(G4double aValue)
const G4String & GetParticleSubType() const
G4int StringLoopInterrupt
void SetStringTensionParameter(G4double aValue)
virtual G4KineticTrackVector * FragmentString(const G4ExcitedString &theString)
const G4String & GetParticleName() const
G4double Mass_of_heavy_quark
const G4ParticleDefinition * GetDefinition() const
G4double MinimalStringMass2
void SetVectorMesonMixings(std::vector< G4double > aVector)
G4double GetDiquarkSuppress()
G4double GetPDGMass() const
void SetSpinThreeHalfBarionProbability(G4double aValue)
void SetDiquarkBreakProbability(G4double aValue)
G4double G4Log(G4double x)
std::vector< G4double > vectorMesonMix
G4double lambda(G4double s, G4double m1_Sqr, G4double m2_Sqr)
G4ParticleDefinition * FS_RightHadron[35]
G4int GetDirection(void) const
static constexpr double fermi
void SetVectorMesonProbability(G4double aValue)
static G4Pow * GetInstance()
G4ParticleDefinition * FindParticle(G4int Encoding)
virtual G4KineticTrack * Splitup(G4FragmentingString *string, G4FragmentingString *&newString)
G4int GetDecayDirection() const
G4ThreeVector SampleQuarkPt(G4double ptMax=-1.)
G4double powA(G4double A, G4double y) const
G4KineticTrackVector * LightFragmentationTest(const G4ExcitedString *const theString)
G4double GetTimeOfCreation() const
G4LorentzRotation TransformToAlignedCms()
void SetStrangenessSuppression(G4double aValue)
G4LorentzVector Get4Momentum() const
G4double MesonWeight[3][3][6]
HepLorentzRotation inverse() const
G4double BaryonWeight[3][3][3][4]
G4double minMassQQbarStr[3][3]
G4Parton * GetLeftParton(void) const
virtual G4LorentzVector * SplitEandP(G4ParticleDefinition *pHadron, G4FragmentingString *string, G4FragmentingString *newString)
G4LundStringFragmentation()
void SetMinimalStringMass(const G4FragmentingString *const string)
G4double Mass_of_string_junction
G4bool Diquark_AntiDiquark_belowThreshold_lastSplitting(G4FragmentingString *&string, G4ParticleDefinition *&LeftHadron, G4ParticleDefinition *&RightHadron)
G4ParticleDefinition * QuarkSplitup(G4ParticleDefinition *decay, G4ParticleDefinition *&created)
G4double Mass_of_light_quark
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
virtual void Sample4Momentum(G4LorentzVector *Mom, G4double Mass, G4LorentzVector *AntiMom, G4double AntiMass, G4double InitialMass)
G4double GetFormationTime() const
static constexpr double c_light
G4ParticleDefinition * GetLeftParton(void) const
G4double GetStrangeSuppress()
void SetPosition(const G4ThreeVector aPosition)
virtual ~G4LundStringFragmentation()
G4bool FourQuarkString(void) const
pDefPair CreatePartonPair(G4int NeedParticle, G4bool AllowDiquarks=true)
G4ParticleDefinition * GetDecayParton() const
G4int GetPDGEncoding() const
G4GLOB_DLL std::ostream G4cout
virtual G4double GetLightConeZ(G4double zmin, G4double zmax, G4int PartonEncoding, G4ParticleDefinition *pHadron, G4double Px, G4double Py)
G4bool Loop_toFragmentString(const G4ExcitedString &theStringInCMS, G4KineticTrackVector *&LeftVector, G4KineticTrackVector *&RightVector)
G4int ClusterLoopInterrupt
virtual G4bool SplitLast(G4FragmentingString *string, G4KineticTrackVector *LeftVector, G4KineticTrackVector *RightVector)
static constexpr double pi
const G4ThreeVector & GetPosition() const
CLHEP::HepLorentzVector G4LorentzVector
G4HadronBuilder * hadronizer
std::pair< G4ParticleDefinition *, G4ParticleDefinition * > pDefPair
virtual G4bool IsFragmentable(const G4FragmentingString *const string)
G4bool Diquark_AntiDiquark_aboveThreshold_lastSplitting(G4FragmentingString *&string, G4ParticleDefinition *&LeftHadron, G4ParticleDefinition *&RightHadron)
std::vector< G4double > scalarMesonMix
const G4LorentzVector & Get4Momentum() const
void Set4Momentum(const G4LorentzVector &a4Momentum)
G4bool Quark_AntiQuark_lastSplitting(G4FragmentingString *&string, G4ParticleDefinition *&LeftHadron, G4ParticleDefinition *&RightHadron)
G4double minMassQDiQStr[3][3][3]
void SetFormationTime(G4double aFormationTime)
static constexpr double GeV
G4LorentzVector GetPstring()
G4double DiquarkBreakProb
G4double MinimalStringMass
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
virtual G4bool StopFragmenting(const G4FragmentingString *const string)
void SetMinimalStringMass2(const G4double aValue)