TIsajet/TIsajet.cxx

   1 #include "TParticle.h"
   2 #include "TSystem.h"
   3 #include "TIsajet.h"
   4 #include "Icommon.h"
   5 #include "Riostream.h"
   6 #include "math.h"
   7 #include "TROOT.h"
   8 #include "TMath.h"
   9
  10 ClassImp(TIsajet)
  11
  12 static TRandom * sRandom;
  13
  14 /**************************************************************************/
  15
  16 TIsajet::TIsajet() : TGenerator("Isajet", "Isajet")
  17 {
  18 //  Default constructor
  19 //  Set random number
  20     if (!sRandom) sRandom=fRandom;
  21
  22 // Initialising equivalence structures in FRGPAR :
  23 // EQUIVALENCE (PMIX1(1,1),PMIXX1(1))
  24 // EQUIVALENCE (PMIX2(1,1),PMIXX2(1))
  25 // EQUIVALENCE (FRPAR(1),PUD)
  26
  27     FRGPAR.pmixx1[0] = &FRGPAR.pmix1[0][0];
  28     FRGPAR.pmixx2[0] = &FRGPAR.pmix2[0][0];
  29     FRGPAR.frpar[0] = &FRGPAR.pud;
  30
  31     for (Int_t i = 1; i < 6; i++) {
  32         FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
  33         FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
  34     }
  35
  36     for (Int_t i = 1; i < 32; i++) {
  37         FRGPAR.frpar[i] = FRGPAR.frpar[i-1] +1;
  38     }
  39
  40 // Internal logical flags ensuring that theta and y limits are not simultaneously set :
  41
  42     DYLIM.ywset = DYLIM.thwset = false;
  43
  44 // Defaults :
  45
  46     title = ("Default title.");
  47     jobtype = ("TWOJET");
  48
  49     RestoreDefaults();
  50 }
  51
  52 /**************************************************************************/
  53
  54 TIsajet::~TIsajet()
  55 {
  56     // No housekeeping required at the moment.
  57 }
  58
  59 /**************************************************************************/
  60
  61 void TIsajet::Initialise()
  62 {
  63
  64 // Writes parameter file and stores common block variables in
  65 // data members, according to booleans.
  66 // If TIsajet is being used in online-control mode, the parameter file is
  67 // unnecessary, hence the output is echoed to the screen instead.
  68
  69     const char *fname =  gSystem->ExpandPathName("$ALICE_ROOT/ISAJET/data/myjob.par");
  70     ofstream Write(fname, ios::out);
  71
  72     ostream *Writer = &Write;
  73
  74     if (online) Writer = &cout;
  75
  76     *Writer << title << '\n';
  77     *Writer << PRIMAR.ecm << ',' << PRIMAR.nevent << ",1,1/\n";
  78     *Writer << jobtype << '\n';
  79
  80     center_energy = PRIMAR.ecm;
  81
  82     if (setBeams) {
  83         beam1_type = PRIMAR.idin[0];
  84         beam2_type = PRIMAR.idin[1];
  85
  86         *Writer << "BEAMS\n";
  87         if (PRIMAR.idin[0] == -1120) *Writer << "AP,";
  88         else if (PRIMAR.idin[0] == 1220) *Writer << "N,";
  89         else if (PRIMAR.idin[0] == -1220) *Writer << "AN,";
  90         else *Writer << "P,";
  91
  92         if (PRIMAR.idin[1] == -1120) *Writer << "AP/\n";
  93         else if (PRIMAR.idin[1] == 1220) *Writer << "N/\n";
  94         else if (PRIMAR.idin[1] == -1220) *Writer << "AN/\n";
  95         else *Writer << "P/\n";
  96     }
  97
  98     if (setCutjet) {
  99         cutoff_mass = QCDPAR.cutjet;
 100         *Writer << "CUTJET\n" << QCDPAR.cutjet << "/\n";
 101     }
 102
 103     if (setFragment) {
 104         for (Int_t i = 0; i < 32; i++) frag_params[i] = *FRGPAR.frpar[i];
 105
 106         *Writer << "FRAGMENT\n";
 107         for (Int_t i = 0; i < 31; i++) *Writer << FRGPAR.frpar[i] << ',';
 108         *Writer << FRGPAR.frpar[31] << "/\n";
 109     }
 110
 111     if (setJettype1) {
 112         for (Int_t i = 0; i < TYPES.njttyp[0]; i++) jet1_type[i] = XTYPES.jetyp[0][i];
 113         num_jet_type[0] = TYPES.njttyp[0];
 114
 115         *Writer << "JETTYPE1\n";
 116         for (Int_t i = 0; i < TYPES.njttyp[0]-1; i++) *Writer << XTYPES.jetyp[0][i] << ',';
 117         *Writer << XTYPES.jetyp[0][TYPES.njttyp[0]-1] << "/\n";
 118     }
 119     if (setJettype2) {
 120         for (Int_t i = 0; i < TYPES.njttyp[1]; i++) jet2_type[i] = XTYPES.jetyp[1][i];
 121         num_jet_type[0] = TYPES.njttyp[0];
 122
 123         *Writer << "JETTYPE2\n";
 124         for (Int_t i = 0; i < TYPES.njttyp[1]-1; i++) *Writer << XTYPES.jetyp[1][i] << ',';
 125         *Writer << XTYPES.jetyp[1][TYPES.njttyp[1]-1] << "/\n";
 126     }
 127     if (setJettype3) {
 128         for (Int_t i = 0; i < TYPES.njttyp[2]; i++) jet3_type[i] = XTYPES.jetyp[2][i];
 129         num_jet_type[0] = TYPES.njttyp[0];
 130
 131         *Writer << "JETTYPE3\n";
 132         for (Int_t i = 0; i < TYPES.njttyp[2]-1; i++) *Writer << XTYPES.jetyp[2][i] << ',';
 133         *Writer << XTYPES.jetyp[2][TYPES.njttyp[2]-1] << "/\n";
 134     }
 135
 136
 137     if (setLambda) {
 138         qcd_lambda = QCDPAR.alam;
 139         *Writer << "LAMBDA\n" << QCDPAR.alam << "/\n";
 140     }
 141
 142
 143     if (setNodcay) {
 144         forbid_decay = NODCAY.nodcay;
 145
 146         *Writer << "NODCAY\n";
 147         if (NODCAY.nodcay) *Writer << "TRUE/\n";
 148         else *Writer << "FALSE/\n";
 149     }
 150
 151     if (setNoeta) {
 152         forbid_eta = NODCAY.noeta;
 153
 154         *Writer << "NOETA\n";
 155         if (NODCAY.noeta) *Writer << "TRUE/\n";
 156         else *Writer << "FALSE/\n";
 157     }
 158
 159     if (setNoevolve) {
 160         forbid_evolve = NODCAY.noevol;
 161
 162         *Writer << "NOEVOLVE\n";
 163         if (NODCAY.noevol) *Writer << "TRUE/\n";
 164         else *Writer << "FALSE/\n";
 165     }
 166
 167     if (setNohadron) {
 168         forbid_hadron = NODCAY.nohadr;
 169
 170         *Writer << "NOHADRON\n";
 171         if (NODCAY.nohadr) *Writer << "TRUE/\n";
 172         else *Writer << "FALSE/\n";
 173     }
 174
 175     if (setNopi0) {
 176         forbid_pi0 = NODCAY.nopi0;
 177
 178         *Writer << "NOPI0\n";
 179         if (NODCAY.nopi0) *Writer << "TRUE/\n";
 180         else *Writer << "FALSE/\n";
 181     }
 182
 183     if (setNsigma) {
 184         generate_sigma = PRIMAR.nsigma;
 185         *Writer << "NSIGMA\n" << PRIMAR.nsigma << "/\n";
 186     }
 187
 188     if (setP) {
 189         for (Int_t i = 0; i < 3; i++) {
 190             p_limits[2 * i] = JETLIM.pmin[i];
 191             p_limits[2 * i + 1] = JETLIM.pmax[i];
 192         }
 193
 194         *Writer << "P\n";
 195         *Writer << JETLIM.pmin[0] << ',' << JETLIM.pmax[0] << ',';
 196         *Writer << JETLIM.pmin[1] << ',' << JETLIM.pmax[1] << ',';
 197         *Writer << JETLIM.pmin[2] << ',' << JETLIM.pmax[2] << "/\n";
 198     }
 199
 200     if (setPhi) {
 201         for (Int_t i = 0; i < 3; i++) {
 202             phi_limits[2 * i] = JETLIM.phimin[i];
 203             phi_limits[2 * i + 1] = JETLIM.phimax[i];
 204         }
 205
 206         *Writer << "PHI\n";
 207         *Writer << JETLIM.phimin[0] << ',' << JETLIM.phimax[0] << ',';
 208         *Writer << JETLIM.phimin[1] << ',' << JETLIM.phimax[1] << ',';
 209         *Writer << JETLIM.phimin[2] << ',' << JETLIM.phimax[2] << "/\n";
 210     }
 211
 212     if (setPt) {
 213         for (Int_t i = 0; i < 3; i++) {
 214             pt_limits[2 * i] = JETLIM.ptmin[i];
 215             pt_limits[2 * i + 1] = JETLIM.ptmax[i];
 216         }
 217
 218         *Writer << "PT\n";
 219         *Writer << JETLIM.ptmin[0] << ',' << JETLIM.ptmax[0] << ',';
 220         *Writer << JETLIM.ptmin[1] << ',' << JETLIM.ptmax[1] << ',';
 221         *Writer << JETLIM.ptmin[2] << ',' << JETLIM.ptmax[2] << "/\n";
 222     }
 223
 224     if (setTheta) {
 225         for (Int_t i = 0; i < 3; i++) {
 226             theta_limits[2 * i] = JETLIM.thmin[i];
 227             theta_limits[2 * i + 1] = JETLIM.thmax[i];
 228         }
 229
 230         *Writer << "THETA\n";
 231         *Writer << JETLIM.thmin[0] << ',' << JETLIM.thmax[0] << ',';
 232         *Writer << JETLIM.thmin[1] << ',' << JETLIM.thmax[1] << ',';
 233         *Writer << JETLIM.thmin[2] << ',' << JETLIM.thmax[2] << "/\n";
 234     }
 235
 236     if (setX) {
 237         for (Int_t i = 0; i < 3; i++) {
 238             x_limits[2 * i] = JETLIM.xjmin[i];
 239             x_limits[2 * i + 1] = JETLIM.xjmax[i];
 240         }
 241
 242         *Writer << "X\n";
 243         *Writer << JETLIM.xjmin[0] << ',' << JETLIM.xjmax[0] << ',';
 244         *Writer << JETLIM.xjmin[1] << ',' << JETLIM.xjmax[1] << ',';
 245         *Writer << JETLIM.xjmin[2] << ',' << JETLIM.xjmax[2] << "/\n";
 246     }
 247
 248     if (setY) {
 249         for (Int_t i = 0; i < 3; i++) {
 250             y_limits[2 * i] = JETLIM.yjmin[i];
 251             y_limits[2 * i + 1] = JETLIM.yjmax[i];
 252         }
 253
 254         *Writer << "Y\n";
 255         *Writer << JETLIM.yjmin[0] << ',' << JETLIM.yjmax[0] << ',';
 256         *Writer << JETLIM.yjmin[1] << ',' << JETLIM.yjmax[1] << ',';
 257         *Writer << JETLIM.yjmin[2] << ',' << JETLIM.yjmax[2] << "/\n";
 258     }
 259
 260     if (setXgen) {
 261         for (Int_t i = 0; i < 8; i++) peter_jet_frag[i] = FRGPAR.xgen[i];
 262
 263         *Writer << "XGEN\n";
 264         for (Int_t i = 0; i < 7; i++) *Writer << FRGPAR.xgen[i] << ',';
 265         *Writer << FRGPAR.xgen[7] << "/\n";
 266     }
 267
 268     if (setPdf) {
 269         *Writer << "PDFLIB\n";
 270         for (Int_t i = 0; i < num_Pdf; i++) *Writer << "\'" << pdfpar[i] << "\'" << ',' << pdfval[i] << "/\n";
 271     }
 272
 273
 274     *Writer << "END\n";
 275     *Writer << "STOP\n";
 276     Write.close();
 277
 278 //  Stuff for online-control mode :
 279
 280     if (online) {
 281         KEYS.reac = jobtype;
 282         KEYS.keyon = false;
 283         for (Int_t i = 0; i < KEYS.mxkeys; i++) KEYS.keys[i] = false;
 284
 285         if (!strcmp(KEYS.reac, "TWOJET")) {
 286             KEYS.keys[0] = true;
 287             KEYS.ikey = 1;
 288             PRIMAR.njet = 2;
 289         }
 290         else if (!strcmp(KEYS.reac, "MINBIAS")) {
 291             KEYS.keys[3] = true;
 292             KEYS.ikey = 4;
 293             PRIMAR.njet = 0;
 294         }
 295         else {
 296             printf("Error in TIsajet::Initialise :\n");
 297             printf("Invalid job type %s.\n", KEYS.reac);
 298             printf("Only TWOJET and MINBIAS are currently supported for online mode.\n");
 299             return;
 300         }
 301
 302         if (setPdf) {
 303             PDFinit();
 304         }
 305     }
 306 }
 307
 308 /**************************************************************************/
 309
 310 void TIsajet::Reload()
 311 {
 312 //
 313 // Sets the common block variables to the data member values.
 314 //
 315
 316     SetECM(center_energy);
 317
 318     if (setBeams) {
 319         SetIDIN(0, beam1_type);
 320         SetIDIN(1, beam2_type);
 321     }
 322
 323     if (setCutjet) SetCUTJET(cutoff_mass);
 324
 325     if (setFragment) SetAllFRPAR(frag_params, 32);
 326
 327     if (setJettype1) for (Int_t i = 0; i < num_jet_type[0]; i++) SetJETYP(0, jet1_type[i]);
 328
 329     if (setJettype2) for (Int_t i = 0; i < num_jet_type[1]; i++) SetJETYP(1, jet2_type[i]);
 330
 331     if (setJettype3) for (Int_t i = 0; i < num_jet_type[2]; i++) SetJETYP(2, jet3_type[i]);
 332
 333     if (setLambda) SetALAM(qcd_lambda);
 334
 335     if (setNodcay) SetNODCAY(forbid_decay);
 336
 337     if (setNoeta) SetNOETA(forbid_eta);
 338
 339     if (setNoevolve) SetNOEVOL(forbid_evolve);
 340
 341     if (setNohadron) SetNOHADR(forbid_hadron);
 342
 343     if (setNopi0) SetNOPI0(forbid_pi0);
 344
 345     if (setNsigma) SetNSIGMA(generate_sigma);
 346
 347     if (setP) {
 348         for (Int_t i = 0; i < 3; i++) {
 349             SetPMIN(p_limits[2 * i], i);
 350             SetPMAX(p_limits[2 * i + 1], i);
 351         }
 352     }
 353
 354     if (setPhi) {
 355         for (Int_t i = 0; i < 3; i++) {
 356             SetPHIMIN(phi_limits[2 * i], i);
 357             SetPHIMAX(phi_limits[2 * i + 1], i);
 358         }
 359     }
 360
 361     if (setPt) {
 362         for (Int_t i = 0; i < 3; i++) {
 363             SetPTMIN(pt_limits[2 * i], i);
 364             SetPTMAX(pt_limits[2 * i + 1], i);
 365         }
 366     }
 367
 368     if (setTheta) {
 369         for (Int_t i = 0; i < 3; i++) {
 370             SetTHMIN(theta_limits[2 * i], i);
 371             SetTHMAX(theta_limits[2 * i + 1], i);
 372         }
 373     }
 374
 375     if (setX) {
 376         for (Int_t i = 0; i < 3; i++) {
 377             SetXJMIN(x_limits[2 * i], i);
 378             SetXJMAX(x_limits[2 * i + 1], i);
 379         }
 380     }
 381
 382     if (setY) {
 383         for (Int_t i = 0; i < 3; i++) {
 384             SetYJMIN(y_limits[2 * i], i);
 385             SetYJMAX(y_limits[2 * i + 1], i);
 386         }
 387     }
 388
 389     if (setXgen) SetAllXGEN(peter_jet_frag, 8);
 390 }
 391
 392 /**************************************************************************/
 393
 394 void TIsajet::RestoreDefaults()
 395 {
 396 // Booleans indicating which keywords should be written into the parameter file.
 397
 398     setBeams = setCutjet = setFragment = setJettype1 = false;
 399     setJettype2 = setJettype3 = setLambda = setNodcay = false;
 400     setNoeta = setNoevolve = setNohadron = setNopi0 = false;
 401     setNsigma = setP = setPhi = setPt  = setTheta = false;
 402     setX = setXgen = setY = setPdf = false;
 403     num_Pdf = 0;
 404
 405 // Calling on FORTRAN for initialisation of variables
 406
 407     Openfiles();
 408     Int_t a, b, c, d, e;
 409
 410     a = -54;
 411     b = 0;
 412     c = 51;
 413     d = 53;
 414
 415     Isaini(a, b, c, d);
 416     e = 0;
 417     Isabeg(e);
 418 }
 419
 420 /**************************************************************************/
 421
 422 Int_t TIsajet::ImportParticles(TClonesArray *particles, Option_t *option)
 423 {
 424 //
 425 //  Default primary creation method. It reads the /HEPEVT/ common block which
 426 //  has been filled by the GenerateEvent method. If the event generator does
 427 //  not use the HEPEVT common block, this routine has to be overloaded by
 428 //  the subclasses.
 429 //  The function loops on the generated particles and stores them in
 430 //  the TClonesArray pointed by the argument particles.
 431 //  The default action is to store only the stable particles (ISTHEP = 1)
 432 //  This can be demanded explicitly by setting the option = "Final"
 433 //  If the option = "All", all the particles are stored.
 434 //
 435   if (particles == 0) return 0;
 436   TClonesArray &Particles = *particles;
 437   Particles.Clear();
 438   TDatabasePDG* converter = TDatabasePDG::Instance();
 439   Int_t numpart = PARTCL.nptcl;
 440   printf("\n TIsajet: ISAJET stack contains %d particles.", numpart);
 441   printf("\n TIsajet: Total energy:         %f           ", PRIMAR.ecm);
 442   Int_t nump = 0;
 443   if ((!strcmp(option,"")) || (!strcmp(option,"Final"))) {
 444       for (Int_t i = 0; i < numpart; i++) {
 445
 446           if (PARTCL.idcay[i] == 0) {  // Check whether particle is stable.
 447 //
 448 //  Use the common block values for the TParticle constructor
 449 //
 450             nump++;
 451             new(Particles[i]) TParticle(
 452                   converter->ConvertIsajetToPdg(PARTCL.ident[i]) , // PDG code
 453                   0 , // Status - currently a default
 454
 455                   -1, // Mothers and daughters - not used for stable particles
 456                   -1,
 457                   -1,
 458                   -1,
 459
 460                   PARTCL.pptcl[i][0] ,  // x, y, z and 0 momenta
 461                   PARTCL.pptcl[i][1] ,
 462                   PARTCL.pptcl[i][2] ,
 463                   PARTCL.pptcl[i][3] ,
 464
 465                   0, // Velocities - currently not used.
 466                   0,
 467                   0,
 468                   0);
 469           }
 470       }
 471   }
 472   else if (!strcmp(option,"All")) {
 473       nump=numpart;
 474       for (Int_t i = 0; i < numpart; i++) {
 475
 476           // Determine mother particle. Set to -1 if the particle originates from
 477           // a parton or is a beam particle.
 478
 479           Int_t origin = PARTCL.iorig[i];
 480           Int_t jet = origin / PARTCL.ipack;
 481           origin = origin - (jet * PARTCL.ipack);
 482
 483           if (origin < 0) origin = 0;
 484
 485           // Determine first and last decay products. Both are -1 if the particle is stable.
 486           // Note this means they are set to 0, because one is subtracted after decoding;
 487           // this avoid off-by-one errors relative to the FORTRAN.
 488
 489           Int_t first_Daughter = 0;
 490           Int_t last_Daughter = 0;
 491
 492           if (PARTCL.idcay[i] != 0) {
 493               first_Daughter = PARTCL.idcay[i] / PARTCL.ipack;
 494               last_Daughter = PARTCL.idcay[i] - (first_Daughter * PARTCL.ipack);
 495           }
 496           new(Particles[i]) TParticle(
 497               converter->ConvertIsajetToPdg(PARTCL.ident[i]) ,
 498               0,
 499
 500               origin - 1,
 501               -1,
 502               first_Daughter - 1,
 503               last_Daughter - 1,
 504
 505               PARTCL.pptcl[i][0] ,
 506               PARTCL.pptcl[i][1] ,
 507               PARTCL.pptcl[i][2] ,
 508               PARTCL.pptcl[i][3] ,
 509
 510               0,
 511               0,
 512               0,
 513               0);
 514       }
 515   }
 516   return nump;
 517 }
 518
 519 /**************************************************************************/
 520
 521 void TIsajet::GenerateEvent()
 522 {
 523     Int_t e, ok, done;
 524
 525 //    e = 0;
 526
 527 //    if (online) Isabg2(e);
 528 //    else Isabeg(e);
 529
 530     e = 1;
 531     Isaevt(e, ok, done);
 532 }
 533
 534 /**************************************************************************/
 535
 536 void TIsajet::SetJobtype(Char_t *val)
 537 {
 538     if ((!strcmp(val, "TWOJET")) || (!strcmp(val, "E+E-")) ||
 539     (!strcmp(val, "DRELLYAN")) || (!strcmp(val, "MINBIAS")) ||
 540     (!strcmp(val, "SUSY")) || (!strcmp(val, "WPAIR")) ||
 541     (!strcmp(val, "HIGGS")) || (!strcmp(val, "PHOTON")) ||
 542     (!strcmp(val, "TCOLOR")) || (!strcmp(val, "WHIGGS")) ||
 543     (!strcmp(val, "EXTRADIM")) || (!strcmp(val, "ZJJ"))) {
 544             jobtype = val;
 545     }
 546     else {
 547         printf("Error in TIsajet::SetJobtype :\n");
 548         printf("Invalid reaction keyword %s.\n", val);
 549         printf("Valid keywords are : TWOJET, E+E-, DRELLYAN,\n");
 550         printf("MINBIAS, SUSY, WPAIR, HIGGS, PHOTON, TCOLOR,\n");
 551         printf("WHIGGS, EXTRADIM and ZJJ.\n");
 552     }
 553 }
 554
 555 /**************************************************************************/
 556
 557 void TIsajet::GetJobtype() const
 558 {
 559     printf ("Current job type is %s.\n", jobtype);
 560 }
 561
 562 /**************************************************************************/
 563
 564 void TIsajet::SetOnline(Bool_t val)
 565 {
 566     online = val;
 567 }
 568
 569 /**************************************************************************/
 570
 571 Bool_t TIsajet::GetOnline() const
 572 {
 573     return online;
 574 }
 575
 576 /**************************************************************************/
 577
 578 void TIsajet::SetPDF(Char_t *name, Float_t val)
 579 {
 580     if (num_Pdf < 19) {
 581         pdfpar[num_Pdf] = name;
 582         pdfval[num_Pdf] = val;
 583         num_Pdf++;
 584         setPdf = true;
 585     }
 586     else {
 587         printf ("Error in TIsajet::SetPDF :\n");
 588         printf ("Maximum of twenty PDF parameters may be set.\n");
 589     }
 590 }
 591
 592 /**************************************************************************/
 593
 594 // Access routines for common blocks.
 595 // Begins DYLIM access.
 596
 597 /**************************************************************************/
 598
 599 void TIsajet::SetQMIN(Float_t val)
 600 {
 601     if (val > DYLIM.qmax) {
 602         printf("Error in TIsajet::SetQMIN : \n");
 603         printf("You may not set QMIN to a value larger than QMAX = %f.\n", DYLIM.qmax);
 604         return;
 605     }
 606
 607     DYLIM.qmin = val;
 608     if (!DYLIM.ywset) SetYWLIMS();
 609 }
 610
 611 /**************************************************************************/
 612
 613 Float_t TIsajet::GetQMIN() const
 614 {
 615     return DYLIM.qmin;
 616 }
 617
 618 /**************************************************************************/
 619
 620 void TIsajet::SetQMAX(Float_t val)
 621 {
 622     if (val < DYLIM.qmin) {
 623         printf("Error in TIsajet::SetQMAX : \n");
 624         printf("You may not set QMAX to a value less than QMIN = %f.\n", DYLIM.qmin);
 625         return;
 626     }
 627
 628     DYLIM.qmax = val;
 629 }
 630
 631 /**************************************************************************/
 632
 633 Float_t TIsajet::GetQMAX() const
 634 {
 635     return DYLIM.qmax;
 636 }
 637
 638 /**************************************************************************/
 639
 640 void TIsajet::SetQTMIN(Float_t val)
 641 {
 642     if (val > DYLIM.qtmax) {
 643         printf("Error in TIsajet::SetQTMIN : \n");
 644         printf("You may not set QTMIN to a value larger than QTMAX = %f.\n", DYLIM.qtmax);
 645         return;
 646     }
 647     DYLIM.qtmin = val;
 648     if (!DYLIM.ywset) SetYWLIMS();
 649 }
 650
 651 /**************************************************************************/
 652
 653 Float_t TIsajet::GetQTMIN() const
 654 {
 655     return DYLIM.qtmin;
 656 }
 657
 658 /**************************************************************************/
 659
 660 void TIsajet::SetQTMAX(Float_t val)
 661 {
 662     if (val < DYLIM.qtmin) {
 663         printf("Error in TIsajet::SetQTMAX : \n");
 664         printf("You may not set QTMAX to a value less than QTMIN = %f.\n", DYLIM.qtmin);
 665         return;
 666     }
 667
 668     DYLIM.qtmax = val;
 669     if (!DYLIM.ywset) SetYWLIMS();
 670 }
 671
 672 /**************************************************************************/
 673
 674 Float_t TIsajet::GetQTMAX() const
 675 {
 676     return DYLIM.qtmax;
 677 }
 678
 679 /**************************************************************************/
 680
 681 void TIsajet::SetYWMIN(Float_t val)
 682 {
 683     if (val > DYLIM.ywmax) {
 684         printf("Error in TIsajet::SetYWMIN : \n");
 685         printf("You may not set YWMIN to a value larger than YWMAX = %f.\n", DYLIM.ywmax);
 686         return;
 687     }
 688
 689     if (DYLIM.thwset) {
 690         printf("Error in TIsajet::SetYWMIN :\n");
 691         printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMIN.\n");
 692     }
 693     else {
 694         DYLIM.ywset = true;
 695         DYLIM.ywmin = val;
 696     }
 697 }
 698
 699 /**************************************************************************/
 700
 701 Float_t TIsajet::GetYWMIN() const
 702 {
 703     return DYLIM.ywmin;
 704 }
 705
 706 /**************************************************************************/
 707
 708 void TIsajet::SetYWMAX(Float_t val)
 709 {
 710     if (val < DYLIM.ywmin) {
 711         printf("Error in TIsajet::SetYWMAX : \n");
 712         printf("You may not set YWMAX to a value less than YWMIN = %f.\n", DYLIM.ywmin);
 713         return;
 714     }
 715
 716     if (DYLIM.thwset) {
 717         printf("Error in TIsajet::SetYWMAX :\n");
 718         printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMAX.\n");
 719     }
 720     else {
 721         DYLIM.ywset = true;
 722         DYLIM.ywmax = val;
 723     }
 724 }
 725
 726 /**************************************************************************/
 727
 728 Float_t TIsajet::GetYWMAX() const
 729 {
 730     return DYLIM.ywmax;
 731 }
 732
 733 /**************************************************************************/
 734
 735 void TIsajet::SetYWLIMS()
 736 {
 737     Float_t rot = sqrt(DYLIM.qmin * DYLIM.qmin + DYLIM.qtmin * DYLIM.qtmin);
 738     DYLIM.ywmax = acosh(PRIMAR.halfe / rot);
 739     DYLIM.ywmin = -DYLIM.ywmax;
 740     DYLIM.ywset = false;
 741 }
 742
 743 /**************************************************************************/
 744
 745 void TIsajet::SetXWMIN(Float_t val)
 746 {
 747     if (val > DYLIM.xwmax) {
 748         printf("Error in TIsajet::SetXWMIN : \n");
 749         printf("You may not set XWMIN to a value larger than XWMAX = %f.\n", DYLIM.xwmax);
 750         return;
 751     }
 752     DYLIM.xwmin = val;
 753 }
 754
 755 /**************************************************************************/
 756
 757 Float_t TIsajet::GetXWMIN() const
 758 {
 759     return DYLIM.xwmin;
 760 }
 761
 762 /**************************************************************************/
 763
 764 void TIsajet::SetXWMAX(Float_t val)
 765 {
 766     if (val < DYLIM.xwmin) {
 767         printf("Error in TIsajet::SetXWMAX : \n");
 768         printf("You may not set XWMAX to a value less than XWMIN = %f.\n", DYLIM.xwmin);
 769         return;
 770     }
 771
 772     DYLIM.xwmax = val;
 773 }
 774
 775 /**************************************************************************/
 776
 777 Float_t TIsajet::GetXWMAX() const
 778 {
 779     return DYLIM.xwmax;
 780 }
 781
 782 /**************************************************************************/
 783
 784 void TIsajet::SetTHWMIN(Float_t val)
 785 {
 786     if (val > DYLIM.thwmax) {
 787         printf("Error in TIsajet::SetTHWMIN : \n");
 788         printf("You may not set THWMIN to a value larger than THWMAX = %f.\n", DYLIM.thwmax);
 789         return;
 790     }
 791
 792     if (DYLIM.ywset) {
 793         printf("Error in TIsajet::SetTHWMIN :\n");
 794         printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMIN.\n");
 795     }
 796     else {
 797         DYLIM.thwset = true;
 798         DYLIM.thwmin = val;
 799     }
 800 }
 801
 802 /**************************************************************************/
 803
 804 Float_t TIsajet::GetTHWMIN() const
 805 {
 806     return DYLIM.thwmin;
 807 }
 808
 809 /**************************************************************************/
 810
 811 void TIsajet::SetTHWMAX(Float_t val)
 812 {
 813     if (val < DYLIM.thwmin) {
 814         printf("Error in TIsajet::SetTHWMAX : \n");
 815         printf("You may not set THWMAX to a value less than THWMIN = %f.\n", DYLIM.thwmin);
 816         return;
 817     }
 818
 819     if (DYLIM.ywset) {
 820         printf("Error in TIsajet::SetTHWMAX :\n");
 821         printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMAX.\n");
 822     }
 823     else {
 824         DYLIM.thwset = true;
 825         DYLIM.thwmax = val;
 826     }
 827 }
 828
 829 /**************************************************************************/
 830
 831 Float_t TIsajet::GetTHWMAX() const
 832 {
 833     return DYLIM.thwmax;
 834 }
 835
 836 /**************************************************************************/
 837
 838 void TIsajet::SetTHWLIMS()
 839 {
 840     DYLIM.thwmin = 0;
 841     DYLIM.thwmax = TMath::Pi();
 842     DYLIM.thwset = false;
 843 }
 844
 845 /**************************************************************************/
 846
 847 void TIsajet::SetPHWMIN(Float_t val)
 848 {
 849     if (val > DYLIM.phwmax) {
 850         printf("Error in TIsajet::SetPHWMIN : \n");
 851         printf("You may not set PHWMIN to a value larger than PHWMAX = %f.\n", DYLIM.phwmax);
 852         return;
 853     }
 854     DYLIM.phwmin = val;
 855 }
 856
 857 /**************************************************************************/
 858
 859 Float_t TIsajet::GetPHWMIN() const
 860 {
 861     return DYLIM.phwmin;
 862 }
 863
 864 /**************************************************************************/
 865
 866 void TIsajet::SetPHWMAX(Float_t val)
 867 {
 868     if (val < DYLIM.phwmin) {
 869         printf("Error in TIsajet::SetPHWMAX : \n");
 870         printf("You may not set PHWMAX to a value less than PHWMIN = %f.\n", DYLIM.phwmin);
 871         return;
 872     }
 873
 874     DYLIM.phwmax = val;
 875 }
 876
 877 /**************************************************************************/
 878
 879 Float_t TIsajet::GetPHWMAX() const
 880 {
 881     return DYLIM.phwmax;
 882 }
 883
 884 /**************************************************************************/
 885
 886 Bool_t TIsajet::GetSETLMQ(Int_t index) const
 887 {
 888     Int_t length = (sizeof DYLIM.setlmq / sizeof DYLIM.setlmq[0]);
 889     if ((index < 0) || (index >= length)) {
 890         printf ("Error in TIsajet::GetSETLMQ : \n");
 891         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
 892         return 0;
 893     }
 894
 895     return DYLIM.setlmq[index];
 896 }
 897
 898 /**************************************************************************/
 899
 900 // End of DYLIM access.
 901 // Begins EEPAR access.
 902
 903 /**************************************************************************/
 904
 905 void TIsajet::SetPLEP(Float_t val)
 906 {
 907     EEPAR.plep = val;
 908 }
 909
 910 /**************************************************************************/
 911
 912 Float_t TIsajet::GetPLEP() const
 913 {
 914     return EEPAR.plep;
 915 }
 916
 917 /**************************************************************************/
 918
 919 void TIsajet::SetPLEM(Float_t val)
 920 {
 921     EEPAR.plem = val;
 922 }
 923
 924 /**************************************************************************/
 925
 926 Float_t TIsajet::GetPLEM() const
 927 {
 928     return EEPAR.plem;
 929 }
 930
 931 /**************************************************************************/
 932
 933 void TIsajet::SetRSHMIN(Float_t val)
 934 {
 935     if (val > EEPAR.rshmax) {
 936         printf("Error in TIsajet::SetRSHMIN : \n");
 937         printf("You may not set RSHMIN to a value larger than RSHMAX = %f.\n", EEPAR.rshmax);
 938         return;
 939     }
 940     EEPAR.rshmin = val;
 941 }
 942
 943 /**************************************************************************/
 944
 945 Float_t TIsajet::GetRSHMIN() const
 946 {
 947     return EEPAR.rshmin;
 948 }
 949
 950 /**************************************************************************/
 951
 952 void TIsajet::SetRSHMAX(Float_t val)
 953 {
 954     if (val < EEPAR.rshmin) {
 955         printf("Error in TIsajet::SetRSHMAX : \n");
 956         printf("You may not set RSHMAX to a value less than RSHMIN = %f.\n", EEPAR.rshmin);
 957         return;
 958     }
 959
 960     EEPAR.rshmax = val;
 961 }
 962
 963 /**************************************************************************/
 964
 965 Float_t TIsajet::GetRSHMAX() const
 966 {
 967     return EEPAR.rshmax;
 968 }
 969
 970 /**************************************************************************/
 971
 972 void TIsajet::SetUPSLON(Float_t val)
 973 {
 974     EEPAR.upslon = val;
 975 }
 976
 977 /**************************************************************************/
 978
 979 Float_t TIsajet::GetUPSLON() const
 980 {
 981     return EEPAR.upslon;
 982 }
 983
 984 /**************************************************************************/
 985
 986 void TIsajet::SetSIGZ(Float_t val)
 987 {
 988     EEPAR.sigz = val;
 989 }
 990
 991 /**************************************************************************/
 992
 993 Float_t TIsajet::GetSIGZ() const
 994 {
 995     return EEPAR.sigz;
 996 }
 997
 998 /**************************************************************************/
 999
