]>
Commit | Line | Data |
---|---|---|
cb220f83 | 1 | //////////////////////////////////////////////////////////////////////////////// |
2 | // // | |
3 | // THydjet // | |
4 | // // | |
5 | // THydjet is an interface class to fortran version of Hydjet event generator // | |
6 | // // | |
7 | // ------------------------------------------------------------- // | |
8 | // HYDJET, fast MC code to simulate flow effects, jet production // | |
9 | // and jet quenching in heavy ion AA collisions at the LHC // | |
10 | // ------------------------------------------------------------- // | |
11 | // This code is merging HYDRO (flow effects), PYTHIA6.4 (hard jet // | |
12 | // production) and PYQUEN (jet quenching) // | |
13 | // -------------------------------------------------------------- // | |
14 | // // | |
15 | // Igor Lokhtin, SINP MSU, Moscow, RU // | |
16 | // e-mail: Igor.Lokhtin@cern.ch // | |
17 | // // | |
18 | // Reference for HYDJET: // | |
19 | // I.P. Lokhtin, A.M. Snigirev, // | |
20 | // Eur. Phys. J. C 46 (2006) 211. // | |
21 | // // | |
22 | // References for HYDRO: // | |
23 | // N.A.Kruglov, I.P.Lokhtin, L.I.Sarycheva, A.M.Snigirev, // | |
24 | // Z. Phys. C 76 (1997) 99; // | |
25 | // I.P.Lokhtin, L.I.Sarycheva, A.M.Snigirev, // | |
26 | // Phys. Lett. B 537 (2002) 261; // | |
27 | // I.P.Lokhtin, A.M.Snigirev, Preprint SINP MSU 2004-14/753,hep-ph/0312204.// | |
28 | // // | |
29 | // References for PYQUEN: // | |
30 | // I.P.Lokhtin, A.M.Snigirev, Eur.Phys.J. C16 (2000) 527; // | |
31 | // I.P.Lokhtin, A.M.Snigirev, Preprint SINP MSU 2004-13/752, hep-ph/0406038.// | |
32 | // // | |
33 | // References for PYTHIA: // | |
34 | // T.Sjostrand et al., Comput.Phys.Commun. 135 (2001) 238; // | |
35 | // T.Sjostrand, S. Mrena and P. Skands, hep-ph/0603175. // | |
36 | // // | |
37 | // Reference for JETSET event format: // | |
38 | // T.Sjostrand, Comput.Phys.Commun. 82 (1994) 74. // | |
39 | // // | |
40 | // -------------------------------------------------------------- // | |
41 | // Web-page: // | |
42 | // http://cern.ch/lokhtin/hydro // | |
43 | // -------------------------------------------------------------- // | |
44 | // // | |
45 | //**************************************************************************** // | |
46 | ||
47 | #include "THydjet.h" | |
48 | #include "TObjArray.h" | |
49 | #include "HydCommon.h" | |
50 | #include "TParticle.h" | |
51 | #include "TROOT.h" | |
52 | ||
53 | #ifndef WIN32 | |
54 | # define pyinit pyinit_ | |
55 | # define hydro hydro_ | |
56 | # define type_of_call | |
57 | #else | |
58 | # define pyinit PYINIT | |
59 | # define hydro HYDRO | |
60 | # define type_of_call _stdcall | |
61 | #endif | |
62 | ||
63 | extern "C" void type_of_call hydro(float* A, int* ifb, float* bmin, | |
64 | float* bmax, float* bfix, int* nh); | |
65 | //extern "C" void type_of_call luedit(Int_t& medit); | |
66 | #ifndef WIN32 | |
67 | extern "C" void type_of_call pyinit( const char *frame, const char *beam, const char *target, | |
68 | double *win, Long_t l_frame, Long_t l_beam, | |
69 | Long_t l_target); | |
70 | #else | |
71 | extern "C" void type_of_call pyinit( const char *frame, Long_t l_frame, | |
72 | const char *beam, Long_t l_beam, | |
73 | const char *target, Long_t l_target, | |
74 | double *win | |
75 | ); | |
76 | #endif | |
77 | ||
78 | #include <TClonesArray.h> | |
79 | ||
80 | ClassImp(THydjet) | |
81 | ||
82 | THydjet::THydjet() : | |
83 | TGenerator("Hydjet","Hydjet"), | |
84 | fEfrm(5500), | |
85 | fFrame("CMS"), | |
86 | fAw(207), | |
87 | fIfb(0), | |
88 | fBmin(0.), | |
89 | fBmax(1.), | |
90 | fBfix(0.), | |
91 | fNh(20000) | |
92 | { | |
93 | // Default constructor | |
94 | } | |
95 | ||
96 | //______________________________________________________________________________ | |
97 | THydjet::THydjet(Float_t efrm, const char *frame="CMS", | |
98 | Float_t aw=207., Int_t ifb=0, Float_t bmin=0, Float_t bmax=1, Float_t bfix=0, | |
99 | Int_t nh=20000) : | |
100 | TGenerator("Hydjet","Hydjet"), | |
101 | fEfrm(efrm), | |
102 | fFrame(frame), | |
103 | fAw(aw), | |
104 | fIfb(ifb), | |
105 | fBmin(bmin), | |
106 | fBmax(bmax), | |
107 | fBfix(bfix), | |
108 | fNh(nh) | |
109 | { | |
110 | // THydjet constructor: | |
111 | } | |
112 | ||
113 | //______________________________________________________________________________ | |
114 | THydjet::~THydjet() | |
115 | { | |
116 | // Destructor | |
117 | } | |
118 | ||
119 | ||
120 | TObjArray* THydjet::ImportParticles(Option_t *option) | |
121 | { | |
122 | // | |
123 | // Default primary creation method. It reads the /LUJETS common block which | |
124 | // has been filled by the GenerateEvent method. | |
125 | // The function loops on the generated particles and store them in | |
126 | // the TClonesArray pointed by the argument particles. | |
127 | // The default action is to store only the stable particles (LUJETS.k[0][i] == 1) | |
128 | // This can be demanded explicitly by setting the option = "Final" | |
129 | // If the option = "All", all the particles are stored. | |
130 | // | |
131 | fParticles->Clear(); | |
132 | Int_t numpart = LUJETS.n; | |
133 | printf("\n THydjet: Hydjet stack contains %d particles.", numpart); | |
134 | Int_t nump = 0; | |
135 | if(!strcmp(option,"") || !strcmp(option,"Final")) { | |
136 | for(Int_t i = 0; i < numpart; i++) { | |
137 | if(LUJETS.k[0][i] == 1) { | |
138 | //Use the common block values for the TParticle constructor | |
139 | nump++; | |
140 | TParticle* p = new TParticle( | |
141 | LUJETS.k[1][i], LUJETS.k[0][i] , | |
142 | LUJETS.k[2][i], -1, LUJETS.k[3][i], LUJETS.k[4][i], | |
143 | LUJETS.p[0][i], LUJETS.p[1][i], LUJETS.p[2][i], LUJETS.p[3][i] , | |
144 | LUJETS.v[0][i], LUJETS.v[1][i], LUJETS.v[2][i], LUJETS.v[3][i] | |
145 | ); | |
146 | fParticles->Add(p); | |
147 | } | |
148 | } | |
149 | } | |
150 | else if(!strcmp(option,"All")) { | |
151 | nump = numpart; | |
152 | for(Int_t i = 0; i < numpart; i++){ | |
153 | TParticle* p = new TParticle( | |
154 | LUJETS.k[1][i], LUJETS.k[0][i] , | |
155 | LUJETS.k[2][i], -1, LUJETS.k[3][i], LUJETS.k[4][i], | |
156 | LUJETS.p[0][i], LUJETS.p[1][i], LUJETS.p[2][i], LUJETS.p[3][i] , | |
157 | LUJETS.v[0][i], LUJETS.v[1][i], LUJETS.v[2][i], LUJETS.v[3][i] | |
158 | ); | |
159 | fParticles->Add(p); | |
160 | } | |
161 | } | |
162 | return fParticles; | |
163 | } | |
164 | ||
165 | Int_t THydjet::ImportParticles(TClonesArray *particles, Option_t *option) | |
166 | { | |
167 | // | |
168 | // Default primary creation method. It reads the /LUJETS common block which | |
169 | // has been filled by the GenerateEvent method. | |
170 | // The function loops on the generated particles and store them in | |
171 | // the TClonesArray pointed by the argument particles. | |
172 | // The default action is to store only the stable particles (LUJETS.k[0][i] == 1) | |
173 | // This can be demanded explicitly by setting the option = "Final" | |
174 | // If the option = "All", all the particles are stored. | |
175 | // | |
176 | if (particles == 0) return 0; | |
177 | TClonesArray &particlesR = *particles; | |
178 | particlesR.Clear(); | |
179 | Int_t numpart = LUJETS.n; | |
180 | printf("\n THydjet: Hydjet stack contains %d particles.", numpart); | |
181 | Int_t nump = 0; | |
182 | if(!strcmp(option,"") || !strcmp(option,"Final")) { | |
183 | for(Int_t i = 0; i < numpart; i++) { | |
184 | if(LUJETS.k[0][i] == 1) { | |
185 | //Use the common block values for the TParticle constructor | |
186 | nump++; | |
187 | new(particlesR[i]) TParticle( | |
188 | LUJETS.k[1][i], LUJETS.k[0][i] , | |
189 | LUJETS.k[2][i], -1, LUJETS.k[3][i], LUJETS.k[4][i], | |
190 | LUJETS.p[0][i], LUJETS.p[1][i], LUJETS.p[2][i], LUJETS.p[3][i] , | |
191 | LUJETS.v[0][i], LUJETS.v[1][i], LUJETS.v[2][i], LUJETS.v[3][i] | |
192 | ); | |
193 | } | |
194 | } | |
195 | } | |
196 | else if(!strcmp(option,"All")){ | |
197 | nump = numpart; | |
198 | for(Int_t i = 0; i < numpart; i++){ | |
199 | new(particlesR[i]) TParticle( | |
200 | LUJETS.k[1][i], LUJETS.k[0][i] , | |
201 | LUJETS.k[2][i], -1, LUJETS.k[3][i], LUJETS.k[4][i], | |
202 | LUJETS.p[0][i], LUJETS.p[1][i], LUJETS.p[2][i], LUJETS.p[3][i] , | |
203 | LUJETS.v[0][i], LUJETS.v[1][i], LUJETS.v[2][i], LUJETS.v[3][i] | |
204 | ); | |
205 | } | |
206 | } | |
207 | return nump; | |
208 | } | |
209 | ||
210 | //______________________________________________________________________________ | |
211 | void THydjet::SetEfrm(Float_t efrm) | |
212 | { | |
213 | // Set the centre of mass (CMS) or lab-energy (LAB) | |
214 | fEfrm=efrm; | |
215 | } | |
216 | //______________________________________________________________________________ | |
217 | void THydjet::SetFrame(const char* frame) | |
218 | { | |
219 | // Set the frame type ("CMS" or "LAB") | |
220 | fFrame=frame; | |
221 | } | |
222 | //______________________________________________________________________________ | |
223 | /*void THydjet::SetProj(const char* proj) | |
224 | { | |
225 | // Set the projectile type | |
226 | fProj=proj; | |
227 | } | |
228 | //______________________________________________________________________________ | |
229 | void THydjet::SetTarg(const char* targ) | |
230 | { | |
231 | // Set the target type | |
232 | fTarg=targ; | |
233 | } | |
234 | */ | |
235 | //______________________________________________________________________________ | |
236 | void THydjet::SetAw(Float_t aw) | |
237 | { | |
238 | // Set the projectile-targed atomic number | |
239 | fAw=aw; | |
240 | } | |
241 | //______________________________________________________________________________ | |
242 | void THydjet::SetIfb(Int_t ifb) | |
243 | { | |
244 | // flag of type of centrality generation | |
245 | fIfb=ifb; | |
246 | } | |
247 | //______________________________________________________________________________ | |
248 | void THydjet::SetBmin(Float_t bmin) | |
249 | { | |
250 | // set minimum impact parameter in units of nucleus radius RA | |
251 | fBmin=bmin; | |
252 | } | |
253 | //______________________________________________________________________________ | |
254 | void THydjet::SetBmax(Float_t bmax) | |
255 | { | |
256 | // set maximum impact parameter in units of nucleus radius RA | |
257 | fBmax=bmax; | |
258 | } | |
259 | //______________________________________________________________________________ | |
260 | void THydjet::SetBfix(Float_t bfix) | |
261 | { | |
262 | // Set fixed impact parameter in units of nucleus radius RA | |
263 | fBfix=bfix; | |
264 | } | |
265 | //______________________________________________________________________________ | |
266 | void THydjet::SetNh(Int_t nh) | |
267 | { | |
268 | // Set mean soft hadron multiplicity in central Pb-Pb collisions | |
269 | fNh=nh; | |
270 | } | |
271 | //______________________________________________________________________________ | |
272 | Float_t THydjet::GetEfrm() const | |
273 | { | |
274 | // Get the centre of mass (CMS) or lab-energy (LAB) | |
275 | return fEfrm; | |
276 | } | |
277 | //______________________________________________________________________________ | |
278 | const char* THydjet::GetFrame() const | |
279 | { | |
280 | // Get the frame type ("CMS" or "LAB") | |
281 | return fFrame.Data(); | |
282 | } | |
283 | //______________________________________________________________________________ | |
284 | /*const char* THydjet::GetProj() const | |
285 | { | |
286 | // Get the projectile type | |
287 | return fProj; | |
288 | } | |
289 | //______________________________________________________________________________ | |
290 | const char* THydjet::GetTarg() const | |
291 | { | |
292 | // Set the target type | |
293 | return fTarg; | |
294 | } | |
295 | */ | |
296 | //______________________________________________________________________________ | |
297 | Float_t THydjet::GetAw() const | |
298 | { | |
299 | // Get the projectile atomic number | |
300 | return fAw; | |
301 | } | |
302 | //______________________________________________________________________________ | |
303 | Int_t THydjet::GetIfb() const | |
304 | { | |
305 | // Get flag of type of centrality generation | |
306 | return fIfb; | |
307 | } | |
308 | //______________________________________________________________________________ | |
309 | Float_t THydjet::GetBmin() const | |
310 | { | |
311 | // Get minimum impact parameter in units of nucleus radius RA | |
312 | return fBmin; | |
313 | } | |
314 | //______________________________________________________________________________ | |
315 | Float_t THydjet::GetBmax() const | |
316 | { | |
317 | // Get maximum impact parameter in units of nucleus radius RA | |
318 | return fBmax; | |
319 | } | |
320 | //______________________________________________________________________________ | |
321 | Float_t THydjet::GetBfix() const | |
322 | { | |
323 | // Get fixed impact parameter in units of nucleus radius RA | |
324 | return fBfix; | |
325 | } | |
326 | //______________________________________________________________________________ | |
327 | Int_t THydjet::GetNh() const | |
328 | { | |
329 | // Get mean soft hadron multiplicity in central Pb-Pb collisions | |
330 | return fNh; | |
331 | } | |
332 | ||
333 | //====================== access to common HYFLOW =============================== | |
334 | ||
335 | //______________________________________________________________________________ | |
336 | const void THydjet::SetYTFL(Float_t value) const | |
337 | { | |
338 | HYFLOW.ytfl=value; | |
339 | } | |
340 | ||
341 | //______________________________________________________________________________ | |
342 | Float_t THydjet::GetYTFL() const | |
343 | { | |
344 | return HYFLOW.ytfl; | |
345 | } | |
346 | ||
347 | //______________________________________________________________________________ | |
348 | const void THydjet::SetYLFL(Float_t value) const | |
349 | { | |
350 | HYFLOW.ylfl=value; | |
351 | } | |
352 | ||
353 | //______________________________________________________________________________ | |
354 | Float_t THydjet::GetYLFL() const | |
355 | { | |
356 | return HYFLOW.ylfl; | |
357 | } | |
358 | ||
359 | //______________________________________________________________________________ | |
360 | const void THydjet::SetFPART(Float_t value) const | |
361 | { | |
362 | HYFLOW.fpart=value; | |
363 | } | |
364 | ||
365 | ||
366 | //______________________________________________________________________________ | |
367 | Float_t THydjet::GetFPART() const | |
368 | { | |
369 | return HYFLOW.fpart; | |
370 | } | |
371 | ||
372 | ||
373 | //====================== access to common HYJPAR =============================== | |
374 | ||
375 | //______________________________________________________________________________ | |
376 | const void THydjet::SetNHSEL(Int_t value) const | |
377 | { | |
378 | HYJPAR.nhsel=value; | |
379 | } | |
380 | ||
381 | //______________________________________________________________________________ | |
382 | Int_t THydjet::GetNHSEL() const | |
383 | { | |
384 | return HYJPAR.nhsel; | |
385 | } | |
386 | ||
387 | //______________________________________________________________________________ | |
388 | const void THydjet::SetPTMIN(Float_t value) const | |
389 | { | |
390 | HYJPAR.ptmin=value; | |
391 | } | |
392 | ||
393 | //______________________________________________________________________________ | |
394 | Float_t THydjet::GetPTMIN() const | |
395 | { | |
396 | return HYJPAR.ptmin; | |
397 | } | |
398 | ||
399 | //______________________________________________________________________________ | |
400 | const void THydjet::SetNJET(Int_t value) const | |
401 | { | |
402 | HYJPAR.njet=value; | |
403 | } | |
404 | ||
405 | //______________________________________________________________________________ | |
406 | Int_t THydjet::GetNJET() const | |
407 | { | |
408 | return HYJPAR.njet; | |
409 | } | |
410 | ||
411 | //====================== access to common HYFPAR =============================== | |
412 | ||
413 | //______________________________________________________________________________ | |
414 | Float_t THydjet::GetBGEN() const | |
415 | { | |
416 | return HYFPAR.bgen; | |
417 | } | |
418 | ||
419 | //______________________________________________________________________________ | |
420 | Int_t THydjet::GetNBCOL() const | |
421 | { | |
422 | return HYFPAR.nbcol; | |
423 | } | |
424 | ||
425 | //______________________________________________________________________________ | |
426 | Int_t THydjet::GetNPART() const | |
427 | { | |
428 | return HYFPAR.npart; | |
429 | } | |
430 | ||
431 | //______________________________________________________________________________ | |
432 | Int_t THydjet::GetNPYT() const | |
433 | { | |
434 | return HYFPAR.npyt; | |
435 | } | |
436 | ||
437 | //______________________________________________________________________________ | |
438 | Int_t THydjet::GetNHYD() const | |
439 | { | |
440 | return HYFPAR.nhyd; | |
441 | } | |
442 | ||
443 | ||
444 | //====================== access to common LUJETS =============================== | |
445 | ||
446 | //______________________________________________________________________________ | |
447 | Int_t THydjet::GetN() const | |
448 | { | |
449 | return LUJETS.n; | |
450 | } | |
451 | ||
452 | //______________________________________________________________________________ | |
453 | Int_t THydjet::GetK(Int_t key1, Int_t key2) const | |
454 | { | |
455 | // Get Particle codes information | |
456 | if ( key1<1 || key1>150000 ) { | |
457 | printf("ERROR in THydjet::GetK(key1,key2):\n"); | |
458 | printf(" key1=%i is out of range [1..150000]\n",key1); | |
459 | return 0; | |
460 | } | |
461 | ||
462 | if ( key2<1 || key2>5 ) { | |
463 | printf("ERROR in THydjet::GetK(key1,key2):\n"); | |
464 | printf(" key2=%i is out of range [1..5]\n",key2); | |
465 | return 0; | |
466 | } | |
467 | ||
468 | return LUJETS.k[key2-1][key1-1]; | |
469 | } | |
470 | ||
471 | //______________________________________________________________________________ | |
472 | Float_t THydjet::GetP(Int_t key1, Int_t key2) const | |
473 | { | |
474 | // Get Particle four momentum and mass | |
475 | if ( key1<1 || key1>150000 ) { | |
476 | printf("ERROR in THydjet::GetP(key1,key2):\n"); | |
477 | printf(" key1=%i is out of range [1..150000]\n",key1); | |
478 | return 0; | |
479 | } | |
480 | ||
481 | if ( key2<1 || key2>5 ) { | |
482 | printf("ERROR in THydjet::GetP(key1,key2):\n"); | |
483 | printf(" key2=%i is out of range [1..5]\n",key2); | |
484 | return 0; | |
485 | } | |
486 | ||
487 | return LUJETS.p[key2-1][key1-1]; | |
488 | } | |
489 | ||
490 | //______________________________________________________________________________ | |
491 | Float_t THydjet::GetV(Int_t key1, Int_t key2) const | |
492 | { | |
493 | // Get particle vertex, production time and lifetime | |
494 | if ( key1<1 || key1>150000 ) { | |
495 | printf("ERROR in THydjet::GetV(key1,key2):\n"); | |
496 | printf(" key1=%i is out of range [1..150000]\n",key1); | |
497 | return 0; | |
498 | } | |
499 | ||
500 | if ( key2<1 || key2>5 ) { | |
501 | printf("ERROR in THydjet::GetV(key1,key2):\n"); | |
502 | printf(" key2=%i is out of range [1..5]\n",key2); | |
503 | return 0; | |
504 | } | |
505 | ||
506 | return LUJETS.v[key2-1][key1-1]; | |
507 | } | |
508 | ||
509 | //====================== access to common HYJETS =============================== | |
510 | ||
511 | //______________________________________________________________________________ | |
512 | Int_t THydjet::GetNL() const | |
513 | { | |
514 | return HYJETS.nl; | |
515 | } | |
516 | ||
517 | //______________________________________________________________________________ | |
518 | Int_t THydjet::GetKL(Int_t key1, Int_t key2) const | |
519 | { | |
520 | // Get Particle codes information | |
521 | if ( key1<1 || key1>150000 ) { | |
522 | printf("ERROR in THydjet::GetKL(key1,key2):\n"); | |
523 | printf(" key1=%i is out of range [1..150000]\n",key1); | |
524 | return 0; | |
525 | } | |
526 | ||
527 | if ( key2<1 || key2>5 ) { | |
528 | printf("ERROR in THydjet::GetKL(key1,key2):\n"); | |
529 | printf(" key2=%i is out of range [1..5]\n",key2); | |
530 | return 0; | |
531 | } | |
532 | ||
533 | return HYJETS.kl[key2-1][key1-1]; | |
534 | } | |
535 | ||
536 | //______________________________________________________________________________ | |
537 | Float_t THydjet::GetPL(Int_t key1, Int_t key2) const | |
538 | { | |
539 | // Get Particle four momentum and mass | |
540 | if ( key1<1 || key1>150000 ) { | |
541 | printf("ERROR in THydjet::GetPL(key1,key2):\n"); | |
542 | printf(" key1=%i is out of range [1..150000]\n",key1); | |
543 | return 0; | |
544 | } | |
545 | ||
546 | if ( key2<1 || key2>5 ) { | |
547 | printf("ERROR in THydjet::GetPL(key1,key2):\n"); | |
548 | printf(" key2=%i is out of range [1..5]\n",key2); | |
549 | return 0; | |
550 | } | |
551 | ||
552 | return HYJETS.pl[key2-1][key1-1]; | |
553 | } | |
554 | ||
555 | //______________________________________________________________________________ | |
556 | Float_t THydjet::GetVL(Int_t key1, Int_t key2) const | |
557 | { | |
558 | // Get particle vertex, production time and lifetime | |
559 | if ( key1<1 || key1>150000 ) { | |
560 | printf("ERROR in THydjet::GetVL(key1,key2):\n"); | |
561 | printf(" key1=%i is out of range [1..150000]\n",key1); | |
562 | return 0; | |
563 | } | |
564 | ||
565 | if ( key2<1 || key2>5 ) { | |
566 | printf("ERROR in THydjet::GetVL(key1,key2):\n"); | |
567 | printf(" key2=%i is out of range [1..5]\n",key2); | |
568 | return 0; | |
569 | } | |
570 | ||
571 | return HYJETS.vl[key2-1][key1-1]; | |
572 | } | |
573 | ||
574 | ||
575 | //====================== access to common PYDAT1 =============================== | |
576 | ||
577 | //______________________________________________________________________________ | |
578 | void THydjet::SetMSTU(Int_t key, Int_t value) | |
579 | { | |
580 | //Set MSTU in Pythia | |
581 | if ( key<1 || key>200 ) { | |
582 | printf("ERROR in THydjet::SetMSTU(key,value):\n"); | |
583 | printf(" key=%i is out of range [1..200]\n",key); | |
584 | } | |
585 | PYDAT1.mstu[key-1] = value; | |
586 | } | |
587 | ||
588 | //______________________________________________________________________________ | |
589 | void THydjet::SetPARU(Int_t key, Double_t value) | |
590 | { | |
591 | //Set PARU in Pythia | |
592 | if ( key<1 || key>200 ) { | |
593 | printf("ERROR in THydjet::SetPARU(key,value):\n"); | |
594 | printf(" key=%i is out of range [1..200]\n",key); | |
595 | } | |
596 | PYDAT1.paru[key-1] = value; | |
597 | } | |
598 | ||
599 | //______________________________________________________________________________ | |
600 | void THydjet::SetMSTJ(Int_t key, Int_t value) | |
601 | { | |
602 | //Set MSTJ in Pythia | |
603 | if ( key<1 || key>200 ) { | |
604 | printf("ERROR in THydjet::SetMSTJ(key,value):\n"); | |
605 | printf(" key=%i is out of range [1..200]\n",key); | |
606 | } | |
607 | PYDAT1.mstj[key-1] = value; | |
608 | } | |
609 | ||
610 | //______________________________________________________________________________ | |
611 | void THydjet::SetPARJ(Int_t key, Double_t value) | |
612 | { | |
613 | //Set PARJ in Pythia | |
614 | if ( key<1 || key>200 ) { | |
615 | printf("ERROR in THydjet::SetPARJ(key,value):\n"); | |
616 | printf(" key=%i is out of range [1..200]\n",key); | |
617 | } | |
618 | PYDAT1.parj[key-1] = value; | |
619 | } | |
620 | ||
621 | ||
622 | //====================== access to common PYSUBS =============================== | |
623 | ||
624 | //______________________________________________________________________________ | |
625 | const void THydjet::SetMSEL(Int_t value) const | |
626 | { | |
627 | PYSUBS.msel=value; | |
628 | } | |
629 | ||
630 | //______________________________________________________________________________ | |
631 | void THydjet::SetCKIN(Int_t key, Double_t value) | |
632 | { | |
633 | //Set CKIN in Pythia | |
634 | if ( key<1 || key>200 ) { | |
635 | printf("ERROR in THydjet::SetCKIN(key,value):\n"); | |
636 | printf(" key=%i is out of range [1..200]\n",key); | |
637 | } | |
638 | PYSUBS.ckin[key-1] = value; | |
639 | } | |
640 | ||
641 | //====================== access to common PYPARS =============================== | |
642 | ||
643 | //______________________________________________________________________________ | |
644 | void THydjet::SetMSTP(Int_t key, Int_t value) | |
645 | { | |
646 | //Set MSTP in Pythia | |
647 | if ( key<1 || key>200 ) { | |
648 | printf("ERROR in THydjet::SetMSTP(key,value):\n"); | |
649 | printf(" key=%i is out of range [1..200]\n",key); | |
650 | } | |
651 | PYPARS.mstp[key-1] = value; | |
652 | } | |
653 | ||
654 | ||
655 | //====================== access to Hijing subroutines ========================= | |
656 | ||
657 | ||
658 | //______________________________________________________________________________ | |
659 | void THydjet::Initialize() | |
660 | { | |
661 | ||
662 | // Initialize PYTHIA for hard parton-parton scattering | |
663 | if ( (!strcmp(fFrame.Data(), "CMS " )) && | |
664 | (!strcmp(fFrame.Data(), "LAB " ))){ | |
665 | printf("WARNING! In THydjet:Initialize():\n"); | |
666 | printf(" specified frame=%s is neither CMS or LAB\n",fFrame.Data()); | |
667 | printf(" resetting to default \"CMS\" ."); | |
668 | fFrame="CMS"; | |
669 | } | |
670 | Int_t nhselflag = GetNHSEL(); | |
671 | if(nhselflag != 0) { | |
672 | Double_t lwin = fEfrm; | |
673 | Long_t s1 = strlen(fFrame); | |
674 | Long_t s2 = strlen("p"); | |
675 | Long_t s3 = strlen("p"); | |
676 | #ifndef WIN32 | |
677 | pyinit(fFrame,"p","p",&lwin,s1,s2,s3); | |
678 | #else | |
679 | pyinit(fFrame, s1, "p" , s2, "p", s3, &lwin); | |
680 | #endif | |
681 | } | |
682 | } | |
683 | ||
684 | ||
685 | //______________________________________________________________________________ | |
686 | void THydjet::GenerateEvent() | |
687 | { | |
688 | // Generates one event; | |
689 | float xbmin = fBmin; | |
690 | float xbmax = fBmax; | |
691 | float xbfix = fBfix; | |
692 | float xAw = fAw; | |
693 | hydro(&xAw,&fIfb,&xbmin,&xbmax,&xbfix,&fNh); | |
694 | ||
695 | } | |
696 | //______________________________________________________________________________ | |
697 | void THydjet::Hydro() | |
698 | { | |
699 | // Generates one event; | |
700 | float xbmin = fBmin; | |
701 | float xbmax = fBmax; | |
702 | float xbfix = fBfix; | |
703 | float xAw = fAw; | |
704 | hydro(&xAw,&fIfb,&xbmin,&xbmax,&xbfix,&fNh); | |
705 | } |