| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
27 27
28 28
29 // ------------------------------------------- 29 // ------------------------------------------------------------
30 // GEANT 4 class implementation file 30 // GEANT 4 class implementation file
31 // 31 //
32 // ---------------- G4FragmentingString - 32 // ---------------- G4FragmentingString ----------------
33 // by Gunter Folger, September 200 33 // by Gunter Folger, September 2001.
34 // class for an excited string used in F 34 // class for an excited string used in Fragmention
35 // ------------------------------------------- 35 // ------------------------------------------------------------
36 36
37 37
38 // G4FragmentingString 38 // G4FragmentingString
39 #include "G4FragmentingString.hh" 39 #include "G4FragmentingString.hh"
40 #include "G4ExcitedString.hh" 40 #include "G4ExcitedString.hh"
41 41
42 //-------------------------------------------- 42 //---------------------------------------------------------------------------------
43 43
44 //-------------------------------------------- 44 //---------------------------------------------------------------------------------
45 45
46 G4FragmentingString::G4FragmentingString(const 46 G4FragmentingString::G4FragmentingString(const G4FragmentingString &old)
47 { 47 {
48 LeftParton=old.LeftParton; 48 LeftParton=old.LeftParton;
49 RightParton=old.RightParton; 49 RightParton=old.RightParton;
50 Ptleft=old.Ptleft; 50 Ptleft=old.Ptleft;
51 Ptright=old.Ptright; 51 Ptright=old.Ptright;
52 Pplus=old.Pplus; 52 Pplus=old.Pplus;
53 Pminus=old.Pminus; 53 Pminus=old.Pminus;
54 theStableParton=old.theStableParton; 54 theStableParton=old.theStableParton;
55 theDecayParton=old.theDecayParton; 55 theDecayParton=old.theDecayParton;
56 decaying=old.decaying; 56 decaying=old.decaying;
57 Pstring=old.Pstring; 57 Pstring=old.Pstring;
58 Pleft =old.Pleft; 58 Pleft =old.Pleft;
59 Pright =old.Pright; 59 Pright =old.Pright;
60 } 60 }
61 61
62 G4FragmentingString & G4FragmentingString::ope 62 G4FragmentingString & G4FragmentingString::operator =(const G4FragmentingString &old)
63 { 63 {
64 if (this != &old) 64 if (this != &old)
65 { 65 {
66 LeftParton=old.LeftParton; 66 LeftParton=old.LeftParton;
67 RightParton=old.RightParton; 67 RightParton=old.RightParton;
68 Ptleft=old.Ptleft; 68 Ptleft=old.Ptleft;
69 Ptright=old.Ptright; 69 Ptright=old.Ptright;
70 Pplus=old.Pplus; 70 Pplus=old.Pplus;
71 Pminus=old.Pminus; 71 Pminus=old.Pminus;
72 theStableParton=old.theStableParton; 72 theStableParton=old.theStableParton;
73 theDecayParton=old.theDecayParton; 73 theDecayParton=old.theDecayParton;
74 decaying=old.decaying; 74 decaying=old.decaying;
75 Pstring=old.Pstring; 75 Pstring=old.Pstring;
76 Pleft =old.Pleft; 76 Pleft =old.Pleft;
77 Pright =old.Pright; 77 Pright =old.Pright;
78 } 78 }
79 return *this; 79 return *this;
80 } 80 }
81 81
82 //-------------------------------------------- 82 //---------------------------------------------------------------------------------
83 83
84 G4FragmentingString::G4FragmentingString(const 84 G4FragmentingString::G4FragmentingString(const G4ExcitedString &excited)
85 { 85 {
86 LeftParton=excited.GetLeftParton()->GetDefin 86 LeftParton=excited.GetLeftParton()->GetDefinition();
87 RightParton=excited.GetRightParton()->GetDef 87 RightParton=excited.GetRightParton()->GetDefinition();
88 Ptleft=excited.GetLeftParton()->Get4Momentum 88 Ptleft=excited.GetLeftParton()->Get4Momentum().vect();
89 Ptleft.setZ(0.); 89 Ptleft.setZ(0.);
90 Ptright=excited.GetRightParton()->Get4Moment 90 Ptright=excited.GetRightParton()->Get4Momentum().vect();
91 Ptright.setZ(0.); 91 Ptright.setZ(0.);
92 theStableParton=0; 92 theStableParton=0;
93 theDecayParton=0; 93 theDecayParton=0;
94 94
95 if (excited.GetDirection() > 0) {decay 95 if (excited.GetDirection() > 0) {decaying=Left; }
96 else {decay 96 else {decaying=Right;}
97 97
98 Pleft = excited.GetLeftParton()->Get4 98 Pleft = excited.GetLeftParton()->Get4Momentum();
99 Pright = excited.GetRightParton()->Get 99 Pright = excited.GetRightParton()->Get4Momentum();
100 Pstring= Pleft + Pright; 100 Pstring= Pleft + Pright;
101 101
102 Pplus = Pstring.plus(); 102 Pplus = Pstring.plus();
103 Pminus = Pstring.minus(); 103 Pminus = Pstring.minus();
104 } 104 }
105 105
106 //-------------------------------------------- 106 //---------------------------------------------------------------------------------
107 107
108 G4FragmentingString::G4FragmentingString(const 108 G4FragmentingString::G4FragmentingString(const G4FragmentingString &old,
109 G4ParticleDefinition * newdecay, 109 G4ParticleDefinition * newdecay,
110 const G4LorentzVector *momentum) 110 const G4LorentzVector *momentum)
111 { 111 {
112 decaying=None; 112 decaying=None;
113 // Momentum of produced hadron 113 // Momentum of produced hadron
114 G4LorentzVector Momentum = G4LorentzVe 114 G4LorentzVector Momentum = G4LorentzVector(momentum->vect(),momentum->e());
115 115
116 if ( old.decaying == Left ) 116 if ( old.decaying == Left )
117 { 117 {
118 RightParton= old.RightParton; 118 RightParton= old.RightParton;
119 Ptright = old.Ptright; 119 Ptright = old.Ptright;
120 Pright = old.Pright; 120 Pright = old.Pright;
121 121
122 LeftParton = newdecay; 122 LeftParton = newdecay;
123 Ptleft = old.Ptleft - mome 123 Ptleft = old.Ptleft - momentum->vect();
124 Ptleft.setZ(0.); 124 Ptleft.setZ(0.);
125 Pleft = old.Pleft - Momentum; 125 Pleft = old.Pleft - Momentum;
126 126
127 Pstring = Pleft + Pright; 127 Pstring = Pleft + Pright;
128 Pplus = Pstring.plus(); 128 Pplus = Pstring.plus();
129 Pminus = Pstring.minus(); 129 Pminus = Pstring.minus();
130 130
131 theDecayParton=GetLeftParton() 131 theDecayParton=GetLeftParton();
132 theStableParton=GetRightParton 132 theStableParton=GetRightParton();
133 decaying = Left; 133 decaying = Left;
134 } else if ( old.decaying == Right ) 134 } else if ( old.decaying == Right )
135 { 135 {
136 RightParton = newdecay; 136 RightParton = newdecay;
137 Ptright = old.Ptright - mo 137 Ptright = old.Ptright - momentum->vect();
138 Ptright.setZ(0.); 138 Ptright.setZ(0.);
139 Pright = old.Pright - Momentum 139 Pright = old.Pright - Momentum;
140 140
141 LeftParton = old.LeftParton; 141 LeftParton = old.LeftParton;
142 Ptleft = old.Ptleft; 142 Ptleft = old.Ptleft;
143 Pleft = old.Pleft; 143 Pleft = old.Pleft;
144 144
145 Pstring = Pleft + Pright; 145 Pstring = Pleft + Pright;
146 Pplus = Pstring.plus(); 146 Pplus = Pstring.plus();
147 Pminus = Pstring.minus(); 147 Pminus = Pstring.minus();
148 148
149 theDecayParton=GetRightParton( 149 theDecayParton=GetRightParton();
150 theStableParton=GetLeftParton( 150 theStableParton=GetLeftParton();
151 decaying = Right; 151 decaying = Right;
152 } else 152 } else
153 { 153 {
154 throw G4HadronicException(__FILE__, __LINE 154 throw G4HadronicException(__FILE__, __LINE__,
155 "G4FragmentingString::G4Frag 155 "G4FragmentingString::G4FragmentingString: no decay Direction defined");
156 } 156 }
157 } 157 }
158 158
159 159
160 //-------------------------------------------- 160 //---------------------------------------------------------------------------------
161 161
162 G4FragmentingString::G4FragmentingString(const 162 G4FragmentingString::G4FragmentingString(const G4FragmentingString &old,
163 G4ParticleDefinition * newdecay) 163 G4ParticleDefinition * newdecay)
164 { 164 {
165 decaying=None; 165 decaying=None;
166 166
167 Ptleft.setX(0.); Ptleft.setY(0.); Pt 167 Ptleft.setX(0.); Ptleft.setY(0.); Ptleft.setZ(0.);
168 Ptright.setX(0.); Ptright.setY(0.); Pt 168 Ptright.setX(0.); Ptright.setY(0.); Ptright.setZ(0.);
169 Pplus=0.; Pminus=0.; 169 Pplus=0.; Pminus=0.;
170 theStableParton=0; theDecayParton=0; 170 theStableParton=0; theDecayParton=0;
171 171
172 Pstring=G4LorentzVector(0.,0.,0.,0.); 172 Pstring=G4LorentzVector(0.,0.,0.,0.);
173 Pleft =G4LorentzVector(0.,0.,0.,0.); 173 Pleft =G4LorentzVector(0.,0.,0.,0.);
174 Pright =G4LorentzVector(0.,0.,0.,0.); 174 Pright =G4LorentzVector(0.,0.,0.,0.);
175 175
176 if ( old.decaying == Left ) 176 if ( old.decaying == Left )
177 { 177 {
178 RightParton= old.RightParton; 178 RightParton= old.RightParton;
179 LeftParton = newdecay; 179 LeftParton = newdecay;
180 decaying=Left; 180 decaying=Left;
181 } else if ( old.decaying == Right ) 181 } else if ( old.decaying == Right )
182 { 182 {
183 RightParton = newdecay; 183 RightParton = newdecay;
184 LeftParton = old.LeftParton; 184 LeftParton = old.LeftParton;
185 decaying=Right; 185 decaying=Right;
186 } else 186 } else
187 { 187 {
188 throw G4HadronicException(__FILE__, __LINE 188 throw G4HadronicException(__FILE__, __LINE__,
189 "G4FragmentingString::G4Frag 189 "G4FragmentingString::G4FragmentingString: no decay Direction defined");
190 } 190 }
191 } 191 }
192 192
193 193
194 //-------------------------------------------- 194 //---------------------------------------------------------------------------------
195 195
196 G4FragmentingString::~G4FragmentingString() 196 G4FragmentingString::~G4FragmentingString()
197 {} 197 {}
198 198
199 //-------------------------------------------- 199 //---------------------------------------------------------------------------------
200 200
201 void G4FragmentingString::SetLeftPartonStable( 201 void G4FragmentingString::SetLeftPartonStable()
202 { 202 {
203 theStableParton=GetLeftParton(); 203 theStableParton=GetLeftParton();
204 theDecayParton=GetRightParton(); 204 theDecayParton=GetRightParton();
205 decaying=Right; 205 decaying=Right;
206 } 206 }
207 207
208 //-------------------------------------------- 208 //---------------------------------------------------------------------------------
209 209
210 void G4FragmentingString::SetRightPartonStable 210 void G4FragmentingString::SetRightPartonStable()
211 { 211 {
212 theStableParton=GetRightParton(); 212 theStableParton=GetRightParton();
213 theDecayParton=GetLeftParton(); 213 theDecayParton=GetLeftParton();
214 decaying=Left; 214 decaying=Left;
215 } 215 }
216 216
217 //-------------------------------------------- 217 //---------------------------------------------------------------------------------
218 218
219 G4int G4FragmentingString::GetDecayDirection() 219 G4int G4FragmentingString::GetDecayDirection() const
220 { 220 {
221 if (decaying == Left ) return +1; 221 if (decaying == Left ) return +1;
222 else if (decaying == Right) return -1; 222 else if (decaying == Right) return -1;
223 else throw G4HadronicException(__FILE__, __L 223 else throw G4HadronicException(__FILE__, __LINE__,
224 "G4FragmentingString::GetDecayD 224 "G4FragmentingString::GetDecayDirection: decay side UNdefined!");
225 return 0; 225 return 0;
226 } 226 }
227 227
228 //-------------------------------------------- 228 //---------------------------------------------------------------------------------
229 229
230 G4bool G4FragmentingString::IsAFourQuarkString 230 G4bool G4FragmentingString::IsAFourQuarkString() const
231 { 231 {
232 return LeftParton->GetParticleSubType()== 232 return LeftParton->GetParticleSubType()== "di_quark"
233 && RightParton->GetParticleSubType()== 233 && RightParton->GetParticleSubType()== "di_quark";
234 } 234 }
235 235
236 //-------------------------------------------- 236 //---------------------------------------------------------------------------------
237 237
238 G4bool G4FragmentingString::DecayIsQuark() 238 G4bool G4FragmentingString::DecayIsQuark()
239 { 239 {
240 return theDecayParton->GetParticleSubType()= 240 return theDecayParton->GetParticleSubType()== "quark";
241 } 241 }
242 242
243 G4bool G4FragmentingString::StableIsQuark() 243 G4bool G4FragmentingString::StableIsQuark()
244 { 244 {
245 return theStableParton->GetParticleSubType() 245 return theStableParton->GetParticleSubType()== "quark";
246 } 246 }
247 247
248 //-------------------------------------------- 248 //---------------------------------------------------------------------------------
249 249
250 G4ThreeVector G4FragmentingString::StablePt() 250 G4ThreeVector G4FragmentingString::StablePt()
251 { 251 {
252 if (decaying == Left ) return Ptright; 252 if (decaying == Left ) return Ptright;
253 else if (decaying == Right ) return Ptleft; 253 else if (decaying == Right ) return Ptleft;
254 else throw G4HadronicException(__FILE__, __L 254 else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!");
255 return G4ThreeVector(); 255 return G4ThreeVector();
256 } 256 }
257 257
258 G4ThreeVector G4FragmentingString::DecayPt() 258 G4ThreeVector G4FragmentingString::DecayPt()
259 { 259 {
260 if (decaying == Left ) return Ptleft; 260 if (decaying == Left ) return Ptleft;
261 else if (decaying == Right ) return Ptright; 261 else if (decaying == Right ) return Ptright;
262 else throw G4HadronicException(__FILE__, __L 262 else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!");
263 return G4ThreeVector(); 263 return G4ThreeVector();
264 } 264 }
265 265
266 //-------------------------------------------- 266 //---------------------------------------------------------------------------------
267 267
268 G4double G4FragmentingString::LightConePlus() 268 G4double G4FragmentingString::LightConePlus()
269 { 269 {
270 return Pplus; 270 return Pplus;
271 } 271 }
272 272
273 G4double G4FragmentingString::LightConeMinus() 273 G4double G4FragmentingString::LightConeMinus()
274 { 274 {
275 return Pminus; 275 return Pminus;
276 } 276 }
277 277
278 G4double G4FragmentingString::LightConeDecay() 278 G4double G4FragmentingString::LightConeDecay()
279 { 279 {
280 if (decaying == Left ) return Pplus; 280 if (decaying == Left ) return Pplus;
281 else if (decaying == Right ) return Pminus; 281 else if (decaying == Right ) return Pminus;
282 else throw G4HadronicException(__FILE__, __L 282 else throw G4HadronicException(__FILE__, __LINE__, "G4FragmentingString::DecayPt: decay side UNdefined!");
283 } 283 }
284 284
285 //-------------------------------------------- 285 //---------------------------------------------------------------------------------
286 286
287 G4LorentzVector G4FragmentingString::Get4Momen 287 G4LorentzVector G4FragmentingString::Get4Momentum() const
288 { 288 {
289 return Pstring; 289 return Pstring;
290 } 290 }
291 291
292 G4double G4FragmentingString::Mass2() const 292 G4double G4FragmentingString::Mass2() const
293 { 293 {
294 return Pstring.mag2(); 294 return Pstring.mag2();
295 } 295 }
296 296
297 G4double G4FragmentingString::Mass() const 297 G4double G4FragmentingString::Mass() const
298 { 298 {
299 return Pstring.mag(); 299 return Pstring.mag();
300 } 300 }
301 301
302 G4double G4FragmentingString::MassT2() const 302 G4double G4FragmentingString::MassT2() const
303 { 303 {
304 return Pplus*Pminus; 304 return Pplus*Pminus;
305 } 305 }
306 306
307 G4LorentzVector G4FragmentingString::GetPstrin 307 G4LorentzVector G4FragmentingString::GetPstring()
308 { 308 {
309 return Pstring; 309 return Pstring;
310 } 310 }
311 311
312 G4LorentzVector G4FragmentingString::GetPleft( 312 G4LorentzVector G4FragmentingString::GetPleft()
313 { 313 {
314 return Pleft; 314 return Pleft;
315 } 315 }
316 316
317 G4LorentzVector G4FragmentingString::GetPright 317 G4LorentzVector G4FragmentingString::GetPright()
318 { 318 {
319 return Pright; 319 return Pright;
320 } 320 }
321 321
322 G4LorentzRotation G4FragmentingString::Transfo 322 G4LorentzRotation G4FragmentingString::TransformToAlignedCms()
323 { 323 {
324 G4LorentzVector momentum = Pstring; 324 G4LorentzVector momentum = Pstring;
325 G4LorentzRotation toAlignedCms(-1*momentu 325 G4LorentzRotation toAlignedCms(-1*momentum.boostVector());
326 momentum = toAlignedCms * Pleft; 326 momentum = toAlignedCms * Pleft;
327 327
328 toAlignedCms.rotateZ(-1*momentum.phi()); 328 toAlignedCms.rotateZ(-1*momentum.phi());
329 toAlignedCms.rotateY(-1*momentum.theta()) 329 toAlignedCms.rotateY(-1*momentum.theta());
330 330
331 Pleft *= toAlignedCms; 331 Pleft *= toAlignedCms;
332 Pright *= toAlignedCms; 332 Pright *= toAlignedCms;
333 Pstring *= toAlignedCms; 333 Pstring *= toAlignedCms;
334 334
335 Ptleft = G4ThreeVector(Pleft.vect()); 335 Ptleft = G4ThreeVector(Pleft.vect());
336 Ptleft.setZ(0.); 336 Ptleft.setZ(0.);
337 Ptright = G4ThreeVector(Pright.vect()); 337 Ptright = G4ThreeVector(Pright.vect());
338 Pplus = Pstring.plus(); 338 Pplus = Pstring.plus();
339 Pminus = Pstring.minus(); 339 Pminus = Pstring.minus();
340 340
341 return toAlignedCms; 341 return toAlignedCms;
342 } 342 }
343 343