1000 Bool_t TIsajet::GetIBREM() const
1001 {
1002     return EEPAR.ibrem;
1003 }
1004
1005 /**************************************************************************/
1006
1007 Bool_t TIsajet::GetIBEAM() const
1008 {
1009     return EEPAR.ibeam;
1010 }
1011
1012 /**************************************************************************/
1013
1014 Float_t TIsajet::GetSGMXEE() const
1015 {
1016     return EEPAR.sgmxee;
1017 }
1018
1019 /**************************************************************************/
1020
1021 // End of EEPAR access.
1022 // Begins FORCE access.
1023
1024 /**************************************************************************/
1025
1026 Int_t TIsajet::GetNFORCE() const
1027 {
1028     return FORCE.nforce;
1029 }
1030
1031 /**************************************************************************/
1032
1033 void TIsajet::SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti = true)
1034 {
1035     if (GetNFORCE() >= FORCE.mxforc - anti) {
1036         printf ("ERROR in TIsajet::SetIFORCE :\n");
1037         printf ("Cannot have more than %d forced decays.\n", FORCE.mxforc );
1038         return;
1039     }
1040
1041     if ((arraySize > 6) || (arraySize < 2)) {
1042         printf ("Error in TIsajet::SetIFORCE : \n");
1043         printf ("Invalid array size %d; must be 2-6.\n", arraySize);
1044         return;
1045     }
1046
1047     for (Int_t i = 0; i < FORCE.nforce; i++) {
1048         if (FORCE.iforce[i] == val[0]) {
1049             printf ("Error in TIsajet::SetIFORCE : \n");
1050             printf ("Particle %d has already been forced, index %d.\n", val[0], i);
1051             return;
1052         }
1053     }
1054
1055
1056     FORCE.iforce[FORCE.nforce] = val[0];
1057     for (Int_t i = 1; i < arraySize; i++) {
1058         FORCE.mforce[FORCE.nforce][i-1] = val[i];
1059     }
1060
1061     FORCE.nforce++;
1062
1063     printf ("Decay channel %d -> ", val[0]);
1064     for (Int_t i = 1; i < arraySize; i++) {
1065         printf ("%d, ", val[i]);
1066     }
1067     printf ("set. \n");
1068
1069     if (anti) {
1070         Int_t antivals[arraySize];
1071         for (Int_t i = 0; i < arraySize; i++){
1072             antivals[i] = (0 - val[i]);
1073         }
1074         SetIFORCE(antivals, arraySize, false);
1075     }
1076 }
1077
1078 /**************************************************************************/
1079
1080 void TIsajet::UnForce(Int_t index, Bool_t anti = true)
1081 {
1082     if (FORCE.nforce == 0) {
1083         printf ("Error in TIsajet::UnForce : \n");
1084         printf ("No decays have been forced.\n");
1085         return;
1086     }
1087
1088     if ((index < 0) || (index >= FORCE.nforce)) {
1089         printf ("Error in TIsajet::UnForce : \n");
1090         printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1091         return;
1092     }
1093
1094     Int_t particle_ID = FORCE.iforce[index];
1095
1096     for (Int_t i = index; i < FORCE.mxforc - 1; i++) {
1097         FORCE.iforce[i] = FORCE.iforce[i+1];
1098         for (Int_t j = 0; j < 5; j++) {
1099             FORCE.mforce[i][j] = FORCE.mforce[i+1][j];
1100         }
1101     }
1102     FORCE.iforce[FORCE.mxforc - 1] = 0;
1103     for (Int_t j = 0; j < 5; j++) {
1104         FORCE.mforce[FORCE.mxforc - 1][j] = 0;
1105     }
1106
1107     FORCE.nforce--;
1108
1109     printf ("Decay of %d unforced.\n", particle_ID);
1110
1111     if (anti) UnForceID(-particle_ID, false);
1112 }
1113
1114 /**************************************************************************/
1115
1116 void TIsajet::UnForceID(Int_t particle_ID, Bool_t anti = true)
1117 {
1118     if (FORCE.nforce == 0) {
1119         printf ("Error in TIsajet::UnForceID : \n");
1120         printf ("No decays have been forced.\n");
1121         return;
1122     }
1123
1124     for (Int_t i = 0; i < FORCE.nforce; i++) {
1125         if (FORCE.iforce[i] == particle_ID) {
1126             UnForce(i, anti);
1127             return;
1128         }
1129     }
1130
1131     printf ("Error in TIsajet::UnForceID : \n");
1132     printf ("Cannot find particle %d.\n", particle_ID);
1133 }
1134
1135 /**************************************************************************/
1136
1137 Int_t* TIsajet::GetIFORCE(Int_t index) const
1138 {
1139     if (FORCE.nforce == 0) {
1140         printf ("Error in TIsajet::GetIFORCE : \n");
1141         printf ("No decays have been forced.\n");
1142         return 0;
1143     }
1144
1145     if ((index < 0) || (index >= FORCE.nforce)) {
1146         printf ("Error in TIsajet::GetIFORCE : \n");
1147         printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1148         return 0;
1149     }
1150
1151     Int_t decay[6];
1152     decay[0] = FORCE.iforce[index];
1153
1154     for (Int_t i = 1; i < 6; i++) {
1155         decay[i] = FORCE.mforce[index][i-1];
1156     }
1157
1158     return decay;
1159 }
1160
1161 /**************************************************************************/
1162
1163 Int_t TIsajet::GetMEFORC(Int_t index) const
1164 {
1165     if (FORCE.nforce == 0) {
1166         printf ("Error in TIsajet::GetMEFORCE : \n");
1167         printf ("No decays have been forced.\n");
1168         return 0;
1169     }
1170
1171     if ((index < 0) || (index >= FORCE.nforce)) {
1172         printf ("Error in TIsajet::GetMEFORC : \n");
1173         printf ("Invalid array index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1174         return 0;
1175     }
1176
1177     return FORCE.meforc[index];
1178 }
1179
1180 /**************************************************************************/
1181
1182 // End of FORCE access.
1183 // Begins FRGPAR access.
1184
1185 /**************************************************************************/
1186
1187 void TIsajet::SetFRPAR(Float_t val, Int_t index)
1188 {
1189     Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1190     if ((index < 0) || (index >= length)) {
1191         printf ("Error in TIsajet::SetFRPAR : \n");
1192         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1193         return;
1194     }
1195
1196     *FRGPAR.frpar[index] = val;
1197     setFragment = true;
1198 }
1199
1200 /**************************************************************************/
1201
1202 void TIsajet::SetAllFRPAR(const Float_t val[], Int_t arraySize)
1203 {
1204     Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1205     if (arraySize != length) {
1206         printf ("Error in TIsajet::SetAllFRPAR : \n");
1207         printf ("Array must have %d elements.\n", length);
1208         return;
1209     }
1210
1211     for (Int_t i = 0; i < arraySize; i++) {
1212         SetFRPAR(val[i], i);
1213     }
1214 }
1215
1216 /**************************************************************************/
1217
1218 Float_t TIsajet::GetFRPAR(Int_t index) const
1219 {
1220     Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1221     if ((index < 0) || (index >= length)) {
1222         printf ("Error in TIsajet::GetFRPAR : \n");
1223         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1224         return 0;
1225     }
1226
1227     return *FRGPAR.frpar[index];
1228 }
1229
1230 /**************************************************************************/
1231
1232 void TIsajet::SetPUD(Float_t val)
1233 {
1234     SetFRPAR(val, 0);
1235 }
1236
1237 /**************************************************************************/
1238
1239 Float_t TIsajet::GetPUD() const
1240 {
1241     return GetFRPAR(0);
1242 }
1243
1244 /**************************************************************************/
1245
1246 void TIsajet::SetPBARY(Float_t val)
1247 {
1248     SetFRPAR(val, 1);
1249 }
1250
1251 /**************************************************************************/
1252
1253 Float_t TIsajet::GetPBARY() const
1254 {
1255     return GetFRPAR(1);
1256 }
1257
1258 /**************************************************************************/
1259
1260 void TIsajet::SetSIGQT(Float_t val)
1261 {
1262     SetFRPAR(val, 2);
1263 }
1264
1265 /**************************************************************************/
1266
1267 Float_t TIsajet::GetSIGQT() const
1268 {
1269     return GetFRPAR(2);
1270 }
1271
1272 /**************************************************************************/
1273
1274 void TIsajet::SetPEND(Float_t val)
1275 {
1276     SetFRPAR(val, 3);
1277 }
1278
1279 /**************************************************************************/
1280
1281 Float_t TIsajet::GetPEND() const
1282 {
1283     return GetFRPAR(3);
1284 }
1285
1286 /**************************************************************************/
1287
1288 void TIsajet::SetXGEN(Float_t val, Int_t index)
1289 {
1290     Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1291     if ((index < 0) || (index >= length)) {
1292         printf ("Error in TIsajet::SetXGEN : \n");
1293         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1294         return;
1295     }
1296     SetFRPAR(val, index + 4);
1297     setXgen = true;
1298 }
1299
1300 /**************************************************************************/
1301
1302 void TIsajet::SetAllXGEN(const Float_t val[], Int_t arraySize)
1303 {
1304     Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1305     if (arraySize != length) {
1306         printf ("Error in TIsajet::SetAllXGEN : \n");
1307         printf ("Array must have %d elements.\n", length);
1308         return;
1309     }
1310
1311     for (Int_t i = 0; i < arraySize; i++) {
1312         SetXGEN(val[i], i);
1313     }
1314 }
1315
1316 /**************************************************************************/
1317
1318 Float_t TIsajet::GetXGEN(Int_t index) const
1319 {
1320     Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1321     if ((index < 0) || (index >= length)) {
1322         printf ("Error in TIsajet::GetXGEN : \n");
1323         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1324         return 0;
1325     }
1326
1327     return GetFRPAR(index + 4);
1328 }
1329
1330 /**************************************************************************/
1331
1332 void TIsajet::SetPSPIN1(Float_t val, Int_t index)
1333 {
1334     Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
1335     if ((index < 0) || (index >= length)) {
1336         printf ("Error in TIsajet::SetPSPIN1 : \n");
1337         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1338         return;
1339     }
1340
1341     SetFRPAR(val, index + 12);
1342 }
1343
1344 /**************************************************************************/
1345
1346 void TIsajet::SetAllPSPIN1(const Float_t val[], Int_t arraySize)
1347 {
1348     Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
1349     if (arraySize != length) {
1350         printf ("Error in TIsajet::SetAllPSPIN1 : \n");
1351         printf ("Array must have %d elements.\n", length);
1352         return;
1353     }
1354
1355     for (Int_t i = 0; i < arraySize; i++) {
1356         SetPSPIN1(val[i], i);
1357     }
1358 }
1359
1360 /**************************************************************************/
1361
1362 Float_t TIsajet::GetPSPIN1(Int_t index) const
1363 {
1364     Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1365     if ((index < 0) || (index >= length)) {
1366         printf ("Error in TIsajet::GetPSPIN1 : \n");
1367         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1368         return 0;
1369     }
1370
1371     return GetFRPAR(index + 12);
1372 }
1373
1374 /**************************************************************************/
1375
1376 void TIsajet::SetPMIX1(Float_t val, Int_t index1, Int_t index2)
1377 {
1378     Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1379     Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1380
1381     if ((index1 < 0) || (index1 >= row_num)) {
1382         printf ("Error in TIsajet::SetPMIX1 : \n");
1383         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1384         return;
1385     }
1386
1387     if ((index2 < 0) || (index2 >= col_num)) {
1388         printf ("Error in TIsajet::SetPMIX1 : \n");
1389         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1390         return;
1391     }
1392
1393     FRGPAR.pmix1[index1][index2] = val;
1394     setFragment = true;
1395 }
1396
1397 /**************************************************************************/
1398
1399 void TIsajet::SetAllPMIX1(const Float_t val[2][3])
1400 {
1401     for (Int_t i = 0; i < 2; i++) {
1402         for (Int_t j = 0; j < 3; j++) {
1403             SetPMIX1(val[i][j], i, j);
1404         }
1405     }
1406 }
1407
1408 /**************************************************************************/
1409
1410 void TIsajet::SetColumnPMIX1(const Float_t val[], Int_t col)
1411 {
1412     Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1413     Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1414
1415     if ((col < 0) || (col >= col_num)) {
1416         printf ("Error in TIsajet::SetColumnPMIX1 : \n");
1417         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
1418         return;
1419     }
1420
1421     for (Int_t i = 0; i < row_num; i++) {
1422         SetPMIX1(val[i], i, col);
1423     }
1424 }
1425
1426 /**************************************************************************/
1427
1428 Float_t TIsajet::GetPMIX1(Int_t index1, Int_t index2) const
1429 {
1430     Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1431     Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1432
1433     if ((index1 < 0) || (index1 >= row_num)) {
1434         printf ("Error in TIsajet::GetPMIX1 : \n");
1435         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1436         return 0;
1437     }
1438
1439     if ((index2 < 0) || (index2 >= col_num)) {
1440         printf ("Error in TIsajet::GetPMIX1 : \n");
1441         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1442         return 0;
1443     }
1444
1445     return FRGPAR.pmix1[index1][index2];
1446 }
1447
1448 /**************************************************************************/
1449
1450 void TIsajet::SetPMIX2(Float_t val, Int_t index1, Int_t index2)
1451 {
1452     Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1453     Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1454
1455     if ((index1 < 0) || (index1 >= row_num)) {
1456         printf ("Error in TIsajet::SetPMIX2 : \n");
1457         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1458         return;
1459     }
1460
1461     if ((index2 < 0) || (index2 >= col_num)) {
1462         printf ("Error in TIsajet::SetPMIX2 : \n");
1463         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1464         return;
1465     }
1466
1467     FRGPAR.pmix2[index1][index2] = val;
1468     setFragment = true;
1469 }
1470
1471 /**************************************************************************/
1472
1473 void TIsajet::SetAllPMIX2(const Float_t val[2][3])
1474 {
1475     for (Int_t i = 0; i < 2; i++) {
1476         for (Int_t j = 0; j < 3; j++) {
1477             SetPMIX2(val[i][j], i, j);
1478         }
1479     }
1480 }
1481
1482 /**************************************************************************/
1483
1484 void TIsajet::SetColumnPMIX2(const Float_t val[], Int_t col)
1485 {
1486     Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1487     Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1488
1489     if ((col < 0) || (col >= col_num)) {
1490         printf ("Error in TIsajet::SetColumnPMIX2 : \n");
1491         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
1492         return;
1493     }
1494
1495     for (Int_t i = 0; i < row_num; i++) {
1496         SetPMIX2(val[i], i, col);
1497     }
1498 }
1499
1500 /**************************************************************************/
1501
1502 Float_t TIsajet::GetPMIX2(Int_t index1, Int_t index2) const
1503 {
1504     Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1505     Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1506
1507     if ((index1 < 0) || (index1 >= row_num)) {
1508         printf ("Error in TIsajet::GetPMIX2 : \n");
1509         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1510         return 0;
1511     }
1512
1513     if ((index2 < 0) || (index2 >= col_num)) {
1514         printf ("Error in TIsajet::GetPMIX2 : \n");
1515         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1516         return 0;
1517     }
1518
1519     return FRGPAR.pmix2[index1][index2];
1520 }
1521
1522 /**************************************************************************/
1523
1524 void TIsajet::SetPMIXX1(Float_t val, Int_t index)
1525 {
1526     Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1527     if ((index < 0) || (index >= length)) {
1528         printf ("Error in TIsajet::SetPMIXX1 : \n");
1529         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1530         return;
1531     }
1532
1533     *FRGPAR.pmixx1[index] = val;
1534     setFragment = true;
1535 }
1536
1537 /**************************************************************************/
1538
1539 void TIsajet::SetAllPMIXX1(const Float_t val[], Int_t arraySize)
1540 {
1541     Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1542     if (arraySize != length) {
1543         printf ("Error in TIsajet::SetAllPMIXX1 : \n");
1544         printf ("Array must have %d elements.\n", length);
1545         return;
1546     }
1547
1548     for (Int_t i = 0; i < arraySize; i++) {
1549         SetPMIXX1(val[i], i);
1550     }
1551 }
1552
1553 /**************************************************************************/
1554
1555 Float_t TIsajet::GetPMIXX1(Int_t index) const
1556 {
1557     Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1558     if ((index < 0) || (index >= length)) {
1559         printf ("Error in TIsajet::GetPMIXX1 : \n");
1560         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1561         return 0;
1562     }
1563
1564     return *FRGPAR.pmixx1[index];
1565 }
1566
1567 /**************************************************************************/
1568
1569 void TIsajet::SetPMIXX2(Float_t val, Int_t index)
1570 {
1571     Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1572     if ((index < 0) || (index >= length)) {
1573         printf ("Error in TIsajet::SetPMIXX2 : \n");
1574         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1575         return;
1576     }
1577
1578     *FRGPAR.pmixx2[index] = val;
1579     setFragment = true;
1580 }
1581
1582 /**************************************************************************/
1583
1584 void TIsajet::SetAllPMIXX2(const Float_t val[], Int_t arraySize)
1585 {
1586     Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1587     if (arraySize != length) {
1588         printf ("Error in TIsajet::SetAllPMIXX2 : \n");
1589         printf ("Array must have %d elements.\n", length);
1590         return;
1591     }
1592
1593     for (Int_t i = 0; i < arraySize; i++) {
1594         SetPMIXX2(val[i], i);
1595     }
1596 }
1597
1598 /**************************************************************************/
1599
1600 Float_t TIsajet::GetPMIXX2(Int_t index) const
1601 {
1602     Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1603     if ((index < 0) || (index >= length)) {
1604         printf ("Error in TIsajet::GetPMIXX2 : \n");
1605         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1606         return 0;
1607     }
1608
1609     return *FRGPAR.pmixx2[index];
1610 }
1611
1612 /**************************************************************************/
1613
1614 void TIsajet::SetXGENSS(Float_t val, Int_t index)
1615 {
1616     Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1617     if ((index < 0) || (index >= length)) {
1618         printf ("Error in TIsajet::SetXGENSS : \n");
1619         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1620         return;
1621     }
1622
1623      FRGPAR.xgenss[index] = val;
1624 }
1625
1626 /**************************************************************************/
1627
1628 void TIsajet::SetAllXGENSS(const Float_t val[], Int_t arraySize)
1629 {
1630     Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1631     if (arraySize != length) {
1632         printf ("Error in TIsajet::SetAllXGENSS : \n");
1633         printf ("Array must have %d elements.\n", length);
1634         return;
1635     }
1636
1637     for (Int_t i = 0; i < arraySize; i++) {
1638         SetXGENSS(val[i], i);
1639     }
1640 }
1641
1642 /**************************************************************************/
1643
1644 Float_t TIsajet::GetXGENSS(Int_t index) const
1645 {
1646     Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1647     if ((index < 0) || (index >= length)) {
1648         printf ("Error in TIsajet::GetXGENSS : \n");
1649         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1650         return 0;
1651     }
1652
1653     return FRGPAR.xgenss[index];
1654 }
1655
1656 /**************************************************************************/
1657
1658 // End of FRGPAR access.
1659 // Begins HCON access.
1660
1661 /**************************************************************************/
1662
1663 Float_t TIsajet::GetANWWWW(Int_t index1, Int_t index2, Int_t index3) const
1664 {
1665     Int_t elem_Size = sizeof HCON.anwwww[0][0][0];
1666     Int_t thd_Dim_Length = (sizeof HCON.anwwww[0][0] / elem_Size);
1667     Int_t sec_Dim_Length = (sizeof HCON.anwwww[0] / (elem_Size * thd_Dim_Length));
1668     Int_t fst_Dim_Length = (sizeof HCON.anwwww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
1669
1670     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1671         printf ("Error in TIsajet::GetANWWWW : \n");
1672         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1673         return 0;
1674     }
1675
1676     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1677         printf ("Error in TIsajet::GetANWWWW : \n");
1678         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1679         return 0;
1680     }
1681
1682     if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
1683         printf ("Error in TIsajet::GetANWWWW : \n");
1684         printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
1685         return 0;
1686     }
1687
1688     return HCON.anwwww[index1][index2][index3];
1689 }
1690
1691 /**************************************************************************/
1692
1693 Float_t TIsajet::GetADWWWW(Int_t index1, Int_t index2) const
1694 {
1695     Int_t elem_Size = sizeof HCON.adwwww[0][0];
1696     Int_t sec_Dim_Length = (sizeof HCON.adwwww[0] / elem_Size);
1697     Int_t fst_Dim_Length = (sizeof HCON.adwwww / (elem_Size * sec_Dim_Length));
1698
1699     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1700         printf ("Error in TIsajet::GetADWWWW : \n");
1701         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1702         return 0;
1703     }
1704
1705     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1706         printf ("Error in TIsajet::GetADWWWW : \n");
1707         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1708         return 0;
1709     }
1710
1711     return HCON.adwwww[index1][index2];
1712 }
1713
1714 /**************************************************************************/
1715
1716 Float_t TIsajet::GetAIWWWW(Int_t index) const
1717 {
1718     Int_t length = (sizeof HCON.aiwwww / sizeof HCON.aiwwww[0]);
1719     if ((index < 0) || (index >= length)) {
1720         printf ("Error in TIsajet::GetAIWWWW : \n");
1721         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1722         return 0;
1723     }
1724
1725     return HCON.aiwwww[index];
1726 }
1727
1728 /**************************************************************************/
1729
1730 Float_t TIsajet::GetHMASS() const
1731 {
1732     return HCON.hmass;
1733 }
1734
1735 /**************************************************************************/
1736
1737 Float_t TIsajet::GetHGAM() const
1738 {
1739     return HCON.hgam;
1740 }
1741
1742 /**************************************************************************/
1743
1744 Float_t TIsajet::GetHGAMS(Int_t index) const
1745 {
1746     Int_t length = (sizeof HCON.hgams / sizeof HCON.hgams[0]);
1747     if ((index < 0) || (index >= length)) {
1748         printf ("Error in TIsajet::GetHGAMS : \n");
1749         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1750         return 0;
1751     }
1752
1753     return HCON.hgams[index];
1754 }
1755
1756 /**************************************************************************/
1757
1758 Float_t TIsajet::GetETAHGG() const
1759 {
1760     return HCON.etahgg;
1761 }
1762
1763 /**************************************************************************/
1764
1765 Int_t TIsajet::GetMATCHH(Int_t index) const
1766 {
1767     Int_t length = (sizeof HCON.matchh / sizeof HCON.matchh[0]);
1768     if ((index < 0) || (index >= length)) {
1769         printf ("Error in TIsajet::GetMATCHH : \n");
1770         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1771         return 0;
1772     }
1773
1774     return HCON.matchh[index];
1775 }
1776
1777 /**************************************************************************/
1778
1779 Float_t TIsajet::GetZSTARS(Int_t index1, Int_t index2) const
1780 {
1781     Int_t elem_Size = sizeof HCON.zstars[0][0];
1782     Int_t sec_Dim_Length = (sizeof HCON.zstars[0] / elem_Size);
1783     Int_t fst_Dim_Length = (sizeof HCON.zstars / (elem_Size * sec_Dim_Length));
1784
1785     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1786         printf ("Error in TIsajet::GetZSTARS : \n");
1787         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1788         return 0;
1789     }
1790
1791     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1792         printf ("Error in TIsajet::GetZSTARS : \n");
1793         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1794         return 0;
1795     }
1796
1797     return HCON.zstars[index1][index2];
1798 }
1799
1800 /**************************************************************************/
1801
1802 void TIsajet::SetIHTYPE(Int_t val)
1803 {
1804     if ((val < 82) || (val > 84)) {
1805         printf ("Error in TIsajet::SetIHTYPE : \n");
1806         printf ("Invalid input value %d. Possible values are 82, 83, 84.\n", val);
1807         return;
1808     }
1809
1810     HCON.ihtype = val;
1811 }
1812
1813 /**************************************************************************/
1814
1815 void TIsajet::SetIHTYPE(Char_t val[])
1816 {
1817     if (!strcmp("HL0", val)) {
1818         HCON.ihtype = 82;
1819     }
1820     else if (!strcmp("HH0", val)) {
1821         HCON.ihtype = 83;
1822     }
1823     else if (!strcmp("HA0", val)){
1824         HCON.ihtype = 84;
1825     }
1826     else {
1827         printf ("Error in TIsajet::SetIHTYPE : \n");
1828         printf ("Invalid input string %s. Possible strings are HL0, HH0, HA0.\n", val);
1829     }
1830 }
1831
1832 /**************************************************************************/
1833
1834 Int_t TIsajet::GetIHTYPE() const
1835 {
1836     return HCON.ihtype;
1837 }
1838
1839 /**************************************************************************/
1840
1841 Float_t TIsajet::GetHGAMSS(Int_t index1, Int_t index2) const
1842 {
1843     Int_t elem_Size = sizeof HCON.hgamss[0][0];
1844     Int_t sec_Dim_Length = (sizeof HCON.hgamss[0] / elem_Size);
1845     Int_t fst_Dim_Length = (sizeof HCON.hgamss / (elem_Size * sec_Dim_Length));
1846
1847     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1848         printf ("Error in TIsajet::GetHGAMSS : \n");
1849         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1850         return 0;
1851     }
1852
1853     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1854         printf ("Error in TIsajet::GetHGAMSS : \n");
1855         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1856         return 0;
1857     }
1858
1859     return HCON.hgamss[index1][index2];
1860 }
1861
1862 /**************************************************************************/
1863
1864 // End of HCON access
1865 // Begins JETLIM access
1866
1867 /**************************************************************************/
1868
1869 void TIsajet::SetPMIN(Float_t val, Int_t index)
1870 {
1871     Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1872     if ((index < 0) || (index >= length)) {
1873         printf ("Error in TIsajet::SetPMIN : \n");
1874         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1875         return;
1876     }
1877
1878     if (val > JETLIM.pmax[index]) {
1879         printf("Error in TIsajet::SetPMIN : \n");
1880         printf("You may not set PMIN to a value larger than PMAX = %f.\n", JETLIM.pmax[index]);
1881         return;
1882     }
1883
1884     JETLIM.pmin[index] = val;
1885     setP = true;
1886 }
1887
1888 /**************************************************************************/
1889
1890 void TIsajet::SetAllPMIN(const Float_t val[], Int_t arraySize)
1891 {
1892     Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1893     if (arraySize != length) {
1894         printf ("Error in TIsajet::SetAllPMIN : \n");
1895         printf ("Array must have %d elements.\n", length);
1896         return;
1897     }
1898
1899     for (Int_t i = 0; i < arraySize; i++) {
1900         SetPMIN(val[i], i);
1901     }
1902 }
1903
1904 /**************************************************************************/
1905
1906 Float_t TIsajet::GetPMIN(Int_t index) const
1907 {
1908     Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1909     if ((index < 0) || (index >= length)) {
1910         printf ("Error in TIsajet::GetPMIN : \n");
1911         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1912         return 0;
1913     }
1914
1915     return JETLIM.pmin[index];
1916 }
1917
1918 /**************************************************************************/
1919
1920 void TIsajet::SetPMAX(Float_t val, Int_t index)
1921 {
1922     Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1923     if ((index < 0) || (index >= length)) {
1924         printf ("Error in TIsajet::SetPMAX : \n");
1925         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1926         return;
1927     }
1928
1929     if (val < JETLIM.pmin[index]) {
1930         printf("Error in TIsajet::SetPMAX : \n");
1931         printf("You may not set PMAX to a value larger than PMIN = %f.\n", JETLIM.pmin[index]);
1932         return;
1933     }
1934
1935     JETLIM.pmax[index] = val;
1936     setP = true;
1937 }
1938
1939 /**************************************************************************/
1940
1941 void TIsajet::SetAllPMAX(const Float_t val[], Int_t arraySize)
1942 {
1943     Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1944     if (arraySize != length) {
1945         printf ("Error in TIsajet::SetAllPMAX : \n");
1946         printf ("Array must have %d elements.\n", length);
1947         return;
1948     }
1949
1950     for (Int_t i = 0; i < arraySize; i++) {
1951         SetPMAX(val[i], i);
1952     }
1953 }
1954
1955 /**************************************************************************/
1956
1957 Float_t TIsajet::GetPMAX(Int_t index) const
1958 {
1959     Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1960     if ((index < 0) || (index >= length)) {
1961         printf ("Error in TIsajet::GetPMAX : \n");
1962         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1963         return 0;
1964     }
1965
1966     return JETLIM.pmax[index];
1967 }
1968
1969 /**************************************************************************/
1970
1971 void TIsajet::SetPTMIN(Float_t val, Int_t index)
1972 {
1973     Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
1974     if ((index < 0) || (index >= length)) {
1975         printf ("Error in TIsajet::SetPTMIN : \n");
1976         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1977         return;
1978     }
1979 /* andreas 7/8/2001
1980     if (val > JETLIM.ptmax[index]) {
1981         printf("Error in TIsajet::SetPTMIN : \n");
1982         printf("You may not set PTMIN to a value larger than PTMAX = %f.\n", JETLIM.ptmax[index]);
1983         return;
1984     }
1985 */
1986      JETLIM.ptmin[index] = val;
1987 //     if (!setY) SetYJLIMS();
1988 //     if (!setTheta) SetTHLIMS();
1989      setPt = true;
1990 }
1991
1992 /**************************************************************************/
1993
1994 void TIsajet::SetAllPTMIN(const Float_t val[], Int_t arraySize)
1995 {
1996     Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
1997     if (arraySize != length) {
1998         printf ("Error in TIsajet::SetAllPTMIN : \n");
1999         printf ("Array must have %d elements.\n", length);
2000         return;
2001     }
2002
2003     for (Int_t i = 0; i < arraySize; i++) {
2004         SetPTMIN(val[i], i);
2005     }
2006 }
2007
2008 /**************************************************************************/
2009
2010 Float_t TIsajet::GetPTMIN(Int_t index) const
2011 {
2012     Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
2013     if ((index < 0) || (index >= length)) {
2014         printf ("Error in TIsajet::GetPTMIN : \n");
2015         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2016         return 0;
2017     }
2018
2019     return JETLIM.ptmin[index];
2020 }
2021
2022 /**************************************************************************/
2023
2024 void TIsajet::SetPTMAX(Float_t val, Int_t index)
2025 {
2026     Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2027     if ((index < 0) || (index >= length)) {
2028         printf ("Error in TIsajet::SetPTMAX : \n");
2029         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2030         return;
2031     }
2032
2033     if (val < JETLIM.ptmin[index]) {
2034         printf("Error in TIsajet::SetPTMAX : \n");
2035         printf("You may not set PTMAX to a value larger than PTMIN = %f.\n", JETLIM.ptmin[index]);
2036         return;
2037     }
2038
2039     JETLIM.ptmax[index] = val;
2040     setPt = true;
2041 }
2042
2043 /**************************************************************************/
2044
2045 void TIsajet::SetAllPTMAX(const Float_t val[], Int_t arraySize)
2046 {
2047     Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2048     if (arraySize != length) {
2049         printf ("Error in TIsajet::SetAllPTMAX : \n");
2050         printf ("Array must have %d elements.\n", length);
2051         return;
2052     }
2053
2054     for (Int_t i = 0; i < arraySize; i++) {
2055         SetPTMAX(val[i], i);
2056     }
2057 }
2058
2059 /**************************************************************************/
2060
2061 Float_t TIsajet::GetPTMAX(Int_t index) const
2062 {
2063     Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2064     if ((index < 0) || (index >= length)) {
2065         printf ("Error in TIsajet::GetPTMAX : \n");
2066         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2067         return 0;
2068     }
2069
2070     return JETLIM.ptmax[index];
2071 }
2072
2073 /**************************************************************************/
2074
2075 void TIsajet::SetYJMIN(Float_t val, Int_t index)
2076 {
2077     Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2078     if ((index < 0) || (index >= length)) {
2079         printf ("Error in TIsajet::SetYJMIN : \n");
2080         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2081         return;
2082     }
2083
2084     if (val > JETLIM.yjmax[index]) {
2085         printf("Error in TIsajet::SetYJMIN : \n");
2086         printf("You may not set YJMIN to a value larger than YJMAX = %f.\n", JETLIM.yjmax[index]);
2087         return;
2088     }
2089
2090     if (setTheta) {
2091         printf("Error in TIsajet::SetYJMIN :\n");
2092         printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMIN.\n");
2093         return;
2094     }
2095
2096     setY =  true;
2097     JETLIM.yjmin[index] = val;
2098 }
2099
2100 /**************************************************************************/
2101
2102 void TIsajet::SetAllYJMIN(const Float_t val[], Int_t arraySize)
2103 {
2104     Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2105     if (arraySize != length) {
2106         printf ("Error in TIsajet::SetAllYJMIN : \n");
2107         printf ("Array must have %d elements.\n", length);
2108         return;
2109     }
2110
2111     for (Int_t i = 0; i < arraySize; i++) {
2112         SetYJMIN(val[i], i);
2113     }
2114 }
2115
2116 /**************************************************************************/
2117
2118 Float_t TIsajet::GetYJMIN(Int_t index) const
2119 {
2120     Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2121     if ((index < 0) || (index >= length)) {
2122         printf ("Error in TIsajet::GetYJMIN : \n");
2123         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2124         return 0;
2125     }
2126
2127     return JETLIM.yjmin[index];
2128 }
2129
2130 /**************************************************************************/
2131
2132 void TIsajet::SetYJMAX(Float_t val, Int_t index)
2133 {
2134     Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2135     if ((index < 0) || (index >= length)) {
2136         printf ("Error in TIsajet::SetYJMAX : \n");
2137         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2138         return;
2139     }
2140
2141     if (val < JETLIM.yjmin[index]) {
2142         printf("Error in TIsajet::SetYJMAX : \n");
2143         printf("You may not set YJMAX to a value larger than YJMIN = %f.\n", JETLIM.yjmin[index]);
2144         return;
2145     }
2146
2147     if (setTheta) {
2148         printf("Error in TIsajet::SetYJMAX :\n");
2149         printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMAX.\n");
2150         return;
2151     }
2152
2153     setY = true;
2154     JETLIM.yjmax[index] = val;
2155 }
2156
2157 /**************************************************************************/
2158
2159 void TIsajet::SetAllYJMAX(const Float_t val[], Int_t arraySize)
2160 {
2161     Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2162     if (arraySize != length) {
2163         printf ("Error in TIsajet::SetAllYJMAX : \n");
2164         printf ("Array must have %d elements.\n", length);
2165         return;
2166     }
2167
2168     for (Int_t i = 0; i < arraySize; i++) {
2169         SetYJMAX(val[i], i);
2170     }
2171 }
2172
2173 /**************************************************************************/
2174
2175 Float_t TIsajet::GetYJMAX(Int_t index) const
2176 {
2177     Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2178     if ((index < 0) || (index >= length)) {
2179         printf ("Error in TIsajet::GetYJMAX : \n");
2180         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2181         return 0;
2182     }
2183
2184     return JETLIM.yjmax[index];
2185 }
2186
2187 /**************************************************************************/
2188
2189 void TIsajet::SetYJLIMS()
2190 {
2191     for (Int_t i = 0; i < JETLIM.mxlim; i++) {
2192         JETLIM.yjmax[i] = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
2193         JETLIM.yjmax[i] = -JETLIM.yjmin[i];
2194     }
2195     setY = false;
2196 }
2197
2198 /**************************************************************************/
2199
2200 void TIsajet::SetPHIMIN(Float_t val, Int_t index)
2201 {
2202     Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2203     if ((index < 0) || (index >= length)) {
2204         printf ("Error in TIsajet::SetPHIMIN : \n");
2205         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2206         return;
2207     }
2208
2209     if (val > JETLIM.phimax[index]) {
2210         printf("Error in TIsajet::SetPHIMIN : \n");
2211         printf("You may not set PHIMIN to a value larger than PHIMAX = %f.\n", JETLIM.phimax[index]);
2212         return;
2213     }
2214
2215     JETLIM.phimin[index] = val;
2216     setPhi = true;
2217 }
2218
2219 /**************************************************************************/
2220
2221 void TIsajet::SetAllPHIMIN(const Float_t val[], Int_t arraySize)
2222 {
2223     Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2224     if (arraySize != length) {
2225         printf ("Error in TIsajet::SetAllPHIMIN : \n");
2226         printf ("Array must have %d elements.\n", length);
2227         return;
2228     }
2229
2230     for (Int_t i = 0; i < arraySize; i++) {
2231         SetPHIMIN(val[i], i);
2232     }
2233 }
2234
2235 /**************************************************************************/
2236
2237 Float_t TIsajet::GetPHIMIN(Int_t index) const
2238 {
2239     Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2240     if ((index < 0) || (index >= length)) {
2241         printf ("Error in TIsajet::GetPHIMIN : \n");
2242         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2243         return 0;
2244     }
2245
2246     return JETLIM.phimin[index];
2247 }
2248
2249 /**************************************************************************/
2250
2251 void TIsajet::SetPHIMAX(Float_t val, Int_t index)
2252 {
2253     Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2254     if ((index < 0) || (index >= length)) {
2255         printf ("Error in TIsajet::SetPHIMAX : \n");
2256         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2257         return;
2258     }
2259
2260     if (val < JETLIM.phimin[index]) {
2261         printf("Error in TIsajet::SetPHIMAX : \n");
2262         printf("You may not set PHIMAX to a value larger than PHIMIN = %f.\n", JETLIM.phimin[index]);
2263         return;
2264     }
2265
2266     JETLIM.phimax[index] = val;
2267     setPhi = true;
2268 }
2269
2270 /**************************************************************************/
2271
2272 void TIsajet::SetAllPHIMAX(const Float_t val[], Int_t arraySize)
2273 {
2274     Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2275     if (arraySize != length) {
2276         printf ("Error in TIsajet::SetAllPHIMAX : \n");
2277         printf ("Array must have %d elements.\n", length);
2278         return;
2279     }
2280
2281     for (Int_t i = 0; i < arraySize; i++) {
2282         SetPHIMAX(val[i], i);
2283     }
2284 }
2285
2286 /**************************************************************************/
2287
2288 Float_t TIsajet::GetPHIMAX(Int_t index) const
2289 {
2290     Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2291     if ((index < 0) || (index >= length)) {
2292         printf ("Error in TIsajet::GetPHIMAX : \n");
2293         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2294         return 0;
2295     }
2296
2297     return JETLIM.phimax[index];
2298 }
2299
2300 /**************************************************************************/
2301
2302 void TIsajet::SetXJMIN(Float_t val, Int_t index)
2303 {
2304     Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2305     if ((index < 0) || (index >= length)) {
2306         printf ("Error in TIsajet::SetXJMIN : \n");
2307         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2308         return;
2309     }
2310     if (val > JETLIM.xjmax[index]) {
2311         printf("Error in TIsajet::SetXJMIN : \n");
2312         printf("You may not set XJMIN to a value larger than XJMAX = %f.\n", JETLIM.xjmax[index]);
2313         return;
2314     }
2315
2316     JETLIM.xjmin[index] = val;
2317     setX = true;
2318 }
2319
2320 /**************************************************************************/
2321
2322 void TIsajet::SetAllXJMIN(const Float_t val[], Int_t arraySize)
2323 {
2324     Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2325     if (arraySize != length) {
2326         printf ("Error in TIsajet::SetAllXJMIN : \n");
2327         printf ("Array must have %d elements.\n", length);
2328         return;
2329     }
2330
2331     for (Int_t i = 0; i < arraySize; i++) {
2332         SetXJMIN(val[i], i);
2333     }
2334 }
2335
2336 /**************************************************************************/
2337
2338 Float_t TIsajet::GetXJMIN(Int_t index) const
2339 {
2340     Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2341     if ((index < 0) || (index >= length)) {
2342         printf ("Error in TIsajet::GetXJMIN : \n");
2343         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2344         return 0;
2345     }
2346
2347     return JETLIM.xjmin[index];
2348 }
2349
2350 /**************************************************************************/
2351
2352 void TIsajet::SetXJMAX(Float_t val, Int_t index)
2353 {
2354     Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2355     if ((index < 0) || (index >= length)) {
2356         printf ("Error in TIsajet::SetXJMAX : \n");
2357         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2358         return;
2359     }
2360
2361     if (val < JETLIM.xjmin[index]) {
2362         printf("Error in TIsajet::SetXJMAX : \n");
2363         printf("You may not set XJMAX to a value larger than XJMIN = %f.\n", JETLIM.xjmin[index]);
2364         return;
2365     }
2366
2367     JETLIM.xjmax[index] = val;
2368     setX = true;
2369 }
2370
2371 /**************************************************************************/
2372
2373 void TIsajet::SetAllXJMAX(const Float_t val[], Int_t arraySize)
2374 {
2375     Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2376     if (arraySize != length) {
2377         printf ("Error in TIsajet::SetAllXJMAX : \n");
2378         printf ("Array must have %d elements.\n", length);
2379         return;
2380     }
2381
2382     for (Int_t i = 0; i < arraySize; i++) {
2383         SetXJMAX(val[i], i);
2384     }
2385 }
2386
2387 /**************************************************************************/
2388
2389 Float_t TIsajet::GetXJMAX(Int_t index) const
2390 {
2391     Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2392     if ((index < 0) || (index >= length)) {
2393         printf ("Error in TIsajet::GetXJMAX : \n");
2394         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2395         return 0;
2396     }
2397
2398     return JETLIM.xjmax[index];
2399 }
2400
2401 /**************************************************************************/
2402
2403 void TIsajet::SetTHMIN(Float_t val, Int_t index)
2404 {
2405     Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2406     if ((index < 0) || (index >= length)) {
2407         printf ("Error in TIsajet::SetTHMIN : \n");
2408         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2409         return;
2410     }
2411
2412     if (val > JETLIM.thmax[index]) {
2413         printf("Error in TIsajet::SetTHMIN : \n");
2414         printf("You may not set THMIN to a value larger than THMAX = %f.\n", JETLIM.thmax[index]);
2415         return;
2416     }
2417
2418     if (setY) {
2419         printf("Error in TIsajet::SetTHMIN :\n");
2420         printf("May not set both theta and y limits. Use SetYJLIMS, then set THMIN.\n");
2421         return;
2422     }
2423
2424     setTheta = true;
2425     JETLIM.thmin[index] = val;
2426
2427 }
2428
2429 /**************************************************************************/
2430
2431 void TIsajet::SetAllTHMIN(const Float_t val[], Int_t arraySize)
2432 {
2433     Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2434     if (arraySize != length) {
2435         printf ("Error in TIsajet::SetAllTHMIN : \n");
2436         printf ("Array must have %d elements.\n", length);
2437         return;
2438     }
2439
2440     for (Int_t i = 0; i < arraySize; i++) {
2441         SetTHMIN(val[i], i);
2442     }
2443 }
2444
2445 /**************************************************************************/
2446
2447 Float_t TIsajet::GetTHMIN(Int_t index) const
2448 {
2449     Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2450     if ((index < 0) || (index >= length)) {
2451         printf ("Error in TIsajet::GetTHMIN : \n");
2452         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2453         return 0;
2454     }
2455
2456     return JETLIM.thmin[index];
2457 }
2458
2459 /**************************************************************************/
2460
2461 void TIsajet::SetTHMAX(Float_t val, Int_t index)
2462 {
2463     Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2464     if ((index < 0) || (index >= length)) {
2465         printf ("Error in TIsajet::SetTHMAX : \n");
2466         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2467         return;
2468     }
2469
2470     if (val < JETLIM.thmin[index]) {
2471         printf("Error in TIsajet::SetTHMAX : \n");
2472         printf("You may not set THMAX to a value larger than THMIN = %f.\n", JETLIM.thmin[index]);
2473         return;
2474     }
2475
2476     if (setY) {
2477         printf("Error in TIsajet::SetTHMAX :\n");
2478         printf("May not set both theta and y limits. Use SetYJLIMS, then set THMAX.\n");
2479         return;
2480     }
2481
2482     setTheta = true;
2483     JETLIM.thmax[index] = val;
2484 }
2485
2486 /**************************************************************************/
2487
2488 void TIsajet::SetAllTHMAX(const Float_t val[], Int_t arraySize)
2489 {
2490     Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2491     if (arraySize != length) {
2492         printf ("Error in TIsajet::SetAllTHMAX : \n");
2493         printf ("Array must have %d elements.\n", length);
2494         return;
2495     }
2496
2497     for (Int_t i = 0; i < arraySize; i++) {
2498         SetTHMAX(val[i], i);
2499     }
2500 }
2501
2502 /**************************************************************************/
2503
2504 Float_t TIsajet::GetTHMAX(Int_t index) const
2505 {
2506     Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2507     if ((index < 0) || (index >= length)) {
2508         printf ("Error in TIsajet::GetTHMAX : \n");
2509         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2510         return 0;
2511     }
2512
2513     return JETLIM.thmax[index];
2514 }
2515
2516 /**************************************************************************/
2517
2518 void TIsajet::SetTHLIMS()
2519 {
2520     Float_t tmin;
2521     for (Int_t i = 0; i < JETLIM.mxlim; i++) {
2522         tmin = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
2523         JETLIM.thmin[i] = 2*atan(exp(tmin));
2524         JETLIM.thmax[i] = 2*atan(exp(-tmin));
2525     }
2526     setTheta = false;
2527 }
2528
2529 /**************************************************************************/
2530
2531 Bool_t TIsajet::GetSETLMJ(Int_t index) const
2532 {
2533     Int_t length = (sizeof JETLIM.setlmj / sizeof JETLIM.setlmj[0]);
2534     if ((index < 0) || (index >= length)) {
2535         printf ("Error in TIsajet::GetSETLMJ : \n");
2536         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2537         return 0;
2538     }
2539
2540     return JETLIM.setlmj[index];
2541 }
2542
2543 /**************************************************************************/
2544
2545 // Ends JETLIM access.
2546 // Begins JETPAR access.
2547
2548 /**************************************************************************/
2549
2550 Float_t TIsajet::GetP(Int_t index) const
2551 {
2552     Int_t length = (sizeof JETPAR.p / sizeof JETPAR.p[0]);
2553     if ((index < 0) || (index >= length)) {
2554         printf ("Error in TIsajet::GetP : \n");
2555         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2556         return 0;
2557     }
2558
2559     return JETPAR.p[index];
2560 }
2561
2562 /**************************************************************************/
2563
2564 Float_t TIsajet::GetPT(Int_t index) const
2565 {
2566     Int_t length = (sizeof JETPAR.pt / sizeof JETPAR.pt[0]);
2567     if ((index < 0) || (index >= length)) {
2568         printf ("Error in TIsajet::GetPT : \n");
2569         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2570         return 0;
2571     }
2572
2573     return JETPAR.pt[index];
2574 }
2575
2576 /**************************************************************************/
2577
2578 Float_t TIsajet::GetYJ(Int_t index) const
2579 {
2580     Int_t length = (sizeof JETPAR.yj / sizeof JETPAR.yj[0]);
2581     if ((index < 0) || (index >= length)) {
2582         printf ("Error in TIsajet::GetYJ : \n");
2583         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2584         return 0;
2585     }
2586
2587     return JETPAR.yj[index];
2588 }
2589
2590 /**************************************************************************/
2591
2592 Float_t TIsajet::GetPHI(Int_t index) const
2593 {
2594     Int_t length = (sizeof JETPAR.phi / sizeof JETPAR.phi[0]);
2595     if ((index < 0) || (index >= length)) {
2596         printf ("Error in TIsajet::GetPHI : \n");
2597         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2598         return 0;
2599     }
2600
2601     return JETPAR.phi[index];
2602 }
2603
2604 /**************************************************************************/
2605
2606 Float_t TIsajet::GetXJ(Int_t index) const
2607 {
2608     Int_t length = (sizeof JETPAR.xj / sizeof JETPAR.xj[0]);
2609     if ((index < 0) || (index >= length)) {
2610         printf ("Error in TIsajet::GetXJ : \n");
2611         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2612         return 0;
2613     }
2614
2615     return JETPAR.xj[index];
2616 }
2617
2618 /**************************************************************************/
2619
2620 Float_t TIsajet::GetTH(Int_t index) const
2621 {
2622     Int_t length = (sizeof JETPAR.th / sizeof JETPAR.th[0]);
2623     if ((index < 0) || (index >= length)) {
2624         printf ("Error in TIsajet::GetTH : \n");
2625         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2626         return 0;
2627     }
2628
2629     return JETPAR.th[index];
2630 }
2631
2632 /**************************************************************************/
2633
2634 Float_t TIsajet::GetCTH(Int_t index) const
2635 {
2636     Int_t length = (sizeof JETPAR.cth / sizeof JETPAR.cth[0]);
2637     if ((index < 0) || (index >= length)) {
2638         printf ("Error in TIsajet::GetCTH : \n");
2639         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2640         return 0;
2641     }
2642
2643     return JETPAR.cth[index];
2644 }
2645
2646 /**************************************************************************/
2647
2648 Float_t TIsajet::GetSTH(Int_t index) const
2649 {
2650     Int_t length = (sizeof JETPAR.sth / sizeof JETPAR.sth[0]);
2651     if ((index < 0) || (index >= length)) {
2652         printf ("Error in TIsajet::GetSTH : \n");
2653         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2654         return 0;
2655     }
2656
2657     return JETPAR.sth[index];
2658 }
2659
2660 /**************************************************************************/
2661
2662 Int_t TIsajet::GetJETTYP(Int_t index) const
2663 {
2664     Int_t length = (sizeof JETPAR.jettyp / sizeof JETPAR.jettyp[0]);
2665     if ((index < 0) || (index >= length)) {
2666         printf ("Error in TIsajet::GetJETTYP : \n");
2667         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2668         return 0;
2669     }
2670
2671     return JETPAR.jettyp[index];
2672 }
2673
2674 /**************************************************************************/
2675
2676 Float_t TIsajet::GetSHAT() const
2677 {
2678     return JETPAR.shat;
2679 }
2680
2681 /**************************************************************************/
2682
2683 Float_t TIsajet::GetTHAT() const
2684 {
2685     return JETPAR.that;
2686 }
2687
2688 /**************************************************************************/
2689
2690 Float_t TIsajet::GetUHAT() const
2691 {
2692     return JETPAR.uhat;
2693 }
2694
2695 /**************************************************************************/
2696
2697 Float_t TIsajet::GetQSQ() const
2698 {
2699     return JETPAR.qsq;
2700 }
2701
2702 /**************************************************************************/
2703
2704 Float_t TIsajet::GetX1() const
2705 {
2706     return JETPAR.x1;
2707 }
2708
2709 /**************************************************************************/
2710
2711 Float_t TIsajet::GetX2() const
2712 {
2713     return JETPAR.x2;
2714 }
2715
2716 /**************************************************************************/
2717
2718 Float_t TIsajet::GetPBEAM(Int_t index) const
2719 {
2720     Int_t length = (sizeof JETPAR.pbeam / sizeof JETPAR.pbeam[0]);
2721     if ((index < 0) || (index >= length)) {
2722         printf ("Error in TIsajet::GetPBEAM : \n");
2723         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2724         return 0;
2725     }
2726
2727     return JETPAR.pbeam[index];
2728 }
2729
2730 /**************************************************************************/
2731
2732 Float_t TIsajet::GetQMW() const
2733 {
2734     return JETPAR.qmw;
2735 }
2736
2737 /**************************************************************************/
2738
2739 Float_t TIsajet::GetQW() const
2740 {
2741     return JETPAR.qw;
2742 }
2743
2744 /**************************************************************************/
2745
2746 Float_t TIsajet::GetQTW() const
2747 {
2748     return JETPAR.qtw;
2749 }
2750
2751 /**************************************************************************/
2752
2753 Float_t TIsajet::GetYW() const
2754 {
2755     return JETPAR.yw;
2756 }
2757
2758 /**************************************************************************/
2759
2760 Float_t TIsajet::GetXW() const
2761 {
2762     return JETPAR.xw;
2763 }
2764
2765 /**************************************************************************/
2766
2767 Float_t TIsajet::GetTHW() const
2768 {
2769     return JETPAR.thw;
2770 }
2771
2772 /**************************************************************************/
2773
2774 Float_t TIsajet::GetQTMW() const
2775 {
2776     return JETPAR.qtmw;
2777 }
2778
2779 /**************************************************************************/
2780
2781 Float_t TIsajet::GetPHIW() const
2782 {
2783     return JETPAR.phiw;
2784 }
2785
2786 /**************************************************************************/
2787
2788 Float_t TIsajet::GetSHAT1() const
2789 {
2790     return JETPAR.shat1;
2791 }
2792
2793 /**************************************************************************/
2794
2795 Float_t TIsajet::GetTHAT1() const
2796 {
2797     return JETPAR.that1;
2798 }
2799
2800 /**************************************************************************/
2801
2802 Float_t TIsajet::GetUHAT1() const
2803 {
2804     return JETPAR.uhat1;
2805 }
2806
2807 /**************************************************************************/
2808
2809 void TIsajet::SetJWTYP(Int_t val)
2810 {
2811     if ((val < 1) || (val > 4) || (val == 2))
2812     {
2813         printf ("Error in TIsajet::SetJWTYP : \n");
2814         printf ("Invalid value  %d; range is 1, 3, and 4.\n", val);
2815         return;
2816     }
2817
2818     JETPAR.jwtyp = val;
2819 }
2820
2821 /**************************************************************************/
2822
2823 void TIsajet::SetJWTYP(Char_t val[])
2824 {
2825     Int_t value;
2826
2827     if (!strcmp(val, "GM")) value = 1;
2828     else if (!strcmp(val, "W+")) value = 3;
2829     else if (!strcmp(val, "W-")) value = 3;
2830     else if (!strcmp(val, "Z0")) value = 4;
2831     else
2832     {
2833         printf ("Error in TIsajet::SetJWTYP : \n");
2834         printf ("Invalid value  %s; possible are GM, Z0, W+ and W-.\n", val);
2835         return;
2836     }
2837
2838
2839     JETPAR.jwtyp = value;
2840 }
2841
2842 /**************************************************************************/
2843
2844 Int_t TIsajet::GetJWTYP() const
2845 {
2846     return JETPAR.jwtyp;
2847 }
2848
2849 /**************************************************************************/
2850
2851 Float_t TIsajet::GetALFQSQ() const
2852 {
2853     return JETPAR.alfqsq;
2854 }
2855
2856 /**************************************************************************/
2857
2858 Float_t TIsajet::GetCTHW() const
2859 {
2860     return JETPAR.cthw;
2861 }
2862
2863 /**************************************************************************/
2864
2865 Float_t TIsajet::GetSTHW() const
2866 {
2867     return JETPAR.sthw;
2868 }
2869
2870 /**************************************************************************/
2871
2872 Float_t TIsajet::GetQ0W() const
2873 {
2874     return JETPAR.q0w;
2875 }
2876
2877 /**************************************************************************/
2878
2879 Int_t TIsajet::GetINITYP(Int_t index) const
2880 {
2881     Int_t length = (sizeof JETPAR.inityp / sizeof JETPAR.inityp[0]);
2882     if ((index < 0) || (index >= length)) {
2883         printf ("Error in TIsajet::GetINITYP : \n");
2884         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2885         return 0;
2886     }
2887
2888     return JETPAR.inityp[index];
2889 }
2890
2891 /**************************************************************************/
2892
2893 Int_t TIsajet::GetISIGS() const
2894 {
2895     return JETPAR.isigs;
2896 }
2897
2898 /**************************************************************************/
2899
2900 Float_t TIsajet::GetPBEAMS(Int_t index) const
2901 {
2902     Int_t length = (sizeof JETPAR.pbeams / sizeof JETPAR.pbeams[0]);
2903     if ((index < 0) || (index >= length)) {
2904         printf ("Error in TIsajet::GetPBEAMS : \n");
2905         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2906         return 0;
2907     }
2908
2909     return JETPAR.pbeams[index];
2910 }
2911
2912 /**************************************************************************/
2913
2914 // Ends JETPAR access.
2915 // Begins KKGRAV access.
2916
2917 /**************************************************************************/
2918
2919 void TIsajet::SetNEXTRAD(Int_t val)
2920 {
2921     KKGRAV.nextrad = val;
2922 }
2923
2924 /**************************************************************************/
2925
2926 Int_t TIsajet::GetNEXTRAD() const
2927 {
2928     return KKGRAV.nextrad;
2929 }
2930
2931 /**************************************************************************/
2932
2933 void TIsajet::SetMASSD(Float_t val)
2934 {
2935     KKGRAV.massd = val;
2936 }
2937
2938 /**************************************************************************/
2939
2940 Float_t TIsajet::GetMASSD() const
2941 {
2942     return KKGRAV.massd;
2943 }
2944
2945 /**************************************************************************/
2946
2947 Float_t TIsajet::GetKKGSD() const
2948 {
2949     return KKGRAV.kkgsd;
2950 }
2951
2952 /**************************************************************************/
2953
2954 Float_t TIsajet::GetSURFD() const
2955 {
2956     return KKGRAV.surfd;
2957 }
2958
2959 /**************************************************************************/
2960
2961 void TIsajet::SetUVCUT(Bool_t val)
2962 {
2963     KKGRAV.uvcut = val;
2964 }
2965
2966 /**************************************************************************/
2967
2968 Bool_t TIsajet::GetUVCUT() const
2969 {
2970     return KKGRAV.uvcut;
2971 }
2972
2973 /**************************************************************************/
2974
2975 // Ends KKGRAV access.
2976 // Begins MBGEN access.
2977
2978 /**************************************************************************/
2979
2980 Float_t TIsajet::GetPOMWT(Int_t index) const
2981 {
2982     Int_t length = (sizeof MBGEN.pomwt / sizeof MBGEN.pomwt[0]);
2983     if ((index < 0) || (index >= length)) {
2984         printf ("Error in TIsajet::GetPOMWT : \n");
2985         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2986         return 0;
2987     }
2988
2989     return MBGEN.pomwt[index];
2990 }
2991
2992 /**************************************************************************/
2993
2994 Float_t TIsajet::GetPOMGEN(Int_t index) const
2995 {
2996     Int_t length = (sizeof MBGEN.pomgen / sizeof MBGEN.pomgen[0]);
2997     if ((index < 0) || (index >= length)) {
2998         printf ("Error in TIsajet::GetPOMGEN : \n");
2999         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3000         return 0;
3001     }
3002
3003     return MBGEN.pomgen[index];
3004 }
3005
3006 /**************************************************************************/
3007
3008 void TIsajet::SetMNPOM(Int_t val)
3009 {
3010     if (val > MBGEN.mxpom) {
3011         printf("Error in TIsajet::SetMNPOM : \n");
3012         printf("You may not set MNPOM to a value larger than MXPOM = %d.\n", MBGEN.mxpom);
3013         return;
3014     }
3015
3016     MBGEN.mnpom = val;
3017 }
3018
3019 /**************************************************************************/
3020
3021 Int_t TIsajet::GetMNPOM() const
3022 {
3023     return MBGEN.mnpom;
3024 }
3025
3026 /**************************************************************************/
3027
3028 void TIsajet::SetMXPOM(Int_t val)
3029 {
3030     if (val < MBGEN.mnpom) {
3031         printf("Error in TIsajet::SetMXPOM : \n");
3032         printf("You may not set MXPOM to a value less than MNPOM = %d.\n", MBGEN.mnpom);
3033         return;
3034     }
3035
3036     MBGEN.mxpom = val;
3037 }
3038
3039 /**************************************************************************/
3040
3041 Int_t TIsajet::GetMXPOM() const
3042 {
3043     return MBGEN.mxpom;
3044 }
3045
3046 /**************************************************************************/
3047
3048 Float_t TIsajet::GetPDIFFR() const
3049 {
3050     return MBGEN.pdiffr;
3051 }
3052
3053 /**************************************************************************/
3054
3055 Int_t TIsajet::GetNPOM() const
3056 {
3057     return MBGEN.npom;
3058 }
3059
3060 /**************************************************************************/
3061
3062 Float_t TIsajet::GetXBARY(Int_t index) const
3063 {
3064     Int_t length = (sizeof MBGEN.xbary / sizeof MBGEN.xbary[0]);
3065     if ((index < 0) || (index >= length)) {
3066         printf ("Error in TIsajet::GetXBARY : \n");
3067         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3068         return 0;
3069     }
3070
3071     return MBGEN.xbary[index];
3072 }
3073
3074 /**************************************************************************/
3075
3076 Float_t TIsajet::GetDXBARY(Int_t index) const
3077 {
3078     Int_t length = (sizeof MBGEN.dxbary / sizeof MBGEN.dxbary[0]);
3079     if ((index < 0) || (index >= length)) {
3080         printf ("Error in TIsajet::GetDXBARY : \n");
3081         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3082         return 0;
3083     }
3084
3085     return MBGEN.dxbary[index];
3086 }
3087
3088 /**************************************************************************/
3089
3090 Float_t TIsajet::GetXPOM(Int_t index1, Int_t index2) const
3091 {
3092     Int_t elem_Size = sizeof MBGEN.xpom[0][0];
3093     Int_t sec_Dim_Length = (sizeof MBGEN.xpom[0] / elem_Size);
3094     Int_t fst_Dim_Length = (sizeof MBGEN.xpom / (elem_Size * sec_Dim_Length));
3095
3096     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
3097         printf ("Error in TIsajet::GetXPOM : \n");
3098         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
3099         return 0;
3100     }
3101
3102     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
3103         printf ("Error in TIsajet::GetXPOM : \n");
3104         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
3105         return 0;
3106     }
3107
3108     return MBGEN.xpom[index1][index2];
3109 }
3110
3111 /**************************************************************************/
3112
3113 // Ends MBGEN access.
3114 // Begins MGLIMS access.
3115
3116 /**************************************************************************/
3117
3118 void TIsajet::SetEHMGMN(Float_t val)
3119 {
3120     if (val > MGLIMS.ehmgmx) {
3121         printf("Error in TIsajet::SetEHMGMN : \n");
3122         printf("You may not set EHMGMN to a value larger than EHMGMX = %f.\n", MGLIMS.ehmgmx);
3123         return;
3124     }
3125
3126     MGLIMS.ehmgmn = val;
3127 }
3128
3129 /**************************************************************************/
3130
3131 Float_t TIsajet::GetEHMGMN() const
3132 {
3133     return MGLIMS.ehmgmn;
3134 }
3135
3136 /**************************************************************************/
3137
3138 void TIsajet::SetEHMGMX(Float_t val)
3139 {
3140     if (val < MGLIMS.ehmgmn) {
3141         printf("Error in TIsajet::SetEHMGMX : \n");
3142         printf("You may not set EHMGMX to a value less than EHMGMN = %f.\n", MGLIMS.ehmgmn);
3143         return;
3144     }
3145
3146     MGLIMS.ehmgmx = val;
3147 }
3148
3149 /**************************************************************************/
3150
3151 Float_t TIsajet::GetEHMGMX() const
3152 {
3153     return MGLIMS.ehmgmx;
3154 }
3155
3156 /**************************************************************************/
3157
3158 Float_t TIsajet::GetYHMGMN() const
3159 {
3160     return MGLIMS.yhmgmn;
3161 }
3162
3163 /**************************************************************************/
3164
3165 Float_t TIsajet::GetYHMGMX() const
3166 {
3167     return MGLIMS.yhmgmx;
3168 }
3169
3170 /**************************************************************************/
3171
3172 void TIsajet::SetAMIJMN(Float_t val, Int_t index1, Int_t index2)
3173 {
3174     Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3175     Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3176
3177     if ((index1 < 0) || (index1 >= row_num)) {
3178         printf ("Error in TIsajet::SetAMIJMN : \n");
3179         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3180         return;
3181     }
3182
3183     if ((index2 < 0) || (index2 >= col_num)) {
3184         printf ("Error in TIsajet::SetAMIJMN : \n");
3185         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3186         return;
3187     }
3188
3189     if (val > MGLIMS.amijmx[index1][index2]) {
3190         printf("Error in TIsajet::SetAMIJMN : \n");
3191         printf("You may not set AMIJMN to a value larger than AMIJMX = %f.\n", MGLIMS.amijmx[index1][index2]);
3192         return;
3193     }
3194
3195     MGLIMS.amijmn[index1][index2] = val;
3196 }
3197
3198 /**************************************************************************/
3199
3200 void TIsajet::SetAllAMIJMN(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
3201 {
3202     for (Int_t i = 0; i < 2; i++) {
3203         for (Int_t j = 0; j < 3; j++) {
3204             SetAMIJMN(val[i][j], i, j);
3205         }
3206     }
3207 }
3208
3209 /**************************************************************************/
3210
3211 void TIsajet::SetColumnAMIJMN(const Float_t val[], Int_t col)
3212 {
3213     Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3214     Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3215
3216     if ((col < 0) || (col >= col_num)) {
3217         printf ("Error in TIsajet::SetColumnAMIJMN : \n");
3218         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
3219         return;
3220     }
3221
3222     for (Int_t i = 0; i < row_num; i++) {
3223         SetAMIJMN(val[i], i, col);
3224     }
3225 }
3226
3227 /**************************************************************************/
3228
3229 Float_t TIsajet::GetAMIJMN(Int_t index1, Int_t index2) const
3230 {
3231     Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3232     Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3233
3234     if ((index1 < 0) || (index1 >= row_num)) {
3235         printf ("Error in TIsajet::GetAMIJMN : \n");
3236         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3237         return 0;
3238     }
3239
3240     if ((index2 < 0) || (index2 >= col_num)) {
3241         printf ("Error in TIsajet::GetAMIJMN : \n");
3242         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3243         return 0;
3244     }
3245
3246     return MGLIMS.amijmn[index1][index2];
3247 }
3248
3249 /**************************************************************************/
3250
3251 void TIsajet::SetAMIJMX(Float_t val, Int_t index1, Int_t index2)
3252 {
3253     Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3254     Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3255
3256     if ((index1 < 0) || (index1 >= row_num)) {
3257         printf ("Error in TIsajet::SetAMIJMX : \n");
3258         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3259         return;
3260     }
3261
3262     if ((index2 < 0) || (index2 >= col_num)) {
3263         printf ("Error in TIsajet::SetAMIJMX : \n");
3264         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3265         return;
3266     }
3267
3268     if (val < MGLIMS.amijmn[index1][index2]) {
3269         printf("Error in TIsajet::SetAMIJMX : \n");
3270         printf("You may not set AMIJMX to a value less than AMIJMN = %f.\n", MGLIMS.amijmn[index1][index2]);
3271         return;
3272     }
3273
3274     MGLIMS.amijmx[index1][index2] = val;
3275 }
3276
3277 /**************************************************************************/
3278
3279 void TIsajet::SetAllAMIJMX(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
3280 {
3281     for (Int_t i = 0; i < 2; i++) {
3282         for (Int_t j = 0; j < 3; j++) {
3283             SetAMIJMX(val[i][j], i, j);
3284         }
3285     }
3286 }
3287
3288 /**************************************************************************/
3289
3290 void TIsajet::SetColumnAMIJMX(const Float_t val[], Int_t col)
3291 {
3292     Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3293     Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3294
3295     if ((col < 0) || (col >= col_num)) {
3296         printf ("Error in TIsajet::SetColumnAMIJMX : \n");
3297         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
3298         return;
3299     }
3300
3301     for (Int_t i = 0; i < row_num; i++) {
3302         SetAMIJMX(val[i], i, col);
3303     }
3304 }
3305
3306 /**************************************************************************/
3307
3308 Float_t TIsajet::GetAMIJMX(Int_t index1, Int_t index2) const
3309 {
3310     Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3311     Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3312
3313     if ((index1 < 0) || (index1 >= row_num)) {
3314         printf ("Error in TIsajet::GetAMIJMX : \n");
3315         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3316         return 0;
3317     }
3318
3319     if ((index2 < 0) || (index2 >= col_num)) {
3320         printf ("Error in TIsajet::GetAMIJMX : \n");
3321         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3322         return 0;
3323     }
3324
3325     return MGLIMS.amijmx[index1][index2];
3326 }
3327
3328 /**************************************************************************/
3329
3330 Bool_t TIsajet::GetFIXMIJ(Int_t index1, Int_t index2) const
3331 {
3332     Int_t elem_Size = sizeof MGLIMS.fixmij[0][0];
3333     Int_t sec_Dim_Length = (sizeof MGLIMS.fixmij[0] / elem_Size);
3334     Int_t fst_Dim_Length = (sizeof MGLIMS.fixmij / (elem_Size * sec_Dim_Length));
3335
3336     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
3337         printf ("Error in TIsajet::GetFIXMIJ : \n");
3338         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
3339         return 0;
3340     }
3341
3342     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
3343         printf ("Error in TIsajet::GetFIXMIJ : \n");
3344         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
3345         return 0;
3346     }
3347
3348     return MGLIMS.fixmij[index1][index2];
3349 }
3350
3351 /**************************************************************************/
3352
3353 // Ends MGLIMS access.
3354 // Begins NODCAY access.
3355
3356 /**************************************************************************/
3357
3358 void TIsajet::SetNODCAY(Bool_t val)
3359 {
3360     NODCAY.nodcay = val;
3361     setNodcay = true;
3362 }
3363
3364 /**************************************************************************/
3365
3366 Bool_t TIsajet::GetNODCAY() const
3367 {
3368     return NODCAY.nodcay;
3369 }
3370
3371 /**************************************************************************/
3372
3373 void TIsajet::SetNOETA(Bool_t val)
3374 {
3375     NODCAY.noeta = val;
3376     setNoeta = true;
3377 }
3378
3379 /**************************************************************************/
3380
3381 Bool_t TIsajet::GetNOETA() const
3382 {
3383     return NODCAY.noeta;
3384 }
3385
3386 /**************************************************************************/
3387
3388 void TIsajet::SetNOPI0(Bool_t val)
3389 {
3390     NODCAY.nopi0 = val;
3391     setNopi0 = true;
3392 }
3393
3394 /**************************************************************************/
3395
3396 Bool_t TIsajet::GetNOPI0() const
3397 {
3398     return NODCAY.nopi0;
3399 }
3400
3401 /**************************************************************************/
3402
3403 void TIsajet::SetNONUNU(Bool_t val)
3404 {
3405     NODCAY.nonunu = val;
3406 }
3407
3408 /**************************************************************************/
3409
3410 Bool_t TIsajet::GetNONUNU() const
3411 {
3412     return NODCAY.nonunu;
3413 }
3414
3415 /**************************************************************************/
3416
3417 void TIsajet::SetNOEVOL(Bool_t val)
3418 {
3419     NODCAY.noevol = val;
3420     setNoevolve = true;
3421 }
3422
3423 /**************************************************************************/
3424
3425 Bool_t TIsajet::GetNOEVOL() const
3426 {
3427     return NODCAY.noevol;
3428 }
3429
3430 /**************************************************************************/
3431
3432 void TIsajet::SetNOHADR(Bool_t val)
3433 {
3434     NODCAY.nohadr = val;
3435     setNohadron = true;
3436 }
3437
3438 /**************************************************************************/
3439
3440 Bool_t TIsajet::GetNOHADR() const
3441 {
3442     return NODCAY.nohadr;
3443 }
3444
3445 /**************************************************************************/
3446
3447 void TIsajet::SetNOGRAV(Bool_t val)
3448 {
3449     NODCAY.nograv = val;
3450 }
3451
3452 /**************************************************************************/
3453
3454 Bool_t TIsajet::GetNOGRAV() const
3455 {
3456     return NODCAY.nograv;
3457 }
3458
3459 /**************************************************************************/
3460
3461 // Ends NODCAY access.
3462 // Begins PARTCL access.
3463
3464 /**************************************************************************/
3465
3466 Int_t TIsajet::GetNPTCL() const
3467 {
3468     return PARTCL.nptcl;
3469 }
3470
3471 /**************************************************************************/
3472
3473 Float_t TIsajet::GetPX(Int_t index) const
3474 {
3475     if ((index < 0) || (index >= PARTCL.nptcl)) {
3476         printf ("Error in TIsajet::GetPX : \n");
3477         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3478         return 0;
3479     }
3480
3481     return PARTCL.pptcl[index][0];
3482 }
3483
3484 /**************************************************************************/
3485
3486 Float_t TIsajet::GetPY(Int_t index) const
3487 {
3488     if ((index < 0) || (index >= PARTCL.nptcl)) {
3489         printf ("Error in TIsajet::GetPY : \n");
3490         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3491         return 0;
3492     }
3493
3494     return PARTCL.pptcl[index][1];
3495 }
3496
3497 /**************************************************************************/
3498
3499 Float_t TIsajet::GetPZ(Int_t index) const
3500 {
3501     if ((index < 0) || (index >= PARTCL.nptcl)) {
3502         printf ("Error in TIsajet::GetPZ : \n");
3503         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3504         return 0;
3505     }
3506
3507     return PARTCL.pptcl[index][2];
3508 }
3509
3510 /**************************************************************************/
3511
3512 Float_t TIsajet::GetP0(Int_t index) const
3513 {
3514     if ((index < 0) || (index >= PARTCL.nptcl)) {
3515         printf ("Error in TIsajet::GetP0 : \n");
3516         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3517         return 0;
3518     }
3519
3520     return PARTCL.pptcl[index][3];
3521 }
3522
3523 /**************************************************************************/
3524
3525 Float_t TIsajet::GetMASS(Int_t index) const
3526 {
3527     if ((index < 0) || (index >= PARTCL.nptcl)) {
3528         printf ("Error in TIsajet::GetMASS : \n");
3529         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3530         return 0;
3531     }
3532
3533     return PARTCL.pptcl[index][4];
3534 }
3535
3536 /**************************************************************************/
3537
3538 Float_t TIsajet::GetORIG(Int_t index) const
3539 {
3540     if ((index < 0) || (index >= PARTCL.nptcl)) {
3541         printf ("Error in TIsajet::GetORIG : \n");
3542         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3543         return 0;
3544     }
3545
3546     return PARTCL.iorig[index];
3547 }
3548
3549 /**************************************************************************/
3550
3551 Float_t TIsajet::GetIDENT(Int_t index) const
3552 {
3553     if ((index < 0) || (index >= PARTCL.nptcl)) {
3554         printf ("Error in TIsajet::GetIDENT : \n");
3555         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3556         return 0;
3557     }
3558
3559     return PARTCL.ident[index];
3560 }
3561
3562 /**************************************************************************/
3563
3564 Float_t TIsajet::GetIDCAY(Int_t index) const
3565 {
3566     if ((index < 0) || (index >= PARTCL.nptcl)) {
3567         printf ("Error in TIsajet::GetIDCAY : \n");
3568         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3569         return 0;
3570     }
3571
3572     return PARTCL.idcay[index];
3573 }
3574
3575 /**************************************************************************/
3576
3577 // Ends PARTCL access.
3578 // Begins PRIMAR access.
3579
3580 /**************************************************************************/
3581
3582 Int_t TIsajet::GetNJET() const
3583 {
3584     return PRIMAR.njet;
3585 }
3586
3587 /**************************************************************************/
3588
3589 Float_t TIsajet::GetSCM() const
3590 {
3591     return PRIMAR.scm;
3592 }
3593
3594 /**************************************************************************/
3595
3596 Float_t TIsajet::GetHALFE() const
3597 {
3598     return PRIMAR.halfe;
3599 }
3600
3601 /**************************************************************************/
3602
3603 void TIsajet::SetECM(Float_t val)
3604 {
3605     if (val < 0) {
3606         printf ("Error in TIsajet::SetECM :\n");
3607         printf ("Cannot set energy to a negative value.\n");
3608         return;
3609     }
3610
3611     PRIMAR.ecm = val;
3612     PRIMAR.scm = val*val;
3613     PRIMAR.halfe = val / 2;
3614 }
3615
3616 /**************************************************************************/
3617
3618 Float_t TIsajet::GetECM() const
3619 {
3620     return PRIMAR.ecm;
3621 }
3622
3623 /**************************************************************************/
3624
3625 void TIsajet::SetIDIN(Int_t val, Int_t index)
3626 {
3627     Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3628     if ((index < 0) || (index >= length)) {
3629         printf ("Error in TIsajet::SetIDIN : \n");
3630         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3631         return;
3632     }
3633
3634     if ((val = 1120) || (val = 1220) || (val = -1120) || (val = -1220)) {
3635         PRIMAR.idin[index] = val;
3636     }
3637     else {
3638         printf ("Error in TIsajet::SetIDIN : \n");
3639         printf ("Invalid input value %d. Possible values are 1120, 1220, -1120, -1220.\n", val);
3640         return;
3641     }
3642
3643     setBeams = true;
3644 }
3645
3646 /**************************************************************************/
3647
3648 void TIsajet::SetIDIN(const Char_t val[], Int_t index)
3649 {
3650     Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3651     if ((index < 0) || (index >= length)) {
3652         printf ("Error in TIsajet::SetIDIN : \n");
3653         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3654         return;
3655     }
3656
3657     if (!strcmp("P", val)) {
3658         PRIMAR.idin[index] = 1120;
3659     }
3660     else if (!strcmp("AP", val)) {
3661         PRIMAR.idin[index] = -1120;
3662     }
3663     else if (!strcmp("N", val)) {
3664         PRIMAR.idin[index] = 1220;
3665     }
3666     else if (!strcmp("AN", val)) {
3667         PRIMAR.idin[index] = -1220;
3668     }
3669     else {
3670         printf ("Error in TIsajet::SetIDIN : \n");
3671         printf ("Invalid input string %s. Possible strings are P, AP, N, and AN.\n", val);
3672         return;
3673     }
3674 }
3675
3676 /**************************************************************************/
3677
3678 Int_t TIsajet::GetIDIN(Int_t index) const
3679 {
3680     Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3681     if ((index < 0) || (index >= length)) {
3682         printf ("Error in TIsajet::GetIDIN : \n");
3683         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3684         return 0;
3685     }
3686
3687     return PRIMAR.idin[index];
3688 }
3689
3690 /**************************************************************************/
3691
3692 Int_t TIsajet::GetNEVENT() const
3693 {
3694     return PRIMAR.nevent;
3695 }
3696
3697 /**************************************************************************/
3698
3699 void TIsajet::SetNTRIES(Int_t val)
3700 {
3701     PRIMAR.ntries = val;
3702 }
3703
3704 /**************************************************************************/
3705
3706 Int_t TIsajet::GetNTRIES() const
3707 {
3708     return PRIMAR.ntries;
3709 }
3710
3711 /**************************************************************************/
3712
3713 void TIsajet::SetNSIGMA(Int_t val)
3714 {
3715     PRIMAR.nsigma = val;
3716     setNsigma = true;
3717 }
3718
3719 /**************************************************************************/
3720
3721 Int_t TIsajet::GetNSIGMA() const
3722 {
3723     return PRIMAR.nsigma;
3724 }
3725
3726 /**************************************************************************/
3727
3728 // Ends PRIMAR access.
3729 // Begins QCDPAR access.
3730
3731 /**************************************************************************/
3732
3733 void TIsajet::SetALAM(Float_t val)
3734 {
3735     QCDPAR.alam = val;
3736     QCDPAR.alam2 = val*val;
3737     setLambda = true;
3738 }
3739
3740 /**************************************************************************/
3741
3742 Float_t TIsajet::GetALAM() const
3743 {
3744     return QCDPAR.alam;
3745 }
3746
3747 /**************************************************************************/
3748
3749 Float_t TIsajet::GetALAM2() const
3750 {
3751     return QCDPAR.alam2;
3752 }
3753
3754 /**************************************************************************/
3755
3756 void TIsajet::SetCUTJET(Float_t val)
3757 {
3758     QCDPAR.cutjet = val;
3759     setCutjet = true;
3760 }
3761
3762 /**************************************************************************/
3763
3764 Float_t TIsajet::GetCUTJET() const
3765 {
3766     return QCDPAR.cutjet;
3767 }
3768
3769 /**************************************************************************/
3770
3771 void TIsajet::SetISTRUC(Int_t val)
3772 {
3773     if ((val < 1) || (val > 6)) {
3774         printf ("Error in TIsajet::SetISTRUC : \n");
3775         printf ("Invalid input value %d. Possible values are 1 through 6.\n", val);
3776         return;