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