Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4LundStringFragmentation Class Reference

#include <G4LundStringFragmentation.hh>

+ Inheritance diagram for G4LundStringFragmentation:

Public Member Functions

 G4LundStringFragmentation ()
 
virtual ~G4LundStringFragmentation ()
 
virtual G4KineticTrackVector * FragmentString (const G4ExcitedString &theString)
 
- Public Member Functions inherited from G4VLongitudinalStringDecay
 G4VLongitudinalStringDecay ()
 
virtual ~G4VLongitudinalStringDecay ()
 
virtual G4KineticTrackVector * FragmentString (const G4ExcitedString &theString)=0
 
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)
 
virtual void Sample4Momentum (G4LorentzVector *Mom, G4double Mass, G4LorentzVector *AntiMom, G4double AntiMass, G4double InitialMass)=0
 
virtual G4bool StopFragmenting (const G4FragmentingString *const string)=0
 
virtual G4bool IsFragmentable (const G4FragmentingString *const string)=0
 
virtual G4bool SplitLast (G4FragmentingString *string, G4KineticTrackVector *LeftVector, G4KineticTrackVector *RightVector)=0
 
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)
 
virtual G4LorentzVector * SplitEandP (G4ParticleDefinition *pHadron, G4FragmentingString *string, G4FragmentingString *newString)=0
 
virtual G4double GetLightConeZ (G4double zmin, G4double zmax, G4int PartonEncoding, G4ParticleDefinition *pHadron, G4double Px, G4double Py)=0
 
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::G4LundStringFragmentation ( )

Definition at line 46 of file G4LundStringFragmentation.cc.

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][2]=(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][2]=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}
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4VLongitudinalStringDecay::scalarMesonMix
std::vector< G4double > scalarMesonMix
Definition: G4VLongitudinalStringDecay.hh:190
G4VLongitudinalStringDecay::vectorMesonMix
std::vector< G4double > vectorMesonMix
Definition: G4VLongitudinalStringDecay.hh:189
G4VLongitudinalStringDecay::SetDiquarkSuppression
void SetDiquarkSuppression(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:537
G4VLongitudinalStringDecay::SetStrangenessSuppression
void SetStrangenessSuppression(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:526
G4VLongitudinalStringDecay::SetDiquarkBreakProbability
void SetDiquarkBreakProbability(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:548
G4VLongitudinalStringDecay::SetStringTensionParameter
void SetStringTensionParameter(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:629

◆ ~G4LundStringFragmentation()

G4LundStringFragmentation::~G4LundStringFragmentation ( )
virtual

Definition at line 402 of file G4LundStringFragmentation.cc.

403{}

Member Function Documentation

◆ FragmentString()

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

Implements G4VLongitudinalStringDecay.

Definition at line 492 of file G4LundStringFragmentation.cc.

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}
G4bool
bool G4bool
Definition: G4Types.hh:67
C1
#define C1
CLHEP::HepLorentzRotation::inverse
HepLorentzRotation inverse() const
G4ExcitedString::GetTimeOfCreation
G4double GetTimeOfCreation() const
Definition: G4ExcitedString.hh:137
G4ExcitedString::GetPosition
const G4ThreeVector & GetPosition() const
Definition: G4ExcitedString.hh:149
G4ExcitedString::TransformToAlignedCms
G4LorentzRotation TransformToAlignedCms()
Definition: G4ExcitedString.hh:215
G4ExcitedString::Get4Momentum
G4LorentzVector Get4Momentum() const
Definition: G4ExcitedString.hh:161
G4KineticTrack::GetFormationTime
G4double GetFormationTime() const
Definition: G4KineticTrack.hh:225
G4KineticTrack::SetPosition
void SetPosition(const G4ThreeVector aPosition)
Definition: G4KineticTrack.hh:242
G4KineticTrack::Set4Momentum
void Set4Momentum(const G4LorentzVector &a4Momentum)
Definition: G4KineticTrack.hh:258
G4KineticTrack::GetPosition
const G4ThreeVector & GetPosition() const
Definition: G4KineticTrack.hh:237
G4KineticTrack::SetFormationTime
void SetFormationTime(G4double aFormationTime)
Definition: G4KineticTrack.hh:230
G4KineticTrack::Get4Momentum
const G4LorentzVector & Get4Momentum() const
Definition: G4KineticTrack.hh:248
G4VLongitudinalStringDecay::SetMassCut
virtual void SetMassCut(G4double aValue)
Definition: G4VLongitudinalStringDecay.cc:146
G4VLongitudinalStringDecay::CalculateHadronTimePosition
void CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector *)
Definition: G4VLongitudinalStringDecay.cc:486
G4VLongitudinalStringDecay::CPExcited
G4ExcitedString * CPExcited(const G4ExcitedString &string)
Definition: G4VLongitudinalStringDecay.cc:315
G4VLongitudinalStringDecay::LightFragmentationTest
G4KineticTrackVector * LightFragmentationTest(const G4ExcitedString *const theString)
Definition: G4VLongitudinalStringDecay.cc:152
The documentation for this class was generated from the following files: