Geant4  10.01.p03
G4VLongitudinalStringDecay.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 // $Id: G4VLongitudinalStringDecay.cc 84826 2014-10-21 12:31:00Z gcosmo $
28 //
29 // -----------------------------------------------------------------------------
30 // GEANT 4 class implementation file
31 //
32 // History: first implementation, Maxim Komogorov, 1-Jul-1998
33 // redesign Gunter Folger, August/September 2001
34 // -----------------------------------------------------------------------------
36 #include "G4PhysicalConstants.hh"
37 #include "G4SystemOfUnits.hh"
38 #include "G4ios.hh"
39 #include "Randomize.hh"
40 #include "G4FragmentingString.hh"
41 
42 #include "G4ParticleDefinition.hh"
43 #include "G4ParticleTypes.hh"
44 #include "G4ParticleChange.hh"
45 #include "G4VShortLivedParticle.hh"
47 #include "G4ParticleTable.hh"
49 #include "G4VDecayChannel.hh"
50 #include "G4DecayTable.hh"
51 
52 #include "G4DiQuarks.hh"
53 #include "G4Quarks.hh"
54 #include "G4Gluons.hh"
55 
56 //------------------------debug switches
57 //#define debug_VStringDecay // Uzhi 20.06.2014
58 
59 //********************************************************************************
60 // Constructors
61 
63 {
64  MassCut = 0.35*GeV;
65  ClusterMass = 0.15*GeV;
66 
67  SmoothParam = 0.9;
68  StringLoopInterrupt = 1000;
70 
71 // Changable Parameters below.
72  SigmaQT = 0.5 * GeV; // 0.5 0.1
73 
74  StrangeSuppress = 0.44; // 27 % strange quarks produced, ie. u:d:s=1:1:0.27
75  DiquarkSuppress = 0.07;
76  DiquarkBreakProb = 0.1;
77 
78  //... pspin_meson is probability to create pseudo-scalar meson
79  pspin_meson = 0.5;
80 
81  //... pspin_barion is probability to create 1/2 barion
82  pspin_barion = 0.5;
83 
84  //... vectorMesonMix[] is quark mixing parameters for vector mesons (Variable spin = 3)
85  vectorMesonMix.resize(6);
86  vectorMesonMix[0] = 0.0; //AR-20Oct2014 : it was 0.5
87  vectorMesonMix[1] = 0.0;
88  vectorMesonMix[2] = 0.0; //AR-20Oct2014 : it was 0.5
89  vectorMesonMix[3] = 0.0;
90  vectorMesonMix[4] = 1.0;
91  vectorMesonMix[5] = 1.0;
92 
93  //... scalarMesonMix[] is quark mixing parameters for scalar mesons (Variable spin=1)
94  scalarMesonMix.resize(6);
95  scalarMesonMix[0] = 0.5;
96  scalarMesonMix[1] = 0.25;
97  scalarMesonMix[2] = 0.5;
98  scalarMesonMix[3] = 0.25;
99  scalarMesonMix[4] = 1.0;
100  scalarMesonMix[5] = 0.5;
101 
102 // Parameters may be changed until the first fragmentation starts
103  PastInitPhase=false;
106  Kappa = 1.0 * GeV/fermi;
107 
108 
109 }
110 
111 
113  {
114  delete hadronizer;
115  }
116 
117 //=============================================================================
118 
119 // Operators
120 
121 //-----------------------------------------------------------------------------
122 
124  {
125  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::operator== forbidden");
126  return false;
127  }
128 
129 //-------------------------------------------------------------------------------------
130 
132  {
133  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::operator!= forbidden");
134  return true;
135  }
136 
137 //***********************************************************************************
138 
139 // For changing Mass Cut used for selection of very small mass strings
141 
142 //-----------------------------------------------------------------------------
143 
144 // For handling a string with very low mass
145 
147  G4ExcitedString * const string)
148 {
149  // Check string decay threshold
150  G4KineticTrackVector * result=0; // return 0 when string exceeds the mass cut
151 
153 //
154  G4FragmentingString aString(*string);
155  if ( sqr(FragmentationMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
156  return 0;
157  }
158 //
159 // The string mass is very low ---------------------------
160 
161  result=new G4KineticTrackVector;
162 
163  if ( hadrons.second ==0 )
164  {
165 // Substitute string by light hadron, Note that Energy is not conserved here!
166 
167 // Uzhi 20.06.2014
168 #ifdef debug_VStringDecay
169  G4cout << "VlongSF Warning replacing string by single hadron (G4VLongitudinalStringDecay)" <<G4endl;
170  G4cout << hadrons.first->GetParticleName()<<G4endl
171  << "string .. " << string->Get4Momentum() << " "
172  << string->Get4Momentum().m() << G4endl;
173 #endif
174 //
175  G4ThreeVector Mom3 = string->Get4Momentum().vect();
176  G4LorentzVector Mom(Mom3,
177  std::sqrt(Mom3.mag2() +
178  sqr(hadrons.first->GetPDGMass())));
179  result->push_back(new G4KineticTrack(hadrons.first, 0,
180  string->GetPosition(),
181  Mom));
182  } else
183  {
184 //... string was qq--qqbar type: Build two stable hadrons,
185 
186 // Uzhi 20.06.2014
187 #ifdef debug_VStringDecay
188  G4cout << "VlongSF Warning replacing qq-qqbar string by TWO hadrons (G4VLongitudinalStringDecay)"
189  << hadrons.first->GetParticleName() << " / "
190  << hadrons.second->GetParticleName()
191  << "string .. " << string->Get4Momentum() << " "
192  << string->Get4Momentum().m() << G4endl;
193 #endif
194 
195  G4LorentzVector Mom1, Mom2;
196  Sample4Momentum(&Mom1, hadrons.first->GetPDGMass(),
197  &Mom2,hadrons.second->GetPDGMass(),
198  string->Get4Momentum().mag());
199 
200  result->push_back(new G4KineticTrack(hadrons.first, 0,
201  string->GetPosition(),
202  Mom1));
203  result->push_back(new G4KineticTrack(hadrons.second, 0,
204  string->GetPosition(),
205  Mom2));
206 
207  G4ThreeVector Velocity = string->Get4Momentum().boostVector();
208  result->Boost(Velocity);
209  }
210 
211  return result;
212 
213 }
214 
215 //----------------------------------------------------------------------------------------
216 
218  const G4FragmentingString * const string,
219  Pcreate build, pDefPair * pdefs )
220 {
221  G4double mass;
222  static G4ThreadLocal G4bool NeedInit(true);
223  static G4ThreadLocal std::vector<double> *nomix_G4MT_TLS_ = 0 ; if (!nomix_G4MT_TLS_) nomix_G4MT_TLS_ = new std::vector<double> ; std::vector<double> &nomix = *nomix_G4MT_TLS_;
224  static G4ThreadLocal G4HadronBuilder * minMassHadronizer;
225  if ( NeedInit )
226  {
227  NeedInit = false;
228  nomix.resize(6);
229  for ( G4int i=0; i<6 ; i++ ) nomix[i]=0;
230 
231 // minMassHadronizer=new G4HadronBuilder(pspin_meson,pspin_barion,nomix,nomix);
232  minMassHadronizer=hadronizer;
233  }
234 
235  if ( build==0 ) build=&G4HadronBuilder::BuildLowSpin;
236 
237  G4ParticleDefinition *Hadron1, *Hadron2=0;
238 
239  if (!string->FourQuarkString() )
240  {
241  // spin 0 meson or spin 1/2 barion will be built
242 
243  Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
244  string->GetRightParton());
245 
246 // Uzhi 20.06.2014
247 #ifdef debug_VStringDecay
248  G4cout<<"Quarks at the string ends "<<string->GetLeftParton()->GetParticleName()<<" "<<string->GetRightParton()->GetParticleName()<<G4endl;
249  G4cout<<"(G4VLongitudinalStringDecay) Hadron "<<Hadron1->GetParticleName()<<" "<<Hadron1->GetPDGMass()<<G4endl;
250 #endif
251  mass= (Hadron1)->GetPDGMass();
252  } else
253  {
254  //... string is qq--qqbar: Build two stable hadrons,
255  //... with extra uubar or ddbar quark pair
256  G4int iflc = (G4UniformRand() < 0.5)? 1 : 2;
257  if (string->GetLeftParton()->GetPDGEncoding() < 0) iflc = -iflc;
258 
259  //... theSpin = 4; spin 3/2 baryons will be built
260  Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
261  FindParticle(iflc) );
262  Hadron2 = (minMassHadronizer->*build)(string->GetRightParton(),
263  FindParticle(-iflc) );
264  mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
265  }
266 
267  if ( pdefs != 0 )
268  { // need to return hadrons as well....
269  pdefs->first = Hadron1;
270  pdefs->second = Hadron2;
271  }
272 
273  return mass;
274 }
275 
276 //----------------------------------------------------------------------------
277 
279  {
281  if (ptr == NULL)
282  {
283  G4cout << "Particle with encoding "<<Encoding<<" does not exist!!!"<<G4endl;
284  throw G4HadronicException(__FILE__, __LINE__, "Check your particle table");
285  }
286  return ptr;
287  }
288 
289 //*********************************************************************************
290 // For decision on continue or stop string fragmentation
291 // virtual G4bool StopFragmenting(const G4FragmentingString * const string)=0;
292 // virtual G4bool IsFragmentable(const G4FragmentingString * const string)=0;
293 
294 // If a string can not fragment, make last break into 2 hadrons
295 // virtual G4bool SplitLast(G4FragmentingString * string,
296 // G4KineticTrackVector * LeftVector,
297 // G4KineticTrackVector * RightVector)=0;
298 //-----------------------------------------------------------------------------
299 //
300 // If a string fragments, do the following
301 //
302 // For transver of a string to its CMS frame
303 //-----------------------------------------------------------------------------
304 
306 {
307  G4Parton *Left=new G4Parton(*in.GetLeftParton());
308  G4Parton *Right=new G4Parton(*in.GetRightParton());
309  return new G4ExcitedString(Left,Right,in.GetDirection());
310 }
311 
312 //-----------------------------------------------------------------------------
313 
315  G4FragmentingString *string,
316  G4FragmentingString *&newString)
317 {
318 // Uzhi 20.06.2014
319 #ifdef debug_VStringDecay
320  G4cout<<G4endl;
321  G4cout<<"Start SplitUP (G4VLongitudinalStringDecay) ========================="<<G4endl;
322  G4cout<<"String partons: " <<string->GetLeftParton()->GetPDGEncoding()<<" "
323  <<string->GetRightParton()->GetPDGEncoding()<<" "
324  <<"Direction " <<string->GetDecayDirection()<<G4endl;
325 #endif
326 
327  //... random choice of string end to use for creating the hadron (decay)
328  G4int SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
329  if (SideOfDecay < 0)
330  {
331  string->SetLeftPartonStable();
332  } else
333  {
334  string->SetRightPartonStable();
335  }
336 
337  G4ParticleDefinition *newStringEnd;
338  G4ParticleDefinition * HadronDefinition;
339  if (string->DecayIsQuark())
340  {
341  HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
342  } else {
343  HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
344  }
345 
346 // Uzhi 20.06.2014
347 #ifdef debug_VStringDecay
348  G4cout<<"The parton "<<string->GetDecayParton()->GetPDGEncoding()<<" "
349  <<" produces hadron "<<HadronDefinition->GetParticleName()
350  <<" and is transformed to "<<newStringEnd->GetPDGEncoding()<<G4endl;
351  G4cout<<"The side of the string decay Left/Right (1/-1) "<<SideOfDecay<<G4endl;
352 #endif
353 // create new String from old, ie. keep Left and Right order, but replace decay
354 
355  newString=new G4FragmentingString(*string,newStringEnd); // To store possible
356  // quark containt of new string
357 
358 // Uzhi 20.06.2014
359 #ifdef debug_VStringDecay
360  G4cout<<"An attempt to determine its energy (SplitEandP)"<<G4endl;
361 #endif
362  G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
363 
364  delete newString; newString=0;
365 
366  G4KineticTrack * Hadron =0;
367  if ( HadronMomentum != 0 ) {
368 
369 // Uzhi 20.06.2014
370 #ifdef debug_VStringDecay
371  G4cout<<"The attempt was successful"<<G4endl;
372 #endif
373  G4ThreeVector Pos;
374  Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
375 
376  newString=new G4FragmentingString(*string,newStringEnd,
377  HadronMomentum);
378 
379  delete HadronMomentum;
380  }
381  else
382  {
383 
384 // Uzhi 20.06.2014
385 #ifdef debug_VStringDecay
386  G4cout<<"The attempt was not successful !!!"<<G4endl;
387 #endif
388  }
389 
390 // Uzhi 20.06.2014
391 #ifdef debug_VStringDecay
392  G4cout<<"End SplitUP (G4VLongitudinalStringDecay) ====================="<<G4endl;
393 #endif
394 
395  return Hadron;
396 }
397 
398 //--------------------------------------------------------------------------------------
399 
402  decay, G4ParticleDefinition *&created)
403 {
404  G4int IsParticle=(decay->GetPDGEncoding()>0) ? -1 : +1; // if we have a quark,
405  // we need antiquark
406  // (or diquark)
407  pDefPair QuarkPair = CreatePartonPair(IsParticle);
408  created = QuarkPair.second;
409  return hadronizer->Build(QuarkPair.first, decay);
410 
411 }
412 /* // Uzhi June 2014
413 //-----------------------------------------------------------------------------
414 
415 G4ParticleDefinition *G4VLongitudinalStringDecay::DiQuarkSplitup(
416  G4ParticleDefinition* decay,
417  G4ParticleDefinition *&created)
418 {
419  //... can Diquark break or not?
420  if (G4UniformRand() < DiquarkBreakProb ){
421  //... Diquark break
422 
423  G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
424  G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
425  if (G4UniformRand() < 0.5)
426  {
427  G4int Swap = stableQuarkEncoding;
428  stableQuarkEncoding = decayQuarkEncoding;
429  decayQuarkEncoding = Swap;
430  }
431 
432  G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1;
433  // if we have a quark, we need antiquark)
434 
435  pDefPair QuarkPair = CreatePartonPair(IsParticle,false); // no diquarks wanted
436 
437  //... Build new Diquark
438  G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
439  G4int i10 = std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
440  G4int i20 = std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
441  G4int spin = (i10 != i20 && G4UniformRand() <= 0.5)? 1 : 3;
442  G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
443  created = FindParticle(NewDecayEncoding);
444  G4ParticleDefinition * decayQuark=FindParticle(decayQuarkEncoding);
445  G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decayQuark);
446  return had;
447 // return hadronizer->Build(QuarkPair.first, decayQuark);
448 
449  } else {
450  //... Diquark does not break
451 
452  G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1;
453  // if we have a diquark, we need quark)
454  pDefPair QuarkPair = CreatePartonPair(IsParticle,false); // no diquarks wanted
455  created = QuarkPair.second;
456 
457  G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
458  return had;
459 // return G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
460  }
461 }
462 */ // Uzhi June 2014
463 //-----------------------------------------------------------------------------
464 
466  {
467  return (1 + (int)(G4UniformRand()/StrangeSuppress));
468  }
469 
470 //-----------------------------------------------------------------------------
471 
473 {
474 // NeedParticle = +1 for Particle, -1 for Antiparticle
475 
476  if ( AllowDiquarks && G4UniformRand() < DiquarkSuppress )
477  {
478  // Create a Diquark - AntiDiquark pair , first in pair is anti to IsParticle
479  G4int q1 = SampleQuarkFlavor();
480  G4int q2 = SampleQuarkFlavor();
481  G4int spin = (q1 != q2 && G4UniformRand() <= 0.5)? 1 : 3;
482  // convention: quark with higher PDG number is first
483  G4int PDGcode = (std::max(q1,q2) * 1000 + std::min(q1,q2) * 100 + spin) * NeedParticle;
484  return pDefPair (FindParticle(-PDGcode),FindParticle(PDGcode));
485 
486 
487  } else {
488  // Create a Quark - AntiQuark pair, first in pair IsParticle
489  G4int PDGcode=SampleQuarkFlavor()*NeedParticle;
490  return pDefPair (FindParticle(PDGcode),FindParticle(-PDGcode));
491  }
492 
493 }
494 
495 //-----------------------------------------------------------------------------
497  {
498  G4double Pt;
499  if ( ptMax < 0 ) {
500  // sample full gaussian
501  Pt = -std::log(G4UniformRand());
502  } else {
503  // sample in limited range
504  Pt = -std::log(G4RandFlat::shoot(std::exp(-sqr(ptMax)/sqr(SigmaQT)), 1.));
505  }
506  Pt = SigmaQT * std::sqrt(Pt);
507  G4double phi = 2.*pi*G4UniformRand();
508  return G4ThreeVector(Pt * std::cos(phi),Pt * std::sin(phi),0);
509  }
510 
511 //******************************************************************************
512 
514  {
515 
516 // `yo-yo` formation time
517 // const G4double kappa = 1.0 * GeV/fermi/4.;
519  for(size_t c1 = 0; c1 < Hadrons->size(); c1++)
520  {
521  G4double SumPz = 0;
522  G4double SumE = 0;
523  for(size_t c2 = 0; c2 < c1; c2++)
524  {
525  SumPz += Hadrons->operator[](c2)->Get4Momentum().pz();
526  SumE += Hadrons->operator[](c2)->Get4Momentum().e();
527  }
528  G4double HadronE = Hadrons->operator[](c1)->Get4Momentum().e();
529  G4double HadronPz = Hadrons->operator[](c1)->Get4Momentum().pz();
530  Hadrons->operator[](c1)->SetFormationTime(
531 (theInitialStringMass - 2.*SumPz + HadronE - HadronPz)/(2.*kappa)/c_light);
532 
533  G4ThreeVector aPosition(0, 0,
534 (theInitialStringMass - 2.*SumE - HadronE + HadronPz)/(2.*kappa));
535  Hadrons->operator[](c1)->SetPosition(aPosition);
536 
537  }
538  }
539 
540 //-----------------------------------------------------------------------------
541 
543 {
544  if ( PastInitPhase ) {
545  throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
546  } else {
547  SigmaQT = aValue;
548  }
549 }
550 
551 //----------------------------------------------------------------------------------------------------------
552 
554 {
555  if ( PastInitPhase ) {
556  throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetStrangenessSuppression after FragmentString() not allowed");
557  } else {
558  StrangeSuppress = aValue;
559  }
560 }
561 
562 //----------------------------------------------------------------------------------------------------------
563 
565 {
566  if ( PastInitPhase ) {
567  throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkSuppression after FragmentString() not allowed");
568  } else {
569  DiquarkSuppress = aValue;
570  }
571 }
572 
573 //----------------------------------------------------------------------------------------
574 
576 {
577  if ( PastInitPhase ) {
578  throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkBreakProbability after FragmentString() not allowed");
579  } else {
580  DiquarkBreakProb = aValue;
581  }
582 }
583 
584 //----------------------------------------------------------------------------------------------------------
585 
587 {
588  if ( PastInitPhase ) {
589  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonProbability after FragmentString() not allowed");
590  } else {
591  pspin_meson = aValue;
592  delete hadronizer;
595  }
596 }
597 
598 //----------------------------------------------------------------------------------------------------------
599 
601 {
602  if ( PastInitPhase ) {
603  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability after FragmentString() not allowed");
604  } else {
605  pspin_barion = aValue;
606  delete hadronizer;
609  }
610 }
611 
612 //----------------------------------------------------------------------------------------------------------
613 
614 void G4VLongitudinalStringDecay::SetScalarMesonMixings(std::vector<G4double> aVector)
615 {
616  if ( PastInitPhase ) {
617  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings after FragmentString() not allowed");
618  } else {
619  if ( aVector.size() < 6 )
620  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings( argument Vector too small");
621  scalarMesonMix[0] = aVector[0];
622  scalarMesonMix[1] = aVector[1];
623  scalarMesonMix[2] = aVector[2];
624  scalarMesonMix[3] = aVector[3];
625  scalarMesonMix[4] = aVector[4];
626  scalarMesonMix[5] = aVector[5];
627  delete hadronizer;
630  }
631 }
632 
633 //----------------------------------------------------------------------------------------------------------
634 
635 void G4VLongitudinalStringDecay::SetVectorMesonMixings(std::vector<G4double> aVector)
636 {
637  if ( PastInitPhase ) {
638  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings after FragmentString() not allowed");
639  } else {
640  if ( aVector.size() < 6 )
641  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings( argument Vector too small");
642  vectorMesonMix[0] = aVector[0];
643  vectorMesonMix[1] = aVector[1];
644  vectorMesonMix[2] = aVector[2];
645  vectorMesonMix[3] = aVector[3];
646  vectorMesonMix[4] = aVector[4];
647  vectorMesonMix[5] = aVector[5];
648  delete hadronizer;
651 
652  }
653 }
654 
655 //-------------------------------------------------------------------------------------------
657 {
658  Kappa = aValue * GeV/fermi;
659 }
660 //**************************************************************************************
661 
G4ParticleDefinition * GetRightParton(void) const
int operator!=(const G4VLongitudinalStringDecay &right) const
ThreeVector shoot(const G4int Ap, const G4int Af)
static c2_factory< G4double > c2
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
G4ParticleDefinition * QuarkSplitup(G4ParticleDefinition *decay, G4ParticleDefinition *&created)
CLHEP::Hep3Vector G4ThreeVector
G4ParticleDefinition * BuildLowSpin(G4ParticleDefinition *black, G4ParticleDefinition *white)
G4ExcitedString * CPExcited(const G4ExcitedString &string)
const G4double pi
void SetStrangenessSuppression(G4double aValue)
G4ParticleDefinition * Build(G4ParticleDefinition *black, G4ParticleDefinition *white)
G4Parton * GetLeftParton(void) const
G4ThreeVector SampleQuarkPt(G4double ptMax=-1.)
std::vector< G4double > vectorMesonMix
#define G4ThreadLocal
Definition: tls.hh:89
G4double FragmentationMass(const G4FragmentingString *const string, Pcreate build=0, pDefPair *pdefs=0)
virtual void SetMassCut(G4double aValue)
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
G4ParticleDefinition * GetDecayParton() const
pDefPair CreatePartonPair(G4int NeedParticle, G4bool AllowDiquarks=true)
void SetStringTensionParameter(G4double aValue)
const G4ThreeVector & GetPosition() const
G4ParticleDefinition * GetLeftParton(void) const
G4double Mass2() const
void SetDiquarkBreakProbability(G4double aValue)
#define G4UniformRand()
Definition: Randomize.hh:93
G4GLOB_DLL std::ostream G4cout
ParticleList decay(Cluster *const c)
Carries out a cluster decay.
G4KineticTrackVector * LightFragmentationTest(const G4ExcitedString *const theString)
std::pair< G4ParticleDefinition *, G4ParticleDefinition * > pDefPair
bool G4bool
Definition: G4Types.hh:79
G4ParticleDefinition * FindParticle(G4int Encoding)
virtual void Sample4Momentum(G4LorentzVector *Mom, G4double Mass, G4LorentzVector *AntiMom, G4double AntiMass, G4double InitialMass)=0
static const double GeV
Definition: G4SIunits.hh:196
void Boost(G4ThreeVector &Velocity)
static const G4double c1
G4bool FourQuarkString(void) const
std::vector< G4double > scalarMesonMix
int operator==(const G4VLongitudinalStringDecay &right) const
void SetVectorMesonProbability(G4double aValue)
G4Parton * GetRightParton(void) const
G4double GetPDGMass() const
static G4ParticleTable * GetParticleTable()
T max(const T t1, const T t2)
brief Return the largest of the two arguments
void SetVectorMesonMixings(std::vector< G4double > aVector)
void SetSpinThreeHalfBarionProbability(G4double aValue)
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
G4int GetDirection(void) const
#define G4endl
Definition: G4ios.hh:61
T sqr(const T &x)
Definition: templates.hh:145
virtual G4ParticleDefinition * DiQuarkSplitup(G4ParticleDefinition *decay, G4ParticleDefinition *&created)=0
double G4double
Definition: G4Types.hh:76
void SetScalarMesonMixings(std::vector< G4double > aVector)
void CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector *)
virtual G4LorentzVector * SplitEandP(G4ParticleDefinition *pHadron, G4FragmentingString *string, G4FragmentingString *newString)=0
static const double fermi
Definition: G4SIunits.hh:93
G4KineticTrack * Splitup(G4FragmentingString *string, G4FragmentingString *&newString)
void SetDiquarkSuppression(G4double aValue)
CLHEP::HepLorentzVector G4LorentzVector