const
[u/mrichter/AliRoot.git] / TAmpt / TAmpt.cxx
CommitLineData
0119ef9a 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18// This class implements an interface to the Ampt event generator
19
20#include <TClonesArray.h>
21#include <TObjArray.h>
22#include <TParticle.h>
23#include <TROOT.h>
24#include <TRandom.h>
25#include "Acommon.h"
26#include "TAmpt.h"
27#include "AliAmptRndm.h"
28
29#ifndef WIN32
30# define amptset amptset_
31# define amptsetdef amptsetdef_
32# define ampt ampt_
33# define invflv invflv_
34# define profile profile_
35# define rluget_ampt rluget_ampt_
36# define rluset_ampt rluset_ampt_
37# define type_of_call
38#else
39# define amptset AMPTSET
40# define amptsetdef AMPTSETDEF
41# define ampt AMPT
42# define invflv INVFLV
43# define profile PROFILE
44# define rluget_ampt RLUGET_AMPT
45# define rluset_ampt RLUSET_AMPT
46# define type_of_call _stdcall
47#endif
48
49#ifndef WIN32
50extern "C" void type_of_call amptset(Double_t & , const char *,
51 const char *, const char *,
52 Int_t & , Int_t &, Int_t &,
53 Int_t &, const int,
54 const int, const int);
55extern "C" void type_of_call amptsetdef();
56extern "C" void type_of_call ampt(const char *, Double_t &,
57 Double_t &, const int);
58extern "C" Int_t type_of_call invflv(Int_t &);
59extern "C" float type_of_call profile(Float_t &);
60extern "C" void type_of_call rluget_ampt(Int_t & lfn, Int_t & move);
61extern "C" void type_of_call rluset_ampt(Int_t & lfn, Int_t & move);
62#else
63#endif
64
65
66ClassImp(TAmpt)
67
68//______________________________________________________________________________
69TAmpt::TAmpt()
70 : TGenerator("Ampt","Ampt"),
71 fEfrm(5500.),
72 fFrame("CMS"),
73 fProj("A"),
74 fTarg("A"),
75 fIap(208),
76 fIzp(82),
77 fIat(208),
78 fIzt(82),
79 fBmin(0.),
80 fBmax(5.),
81 fPhi(0.)
82{
83 // Default constructor
84 amptsetdef();
85}
86
87//______________________________________________________________________________
88TAmpt::TAmpt(Double_t efrm, const char *frame="CMS",
89 const char *proj="A", const char *targ="A",
90 Int_t iap=207, Int_t izp=82, Int_t iat=207, Int_t izt=82,
91 Double_t bmin=0, Double_t bmax=20)
92 : TGenerator("Ampt","Ampt"),
93 fEfrm(efrm),
94 fFrame(frame),
95 fProj(proj),
96 fTarg(targ),
97 fIap(iap),
98 fIzp(izp),
99 fIat(iat),
100 fIzt(izt),
101 fBmin(bmin),
102 fBmax(bmax),
103 fPhi(0.)
104{
105 // TAmpt constructor:
106 // Note that there may be only one functional TAmpt object
107 // at a time, so it's not use to create more than one instance of it.
108 amptsetdef();
109}
110
111//______________________________________________________________________________
112TAmpt::~TAmpt()
113{
114 // Destructor
115}
116
117//______________________________________________________________________________
118TObjArray* TAmpt::ImportParticles(Option_t */*option*/)
119{
120 // Import created particles.
121
122 fParticles->Clear();
123 Int_t numpart = HBT.nlast;
124 printf("TAmpt: AMPT stack contains %d particles.\n", numpart);
125
126 Double_t sinphi = TMath::Sin(fPhi);
127 Double_t cosphi = TMath::Cos(fPhi);
128
129 for (Int_t i=0; i < numpart; ++i) {
130 Int_t status = 1;
131 Double_t px0 = HBT.plast[i][0];//GeV/c
132 Double_t py0 = HBT.plast[i][1];//GeV/c
133 Double_t px = px0*cosphi-py0*sinphi;
134 Double_t py = py0*cosphi+px0*sinphi;
135 Double_t pz = HBT.plast[i][2];//GeV/c
136 Double_t ma = HBT.plast[i][3];//GeV/c/c
137 Double_t vx0 = 0;//HBT.xlast[i][0]*1e-12;//mm
138 Double_t vy0 = 0;//HBT.xlast[i][1]*1e-12;//mm
139 Double_t vx = vx0*cosphi-vy0*sinphi;
140 Double_t vy = vy0*cosphi+vx0*sinphi;
141 Double_t vz = 0;//HBT.xlast[i][2]*1e-12;//mm
142 Double_t vt = 0;//HBT.xlast[i][3]*1e-12;//mm/c
143 Int_t pdg = invflv(HBT.lblast[i]);
144 TParticle *p = new TParticle(pdg,
145 status,
146 -1,
147 -1,
148 -1,
149 -1,
150 px,
151 py,
152 pz,
153 TMath::Sqrt(ma*ma+px*px+py*py+pz*pz),
154 vx,
155 vy,
156 vz,
157 vt
158 );
159 if((px0==0)&&(py0==0)) {
160 if(pz<0)
161 p->SetUniqueID(0);
162 else
163 p->SetUniqueID(10);
164 } else
165 p->SetUniqueID(999);
166 }
167 return fParticles;
168}
169
170//______________________________________________________________________________
171Int_t TAmpt::ImportParticles(TClonesArray *particles, Option_t */*option*/)
172{
173 // Import created particles.
174
175 if (particles == 0)
176 return 0;
177
178 TClonesArray &particlesR = *particles;
179 particlesR.Clear();
180
181 Int_t numpart = HBT.nlast;
182 printf("TAmpt: AMPT stack contains %d particles.\n", numpart);
183
184 Double_t sinphi = TMath::Sin(fPhi);
185 Double_t cosphi = TMath::Cos(fPhi);
186
187 //at this point not clear how to read particle history, just take primaries.
188 for (Int_t i=0; i < numpart; ++i) {
189 Int_t status = 1;
190 Double_t px0 = HBT.plast[i][0];//GeV/c
191 Double_t py0 = HBT.plast[i][1];//GeV/c
192 Double_t px = px0*cosphi-py0*sinphi;
193 Double_t py = py0*cosphi+px0*sinphi;
194 Double_t pz = HBT.plast[i][2];//GeV/c
195 Double_t ma = HBT.plast[i][3];//GeV/c/c
196 Double_t vx0 = 0;//HBT.xlast[i][0]*1e-12;//mm
197 Double_t vy0 = 0;//HBT.xlast[i][1]*1e-12;//mm
198 Double_t vx = vx0*cosphi-vy0*sinphi;
199 Double_t vy = vy0*cosphi+vx0*sinphi;
200 Double_t vz = 0;//HBT.xlast[i][2]*1e-12;//mm
201 Double_t vt = 0;//HBT.xlast[i][3]*1e-12;//mm/c
202 Int_t pdg = invflv(HBT.lblast[i]);
203 //printf("i %d pdg %d px %f py %f pz %f vx %f vy %f vz %f vt %f\n", i, pdg, px, py, pz, vx, vy, vz, vt);
204 new(particlesR[i]) TParticle(pdg,
205 status,
206 -1,
207 -1,
208 -1,
209 -1,
210 px,
211 py,
212 pz,
213 TMath::Sqrt(ma*ma+px*px+py*py+pz*pz),
214 vx,
215 vy,
216 vz,
217 vt
218 );
219 if((px0==0)&&(py0==0)){
220 if(pz<0)
221 particlesR[i]->SetUniqueID(0);
222 else
223 particlesR[i]->SetUniqueID(10);
224 } else
225 particlesR[i]->SetUniqueID(999);
226 }
227 return numpart;
228}
229
230//______________________________________________________________________________
231Int_t TAmpt::ImportNucleons(TClonesArray *nucleons, Option_t */*option*/)
232{
233 // Import created particles.
234
235 if (nucleons == 0)
236 return 0;
237
238 TClonesArray &nucleonsR = *nucleons;
239 nucleonsR.Clear();
240
241 Double_t sinphi = TMath::Sin(fPhi);
242 Double_t cosphi = TMath::Cos(fPhi);
243
244 Int_t nA = HPARNT.ihnt2[0];
245 for (Int_t i=0; i < nA; ++i) {
246 Double_t x0 = HJCRDN.yp[i][0] + 0.5*GetBB();
247 Double_t y0 = HJCRDN.yp[i][1];
248 Double_t x = x0*cosphi-y0*sinphi;
249 Double_t y = y0*cosphi+x0*sinphi;
250 Double_t z = HJCRDN.yp[i][2];
251 Int_t p = HSTRNG.nfp[3][i];
252 Int_t s = HSTRNG.nfp[4][i];
253 new(nucleonsR[i]) TParticle(p,
254 s,
255 -1,
256 -1,
257 -1,
258 -1,
259 0,
260 0,
261 0,
262 0,
263 x,
264 y,
265 z,
266 0
267 );
268 nucleonsR[i]->SetUniqueID(1);
269 }
270 Int_t nB = HPARNT.ihnt2[2];
271 for (Int_t i=0; i < nB; ++i) {
272 Double_t x0 = HJCRDN.yt[i][0] - 0.5*HPARNT.hint1[18];
273 Double_t y0 = HJCRDN.yt[i][1];
274 Double_t x = x0*cosphi-y0*sinphi;
275 Double_t y = y0*cosphi+x0*sinphi;
276 Double_t z = HJCRDN.yt[i][2];
277 Int_t p = HSTRNG.nft[3][i];
278 Int_t s = HSTRNG.nft[4][i];
279 new(nucleonsR[nA+i]) TParticle(p,
280 s,
281 -1,
282 -1,
283 -1,
284 -1,
285 0,
286 0,
287 0,
288 0,
289 x,
290 y,
291 z,
292 0
293 );
294 nucleonsR[nA+i]->SetUniqueID(-1);
295 }
296 return nA+nB;
297}
298
299//______________________________________________________________________________
300void TAmpt::SetEFRM(Float_t efrm)
301{
302 // Set the centre of mass (CMS) or lab-energy (LAB)
303 fEfrm=efrm;
304}
305
306//______________________________________________________________________________
307void TAmpt::SetFRAME(const char* frame)
308{
309 // Set the frame type ("CMS" or "LAB")
310 fFrame=frame;
311}
312
313//______________________________________________________________________________
314void TAmpt::SetPROJ(const char* proj)
315{
316 // Set the projectile type
317 fProj=proj;
318}
319
320//______________________________________________________________________________
321void TAmpt::SetTARG(const char* targ)
322{
323 // Set the target type
324 fTarg=targ;
325}
326
327//______________________________________________________________________________
328void TAmpt::SetIAP(Int_t iap)
329{
330 // Set the projectile atomic number
331 fIap=iap;
332}
333
334//______________________________________________________________________________
335void TAmpt::SetIZP(Int_t izp)
336{
337 // Set the projectile charge number
338 fIzp=izp;
339}
340
341//______________________________________________________________________________
342void TAmpt::SetIAT(Int_t iat)
343{
344 // Set the target atomic number
345 fIat=iat;
346}
347
348//______________________________________________________________________________
349void TAmpt::SetIZT(Int_t izt)
350{
351 // Set the target charge number
352 fIzt=izt;
353}
354
355//______________________________________________________________________________
356void TAmpt::SetBMIN(Float_t bmin)
357{
358 // Set the minimum impact parameter
359 fBmin=bmin;
360}
361
362//______________________________________________________________________________
363void TAmpt::SetBMAX(Float_t bmax)
364{
365 // Set the maximum impact parameter
366 fBmax=bmax;
367}
368
369//______________________________________________________________________________
370Float_t TAmpt::GetEFRM() const
371{
372 // Get the centre of mass (CMS) or lab-energy (LAB)
373 return fEfrm;
374}
375
376//______________________________________________________________________________
377const char* TAmpt::GetFRAME() const
378{
379 // Get the frame type ("CMS" or "LAB")
380 return fFrame.Data();
381}
382
383//______________________________________________________________________________
384const char* TAmpt::GetPROJ() const
385{
386 // Get the projectile type
387 return fProj;
388}
389
390//______________________________________________________________________________
391const char* TAmpt::GetTARG() const
392{
393 // Set the target type
394 return fTarg;
395}
396
397//______________________________________________________________________________
398Int_t TAmpt::GetIAP() const
399{
400 // Get the projectile atomic number
401 return fIap;
402}
403
404//______________________________________________________________________________
405Int_t TAmpt::GetIZP() const
406{
407 // Get the projectile charge number
408 return fIzp;
409}
410
411//______________________________________________________________________________
412Int_t TAmpt::GetIAT() const
413{
414 // Get the target atomic number
415 return fIat;
416}
417
418//______________________________________________________________________________
419Int_t TAmpt::GetIZT() const
420{
421 // Get the target charge number
422 return fIzt;
423}
424
425//______________________________________________________________________________
426Float_t TAmpt::GetBMIN() const
427{
428 // Get the minimum impact parameter
429 return fBmin;
430}
431
432//______________________________________________________________________________
433Float_t TAmpt::GetBMAX() const
434{
435 // Get the maximum impact parameter
436 return fBmax;
437}
438
439//====================== access to common HIPARNT ===============================
440
441//______________________________________________________________________________
442void TAmpt::SetHIPR1(Int_t key,Float_t value)
443{
444 // Set the values of array HIPR1 in common HIPARNT
445 if ( key<1 || key>100 ) {
446 printf ("ERROR in TAmpt:SetHIPR1(key,value): \n ");
447 printf (" key=%i is out of range [1..100]!\n",key);
448 return;
449 }
450 HPARNT.hipr1[key-1]=value;
451}
452
453//______________________________________________________________________________
454Float_t TAmpt::GetHIPR1(Int_t key) const
455{
456 // Get the values of array HIPR1 in common HIPARNT
457 if ( key<1 || key>100 ) {
458 printf ("ERROR in TAmpt:GetHIPR1(key): \n ");
459 printf (" key=%i is out of range [1..100]!\n",key);
460 return 0;
461 }
462 return HPARNT.hipr1[key-1];
463}
464
465//______________________________________________________________________________
466void TAmpt::SetIHPR2(Int_t key,Int_t value)
467{
468 // Set the values of array HIPR2 in common HIPARNT
469 if ( key<1 || key>50 ) {
470 printf ("ERROR in TAmpt:SetIHPR2(key,value): \n ");
471 printf (" key=%i is out of range [1..50]!\n",key);
472 return;
473 }
474 HPARNT.ihpr2[key-1]=value;
475}
476
477//______________________________________________________________________________
478Int_t TAmpt::GetIHPR2(Int_t key) const
479{
480 // Get the values of array HIPR2 in common HIPARNT
481 if ( key<1 || key>50 ) {
482 printf ("ERROR in TAmpt:GetIHPR2(key): \n ");
483 printf (" key=%i is out of range [1..50]!\n",key);
484 return 0;
485 }
486 return HPARNT.ihpr2[key-1];
487}
488
489//______________________________________________________________________________
490Float_t TAmpt::GetHINT1(Int_t key) const
491{
492 // Get the values of array HINT1 in common HIPARNT
493 if ( key<1 || key>100 ) {
494 printf ("ERROR in TAmpt:GetHINT1(key): \n ");
495 printf (" key=%i is out of range [1..100]!\n",key);
496 return 0;
497 }
498 return HPARNT.hint1[key-1];
499}
500
501//______________________________________________________________________________
502Int_t TAmpt::GetIHNT2(Int_t key) const
503{
504 // Get the values of array HINT2 in common HIPARNT
505 if ( key<1 || key>50 ) {
506 printf ("ERROR in TAmpt:GetIHNT2(key): \n ");
507 printf (" key=%i is out of range [1..50]!\n",key);
508 return 0;
509 }
510 return HPARNT.ihnt2[key-1];
511}
512
513//====================== access to common HMAIN1 ===============================
514
515//______________________________________________________________________________
516Int_t TAmpt::GetNATT() const
517{
518 // Get the number of particles produces
519 return HMAIN1.natt;
520}
521
522//______________________________________________________________________________
523Float_t TAmpt::GetEATT() const
524{
525 // Get total energy of particles
526 return HMAIN1.eatt;
527}
528
529//______________________________________________________________________________
530Int_t TAmpt::GetJATT() const
531{
532 // Get number of hard scatterings
533 return HMAIN1.jatt;
534}
535
536//______________________________________________________________________________
537Int_t TAmpt::GetNT() const
538{
539 // Get number of target participants
540 return HMAIN1.nt;
541}
542
543//______________________________________________________________________________
544Int_t TAmpt::GetNP() const
545{
546 // Get number of projectile participants
547 return HMAIN1.np;
548}
549
550//______________________________________________________________________________
551Int_t TAmpt::GetN0() const
552{
553 // Get number of N-N collisions
554 return HMAIN1.n0;
555}
556
557//______________________________________________________________________________
558Int_t TAmpt::GetN01() const
559{
560 // Get number of N-wounded collisions
561 return HMAIN1.n01;
562}
563
564//______________________________________________________________________________
565Int_t TAmpt::GetN10() const
566{
567 // Get number of wounded-N collisions
568 return HMAIN1.n10;
569}
570
571//______________________________________________________________________________
572Int_t TAmpt::GetN11() const
573{
574 // Get number of wounded-wounded collisions
575 return HMAIN1.n11;
576}
577
578//______________________________________________________________________________
579Float_t TAmpt::GetBB() const
580{
581 // Get impact parameter
582
583 return HPARNT.hint1[18];
584}
585
586//====================== access to common HMAIN2 ===============================
587
588//______________________________________________________________________________
589Int_t TAmpt::GetKATT(Int_t key1, Int_t key2) const
590{
591 // Get values of array KATT in common HMAIN2
592 if ( key1<1 || key1>200000 ) {
593 printf("ERROR in TAmpt::GetKATT(key1,key2):\n");
594 printf(" key1=%i is out of range [1..200000]\n",key1);
595 return 0;
596 }
597 if ( key2<1 || key2>4 ) {
598 printf("ERROR in TAmpt::GetKATT(key1,key2):\n");
599 printf(" key2=%i is out of range [1..4]\n",key2);
600 return 0;
601 }
602 return HMAIN2.katt[key2-1][key1-1];
603}
604
605//______________________________________________________________________________
606Float_t TAmpt::GetPATT(Int_t key1, Int_t key2) const
607{
608 // Get values of array PATT in common HMAIN2
609 if ( key1<1 || key1>200000 ) {
610 printf("ERROR in TAmpt::GetPATT(key1,key2):\n");
611 printf(" key1=%i is out of range [1..130000]\n",key1);
612 return 0;
613 }
614 if ( key2<1 || key2>4 ) {
615 printf("ERROR in TAmpt::GetPATT(key1,key2):\n");
616 printf(" key2=%i is out of range [1..4]\n",key2);
617 return 0;
618 }
619 return HMAIN2.patt[key2-1][key1-1];
620}
621
622//______________________________________________________________________________
623Float_t TAmpt::GetVATT(Int_t key1, Int_t key2) const
624{
625 // Get values of array VATT in common HMAIN2
626 if ( key1<1 || key1>200000 ) {
627 printf("ERROR in TAmpt::GetVATT(key1,key2):\n");
628 printf(" key1=%i is out of range [1..130000]\n",key1);
629 return 0;
630 }
631 if ( key2<1 || key2>4 ) {
632 printf("ERROR in TAmpt::GetVATT(key1,key2):\n");
633 printf(" key2=%i is out of range [1..4]\n",key2);
634 return 0;
635 }
636 return HMAIN2.vatt[key2-1][key1-1];
637}
638
639//====================== access to common HIJJET1 ===============================
640
641//______________________________________________________________________________
642Int_t TAmpt::GetNPJ(Int_t key) const
643{
644 // Get values of array NPJ of common HIJJET1
645 if ( key<1 || key>300 ) {
646 printf("ERROR in TAmpt::GetNPJ(key):\n");
647 printf(" key=%i is out of range [1..300]\n",key);
648 return 0;
649 }
650 return HJJET1.npj[key-1];
651}
652
653//______________________________________________________________________________
654Int_t TAmpt::GetKFPJ(Int_t key1, Int_t key2) const
655{
656 // Get values of array KFPJ in common HIJJET1
657 if ( key1<1 || key1>300 ) {
658 printf("ERROR in TAmpt::GetKFPJ(key1):\n");
659 printf(" key1=%i is out of range [1..300]\n",key1);
660 return 0;
661 }
662 if ( key2<1 || key2>500 ) {
663 printf("ERROR in TAmpt::GetKFPJ(key1,key2):\n");
664 printf(" key2=%i is out of range [1..500]\n",key2);
665 return 0;
666 }
667 return HJJET1.kfpj[key2-1][key1-1];
668}
669
670//______________________________________________________________________________
671Float_t TAmpt::GetPJPX(Int_t key1, Int_t key2) const
672{
673 // Get values of array PJPX in common HIJJET1
674 if ( key1<1 || key1>300 ) {
675 printf("ERROR in TAmpt::GetPJPX(key1):\n");
676 printf(" key1=%i is out of range [1..300]\n",key1);
677 return 0;
678 }
679 if ( key2<1 || key2>500 ) {
680 printf("ERROR in TAmpt::GetPJPX(key1,key2):\n");
681 printf(" key2=%i is out of range [1..500]\n",key2);
682 return 0;
683 }
684 return HJJET1.pjpx[key2-1][key1-1];
685}
686
687//______________________________________________________________________________
688Float_t TAmpt::GetPJPY(Int_t key1, Int_t key2) const
689{
690 // Get values of array PJPY in common HIJJET1
691 if ( key1<1 || key1>300 ) {
692 printf("ERROR in TAmpt::GetPJPY(key1):\n");
693 printf(" key1=%i is out of range [1..300]\n",key1);
694 return 0;
695 }
696 if ( key2<1 || key2>500 ) {
697 printf("ERROR in TAmpt::GetPJPY(key1,key2):\n");
698 printf(" key2=%i is out of range [1..500]\n",key2);
699 return 0;
700 }
701 return HJJET1.pjpy[key2-1][key1-1];
702}
703
704//______________________________________________________________________________
705Float_t TAmpt::GetPJPZ(Int_t key1, Int_t key2) const
706{
707 // Get values of array PJPZ in common HIJJET1
708 if ( key1<1 || key1>300 ) {
709 printf("ERROR in TAmpt::GetPJPZ(key1):\n");
710 printf(" key1=%i is out of range [1..300]\n",key1);
711 return 0;
712 }
713 if ( key2<1 || key2>500 ) {
714 printf("ERROR in TAmpt::GetPJPZ(key1,key2):\n");
715 printf(" key2=%i is out of range [1..500]\n",key2);
716 return 0;
717 }
718 return HJJET1.pjpz[key2-1][key1-1];
719}
720
721//______________________________________________________________________________
722Float_t TAmpt::GetPJPE(Int_t key1, Int_t key2) const
723{
724 // Get values of array PJPE in common HIJJET1
725 if ( key1<1 || key1>300 ) {
726 printf("ERROR in TAmpt::GetPJPE(key1):\n");
727 printf(" key1=%i is out of range [1..300]\n",key1);
728 return 0;
729 }
730 if ( key2<1 || key2>500 ) {
731 printf("ERROR in TAmpt::GetPJPE(key1,key2):\n");
732 printf(" key2=%i is out of range [1..500]\n",key2);
733 return 0;
734 }
735 return HJJET1.pjpe[key2-1][key1-1];
736}
737
738//______________________________________________________________________________
739Float_t TAmpt::GetPJPM(Int_t key1, Int_t key2) const
740{
741 // Get values of array PJPM in common HIJJET1
742 if ( key1<1 || key1>300 ) {
743 printf("ERROR in TAmpt::GetPJPM(key1):\n");
744 printf(" key1=%i is out of range [1..300]\n",key1);
745 return 0;
746 }
747 if ( key2<1 || key2>500 ) {
748 printf("ERROR in TAmpt::GetPJPM(key1,key2):\n");
749 printf(" key2=%i is out of range [1..500]\n",key2);
750 return 0;
751 }
752 return HJJET1.pjpm[key2-1][key1-1];
753}
754
755//______________________________________________________________________________
756Int_t TAmpt::GetNTJ(Int_t key) const
757{
758 // Get values of array NTJ in common HIJJET1
759 if ( key<1 || key>300 ) {
760 printf("ERROR in TAmpt::GetNTJ(key):\n");
761 printf(" key=%i is out of range [1..300]\n",key);
762 return 0;
763 }
764 return HJJET1.ntj[key-1];
765}
766
767//______________________________________________________________________________
768Int_t TAmpt::GetKFTJ(Int_t key1, Int_t key2) const
769{
770 // Get values of array KFTJ in common HIJJET1
771 if ( key1<1 || key1>300 ) {
772 printf("ERROR in TAmpt::GetKFTJ(key1):\n");
773 printf(" key1=%i is out of range [1..300]\n",key1);
774 return 0;
775 }
776 if ( key2<1 || key2>500 ) {
777 printf("ERROR in TAmpt::GetKFTJ(key1,key2):\n");
778 printf(" key2=%i is out of range [1..500]\n",key2);
779 return 0;
780 }
781 return HJJET1.kftj[key2-1][key1-1];
782}
783
784//______________________________________________________________________________
785Float_t TAmpt::GetPJTX(Int_t key1, Int_t key2) const
786{
787 // Get values of array PJTX in common HIJJET1
788 if ( key1<1 || key1>300 ) {
789 printf("ERROR in TAmpt::GetPJTX(key1):\n");
790 printf(" key1=%i is out of range [1..300]\n",key1);
791 return 0;
792 }
793 if ( key2<1 || key2>500 ) {
794 printf("ERROR in TAmpt::GetPJTX(key1,key2):\n");
795 printf(" key2=%i is out of range [1..500]\n",key2);
796 return 0;
797 }
798 return HJJET1.pjtx[key2-1][key1-1];
799}
800
801//______________________________________________________________________________
802Float_t TAmpt::GetPJTY(Int_t key1, Int_t key2) const
803{
804 // Get values of array PJTY in common HIJJET1
805 if ( key1<1 || key1>300 ) {
806 printf("ERROR in TAmpt::GetPJTY(key1):\n");
807 printf(" key1=%i is out of range [1..300]\n",key1);
808 return 0;
809 }
810 if ( key2<1 || key2>500 ) {
811 printf("ERROR in TAmpt::GetPJTY(key1,key2):\n");
812 printf(" key2=%i is out of range [1..500]\n",key2);
813 return 0;
814 }
815 return HJJET1.pjty[key2-1][key1-1];
816}
817
818//______________________________________________________________________________
819Float_t TAmpt::GetPJTZ(Int_t key1, Int_t key2) const
820{
821 // Get values of array PJTZ in common HIJJET1
822 if ( key1<1 || key1>300 ) {
823 printf("ERROR in TAmpt::GetPJTZ(key1):\n");
824 printf(" key1=%i is out of range [1..300]\n",key1);
825 return 0;
826 }
827 if ( key2<1 || key2>500 ) {
828 printf("ERROR in TAmpt::GetPJTZ(key1,key2):\n");
829 printf(" key2=%i is out of range [1..500]\n",key2);
830 return 0;
831 }
832 return HJJET1.pjtz[key2-1][key1-1];
833}
834
835//______________________________________________________________________________
836Float_t TAmpt::GetPJTE(Int_t key1, Int_t key2) const
837{
838 // Get values of array PJTE in common HIJJET1
839 if ( key1<1 || key1>300 ) {
840 printf("ERROR in TAmpt::GetPJTE(key1):\n");
841 printf(" key1=%i is out of range [1..300]\n",key1);
842 return 0;
843 }
844 if ( key2<1 || key2>500 ) {
845 printf("ERROR in TAmpt::GetPJTE(key1,key2):\n");
846 printf(" key2=%i is out of range [1..500]\n",key2);
847 return 0;
848 }
849 return HJJET1.pjte[key2-1][key1-1];
850}
851
852//______________________________________________________________________________
853Float_t TAmpt::GetPJTM(Int_t key1, Int_t key2) const
854{
855 // Get values of array PJTM in common HIJJET1
856 if ( key1<1 || key1>300 ) {
857 printf("ERROR in TAmpt::GetPJTM(key1):\n");
858 printf(" key1=%i is out of range [1..300]\n",key1);
859 return 0;
860 }
861 if ( key2<1 || key2>500 ) {
862 printf("ERROR in TAmpt::GetPJTM(key1,key2):\n");
863 printf(" key2=%i is out of range [1..500]\n",key2);
864 return 0;
865 }
866 return HJJET1.pjtm[key2-1][key1-1];
867}
868
869//====================== access to common HIJJET1 ===============================
870
871//______________________________________________________________________________
872Int_t TAmpt::GetNSG() const
873{
874 // Get value of NSG in common HIJJET2
875 return HJJET2.nsg;
876}
877
878//______________________________________________________________________________
879Int_t TAmpt::GetNJSG(Int_t key) const
880{
881 // Get values of array NJSG in common HIJJET2
882 if ( key<1 || key>900 ) {
883 printf ("ERROR in TAmpt:GetNJSG(key): \n ");
884 printf (" key=%i is out of range [1..900]!\n",key);
885 return 0;
886 }
887 return HJJET2.njsg[key-1];
888}
889
890//______________________________________________________________________________
891Int_t TAmpt::GetIASG(Int_t key1, Int_t key2) const
892{
893 // Get values of IASG in common HIJJET2
894 if ( key1<1 || key1>900 ) {
895 printf("ERROR in TAmpt::GetIASG(key1):\n");
896 printf(" key1=%i is out of range [1..900]\n",key1);
897 return 0;
898 }
899 if ( key2<1 || key2>3 ) {
900 printf("ERROR in TAmpt::GetIASG(key1,key2):\n");
901 printf(" key2=%i is out of range [1..3]\n",key2);
902 return 0;
903 }
904 return HJJET2.iasg[key2-1][key1-1];
905}
906
907//______________________________________________________________________________
908Int_t TAmpt::GetK1SG(Int_t key1, Int_t key2) const
909{
910 // Get values of K1SG in common HIJJET2
911 if ( key1<1 || key1>900 ) {
912 printf("ERROR in TAmpt::GetK1SG(key1):\n");
913 printf(" key1=%i is out of range [1..900]\n",key1);
914 return 0;
915 }
916 if ( key2<1 || key2>100 ) {
917 printf("ERROR in TAmpt::GetK1SG(key1,key2):\n");
918 printf(" key2=%i is out of range [1..100]\n",key2);
919 return 0;
920 }
921 return HJJET2.k1sg[key2-1][key1-1];
922}
923
924//______________________________________________________________________________
925Int_t TAmpt::GetK2SG(Int_t key1, Int_t key2) const
926{
927 // Get values of K2SG in common HIJJET2
928 if ( key1<1 || key1>900 ) {
929 printf("ERROR in TAmpt::GetK2SG(key1):\n");
930 printf(" key1=%i is out of range [1..900]\n",key1);
931 return 0;
932 }
933 if ( key2<1 || key2>100 ) {
934 printf("ERROR in TAmpt::GetK2SG(key1,key2):\n");
935 printf(" key2=%i is out of range [1..100]\n",key2);
936 return 0;
937 }
938 return HJJET2.k2sg[key2-1][key1-1];
939}
940
941//______________________________________________________________________________
942Float_t TAmpt::GetPXSG(Int_t key1, Int_t key2) const
943{
944 // Get values of PXSG in common HIJJET2
945 if ( key1<1 || key1>900 ) {
946 printf("ERROR in TAmpt::GetPXSG(key1):\n");
947 printf(" key1=%i is out of range [1..900]\n",key1);
948 return 0;
949 }
950 if ( key2<1 || key2>100 ) {
951 printf("ERROR in TAmpt::GetPXSG(key1,key2):\n");
952 printf(" key2=%i is out of range [1..100]\n",key2);
953 return 0;
954 }
955 return HJJET2.pxsg[key2-1][key1-1];
956}
957
958//______________________________________________________________________________
959Float_t TAmpt::GetPYSG(Int_t key1, Int_t key2) const
960{
961 // Get values of PYSG in common HIJJET2
962 if ( key1<1 || key1>900 ) {
963 printf("ERROR in TAmpt::GetPYSG(key1):\n");
964 printf(" key1=%i is out of range [1..900]\n",key1);
965 return 0;
966 }
967 if ( key2<1 || key2>100 ) {
968 printf("ERROR in TAmpt::GetPYSG(key1,key2):\n");
969 printf(" key2=%i is out of range [1..100]\n",key2);
970 return 0;
971 }
972 return HJJET2.pysg[key2-1][key1-1];
973}
974
975//______________________________________________________________________________
976Float_t TAmpt::GetPZSG(Int_t key1, Int_t key2) const
977{
978 // Get values of PZSG in common HIJJET2
979 if ( key1<1 || key1>900 ) {
980 printf("ERROR in TAmpt::GetPZSG(key1):\n");
981 printf(" key1=%i is out of range [1..900]\n",key1);
982 return 0;
983 }
984 if ( key2<1 || key2>100 ) {
985 printf("ERROR in TAmpt::GetPZSG(key1,key2):\n");
986 printf(" key2=%i is out of range [1..100]\n",key2);
987 return 0;
988 }
989 return HJJET2.pzsg[key2-1][key1-1];
990}
991
992//______________________________________________________________________________
993Float_t TAmpt::GetPESG(Int_t key1, Int_t key2) const
994{
995 // Get values of PESG in common HIJJET2
996 if ( key1<1 || key1>900 ) {
997 printf("ERROR in TAmpt::GetPESG(key1):\n");
998 printf(" key1=%i is out of range [1..900]\n",key1);
999 return 0;
1000 }
1001 if ( key2<1 || key2>100 ) {
1002 printf("ERROR in TAmpt::GetPESG(key1,key2):\n");
1003 printf(" key2=%i is out of range [1..100]\n",key2);
1004 return 0;
1005 }
1006 return HJJET2.pesg[key2-1][key1-1];
1007}
1008
1009//______________________________________________________________________________
1010Float_t TAmpt::GetPMSG(Int_t key1, Int_t key2) const
1011{
1012 // Get values of PMSG in common HIJJET2
1013 if ( key1<1 || key1>900 ) {
1014 printf("ERROR in TAmpt::GetPMSG(key1):\n");
1015 printf(" key1=%i is out of range [1..900]\n",key1);
1016 return 0;
1017 }
1018 if ( key2<1 || key2>100 ) {
1019 printf("ERROR in TAmpt::GetPMSG(key1,key2):\n");
1020 printf(" key2=%i is out of range [1..100]\n",key2);
1021 return 0;
1022 }
1023 return HJJET2.pmsg[key2-1][key1-1];
1024}
1025
1026//====================== access to common HISTRNG ===============================
1027
1028//______________________________________________________________________________
1029Int_t TAmpt::GetNFP(Int_t key1, Int_t key2) const
1030{
1031 // Get values of array NFP in common HISTRNG
1032 if ( key1<1 || key1>300 ) {
1033 printf("ERROR in TAmpt::GetNFP(key1):\n");
1034 printf(" key1=%i is out of range [1..300]\n",key1);
1035 return 0;
1036 }
1037 if ( key2<1 || key2>15 ) {
1038 printf("ERROR in TAmpt::GetNFP(key1,key2):\n");
1039 printf(" key2=%i is out of range [1..15]\n",key2);
1040 return 0;
1041 }
1042 return HSTRNG.nfp[key2-1][key1-1];
1043}
1044
1045//______________________________________________________________________________
1046Float_t TAmpt::GetPP(Int_t key1, Int_t key2) const
1047{
1048 // Get values of array PP in common HISTRNG
1049 if ( key1<1 || key1>300 ) {
1050 printf("ERROR in TAmpt::GetPP(key1):\n");
1051 printf(" key1=%i is out of range [1..300]\n",key1);
1052 return 0;
1053 }
1054 if ( key2<1 || key2>15 ) {
1055 printf("ERROR in TAmpt::GetPP(key1,key2):\n");
1056 printf(" key2=%i is out of range [1..15]\n",key2);
1057 return 0;
1058 }
1059 return HSTRNG.pp[key2-1][key1-1];
1060}
1061
1062//______________________________________________________________________________
1063Int_t TAmpt::GetNFT(Int_t key1, Int_t key2) const
1064{
1065 // Get values of array NFT in common HISTRNG
1066 if ( key1<1 || key1>300 ) {
1067 printf("ERROR in TAmpt::GetNFT(key1):\n");
1068 printf(" key1=%i is out of range [1..300]\n",key1);
1069 return 0;
1070 }
1071 if ( key2<1 || key2>15 ) {
1072 printf("ERROR in TAmpt::GetNFT(key1,key2):\n");
1073 printf(" key2=%i is out of range [1..15]\n",key2);
1074 return 0;
1075 }
1076 return HSTRNG.nft[key2-1][key1-1];
1077}
1078
1079//______________________________________________________________________________
1080Float_t TAmpt::GetPT(Int_t key1, Int_t key2) const
1081{
1082 // Get values of array PT in common HISTRNG
1083 if ( key1<1 || key1>300 ) {
1084 printf("ERROR in TAmpt::GetPT(key1):\n");
1085 printf(" key1=%i is out of range [1..300]\n",key1);
1086 return 0;
1087 }
1088 if ( key2<1 || key2>15 ) {
1089 printf("ERROR in TAmpt::GetPT(key1,key2):\n");
1090 printf(" key2=%i is out of range [1..15]\n",key2);
1091 return 0;
1092 }
1093 return HSTRNG.pt[key2-1][key1-1];
1094}
1095
1096void TAmpt::SetPARJ(Int_t key, Float_t parm)
1097{
1098 // Set values of array PARJ in common HISTRNG
1099 if ( key < 1 || key > 200) {
1100 printf("ERROR in TAmpt::SetPARJ(key,parm):\n");
1101 printf(" key=%i is out of range [1..200]\n",key);
1102 }
1103 LUDAT1.parj[key-1] = parm;
1104}
1105
1106
1107void TAmpt::SetMSTJ(Int_t key, Int_t parm)
1108{
1109 // Set values of array MSTJ in common HISTRNG
1110 if ( key < 1 || key > 200) {
1111 printf("ERROR in TAmpt::SetMSTJ(key,parm):\n");
1112 printf(" key=%i is out of range [1..200]\n",key);
1113 }
1114 LUDAT1.mstj[key-1] = parm;
1115}
1116
1117//====================== access to Ampt subroutines =========================
1118
1119//______________________________________________________________________________
1120void TAmpt::Initialize()
1121{
1122 // Calls Ampset with the either default parameters or the ones set by the user //
1123 // via SetEFRM, SetFRAME, SetPROJ, SetTARG, SetIAP, SetIZP, SetIAT, SetIZT //
1124
1125 if ( (!strcmp(fFrame.Data(), "CMS " )) &&
1126 (!strcmp(fFrame.Data(), "LAB " ))){
1127 printf("WARNING! In TAmpt:Initialize():\n");
1128 printf(" specified frame=%s is neither CMS or LAB\n",fFrame.Data());
1129 printf(" resetting to default \"CMS\" .");
1130 fFrame="CMS";
1131 }
1132
1133 if ( (!strcmp(fProj.Data(), "A " )) &&
1134 (!strcmp(fProj.Data(), "P " )) &&
1135 (!strcmp(fProj.Data(), "PBAR " ))){
1136 printf("WARNING! In TAmpt:Initialize():\n");
1137 printf(" specified projectile=%s is neither A, P or PBAR\n",fProj.Data());
1138 printf(" resetting to default \"A\" .");
1139 fProj="A";
1140 }
1141
1142 if ( (!strcmp(fTarg.Data(), "A " )) &&
1143 (!strcmp(fTarg.Data(), "P " )) &&
1144 (!strcmp(fTarg.Data(), "PBAR " ))){
1145 printf("WARNING! In TAmpt:Initialize():\n");
1146 printf(" specified target=%s is neither A, P or PBAR\n",fTarg.Data());
1147 printf(" resetting to default \"A\" .");
1148 fTarg="A";
1149 }
1150
1151 //printf(" %s-%s at %f GeV \n",fProj.Data(),fTarg.Data(),fEfrm);
1152 Amptset(fEfrm,fFrame.Data(),fProj.Data(),fTarg.Data(),fIap,fIzp,fIat,fIzt);
1153}
1154
1155//______________________________________________________________________________
1156void TAmpt::GenerateEvent()
1157{
1158 // Generates one event;
1159
1160 //printf("Next event ------------------------\n");
1161 fPhi = TMath::TwoPi()*AliAmptRndm::GetAmptRandom()->Rndm()-TMath::Pi();
1162 Ampt(fFrame.Data(),fBmin,fBmax);
1163}
1164
1165//______________________________________________________________________________
1166void TAmpt::Amptset(double efrm, const char *frame, const char *proj,
1167 const char *targ, int iap, int izp, int iat, int izt)
1168{
1169 // Call AMPT routine HIJSET passing the parameters in a way accepted by
1170 // Fortran routines
1171
1172 int s1 = strlen(frame);
1173 int s2 = strlen(proj);
1174 int s3 = strlen(targ);
1175 //printf("s1 = %d s2 = %d s3 = %d\n",s1,s2,s3);
1176#ifndef WIN32
1177 amptset(efrm, frame, proj, targ, iap, izp, iat, izt, s1, s2, s3);
1178#else
1179 amptset(efrm, frame, s1, proj, s2, targ, s3, iap, izp, iat, izt);
1180#endif
1181}
1182
1183//______________________________________________________________________________
1184void TAmpt::Ampt(const char *frame, double bmin, double bmax)
1185{
1186 // Call AMPT routine HIJSET passing the parameters in a way accepted by
1187 // Fortran routines
1188
1189 int s1 = strlen(frame);
1190
1191#ifndef WIN32
1192 ampt(frame, bmin, bmax, s1);
1193#else
1194 ampt(frame, s1, bmin, bmax);
1195#endif
1196}
1197
1198Float_t TAmpt::Profile(float b)
1199{
1200 // Call AMPT routine PROFILE
1201 return profile(b);
1202}
1203
1204//______________________________________________________________________________
1205void TAmpt::Rluget(Int_t lfn, Int_t move)
1206{
1207 // write seed to file
1208 rluget_ampt(lfn, move);
1209}
1210
1211//______________________________________________________________________________
1212void TAmpt::Rluset(Int_t lfn, Int_t move)
1213{
1214 // read seed from file
1215 rluset_ampt(lfn, move);
1216}
1217
1218//______________________________________________________________________________
1219void TAmpt::SetIsoft(Int_t i)
1220{
1221 // set ampt mode.
1222 ANIM.isoft = i;
1223}
1224
1225//______________________________________________________________________________
1226void TAmpt::SetNtMax(Int_t max)
1227{
1228 // set maximum number of timesteps
1229 INPUT2.ntmax = max;
1230}
1231
1232//______________________________________________________________________________
1233void TAmpt::SetIpop(Int_t pop)
1234{
1235 // set flag for popcorn mechanism(netbaryon stopping)
1236 POPCORN.ipop = pop;
1237}
1238
1239//______________________________________________________________________________
1240void TAmpt::SetXmu(Float_t m)
1241{
a004b331 1242 // set parton screening mass in fm^-1.
0119ef9a 1243 PARA2.xmu = m;
1244}
a004b331 1245
1246//______________________________________________________________________________
1247void TAmpt::SetAlpha(Float_t alpha)
1248{
1249 // set parton screening mass in fm^-1.
1250 PARA2.alpha = alpha;
1251}
1252
1253//______________________________________________________________________________
1254void TAmpt::SetStringFrag(Float_t a, Float_t b)
1255{
1256 // Set string frag parameters, f(z) = 1/z*(1-z)^a*exp(-b*mz^2/z).
1257 SetPARJ(41, a);
1258 SetPARJ(42, b);
1259}