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