Geant4  10.02.p01
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 91773 2015-08-05 13:59:07Z 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 #include "G4Exp.hh"
57 #include "G4Log.hh"
58 
59 //------------------------debug switches
60 //#define debug_VStringDecay // Uzhi 20.06.2014
61 
62 //********************************************************************************
63 // Constructors
64 
66 {
67  MassCut = 0.35*GeV;
68  ClusterMass = 0.15*GeV;
69 
70  SmoothParam = 0.9;
71  StringLoopInterrupt = 1000;
73 
74 // Changable Parameters below.
75  SigmaQT = 0.5 * GeV; // 0.5 0.1
76 
77  StrangeSuppress = 0.44; // 27 % strange quarks produced, ie. u:d:s=1:1:0.27
78  DiquarkSuppress = 0.07;
79  DiquarkBreakProb = 0.1;
80 
81  //... pspin_meson is probability to create pseudo-scalar meson
82  pspin_meson = 0.5;
83 
84  //... pspin_barion is probability to create 1/2 barion
85  pspin_barion = 0.5;
86 
87  //... vectorMesonMix[] is quark mixing parameters for vector mesons (Variable spin = 3)
88  vectorMesonMix.resize(6);
89  vectorMesonMix[0] = 0.0; //AR-20Oct2014 : it was 0.5
90  vectorMesonMix[1] = 0.0;
91  vectorMesonMix[2] = 0.0; //AR-20Oct2014 : it was 0.5
92  vectorMesonMix[3] = 0.0;
93  vectorMesonMix[4] = 1.0;
94  vectorMesonMix[5] = 1.0;
95 
96  //... scalarMesonMix[] is quark mixing parameters for scalar mesons (Variable spin=1)
97  scalarMesonMix.resize(6);
98  scalarMesonMix[0] = 0.5;
99  scalarMesonMix[1] = 0.25;
100  scalarMesonMix[2] = 0.5;
101  scalarMesonMix[3] = 0.25;
102  scalarMesonMix[4] = 1.0;
103  scalarMesonMix[5] = 0.5;
104 
105 // Parameters may be changed until the first fragmentation starts
106  PastInitPhase=false;
109  Kappa = 1.0 * GeV/fermi;
110 
111 
112 }
113 
114 
116  {
117  delete hadronizer;
118  }
119 
120 //=============================================================================
121 
122 // Operators
123 
124 //-----------------------------------------------------------------------------
125 
127  {
128  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::operator== forbidden");
129  return false;
130  }
131 
132 //-------------------------------------------------------------------------------------
133 
135  {
136  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::operator!= forbidden");
137  return true;
138  }
139 
140 //***********************************************************************************
141 
142 // For changing Mass Cut used for selection of very small mass strings
144 
145 //-----------------------------------------------------------------------------
146 
147 // For handling a string with very low mass
148 
150  G4ExcitedString * const string)
151 {
152  // Check string decay threshold
153  G4KineticTrackVector * result=0; // return 0 when string exceeds the mass cut
154 
156 //
157  G4FragmentingString aString(*string);
158  if ( sqr(FragmentationMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
159  return 0;
160  }
161 //
162 // The string mass is very low ---------------------------
163 
164  result=new G4KineticTrackVector;
165 
166  if ( hadrons.second ==0 )
167  {
168 // Substitute string by light hadron, Note that Energy is not conserved here!
169 
170 // Uzhi 20.06.2014
171 #ifdef debug_VStringDecay
172  G4cout << "VlongSF Warning replacing string by single hadron (G4VLongitudinalStringDecay)" <<G4endl;
173  G4cout << hadrons.first->GetParticleName()<<G4endl
174  << "string .. " << string->Get4Momentum() << " "
175  << string->Get4Momentum().m() << G4endl;
176 #endif
177 //
178  G4ThreeVector Mom3 = string->Get4Momentum().vect();
179  G4LorentzVector Mom(Mom3,
180  std::sqrt(Mom3.mag2() +
181  sqr(hadrons.first->GetPDGMass())));
182  result->push_back(new G4KineticTrack(hadrons.first, 0,
183  string->GetPosition(),
184  Mom));
185  } else
186  {
187 //... string was qq--qqbar type: Build two stable hadrons,
188 
189 // Uzhi 20.06.2014
190 #ifdef debug_VStringDecay
191  G4cout << "VlongSF Warning replacing qq-qqbar string by TWO hadrons (G4VLongitudinalStringDecay)"
192  << hadrons.first->GetParticleName() << " / "
193  << hadrons.second->GetParticleName()
194  << "string .. " << string->Get4Momentum() << " "
195  << string->Get4Momentum().m() << G4endl;
196 #endif
197 
198  G4LorentzVector Mom1, Mom2;
199  Sample4Momentum(&Mom1, hadrons.first->GetPDGMass(),
200  &Mom2,hadrons.second->GetPDGMass(),
201  string->Get4Momentum().mag());
202 
203  result->push_back(new G4KineticTrack(hadrons.first, 0,
204  string->GetPosition(),
205  Mom1));
206  result->push_back(new G4KineticTrack(hadrons.second, 0,
207  string->GetPosition(),
208  Mom2));
209 
210  G4ThreeVector Velocity = string->Get4Momentum().boostVector();
211  result->Boost(Velocity);
212  }
213 
214  return result;
215 
216 }
217 
218 //----------------------------------------------------------------------------------------
219 
221  const G4FragmentingString * const string,
222  Pcreate build, pDefPair * pdefs )
223 {
224  G4double mass;
225  static G4ThreadLocal G4bool NeedInit(true);
226  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_;
227  static G4ThreadLocal G4HadronBuilder * minMassHadronizer;
228  if ( NeedInit )
229  {
230  NeedInit = false;
231  nomix.resize(6);
232  for ( G4int i=0; i<6 ; i++ ) nomix[i]=0;
233 
234 // minMassHadronizer=new G4HadronBuilder(pspin_meson,pspin_barion,nomix,nomix);
235  minMassHadronizer=hadronizer;
236  }
237 
238  if ( build==0 ) build=&G4HadronBuilder::BuildLowSpin;
239 
240  G4ParticleDefinition *Hadron1, *Hadron2=0;
241 
242  if (!string->FourQuarkString() )
243  {
244  // spin 0 meson or spin 1/2 barion will be built
245 
246  Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
247  string->GetRightParton());
248 
249 // Uzhi 20.06.2014
250 #ifdef debug_VStringDecay
251  G4cout<<"Quarks at the string ends "<<string->GetLeftParton()->GetParticleName()<<" "<<string->GetRightParton()->GetParticleName()<<G4endl;
252  G4cout<<"(G4VLongitudinalStringDecay) Hadron "<<Hadron1->GetParticleName()<<" "<<Hadron1->GetPDGMass()<<G4endl;
253 #endif
254  mass= (Hadron1)->GetPDGMass();
255  } else
256  {
257  //... string is qq--qqbar: Build two stable hadrons,
258  //... with extra uubar or ddbar quark pair
259  G4int iflc = (G4UniformRand() < 0.5)? 1 : 2;
260  if (string->GetLeftParton()->GetPDGEncoding() < 0) iflc = -iflc;
261 
262  //... theSpin = 4; spin 3/2 baryons will be built
263  Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
264  FindParticle(iflc) );
265  Hadron2 = (minMassHadronizer->*build)(string->GetRightParton(),
266  FindParticle(-iflc) );
267  mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
268  }
269 
270  if ( pdefs != 0 )
271  { // need to return hadrons as well....
272  pdefs->first = Hadron1;
273  pdefs->second = Hadron2;
274  }
275 
276  return mass;
277 }
278 
279 //----------------------------------------------------------------------------
280 
282  {
284  if (ptr == NULL)
285  {
286  G4cout << "Particle with encoding "<<Encoding<<" does not exist!!!"<<G4endl;
287  throw G4HadronicException(__FILE__, __LINE__, "Check your particle table");
288  }
289  return ptr;
290  }
291 
292 //*********************************************************************************
293 // For decision on continue or stop string fragmentation
294 // virtual G4bool StopFragmenting(const G4FragmentingString * const string)=0;
295 // virtual G4bool IsFragmentable(const G4FragmentingString * const string)=0;
296 
297 // If a string can not fragment, make last break into 2 hadrons
298 // virtual G4bool SplitLast(G4FragmentingString * string,
299 // G4KineticTrackVector * LeftVector,
300 // G4KineticTrackVector * RightVector)=0;
301 //-----------------------------------------------------------------------------
302 //
303 // If a string fragments, do the following
304 //
305 // For transver of a string to its CMS frame
306 //-----------------------------------------------------------------------------
307 
309 {
310  G4Parton *Left=new G4Parton(*in.GetLeftParton());
311  G4Parton *Right=new G4Parton(*in.GetRightParton());
312  return new G4ExcitedString(Left,Right,in.GetDirection());
313 }
314 
315 //-----------------------------------------------------------------------------
316 
318  G4FragmentingString *string,
319  G4FragmentingString *&newString)
320 {
321 // Uzhi 20.06.2014
322 #ifdef debug_VStringDecay
323  G4cout<<G4endl;
324  G4cout<<"Start SplitUP (G4VLongitudinalStringDecay) ========================="<<G4endl;
325  G4cout<<"String partons: " <<string->GetLeftParton()->GetPDGEncoding()<<" "
326  <<string->GetRightParton()->GetPDGEncoding()<<" "
327  <<"Direction " <<string->GetDecayDirection()<<G4endl;
328 #endif
329 
330  //... random choice of string end to use for creating the hadron (decay)
331  G4int SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
332  if (SideOfDecay < 0)
333  {
334  string->SetLeftPartonStable();
335  } else
336  {
337  string->SetRightPartonStable();
338  }
339 
340  G4ParticleDefinition *newStringEnd;
341  G4ParticleDefinition * HadronDefinition;
342  if (string->DecayIsQuark())
343  {
344  HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
345  } else {
346  HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
347  }
348 
349 // Uzhi 20.06.2014
350 #ifdef debug_VStringDecay
351  G4cout<<"The parton "<<string->GetDecayParton()->GetPDGEncoding()<<" "
352  <<" produces hadron "<<HadronDefinition->GetParticleName()
353  <<" and is transformed to "<<newStringEnd->GetPDGEncoding()<<G4endl;
354  G4cout<<"The side of the string decay Left/Right (1/-1) "<<SideOfDecay<<G4endl;
355 #endif
356 // create new String from old, ie. keep Left and Right order, but replace decay
357 
358  newString=new G4FragmentingString(*string,newStringEnd); // To store possible
359  // quark containt of new string
360 
361 // Uzhi 20.06.2014
362 #ifdef debug_VStringDecay
363  G4cout<<"An attempt to determine its energy (SplitEandP)"<<G4endl;
364 #endif
365  G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
366 
367  delete newString; newString=0;
368 
369  G4KineticTrack * Hadron =0;
370  if ( HadronMomentum != 0 ) {
371 
372 // Uzhi 20.06.2014
373 #ifdef debug_VStringDecay
374  G4cout<<"The attempt was successful"<<G4endl;
375 #endif
376  G4ThreeVector Pos;
377  Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
378 
379  newString=new G4FragmentingString(*string,newStringEnd,
380  HadronMomentum);
381 
382  delete HadronMomentum;
383  }
384  else
385  {
386 
387 // Uzhi 20.06.2014
388 #ifdef debug_VStringDecay
389  G4cout<<"The attempt was not successful !!!"<<G4endl;
390 #endif
391  }
392 
393 // Uzhi 20.06.2014
394 #ifdef debug_VStringDecay
395  G4cout<<"End SplitUP (G4VLongitudinalStringDecay) ====================="<<G4endl;
396 #endif
397 
398  return Hadron;
399 }
400 
401 //--------------------------------------------------------------------------------------
402 
405  decay, G4ParticleDefinition *&created)
406 {
407  G4int IsParticle=(decay->GetPDGEncoding()>0) ? -1 : +1; // if we have a quark,
408  // we need antiquark
409  // (or diquark)
410  pDefPair QuarkPair = CreatePartonPair(IsParticle);
411  created = QuarkPair.second;
412  return hadronizer->Build(QuarkPair.first, decay);
413 
414 }
415 /* // Uzhi June 2014
416 //-----------------------------------------------------------------------------
417 
418 G4ParticleDefinition *G4VLongitudinalStringDecay::DiQuarkSplitup(
419  G4ParticleDefinition* decay,
420  G4ParticleDefinition *&created)
421 {
422  //... can Diquark break or not?
423  if (G4UniformRand() < DiquarkBreakProb ){
424  //... Diquark break
425 
426  G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
427  G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
428  if (G4UniformRand() < 0.5)
429  {
430  G4int Swap = stableQuarkEncoding;
431  stableQuarkEncoding = decayQuarkEncoding;
432  decayQuarkEncoding = Swap;
433  }
434 
435  G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1;
436  // if we have a quark, we need antiquark)
437 
438  pDefPair QuarkPair = CreatePartonPair(IsParticle,false); // no diquarks wanted
439 
440  //... Build new Diquark
441  G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
442  G4int i10 = std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
443  G4int i20 = std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
444  G4int spin = (i10 != i20 && G4UniformRand() <= 0.5)? 1 : 3;
445  G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
446  created = FindParticle(NewDecayEncoding);
447  G4ParticleDefinition * decayQuark=FindParticle(decayQuarkEncoding);
448  G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decayQuark);
449  return had;
450 // return hadronizer->Build(QuarkPair.first, decayQuark);
451 
452  } else {
453  //... Diquark does not break
454 
455  G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1;
456  // if we have a diquark, we need quark)
457  pDefPair QuarkPair = CreatePartonPair(IsParticle,false); // no diquarks wanted
458  created = QuarkPair.second;
459 
460  G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
461  return had;
462 // return G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
463  }
464 }
465 */ // Uzhi June 2014
466 //-----------------------------------------------------------------------------
467 
469  {
470  return (1 + (int)(G4UniformRand()/StrangeSuppress));
471  }
472 
473 //-----------------------------------------------------------------------------
474 
476 {
477 // NeedParticle = +1 for Particle, -1 for Antiparticle
478 
479  if ( AllowDiquarks && G4UniformRand() < DiquarkSuppress )
480  {
481  // Create a Diquark - AntiDiquark pair , first in pair is anti to IsParticle
482  G4int q1 = SampleQuarkFlavor();
483  G4int q2 = SampleQuarkFlavor();
484  G4int spin = (q1 != q2 && G4UniformRand() <= 0.5)? 1 : 3;
485  // convention: quark with higher PDG number is first
486  G4int PDGcode = (std::max(q1,q2) * 1000 + std::min(q1,q2) * 100 + spin) * NeedParticle;
487  return pDefPair (FindParticle(-PDGcode),FindParticle(PDGcode));
488 
489 
490  } else {
491  // Create a Quark - AntiQuark pair, first in pair IsParticle
492  G4int PDGcode=SampleQuarkFlavor()*NeedParticle;
493  return pDefPair (FindParticle(PDGcode),FindParticle(-PDGcode));
494  }
495 
496 }
497 
498 //-----------------------------------------------------------------------------
500  {
501  G4double Pt;
502  if ( ptMax < 0 ) {
503  // sample full gaussian
504  Pt = -G4Log(G4UniformRand());
505  } else {
506  // sample in limited range
507  Pt = -G4Log(G4RandFlat::shoot(G4Exp(-sqr(ptMax)/sqr(SigmaQT)), 1.));
508  }
509  Pt = SigmaQT * std::sqrt(Pt);
510  G4double phi = 2.*pi*G4UniformRand();
511  return G4ThreeVector(Pt * std::cos(phi),Pt * std::sin(phi),0);
512  }
513 
514 //******************************************************************************
515 
517  {
518 
519 // `yo-yo` formation time
520 // const G4double kappa = 1.0 * GeV/fermi/4.;
522  for(size_t c1 = 0; c1 < Hadrons->size(); c1++)
523  {
524  G4double SumPz = 0;
525  G4double SumE = 0;
526  for(size_t c2 = 0; c2 < c1; c2++)
527  {
528  SumPz += Hadrons->operator[](c2)->Get4Momentum().pz();
529  SumE += Hadrons->operator[](c2)->Get4Momentum().e();
530  }
531  G4double HadronE = Hadrons->operator[](c1)->Get4Momentum().e();
532  G4double HadronPz = Hadrons->operator[](c1)->Get4Momentum().pz();
533  Hadrons->operator[](c1)->SetFormationTime(
534 (theInitialStringMass - 2.*SumPz + HadronE - HadronPz)/(2.*kappa)/c_light);
535 
536  G4ThreeVector aPosition(0, 0,
537 (theInitialStringMass - 2.*SumE - HadronE + HadronPz)/(2.*kappa));
538  Hadrons->operator[](c1)->SetPosition(aPosition);
539 
540  }
541  }
542 
543 //-----------------------------------------------------------------------------
544 
546 {
547  if ( PastInitPhase ) {
548  throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
549  } else {
550  SigmaQT = aValue;
551  }
552 }
553 
554 //----------------------------------------------------------------------------------------------------------
555 
557 {
558  if ( PastInitPhase ) {
559  throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetStrangenessSuppression after FragmentString() not allowed");
560  } else {
561  StrangeSuppress = aValue;
562  }
563 }
564 
565 //----------------------------------------------------------------------------------------------------------
566 
568 {
569  if ( PastInitPhase ) {
570  throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkSuppression after FragmentString() not allowed");
571  } else {
572  DiquarkSuppress = aValue;
573  }
574 }
575 
576 //----------------------------------------------------------------------------------------
577 
579 {
580  if ( PastInitPhase ) {
581  throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkBreakProbability after FragmentString() not allowed");
582  } else {
583  DiquarkBreakProb = aValue;
584  }
585 }
586 
587 //----------------------------------------------------------------------------------------------------------
588 
590 {
591  if ( PastInitPhase ) {
592  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonProbability after FragmentString() not allowed");
593  } else {
594  pspin_meson = aValue;
595  delete hadronizer;
598  }
599 }
600 
601 //----------------------------------------------------------------------------------------------------------
602 
604 {
605  if ( PastInitPhase ) {
606  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability after FragmentString() not allowed");
607  } else {
608  pspin_barion = aValue;
609  delete hadronizer;
612  }
613 }
614 
615 //----------------------------------------------------------------------------------------------------------
616 
617 void G4VLongitudinalStringDecay::SetScalarMesonMixings(std::vector<G4double> aVector)
618 {
619  if ( PastInitPhase ) {
620  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings after FragmentString() not allowed");
621  } else {
622  if ( aVector.size() < 6 )
623  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings( argument Vector too small");
624  scalarMesonMix[0] = aVector[0];
625  scalarMesonMix[1] = aVector[1];
626  scalarMesonMix[2] = aVector[2];
627  scalarMesonMix[3] = aVector[3];
628  scalarMesonMix[4] = aVector[4];
629  scalarMesonMix[5] = aVector[5];
630  delete hadronizer;
633  }
634 }
635 
636 //----------------------------------------------------------------------------------------------------------
637 
638 void G4VLongitudinalStringDecay::SetVectorMesonMixings(std::vector<G4double> aVector)
639 {
640  if ( PastInitPhase ) {
641  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings after FragmentString() not allowed");
642  } else {
643  if ( aVector.size() < 6 )
644  throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings( argument Vector too small");
645  vectorMesonMix[0] = aVector[0];
646  vectorMesonMix[1] = aVector[1];
647  vectorMesonMix[2] = aVector[2];
648  vectorMesonMix[3] = aVector[3];
649  vectorMesonMix[4] = aVector[4];
650  vectorMesonMix[5] = aVector[5];
651  delete hadronizer;
654 
655  }
656 }
657 
658 //-------------------------------------------------------------------------------------------
660 {
661  Kappa = aValue * GeV/fermi;
662 }
663 //**************************************************************************************
664 
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)
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:97
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:214
void Boost(G4ThreeVector &Velocity)
static const G4double c1
G4bool FourQuarkString(void) const
std::vector< G4double > scalarMesonMix
int operator==(const G4VLongitudinalStringDecay &right) const
G4double G4Log(G4double x)
Definition: G4Log.hh:230
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
void SetVectorMesonProbability(G4double aValue)
G4Parton * GetRightParton(void) const
G4double GetPDGMass() const
static const double pi
Definition: G4SIunits.hh:74
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:102
G4KineticTrack * Splitup(G4FragmentingString *string, G4FragmentingString *&newString)
void SetDiquarkSuppression(G4double aValue)
CLHEP::HepLorentzVector G4LorentzVector