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