Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions
G4LundStringFragmentation Class Reference

#include <G4LundStringFragmentation.hh>

Inheritance diagram for G4LundStringFragmentation:
G4VLongitudinalStringDecay

Public Member Functions

 G4LundStringFragmentation ()
 
virtual ~G4LundStringFragmentation ()
 
virtual G4KineticTrackVector * FragmentString (const G4ExcitedString &theString)
 
- Public Member Functions inherited from G4VLongitudinalStringDecay
 G4VLongitudinalStringDecay ()
 
virtual ~G4VLongitudinalStringDecay ()
 
G4int SampleQuarkFlavor (void)
 
G4ThreeVector SampleQuarkPt (G4double ptMax=-1.)
 
G4KineticTrackVector * DecayResonans (G4KineticTrackVector *aHadrons)
 
void SetSigmaTransverseMomentum (G4double aQT)
 
void SetStrangenessSuppression (G4double aValue)
 
void SetDiquarkSuppression (G4double aValue)
 
void SetDiquarkBreakProbability (G4double aValue)
 
void SetVectorMesonProbability (G4double aValue)
 
void SetSpinThreeHalfBarionProbability (G4double aValue)
 
void SetScalarMesonMixings (std::vector< G4double > aVector)
 
void SetVectorMesonMixings (std::vector< G4double > aVector)
 
void SetStringTensionParameter (G4double aValue)
 

Additional Inherited Members

- Protected Types inherited from G4VLongitudinalStringDecay
typedef std::pair
< G4ParticleDefinition
*, G4ParticleDefinition * > 		pDefPair
 
typedef G4ParticleDefinition
*(G4HadronBuilder::* 		Pcreate )(G4ParticleDefinition *, G4ParticleDefinition *)
 
- Protected Member Functions inherited from G4VLongitudinalStringDecay
virtual void SetMassCut (G4double aValue)
 
G4KineticTrackVector * LightFragmentationTest (const G4ExcitedString *const theString)
 
G4double FragmentationMass (const G4FragmentingString *const string, Pcreate build=0, pDefPair *pdefs=0)
 
G4ParticleDefinition * FindParticle (G4int Encoding)
 
G4ExcitedString * CPExcited (const G4ExcitedString &string)
 
G4KineticTrack * Splitup (G4FragmentingString *string, G4FragmentingString *&newString)
 
G4ParticleDefinition * QuarkSplitup (G4ParticleDefinition *decay, G4ParticleDefinition *&created)
 
G4ParticleDefinition * DiQuarkSplitup (G4ParticleDefinition *decay, G4ParticleDefinition *&created)
 
pDefPair CreatePartonPair (G4int NeedParticle, G4bool AllowDiquarks=true)
 
void CalculateHadronTimePosition (G4double theInitialStringMass, G4KineticTrackVector *)
 
void ConstructParticle ()
 
G4ParticleDefinition * CreateHadron (G4int id1, G4int id2, G4bool theGivenSpin, G4int theSpin)
 
G4double GetDiquarkSuppress ()
 
G4double GetDiquarkBreakProb ()
 
G4double GetStrangeSuppress ()
 
G4double GetClusterMass ()
 
G4int GetClusterLoopInterrupt ()
 
G4double GetStringTensionParameter ()
 
- Protected Attributes inherited from G4VLongitudinalStringDecay
G4double MassCut
 
G4double ClusterMass
 
G4double SigmaQT
 
G4double DiquarkSuppress
 
G4double DiquarkBreakProb
 
G4double SmoothParam
 
G4double StrangeSuppress
 
G4int StringLoopInterrupt
 
G4int ClusterLoopInterrupt
 
G4HadronBuilder * hadronizer
 
G4double pspin_meson
 
G4double pspin_barion
 
std::vector< G4double > vectorMesonMix
 
std::vector< G4double > scalarMesonMix
 
G4bool PastInitPhase
 
G4double Kappa
 

Detailed Description

Definition at line 42 of file G4LundStringFragmentation.hh.

Constructor & Destructor Documentation

G4LundStringFragmentation::G4LundStringFragmentation ( )

Definition at line 46 of file G4LundStringFragmentation.cc.

