lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.6.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2019-12-06 15:12:28 +01:00
parent b2a62ae692
commit 5baee230e9
2997 changed files with 141580 additions and 98673 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/parton_string/hadronization/src/G4ExcitedStringDecay.cc
+16 -12
View File
@@ -214,10 +214,12 @@ G4KineticTrackVector *G4ExcitedStringDecay::FragmentStrings(const G4ExcitedStrin
// --------------- Sampling mass of unstable hadronic resonances ----------------
TrackDefinition = (*generatedKineticTracks)[aTrack]->GetDefinition();
if(TrackDefinition->IsShortLived())
if (TrackDefinition->IsShortLived())
{
G4double NewTrackMass = BrW.SampleMass( TrackDefinition,
TrackDefinition->GetPDGMass() + 5.0*TrackDefinition->GetPDGWidth() );
G4double NewTrackMass =
BrW.SampleMass( TrackDefinition->GetPDGMass(), TrackDefinition->GetPDGWidth(),
BrW.GetMinimumMass( TrackDefinition ) + 10.0*MeV,
TrackDefinition->GetPDGMass() + 5.0*TrackDefinition->GetPDGWidth() );
G4LorentzVector Tmp=G4LorentzVector((*generatedKineticTracks)[aTrack]->Get4Momentum());
Tmp.setE(std::sqrt(sqr(NewTrackMass) + Tmp.vect().mag2()));
@@ -243,7 +245,8 @@ G4KineticTrackVector *G4ExcitedStringDecay::FragmentStrings(const G4ExcitedStrin
<<"Final hadrons momentum: "<< KTsum1 << G4endl;
#endif
if ( KTsum1.e() > 0 && std::abs((KTsum1.e()-theStrings->operator[](astring)->Get4Momentum().e()) / KTsum1.e()) > perMillion )
if ( KTsum1.e() > 0 &&
std::abs((KTsum1.e()-theStrings->operator[](astring)->Get4Momentum().e()) / KTsum1.e()) > perMillion )
{
NeedEnergyCorrector=true;
}
@@ -287,9 +290,9 @@ G4KineticTrackVector *G4ExcitedStringDecay::FragmentStrings(const G4ExcitedStrin
G4cout<<"End of the Hadronization (G4ExcitedStringDecay)"<<G4endl;
#endif
if(!success)
if (!success)
{
if(theResult->size() != 0)
if (theResult->size() != 0)
{
std::for_each(theResult->begin() , theResult->end() , DeleteKineticTrack());
theResult->clear();
@@ -320,8 +323,8 @@ G4KineticTrackVector *G4ExcitedStringDecay::FragmentStrings(const G4ExcitedStrin
}
G4bool G4ExcitedStringDecay::EnergyAndMomentumCorrector
(G4KineticTrackVector* Output, G4LorentzVector& TotalCollisionMom)
G4bool G4ExcitedStringDecay::
EnergyAndMomentumCorrector(G4KineticTrackVector* Output, G4LorentzVector& TotalCollisionMom)
{
const int nAttemptScale = 500;
const double ErrLimit = 1.E-5;
@@ -337,7 +340,7 @@ G4bool G4ExcitedStringDecay::EnergyAndMomentumCorrector
#endif
// Calculate sum hadron 4-momenta and summing hadron mass
unsigned int cHadron;
for(cHadron = 0; cHadron < Output->size(); cHadron++)
for (cHadron = 0; cHadron < Output->size(); cHadron++)
{
SumMom += Output->operator[](cHadron)->Get4Momentum();
HadronM=Output->operator[](cHadron)->Get4Momentum().mag(); HadronMass.push_back(HadronM);
@@ -369,10 +372,10 @@ G4bool G4ExcitedStringDecay::EnergyAndMomentumCorrector
G4int cAttempt = 0;
G4double Sum = 0;
G4bool success = false;
for(cAttempt = 0; cAttempt < nAttemptScale; cAttempt++)
for (cAttempt = 0; cAttempt < nAttemptScale; cAttempt++)
{
Sum = 0;
for(cHadron = 0; cHadron < Output->size(); cHadron++)
for (cHadron = 0; cHadron < Output->size(); cHadron++)
{
HadronM = HadronMass.at(cHadron);
G4LorentzVector HadronMom = Output->operator[](cHadron)->Get4Momentum();
@@ -398,7 +401,7 @@ G4bool G4ExcitedStringDecay::EnergyAndMomentumCorrector
}
#ifdef debug_G4ExcitedStringCorr
if(!success)
if (!success)
{
G4cout << "G4ExcitedStringDecay::EnergyAndMomentumCorrector - Warning"<<G4endl;
G4cout << " Scale not unity at end of iteration loop: "<<TotalCollisionMass<<" "<<Sum<<" "<<Scale<<G4endl;
@@ -415,3 +418,4 @@ G4bool G4ExcitedStringDecay::EnergyAndMomentumCorrector
return success;
}
source/processes/hadronic/models/parton_string/hadronization/src/G4FragmentingString.cc
+19 -9
View File
@@ -95,8 +95,8 @@ G4FragmentingString::G4FragmentingString(const G4ExcitedString &excited)
theStableParton=0;
theDecayParton=0;
if(excited.GetDirection() > 0) {decaying=Left; }
else {decaying=Right;}
if (excited.GetDirection() > 0) {decaying=Left; }
else {decaying=Right;}
Pleft = excited.GetLeftParton()->Get4Momentum();
Pright = excited.GetRightParton()->Get4Momentum();
@@ -162,7 +162,8 @@ G4FragmentingString::G4FragmentingString(const G4FragmentingString &old,
decaying=Right;
} else
{
throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::G4FragmentingString: no decay Direction defined");
throw G4HadronicException(__FILE__, __LINE__,
"G4FragmentingString::G4FragmentingString: no decay Direction defined");
}
Pplus = Pstring.plus(); //old.Pplus - (momentum->e() + momentum->pz());
Pminus = Pstring.minus(); //old.Pminus - (momentum->e() - momentum->pz());
@@ -197,7 +198,8 @@ G4FragmentingString::G4FragmentingString(const G4FragmentingString &old,
decaying=Right;
} else
{
throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::G4FragmentingString: no decay Direction defined");
throw G4HadronicException(__FILE__, __LINE__,
"G4FragmentingString::G4FragmentingString: no decay Direction defined");
}
}
@@ -232,13 +234,14 @@ G4int G4FragmentingString::GetDecayDirection() const
{
if (decaying == Left ) return +1;
else if (decaying == Right) return -1;
else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::GetDecayDirection: decay side UNdefined!");
else throw G4HadronicException(__FILE__, __LINE__,
"G4FragmentingString::GetDecayDirection: decay side UNdefined!");
return 0;
}
//---------------------------------------------------------------------------------
G4bool G4FragmentingString::FourQuarkString() const
G4bool G4FragmentingString::IsAFourQuarkString() const
{
return LeftParton->GetParticleSubType()== "di_quark"
&& RightParton->GetParticleSubType()== "di_quark";
@@ -321,10 +324,17 @@ G4double G4FragmentingString::MassT2() const
}
G4LorentzVector G4FragmentingString::GetPstring()
{ return Pstring; }
{
return Pstring;
}
G4LorentzVector G4FragmentingString::GetPleft()
{ return Pleft; }
{
return Pleft;
}
G4LorentzVector G4FragmentingString::GetPright()
{ return Pright; }
{
return Pright;
}
source/processes/hadronic/models/parton_string/hadronization/src/G4HadronBuilder.cc
+81 -50
View File
@@ -39,24 +39,28 @@
#include "G4HadronicException.hh"
#include "G4ParticleTable.hh"
//#define debug_Hbuilder
G4HadronBuilder::G4HadronBuilder(G4double mesonMix, G4double barionMix,
std::vector<double> scalarMesonMix,
std::vector<double> vectorMesonMix)
std::vector<double> scalarMesonMix,
std::vector<double> vectorMesonMix,
G4double Eta_cProb, G4double Eta_bProb)
{
mesonSpinMix=mesonMix;
barionSpinMix=barionMix;
scalarMesonMixings=scalarMesonMix;
vectorMesonMixings=vectorMesonMix;
mesonSpinMix = mesonMix;
barionSpinMix = barionMix;
scalarMesonMixings = scalarMesonMix;
vectorMesonMixings = vectorMesonMix;
ProbEta_c = Eta_cProb;
ProbEta_b = Eta_bProb;
}
G4ParticleDefinition * G4HadronBuilder::Build(G4ParticleDefinition * black, G4ParticleDefinition * white)
{
if (black->GetParticleSubType()== "di_quark" || white->GetParticleSubType()== "di_quark" ) {
// Barion
Spin spin = (G4UniformRand() < barionSpinMix) ? SpinHalf : SpinThreeHalf;
return Barion(black,white,spin);
} else {
// Meson
Spin spin = (G4UniformRand() < mesonSpinMix) ? SpinZero : SpinOne;
@@ -92,7 +96,7 @@ G4ParticleDefinition * G4HadronBuilder::BuildHighSpin(G4ParticleDefinition * bla
G4ParticleDefinition * G4HadronBuilder::Meson(G4ParticleDefinition * black,
G4ParticleDefinition * white, Spin theSpin)
{
#ifdef G4VERBOSE
#ifdef debug_Hbuilder
// Verify Input Charge
G4double charge = black->GetPDGCharge() + white->GetPDGCharge();
if (std::abs(charge) > 2 || std::abs(3.*charge - 3*G4int(charge*1.001)) > perCent ) // 1.001 to avoid int(.9999) -> 0
@@ -106,9 +110,10 @@ G4ParticleDefinition * G4HadronBuilder::Meson(G4ParticleDefinition * black,
G4cerr << G4endl;
}
#endif
G4int id1= black->GetPDGEncoding();
G4int id2= white->GetPDGEncoding();
G4int id1 = black->GetPDGEncoding();
G4int id2 = white->GetPDGEncoding();
// G4int ifl1= std::max(std::abs(id1), std::abs(id2));
if ( std::abs(id1) < std::abs(id2) )
{
@@ -116,39 +121,61 @@ G4ParticleDefinition * G4HadronBuilder::Meson(G4ParticleDefinition * black,
id1 = id2;
id2 = xchg;
}
G4int abs_id1 = std::abs(id1);
if (std::abs(id1) > 3 )
if ( abs_id1 > 5 )
throw G4HadronicException(__FILE__, __LINE__, "G4HadronBuilder::Meson : Illegal Quark content as input");
G4int PDGEncoding=0;
if (id1 + id2 == 0) {
G4double rmix = G4UniformRand();
G4int imix = 2*std::abs(id1) - 1;
if (theSpin == SpinZero) {
PDGEncoding = 110*(1 + (G4int)(rmix + scalarMesonMixings[imix - 1])
+ (G4int)(rmix + scalarMesonMixings[imix])
) + theSpin;
} else {
PDGEncoding = 110*(1 + (G4int)(rmix + vectorMesonMixings[imix - 1])
+ (G4int)(rmix + vectorMesonMixings[imix])
) + theSpin;
}
if ( abs_id1 < 4) { // light quarks: u, d or s
G4double rmix = G4UniformRand();
G4int imix = 2*std::abs(id1) - 1;
if (theSpin == SpinZero) {
PDGEncoding = 110*(1 + (G4int)(rmix + scalarMesonMixings[imix - 1])
+ (G4int)(rmix + scalarMesonMixings[imix])
) + theSpin;
} else {
PDGEncoding = 110*(1 + (G4int)(rmix + vectorMesonMixings[imix - 1])
+ (G4int)(rmix + vectorMesonMixings[imix])
) + theSpin;
}
} else { // for c and b quarks
PDGEncoding = abs_id1*100 + abs_id1*10;
if (PDGEncoding == 440) {
if ( G4UniformRand() < ProbEta_c ) {
PDGEncoding +=1;
} else {
PDGEncoding +=3;
}
}
if (PDGEncoding == 550) {
if ( G4UniformRand() < ProbEta_b ) {
PDGEncoding +=1;
} else {
PDGEncoding +=3;
}
}
}
} else {
PDGEncoding = 100 * std::abs(id1) + 10 * std::abs(id2) + theSpin;
G4bool IsUp = (std::abs(id1)&1) == 0; // quark 1 up type quark (u or c)
G4bool IsAnti = id1 < 0; // quark 1 is antiquark?
if( (IsUp && IsAnti ) || (!IsUp && !IsAnti ) )
PDGEncoding = - PDGEncoding;
G4bool IsAnti = id1 < 0; // quark 1 is antiquark?
if ( (IsUp && IsAnti ) || (!IsUp && !IsAnti ) ) PDGEncoding = - PDGEncoding;
}
G4ParticleDefinition * MesonDef=
G4ParticleTable::GetParticleTable()->FindParticle(PDGEncoding);
#ifdef G4VERBOSE
#ifdef debug_Hbuilder
if (MesonDef == 0 ) {
G4cerr << " G4HadronBuilder - Warning: No particle for PDGcode= "
<< PDGEncoding << G4endl;
} else if ( ( black->GetPDGCharge() + white->GetPDGCharge()
- MesonDef->GetPDGCharge() ) > perCent ) {
G4cerr << " G4HadronBuilder - Warning: Incorrect Charge : "
@@ -165,9 +192,9 @@ G4ParticleDefinition * G4HadronBuilder::Meson(G4ParticleDefinition * black,
G4ParticleDefinition * G4HadronBuilder::Barion(G4ParticleDefinition * black,
G4ParticleDefinition * white,Spin theSpin)
G4ParticleDefinition * white,Spin theSpin)
{
#ifdef G4VERBOSE
#ifdef debug_Hbuilder
// Verify Input Charge
G4double charge = black->GetPDGCharge() + white->GetPDGCharge();
if (std::abs(charge) > 2 || std::abs(3.*charge - 3*G4int(charge*1.001)) > perCent )
@@ -182,8 +209,9 @@ G4ParticleDefinition * G4HadronBuilder::Barion(G4ParticleDefinition * black,
}
#endif
G4int id1= black->GetPDGEncoding();
G4int id2= white->GetPDGEncoding();
G4int id1 = black->GetPDGEncoding();
G4int id2 = white->GetPDGEncoding();
if ( std::abs(id1) < std::abs(id2) )
{
G4int xchg = id1;
@@ -191,7 +219,7 @@ G4ParticleDefinition * G4HadronBuilder::Barion(G4ParticleDefinition * black,
id2 = xchg;
}
if (std::abs(id1) < 1000 || std::abs(id2) > 3 )
if (std::abs(id1) < 1000 || std::abs(id2) > 5 )
throw G4HadronicException(__FILE__, __LINE__, "G4HadronBuilder::Barion: Illegal quark content as input");
G4int ifl1= std::abs(id1)/1000;
@@ -219,21 +247,23 @@ G4ParticleDefinition * G4HadronBuilder::Barion(G4ParticleDefinition * black,
theSpin = (kfla == kflb && kflb == kflc)? SpinThreeHalf : theSpin;
G4int kfll = 0;
if (theSpin == SpinHalf && kfld > kfle && kfle > kflf) {
// Spin J=1/2 and all three quarks different
// Two states exist: (uds -> lambda or sigma0)
// - lambda: s(ud)0 s : 3122; ie. reverse the two lighter quarks
// - sigma0: s(ud)1 s : 3212
if(diquarkSpin == 1 ) {
if ( kfla == kfld) { // heaviest quark in diquark
kfll = 1;
} else {
kfll = (G4int)(0.25 + G4UniformRand());
}
}
if(diquarkSpin == 3 && kfla != kfld)
kfll = (G4int)(0.75 + G4UniformRand());
}
if (kfld < 4) {
if (theSpin == SpinHalf && kfld > kfle && kfle > kflf) {
// Spin J=1/2 and all three quarks different
// Two states exist: (uds -> lambda or sigma0)
// - lambda: s(ud)0 s : 3122; ie. reverse the two lighter quarks
// - sigma0: s(ud)1 s : 3212
if (diquarkSpin == 1 ) {
if ( kfla == kfld) { // heaviest quark in diquark
kfll = 1;
} else {
kfll = (G4int)(0.25 + G4UniformRand());
}
}
if (diquarkSpin == 3 && kfla != kfld)
kfll = (G4int)(0.75 + G4UniformRand());
}
}
G4int PDGEncoding;
if (kfll == 1)
@@ -247,7 +277,7 @@ G4ParticleDefinition * G4HadronBuilder::Barion(G4ParticleDefinition * black,
G4ParticleDefinition * BarionDef=
G4ParticleTable::GetParticleTable()->FindParticle(PDGEncoding);
#ifdef G4VERBOSE
#ifdef debug_Hbuilder
if (BarionDef == 0 ) {
G4cerr << " G4HadronBuilder - Warning: No particle for PDGcode= "
<< PDGEncoding << G4endl;
@@ -264,3 +294,4 @@ G4ParticleDefinition * G4HadronBuilder::Barion(G4ParticleDefinition * black,
return BarionDef;
}
source/processes/hadronic/models/parton_string/hadronization/src/G4LundStringFragmentation.cc
+167 -607
View File
File diff suppressed because it is too large Load Diff
source/processes/hadronic/models/parton_string/hadronization/src/G4QGSMFragmentation.cc
+365 -469
View File
@@ -46,29 +46,55 @@
// Class G4QGSMFragmentation
//****************************************************************************************
G4QGSMFragmentation::G4QGSMFragmentation() :
arho(0.5), aphi(0.), an(-0.5), ala(-0.75), aksi(-1.), alft(0.5)
G4QGSMFragmentation::G4QGSMFragmentation()
{
MassCut = 0.35*GeV;
SetStrangenessSuppression((1.0 - 0.16)/2.);
SetDiquarkSuppression(0.299);
// For the time being, set to 0.0 the probabilities for c-cbar and b-bbar creation.
SetProbCCbar(0.0); //(0.0033); // According to O.I. Piskunova Yad. Fiz. 56 (1993) 1094
SetProbBBbar(0.0); //(5.0e-5); // According to O.I. Piskunova Yad. Fiz. 56 (1993) 1094
SetDiquarkSuppression(0.32);
SetDiquarkBreakProbability(0.7);
//... pspin_meson is probability to create pseudo-scalar meson
pspin_meson = 0.25; SetVectorMesonProbability(pspin_meson);
//... pspin_barion is probability to create 1/2 barion
pspin_barion = 0.5; SetSpinThreeHalfBarionProbability(pspin_barion);
//... vectorMesonMix[] is quark mixing parameters for vector mesons (Variable spin = 3)
vectorMesonMix[0] = 0.; //0.5
vectorMesonMix[1] = 0.375; //0.5;
vectorMesonMix[2] = 0.0;
vectorMesonMix[3] = 0.375; //0.5;
vectorMesonMix[4] = 1.0;
vectorMesonMix[5] = 1.0;
SetVectorMesonMixings(vectorMesonMix);
SetMinMasses();
arho = 0.5; // alpha_rho0
aphi = 0.0; // alpha_fi
aJPs =-2.2; // alpha_J/Psi
aUps =-8.0; // alpha_Y ??? O. Piskunova Yad. Phys. 56 (1993) 1094.
aksi =-1.0;
alft = 0.5; // 2 * alpha'_R *<Pt^2>
an = -0.5 ;
ala = -0.75; // an - arho/2 + aphi/2
alaC = an - arho/2.0 + aJPs/2.0;
alaB = an - arho/2.0 + aUps/2.0;
aXi = 0.0; // ??
aXiC = 0.0; // ??
aXiB = 0.0; // ??
aXiCC = 0.0; // ??
aXiCB = 0.0; // ??
aXiBB = 0.0; // ??
SetFFq2q();
SetFFq2qq();
SetFFqq2q();
SetFFqq2qq();
// d u s c b
G4int Index[5][5] = { { 0, 1, 2, 3, 4 }, // d
{ 1, 5, 6, 7, 8 }, // u
{ 2, 6, 9, 10, 11 }, // s
{ 3, 7, 10, 12, 13 }, // c
{ 4, 8, 11, 13, 14 } }; // b
for (G4int i = 0; i < 5; i++ ) {
for ( G4int j = 0; j < 5; j++ ) {
IndexDiQ[i][j] = Index[i][j];
}
};
}
G4QGSMFragmentation::~G4QGSMFragmentation()
@@ -78,6 +104,10 @@ G4QGSMFragmentation::~G4QGSMFragmentation()
G4KineticTrackVector* G4QGSMFragmentation::FragmentString(const G4ExcitedString& theString)
{
G4FragmentingString aString(theString);
SetMinimalStringMass(&aString);
#ifdef debug_QGSMfragmentation
G4cout<<G4endl<<"QGSM StringFragm: String Mass "
<<theString.Get4Momentum().mag()<<" Pz "
@@ -95,13 +125,17 @@ G4KineticTrackVector* G4QGSMFragmentation::FragmentString(const G4ExcitedString&
PastInitPhase=true;
// Check if string has enough mass to fragment...
G4KineticTrackVector * LeftVector=LightFragmentationTest(&theString);
G4KineticTrackVector * LeftVector=NULL;
#ifdef debug_QGSMfragmentation
if ( LeftVector != 0 ) G4cout<<"Non fragmentable - the string is converted to one hadron "<<G4endl;
#endif
if ( !IsItFragmentable(&aString) ) {
LeftVector=ProduceOneHadron(&theString);
if ( LeftVector != 0 ) return LeftVector;
#ifdef debug_QGSMfragmentation
if ( LeftVector != 0 ) G4cout<<"Non fragmentable - the string is converted to one hadron "<<G4endl;
#endif
if ( LeftVector != 0 ) return LeftVector;
}
#ifdef debug_QGSMfragmentation
G4cout<<"The string will be fragmented. "<<G4endl;
@@ -208,7 +242,7 @@ G4KineticTrackVector* G4QGSMFragmentation::FragmentString(const G4ExcitedString&
G4LorentzRotation toObserverFrame(toCms.inverse());
for(size_t C1 = 0; C1 < LeftVector->size(); C1++)
for (size_t C1 = 0; C1 < LeftVector->size(); C1++)
{
G4KineticTrack* Hadron = LeftVector->operator[](C1);
G4LorentzVector Momentum = Hadron->Get4Momentum();
@@ -225,155 +259,185 @@ G4KineticTrackVector* G4QGSMFragmentation::FragmentString(const G4ExcitedString&
//----------------------------------------------------------------------------------------------------------
G4double G4QGSMFragmentation::GetLightConeZ(G4double zmin, G4double zmax, G4int PartonEncoding,
G4ParticleDefinition* pHadron, G4double , G4double )
{
#ifdef debug_QGSMfragmentation
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;} // d1=2.0;
else {d1=1.0; d2 = -aphi + alft;} // d1=1.0;
}
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 d1=1.0
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
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=0.0; d2 = 2.*arho - 2.0*an - aphi + alft;} // d1=1.0;
}
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
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)
{
// For future improvements
// if (absHadronCode < 1000) {d1=1.0;} // Meson production
// else {d1=2.0;} // Baryon production
d2 = (alft - (2.*ala - arho));
}
else
{
// if (absHadronCode < 1000) {d1=1.0;} // Meson production
// else {d1=2.0;} // Baryon production
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 //
/* For future improvements
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 );
*/
if ( loopCounter >= maxNumberOfLoops ) {
z = 0.5*(zmin + zmax); // Just a value between zmin and zmax, no physics considerations at all!
}
return z;
}
return z;
G4bool G4QGSMFragmentation::IsItFragmentable(const G4FragmentingString * const string)
{
return sqr( PossibleHadronMass(string) + MassCut ) < string->Mass2();
}
//----------------------------------------------------------------------------------------------------------
G4bool G4QGSMFragmentation::StopFragmenting(const G4FragmentingString * const string)
{
SetMinimalStringMass(string);
if ( MinimalStringMass < 0.0 ) return true;
if (string->IsAFourQuarkString())
{
return G4UniformRand() < G4Exp(-0.005*(string->Mass() - MinimalStringMass));
} else {
G4bool Result = G4UniformRand() <
G4Exp(-0.66e-6*(string->Mass()*string->Mass() - MinimalStringMass*MinimalStringMass));
// G4bool Result = string->Mass() < MinimalStringMass + 150.*MeV*G4UniformRand(); // a'la LUND
#ifdef debug_QGSMfragmentation
G4cout<<"StopFragmenting MinimalStringMass string->Mass() "<<MinimalStringMass<<" "<<string->Mass()<<G4endl;
G4cout<<"StopFragmenting - Yes/No "<<Result<<G4endl;
#endif
return Result;
}
}
//-----------------------------------------------------------------------------
G4KineticTrack * G4QGSMFragmentation::Splitup( G4FragmentingString *string,
G4FragmentingString *&newString )
{
#ifdef debug_QGSMfragmentation
G4cout<<G4endl;
G4cout<<"Start SplitUP (G4VLongitudinalStringDecay) ========================="<<G4endl;
G4cout<<"String partons: " <<string->GetLeftParton()->GetPDGEncoding()<<" "
<<string->GetRightParton()->GetPDGEncoding()<<" "
<<"Direction " <<string->GetDecayDirection()<<G4endl;
#endif
//... random choice of string end to use for creating the hadron (decay)
G4int SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
if (SideOfDecay < 0)
{
string->SetLeftPartonStable();
} else
{
string->SetRightPartonStable();
}
G4ParticleDefinition *newStringEnd;
G4ParticleDefinition * HadronDefinition;
if (string->DecayIsQuark())
{
G4double ProbDqADq = GetDiquarkSuppress();
G4int NumberOfpossibleBaryons = 2;
if (string->GetLeftParton()->GetParticleSubType() != "quark") NumberOfpossibleBaryons++;
if (string->GetRightParton()->GetParticleSubType() != "quark") NumberOfpossibleBaryons++;
G4double ActualProb = ProbDqADq ;
ActualProb *= (1.0-G4Exp(2.0*(1.0 - string->Mass()/(NumberOfpossibleBaryons*1400.0))));
SetDiquarkSuppression(ActualProb);
HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
SetDiquarkSuppression(ProbDqADq);
} else {
HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
}
if ( HadronDefinition == NULL ) return NULL;
#ifdef debug_QGSMfragmentation
G4cout<<"The parton "<<string->GetDecayParton()->GetPDGEncoding()<<" "
<<" produces hadron "<<HadronDefinition->GetParticleName()
<<" and is transformed to "<<newStringEnd->GetPDGEncoding()<<G4endl;
G4cout<<"The side of the string decay Left/Right (1/-1) "<<SideOfDecay<<G4endl;
#endif
// 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
#ifdef debug_QGSMfragmentation
G4cout<<"An attempt to determine its energy (SplitEandP)"<<G4endl;
#endif
G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
delete newString; newString=0;
G4KineticTrack * Hadron =0;
if ( HadronMomentum != 0 ) {
#ifdef debug_QGSMfragmentation
G4cout<<"The attempt was successful"<<G4endl;
#endif
G4ThreeVector Pos;
Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
newString=new G4FragmentingString(*string,newStringEnd,HadronMomentum);
delete HadronMomentum;
}
else
{
#ifdef debug_QGSMfragmentation
G4cout<<"The attempt was not successful !!!"<<G4endl;
#endif
}
#ifdef debug_VStringDecay
G4cout<<"End SplitUP (G4VLongitudinalStringDecay) ====================="<<G4endl;
#endif
return Hadron;
}
//-----------------------------------------------------------------------------
G4ParticleDefinition *G4QGSMFragmentation::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
G4double StrSup=GetStrangeSuppress();
SetStrangenessSuppression((1.0 - 0.07)/2.);
pDefPair QuarkPair = CreatePartonPair(IsParticle,false); // no diquarks wanted
SetStrangenessSuppression(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);
DecayQuark = decayQuarkEncoding;
NewQuark = QuarkPair.first->GetPDGEncoding();
return had;
} 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
SetStrangenessSuppression((1.0 - 0.07)/2.);
pDefPair QuarkPair = CreatePartonPair(IsParticle,false); // no diquarks wanted
SetStrangenessSuppression(StrSup);
created = QuarkPair.second;
DecayQuark = decay->GetPDGEncoding();
NewQuark = created->GetPDGEncoding();
G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
return had;
}
}
//-----------------------------------------------------------------------------------------
G4LorentzVector * G4QGSMFragmentation::SplitEandP(G4ParticleDefinition * pHadron,
@@ -384,6 +448,8 @@ G4LorentzVector * G4QGSMFragmentation::SplitEandP(G4ParticleDefinition * pHadron
SetMinimalStringMass(NewString);
if ( MinimalStringMass < 0.0 ) return nullptr;
#ifdef debug_QGSMfragmentation
G4cout<<"G4QGSMFragmentation::SplitEandP "<<pHadron->GetParticleName()<<G4endl;
G4cout<<"String 4 mom, String M "<<string->Get4Momentum()<<" "<<string->Mass()<<G4endl;
@@ -466,6 +532,70 @@ G4LorentzVector * G4QGSMFragmentation::SplitEandP(G4ParticleDefinition * pHadron
return a4Momentum;
}
//----------------------------------------------------------------------------------------------------------
G4double G4QGSMFragmentation::GetLightConeZ(G4double zmin, G4double zmax, G4int /* PartonEncoding */,
G4ParticleDefinition* /* pHadron */, G4double , G4double )
{
#ifdef debug_QGSMfragmentation
G4cout<<"GetLightConeZ zmin zmax Parton pHadron "<<zmin<<" "<<zmax<<" "<< /* PartonEncoding */
<<" "<</* pHadron->GetParticleName() */ <<G4endl;
#endif
G4double z(0.);
G4int DiQold(0), DiQnew(0);
G4double d1(-1.0), d2(0.);
G4double invD1(0.),invD2(0.), r1(0.),r2(0.),r12(0.);
G4int absDecayQuarkCode = std::abs( DecayQuark );
G4int absNewQuarkCode = std::abs( NewQuark );
G4int q1(0), q2(0);
// q1 = absDecayQuarkCode/1000; q2 = (absDecayQuarkCode % 1000)/100;
G4int qA(0), qB(0);
// qA = absNewQuarkCode/1000; qB = (absNewQuarkCode % 1000)/100;
if ( (absDecayQuarkCode < 6) && (absNewQuarkCode < 6) ) {
d1 = FFq2q[absDecayQuarkCode-1][absNewQuarkCode-1][0]; d2 = FFq2q[absDecayQuarkCode-1][absNewQuarkCode-1][1];
}
if ( (absDecayQuarkCode < 6) && (absNewQuarkCode > 6) ) {
qA = absNewQuarkCode/1000; qB = (absNewQuarkCode % 1000)/100; DiQnew = IndexDiQ[qA-1][qB-1];
d1 = FFq2qq[absDecayQuarkCode-1][DiQnew][0]; d2 = FFq2q[absDecayQuarkCode-1][DiQnew][1];
}
if ( (absDecayQuarkCode > 6) && (absNewQuarkCode < 6) ) {
q1 = absDecayQuarkCode/1000; q2 = (absDecayQuarkCode % 1000)/100; DiQold = IndexDiQ[q1-1][q2-1];
d1 = FFqq2q[DiQold][absNewQuarkCode-1][0]; d2 = FFqq2q[DiQold][absNewQuarkCode-1][1];
}
if ( d1 < 0. ) {
q1 = absDecayQuarkCode/1000; q2 = (absDecayQuarkCode % 1000)/100; DiQold = IndexDiQ[q1-1][q2-1];
d1 = FFqq2qq[DiQold][absNewQuarkCode-1][0]; d2 = FFqq2qq[DiQold][absNewQuarkCode-1][1];
}
d1+=1.0; d2+=1.0;
invD1=1./d1; invD2=1./d2;
const G4int maxNumberOfLoops = 10000;
G4int loopCounter = 0;
do // Jong's algorithm
{
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;
}
//-----------------------------------------------------------------------------------------
@@ -486,15 +616,19 @@ G4bool G4QGSMFragmentation::SplitLast(G4FragmentingString * string,
#endif
G4int cClusterInterrupt = 0;
G4ParticleDefinition * LeftHadron, * RightHadron;
G4ParticleDefinition *LeftHadron = nullptr;
G4ParticleDefinition *RightHadron = nullptr;
const G4int maxNumberOfLoops = 1000;
G4int loopCounter = 0;
G4double LeftHadronMass(0.); G4double RightHadronMass(0.);
do
{
if (cClusterInterrupt++ >= ClusterLoopInterrupt)
{
return false;
}
LeftHadronMass = -MaxMass; RightHadronMass = -MaxMass;
G4ParticleDefinition * quark = NULL;
string->SetLeftPartonStable(); // to query quark contents..
@@ -503,8 +637,9 @@ G4bool G4QGSMFragmentation::SplitLast(G4FragmentingString * string,
{
//... there are quarks on cluster ends
G4int IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? -1 : +1; // if we have a quark,
// we need antiquark or diquark
G4int IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? -1 : +1;
// if we have a quark, we need antiquark or diquark
pDefPair QuarkPair = CreatePartonPair(IsParticle);
quark = QuarkPair.second;
@@ -528,9 +663,15 @@ G4bool G4QGSMFragmentation::SplitLast(G4FragmentingString * string,
LeftHadron=hadronizer->BuildLowSpin(QuarkPair.first, string->GetLeftParton());
}
if ( LeftHadron == NULL ) continue;
RightHadron = hadronizer->BuildLowSpin(string->GetRightParton(), quark);
} while ( ( ResidualMass <= LeftHadron->GetPDGMass() + RightHadron->GetPDGMass() )
if ( RightHadron == NULL ) continue;
LeftHadronMass = LeftHadron->GetPDGMass();
RightHadronMass = RightHadron->GetPDGMass();
} while ( ( ResidualMass <= LeftHadronMass + RightHadronMass )
&& ++loopCounter < maxNumberOfLoops ); /* Loop checking, 07.08.2015, A.Ribon */
if ( loopCounter >= maxNumberOfLoops ) {
@@ -555,38 +696,8 @@ G4bool G4QGSMFragmentation::SplitLast(G4FragmentingString * string,
RightVector->push_back(new G4KineticTrack(RightHadron, 0, Pos, RightMom));
return true;
}
//----------------------------------------------------------------------------------------------------------
G4bool G4QGSMFragmentation::IsFragmentable(const G4FragmentingString * const string)
{
return sqr( FragmentationMass(string) + MassCut ) < string->Mass2();
}
//----------------------------------------------------------------------------------------------------------
G4bool G4QGSMFragmentation::StopFragmenting(const G4FragmentingString * const string)
{
SetMinimalStringMass(string);
if (string->FourQuarkString())
{
return G4UniformRand() < G4Exp(-0.0005*(string->Mass() - MinimalStringMass));
} else {
G4bool Result = G4UniformRand() <
G4Exp(-0.66e-6*(string->Mass()*string->Mass() - MinimalStringMass*MinimalStringMass));
// G4bool Result = string->Mass() < MinimalStringMass + 150.*MeV*G4UniformRand(); // a'la LUND
#ifdef debug_QGSMfragmentation
G4cout<<"StopFragmenting MinimalStringMass string->Mass() "<<MinimalStringMass<<" "<<string->Mass()<<G4endl;
G4cout<<"StopFragmenting - Yes/No "<<Result<<G4endl;
#endif
return Result;
}
}
//----------------------------------------------------------------------------------------------------------
void G4QGSMFragmentation::Sample4Momentum(G4LorentzVector* Mom , G4double Mass ,
@@ -610,280 +721,65 @@ void G4QGSMFragmentation::Sample4Momentum(G4LorentzVector* Mom , G4double Mas
AntiMom->setE (std::sqrt(Pabs*Pabs + AntiMass*AntiMass));
}
//-----------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------
G4ParticleDefinition *G4QGSMFragmentation::DiQuarkSplitup( G4ParticleDefinition* decay,
G4ParticleDefinition *&created )
void G4QGSMFragmentation::SetFFq2q() // q-> q' + Meson (q anti q')
{
//... 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();
SetStrangenessSuppression((1.0 - 0.07)/2.);
pDefPair QuarkPair = CreatePartonPair(IsParticle,false); // no diquarks wanted
SetStrangenessSuppression(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;
} 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
SetStrangenessSuppression((1.0 - 0.07)/2.);
pDefPair QuarkPair = CreatePartonPair(IsParticle,false); // no diquarks wanted
SetStrangenessSuppression(StrSup);
created = QuarkPair.second;
G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
return had;
}
for (G4int i=0; i < 5; i++) {
FFq2q[i][0][0] = 2.0 ; FFq2q[i][0][1] = -arho + alft; // q->d + (q dbar) Pi0, Eta, Eta', Rho0, omega
FFq2q[i][1][0] = 2.0 ; FFq2q[i][1][1] = -arho + alft; // q->u + (q ubar) Pi-, Rho-
FFq2q[i][2][0] = 1.0 ; FFq2q[i][2][1] = -aphi + alft; // q->s + (q sbar) K0, K*0
FFq2q[i][3][0] = 1.0 ; FFq2q[i][3][1] = -aJPs + alft; // q->c + (q+cbar) D-, D*-
FFq2q[i][4][0] = 1.0 ; FFq2q[i][4][1] = -aUps + alft; // q->b + (q bbar) EtaB, Upsilon
}
}
//-----------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------
G4KineticTrack * G4QGSMFragmentation::Splitup( G4FragmentingString *string,
G4FragmentingString *&newString)
void G4QGSMFragmentation::SetFFq2qq() // q-> anti (q1'q2') + Baryon (q + q1 + q2)
{
#ifdef debug_QGSMfragmentation
G4cout<<G4endl;
G4cout<<"Start SplitUP (G4VLongitudinalStringDecay) ========================="<<G4endl;
G4cout<<"String partons: " <<string->GetLeftParton()->GetPDGEncoding()<<" "
<<string->GetRightParton()->GetPDGEncoding()<<" "
<<"Direction " <<string->GetDecayDirection()<<G4endl;
#endif
//... random choice of string end to use for creating the hadron (decay)
G4int SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
if (SideOfDecay < 0)
{
string->SetLeftPartonStable();
} else
{
string->SetRightPartonStable();
}
G4ParticleDefinition *newStringEnd;
G4ParticleDefinition * HadronDefinition;
if (string->DecayIsQuark())
{
G4double ProbDqADq = GetDiquarkSuppress();
G4int NumberOfpossibleBaryons = 2;
if (string->GetLeftParton()->GetParticleSubType() != "quark") NumberOfpossibleBaryons++;
if (string->GetRightParton()->GetParticleSubType() != "quark") NumberOfpossibleBaryons++;
G4double ActualProb = ProbDqADq ;
ActualProb *= (1.0-G4Exp(2.0*(1.0 - string->Mass()/(NumberOfpossibleBaryons*1400.0))));
SetDiquarkSuppression(ActualProb);
HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
SetDiquarkSuppression(ProbDqADq);
} else {
HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
}
#ifdef debug_QGSMfragmentation
G4cout<<"The parton "<<string->GetDecayParton()->GetPDGEncoding()<<" "
<<" produces hadron "<<HadronDefinition->GetParticleName()
<<" and is transformed to "<<newStringEnd->GetPDGEncoding()<<G4endl;
G4cout<<"The side of the string decay Left/Right (1/-1) "<<SideOfDecay<<G4endl;
#endif
// 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
#ifdef debug_QGSMfragmentation
G4cout<<"An attempt to determine its energy (SplitEandP)"<<G4endl;
#endif
G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
delete newString; newString=0;
G4KineticTrack * Hadron =0;
if ( HadronMomentum != 0 ) {
#ifdef debug_QGSMfragmentation
G4cout<<"The attempt was successful"<<G4endl;
#endif
G4ThreeVector Pos;
Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
newString=new G4FragmentingString(*string,newStringEnd,HadronMomentum);
delete HadronMomentum;
}
else
{
#ifdef debug_QGSMfragmentation
G4cout<<"The attempt was not successful !!!"<<G4endl;
#endif
}
#ifdef debug_VStringDecay
G4cout<<"End SplitUP (G4VLongitudinalStringDecay) ====================="<<G4endl;
#endif
return Hadron;
for (G4int i=0; i < 5; i++) {
FFq2qq[i][ 0][0] = 0.0 ; FFq2qq[i][ 0][1] = arho - 2.0*an + alft; // q->dd bar + (q dd)
FFq2qq[i][ 1][0] = 0.0 ; FFq2qq[i][ 1][1] = arho - 2.0*an + alft; // q->ud bar + (q ud)
FFq2qq[i][ 2][0] = 0.0 ; FFq2qq[i][ 2][1] = arho - 2.0*ala + alft; // q->sd bar + (q sd)
FFq2qq[i][ 3][0] = 0.0 ; FFq2qq[i][ 3][1] = arho - 2.0*alaC + alft; // q->cd bar + (q cd)
FFq2qq[i][ 4][0] = 0.0 ; FFq2qq[i][ 4][1] = arho - 2.0*alaB + alft; // q->bd bar + (q bd)
FFq2qq[i][ 5][0] = 0.0 ; FFq2qq[i][ 5][1] = arho - 2.0*an + alft; // q->uu bar + (q uu)
FFq2qq[i][ 6][0] = 0.0 ; FFq2qq[i][ 6][1] = arho - 2.0*ala + alft; // q->su bar + (q su)
FFq2qq[i][ 7][0] = 0.0 ; FFq2qq[i][ 7][1] = arho - 2.0*alaC + alft; // q->cu bar + (q cu)
FFq2qq[i][ 8][0] = 0.0 ; FFq2qq[i][ 8][1] = arho - 2.0*alaB + alft; // q->bu bar + (q bu)
FFq2qq[i][ 9][0] = 0.0 ; FFq2qq[i][ 9][1] = arho - 2.0*aXi + alft; // q->ss bar + (q ss)
FFq2qq[i][10][0] = 0.0 ; FFq2qq[i][10][1] = arho - 2.0*aXiC + alft; // q->cs bar + (q cs)
FFq2qq[i][11][0] = 0.0 ; FFq2qq[i][11][1] = arho - 2.0*aXiB + alft; // q->bs bar + (q bc)
FFq2qq[i][12][0] = 0.0 ; FFq2qq[i][12][1] = arho - 2.0*aXiCC + alft; // q->cc bar + (q cc)
FFq2qq[i][13][0] = 0.0 ; FFq2qq[i][13][1] = arho - 2.0*aXiCB + alft; // q->bc bar + (q bc)
FFq2qq[i][14][0] = 0.0 ; FFq2qq[i][14][1] = arho - 2.0*aXiBB + alft; // q->bb bar + (q bb)
}
}
//---------------------------------------------------------------
void G4QGSMFragmentation::SetMinMasses()
//----------------------------------------------------------------------------------------------------------
void G4QGSMFragmentation::SetFFqq2q() // q1q2-> anti(q') + Baryon (q1 + q2 + q')
{
// ------ For estimation of a minimal string mass ---------------
Mass_of_light_quark =140.*MeV;
Mass_of_heavy_quark =500.*MeV;
Mass_of_string_junction=720.*MeV;
G4double minMQQbarStr[3][3] ={ {350.0, 350.0, 710.0}, //DDbar, DUbar, DSbar in MeV
{350.0, 350.0, 710.0}, //UDbar, UUbar, USbar in Mev
{710.0, 710.0,1070.0 }};//SDbar, SUbar, SSbar in MeV
for (G4int i=0; i<3; i++){ for (G4int j=0; j<3; j++){minMassQQbarStr[i][j]=minMQQbarStr[i][j];};};
G4double minMQDiQStr[3][3][3] = {{{1160., 1160., 1340.}, {1160., 1160., 1340.}, {1340., 1340., 1540.},}, //d-dd, d-du, d-ds, d-ud, d-uu, d-us, d-sd, d-su, d-ss
{{1160., 1160., 1340.}, {1160., 1160., 1340.}, {1340., 1340., 1540.},}, //u-dd, u-du, u-ds, u-ud, u-uu, u-us, u-sd, u-su, u-ss
{{1520., 1520., 1690.}, {1520., 1520., 1690.}, {1690., 1690., 1890. }}};//s-dd, s-du, s-ds, s-ud, s-uu, s-us, s-sd, s-su, s-ss
for (G4int i=0; i<3; i++){ for (G4int j=0; j<3; j++){ for (G4int k=0; k<3; k++){minMassQDiQStr[i][j][k]=minMQDiQStr[i][j][k];};};};
// ------ An estimated minimal string mass ----------------------
MinimalStringMass = 0.;
MinimalStringMass2 = 0.;
for (G4int i=0; i < 15; i++) {
FFqq2q[i][0][0] = 2.0*(arho - an); FFqq2q[i][0][1] = -arho + alft;
FFqq2q[i][1][0] = 2.0*(arho - an); FFqq2q[i][1][1] = -arho + alft;
FFqq2q[i][2][0] = 2.0*(arho - an); FFqq2q[i][2][1] = -aphi + alft;
FFqq2q[i][3][0] = 2.0*(arho - an); FFqq2q[i][3][1] = -aJPs + alft;
FFqq2q[i][4][0] = 2.0*(arho - an); FFqq2q[i][4][1] = -aUps + alft;
}
}
//--------------------------------------------------------------------------------------
void G4QGSMFragmentation::SetMinimalStringMass(const G4FragmentingString * const string)
//----------------------------------------------------------------------------------------------------------
void G4QGSMFragmentation::SetFFqq2qq() // q1(q2)-> q'(q2) + Meson(q1 anti q')
{
G4double EstimatedMass=0.;
G4int Qleft =std::abs(string->GetLeftParton()->GetPDGEncoding());
G4int Qright=std::abs(string->GetRightParton()->GetPDGEncoding());
if ((Qleft < 4) && (Qright < 4)) { // Q-Qbar string
EstimatedMass=minMassQQbarStr[Qleft-1][Qright-1];
MinimalStringMass=EstimatedMass;
SetMinimalStringMass2(EstimatedMass);
return;
}
if ((Qleft < 4) && (Qright > 1000)) { // Q - DiQ string
G4int q1=Qright/1000;
G4int q2=(Qright/100)%10;
EstimatedMass=minMassQDiQStr[Qleft-1][q1-1][q2-1];
MinimalStringMass=EstimatedMass;
SetMinimalStringMass2(EstimatedMass);
return;
}
if ((Qleft > 1000) && (Qright < 4)) { // DiQ - Q string
G4int q1=Qleft/1000;
G4int q2=(Qleft/100)%10;
EstimatedMass=minMassQDiQStr[Qright-1][q1-1][q2-1];
MinimalStringMass=EstimatedMass;
SetMinimalStringMass2(EstimatedMass);
return;
}
// DiQuark - Anti DiQuark string -----------------
G4int Number_of_quarks=0;
G4int Number_of_squarks=0;
G4double StringM=string->Get4Momentum().mag();
#ifdef debug_QGSMfragmentation
// G4cout<<"MinStringMass// Input String mass "<<string->Get4Momentum().mag()<<" Qleft "<<Qleft<<G4endl;
#endif
if ( Qleft > 1000)
{
Number_of_quarks+=2;
G4int q1=Qleft/1000;
if ( q1 < 3) {EstimatedMass +=Mass_of_light_quark;}
if ( q1 > 2) {EstimatedMass +=Mass_of_heavy_quark; Number_of_squarks++;}
G4int q2=(Qleft/100)%10;
if ( q2 < 3) {EstimatedMass +=Mass_of_light_quark;}
if ( q2 > 2) {EstimatedMass +=Mass_of_heavy_quark; Number_of_squarks++;}
}
#ifdef debug_QGSMfragmentation
// G4cout<<"Min mass with Qleft "<<Qleft<<" "<<EstimatedMass<<G4endl;
#endif
if ( Qright > 1000)
{
Number_of_quarks+=2;
G4int q1=Qright/1000;
if ( q1 < 3) {EstimatedMass +=Mass_of_light_quark;}
if ( q1 > 2) {EstimatedMass +=Mass_of_heavy_quark; Number_of_squarks++;}
G4int q2=(Qright/100)%10;
if ( q2 < 3) {EstimatedMass +=Mass_of_light_quark;}
if ( q2 > 2) {EstimatedMass +=Mass_of_heavy_quark; Number_of_squarks++;}
//EstimatedMass +=Mass_of_string_junction;
}
#ifdef debug_QGSMfragmentation
// G4cout<<"Min mass with Qleft and Qright "<<Qright<<" "<<EstimatedMass<<G4endl;
// G4cout<<"Number_of_quarks "<<Number_of_quarks<<" Number_of_squarks "<<Number_of_squarks<<G4endl;
#endif
if (Number_of_quarks==4)
{
if (StringM > 1880.) { // 2*Mn = 1880
if (Number_of_squarks==0) {EstimatedMass += 1320.*MeV;} //560+1320=1880=2*Mn
else if (Number_of_squarks==1) {EstimatedMass += 1150.*MeV;} //920+1150=2070=M(Lam+N)
else if (Number_of_squarks==2) {EstimatedMass += 960.*MeV;} //1280+960=2240= 2*M Lam
else if (Number_of_squarks==3) {EstimatedMass += 800.*MeV;} //1640+800=2440=Mxi+Mlam
else if (Number_of_squarks==4) {EstimatedMass += 640.*MeV;} //2000+640=2640=2*Mxi
else {}
}
else
{
if (Number_of_squarks < 3) {EstimatedMass -= 200.*MeV;}
else if (Number_of_squarks==3) {EstimatedMass -= 50.*MeV;}
else if (Number_of_squarks==4) {EstimatedMass -= 40.*MeV;}
else {}
}
}
#ifdef debug_QGSMfragmentation
// G4cout<<"EstimatedMass -------------------- "<<EstimatedMass <<G4endl;
#endif
MinimalStringMass=EstimatedMass;
SetMinimalStringMass2(EstimatedMass);
}
//--------------------------------------------------------------------------------------
void G4QGSMFragmentation::SetMinimalStringMass2(const G4double aValue)
{
MinimalStringMass2=aValue * aValue;
for (G4int i=0; i < 15; i++) {
FFqq2qq[i][0][0] = 0. ; FFqq2qq[i][0][1] = 2.0*arho - 2.0*an -arho + alft; // dd -> dd + Pi0 (d d bar)
FFqq2qq[i][1][0] = 0. ; FFqq2qq[i][1][1] = 2.0*arho - 2.0*an -arho + alft; // dd -> ud + Pi- (d u bar)
FFqq2qq[i][2][0] = 0. ; FFqq2qq[i][2][1] = 2.0*arho - 2.0*an -aphi + alft; // dd -> sd + K0 (d s bar)
FFqq2qq[i][3][0] = 0. ; FFqq2qq[i][3][1] = 2.0*arho - 2.0*an -aJPs + alft; // dd -> cd + D- (d c bar)
FFqq2qq[i][4][0] = 0. ; FFqq2qq[i][4][1] = 2.0*arho - 2.0*an -aUps + alft; // dd -> bd + B0 (d b bar)
}
}
source/processes/hadronic/models/parton_string/hadronization/src/G4VKinkyStringDecay.cc
-115
View File
@@ -1,115 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// Maxim Komogorov
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
//
// History: first implementation, Maxim Komogorov, 10-Oct-1998
// -----------------------------------------------------------------------------
#include "G4VKinkyStringDecay.hh"
#include "G4KineticTrackVector.hh"
#include "G4KineticTrack.hh"
#include "Randomize.hh"
//*****************************************************************************************************
G4VKinkyStringDecay::G4VKinkyStringDecay(G4VLongitudinalStringDecay* theModal)
{
this->SetLongitudinalStringDecay(theModal);
}
//*****************************************************************************************************
G4double G4VKinkyStringDecay::GetLightConeGluonZ(G4double zmin, G4double zmax)
{
G4double z, yf;
do {
z = zmin + G4UniformRand()*(zmax-zmin);
yf = z*z +sqr(1 - z);
}
while (G4UniformRand() > yf); /* Loop checking, 07.08.2015, A.Ribon */
return z;
}
//*****************************************************************************************************
G4KineticTrackVector* G4VKinkyStringDecay::FragmentString(const G4ExcitedString& String)
{
G4LorentzVector Mom = String.GetGluon()->Get4Momentum();
G4ThreeVector Pos = String.GetGluon()->GetPosition();
G4int QuarkEncoding = theLongitudinalStringDecay->SampleQuarkFlavor();
G4ThreeVector Pquark=theLongitudinalStringDecay->SampleQuarkPt();
G4double Pt2 = Pquark.mag2();
G4double z = GetLightConeGluonZ(0, 1);
G4double w = Mom.e() + Mom.pz();
//... now compute quark longitudinal momentum and energy
Pquark.setZ( (z*w - Pt2/(z*w))*0.5);
G4double E = (z*w + Pt2/(z*w))*0.5;
G4Parton* AntiColor = new G4Parton(-QuarkEncoding);
AntiColor->SetPosition(Pos);
G4LorentzVector AntiColorMom(-Pquark, E);
AntiColor->Set4Momentum(AntiColorMom);
G4Parton* Color = new G4Parton(*String.GetColorParton());
G4ExcitedString Str1(Color, AntiColor, String.GetDirection());
G4KineticTrackVector* KTV1 = theLongitudinalStringDecay->FragmentString(Str1);
Color = new G4Parton(QuarkEncoding);
Color->SetPosition(Pos);
G4LorentzVector ColorMom(Pquark, E);
Color->Set4Momentum(ColorMom);
AntiColor = new G4Parton(*String.GetAntiColorParton());
G4ExcitedString Str2(Color, AntiColor, String.GetDirection());
G4KineticTrackVector* KTV2 = theLongitudinalStringDecay->FragmentString(Str2);
if (KTV1 && KTV2)
while(!KTV2->empty()) /* Loop checking, 07.08.2015, A.Ribon */
{
KTV1->push_back(KTV2->back());
KTV1->erase(KTV1->end()-1);
}
return KTV1;
}
//*****************************************************************************************************
source/processes/hadronic/models/parton_string/hadronization/src/G4VLongitudinalStringDecay.cc
+646 -75
View File
@@ -61,21 +61,19 @@
//********************************************************************************
// Constructors
G4VLongitudinalStringDecay::G4VLongitudinalStringDecay()
G4VLongitudinalStringDecay::G4VLongitudinalStringDecay() : ProbCCbar(0.0), ProbBBbar(0.0)
{
MassCut = 0.35*GeV;
ClusterMass = 0.15*GeV;
MassCut = 210.0*MeV; // Mpi + Delta
SmoothParam = 0.9;
StringLoopInterrupt = 1000;
ClusterLoopInterrupt = 500;
StringLoopInterrupt = 1000;
ClusterLoopInterrupt = 500;
// Changable Parameters below.
SigmaQT = 0.5 * GeV;
StrangeSuppress = 0.44; // 27 % strange quarks produced, ie. u:d:s=1:1:0.27
DiquarkSuppress = 0.07;
DiquarkBreakProb = 0.1;
StrangeSuppress = 0.44; // =0.27/2.27 suppresion of strange quark pait prodution, ie. u:d:s=1:1:0.27
DiquarkSuppress = 0.07; // Probability of qq-qqbar pair production
DiquarkBreakProb = 0.1; // Probability of (qq)->h+(qq)'
//... pspin_meson is probability to create pseudo-scalar meson
pspin_meson = 0.5;
@@ -85,26 +83,39 @@ G4VLongitudinalStringDecay::G4VLongitudinalStringDecay()
//... vectorMesonMix[] is quark mixing parameters for vector mesons (Variable spin = 3)
vectorMesonMix.resize(6);
vectorMesonMix[0] = 0.;
vectorMesonMix[0] = 0.0;
vectorMesonMix[1] = 0.375;
vectorMesonMix[2] = 0.0;
vectorMesonMix[3] = 0.375;
vectorMesonMix[4] = 1.0;
vectorMesonMix[5] = 1.0;
vectorMesonMix[5] = 1.0;
//... scalarMesonMix[] is quark mixing parameters for scalar mesons (Variable spin=1)
scalarMesonMix.resize(6);
scalarMesonMix[0] = 0.5;
scalarMesonMix[1] = 0.25;
scalarMesonMix[2] = 0.5;
scalarMesonMix[3] = 0.25;
scalarMesonMix[4] = 1.0;
scalarMesonMix[5] = 0.5;
scalarMesonMix[0] = 0.5;
scalarMesonMix[1] = 0.25;
scalarMesonMix[2] = 0.5;
scalarMesonMix[3] = 0.25;
scalarMesonMix[4] = 1.0;
scalarMesonMix[5] = 0.5;
// For the time being, set to 0.0 the probabilities for c-cbar and b-bbar creation.
SetProbCCbar(0.0); //SetProbCCbar(0.43e-11); // Probability of CCbar pair creation
//Pythia8 and Pythia 6.4 Comp. Phys. Commun. 191 (2015) 159; arXiv:1410.3012
SetProbEta_c(0.1); // Mixing of Eta_c and J/Psi
SetProbBBbar(0.0); // Probability of BBbar pair creation,
SetProbEta_b(0.0); // Mixing of Eta_b and Ipsilon_b
// Parameters may be changed until the first fragmentation starts
PastInitPhase=false;
hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
scalarMesonMix,vectorMesonMix);
scalarMesonMix,vectorMesonMix,
ProbEta_c, ProbEta_b);
MaxMass=-350.0*GeV; // If there will be a particle with mass larger than Higgs the value must be changed.
SetMinMasses(); // Re-calculation of minimal mass of strings and weights of particles in 2-part. decays
Kappa = 1.0 * GeV/fermi;
}
@@ -137,13 +148,14 @@ G4bool G4VLongitudinalStringDecay::operator!=(const G4VLongitudinalStringDecay &
//***********************************************************************************
// For changing Mass Cut used for selection of very small mass strings
void G4VLongitudinalStringDecay::SetMassCut(G4double aValue){MassCut=aValue;}
G4double G4VLongitudinalStringDecay::GetMassCut(){return MassCut;}
void G4VLongitudinalStringDecay::SetMassCut(G4double aValue){ MassCut=aValue; }
G4double G4VLongitudinalStringDecay::GetMassCut() { return MassCut; }
//-----------------------------------------------------------------------------
// For handling a string with very low mass
G4KineticTrackVector* G4VLongitudinalStringDecay::LightFragmentationTest(const G4ExcitedString * const string)
G4KineticTrackVector* G4VLongitudinalStringDecay::ProduceOneHadron(const G4ExcitedString * const string)
{
// Check string decay threshold
G4KineticTrackVector * result=0; // return 0 when string exceeds the mass cut
@@ -151,11 +163,19 @@ G4KineticTrackVector* G4VLongitudinalStringDecay::LightFragmentationTest(const G
pDefPair hadrons((G4ParticleDefinition *)0,(G4ParticleDefinition *)0);
G4FragmentingString aString(*string);
if ( sqr(FragmentationMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
#ifdef debug_VStringDecay
G4cout<<"G4VLongitudinalStringDecay::ProduceOneHadron: PossibleHmass StrMass "
<<aString.Mass()<<" MassCut "<<MassCut<<G4endl;
G4cout<<"G4VLongitudinalStringDecay::ProduceOneHadron: PossibleHmass StrMass WWW "
<<aString.Mass()<<G4endl;
#endif
if ( sqr(PossibleHadronMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
return 0;
}
// The string mass is very low ---------------------------
// The string mass has low mass---------------------------
result=new G4KineticTrackVector;
@@ -170,11 +190,12 @@ G4KineticTrackVector* G4VLongitudinalStringDecay::LightFragmentationTest(const G
<< string->Get4Momentum().m() << G4endl;
#endif
G4ThreeVector Mom3 = string->Get4Momentum().vect();
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
{
// I do not know if this part work?
//... string was qq--qqbar type: Build two stable hadrons,
#ifdef debug_VStringDecay
@@ -198,13 +219,12 @@ G4KineticTrackVector* G4VLongitudinalStringDecay::LightFragmentationTest(const G
}
return result;
}
//----------------------------------------------------------------------------------------
G4double G4VLongitudinalStringDecay::FragmentationMass( const G4FragmentingString * const string,
Pcreate build, pDefPair * pdefs )
G4double G4VLongitudinalStringDecay::PossibleHadronMass( const G4FragmentingString * const string,
Pcreate build, pDefPair * pdefs )
{
G4double mass;
@@ -212,28 +232,44 @@ G4double G4VLongitudinalStringDecay::FragmentationMass( const G4FragmentingStrin
G4ParticleDefinition *Hadron1, *Hadron2=0;
if (!string->FourQuarkString() )
if (!string->IsAFourQuarkString() )
{
// spin 0 meson or spin 1/2 barion will be built
Hadron1 = (hadronizer->*build)(string->GetLeftParton(), string->GetRightParton());
#ifdef debug_VStringDecay
G4cout<<"Quarks at the string ends "<<string->GetLeftParton()->GetParticleName()<<" "<<string->GetRightParton()->GetParticleName()<<G4endl;
G4cout<<"(G4VLongitudinalStringDecay) Hadron "<<Hadron1->GetParticleName()<<" "<<Hadron1->GetPDGMass()<<G4endl;
G4cout<<"VlongSF Quarks at the string ends "<<string->GetLeftParton()->GetParticleName()
<<" "<<string->GetRightParton()->GetParticleName()<<G4endl;
if ( Hadron1 != NULL) {
G4cout<<"(G4VLongitudinalStringDecay) Hadron "<<Hadron1->GetParticleName()
<<" "<<Hadron1->GetPDGMass()<<G4endl;
}
#endif
mass= (Hadron1)->GetPDGMass();
if ( Hadron1 != NULL) { mass = (Hadron1)->GetPDGMass();}
else { mass = MaxMass;}
} else
{
//... string is qq--qqbar: Build two stable hadrons,
//... with extra uubar or ddbar quark pair
#ifdef debug_VStringDecay
G4cout<<"VlongSF string is qq--qqbar: Build two stable hadrons"<<G4endl;
#endif
G4int iflc = (G4UniformRand() < 0.5)? 1 : 2;
if (string->GetLeftParton()->GetPDGEncoding() < 0) iflc = -iflc;
//... theSpin = 4; spin 3/2 baryons will be built
Hadron1 = (hadronizer->*build)(string->GetLeftParton(), FindParticle(iflc));
Hadron2 = (hadronizer->*build)(string->GetRightParton(), FindParticle(-iflc));
mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
if ( (Hadron1 != NULL) && (Hadron2 != NULL) ) { mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();}
else { mass = MaxMass;}
}
#ifdef debug_VStringDecay
G4cout<<"VlongSF *Hadrons 1 and 2, proposed mass "<<Hadron1<<" "<<Hadron2<<" "<<mass<<G4endl;
#endif
if ( pdefs != 0 )
{ // need to return hadrons as well....
@@ -248,20 +284,39 @@ G4double G4VLongitudinalStringDecay::FragmentationMass( const G4FragmentingStrin
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;
/*
G4cout<<Encoding<<" G4VLongitudinalStringDecay::FindParticle Check di-quarks *******************"<<G4endl;
for (G4int i=4; i<6;i++){
for (G4int j=1;j<6;j++){
G4cout<<i<<" "<<j<<" ";
G4int Code = 1000 * i + 100 * j +1;
G4ParticleDefinition* ptr1 = G4ParticleTable::GetParticleTable()->FindParticle(Code);
Code +=2;
G4ParticleDefinition* ptr2 = G4ParticleTable::GetParticleTable()->FindParticle(Code);
G4cout<<"Code "<<Code - 2<<" ptr "<<ptr1<<" :: Code "<<Code<<" ptr "<<ptr2<<G4endl;
}
G4cout<<G4endl;
}
*/
G4ParticleDefinition* ptr = G4ParticleTable::GetParticleTable()->FindParticle(Encoding);
if (ptr == NULL)
{
for (size_t i=0; i < NewParticles.size(); i++)
{
if ( Encoding == NewParticles[i]->GetPDGEncoding() ) { ptr = NewParticles[i]; return ptr;}
}
}
return ptr;
}
//*********************************************************************************
// 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 G4bool IsItFragmentable(const G4FragmentingString * const string)=0;
//
// If a string can not fragment, make last break into 2 hadrons
// virtual G4bool SplitLast(G4FragmentingString * string,
// G4KineticTrackVector * LeftVector,
@@ -281,48 +336,83 @@ G4ExcitedString *G4VLongitudinalStringDecay::CopyExcited(const G4ExcitedString &
}
//-----------------------------------------------------------------------------
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);
#ifdef debug_VStringDecay
G4cout<<"VlongSF QuarkSplitup: quark ID "<<decay->GetPDGEncoding()<<G4endl;
#endif
G4int IsParticle=(decay->GetPDGEncoding()>0) ? -1 : +1; // if we have a quark, we need antiquark (or diquark)
pDefPair QuarkPair = CreatePartonPair(IsParticle);
created = QuarkPair.second;
DecayQuark = decay->GetPDGEncoding();
NewQuark = created->GetPDGEncoding();
#ifdef debug_VStringDecay
G4cout<<"VlongSF QuarkSplitup: "<<decay->GetPDGEncoding()<<" -> "<<QuarkPair.second->GetPDGEncoding()<<G4endl;
G4cout<<"hadronizer->Build(QuarkPair.first, decay)"<<G4endl;
#endif
return hadronizer->Build(QuarkPair.first, decay);
}
//-----------------------------------------------------------------------------
G4int G4VLongitudinalStringDecay::SampleQuarkFlavor(void)
{
return (1 + (int)(G4UniformRand()/StrangeSuppress));
}
//-----------------------------------------------------------------------------
G4VLongitudinalStringDecay::pDefPair G4VLongitudinalStringDecay::CreatePartonPair(G4int NeedParticle,G4bool AllowDiquarks)
G4VLongitudinalStringDecay::pDefPair G4VLongitudinalStringDecay::
CreatePartonPair(G4int NeedParticle,G4bool AllowDiquarks)
{
// NeedParticle = +1 for Particle, -1 for Antiparticle
if ( AllowDiquarks && G4UniformRand() < DiquarkSuppress )
{
// Create a Diquark - AntiDiquark pair , first in pair is anti to IsParticle
G4int q1 = SampleQuarkFlavor();
G4int q2 = SampleQuarkFlavor();
#ifdef debug_VStringDecay
G4cout<<"VlongSF Create a Diquark - AntiDiquark pair"<<G4endl;
#endif
G4int q1(0), q2(0), spin(0), PDGcode(0);
G4int spin = (q1 != q2 && G4UniformRand() <= 0.5)? 1 : 3;
q1 = SampleQuarkFlavor();
q2 = SampleQuarkFlavor();
spin = (q1 != q2 && G4UniformRand() <= 0.5)? 1 : 3;
// convention: quark with higher PDG number is first
G4int PDGcode = (std::max(q1,q2) * 1000 + std::min(q1,q2) * 100 + spin) * NeedParticle;
PDGcode = (std::max(q1,q2) * 1000 + std::min(q1,q2) * 100 + spin) * NeedParticle;
return pDefPair (FindParticle(-PDGcode),FindParticle(PDGcode));
} else {
// Create a Quark - AntiQuark pair, first in pair IsParticle
#ifdef debug_VStringDecay
G4cout<<"VlongSF Create a Quark - AntiQuark pair"<<G4endl;
#endif
G4int PDGcode=SampleQuarkFlavor()*NeedParticle;
return pDefPair (FindParticle(PDGcode),FindParticle(-PDGcode));
}
}
//-----------------------------------------------------------------------------
G4int G4VLongitudinalStringDecay::SampleQuarkFlavor(void)
{
G4int quark(1);
G4double ksi = G4UniformRand();
if ( ksi < ProbCB ) {
if ( ksi < ProbCCbar ) {quark = 4;} // c quark
else {quark = 5;} // b quark
} else {
quark = 1 + (int)(G4UniformRand()/StrangeSuppress);
}
#ifdef debug_VStringDecay
G4cout<<"VlongSF SampleQuarkFlavor "<<quark<<" (ProbCB ProbCCbar ProbBBbar "<<ProbCB
<<" "<<ProbCCbar<<" "<<ProbBBbar<<" )"<<G4endl;
#endif
return quark;
}
//-----------------------------------------------------------------------------
G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt(G4double ptMax)
{
G4double Pt;
@@ -340,16 +430,17 @@ G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt(G4double ptMax)
//******************************************************************************
void G4VLongitudinalStringDecay::CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector* Hadrons)
void G4VLongitudinalStringDecay::CalculateHadronTimePosition(G4double theInitialStringMass,
G4KineticTrackVector* Hadrons)
{
// `yo-yo` formation time
// const G4double kappa = 1.0 * GeV/fermi/4.;
G4double kappa = GetStringTensionParameter();
for(size_t c1 = 0; c1 < Hadrons->size(); c1++)
for (size_t c1 = 0; c1 < Hadrons->size(); c1++)
{
G4double SumPz = 0;
G4double SumE = 0;
for(size_t c2 = 0; c2 < c1; c2++)
for (size_t c2 = 0; c2 < c1; c2++)
{
SumPz += Hadrons->operator[](c2)->Get4Momentum().pz();
SumE += Hadrons->operator[](c2)->Get4Momentum().e();
@@ -369,7 +460,8 @@ void G4VLongitudinalStringDecay::CalculateHadronTimePosition(G4double theInitial
void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum(G4double aValue)
{
if ( PastInitPhase ) {
throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
throw G4HadronicException(__FILE__, __LINE__,
"G4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
} else {
SigmaQT = aValue;
}
@@ -394,7 +486,8 @@ void G4VLongitudinalStringDecay::SetDiquarkSuppression(G4double aValue)
void G4VLongitudinalStringDecay::SetDiquarkBreakProbability(G4double aValue)
{
if ( PastInitPhase ) {
throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkBreakProbability after FragmentString() not allowed");
throw G4HadronicException(__FILE__, __LINE__,
"G4VLongitudinalStringDecay::SetDiquarkBreakProbability after FragmentString() not allowed");
} else {
DiquarkBreakProb = aValue;
}
@@ -405,11 +498,12 @@ void G4VLongitudinalStringDecay::SetDiquarkBreakProbability(G4double aValue)
void G4VLongitudinalStringDecay::SetVectorMesonProbability(G4double aValue)
{
if ( PastInitPhase ) {
throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonProbability after FragmentString() not allowed");
throw G4HadronicException(__FILE__, __LINE__,
"G4VLongitudinalStringDecay::SetVectorMesonProbability after FragmentString() not allowed");
} else {
pspin_meson = aValue;
delete hadronizer;
hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix );
hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix, ProbEta_c, ProbEta_b );
}
}
@@ -418,11 +512,12 @@ void G4VLongitudinalStringDecay::SetVectorMesonProbability(G4double aValue)
void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(G4double aValue)
{
if ( PastInitPhase ) {
throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability after FragmentString() not allowed");
throw G4HadronicException(__FILE__, __LINE__,
"G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability after FragmentString() not allowed");
} else {
pspin_barion = aValue;
delete hadronizer;
hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix );
hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix, ProbEta_c, ProbEta_b );
}
}
@@ -431,10 +526,12 @@ void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(G4double aVal
void G4VLongitudinalStringDecay::SetScalarMesonMixings(std::vector<G4double> aVector)
{
if ( PastInitPhase ) {
throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings after FragmentString() not allowed");
throw G4HadronicException(__FILE__, __LINE__,
"G4VLongitudinalStringDecay::SetScalarMesonMixings after FragmentString() not allowed");
} else {
if ( aVector.size() < 6 )
throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings( argument Vector too small");
throw G4HadronicException(__FILE__, __LINE__,
"G4VLongitudinalStringDecay::SetScalarMesonMixings( argument Vector too small");
scalarMesonMix[0] = aVector[0];
scalarMesonMix[1] = aVector[1];
scalarMesonMix[2] = aVector[2];
@@ -442,7 +539,7 @@ void G4VLongitudinalStringDecay::SetScalarMesonMixings(std::vector<G4double> aVe
scalarMesonMix[4] = aVector[4];
scalarMesonMix[5] = aVector[5];
delete hadronizer;
hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix );
hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix, ProbEta_c, ProbEta_b );
}
}
@@ -451,10 +548,12 @@ void G4VLongitudinalStringDecay::SetScalarMesonMixings(std::vector<G4double> aVe
void G4VLongitudinalStringDecay::SetVectorMesonMixings(std::vector<G4double> aVector)
{
if ( PastInitPhase ) {
throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings after FragmentString() not allowed");
throw G4HadronicException(__FILE__, __LINE__,
"G4VLongitudinalStringDecay::SetVectorMesonMixings after FragmentString() not allowed");
} else {
if ( aVector.size() < 6 )
throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings( argument Vector too small");
throw G4HadronicException(__FILE__, __LINE__,
"G4VLongitudinalStringDecay::SetVectorMesonMixings( argument Vector too small");
vectorMesonMix[0] = aVector[0];
vectorMesonMix[1] = aVector[1];
vectorMesonMix[2] = aVector[2];
@@ -462,14 +561,486 @@ void G4VLongitudinalStringDecay::SetVectorMesonMixings(std::vector<G4double> aVe
vectorMesonMix[4] = aVector[4];
vectorMesonMix[5] = aVector[5];
delete hadronizer;
hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix );
hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix, ProbEta_c, ProbEta_b );
}
}
//-------------------------------------------------------------------------------------------
void G4VLongitudinalStringDecay::SetProbCCbar(G4double aValue)
{
ProbCCbar = aValue;
ProbCB = ProbCCbar + ProbBBbar;
}
//-------------------------------------------------------------------------------------------
void G4VLongitudinalStringDecay::SetProbEta_c(G4double aValue)
{
ProbEta_c = aValue;
}
//-------------------------------------------------------------------------------------------
void G4VLongitudinalStringDecay::SetProbBBbar(G4double aValue)
{
ProbBBbar = aValue;
ProbCB = ProbCCbar + ProbBBbar;
}
//-------------------------------------------------------------------------------------------
void G4VLongitudinalStringDecay::SetProbEta_b(G4double aValue)
{
ProbEta_b = aValue;
}
//-------------------------------------------------------------------------------------------
void G4VLongitudinalStringDecay::SetStringTensionParameter(G4double aValue)
{
Kappa = aValue * GeV/fermi;
}
//**************************************************************************************
//-----------------------------------------------------------------------
void G4VLongitudinalStringDecay::SetMinMasses()
{
// ------ For estimation of a minimal string mass ---------------
Mass_of_light_quark =140.*MeV;
Mass_of_s_quark =500.*MeV;
Mass_of_c_quark = 0.*MeV; // ???
Mass_of_b_quark = 0.*MeV; // ???
Mass_of_string_junction=720.*MeV;
// ---------------- Determination of minimal mass of q-qbar strings -------------------
G4ParticleDefinition * hadron1; G4int Code1;
G4ParticleDefinition * hadron2; G4int Code2;
for (G4int i=1; i < 6; i++) {
Code1 = 100*i + 10*1 + 1;
hadron1 = FindParticle(Code1);
if (hadron1 != NULL) {
for (G4int j=1; j < 6; j++) {
Code2 = 100*j + 10*1 + 1;
hadron2 = FindParticle(Code2);
if (hadron2 != NULL) {
minMassQQbarStr[i-1][j-1] = hadron1->GetPDGMass() + hadron2->GetPDGMass() + 70.0 * MeV;
}
}
}
}
minMassQQbarStr[1][1] = minMassQQbarStr[0][0]; // u-ubar = 0.5 Pi0 + 0.24 Eta + 0.25 Eta'
// ---------------- Determination of minimal mass of qq-q strings -------------------
G4ParticleDefinition * hadron3;
G4int kfla, kflb;
// MaxMass = -350.0*GeV; // If there will be a particle with mass larger than Higgs the value must be changed.
for (G4int i=1; i < 6; i++) { //i=1
Code1 = 100*i + 10*1 + 1;
hadron1 = FindParticle(Code1);
for (G4int j=1; j < 6; j++) {
for (G4int k=1; k < 6; k++) {
kfla = std::max(j,k);
kflb = std::min(j,k);
// Add d-quark
Code2 = 1000*kfla + 100*kflb + 10*1 + 2;
if ( (j == 1) && (k==1)) Code2 = 1000*2 + 100*1 + 10*1 + 2; // In the case - add u-quark.
hadron2 = G4ParticleTable::GetParticleTable()->FindParticle(Code2);
hadron3 = G4ParticleTable::GetParticleTable()->FindParticle(Code2 + 2);
if ((hadron2 == NULL) && (hadron3 == NULL)) {minMassQDiQStr[i-1][j-1][k-1] = MaxMass; continue;};
if ((hadron2 != NULL) && (hadron3 != NULL)) {
if (hadron2->GetPDGMass() > hadron3->GetPDGMass() ) { hadron2 = hadron3; }
};
if ((hadron2 != NULL) && (hadron3 == NULL)) {};
if ((hadron2 == NULL) && (hadron3 != NULL)) {hadron2 = hadron3;};
minMassQDiQStr[i-1][j-1][k-1] = hadron1->GetPDGMass() + hadron2->GetPDGMass() + 70.0 * MeV;
}
}
}
// ------ An estimated minimal string mass ----------------------
MinimalStringMass = 0.;
MinimalStringMass2 = 0.;
// q charges d u s c b
Qcharge[0] = -1; Qcharge[1] = 2; Qcharge[2] = -1; Qcharge[3] = 2; Qcharge[4] = -1;
// For treating of small string decays
for (G4int i=0; i<5; i++)
{ for (G4int j=0; j<5; j++)
{ for (G4int k=0; k<7; k++)
{
Meson[i][j][k]=0; MesonWeight[i][j][k]=0.;
}
}
}
//--------------------------
for (G4int i=0; i<5; i++)
{ for (G4int j=0; j<5; j++)
{
Meson[i][j][0] = 100 * (std::max(i,j)+1) + 10 * (std::min(i,j)+1) + 1; // Scalar meson
MesonWeight[i][j][0] = ( pspin_meson);
Meson[i][j][1] = 100 * (std::max(i,j)+1) + 10 * (std::min(i,j)+1) + 3; // Vector meson
MesonWeight[i][j][1] = (1.-pspin_meson);
}
}
//qqs indexes
//dd1 -> scalarMesonMix[0] * 111 + (1-scalarMesonMix[0]-scalarMesonMix[1]) * 221 + scalarMesonMix[1] * 331 (000)
//dd1 -> Pi0 Eta Eta'
Meson[0][0][0] = 111; MesonWeight[0][0][0] = ( pspin_meson) * ( scalarMesonMix[0] ); // Pi0
Meson[0][0][2] = 221; MesonWeight[0][0][3] = ( pspin_meson) * (1-scalarMesonMix[0]-scalarMesonMix[1]); // Eta
Meson[0][0][3] = 331; MesonWeight[0][0][4] = ( pspin_meson) * ( scalarMesonMix[1]); // Eta'
//dd3 -> vectorMesonMix[0] * 113 + (1-vectorMesonMix[0]-vectorMesonMix[1]) * 223 + vectorMesonMix[1] * 333 (001)
//dd3 -> rho_0 omega fi
Meson[0][0][1] = 113; MesonWeight[0][0][1] = (1.-pspin_meson) * ( vectorMesonMix[0] ); // Rho
Meson[0][0][4] = 223; MesonWeight[0][0][4] = (1.-pspin_meson) * (1-vectorMesonMix[0]-vectorMesonMix[1]); // omega
Meson[0][0][5] = 333; MesonWeight[0][0][5] = (1.-pspin_meson) * ( vectorMesonMix[1]); // fi
//uu1 -> scalarMesonMix[0] * 111 + (1-scalarMesonMix[0]-scalarMesonMix[1]) * 221 + scalarMesonMix[1] * 331 (110)
//uu1 -> Pi0 Eta Eta'
Meson[1][1][0] = 111; MesonWeight[1][1][0] = ( pspin_meson) * ( scalarMesonMix[0] ); // Pi0
Meson[1][1][2] = 221; MesonWeight[1][1][2] = ( pspin_meson) * (1-scalarMesonMix[0]-scalarMesonMix[1]); // Eta
Meson[1][1][3] = 331; MesonWeight[1][1][3] = ( pspin_meson) * ( scalarMesonMix[1]); // Eta'
//uu3 -> vectorMesonMix[0] * 113 + (1-vectorMesonMix[0]-vectorMesonMix[1]) * 223 + vectorMesonMix[1] * 333 (111)
//uu3 -> rho_0 omega fi
Meson[1][1][1] = 113; MesonWeight[1][1][1] = (1.-pspin_meson) * ( vectorMesonMix[0] ); // Rho
Meson[1][1][4] = 223; MesonWeight[1][1][4] = (1.-pspin_meson) * (1-vectorMesonMix[0]-vectorMesonMix[1]); // omega
Meson[1][1][5] = 333; MesonWeight[1][1][5] = (1.-pspin_meson) * ( vectorMesonMix[1]); // fi
//ss1 -> (1-scalarMesonMix[5]) * 221 + scalarMesonMix[5] * 331 (220)
//ss1 -> Eta Eta'
Meson[2][2][0] = 221; MesonWeight[2][2][0] = ( pspin_meson) * (1-scalarMesonMix[5] ); // Eta
Meson[2][2][2] = 331; MesonWeight[2][2][2] = ( pspin_meson) * ( scalarMesonMix[5]); // Eta'
//ss3 -> (1-vectorMesonMix[5]) * 223 + vectorMesonMix[5] * 333 (221)
//ss3 -> omega fi
Meson[2][2][1] = 223; MesonWeight[2][2][1] = (1.-pspin_meson) * (1-vectorMesonMix[5] ); // omega
Meson[2][2][3] = 333; MesonWeight[2][2][3] = (1.-pspin_meson) * ( vectorMesonMix[5]); // fi
//cc1 -> ProbEta_c /(1-pspin_meson) 441 (330) Probability of Eta_c
//cc3 -> (1-ProbEta_c)/( pspin_meson) 443 (331) Probability of J/Psi
//bb1 -> ProbEta_b /pspin_meson 551 (440) Probability of Eta_b
//bb3 -> (1-ProbEta_b)/pspin_meson 553 (441) Probability of ipsilon
if ( pspin_meson != 0. ) {
Meson[3][3][0] *= ( ProbEta_c)/( pspin_meson); // Eta_c
Meson[3][3][1] *= (1.0-ProbEta_c)/(1.-pspin_meson); // J/Psi
Meson[4][4][0] *= ( ProbEta_b)/( pspin_meson); // Eta_b
Meson[4][4][1] *= (1.0-ProbEta_b)/(1.-pspin_meson); // ipsilon
}
//--------------------------
for (G4int i=0; i<5; i++)
{ for (G4int j=0; j<5; j++)
{ for (G4int k=0; k<5; k++)
{ for (G4int l=0; l<4; l++)
{ Baryon[i][j][k][l]=0; BaryonWeight[i][j][k][l]=0.;}
}
}
}
kfla =0; kflb =0;
G4int kflc(0), kfld(0), kfle(0), kflf(0);
for (G4int i=0; i<5; i++)
{ for (G4int j=0; j<5; j++)
{ for (G4int k=0; k<5; k++)
{
kfla = i+1; kflb = j+1; kflc = k+1;
kfld = std::max(kfla,kflb);
kfld = std::max(kfld,kflc);
kflf = std::min(kfla,kflb);
kflf = std::min(kflf,kflc);
kfle = kfla + kflb + kflc - kfld - kflf;
Baryon[i][j][k][0] = 1000 * kfld + 100 * kfle + 10 * kflf + 2; // spin=1/2
BaryonWeight[i][j][k][0] = ( pspin_barion);
Baryon[i][j][k][1] = 1000 * kfld + 100 * kfle + 10 * kflf + 4; // spin=3/2
BaryonWeight[i][j][k][1] = (1.-pspin_barion);
}
}
}
// Delta- ddd - only 1114
Baryon[0][0][0][0] = 1114; BaryonWeight[0][0][0][0] = 1.0;
Baryon[0][0][0][1] = 0; BaryonWeight[0][0][0][1] = 0.0;
// Delta++ uuu - only 2224
Baryon[1][1][1][0] = 2224; BaryonWeight[1][1][1][0] = 1.0;
Baryon[1][1][1][1] = 0; BaryonWeight[1][1][1][1] = 0.0;
// Omega- sss - only 3334
Baryon[2][2][2][0] = 3334; BaryonWeight[2][2][2][0] = 1.0;
Baryon[2][2][2][1] = 0; BaryonWeight[2][2][2][1] = 0.0;
// Omega_cc++ ccc - only 4444
Baryon[3][3][3][0] = 4444; BaryonWeight[3][3][3][0] = 1.0;
Baryon[3][3][3][1] = 0; BaryonWeight[3][3][3][1] = 0.0;
// Omega_bb- bbb - only 5454
Baryon[4][4][4][0] = 5554; BaryonWeight[4][4][4][0] = 1.0;
Baryon[4][4][4][1] = 0; BaryonWeight[4][4][4][1] = 0.0;
// Lambda/Sigma0 sud - 3122/3212
Baryon[0][1][2][0] = 3122; BaryonWeight[0][1][2][0] *= 0.5; // Lambda
Baryon[0][2][1][0] = 3122; BaryonWeight[0][2][1][0] *= 0.5;
Baryon[1][0][2][0] = 3122; BaryonWeight[1][0][2][0] *= 0.5;
Baryon[1][2][0][0] = 3122; BaryonWeight[1][2][0][0] *= 0.5;
Baryon[2][0][1][0] = 3122; BaryonWeight[2][0][1][0] *= 0.5;
Baryon[2][1][0][0] = 3122; BaryonWeight[2][1][0][0] *= 0.5;
Baryon[0][1][2][2] = 3212; BaryonWeight[0][1][2][2] = 0.5 * pspin_barion; // Sigma0
Baryon[0][2][1][2] = 3212; BaryonWeight[0][2][1][2] = 0.5 * pspin_barion;
Baryon[1][0][2][2] = 3212; BaryonWeight[1][0][2][2] = 0.5 * pspin_barion;
Baryon[1][2][0][2] = 3212; BaryonWeight[1][2][0][2] = 0.5 * pspin_barion;
Baryon[2][0][1][2] = 3212; BaryonWeight[2][0][1][2] = 0.5 * pspin_barion;
Baryon[2][1][0][2] = 3212; BaryonWeight[2][1][0][2] = 0.5 * pspin_barion;
// Lambda_c+/Sigma_c+ cud - 4122/4212
Baryon[0][1][3][0] = 4122; BaryonWeight[0][1][3][0] *= 0.5; // Lambda_c+
Baryon[0][3][1][0] = 4122; BaryonWeight[0][3][1][0] *= 0.5;
Baryon[1][0][3][0] = 4122; BaryonWeight[1][0][3][0] *= 0.5;
Baryon[1][3][0][0] = 4122; BaryonWeight[1][3][0][0] *= 0.5;
Baryon[3][0][1][0] = 4122; BaryonWeight[3][0][1][0] *= 0.5;
Baryon[3][1][0][0] = 4122; BaryonWeight[3][1][0][0] *= 0.5;
Baryon[0][1][3][2] = 4212; BaryonWeight[0][1][3][2] = 0.5 * pspin_barion; // SigmaC+
Baryon[0][3][1][2] = 4212; BaryonWeight[0][3][1][2] = 0.5 * pspin_barion;
Baryon[1][0][3][2] = 4212; BaryonWeight[1][0][3][2] = 0.5 * pspin_barion;
Baryon[1][3][0][2] = 4212; BaryonWeight[1][3][0][2] = 0.5 * pspin_barion;
Baryon[3][0][1][2] = 4212; BaryonWeight[3][0][1][2] = 0.5 * pspin_barion;
Baryon[3][1][0][2] = 4212; BaryonWeight[3][1][0][2] = 0.5 * pspin_barion;
// Xi_c+/Xi_c+' cus - 4232/4322
Baryon[1][2][3][0] = 4232; BaryonWeight[1][2][3][0] *= 0.5; // Xi_c+
Baryon[1][3][2][0] = 4232; BaryonWeight[1][3][2][0] *= 0.5;
Baryon[2][1][3][0] = 4232; BaryonWeight[2][1][3][0] *= 0.5;
Baryon[2][3][1][0] = 4232; BaryonWeight[2][3][1][0] *= 0.5;
Baryon[3][1][2][0] = 4232; BaryonWeight[3][1][2][0] *= 0.5;
Baryon[3][2][1][0] = 4232; BaryonWeight[3][2][1][0] *= 0.5;
Baryon[1][2][3][2] = 4322; BaryonWeight[1][2][3][2] = 0.5 * pspin_barion; // Xi_c+'
Baryon[1][3][2][2] = 4322; BaryonWeight[1][3][2][2] = 0.5 * pspin_barion;
Baryon[2][1][3][2] = 4322; BaryonWeight[2][1][3][2] = 0.5 * pspin_barion;
Baryon[2][3][1][2] = 4322; BaryonWeight[2][3][1][2] = 0.5 * pspin_barion;
Baryon[3][1][2][2] = 4322; BaryonWeight[3][1][2][2] = 0.5 * pspin_barion;
Baryon[3][2][1][2] = 4322; BaryonWeight[3][2][1][2] = 0.5 * pspin_barion;
// Xi_c0/Xi_c0' cus - 4232/4322
Baryon[0][2][3][0] = 4132; BaryonWeight[0][2][3][0] *= 0.5; // Xi_c0
Baryon[0][3][2][0] = 4132; BaryonWeight[0][3][2][0] *= 0.5;
Baryon[2][0][3][0] = 4132; BaryonWeight[2][0][3][0] *= 0.5;
Baryon[2][3][0][0] = 4132; BaryonWeight[2][3][0][0] *= 0.5;
Baryon[3][0][2][0] = 4132; BaryonWeight[3][0][2][0] *= 0.5;
Baryon[3][2][0][0] = 4132; BaryonWeight[3][2][0][0] *= 0.5;
Baryon[0][2][3][2] = 4312; BaryonWeight[0][2][3][2] = 0.5 * pspin_barion; // Xi_c0'
Baryon[0][3][2][2] = 4312; BaryonWeight[0][3][2][2] = 0.5 * pspin_barion;
Baryon[2][0][3][2] = 4312; BaryonWeight[2][0][3][2] = 0.5 * pspin_barion;
Baryon[2][3][0][2] = 4312; BaryonWeight[2][3][0][2] = 0.5 * pspin_barion;
Baryon[3][0][2][2] = 4312; BaryonWeight[3][0][2][2] = 0.5 * pspin_barion;
Baryon[3][2][0][2] = 4312; BaryonWeight[3][2][0][2] = 0.5 * pspin_barion;
// Lambda_b0/Sigma_b0 bud - 5122/5212
Baryon[0][1][4][0] = 5122; BaryonWeight[0][1][4][0] *= 0.5; // Lambda_b0
Baryon[0][4][1][0] = 5122; BaryonWeight[0][4][1][0] *= 0.5;
Baryon[1][0][4][0] = 5122; BaryonWeight[1][0][4][0] *= 0.5;
Baryon[1][4][0][0] = 5122; BaryonWeight[1][4][0][0] *= 0.5;
Baryon[4][0][1][0] = 5122; BaryonWeight[4][0][1][0] *= 0.5;
Baryon[4][1][0][0] = 5122; BaryonWeight[4][1][0][0] *= 0.5;
Baryon[0][1][4][2] = 5212; BaryonWeight[0][1][4][2] = 0.5 * pspin_barion; // Sigma_b0
Baryon[0][4][1][2] = 5212; BaryonWeight[0][4][1][2] = 0.5 * pspin_barion;
Baryon[1][0][4][2] = 5212; BaryonWeight[1][0][4][2] = 0.5 * pspin_barion;
Baryon[1][4][0][2] = 5212; BaryonWeight[1][4][0][2] = 0.5 * pspin_barion;
Baryon[4][0][1][2] = 5212; BaryonWeight[4][0][1][2] = 0.5 * pspin_barion;
Baryon[4][1][0][2] = 5212; BaryonWeight[4][1][0][2] = 0.5 * pspin_barion;
// Xi_b-/Xi_b-' bus - 5232/5322
Baryon[1][2][4][0] = 5232; BaryonWeight[1][2][4][0] *= 0.5; // Xi_b-
Baryon[1][4][2][0] = 5232; BaryonWeight[1][4][2][0] *= 0.5;
Baryon[2][1][4][0] = 5232; BaryonWeight[2][1][4][0] *= 0.5;
Baryon[2][4][1][0] = 5232; BaryonWeight[2][4][1][0] *= 0.5;
Baryon[4][1][2][0] = 5232; BaryonWeight[4][1][2][0] *= 0.5;
Baryon[4][2][1][0] = 5232; BaryonWeight[4][2][1][0] *= 0.5;
Baryon[1][2][4][2] = 5322; BaryonWeight[1][2][4][2] = 0.5 * pspin_barion; // Xi_b-'
Baryon[1][4][2][2] = 5322; BaryonWeight[1][4][2][2] = 0.5 * pspin_barion;
Baryon[2][1][4][2] = 5322; BaryonWeight[2][1][4][2] = 0.5 * pspin_barion;
Baryon[2][4][1][2] = 5322; BaryonWeight[2][4][1][2] = 0.5 * pspin_barion;
Baryon[4][1][2][2] = 5322; BaryonWeight[4][1][2][2] = 0.5 * pspin_barion;
Baryon[4][2][1][2] = 5322; BaryonWeight[4][2][1][2] = 0.5 * pspin_barion;
// Xi_b0/Xi_b0' bus - 5232/5322
Baryon[0][2][4][0] = 5132; BaryonWeight[0][2][4][0] *= 0.5; // Xi_b0
Baryon[0][4][2][0] = 5132; BaryonWeight[0][4][2][0] *= 0.5;
Baryon[2][0][4][0] = 5132; BaryonWeight[2][0][4][0] *= 0.5;
Baryon[2][4][0][0] = 5132; BaryonWeight[2][4][0][0] *= 0.5;
Baryon[4][0][2][0] = 5132; BaryonWeight[4][0][2][0] *= 0.5;
Baryon[4][2][0][0] = 5132; BaryonWeight[4][2][0][0] *= 0.5;
Baryon[0][2][4][2] = 5312; BaryonWeight[0][2][4][2] = 0.5 * pspin_barion; // Xi_b0'
Baryon[0][4][2][2] = 5312; BaryonWeight[0][4][2][2] = 0.5 * pspin_barion;
Baryon[2][0][4][2] = 5312; BaryonWeight[2][0][4][2] = 0.5 * pspin_barion;
Baryon[2][4][0][2] = 5312; BaryonWeight[2][4][0][2] = 0.5 * pspin_barion;
Baryon[4][0][2][2] = 5312; BaryonWeight[4][0][2][2] = 0.5 * pspin_barion;
Baryon[4][2][0][2] = 5312; BaryonWeight[4][2][0][2] = 0.5 * pspin_barion;
for (G4int i=0; i<5; i++)
{ for (G4int j=0; j<5; j++)
{ for (G4int k=0; k<5; k++)
{ for (G4int l=0; l<4; l++)
{
G4ParticleDefinition * TestHadron=
G4ParticleTable::GetParticleTable()->FindParticle(Baryon[i][j][k][l]);
/*
G4cout<<i<<" "<<j<<" "<<k<<" "<<l<<" "<<Baryon[i][j][k][l]<<" "<<TestHadron<<" "<<BaryonWeight[i][j][k][l];
if (TestHadron != NULL) G4cout<<" "<<TestHadron->GetParticleName();
if ((TestHadron == NULL)&&(Baryon[i][j][k][l] != 0)) G4cout<<" *****";
if ((TestHadron == NULL)&&(Baryon[i][j][k][l] == 0)) G4cout<<" ---------------";
G4cout<<G4endl;
*/
if ((TestHadron == NULL)&&(Baryon[i][j][k][l] != 0)) Baryon[i][j][k][l] = 0;
}
}
}
}
// --------- Probabilities of q-qbar pair productions for kink or gluons.
G4double ProbUUbar = 0.33;
Prob_QQbar[0]=ProbUUbar; // Probability of ddbar production
Prob_QQbar[1]=ProbUUbar; // Probability of uubar production
Prob_QQbar[2]=1.0-2.*ProbUUbar; // Probability of ssbar production
Prob_QQbar[3]=0.0; // Probability of ccbar production
Prob_QQbar[4]=0.0; // Probability of bbbar production
for ( G4int i=0 ; i<350 ; i++ ) { // Must be checked
FS_LeftHadron[i] = 0;
FS_RightHadron[i] = 0;
FS_Weight[i] = 0.0;
}
NumberOf_FS = 0;
}
// --------------------------------------------------------------
void G4VLongitudinalStringDecay::SetMinimalStringMass(const G4FragmentingString * const string)
{
//MaxMass = -350.0*GeV;
G4double EstimatedMass=0.;
G4int Qleft =std::abs(string->GetLeftParton()->GetPDGEncoding());
G4int Qright=std::abs(string->GetRightParton()->GetPDGEncoding());
if ((Qleft < 6) && (Qright < 6)) { // Q-Qbar string
EstimatedMass=minMassQQbarStr[Qleft-1][Qright-1];
MinimalStringMass=EstimatedMass;
SetMinimalStringMass2(EstimatedMass);
return;
}
if ((Qleft < 6) && (Qright > 1000)) { // Q - DiQ string
G4int q1=Qright/1000;
G4int q2=(Qright/100)%10;
EstimatedMass=minMassQDiQStr[Qleft-1][q1-1][q2-1];
MinimalStringMass=EstimatedMass; // It can be negative!
SetMinimalStringMass2(EstimatedMass);
return;
}
if ((Qleft > 1000) && (Qright < 6)) { // DiQ - Q string 6 6 6
G4int q1=Qleft/1000;
G4int q2=(Qleft/100)%10;
EstimatedMass=minMassQDiQStr[Qright-1][q1-1][q2-1];
MinimalStringMass=EstimatedMass; // It can be negative!
SetMinimalStringMass2(EstimatedMass);
return;
}
// DiQuark - Anti DiQuark string -----------------
G4double StringM=string->Get4Momentum().mag();
#ifdef debug_LUNDfragmentation
// G4cout<<"MinStringMass// Input String mass "<<string->Get4Momentum().mag()<<" Qleft "<<Qleft<<G4endl;
#endif
G4int q1= Qleft/1000 ;
G4int q2=(Qleft/100)%10 ;
G4int q3= Qright/1000 ;
G4int q4=(Qright/100)%10;
// -------------- 2 baryon production or 2 mesons production --------
G4double EstimatedMass1 = minMassQDiQStr[q1-1][q2-1][0];
G4double EstimatedMass2 = minMassQDiQStr[q3-1][q4-1][0];
// Mass is negative if there is no corresponding particle.
if ( (EstimatedMass1 > 0.) && (EstimatedMass2 > 0.)) {
EstimatedMass = EstimatedMass1 + EstimatedMass2;
if ( StringM > EstimatedMass ) { // 2 baryon production is possible.
MinimalStringMass=EstimatedMass1 + EstimatedMass2;
SetMinimalStringMass2(EstimatedMass);
return;
}
}
if ( (EstimatedMass1 < 0.) && (EstimatedMass2 > 0.)) {
EstimatedMass = MaxMass;
MinimalStringMass=EstimatedMass;
SetMinimalStringMass2(EstimatedMass);
return;
}
if ( (EstimatedMass1 > 0.) && (EstimatedMass2 < 0.)) {
EstimatedMass = EstimatedMass1;
MinimalStringMass=EstimatedMass;
SetMinimalStringMass2(EstimatedMass);
return;
}
// if ( EstimatedMass >= StringM ) {
// ------------- Re-orangement ---------------
EstimatedMass=std::min(minMassQQbarStr[q1-1][q3-1] + minMassQQbarStr[q2-1][q4-1],
minMassQQbarStr[q1-1][q4-1] + minMassQQbarStr[q2-1][q3-1]);
// In principle, re-orangement and 2 baryon production can compite.
// More physics consideration is needed.
MinimalStringMass=EstimatedMass;
SetMinimalStringMass2(EstimatedMass);
return;
}
//--------------------------------------------------------------------------------------
void G4VLongitudinalStringDecay::SetMinimalStringMass2(const G4double aValue)
{
MinimalStringMass2=aValue * aValue;
}