References python.hepunit::GeV, python.hepunit::MeV, G4VLongitudinalStringDecay::pspin_barion, G4VLongitudinalStringDecay::pspin_meson, G4VLongitudinalStringDecay::scalarMesonMix, G4VLongitudinalStringDecay::SetDiquarkBreakProbability(), G4VLongitudinalStringDecay::SetDiquarkSuppression(), G4VLongitudinalStringDecay::SetStrangenessSuppression(), G4VLongitudinalStringDecay::SetStringTensionParameter(), G4VLongitudinalStringDecay::SmoothParam, G4VLongitudinalStringDecay::StrangeSuppress, and G4VLongitudinalStringDecay::vectorMesonMix.

47 {
48 // ------ For estimation of a minimal string mass ---------------
49  Mass_of_light_quark =140.*MeV;
50  Mass_of_heavy_quark =500.*MeV;
51  Mass_of_string_junction=720.*MeV;
52 // ------ An estimated minimal string mass ----------------------
53  MinimalStringMass = 0.;
54  MinimalStringMass2 = 0.;
55 // ------ Minimal invariant mass used at a string fragmentation -
56  WminLUND = 0.45*GeV; //0.23*GeV; // Uzhi 0.7 -> 0.23 3.8.10 //0.8 1.5
57 // ------ Smooth parameter used at a string fragmentation for ---
58 // ------ smearinr sharp mass cut-off ---------------------------
59  SmoothParam = 0.2;
60 
61 // SetStringTensionParameter(0.25);
62  SetStringTensionParameter(1.);
63  SetDiquarkSuppression(0.087); // Uzhi 18.05.2012
64  SetDiquarkBreakProbability(0.05);
65  SetStrangenessSuppression(0.47); // Uzhi 18.05.2012
66 
67 // For treating of small string decays
68  for(G4int i=0; i<3; i++)
69  { for(G4int j=0; j<3; j++)
70  { for(G4int k=0; k<6; k++)
71  { Meson[i][j][k]=0; MesonWeight[i][j][k]=0.;
72  }
73  }
74  }
75 //--------------------------
76  Meson[0][0][0]=111; // dbar-d Pi0
77  MesonWeight[0][0][0]=(1.-pspin_meson)*(1.-scalarMesonMix[0]);
78 
79  Meson[0][0][1]=221; // dbar-d Eta
80  MesonWeight[0][0][1]=(1.-pspin_meson)*(scalarMesonMix[0]-scalarMesonMix[1]);
81 
82  Meson[0][0][2]=331; // dbar-d EtaPrime
83  MesonWeight[0][0][2]=(1.-pspin_meson)*(scalarMesonMix[1]);
84 
85  Meson[0][0][3]=113; // dbar-d Rho0
86  MesonWeight[0][0][3]=pspin_meson*(1.-vectorMesonMix[0]);
87 
88  Meson[0][0][4]=223; // dbar-d Omega
89  MesonWeight[0][0][4]=pspin_meson*(vectorMesonMix[0]);
90 //--------------------------
91 
92  Meson[0][1][0]=211; // dbar-u Pi+
93  MesonWeight[0][1][0]=(1.-pspin_meson);
94 
95  Meson[0][1][1]=213; // dbar-u Rho+
96  MesonWeight[0][1][1]=pspin_meson;
97 //--------------------------
98 
99  Meson[0][2][0]=311; // dbar-s K0bar
100  MesonWeight[0][2][0]=(1.-pspin_meson);
101 
102  Meson[0][2][1]=313; // dbar-s K*0bar
103  MesonWeight[0][2][1]=pspin_meson;
104 //--------------------------
105 //--------------------------
106  Meson[1][0][0]=211; // ubar-d Pi-
107  MesonWeight[1][0][0]=(1.-pspin_meson);
108 
109  Meson[1][0][1]=213; // ubar-d Rho-
110  MesonWeight[1][0][1]=pspin_meson;
111 //--------------------------
112 
113  Meson[1][1][0]=111; // ubar-u Pi0
114  MesonWeight[1][1][0]=(1.-pspin_meson)*(1.-scalarMesonMix[0]);
115 
116  Meson[1][1][1]=221; // ubar-u Eta
117  MesonWeight[1][1][1]=(1.-pspin_meson)*(scalarMesonMix[0]-scalarMesonMix[1]);
118 
119  Meson[1][1][2]=331; // ubar-u EtaPrime
120  MesonWeight[1][1][2]=(1.-pspin_meson)*(scalarMesonMix[1]);
121 
122  Meson[1][1][3]=113; // ubar-u Rho0
123  MesonWeight[1][1][3]=pspin_meson*(1.-vectorMesonMix[0]);
124 
125  Meson[1][1][4]=223; // ubar-u Omega
126  MesonWeight[1][1][4]=pspin_meson*(scalarMesonMix[0]);
127 //--------------------------
128 
129  Meson[1][2][0]=321; // ubar-s K-
130  MesonWeight[1][2][0]=(1.-pspin_meson);
131 
132  Meson[1][2][1]=323; // ubar-s K*-bar -
133  MesonWeight[1][2][1]=pspin_meson;
134 //--------------------------
135 //--------------------------
136 
137  Meson[2][0][0]=311; // sbar-d K0
138  MesonWeight[2][0][0]=(1.-pspin_meson);
139 
140  Meson[2][0][1]=313; // sbar-d K*0
141  MesonWeight[2][0][1]=pspin_meson;
142 //--------------------------
143 
144  Meson[2][1][0]=321; // sbar-u K+
145  MesonWeight[2][1][0]=(1.-pspin_meson);
146 
147  Meson[2][1][1]=323; // sbar-u K*+
148  MesonWeight[2][1][1]=pspin_meson;
149 //--------------------------
150 
151  Meson[2][2][0]=221; // sbar-s Eta
152  MesonWeight[2][2][0]=(1.-pspin_meson)*(1.-scalarMesonMix[5]);
153 
154  Meson[2][2][1]=331; // sbar-s EtaPrime
155  MesonWeight[2][2][1]=(1.-pspin_meson)*(1.-scalarMesonMix[5]);
156 
157  Meson[2][2][3]=333; // sbar-s EtaPrime
158  MesonWeight[2][2][3]=pspin_meson*(vectorMesonMix[5]);
159 //--------------------------
160 
161  for(G4int i=0; i<3; i++)
162  { for(G4int j=0; j<3; j++)
163  { for(G4int k=0; k<3; k++)
164  { for(G4int l=0; l<4; l++)
165  { Baryon[i][j][k][l]=0; BaryonWeight[i][j][k][l]=0.;}
166  }
167  }
168  }
169 
170  G4double pspin_barion_in=pspin_barion;
171  //pspin_barion=0.75;
172 //---------------------------------------
173  Baryon[0][0][0][0]=1114; // Delta-
174  BaryonWeight[0][0][0][0]=1.;
175 
176 //---------------------------------------
177  Baryon[0][0][1][0]=2112; // neutron
178  BaryonWeight[0][0][1][0]=1.-pspin_barion;
179 
180  Baryon[0][0][1][1]=2114; // Delta0
181  BaryonWeight[0][0][1][1]=pspin_barion;
182 
183 //---------------------------------------
184  Baryon[0][0][2][0]=3112; // Sigma-
185  BaryonWeight[0][0][2][0]=1.-pspin_barion;
186 
187  Baryon[0][0][2][1]=3114; // Sigma*-
188  BaryonWeight[0][0][2][1]=pspin_barion;
189 
190 //---------------------------------------
191  Baryon[0][1][0][0]=2112; // neutron
192  BaryonWeight[0][1][0][0]=1.-pspin_barion;
193 
194  Baryon[0][1][0][1]=2114; // Delta0
195  BaryonWeight[0][1][0][1]=pspin_barion;
196 
197 //---------------------------------------
198  Baryon[0][1][1][0]=2212; // proton
199  BaryonWeight[0][1][1][0]=1.-pspin_barion;
200 
201  Baryon[0][1][1][1]=2214; // Delta+
202  BaryonWeight[0][1][1][1]=pspin_barion;
203 
204 //---------------------------------------
205  Baryon[0][1][2][0]=3122; // Lambda
206  BaryonWeight[0][1][2][0]=(1.-pspin_barion)*0.5;
207 
208  Baryon[0][1][2][1]=3212; // Sigma0
209  BaryonWeight[0][1][2][1]=(1.-pspin_barion)*0.5;
210 
211  Baryon[0][1][2][2]=3214; // Sigma*0
212  BaryonWeight[0][1][2][2]=pspin_barion;
213 
214 //---------------------------------------
215  Baryon[0][2][0][0]=3112; // Sigma-
216  BaryonWeight[0][2][0][0]=1.-pspin_barion;
217 
218  Baryon[0][2][0][1]=3114; // Sigma*-
219  BaryonWeight[0][2][0][1]=pspin_barion;
220 
221 //---------------------------------------
222  Baryon[0][2][1][0]=3122; // Lambda
223  BaryonWeight[0][2][1][0]=(1.-pspin_barion)*0.5;
224 
225  Baryon[0][2][1][1]=3212; // Sigma0
226  BaryonWeight[0][2][1][1]=(1.-pspin_barion)*0.5;
227 
228  Baryon[0][2][1][2]=3214; // Sigma*0
229  BaryonWeight[0][2][1][2]=pspin_barion;
230 
231 //---------------------------------------
232  Baryon[0][2][2][0]=3312; // Theta-
233  BaryonWeight[0][2][2][0]=1.-pspin_barion;
234 
235  Baryon[0][2][2][1]=3314; // Theta*-
236  BaryonWeight[0][2][2][1]=pspin_barion;
237 
238 //---------------------------------------
239 //---------------------------------------
240  Baryon[1][0][0][0]=2112; // neutron
241  BaryonWeight[1][0][0][0]=1.-pspin_barion;
242 
243  Baryon[1][0][0][1]=2114; // Delta0
244  BaryonWeight[1][0][0][1]=pspin_barion;
245 
246 //---------------------------------------
247  Baryon[1][0][1][0]=2212; // proton
248  BaryonWeight[1][0][1][0]=1.-pspin_barion;
249 
250  Baryon[1][0][1][1]=2214; // Delta+
251  BaryonWeight[1][0][1][1]=pspin_barion;
252 
253 //---------------------------------------
254  Baryon[1][0][2][0]=3122; // Lambda
255  BaryonWeight[1][0][2][0]=(1.-pspin_barion)*0.5;
256 
257  Baryon[1][0][2][1]=3212; // Sigma0
258  BaryonWeight[1][0][2][1]=(1.-pspin_barion)*0.5;
259 
260  Baryon[1][0][2][2]=3214; // Sigma*0
261  BaryonWeight[1][0][2][2]=pspin_barion;
262 
263 //---------------------------------------
264  Baryon[1][1][0][0]=2212; // proton
265  BaryonWeight[1][1][0][0]=1.-pspin_barion;
266 
267  Baryon[1][1][0][1]=2214; // Delta+
268  BaryonWeight[1][1][0][1]=pspin_barion;
269 
270 //---------------------------------------
271  Baryon[1][1][1][0]=2224; // Delta++
272  BaryonWeight[1][1][1][0]=1.;
273 
274 //---------------------------------------
275  Baryon[1][1][2][0]=3222; // Sigma+
276  BaryonWeight[1][1][2][0]=1.-pspin_barion;
277 
278  Baryon[1][1][2][1]=3224; // Sigma*+
279  BaryonWeight[1][1][2][1]=pspin_barion;
280 
281 //---------------------------------------
282  Baryon[1][2][0][0]=3122; // Lambda
283  BaryonWeight[1][2][0][0]=(1.-pspin_barion)*0.5;
284 
285  Baryon[1][2][0][1]=3212; // Sigma0
286  BaryonWeight[1][2][0][1]=(1.-pspin_barion)*0.5;
287 
288  Baryon[1][2][0][2]=3214; // Sigma*0
289  BaryonWeight[1][2][0][2]=pspin_barion;
290 
291 //---------------------------------------
292  Baryon[1][2][1][0]=3222; // Sigma+
293  BaryonWeight[1][2][1][0]=1.-pspin_barion;
294 
295  Baryon[1][2][1][1]=3224; // Sigma*+
296  BaryonWeight[1][2][1][1]=pspin_barion;
297 
298 //---------------------------------------
299  Baryon[1][2][2][0]=3322; // Theta0
300  BaryonWeight[1][2][2][0]=1.-pspin_barion;
301 
302  Baryon[1][2][2][1]=3324; // Theta*0
303  BaryonWeight[1][2][2][1]=pspin_barion;
304 
305 //---------------------------------------
306 //---------------------------------------
307  Baryon[2][0][0][0]=3112; // Sigma-
308  BaryonWeight[2][0][0][0]=1.-pspin_barion;
309 
310  Baryon[2][0][0][1]=3114; // Sigma*-
311  BaryonWeight[2][0][0][1]=pspin_barion;
312 
313 //---------------------------------------
314  Baryon[2][0][1][0]=3122; // Lambda
315  BaryonWeight[2][0][1][0]=(1.-pspin_barion)*0.5;
316 
317  Baryon[2][0][1][1]=3212; // Sigma0
318  BaryonWeight[2][0][1][1]=(1.-pspin_barion)*0.5;
319 
320  Baryon[2][0][1][2]=3214; // Sigma*0
321  BaryonWeight[2][0][1][2]=pspin_barion;
322 
323 //---------------------------------------
324  Baryon[2][0][2][0]=3312; // Sigma-
325  BaryonWeight[2][0][2][0]=1.-pspin_barion;
326 
327  Baryon[2][0][2][1]=3314; // Sigma*-
328  BaryonWeight[2][0][2][1]=pspin_barion;
329 
330 //---------------------------------------
331  Baryon[2][1][0][0]=3122; // Lambda
332  BaryonWeight[2][1][0][0]=(1.-pspin_barion)*0.5;
333 
334  Baryon[2][1][0][1]=3212; // Sigma0
335  BaryonWeight[2][1][0][1]=(1.-pspin_barion)*0.5;
336 
337  Baryon[2][1][0][2]=3214; // Sigma*0
338  BaryonWeight[2][1][0][2]=pspin_barion;
339 
340 //---------------------------------------
341  Baryon[2][1][1][0]=3222; // Sigma+
342  BaryonWeight[2][1][1][0]=1.-pspin_barion;
343 
344  Baryon[2][1][1][1]=3224; // Sigma*+
345  BaryonWeight[2][1][1][1]=pspin_barion;
346 
347 //---------------------------------------
348  Baryon[2][1][2][0]=3322; // Theta0
349  BaryonWeight[2][1][2][0]=1.-pspin_barion;
350 
351  Baryon[2][1][2][1]=3324; // Theta*0
352  BaryonWeight[2][1][2][1]=pspin_barion;
353 
354 //---------------------------------------
355  Baryon[2][2][0][0]=3312; // Theta-
356  BaryonWeight[2][2][0][0]=1.-pspin_barion;
357 
358  Baryon[2][2][0][1]=3314; // Theta*-
359  BaryonWeight[2][2][0][1]=pspin_barion;
360 
361 //---------------------------------------
362  Baryon[2][2][1][0]=3322; // Theta0
363  BaryonWeight[2][2][1][0]=1.-pspin_barion;
364 
365  Baryon[2][2][1][1]=3324; // Theta*0
366  BaryonWeight[2][2][1][1]=pspin_barion;
367 
368 //---------------------------------------
369  Baryon[2][2][2][0]=3334; // Omega
370  BaryonWeight[2][2][2][0]=1.;
371 
372 //---------------------------------------
373  pspin_barion=pspin_barion_in;
374  /*
375  for(G4int i=0; i<3; i++)
376  { for(G4int j=0; j<3; j++)
377  { for(G4int k=0; k<3; k++)
378  { for(G4int l=0; l<4; l++)
379  { G4cout<<i<<" "<<j<<" "<<k<<" "<<l<<" "<<Baryon[i][j][k][l]<<G4endl;}
380  }
381  }
382  }
383  G4int Uzhi;
384  G4cin>>Uzhi;
385  */
386  //StrangeSuppress=0.38;
387  Prob_QQbar[0]=StrangeSuppress; // Probability of ddbar production
388  Prob_QQbar[1]=StrangeSuppress; // Probability of uubar production
389  Prob_QQbar[2]=StrangeSuppress/(2.+StrangeSuppress);//(1.-2.*StrangeSuppress); // Probability of ssbar production
390 
391  //A.R. 25-Jul-2012 : Coverity fix.
392  for ( G4int i=0 ; i<35 ; i++ ) {
393  FS_LeftHadron[i] = 0;
394  FS_RightHadron[i] = 0;
395  FS_Weight[i] = 0.0;
396  }
397  NumberOf_FS = 0;
398 
399 }
G4VLongitudinalStringDecay::SetStrangenessSuppression
void SetStrangenessSuppression(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:525
G4VLongitudinalStringDecay::vectorMesonMix
std::vector< G4double > vectorMesonMix
Definition: G4VLongitudinalStringDecay.hh:189
G4int
int G4int
Definition: G4Types.hh:78
G4VLongitudinalStringDecay::SetStringTensionParameter
void SetStringTensionParameter(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:628
G4VLongitudinalStringDecay::SetDiquarkBreakProbability
void SetDiquarkBreakProbability(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:547
G4VLongitudinalStringDecay::scalarMesonMix
std::vector< G4double > scalarMesonMix
Definition: G4VLongitudinalStringDecay.hh:190
G4double
double G4double
Definition: G4Types.hh:76
G4VLongitudinalStringDecay::SetDiquarkSuppression
void SetDiquarkSuppression(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:536
G4LundStringFragmentation::~G4LundStringFragmentation ( )
virtual

Definition at line 402 of file G4LundStringFragmentation.cc.

403 {}

Member Function Documentation

G4KineticTrackVector * G4LundStringFragmentation::FragmentString ( const G4ExcitedString &  theString)
virtual

Implements G4VLongitudinalStringDecay.

Definition at line 492 of file G4LundStringFragmentation.cc.

References C1, python.hepunit::c_light, G4VLongitudinalStringDecay::CalculateHadronTimePosition(), G4VLongitudinalStringDecay::CPExcited(), python.hepunit::fermi, G4ExcitedString::Get4Momentum(), G4KineticTrack::Get4Momentum(), G4KineticTrack::GetFormationTime(), G4ExcitedString::GetPosition(), G4KineticTrack::GetPosition(), G4ExcitedString::GetTimeOfCreation(), CLHEP::HepLorentzRotation::inverse(), G4VLongitudinalStringDecay::LightFragmentationTest(), CLHEP::HepLorentzVector::mag(), python.hepunit::MeV, G4VLongitudinalStringDecay::PastInitPhase, G4KineticTrack::Set4Momentum(), G4KineticTrack::SetFormationTime(), G4VLongitudinalStringDecay::SetMassCut(), G4KineticTrack::SetPosition(), and G4ExcitedString::TransformToAlignedCms().

494 {
495  // Can no longer modify Parameters for Fragmentation.
496  PastInitPhase=true;
497 
498  SetMassCut(160.*MeV); // For LightFragmentationTest it is required
499  // that no one pi-meson can be produced.
500 
501  G4FragmentingString aString(theString);
502  SetMinimalStringMass(&aString);
503 
504  G4KineticTrackVector * LeftVector(0);
505 
506  if(!IsFragmentable(&aString)) // produce 1 hadron
507  {
508  //G4cout<<"Non fragmentable"<<G4endl;
509  SetMassCut(1000.*MeV);
510  LeftVector=LightFragmentationTest(&theString);
511  SetMassCut(160.*MeV);
512  } // end of if(!IsFragmentable(&aString))
513 
514  if ( LeftVector != 0 ) {
515  // Uzhi insert 6.05.08 start
516  LeftVector->operator[](0)->SetFormationTime(theString.GetTimeOfCreation());
517  LeftVector->operator[](0)->SetPosition(theString.GetPosition());
518  if(LeftVector->size() > 1)
519  {
520  // 2 hadrons created from qq-qqbar are stored
521  LeftVector->operator[](1)->SetFormationTime(theString.GetTimeOfCreation());
522  LeftVector->operator[](1)->SetPosition(theString.GetPosition());
523  }
524  return LeftVector;
525  }
526 
527  // The string can fragment. At least two particles can be produced.
528  LeftVector =new G4KineticTrackVector;
529  G4KineticTrackVector * RightVector=new G4KineticTrackVector;
530 
531  G4ExcitedString *theStringInCMS=CPExcited(theString);
532  G4LorentzRotation toCms=theStringInCMS->TransformToAlignedCms();
533 
534  G4bool success = Loop_toFragmentString(theStringInCMS, LeftVector, RightVector);
535 
536  delete theStringInCMS;
537 
538  if ( ! success )
539  {
540  std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
541  LeftVector->clear();
542  std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
543  delete RightVector;
544  return LeftVector;
545  }
546 
547  // Join Left- and RightVector into LeftVector in correct order.
548  while(!RightVector->empty())
549  {
550  LeftVector->push_back(RightVector->back());
551  RightVector->erase(RightVector->end()-1);
552  }
553  delete RightVector;
554 
555  CalculateHadronTimePosition(theString.Get4Momentum().mag(), LeftVector);
556 
557  G4LorentzRotation toObserverFrame(toCms.inverse());
558 
559  G4double TimeOftheStringCreation=theString.GetTimeOfCreation();
560  G4ThreeVector PositionOftheStringCreation(theString.GetPosition());
561 
562  //G4cout<<"# prod hadrons "<<LeftVector->size()<<G4endl;
563  for(size_t C1 = 0; C1 < LeftVector->size(); C1++)
564  {
565  G4KineticTrack* Hadron = LeftVector->operator[](C1);
566  G4LorentzVector Momentum = Hadron->Get4Momentum();
567  //G4cout<<"Hadron "<<Hadron->GetDefinition()->GetParticleName()<<" "<<Momentum<<G4endl;
568  Momentum = toObserverFrame*Momentum;
569  Hadron->Set4Momentum(Momentum);
570 
571  G4LorentzVector Coordinate(Hadron->GetPosition(), Hadron->GetFormationTime());
572  Momentum = toObserverFrame*Coordinate;
573  Hadron->SetFormationTime(TimeOftheStringCreation + Momentum.e() - fermi/c_light);
574  G4ThreeVector aPosition(Momentum.vect());
575  Hadron->SetPosition(PositionOftheStringCreation+aPosition);
576  };
577 
578  return LeftVector;
579 }
G4KineticTrack::GetPosition
const G4ThreeVector & GetPosition() const
Definition: G4KineticTrack.hh:237
G4VLongitudinalStringDecay::CPExcited
G4ExcitedString * CPExcited(const G4ExcitedString &string)
Definition: G4VLongitudinalStringDecay.cc:314
G4KineticTrack::SetFormationTime
void SetFormationTime(G4double aFormationTime)
Definition: G4KineticTrack.hh:230
G4VLongitudinalStringDecay::SetMassCut
virtual void SetMassCut(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:145
G4ExcitedString::GetPosition
const G4ThreeVector & GetPosition() const
Definition: G4ExcitedString.hh:149
G4VLongitudinalStringDecay::LightFragmentationTest
G4KineticTrackVector * LightFragmentationTest(const G4ExcitedString *const theString)
Definition: G4VLongitudinalStringDecay.cc:151
G4ExcitedString::Get4Momentum
G4LorentzVector Get4Momentum() const
Definition: G4ExcitedString.hh:161
G4KineticTrack::GetFormationTime
G4double GetFormationTime() const
Definition: G4KineticTrack.hh:225
CLHEP::HepLorentzVector::mag
double mag() const
G4bool
bool G4bool
Definition: G4Types.hh:79
G4ExcitedString::TransformToAlignedCms
G4LorentzRotation TransformToAlignedCms()
Definition: G4ExcitedString.hh:215
G4KineticTrack::SetPosition
void SetPosition(const G4ThreeVector aPosition)
Definition: G4KineticTrack.hh:242
G4KineticTrack::Set4Momentum
void Set4Momentum(const G4LorentzVector &a4Momentum)
Definition: G4KineticTrack.hh:258
C1
#define C1
G4ExcitedString::GetTimeOfCreation
G4double GetTimeOfCreation() const
Definition: G4ExcitedString.hh:137
CLHEP::HepLorentzRotation::inverse
HepLorentzRotation inverse() const
G4double
double G4double
Definition: G4Types.hh:76
G4KineticTrack::Get4Momentum
const G4LorentzVector & Get4Momentum() const
Definition: G4KineticTrack.hh:248
G4VLongitudinalStringDecay::CalculateHadronTimePosition
void CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector *)
Definition: G4VLongitudinalStringDecay.cc:485
python.hepunit.c_light
float c_light
Definition: hepunit.py:257
The documentation for this class was generated from the following files:
Generated on Wed Apr 30 2014 15:56:40 for Geant4.10 by   doxygen 1.8.7