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 /**************************************************************************/
  13
  14 TIsajet::TIsajet() : TGenerator("Isajet", "Isajet")
  15 {
  16 //  Default constructor
  17 //  Set random number
  18     if (!sRandom) sRandom=fRandom;
  19
  20 // Initialising equivalence structures in FRGPAR :
  21 // EQUIVALENCE (PMIX1(1,1),PMIXX1(1))
  22 // EQUIVALENCE (PMIX2(1,1),PMIXX2(1))
  23 // EQUIVALENCE (FRPAR(1),PUD)
  24
  25     FRGPAR.pmixx1[0] = &FRGPAR.pmix1[0][0];
  26     FRGPAR.pmixx2[0] = &FRGPAR.pmix2[0][0];
  27     FRGPAR.frpar[0] = &FRGPAR.pud;
  28
  29     for (Int_t i = 1; i < 6; i++) {
  30         FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
  31         FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
  32     }
  33
  34     for (Int_t i = 1; i < 32; i++) {
  35         FRGPAR.frpar[i] = FRGPAR.frpar[i-1] +1;
  36     }
  37
  38 // Internal logical flags ensuring that theta and y limits are not simultaneously set :
  39
  40     DYLIM.ywset = DYLIM.thwset = false;
  41
  42 // Defaults :
  43
  44     title = ("Default title.");
  45     jobtype = ("TWOJET");
  46
  47     RestoreDefaults();
  48 }
  49
  50 /**************************************************************************/
  51
  52 TIsajet::~TIsajet()
  53 {
  54     // No housekeeping required at the moment.
  55 }
  56
  57 /**************************************************************************/
  58
  59 void TIsajet::Initialise()
  60 {
  61
  62 // Writes parameter file and stores common block variables in
  63 // data members, according to booleans.
  64 // If TIsajet is being used in online-control mode, the parameter file is
  65 // unnecessary, hence the output is echoed to the screen instead.
  66
  67     const char *fname =  gSystem->ExpandPathName("$ALICE_ROOT/ISAJET/data/myjob.par");
  68     ofstream Write(fname, ios::out);
  69
  70     ostream *Writer = &Write;
  71
  72     if (online) Writer = &cout;
  73
  74     *Writer << title << '\n';
  75     *Writer << PRIMAR.ecm << ',' << PRIMAR.nevent << ",1,1/\n";
  76     *Writer << jobtype << '\n';
  77
  78     center_energy = PRIMAR.ecm;
  79
  80     if (setBeams) {
  81         beam1_type = PRIMAR.idin[0];
  82         beam2_type = PRIMAR.idin[1];
  83
  84         *Writer << "BEAMS\n";
  85         if (PRIMAR.idin[0] == -1120) *Writer << "AP,";
  86         else if (PRIMAR.idin[0] == 1220) *Writer << "N,";
  87         else if (PRIMAR.idin[0] == -1220) *Writer << "AN,";
  88         else *Writer << "P,";
  89
  90         if (PRIMAR.idin[1] == -1120) *Writer << "AP/\n";
  91         else if (PRIMAR.idin[1] == 1220) *Writer << "N/\n";
  92         else if (PRIMAR.idin[1] == -1220) *Writer << "AN/\n";
  93         else *Writer << "P/\n";
  94     }
  95
  96     if (setCutjet) {
  97         cutoff_mass = QCDPAR.cutjet;
  98         *Writer << "CUTJET\n" << QCDPAR.cutjet << "/\n";
  99     }
 100
 101     if (setFragment) {
 102         for (Int_t i = 0; i < 32; i++) frag_params[i] = *FRGPAR.frpar[i];
 103
 104         *Writer << "FRAGMENT\n";
 105         for (Int_t i = 0; i < 31; i++) *Writer << FRGPAR.frpar[i] << ',';
 106         *Writer << FRGPAR.frpar[31] << "/\n";
 107     }
 108
 109     if (setJettype1) {
 110         for (Int_t i = 0; i < TYPES.njttyp[0]; i++) jet1_type[i] = XTYPES.jetyp[0][i];
 111         num_jet_type[0] = TYPES.njttyp[0];
 112
 113         *Writer << "JETTYPE1\n";
 114         for (Int_t i = 0; i < TYPES.njttyp[0]-1; i++) *Writer << XTYPES.jetyp[0][i] << ',';
 115         *Writer << XTYPES.jetyp[0][TYPES.njttyp[0]-1] << "/\n";
 116     }
 117     if (setJettype2) {
 118         for (Int_t i = 0; i < TYPES.njttyp[1]; i++) jet2_type[i] = XTYPES.jetyp[1][i];
 119         num_jet_type[0] = TYPES.njttyp[0];
 120
 121         *Writer << "JETTYPE2\n";
 122         for (Int_t i = 0; i < TYPES.njttyp[1]-1; i++) *Writer << XTYPES.jetyp[1][i] << ',';
 123         *Writer << XTYPES.jetyp[1][TYPES.njttyp[1]-1] << "/\n";
 124     }
 125     if (setJettype3) {
 126         for (Int_t i = 0; i < TYPES.njttyp[2]; i++) jet3_type[i] = XTYPES.jetyp[2][i];
 127         num_jet_type[0] = TYPES.njttyp[0];
 128
 129         *Writer << "JETTYPE3\n";
 130         for (Int_t i = 0; i < TYPES.njttyp[2]-1; i++) *Writer << XTYPES.jetyp[2][i] << ',';
 131         *Writer << XTYPES.jetyp[2][TYPES.njttyp[2]-1] << "/\n";
 132     }
 133
 134
 135     if (setLambda) {
 136         qcd_lambda = QCDPAR.alam;
 137         *Writer << "LAMBDA\n" << QCDPAR.alam << "/\n";
 138     }
 139
 140
 141     if (setNodcay) {
 142         forbid_decay = NODCAY.nodcay;
 143
 144         *Writer << "NODCAY\n";
 145         if (NODCAY.nodcay) *Writer << "TRUE/\n";
 146         else *Writer << "FALSE/\n";
 147     }
 148
 149     if (setNoeta) {
 150         forbid_eta = NODCAY.noeta;
 151
 152         *Writer << "NOETA\n";
 153         if (NODCAY.noeta) *Writer << "TRUE/\n";
 154         else *Writer << "FALSE/\n";
 155     }
 156
 157     if (setNoevolve) {
 158         forbid_evolve = NODCAY.noevol;
 159
 160         *Writer << "NOEVOLVE\n";
 161         if (NODCAY.noevol) *Writer << "TRUE/\n";
 162         else *Writer << "FALSE/\n";
 163     }
 164
 165     if (setNohadron) {
 166         forbid_hadron = NODCAY.nohadr;
 167
 168         *Writer << "NOHADRON\n";
 169         if (NODCAY.nohadr) *Writer << "TRUE/\n";
 170         else *Writer << "FALSE/\n";
 171     }
 172
 173     if (setNopi0) {
 174         forbid_pi0 = NODCAY.nopi0;
 175
 176         *Writer << "NOPI0\n";
 177         if (NODCAY.nopi0) *Writer << "TRUE/\n";
 178         else *Writer << "FALSE/\n";
 179     }
 180
 181     if (setNsigma) {
 182         generate_sigma = PRIMAR.nsigma;
 183         *Writer << "NSIGMA\n" << PRIMAR.nsigma << "/\n";
 184     }
 185
 186     if (setP) {
 187         for (Int_t i = 0; i < 3; i++) {
 188             p_limits[2 * i] = JETLIM.pmin[i];
 189             p_limits[2 * i + 1] = JETLIM.pmax[i];
 190         }
 191
 192         *Writer << "P\n";
 193         *Writer << JETLIM.pmin[0] << ',' << JETLIM.pmax[0] << ',';
 194         *Writer << JETLIM.pmin[1] << ',' << JETLIM.pmax[1] << ',';
 195         *Writer << JETLIM.pmin[2] << ',' << JETLIM.pmax[2] << "/\n";
 196     }
 197
 198     if (setPhi) {
 199         for (Int_t i = 0; i < 3; i++) {
 200             phi_limits[2 * i] = JETLIM.phimin[i];
 201             phi_limits[2 * i + 1] = JETLIM.phimax[i];
 202         }
 203
 204         *Writer << "PHI\n";
 205         *Writer << JETLIM.phimin[0] << ',' << JETLIM.phimax[0] << ',';
 206         *Writer << JETLIM.phimin[1] << ',' << JETLIM.phimax[1] << ',';
 207         *Writer << JETLIM.phimin[2] << ',' << JETLIM.phimax[2] << "/\n";
 208     }
 209
 210     if (setPt) {
 211         for (Int_t i = 0; i < 3; i++) {
 212             pt_limits[2 * i] = JETLIM.ptmin[i];
 213             pt_limits[2 * i + 1] = JETLIM.ptmax[i];
 214         }
 215
 216         *Writer << "PT\n";
 217         *Writer << JETLIM.ptmin[0] << ',' << JETLIM.ptmax[0] << ',';
 218         *Writer << JETLIM.ptmin[1] << ',' << JETLIM.ptmax[1] << ',';
 219         *Writer << JETLIM.ptmin[2] << ',' << JETLIM.ptmax[2] << "/\n";
 220     }
 221
 222     if (setTheta) {
 223         for (Int_t i = 0; i < 3; i++) {
 224             theta_limits[2 * i] = JETLIM.thmin[i];
 225             theta_limits[2 * i + 1] = JETLIM.thmax[i];
 226         }
 227
 228         *Writer << "THETA\n";
 229         *Writer << JETLIM.thmin[0] << ',' << JETLIM.thmax[0] << ',';
 230         *Writer << JETLIM.thmin[1] << ',' << JETLIM.thmax[1] << ',';
 231         *Writer << JETLIM.thmin[2] << ',' << JETLIM.thmax[2] << "/\n";
 232     }
 233
 234     if (setX) {
 235         for (Int_t i = 0; i < 3; i++) {
 236             x_limits[2 * i] = JETLIM.xjmin[i];
 237             x_limits[2 * i + 1] = JETLIM.xjmax[i];
 238         }
 239
 240         *Writer << "X\n";
 241         *Writer << JETLIM.xjmin[0] << ',' << JETLIM.xjmax[0] << ',';
 242         *Writer << JETLIM.xjmin[1] << ',' << JETLIM.xjmax[1] << ',';
 243         *Writer << JETLIM.xjmin[2] << ',' << JETLIM.xjmax[2] << "/\n";
 244     }
 245
 246     if (setY) {
 247         for (Int_t i = 0; i < 3; i++) {
 248             y_limits[2 * i] = JETLIM.yjmin[i];
 249             y_limits[2 * i + 1] = JETLIM.yjmax[i];
 250         }
 251
 252         *Writer << "Y\n";
 253         *Writer << JETLIM.yjmin[0] << ',' << JETLIM.yjmax[0] << ',';
 254         *Writer << JETLIM.yjmin[1] << ',' << JETLIM.yjmax[1] << ',';
 255         *Writer << JETLIM.yjmin[2] << ',' << JETLIM.yjmax[2] << "/\n";
 256     }
 257
 258     if (setXgen) {
 259         for (Int_t i = 0; i < 8; i++) peter_jet_frag[i] = FRGPAR.xgen[i];
 260
 261         *Writer << "XGEN\n";
 262         for (Int_t i = 0; i < 7; i++) *Writer << FRGPAR.xgen[i] << ',';
 263         *Writer << FRGPAR.xgen[7] << "/\n";
 264     }
 265
 266     if (setPdf) {
 267         *Writer << "PDFLIB\n";
 268         for (Int_t i = 0; i < num_Pdf; i++) *Writer << "\'" << pdfpar[i] << "\'" << ',' << pdfval[i] << "/\n";
 269     }
 270
 271
 272     *Writer << "END\n";
 273     *Writer << "STOP\n";
 274     Write.close();
 275
 276 //  Stuff for online-control mode :
 277
 278     if (online) {
 279         KEYS.reac = jobtype;
 280         KEYS.keyon = false;
 281         for (Int_t i = 0; i < KEYS.mxkeys; i++) KEYS.keys[i] = false;
 282
 283         if (!strcmp(KEYS.reac, "TWOJET")) {
 284             KEYS.keys[0] = true;
 285             KEYS.ikey = 1;
 286             PRIMAR.njet = 2;
 287         }
 288         else if (!strcmp(KEYS.reac, "MINBIAS")) {
 289             KEYS.keys[3] = true;
 290             KEYS.ikey = 4;
 291             PRIMAR.njet = 0;
 292         }
 293         else {
 294             printf("Error in TIsajet::Initialise :\n");
 295             printf("Invalid job type %s.\n", KEYS.reac);
 296             printf("Only TWOJET and MINBIAS are currently supported for online mode.\n");
 297             return;
 298         }
 299
 300         if (setPdf) {
 301             PDFinit();
 302         }
 303     }
 304 }
 305
 306 /**************************************************************************/
 307
 308 void TIsajet::Reload()
 309 {
 310 //
 311 // Sets the common block variables to the data member values.
 312 //
 313
 314     SetECM(center_energy);
 315
 316     if (setBeams) {
 317         SetIDIN(0, beam1_type);
 318         SetIDIN(1, beam2_type);
 319     }
 320
 321     if (setCutjet) SetCUTJET(cutoff_mass);
 322
 323     if (setFragment) SetAllFRPAR(frag_params, 32);
 324
 325     if (setJettype1) for (Int_t i = 0; i < num_jet_type[0]; i++) SetJETYP(0, jet1_type[i]);
 326
 327     if (setJettype2) for (Int_t i = 0; i < num_jet_type[1]; i++) SetJETYP(1, jet2_type[i]);
 328
 329     if (setJettype3) for (Int_t i = 0; i < num_jet_type[2]; i++) SetJETYP(2, jet3_type[i]);
 330
 331     if (setLambda) SetALAM(qcd_lambda);
 332
 333     if (setNodcay) SetNODCAY(forbid_decay);
 334
 335     if (setNoeta) SetNOETA(forbid_eta);
 336
 337     if (setNoevolve) SetNOEVOL(forbid_evolve);
 338
 339     if (setNohadron) SetNOHADR(forbid_hadron);
 340
 341     if (setNopi0) SetNOPI0(forbid_pi0);
 342
 343     if (setNsigma) SetNSIGMA(generate_sigma);
 344
 345     if (setP) {
 346         for (Int_t i = 0; i < 3; i++) {
 347             SetPMIN(p_limits[2 * i], i);
 348             SetPMAX(p_limits[2 * i + 1], i);
 349         }
 350     }
 351
 352     if (setPhi) {
 353         for (Int_t i = 0; i < 3; i++) {
 354             SetPHIMIN(phi_limits[2 * i], i);
 355             SetPHIMAX(phi_limits[2 * i + 1], i);
 356         }
 357     }
 358
 359     if (setPt) {
 360         for (Int_t i = 0; i < 3; i++) {
 361             SetPTMIN(pt_limits[2 * i], i);
 362             SetPTMAX(pt_limits[2 * i + 1], i);
 363         }
 364     }
 365
 366     if (setTheta) {
 367         for (Int_t i = 0; i < 3; i++) {
 368             SetTHMIN(theta_limits[2 * i], i);
 369             SetTHMAX(theta_limits[2 * i + 1], i);
 370         }
 371     }
 372
 373     if (setX) {
 374         for (Int_t i = 0; i < 3; i++) {
 375             SetXJMIN(x_limits[2 * i], i);
 376             SetXJMAX(x_limits[2 * i + 1], i);
 377         }
 378     }
 379
 380     if (setY) {
 381         for (Int_t i = 0; i < 3; i++) {
 382             SetYJMIN(y_limits[2 * i], i);
 383             SetYJMAX(y_limits[2 * i + 1], i);
 384         }
 385     }
 386
 387     if (setXgen) SetAllXGEN(peter_jet_frag, 8);
 388 }
 389
 390 /**************************************************************************/
 391
 392 void TIsajet::RestoreDefaults()
 393 {
 394 // Booleans indicating which keywords should be written into the parameter file.
 395
 396     setBeams = setCutjet = setFragment = setJettype1 = false;
 397     setJettype2 = setJettype3 = setLambda = setNodcay = false;
 398     setNoeta = setNoevolve = setNohadron = setNopi0 = false;
 399     setNsigma = setP = setPhi = setPt  = setTheta = false;
 400     setX = setXgen = setY = setPdf = false;
 401     num_Pdf = 0;
 402
 403 // Calling on FORTRAN for initialisation of variables
 404
 405     Openfiles();
 406     Int_t a, b, c, d, e;
 407
 408     a = -54;
 409     b = 0;
 410     c = 51;
 411     d = 53;
 412
 413     Isaini(a, b, c, d);
 414     e = 0;
 415     Isabeg(e);
 416 }
 417
 418 /**************************************************************************/
 419
 420 Int_t TIsajet::ImportParticles(TClonesArray *particles, Option_t *option)
 421 {
 422 //
 423 //  Default primary creation method. It reads the /HEPEVT/ common block which
 424 //  has been filled by the GenerateEvent method. If the event generator does
 425 //  not use the HEPEVT common block, this routine has to be overloaded by
 426 //  the subclasses.
 427 //  The function loops on the generated particles and stores them in
 428 //  the TClonesArray pointed by the argument particles.
 429 //  The default action is to store only the stable particles (ISTHEP = 1)
 430 //  This can be demanded explicitly by setting the option = "Final"
 431 //  If the option = "All", all the particles are stored.
 432 //
 433   if (particles == 0) return 0;
 434   TClonesArray &Particles = *particles;
 435   Particles.Clear();
 436   TDatabasePDG* converter = TDatabasePDG::Instance();
 437   Int_t numpart = PARTCL.nptcl;
 438   printf("\n TIsajet: ISAJET stack contains %d particles.", numpart);
 439   printf("\n TIsajet: Total energy:         %f           ", PRIMAR.ecm);
 440   Int_t nump = 0;
 441   if ((!strcmp(option,"")) || (!strcmp(option,"Final"))) {
 442       for (Int_t i = 0; i < numpart; i++) {
 443
 444           if (PARTCL.idcay[i] == 0) {  // Check whether particle is stable.
 445 //
 446 //  Use the common block values for the TParticle constructor
 447 //
 448             nump++;
 449             new(Particles[i]) TParticle(
 450                   converter->ConvertIsajetToPdg(PARTCL.ident[i]) , // PDG code
 451                   0 , // Status - currently a default
 452
 453                   -1, // Mothers and daughters - not used for stable particles
 454                   -1,
 455                   -1,
 456                   -1,
 457
 458                   PARTCL.pptcl[i][0] ,  // x, y, z and 0 momenta
 459                   PARTCL.pptcl[i][1] ,
 460                   PARTCL.pptcl[i][2] ,
 461                   PARTCL.pptcl[i][3] ,
 462
 463                   0, // Velocities - currently not used.
 464                   0,
 465                   0,
 466                   0);
 467           }
 468       }
 469   }
 470   else if (!strcmp(option,"All")) {
 471       nump=numpart;
 472       for (Int_t i = 0; i < numpart; i++) {
 473
 474           // Determine mother particle. Set to -1 if the particle originates from
 475           // a parton or is a beam particle.
 476
 477           Int_t origin = PARTCL.iorig[i];
 478           Int_t jet = origin / PARTCL.ipack;
 479           origin = origin - (jet * PARTCL.ipack);
 480
 481           if (origin < 0) origin = 0;
 482
 483           // Determine first and last decay products. Both are -1 if the particle is stable.
 484           // Note this means they are set to 0, because one is subtracted after decoding;
 485           // this avoid off-by-one errors relative to the FORTRAN.
 486
 487           Int_t first_Daughter = 0;
 488           Int_t last_Daughter = 0;
 489
 490           if (PARTCL.idcay[i] != 0) {
 491               first_Daughter = PARTCL.idcay[i] / PARTCL.ipack;
 492               last_Daughter = PARTCL.idcay[i] - (first_Daughter * PARTCL.ipack);
 493           }
 494           new(Particles[i]) TParticle(
 495               converter->ConvertIsajetToPdg(PARTCL.ident[i]) ,
 496               0,
 497
 498               origin - 1,
 499               -1,
 500               first_Daughter - 1,
 501               last_Daughter - 1,
 502
 503               PARTCL.pptcl[i][0] ,
 504               PARTCL.pptcl[i][1] ,
 505               PARTCL.pptcl[i][2] ,
 506               PARTCL.pptcl[i][3] ,
 507
 508               0,
 509               0,
 510               0,
 511               0);
 512       }
 513   }
 514   return nump;
 515 }
 516
 517 /**************************************************************************/
 518
 519 void TIsajet::GenerateEvent()
 520 {
 521     Int_t e, ok, done;
 522
 523 //    e = 0;
 524
 525 //    if (online) Isabg2(e);
 526 //    else Isabeg(e);
 527
 528     e = 1;
 529     Isaevt(e, ok, done);
 530 }
 531
 532 /**************************************************************************/
 533
 534 void TIsajet::SetJobtype(Char_t *val)
 535 {
 536     if ((!strcmp(val, "TWOJET")) || (!strcmp(val, "E+E-")) ||
 537     (!strcmp(val, "DRELLYAN")) || (!strcmp(val, "MINBIAS")) ||
 538     (!strcmp(val, "SUSY")) || (!strcmp(val, "WPAIR")) ||
 539     (!strcmp(val, "HIGGS")) || (!strcmp(val, "PHOTON")) ||
 540     (!strcmp(val, "TCOLOR")) || (!strcmp(val, "WHIGGS")) ||
 541     (!strcmp(val, "EXTRADIM")) || (!strcmp(val, "ZJJ"))) {
 542             jobtype = val;
 543     }
 544     else {
 545         printf("Error in TIsajet::SetJobtype :\n");
 546         printf("Invalid reaction keyword %s.\n", val);
 547         printf("Valid keywords are : TWOJET, E+E-, DRELLYAN,\n");
 548         printf("MINBIAS, SUSY, WPAIR, HIGGS, PHOTON, TCOLOR,\n");
 549         printf("WHIGGS, EXTRADIM and ZJJ.\n");
 550     }
 551 }
 552
 553 /**************************************************************************/
 554
 555 void TIsajet::GetJobtype() const
 556 {
 557     printf ("Current job type is %s.\n", jobtype);
 558 }
 559
 560 /**************************************************************************/
 561
 562 void TIsajet::SetOnline(Bool_t val)
 563 {
 564     online = val;
 565 }
 566
 567 /**************************************************************************/
 568
 569 Bool_t TIsajet::GetOnline() const
 570 {
 571     return online;
 572 }
 573
 574 /**************************************************************************/
 575
 576 void TIsajet::SetPDF(Char_t *name, Float_t val)
 577 {
 578     if (num_Pdf < 19) {
 579         pdfpar[num_Pdf] = name;
 580         pdfval[num_Pdf] = val;
 581         num_Pdf++;
 582         setPdf = true;
 583     }
 584     else {
 585         printf ("Error in TIsajet::SetPDF :\n");
 586         printf ("Maximum of twenty PDF parameters may be set.\n");
 587     }
 588 }
 589
 590 /**************************************************************************/
 591
 592 // Access routines for common blocks.
 593 // Begins DYLIM access.
 594
 595 /**************************************************************************/
 596
 597 void TIsajet::SetQMIN(Float_t val)
 598 {
 599     if (val > DYLIM.qmax) {
 600         printf("Error in TIsajet::SetQMIN : \n");
 601         printf("You may not set QMIN to a value larger than QMAX = %f.\n", DYLIM.qmax);
 602         return;
 603     }
 604
 605     DYLIM.qmin = val;
 606     if (!DYLIM.ywset) SetYWLIMS();
 607 }
 608
 609 /**************************************************************************/
 610
 611 Float_t TIsajet::GetQMIN() const
 612 {
 613     return DYLIM.qmin;
 614 }
 615
 616 /**************************************************************************/
 617
 618 void TIsajet::SetQMAX(Float_t val)
 619 {
 620     if (val < DYLIM.qmin) {
 621         printf("Error in TIsajet::SetQMAX : \n");
 622         printf("You may not set QMAX to a value less than QMIN = %f.\n", DYLIM.qmin);
 623         return;
 624     }
 625
 626     DYLIM.qmax = val;
 627 }
 628
 629 /**************************************************************************/
 630
 631 Float_t TIsajet::GetQMAX() const
 632 {
 633     return DYLIM.qmax;
 634 }
 635
 636 /**************************************************************************/
 637
 638 void TIsajet::SetQTMIN(Float_t val)
 639 {
 640     if (val > DYLIM.qtmax) {
 641         printf("Error in TIsajet::SetQTMIN : \n");
 642         printf("You may not set QTMIN to a value larger than QTMAX = %f.\n", DYLIM.qtmax);
 643         return;
 644     }
 645     DYLIM.qtmin = val;
 646     if (!DYLIM.ywset) SetYWLIMS();
 647 }
 648
 649 /**************************************************************************/
 650
 651 Float_t TIsajet::GetQTMIN() const
 652 {
 653     return DYLIM.qtmin;
 654 }
 655
 656 /**************************************************************************/
 657
 658 void TIsajet::SetQTMAX(Float_t val)
 659 {
 660     if (val < DYLIM.qtmin) {
 661         printf("Error in TIsajet::SetQTMAX : \n");
 662         printf("You may not set QTMAX to a value less than QTMIN = %f.\n", DYLIM.qtmin);
 663         return;
 664     }
 665
 666     DYLIM.qtmax = val;
 667     if (!DYLIM.ywset) SetYWLIMS();
 668 }
 669
 670 /**************************************************************************/
 671
 672 Float_t TIsajet::GetQTMAX() const
 673 {
 674     return DYLIM.qtmax;
 675 }
 676
 677 /**************************************************************************/
 678
 679 void TIsajet::SetYWMIN(Float_t val)
 680 {
 681     if (val > DYLIM.ywmax) {
 682         printf("Error in TIsajet::SetYWMIN : \n");
 683         printf("You may not set YWMIN to a value larger than YWMAX = %f.\n", DYLIM.ywmax);
 684         return;
 685     }
 686
 687     if (DYLIM.thwset) {
 688         printf("Error in TIsajet::SetYWMIN :\n");
 689         printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMIN.\n");
 690     }
 691     else {
 692         DYLIM.ywset = true;
 693         DYLIM.ywmin = val;
 694     }
 695 }
 696
 697 /**************************************************************************/
 698
 699 Float_t TIsajet::GetYWMIN() const
 700 {
 701     return DYLIM.ywmin;
 702 }
 703
 704 /**************************************************************************/
 705
 706 void TIsajet::SetYWMAX(Float_t val)
 707 {
 708     if (val < DYLIM.ywmin) {
 709         printf("Error in TIsajet::SetYWMAX : \n");
 710         printf("You may not set YWMAX to a value less than YWMIN = %f.\n", DYLIM.ywmin);
 711         return;
 712     }
 713
 714     if (DYLIM.thwset) {
 715         printf("Error in TIsajet::SetYWMAX :\n");
 716         printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMAX.\n");
 717     }
 718     else {
 719         DYLIM.ywset = true;
 720         DYLIM.ywmax = val;
 721     }
 722 }
 723
 724 /**************************************************************************/
 725
 726 Float_t TIsajet::GetYWMAX() const
 727 {
 728     return DYLIM.ywmax;
 729 }
 730
 731 /**************************************************************************/
 732
 733 void TIsajet::SetYWLIMS()
 734 {
 735     Float_t rot = sqrt(DYLIM.qmin * DYLIM.qmin + DYLIM.qtmin * DYLIM.qtmin);
 736     DYLIM.ywmax = acosh(PRIMAR.halfe / rot);
 737     DYLIM.ywmin = -DYLIM.ywmax;
 738     DYLIM.ywset = false;
 739 }
 740
 741 /**************************************************************************/
 742
 743 void TIsajet::SetXWMIN(Float_t val)
 744 {
 745     if (val > DYLIM.xwmax) {
 746         printf("Error in TIsajet::SetXWMIN : \n");
 747         printf("You may not set XWMIN to a value larger than XWMAX = %f.\n", DYLIM.xwmax);
 748         return;
 749     }
 750     DYLIM.xwmin = val;
 751 }
 752
 753 /**************************************************************************/
 754
 755 Float_t TIsajet::GetXWMIN() const
 756 {
 757     return DYLIM.xwmin;
 758 }
 759
 760 /**************************************************************************/
 761
 762 void TIsajet::SetXWMAX(Float_t val)
 763 {
 764     if (val < DYLIM.xwmin) {
 765         printf("Error in TIsajet::SetXWMAX : \n");
 766         printf("You may not set XWMAX to a value less than XWMIN = %f.\n", DYLIM.xwmin);
 767         return;
 768     }
 769
 770     DYLIM.xwmax = val;
 771 }
 772
 773 /**************************************************************************/
 774
 775 Float_t TIsajet::GetXWMAX() const
 776 {
 777     return DYLIM.xwmax;
 778 }
 779
 780 /**************************************************************************/
 781
 782 void TIsajet::SetTHWMIN(Float_t val)
 783 {
 784     if (val > DYLIM.thwmax) {
 785         printf("Error in TIsajet::SetTHWMIN : \n");
 786         printf("You may not set THWMIN to a value larger than THWMAX = %f.\n", DYLIM.thwmax);
 787         return;
 788     }
 789
 790     if (DYLIM.ywset) {
 791         printf("Error in TIsajet::SetTHWMIN :\n");
 792         printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMIN.\n");
 793     }
 794     else {
 795         DYLIM.thwset = true;
 796         DYLIM.thwmin = val;
 797     }
 798 }
 799
 800 /**************************************************************************/
 801
 802 Float_t TIsajet::GetTHWMIN() const
 803 {
 804     return DYLIM.thwmin;
 805 }
 806
 807 /**************************************************************************/
 808
 809 void TIsajet::SetTHWMAX(Float_t val)
 810 {
 811     if (val < DYLIM.thwmin) {
 812         printf("Error in TIsajet::SetTHWMAX : \n");
 813         printf("You may not set THWMAX to a value less than THWMIN = %f.\n", DYLIM.thwmin);
 814         return;
 815     }
 816
 817     if (DYLIM.ywset) {
 818         printf("Error in TIsajet::SetTHWMAX :\n");
 819         printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMAX.\n");
 820     }
 821     else {
 822         DYLIM.thwset = true;
 823         DYLIM.thwmax = val;
 824     }
 825 }
 826
 827 /**************************************************************************/
 828
 829 Float_t TIsajet::GetTHWMAX() const
 830 {
 831     return DYLIM.thwmax;
 832 }
 833
 834 /**************************************************************************/
 835
 836 void TIsajet::SetTHWLIMS()
 837 {
 838     DYLIM.thwmin = 0;
 839     DYLIM.thwmax = TMath::Pi();
 840     DYLIM.thwset = false;
 841 }
 842
 843 /**************************************************************************/
 844
 845 void TIsajet::SetPHWMIN(Float_t val)
 846 {
 847     if (val > DYLIM.phwmax) {
 848         printf("Error in TIsajet::SetPHWMIN : \n");
 849         printf("You may not set PHWMIN to a value larger than PHWMAX = %f.\n", DYLIM.phwmax);
 850         return;
 851     }
 852     DYLIM.phwmin = val;
 853 }
 854
 855 /**************************************************************************/
 856
 857 Float_t TIsajet::GetPHWMIN() const
 858 {
 859     return DYLIM.phwmin;
 860 }
 861
 862 /**************************************************************************/
 863
 864 void TIsajet::SetPHWMAX(Float_t val)
 865 {
 866     if (val < DYLIM.phwmin) {
 867         printf("Error in TIsajet::SetPHWMAX : \n");
 868         printf("You may not set PHWMAX to a value less than PHWMIN = %f.\n", DYLIM.phwmin);
 869         return;
 870     }
 871
 872     DYLIM.phwmax = val;
 873 }
 874
 875 /**************************************************************************/
 876
 877 Float_t TIsajet::GetPHWMAX() const
 878 {
 879     return DYLIM.phwmax;
 880 }
 881
 882 /**************************************************************************/
 883
 884 Bool_t TIsajet::GetSETLMQ(Int_t index) const
 885 {
 886     Int_t length = (sizeof DYLIM.setlmq / sizeof DYLIM.setlmq[0]);
 887     if ((index < 0) || (index >= length)) {
 888         printf ("Error in TIsajet::GetSETLMQ : \n");
 889         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
 890         return 0;
 891     }
 892
 893     return DYLIM.setlmq[index];
 894 }
 895
 896 /**************************************************************************/
 897
 898 // End of DYLIM access.
 899 // Begins EEPAR access.
 900
 901 /**************************************************************************/
 902
 903 void TIsajet::SetPLEP(Float_t val)
 904 {
 905     EEPAR.plep = val;
 906 }
 907
 908 /**************************************************************************/
 909
 910 Float_t TIsajet::GetPLEP() const
 911 {
 912     return EEPAR.plep;
 913 }
 914
 915 /**************************************************************************/
 916
 917 void TIsajet::SetPLEM(Float_t val)
 918 {
 919     EEPAR.plem = val;
 920 }
 921
 922 /**************************************************************************/
 923
 924 Float_t TIsajet::GetPLEM() const
 925 {
 926     return EEPAR.plem;
 927 }
 928
 929 /**************************************************************************/
 930
 931 void TIsajet::SetRSHMIN(Float_t val)
 932 {
 933     if (val > EEPAR.rshmax) {
 934         printf("Error in TIsajet::SetRSHMIN : \n");
 935         printf("You may not set RSHMIN to a value larger than RSHMAX = %f.\n", EEPAR.rshmax);
 936         return;
 937     }
 938     EEPAR.rshmin = val;
 939 }
 940
 941 /**************************************************************************/
 942
 943 Float_t TIsajet::GetRSHMIN() const
 944 {
 945     return EEPAR.rshmin;
 946 }
 947
 948 /**************************************************************************/
 949
 950 void TIsajet::SetRSHMAX(Float_t val)
 951 {
 952     if (val < EEPAR.rshmin) {
 953         printf("Error in TIsajet::SetRSHMAX : \n");
 954         printf("You may not set RSHMAX to a value less than RSHMIN = %f.\n", EEPAR.rshmin);
 955         return;
 956     }
 957
 958     EEPAR.rshmax = val;
 959 }
 960
 961 /**************************************************************************/
 962
 963 Float_t TIsajet::GetRSHMAX() const
 964 {
 965     return EEPAR.rshmax;
 966 }
 967
 968 /**************************************************************************/
 969
 970 void TIsajet::SetUPSLON(Float_t val)
 971 {
 972     EEPAR.upslon = val;
 973 }
 974
 975 /**************************************************************************/
 976
 977 Float_t TIsajet::GetUPSLON() const
 978 {
 979     return EEPAR.upslon;
 980 }
 981
 982 /**************************************************************************/
 983
 984 void TIsajet::SetSIGZ(Float_t val)
 985 {
 986     EEPAR.sigz = val;
 987 }
 988
 989 /**************************************************************************/
 990
 991 Float_t TIsajet::GetSIGZ() const
 992 {
 993     return EEPAR.sigz;
 994 }
 995
 996 /**************************************************************************/
 997
 998 Bool_t TIsajet::GetIBREM() const
 999 {
1000     return EEPAR.ibrem;
1001 }
1002
1003 /**************************************************************************/
1004
1005 Bool_t TIsajet::GetIBEAM() const
1006 {
1007     return EEPAR.ibeam;
1008 }
1009
1010 /**************************************************************************/
1011
1012 Float_t TIsajet::GetSGMXEE() const
1013 {
1014     return EEPAR.sgmxee;
1015 }
1016
1017 /**************************************************************************/
1018
1019 // End of EEPAR access.
1020 // Begins FORCE access.
1021
1022 /**************************************************************************/
1023
1024 Int_t TIsajet::GetNFORCE() const
1025 {
1026     return FORCE.nforce;
1027 }
1028
1029 /**************************************************************************/
1030
1031 void TIsajet::SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti = true)
1032 {
1033     if (GetNFORCE() >= FORCE.mxforc - anti) {
1034         printf ("ERROR in TIsajet::SetIFORCE :\n");
1035         printf ("Cannot have more than %d forced decays.\n", FORCE.mxforc );
1036         return;
1037     }
1038
1039     if ((arraySize > 6) || (arraySize < 2)) {
1040         printf ("Error in TIsajet::SetIFORCE : \n");
1041         printf ("Invalid array size %d; must be 2-6.\n", arraySize);
1042         return;
1043     }
1044
1045     for (Int_t i = 0; i < FORCE.nforce; i++) {
1046         if (FORCE.iforce[i] == val[0]) {
1047             printf ("Error in TIsajet::SetIFORCE : \n");
1048             printf ("Particle %d has already been forced, index %d.\n", val[0], i);
1049             return;
1050         }
1051     }
1052
1053
1054     FORCE.iforce[FORCE.nforce] = val[0];
1055     for (Int_t i = 1; i < arraySize; i++) {
1056         FORCE.mforce[FORCE.nforce][i-1] = val[i];
1057     }
1058
1059     FORCE.nforce++;
1060
1061     printf ("Decay channel %d -> ", val[0]);
1062     for (Int_t i = 1; i < arraySize; i++) {
1063         printf ("%d, ", val[i]);
1064     }
1065     printf ("set. \n");
1066
1067     if (anti) {
1068         Int_t antivals[arraySize];
1069         for (Int_t i = 0; i < arraySize; i++){
1070             antivals[i] = (0 - val[i]);
1071         }
1072         SetIFORCE(antivals, arraySize, false);
1073     }
1074 }
1075
1076 /**************************************************************************/
1077
1078 void TIsajet::UnForce(Int_t index, Bool_t anti = true)
1079 {
1080     if (FORCE.nforce == 0) {
1081         printf ("Error in TIsajet::UnForce : \n");
1082         printf ("No decays have been forced.\n");
1083         return;
1084     }
1085
1086     if ((index < 0) || (index >= FORCE.nforce)) {
1087         printf ("Error in TIsajet::UnForce : \n");
1088         printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1089         return;
1090     }
1091
1092     Int_t particle_ID = FORCE.iforce[index];
1093
1094     for (Int_t i = index; i < FORCE.mxforc - 1; i++) {
1095         FORCE.iforce[i] = FORCE.iforce[i+1];
1096         for (Int_t j = 0; j < 5; j++) {
1097             FORCE.mforce[i][j] = FORCE.mforce[i+1][j];
1098         }
1099     }
1100     FORCE.iforce[FORCE.mxforc - 1] = 0;
1101     for (Int_t j = 0; j < 5; j++) {
1102         FORCE.mforce[FORCE.mxforc - 1][j] = 0;
1103     }
1104
1105     FORCE.nforce--;
1106
1107     printf ("Decay of %d unforced.\n", particle_ID);
1108
1109     if (anti) UnForceID(-particle_ID, false);
1110 }
1111
1112 /**************************************************************************/
1113
1114 void TIsajet::UnForceID(Int_t particle_ID, Bool_t anti = true)
1115 {
1116     if (FORCE.nforce == 0) {
1117         printf ("Error in TIsajet::UnForceID : \n");
1118         printf ("No decays have been forced.\n");
1119         return;
1120     }
1121
1122     for (Int_t i = 0; i < FORCE.nforce; i++) {
1123         if (FORCE.iforce[i] == particle_ID) {
1124             UnForce(i, anti);
1125             return;
1126         }
1127     }
1128
1129     printf ("Error in TIsajet::UnForceID : \n");
1130     printf ("Cannot find particle %d.\n", particle_ID);
1131 }
1132
1133 /**************************************************************************/
1134
1135 Int_t* TIsajet::GetIFORCE(Int_t index) const
1136 {
1137     if (FORCE.nforce == 0) {
1138         printf ("Error in TIsajet::GetIFORCE : \n");
1139         printf ("No decays have been forced.\n");
1140         return 0;
1141     }
1142
1143     if ((index < 0) || (index >= FORCE.nforce)) {
1144         printf ("Error in TIsajet::GetIFORCE : \n");
1145         printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1146         return 0;
1147     }
1148
1149     Int_t decay[6];
1150     decay[0] = FORCE.iforce[index];
1151
1152     for (Int_t i = 1; i < 6; i++) {
1153         decay[i] = FORCE.mforce[index][i-1];
1154     }
1155
1156     return decay;
1157 }
1158
1159 /**************************************************************************/
1160
1161 Int_t TIsajet::GetMEFORC(Int_t index) const
1162 {
1163     if (FORCE.nforce == 0) {
1164         printf ("Error in TIsajet::GetMEFORCE : \n");
1165         printf ("No decays have been forced.\n");
1166         return 0;
1167     }
1168
1169     if ((index < 0) || (index >= FORCE.nforce)) {
1170         printf ("Error in TIsajet::GetMEFORC : \n");
1171         printf ("Invalid array index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1172         return 0;
1173     }
1174
1175     return FORCE.meforc[index];
1176 }
1177
1178 /**************************************************************************/
1179
1180 // End of FORCE access.
1181 // Begins FRGPAR access.
1182
1183 /**************************************************************************/
1184
1185 void TIsajet::SetFRPAR(Float_t val, Int_t index)
1186 {
1187     Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1188     if ((index < 0) || (index >= length)) {
1189         printf ("Error in TIsajet::SetFRPAR : \n");
1190         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1191         return;
1192     }
1193
1194     *FRGPAR.frpar[index] = val;
1195     setFragment = true;
1196 }
1197
1198 /**************************************************************************/
1199
1200 void TIsajet::SetAllFRPAR(const Float_t val[], Int_t arraySize)
1201 {
1202     Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1203     if (arraySize != length) {
1204         printf ("Error in TIsajet::SetAllFRPAR : \n");
1205         printf ("Array must have %d elements.\n", length);
1206         return;
1207     }
1208
1209     for (Int_t i = 0; i < arraySize; i++) {
1210         SetFRPAR(val[i], i);
1211     }
1212 }
1213
1214 /**************************************************************************/
1215
1216 Float_t TIsajet::GetFRPAR(Int_t index) const
1217 {
1218     Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1219     if ((index < 0) || (index >= length)) {
1220         printf ("Error in TIsajet::GetFRPAR : \n");
1221         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1222         return 0;
1223     }
1224
1225     return *FRGPAR.frpar[index];
1226 }
1227
1228 /**************************************************************************/
1229
1230 void TIsajet::SetPUD(Float_t val)
1231 {
1232     SetFRPAR(val, 0);
1233 }
1234
1235 /**************************************************************************/
1236
1237 Float_t TIsajet::GetPUD() const
1238 {
1239     return GetFRPAR(0);
1240 }
1241
1242 /**************************************************************************/
1243
1244 void TIsajet::SetPBARY(Float_t val)
1245 {
1246     SetFRPAR(val, 1);
1247 }
1248
1249 /**************************************************************************/
1250
1251 Float_t TIsajet::GetPBARY() const
1252 {
1253     return GetFRPAR(1);
1254 }
1255
1256 /**************************************************************************/
1257
1258 void TIsajet::SetSIGQT(Float_t val)
1259 {
1260     SetFRPAR(val, 2);
1261 }
1262
1263 /**************************************************************************/
1264
1265 Float_t TIsajet::GetSIGQT() const
1266 {
1267     return GetFRPAR(2);
1268 }
1269
1270 /**************************************************************************/
1271
1272 void TIsajet::SetPEND(Float_t val)
1273 {
1274     SetFRPAR(val, 3);
1275 }
1276
1277 /**************************************************************************/
1278
1279 Float_t TIsajet::GetPEND() const
1280 {
1281     return GetFRPAR(3);
1282 }
1283
1284 /**************************************************************************/
1285
1286 void TIsajet::SetXGEN(Float_t val, Int_t index)
1287 {
1288     Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1289     if ((index < 0) || (index >= length)) {
1290         printf ("Error in TIsajet::SetXGEN : \n");
1291         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1292         return;
1293     }
1294     SetFRPAR(val, index + 4);
1295     setXgen = true;
1296 }
1297
1298 /**************************************************************************/
1299
1300 void TIsajet::SetAllXGEN(const Float_t val[], Int_t arraySize)
1301 {
1302     Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1303     if (arraySize != length) {
1304         printf ("Error in TIsajet::SetAllXGEN : \n");
1305         printf ("Array must have %d elements.\n", length);
1306         return;
1307     }
1308
1309     for (Int_t i = 0; i < arraySize; i++) {
1310         SetXGEN(val[i], i);
1311     }
1312 }
1313
1314 /**************************************************************************/
1315
1316 Float_t TIsajet::GetXGEN(Int_t index) const
1317 {
1318     Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1319     if ((index < 0) || (index >= length)) {
1320         printf ("Error in TIsajet::GetXGEN : \n");
1321         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1322         return 0;
1323     }
1324
1325     return GetFRPAR(index + 4);
1326 }
1327
1328 /**************************************************************************/
1329
1330 void TIsajet::SetPSPIN1(Float_t val, Int_t index)
1331 {
1332     Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
1333     if ((index < 0) || (index >= length)) {
1334         printf ("Error in TIsajet::SetPSPIN1 : \n");
1335         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1336         return;
1337     }
1338
1339     SetFRPAR(val, index + 12);
1340 }
1341
1342 /**************************************************************************/
1343
1344 void TIsajet::SetAllPSPIN1(const Float_t val[], Int_t arraySize)
1345 {
1346     Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
1347     if (arraySize != length) {
1348         printf ("Error in TIsajet::SetAllPSPIN1 : \n");
1349         printf ("Array must have %d elements.\n", length);
1350         return;
1351     }
1352
1353     for (Int_t i = 0; i < arraySize; i++) {
1354         SetPSPIN1(val[i], i);
1355     }
1356 }
1357
1358 /**************************************************************************/
1359
1360 Float_t TIsajet::GetPSPIN1(Int_t index) const
1361 {
1362     Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1363     if ((index < 0) || (index >= length)) {
1364         printf ("Error in TIsajet::GetPSPIN1 : \n");
1365         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1366         return 0;
1367     }
1368
1369     return GetFRPAR(index + 12);
1370 }
1371
1372 /**************************************************************************/
1373
1374 void TIsajet::SetPMIX1(Float_t val, Int_t index1, Int_t index2)
1375 {
1376     Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1377     Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1378
1379     if ((index1 < 0) || (index1 >= row_num)) {
1380         printf ("Error in TIsajet::SetPMIX1 : \n");
1381         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1382         return;
1383     }
1384
1385     if ((index2 < 0) || (index2 >= col_num)) {
1386         printf ("Error in TIsajet::SetPMIX1 : \n");
1387         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1388         return;
1389     }
1390
1391     FRGPAR.pmix1[index1][index2] = val;
1392     setFragment = true;
1393 }
1394
1395 /**************************************************************************/
1396
1397 void TIsajet::SetAllPMIX1(const Float_t val[2][3])
1398 {
1399     for (Int_t i = 0; i < 2; i++) {
1400         for (Int_t j = 0; j < 3; j++) {
1401             SetPMIX1(val[i][j], i, j);
1402         }
1403     }
1404 }
1405
1406 /**************************************************************************/
1407
1408 void TIsajet::SetColumnPMIX1(const Float_t val[], Int_t col)
1409 {
1410     Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1411     Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1412
1413     if ((col < 0) || (col >= col_num)) {
1414         printf ("Error in TIsajet::SetColumnPMIX1 : \n");
1415         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
1416         return;
1417     }
1418
1419     for (Int_t i = 0; i < row_num; i++) {
1420         SetPMIX1(val[i], i, col);
1421     }
1422 }
1423
1424 /**************************************************************************/
1425
1426 Float_t TIsajet::GetPMIX1(Int_t index1, Int_t index2) const
1427 {
1428     Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1429     Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1430
1431     if ((index1 < 0) || (index1 >= row_num)) {
1432         printf ("Error in TIsajet::GetPMIX1 : \n");
1433         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1434         return 0;
1435     }
1436
1437     if ((index2 < 0) || (index2 >= col_num)) {
1438         printf ("Error in TIsajet::GetPMIX1 : \n");
1439         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1440         return 0;
1441     }
1442
1443     return FRGPAR.pmix1[index1][index2];
1444 }
1445
1446 /**************************************************************************/
1447
1448 void TIsajet::SetPMIX2(Float_t val, Int_t index1, Int_t index2)
1449 {
1450     Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1451     Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1452
1453     if ((index1 < 0) || (index1 >= row_num)) {
1454         printf ("Error in TIsajet::SetPMIX2 : \n");
1455         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1456         return;
1457     }
1458
1459     if ((index2 < 0) || (index2 >= col_num)) {
1460         printf ("Error in TIsajet::SetPMIX2 : \n");
1461         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1462         return;
1463     }
1464
1465     FRGPAR.pmix2[index1][index2] = val;
1466     setFragment = true;
1467 }
1468
1469 /**************************************************************************/
1470
1471 void TIsajet::SetAllPMIX2(const Float_t val[2][3])
1472 {
1473     for (Int_t i = 0; i < 2; i++) {
1474         for (Int_t j = 0; j < 3; j++) {
1475             SetPMIX2(val[i][j], i, j);
1476         }
1477     }
1478 }
1479
1480 /**************************************************************************/
1481
1482 void TIsajet::SetColumnPMIX2(const Float_t val[], Int_t col)
1483 {
1484     Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1485     Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1486
1487     if ((col < 0) || (col >= col_num)) {
1488         printf ("Error in TIsajet::SetColumnPMIX2 : \n");
1489         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
1490         return;
1491     }
1492
1493     for (Int_t i = 0; i < row_num; i++) {
1494         SetPMIX2(val[i], i, col);
1495     }
1496 }
1497
1498 /**************************************************************************/
1499
1500 Float_t TIsajet::GetPMIX2(Int_t index1, Int_t index2) const
1501 {
1502     Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1503     Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1504
1505     if ((index1 < 0) || (index1 >= row_num)) {
1506         printf ("Error in TIsajet::GetPMIX2 : \n");
1507         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1508         return 0;
1509     }
1510
1511     if ((index2 < 0) || (index2 >= col_num)) {
1512         printf ("Error in TIsajet::GetPMIX2 : \n");
1513         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1514         return 0;
1515     }
1516
1517     return FRGPAR.pmix2[index1][index2];
1518 }
1519
1520 /**************************************************************************/
1521
1522 void TIsajet::SetPMIXX1(Float_t val, Int_t index)
1523 {
1524     Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1525     if ((index < 0) || (index >= length)) {
1526         printf ("Error in TIsajet::SetPMIXX1 : \n");
1527         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1528         return;
1529     }
1530
1531     *FRGPAR.pmixx1[index] = val;
1532     setFragment = true;
1533 }
1534
1535 /**************************************************************************/
1536
1537 void TIsajet::SetAllPMIXX1(const Float_t val[], Int_t arraySize)
1538 {
1539     Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1540     if (arraySize != length) {
1541         printf ("Error in TIsajet::SetAllPMIXX1 : \n");
1542         printf ("Array must have %d elements.\n", length);
1543         return;
1544     }
1545
1546     for (Int_t i = 0; i < arraySize; i++) {
1547         SetPMIXX1(val[i], i);
1548     }
1549 }
1550
1551 /**************************************************************************/
1552
1553 Float_t TIsajet::GetPMIXX1(Int_t index) const
1554 {
1555     Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1556     if ((index < 0) || (index >= length)) {
1557         printf ("Error in TIsajet::GetPMIXX1 : \n");
1558         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1559         return 0;
1560     }
1561
1562     return *FRGPAR.pmixx1[index];
1563 }
1564
1565 /**************************************************************************/
1566
1567 void TIsajet::SetPMIXX2(Float_t val, Int_t index)
1568 {
1569     Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1570     if ((index < 0) || (index >= length)) {
1571         printf ("Error in TIsajet::SetPMIXX2 : \n");
1572         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1573         return;
1574     }
1575
1576     *FRGPAR.pmixx2[index] = val;
1577     setFragment = true;
1578 }
1579
1580 /**************************************************************************/
1581
1582 void TIsajet::SetAllPMIXX2(const Float_t val[], Int_t arraySize)
1583 {
1584     Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1585     if (arraySize != length) {
1586         printf ("Error in TIsajet::SetAllPMIXX2 : \n");
1587         printf ("Array must have %d elements.\n", length);
1588         return;
1589     }
1590
1591     for (Int_t i = 0; i < arraySize; i++) {
1592         SetPMIXX2(val[i], i);
1593     }
1594 }
1595
1596 /**************************************************************************/
1597
1598 Float_t TIsajet::GetPMIXX2(Int_t index) const
1599 {
1600     Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1601     if ((index < 0) || (index >= length)) {
1602         printf ("Error in TIsajet::GetPMIXX2 : \n");
1603         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1604         return 0;
1605     }
1606
1607     return *FRGPAR.pmixx2[index];
1608 }
1609
1610 /**************************************************************************/
1611
1612 void TIsajet::SetXGENSS(Float_t val, Int_t index)
1613 {
1614     Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1615     if ((index < 0) || (index >= length)) {
1616         printf ("Error in TIsajet::SetXGENSS : \n");
1617         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1618         return;
1619     }
1620
1621      FRGPAR.xgenss[index] = val;
1622 }
1623
1624 /**************************************************************************/
1625
1626 void TIsajet::SetAllXGENSS(const Float_t val[], Int_t arraySize)
1627 {
1628     Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1629     if (arraySize != length) {
1630         printf ("Error in TIsajet::SetAllXGENSS : \n");
1631         printf ("Array must have %d elements.\n", length);
1632         return;
1633     }
1634
1635     for (Int_t i = 0; i < arraySize; i++) {
1636         SetXGENSS(val[i], i);
1637     }
1638 }
1639
1640 /**************************************************************************/
1641
1642 Float_t TIsajet::GetXGENSS(Int_t index) const
1643 {
1644     Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1645     if ((index < 0) || (index >= length)) {
1646         printf ("Error in TIsajet::GetXGENSS : \n");
1647         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1648         return 0;
1649     }
1650
1651     return FRGPAR.xgenss[index];
1652 }
1653
1654 /**************************************************************************/
1655
1656 // End of FRGPAR access.
1657 // Begins HCON access.
1658
1659 /**************************************************************************/
1660
1661 Float_t TIsajet::GetANWWWW(Int_t index1, Int_t index2, Int_t index3) const
1662 {
1663     Int_t elem_Size = sizeof HCON.anwwww[0][0][0];
1664     Int_t thd_Dim_Length = (sizeof HCON.anwwww[0][0] / elem_Size);
1665     Int_t sec_Dim_Length = (sizeof HCON.anwwww[0] / (elem_Size * thd_Dim_Length));
1666     Int_t fst_Dim_Length = (sizeof HCON.anwwww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
1667
1668     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1669         printf ("Error in TIsajet::GetANWWWW : \n");
1670         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1671         return 0;
1672     }
1673
1674     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1675         printf ("Error in TIsajet::GetANWWWW : \n");
1676         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1677         return 0;
1678     }
1679
1680     if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
1681         printf ("Error in TIsajet::GetANWWWW : \n");
1682         printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
1683         return 0;
1684     }
1685
1686     return HCON.anwwww[index1][index2][index3];
1687 }
1688
1689 /**************************************************************************/
1690
1691 Float_t TIsajet::GetADWWWW(Int_t index1, Int_t index2) const
1692 {
1693     Int_t elem_Size = sizeof HCON.adwwww[0][0];
1694     Int_t sec_Dim_Length = (sizeof HCON.adwwww[0] / elem_Size);
1695     Int_t fst_Dim_Length = (sizeof HCON.adwwww / (elem_Size * sec_Dim_Length));
1696
1697     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1698         printf ("Error in TIsajet::GetADWWWW : \n");
1699         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1700         return 0;
1701     }
1702
1703     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1704         printf ("Error in TIsajet::GetADWWWW : \n");
1705         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1706         return 0;
1707     }
1708
1709     return HCON.adwwww[index1][index2];
1710 }
1711
1712 /**************************************************************************/
1713
1714 Float_t TIsajet::GetAIWWWW(Int_t index) const
1715 {
1716     Int_t length = (sizeof HCON.aiwwww / sizeof HCON.aiwwww[0]);
1717     if ((index < 0) || (index >= length)) {
1718         printf ("Error in TIsajet::GetAIWWWW : \n");
1719         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1720         return 0;
1721     }
1722
1723     return HCON.aiwwww[index];
1724 }
1725
1726 /**************************************************************************/
1727
1728 Float_t TIsajet::GetHMASS() const
1729 {
1730     return HCON.hmass;
1731 }
1732
1733 /**************************************************************************/
1734
1735 Float_t TIsajet::GetHGAM() const
1736 {
1737     return HCON.hgam;
1738 }
1739
1740 /**************************************************************************/
1741
1742 Float_t TIsajet::GetHGAMS(Int_t index) const
1743 {
1744     Int_t length = (sizeof HCON.hgams / sizeof HCON.hgams[0]);
1745     if ((index < 0) || (index >= length)) {
1746         printf ("Error in TIsajet::GetHGAMS : \n");
1747         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1748         return 0;
1749     }
1750
1751     return HCON.hgams[index];
1752 }
1753
1754 /**************************************************************************/
1755
1756 Float_t TIsajet::GetETAHGG() const
1757 {
1758     return HCON.etahgg;
1759 }
1760
1761 /**************************************************************************/
1762
1763 Int_t TIsajet::GetMATCHH(Int_t index) const
1764 {
1765     Int_t length = (sizeof HCON.matchh / sizeof HCON.matchh[0]);
1766     if ((index < 0) || (index >= length)) {
1767         printf ("Error in TIsajet::GetMATCHH : \n");
1768         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1769         return 0;
1770     }
1771
1772     return HCON.matchh[index];
1773 }
1774
1775 /**************************************************************************/
1776
1777 Float_t TIsajet::GetZSTARS(Int_t index1, Int_t index2) const
1778 {
1779     Int_t elem_Size = sizeof HCON.zstars[0][0];
1780     Int_t sec_Dim_Length = (sizeof HCON.zstars[0] / elem_Size);
1781     Int_t fst_Dim_Length = (sizeof HCON.zstars / (elem_Size * sec_Dim_Length));
1782
1783     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1784         printf ("Error in TIsajet::GetZSTARS : \n");
1785         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1786         return 0;
1787     }
1788
1789     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1790         printf ("Error in TIsajet::GetZSTARS : \n");
1791         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1792         return 0;
1793     }
1794
1795     return HCON.zstars[index1][index2];
1796 }
1797
1798 /**************************************************************************/
1799
1800 void TIsajet::SetIHTYPE(Int_t val)
1801 {
1802     if ((val < 82) || (val > 84)) {
1803         printf ("Error in TIsajet::SetIHTYPE : \n");
1804         printf ("Invalid input value %d. Possible values are 82, 83, 84.\n", val);
1805         return;
1806     }
1807
1808     HCON.ihtype = val;
1809 }
1810
1811 /**************************************************************************/
1812
1813 void TIsajet::SetIHTYPE(Char_t val[])
1814 {
1815     if (!strcmp("HL0", val)) {
1816         HCON.ihtype = 82;
1817     }
1818     else if (!strcmp("HH0", val)) {
1819         HCON.ihtype = 83;
1820     }
1821     else if (!strcmp("HA0", val)){
1822         HCON.ihtype = 84;
1823     }
1824     else {
1825         printf ("Error in TIsajet::SetIHTYPE : \n");
1826         printf ("Invalid input string %s. Possible strings are HL0, HH0, HA0.\n", val);
1827     }
1828 }
1829
1830 /**************************************************************************/
1831
1832 Int_t TIsajet::GetIHTYPE() const
1833 {
1834     return HCON.ihtype;
1835 }
1836
1837 /**************************************************************************/
1838
1839 Float_t TIsajet::GetHGAMSS(Int_t index1, Int_t index2) const
1840 {
1841     Int_t elem_Size = sizeof HCON.hgamss[0][0];
1842     Int_t sec_Dim_Length = (sizeof HCON.hgamss[0] / elem_Size);
1843     Int_t fst_Dim_Length = (sizeof HCON.hgamss / (elem_Size * sec_Dim_Length));
1844
1845     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1846         printf ("Error in TIsajet::GetHGAMSS : \n");
1847         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1848         return 0;
1849     }
1850
1851     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1852         printf ("Error in TIsajet::GetHGAMSS : \n");
1853         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1854         return 0;
1855     }
1856
1857     return HCON.hgamss[index1][index2];
1858 }
1859
1860 /**************************************************************************/
1861
1862 // End of HCON access
1863 // Begins JETLIM access
1864
1865 /**************************************************************************/
1866
1867 void TIsajet::SetPMIN(Float_t val, Int_t index)
1868 {
1869     Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1870     if ((index < 0) || (index >= length)) {
1871         printf ("Error in TIsajet::SetPMIN : \n");
1872         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1873         return;
1874     }
1875
1876     if (val > JETLIM.pmax[index]) {
1877         printf("Error in TIsajet::SetPMIN : \n");
1878         printf("You may not set PMIN to a value larger than PMAX = %f.\n", JETLIM.pmax[index]);
1879         return;
1880     }
1881
1882     JETLIM.pmin[index] = val;
1883     setP = true;
1884 }
1885
1886 /**************************************************************************/
1887
1888 void TIsajet::SetAllPMIN(const Float_t val[], Int_t arraySize)
1889 {
1890     Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1891     if (arraySize != length) {
1892         printf ("Error in TIsajet::SetAllPMIN : \n");
1893         printf ("Array must have %d elements.\n", length);
1894         return;
1895     }
1896
1897     for (Int_t i = 0; i < arraySize; i++) {
1898         SetPMIN(val[i], i);
1899     }
1900 }
1901
1902 /**************************************************************************/
1903
1904 Float_t TIsajet::GetPMIN(Int_t index) const
1905 {
1906     Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1907     if ((index < 0) || (index >= length)) {
1908         printf ("Error in TIsajet::GetPMIN : \n");
1909         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1910         return 0;
1911     }
1912
1913     return JETLIM.pmin[index];
1914 }
1915
1916 /**************************************************************************/
1917
1918 void TIsajet::SetPMAX(Float_t val, Int_t index)
1919 {
1920     Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1921     if ((index < 0) || (index >= length)) {
1922         printf ("Error in TIsajet::SetPMAX : \n");
1923         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1924         return;
1925     }
1926
1927     if (val < JETLIM.pmin[index]) {
1928         printf("Error in TIsajet::SetPMAX : \n");
1929         printf("You may not set PMAX to a value larger than PMIN = %f.\n", JETLIM.pmin[index]);
1930         return;
1931     }
1932
1933     JETLIM.pmax[index] = val;
1934     setP = true;
1935 }
1936
1937 /**************************************************************************/
1938
1939 void TIsajet::SetAllPMAX(const Float_t val[], Int_t arraySize)
1940 {
1941     Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1942     if (arraySize != length) {
1943         printf ("Error in TIsajet::SetAllPMAX : \n");
1944         printf ("Array must have %d elements.\n", length);
1945         return;
1946     }
1947
1948     for (Int_t i = 0; i < arraySize; i++) {
1949         SetPMAX(val[i], i);
1950     }
1951 }
1952
1953 /**************************************************************************/
1954
1955 Float_t TIsajet::GetPMAX(Int_t index) const
1956 {
1957     Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1958     if ((index < 0) || (index >= length)) {
1959         printf ("Error in TIsajet::GetPMAX : \n");
1960         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1961         return 0;
1962     }
1963
1964     return JETLIM.pmax[index];
1965 }
1966
1967 /**************************************************************************/
1968
1969 void TIsajet::SetPTMIN(Float_t val, Int_t index)
1970 {
1971     Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
1972     if ((index < 0) || (index >= length)) {
1973         printf ("Error in TIsajet::SetPTMIN : \n");
1974         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1975         return;
1976     }
1977 /* andreas 7/8/2001
1978     if (val > JETLIM.ptmax[index]) {
1979         printf("Error in TIsajet::SetPTMIN : \n");
1980         printf("You may not set PTMIN to a value larger than PTMAX = %f.\n", JETLIM.ptmax[index]);
1981         return;
1982     }
1983 */
1984      JETLIM.ptmin[index] = val;
1985 //     if (!setY) SetYJLIMS();
1986 //     if (!setTheta) SetTHLIMS();
1987      setPt = true;
1988 }
1989
1990 /**************************************************************************/
1991
1992 void TIsajet::SetAllPTMIN(const Float_t val[], Int_t arraySize)
1993 {
1994     Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
1995     if (arraySize != length) {
1996         printf ("Error in TIsajet::SetAllPTMIN : \n");
1997         printf ("Array must have %d elements.\n", length);
1998         return;
1999     }
2000
2001     for (Int_t i = 0; i < arraySize; i++) {
2002         SetPTMIN(val[i], i);
2003     }
2004 }
2005
2006 /**************************************************************************/
2007
2008 Float_t TIsajet::GetPTMIN(Int_t index) const
2009 {
2010     Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
2011     if ((index < 0) || (index >= length)) {
2012         printf ("Error in TIsajet::GetPTMIN : \n");
2013         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2014         return 0;
2015     }
2016
2017     return JETLIM.ptmin[index];
2018 }
2019
2020 /**************************************************************************/
2021
2022 void TIsajet::SetPTMAX(Float_t val, Int_t index)
2023 {
2024     Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2025     if ((index < 0) || (index >= length)) {
2026         printf ("Error in TIsajet::SetPTMAX : \n");
2027         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2028         return;
2029     }
2030
2031     if (val < JETLIM.ptmin[index]) {
2032         printf("Error in TIsajet::SetPTMAX : \n");
2033         printf("You may not set PTMAX to a value larger than PTMIN = %f.\n", JETLIM.ptmin[index]);
2034         return;
2035     }
2036
2037     JETLIM.ptmax[index] = val;
2038     setPt = true;
2039 }
2040
2041 /**************************************************************************/
2042
2043 void TIsajet::SetAllPTMAX(const Float_t val[], Int_t arraySize)
2044 {
2045     Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2046     if (arraySize != length) {
2047         printf ("Error in TIsajet::SetAllPTMAX : \n");
2048         printf ("Array must have %d elements.\n", length);
2049         return;
2050     }
2051
2052     for (Int_t i = 0; i < arraySize; i++) {
2053         SetPTMAX(val[i], i);
2054     }
2055 }
2056
2057 /**************************************************************************/
2058
2059 Float_t TIsajet::GetPTMAX(Int_t index) const
2060 {
2061     Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2062     if ((index < 0) || (index >= length)) {
2063         printf ("Error in TIsajet::GetPTMAX : \n");
2064         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2065         return 0;
2066     }
2067
2068     return JETLIM.ptmax[index];
2069 }
2070
2071 /**************************************************************************/
2072
2073 void TIsajet::SetYJMIN(Float_t val, Int_t index)
2074 {
2075     Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2076     if ((index < 0) || (index >= length)) {
2077         printf ("Error in TIsajet::SetYJMIN : \n");
2078         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2079         return;
2080     }
2081
2082     if (val > JETLIM.yjmax[index]) {
2083         printf("Error in TIsajet::SetYJMIN : \n");
2084         printf("You may not set YJMIN to a value larger than YJMAX = %f.\n", JETLIM.yjmax[index]);
2085         return;
2086     }
2087
2088     if (setTheta) {
2089         printf("Error in TIsajet::SetYJMIN :\n");
2090         printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMIN.\n");
2091         return;
2092     }
2093
2094     setY =  true;
2095     JETLIM.yjmin[index] = val;
2096 }
2097
2098 /**************************************************************************/
2099
2100 void TIsajet::SetAllYJMIN(const Float_t val[], Int_t arraySize)
2101 {
2102     Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2103     if (arraySize != length) {
2104         printf ("Error in TIsajet::SetAllYJMIN : \n");
2105         printf ("Array must have %d elements.\n", length);
2106         return;
2107     }
2108
2109     for (Int_t i = 0; i < arraySize; i++) {
2110         SetYJMIN(val[i], i);
2111     }
2112 }
2113
2114 /**************************************************************************/
2115
2116 Float_t TIsajet::GetYJMIN(Int_t index) const
2117 {
2118     Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2119     if ((index < 0) || (index >= length)) {
2120         printf ("Error in TIsajet::GetYJMIN : \n");
2121         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2122         return 0;
2123     }
2124
2125     return JETLIM.yjmin[index];
2126 }
2127
2128 /**************************************************************************/
2129
2130 void TIsajet::SetYJMAX(Float_t val, Int_t index)
2131 {
2132     Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2133     if ((index < 0) || (index >= length)) {
2134         printf ("Error in TIsajet::SetYJMAX : \n");
2135         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2136         return;
2137     }
2138
2139     if (val < JETLIM.yjmin[index]) {
2140         printf("Error in TIsajet::SetYJMAX : \n");
2141         printf("You may not set YJMAX to a value larger than YJMIN = %f.\n", JETLIM.yjmin[index]);
2142         return;
2143     }
2144
2145     if (setTheta) {
2146         printf("Error in TIsajet::SetYJMAX :\n");
2147         printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMAX.\n");
2148         return;
2149     }
2150
2151     setY = true;
2152     JETLIM.yjmax[index] = val;
2153 }
2154
2155 /**************************************************************************/
2156
2157 void TIsajet::SetAllYJMAX(const Float_t val[], Int_t arraySize)
2158 {
2159     Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2160     if (arraySize != length) {
2161         printf ("Error in TIsajet::SetAllYJMAX : \n");
2162         printf ("Array must have %d elements.\n", length);
2163         return;
2164     }
2165
2166     for (Int_t i = 0; i < arraySize; i++) {
2167         SetYJMAX(val[i], i);
2168     }
2169 }
2170
2171 /**************************************************************************/
2172
2173 Float_t TIsajet::GetYJMAX(Int_t index) const
2174 {
2175     Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2176     if ((index < 0) || (index >= length)) {
2177         printf ("Error in TIsajet::GetYJMAX : \n");
2178         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2179         return 0;
2180     }
2181
2182     return JETLIM.yjmax[index];
2183 }
2184
2185 /**************************************************************************/
2186
2187 void TIsajet::SetYJLIMS()
2188 {
2189     for (Int_t i = 0; i < JETLIM.mxlim; i++) {
2190         JETLIM.yjmax[i] = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
2191         JETLIM.yjmax[i] = -JETLIM.yjmin[i];
2192     }
2193     setY = false;
2194 }
2195
2196 /**************************************************************************/
2197
2198 void TIsajet::SetPHIMIN(Float_t val, Int_t index)
2199 {
2200     Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2201     if ((index < 0) || (index >= length)) {
2202         printf ("Error in TIsajet::SetPHIMIN : \n");
2203         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2204         return;
2205     }
2206
2207     if (val > JETLIM.phimax[index]) {
2208         printf("Error in TIsajet::SetPHIMIN : \n");
2209         printf("You may not set PHIMIN to a value larger than PHIMAX = %f.\n", JETLIM.phimax[index]);
2210         return;
2211     }
2212
2213     JETLIM.phimin[index] = val;
2214     setPhi = true;
2215 }
2216
2217 /**************************************************************************/
2218
2219 void TIsajet::SetAllPHIMIN(const Float_t val[], Int_t arraySize)
2220 {
2221     Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2222     if (arraySize != length) {
2223         printf ("Error in TIsajet::SetAllPHIMIN : \n");
2224         printf ("Array must have %d elements.\n", length);
2225         return;
2226     }
2227
2228     for (Int_t i = 0; i < arraySize; i++) {
2229         SetPHIMIN(val[i], i);
2230     }
2231 }
2232
2233 /**************************************************************************/
2234
2235 Float_t TIsajet::GetPHIMIN(Int_t index) const
2236 {
2237     Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2238     if ((index < 0) || (index >= length)) {
2239         printf ("Error in TIsajet::GetPHIMIN : \n");
2240         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2241         return 0;
2242     }
2243
2244     return JETLIM.phimin[index];
2245 }
2246
2247 /**************************************************************************/
2248
2249 void TIsajet::SetPHIMAX(Float_t val, Int_t index)
2250 {
2251     Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2252     if ((index < 0) || (index >= length)) {
2253         printf ("Error in TIsajet::SetPHIMAX : \n");
2254         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2255         return;
2256     }
2257
2258     if (val < JETLIM.phimin[index]) {
2259         printf("Error in TIsajet::SetPHIMAX : \n");
2260         printf("You may not set PHIMAX to a value larger than PHIMIN = %f.\n", JETLIM.phimin[index]);
2261         return;
2262     }
2263
2264     JETLIM.phimax[index] = val;
2265     setPhi = true;
2266 }
2267
2268 /**************************************************************************/
2269
2270 void TIsajet::SetAllPHIMAX(const Float_t val[], Int_t arraySize)
2271 {
2272     Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2273     if (arraySize != length) {
2274         printf ("Error in TIsajet::SetAllPHIMAX : \n");
2275         printf ("Array must have %d elements.\n", length);
2276         return;
2277     }
2278
2279     for (Int_t i = 0; i < arraySize; i++) {
2280         SetPHIMAX(val[i], i);
2281     }
2282 }
2283
2284 /**************************************************************************/
2285
2286 Float_t TIsajet::GetPHIMAX(Int_t index) const
2287 {
2288     Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2289     if ((index < 0) || (index >= length)) {
2290         printf ("Error in TIsajet::GetPHIMAX : \n");
2291         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2292         return 0;
2293     }
2294
2295     return JETLIM.phimax[index];
2296 }
2297
2298 /**************************************************************************/
2299
2300 void TIsajet::SetXJMIN(Float_t val, Int_t index)
2301 {
2302     Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2303     if ((index < 0) || (index >= length)) {
2304         printf ("Error in TIsajet::SetXJMIN : \n");
2305         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2306         return;
2307     }
2308     if (val > JETLIM.xjmax[index]) {
2309         printf("Error in TIsajet::SetXJMIN : \n");
2310         printf("You may not set XJMIN to a value larger than XJMAX = %f.\n", JETLIM.xjmax[index]);
2311         return;
2312     }
2313
2314     JETLIM.xjmin[index] = val;
2315     setX = true;
2316 }
2317
2318 /**************************************************************************/
2319
2320 void TIsajet::SetAllXJMIN(const Float_t val[], Int_t arraySize)
2321 {
2322     Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2323     if (arraySize != length) {
2324         printf ("Error in TIsajet::SetAllXJMIN : \n");
2325         printf ("Array must have %d elements.\n", length);
2326         return;
2327     }
2328
2329     for (Int_t i = 0; i < arraySize; i++) {
2330         SetXJMIN(val[i], i);
2331     }
2332 }
2333
2334 /**************************************************************************/
2335
2336 Float_t TIsajet::GetXJMIN(Int_t index) const
2337 {
2338     Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2339     if ((index < 0) || (index >= length)) {
2340         printf ("Error in TIsajet::GetXJMIN : \n");
2341         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2342         return 0;
2343     }
2344
2345     return JETLIM.xjmin[index];
2346 }
2347
2348 /**************************************************************************/
2349
2350 void TIsajet::SetXJMAX(Float_t val, Int_t index)
2351 {
2352     Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2353     if ((index < 0) || (index >= length)) {
2354         printf ("Error in TIsajet::SetXJMAX : \n");
2355         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2356         return;
2357     }
2358
2359     if (val < JETLIM.xjmin[index]) {
2360         printf("Error in TIsajet::SetXJMAX : \n");
2361         printf("You may not set XJMAX to a value larger than XJMIN = %f.\n", JETLIM.xjmin[index]);
2362         return;
2363     }
2364
2365     JETLIM.xjmax[index] = val;
2366     setX = true;
2367 }
2368
2369 /**************************************************************************/
2370
2371 void TIsajet::SetAllXJMAX(const Float_t val[], Int_t arraySize)
2372 {
2373     Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2374     if (arraySize != length) {
2375         printf ("Error in TIsajet::SetAllXJMAX : \n");
2376         printf ("Array must have %d elements.\n", length);
2377         return;
2378     }
2379
2380     for (Int_t i = 0; i < arraySize; i++) {
2381         SetXJMAX(val[i], i);
2382     }
2383 }
2384
2385 /**************************************************************************/
2386
2387 Float_t TIsajet::GetXJMAX(Int_t index) const
2388 {
2389     Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2390     if ((index < 0) || (index >= length)) {
2391         printf ("Error in TIsajet::GetXJMAX : \n");
2392         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2393         return 0;
2394     }
2395
2396     return JETLIM.xjmax[index];
2397 }
2398
2399 /**************************************************************************/
2400
2401 void TIsajet::SetTHMIN(Float_t val, Int_t index)
2402 {
2403     Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2404     if ((index < 0) || (index >= length)) {
2405         printf ("Error in TIsajet::SetTHMIN : \n");
2406         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2407         return;
2408     }
2409
2410     if (val > JETLIM.thmax[index]) {
2411         printf("Error in TIsajet::SetTHMIN : \n");
2412         printf("You may not set THMIN to a value larger than THMAX = %f.\n", JETLIM.thmax[index]);
2413         return;
2414     }
2415
2416     if (setY) {
2417         printf("Error in TIsajet::SetTHMIN :\n");
2418         printf("May not set both theta and y limits. Use SetYJLIMS, then set THMIN.\n");
2419         return;
2420     }
2421
2422     setTheta = true;
2423     JETLIM.thmin[index] = val;
2424
2425 }
2426
2427 /**************************************************************************/
2428
2429 void TIsajet::SetAllTHMIN(const Float_t val[], Int_t arraySize)
2430 {
2431     Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2432     if (arraySize != length) {
2433         printf ("Error in TIsajet::SetAllTHMIN : \n");
2434         printf ("Array must have %d elements.\n", length);
2435         return;
2436     }
2437
2438     for (Int_t i = 0; i < arraySize; i++) {
2439         SetTHMIN(val[i], i);
2440     }
2441 }
2442
2443 /**************************************************************************/
2444
2445 Float_t TIsajet::GetTHMIN(Int_t index) const
2446 {
2447     Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2448     if ((index < 0) || (index >= length)) {
2449         printf ("Error in TIsajet::GetTHMIN : \n");
2450         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2451         return 0;
2452     }
2453
2454     return JETLIM.thmin[index];
2455 }
2456
2457 /**************************************************************************/
2458
2459 void TIsajet::SetTHMAX(Float_t val, Int_t index)
2460 {
2461     Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2462     if ((index < 0) || (index >= length)) {
2463         printf ("Error in TIsajet::SetTHMAX : \n");
2464         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2465         return;
2466     }
2467
2468     if (val < JETLIM.thmin[index]) {
2469         printf("Error in TIsajet::SetTHMAX : \n");
2470         printf("You may not set THMAX to a value larger than THMIN = %f.\n", JETLIM.thmin[index]);
2471         return;
2472     }
2473
2474     if (setY) {
2475         printf("Error in TIsajet::SetTHMAX :\n");
2476         printf("May not set both theta and y limits. Use SetYJLIMS, then set THMAX.\n");
2477         return;
2478     }
2479
2480     setTheta = true;
2481     JETLIM.thmax[index] = val;
2482 }
2483
2484 /**************************************************************************/
2485
2486 void TIsajet::SetAllTHMAX(const Float_t val[], Int_t arraySize)
2487 {
2488     Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2489     if (arraySize != length) {
2490         printf ("Error in TIsajet::SetAllTHMAX : \n");
2491         printf ("Array must have %d elements.\n", length);
2492         return;
2493     }
2494
2495     for (Int_t i = 0; i < arraySize; i++) {
2496         SetTHMAX(val[i], i);
2497     }
2498 }
2499
2500 /**************************************************************************/
2501
2502 Float_t TIsajet::GetTHMAX(Int_t index) const
2503 {
2504     Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2505     if ((index < 0) || (index >= length)) {
2506         printf ("Error in TIsajet::GetTHMAX : \n");
2507         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2508         return 0;
2509     }
2510
2511     return JETLIM.thmax[index];
2512 }
2513
2514 /**************************************************************************/
2515
2516 void TIsajet::SetTHLIMS()
2517 {
2518     Float_t tmin;
2519     for (Int_t i = 0; i < JETLIM.mxlim; i++) {
2520         tmin = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
2521         JETLIM.thmin[i] = 2*atan(exp(tmin));
2522         JETLIM.thmax[i] = 2*atan(exp(-tmin));
2523     }
2524     setTheta = false;
2525 }
2526
2527 /**************************************************************************/
2528
2529 Bool_t TIsajet::GetSETLMJ(Int_t index) const
2530 {
2531     Int_t length = (sizeof JETLIM.setlmj / sizeof JETLIM.setlmj[0]);
2532     if ((index < 0) || (index >= length)) {
2533         printf ("Error in TIsajet::GetSETLMJ : \n");
2534         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2535         return 0;
2536     }
2537
2538     return JETLIM.setlmj[index];
2539 }
2540
2541 /**************************************************************************/
2542
2543 // Ends JETLIM access.
2544 // Begins JETPAR access.
2545
2546 /**************************************************************************/
2547
2548 Float_t TIsajet::GetP(Int_t index) const
2549 {
2550     Int_t length = (sizeof JETPAR.p / sizeof JETPAR.p[0]);
2551     if ((index < 0) || (index >= length)) {
2552         printf ("Error in TIsajet::GetP : \n");
2553         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2554         return 0;
2555     }
2556
2557     return JETPAR.p[index];
2558 }
2559
2560 /**************************************************************************/
2561
2562 Float_t TIsajet::GetPT(Int_t index) const
2563 {
2564     Int_t length = (sizeof JETPAR.pt / sizeof JETPAR.pt[0]);
2565     if ((index < 0) || (index >= length)) {
2566         printf ("Error in TIsajet::GetPT : \n");
2567         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2568         return 0;
2569     }
2570
2571     return JETPAR.pt[index];
2572 }
2573
2574 /**************************************************************************/
2575
2576 Float_t TIsajet::GetYJ(Int_t index) const
2577 {
2578     Int_t length = (sizeof JETPAR.yj / sizeof JETPAR.yj[0]);
2579     if ((index < 0) || (index >= length)) {
2580         printf ("Error in TIsajet::GetYJ : \n");
2581         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2582         return 0;
2583     }
2584
2585     return JETPAR.yj[index];
2586 }
2587
2588 /**************************************************************************/
2589
2590 Float_t TIsajet::GetPHI(Int_t index) const
2591 {
2592     Int_t length = (sizeof JETPAR.phi / sizeof JETPAR.phi[0]);
2593     if ((index < 0) || (index >= length)) {
2594         printf ("Error in TIsajet::GetPHI : \n");
2595         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2596         return 0;
2597     }
2598
2599     return JETPAR.phi[index];
2600 }
2601
2602 /**************************************************************************/
2603
2604 Float_t TIsajet::GetXJ(Int_t index) const
2605 {
2606     Int_t length = (sizeof JETPAR.xj / sizeof JETPAR.xj[0]);
2607     if ((index < 0) || (index >= length)) {
2608         printf ("Error in TIsajet::GetXJ : \n");
2609         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2610         return 0;
2611     }
2612
2613     return JETPAR.xj[index];
2614 }
2615
2616 /**************************************************************************/
2617
2618 Float_t TIsajet::GetTH(Int_t index) const
2619 {
2620     Int_t length = (sizeof JETPAR.th / sizeof JETPAR.th[0]);
2621     if ((index < 0) || (index >= length)) {
2622         printf ("Error in TIsajet::GetTH : \n");
2623         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2624         return 0;
2625     }
2626
2627     return JETPAR.th[index];
2628 }
2629
2630 /**************************************************************************/
2631
2632 Float_t TIsajet::GetCTH(Int_t index) const
2633 {
2634     Int_t length = (sizeof JETPAR.cth / sizeof JETPAR.cth[0]);
2635     if ((index < 0) || (index >= length)) {
2636         printf ("Error in TIsajet::GetCTH : \n");
2637         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2638         return 0;
2639     }
2640
2641     return JETPAR.cth[index];
2642 }
2643
2644 /**************************************************************************/
2645
2646 Float_t TIsajet::GetSTH(Int_t index) const
2647 {
2648     Int_t length = (sizeof JETPAR.sth / sizeof JETPAR.sth[0]);
2649     if ((index < 0) || (index >= length)) {
2650         printf ("Error in TIsajet::GetSTH : \n");
2651         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2652         return 0;
2653     }
2654
2655     return JETPAR.sth[index];
2656 }
2657
2658 /**************************************************************************/
2659
2660 Int_t TIsajet::GetJETTYP(Int_t index) const
2661 {
2662     Int_t length = (sizeof JETPAR.jettyp / sizeof JETPAR.jettyp[0]);
2663     if ((index < 0) || (index >= length)) {
2664         printf ("Error in TIsajet::GetJETTYP : \n");
2665         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2666         return 0;
2667     }
2668
2669     return JETPAR.jettyp[index];
2670 }
2671
2672 /**************************************************************************/
2673
2674 Float_t TIsajet::GetSHAT() const
2675 {
2676     return JETPAR.shat;
2677 }
2678
2679 /**************************************************************************/
2680
2681 Float_t TIsajet::GetTHAT() const
2682 {
2683     return JETPAR.that;
2684 }
2685
2686 /**************************************************************************/
2687
2688 Float_t TIsajet::GetUHAT() const
2689 {
2690     return JETPAR.uhat;
2691 }
2692
2693 /**************************************************************************/
2694
2695 Float_t TIsajet::GetQSQ() const
2696 {
2697     return JETPAR.qsq;
2698 }
2699
2700 /**************************************************************************/
2701
2702 Float_t TIsajet::GetX1() const
2703 {
2704     return JETPAR.x1;
2705 }
2706
2707 /**************************************************************************/
2708
2709 Float_t TIsajet::GetX2() const
2710 {
2711     return JETPAR.x2;
2712 }
2713
2714 /**************************************************************************/
2715
2716 Float_t TIsajet::GetPBEAM(Int_t index) const
2717 {
2718     Int_t length = (sizeof JETPAR.pbeam / sizeof JETPAR.pbeam[0]);
2719     if ((index < 0) || (index >= length)) {
2720         printf ("Error in TIsajet::GetPBEAM : \n");
2721         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2722         return 0;
2723     }
2724
2725     return JETPAR.pbeam[index];
2726 }
2727
2728 /**************************************************************************/
2729
2730 Float_t TIsajet::GetQMW() const
2731 {
2732     return JETPAR.qmw;
2733 }
2734
2735 /**************************************************************************/
2736
2737 Float_t TIsajet::GetQW() const
2738 {
2739     return JETPAR.qw;
2740 }
2741
2742 /**************************************************************************/
2743
2744 Float_t TIsajet::GetQTW() const
2745 {
2746     return JETPAR.qtw;
2747 }
2748
2749 /**************************************************************************/
2750
2751 Float_t TIsajet::GetYW() const
2752 {
2753     return JETPAR.yw;
2754 }
2755
2756 /**************************************************************************/
2757
2758 Float_t TIsajet::GetXW() const
2759 {
2760     return JETPAR.xw;
2761 }
2762
2763 /**************************************************************************/
2764
2765 Float_t TIsajet::GetTHW() const
2766 {
2767     return JETPAR.thw;
2768 }
2769
2770 /**************************************************************************/
2771
2772 Float_t TIsajet::GetQTMW() const
2773 {
2774     return JETPAR.qtmw;
2775 }
2776
2777 /**************************************************************************/
2778
2779 Float_t TIsajet::GetPHIW() const
2780 {
2781     return JETPAR.phiw;
2782 }
2783
2784 /**************************************************************************/
2785
2786 Float_t TIsajet::GetSHAT1() const
2787 {
2788     return JETPAR.shat1;
2789 }
2790
2791 /**************************************************************************/
2792
2793 Float_t TIsajet::GetTHAT1() const
2794 {
2795     return JETPAR.that1;
2796 }
2797
2798 /**************************************************************************/
2799
2800 Float_t TIsajet::GetUHAT1() const
2801 {
2802     return JETPAR.uhat1;
2803 }
2804
2805 /**************************************************************************/
2806
2807 void TIsajet::SetJWTYP(Int_t val)
2808 {
2809     if ((val < 1) || (val > 4) || (val == 2))
2810     {
2811         printf ("Error in TIsajet::SetJWTYP : \n");
2812         printf ("Invalid value  %d; range is 1, 3, and 4.\n", val);
2813         return;
2814     }
2815
2816     JETPAR.jwtyp = val;
2817 }
2818
2819 /**************************************************************************/
2820
2821 void TIsajet::SetJWTYP(Char_t val[])
2822 {
2823     Int_t value;
2824
2825     if (!strcmp(val, "GM")) value = 1;
2826     else if (!strcmp(val, "W+")) value = 3;
2827     else if (!strcmp(val, "W-")) value = 3;
2828     else if (!strcmp(val, "Z0")) value = 4;
2829     else
2830     {
2831         printf ("Error in TIsajet::SetJWTYP : \n");
2832         printf ("Invalid value  %s; possible are GM, Z0, W+ and W-.\n", val);
2833         return;
2834     }
2835
2836
2837     JETPAR.jwtyp = value;
2838 }
2839
2840 /**************************************************************************/
2841
2842 Int_t TIsajet::GetJWTYP() const
2843 {
2844     return JETPAR.jwtyp;
2845 }
2846
2847 /**************************************************************************/
2848
2849 Float_t TIsajet::GetALFQSQ() const
2850 {
2851     return JETPAR.alfqsq;
2852 }
2853
2854 /**************************************************************************/
2855
2856 Float_t TIsajet::GetCTHW() const
2857 {
2858     return JETPAR.cthw;
2859 }
2860
2861 /**************************************************************************/
2862
2863 Float_t TIsajet::GetSTHW() const
2864 {
2865     return JETPAR.sthw;
2866 }
2867
2868 /**************************************************************************/
2869
2870 Float_t TIsajet::GetQ0W() const
2871 {
2872     return JETPAR.q0w;
2873 }
2874
2875 /**************************************************************************/
2876
2877 Int_t TIsajet::GetINITYP(Int_t index) const
2878 {
2879     Int_t length = (sizeof JETPAR.inityp / sizeof JETPAR.inityp[0]);
2880     if ((index < 0) || (index >= length)) {
2881         printf ("Error in TIsajet::GetINITYP : \n");
2882         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2883         return 0;
2884     }
2885
2886     return JETPAR.inityp[index];
2887 }
2888
2889 /**************************************************************************/
2890
2891 Int_t TIsajet::GetISIGS() const
2892 {
2893     return JETPAR.isigs;
2894 }
2895
2896 /**************************************************************************/
2897
2898 Float_t TIsajet::GetPBEAMS(Int_t index) const
2899 {
2900     Int_t length = (sizeof JETPAR.pbeams / sizeof JETPAR.pbeams[0]);
2901     if ((index < 0) || (index >= length)) {
2902         printf ("Error in TIsajet::GetPBEAMS : \n");
2903         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2904         return 0;
2905     }
2906
2907     return JETPAR.pbeams[index];
2908 }
2909
2910 /**************************************************************************/
2911
2912 // Ends JETPAR access.
2913 // Begins KKGRAV access.
2914
2915 /**************************************************************************/
2916
2917 void TIsajet::SetNEXTRAD(Int_t val)
2918 {
2919     KKGRAV.nextrad = val;
2920 }
2921
2922 /**************************************************************************/
2923
2924 Int_t TIsajet::GetNEXTRAD() const
2925 {
2926     return KKGRAV.nextrad;
2927 }
2928
2929 /**************************************************************************/
2930
2931 void TIsajet::SetMASSD(Float_t val)
2932 {
2933     KKGRAV.massd = val;
2934 }
2935
2936 /**************************************************************************/
2937
2938 Float_t TIsajet::GetMASSD() const
2939 {
2940     return KKGRAV.massd;
2941 }
2942
2943 /**************************************************************************/
2944
2945 Float_t TIsajet::GetKKGSD() const
2946 {
2947     return KKGRAV.kkgsd;
2948 }
2949
2950 /**************************************************************************/
2951
2952 Float_t TIsajet::GetSURFD() const
2953 {
2954     return KKGRAV.surfd;
2955 }
2956
2957 /**************************************************************************/
2958
2959 void TIsajet::SetUVCUT(Bool_t val)
2960 {
2961     KKGRAV.uvcut = val;
2962 }
2963
2964 /**************************************************************************/
2965
2966 Bool_t TIsajet::GetUVCUT() const
2967 {
2968     return KKGRAV.uvcut;
2969 }
2970
2971 /**************************************************************************/
2972
2973 // Ends KKGRAV access.
2974 // Begins MBGEN access.
2975
2976 /**************************************************************************/
2977
2978 Float_t TIsajet::GetPOMWT(Int_t index) const
2979 {
2980     Int_t length = (sizeof MBGEN.pomwt / sizeof MBGEN.pomwt[0]);
2981     if ((index < 0) || (index >= length)) {
2982         printf ("Error in TIsajet::GetPOMWT : \n");
2983         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2984         return 0;
2985     }
2986
2987     return MBGEN.pomwt[index];
2988 }
2989
2990 /**************************************************************************/
2991
2992 Float_t TIsajet::GetPOMGEN(Int_t index) const
2993 {
2994     Int_t length = (sizeof MBGEN.pomgen / sizeof MBGEN.pomgen[0]);
2995     if ((index < 0) || (index >= length)) {
2996         printf ("Error in TIsajet::GetPOMGEN : \n");
2997         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2998         return 0;
2999     }
3000
3001     return MBGEN.pomgen[index];
3002 }
3003
3004 /**************************************************************************/
3005
3006 void TIsajet::SetMNPOM(Int_t val)
3007 {
3008     if (val > MBGEN.mxpom) {
3009         printf("Error in TIsajet::SetMNPOM : \n");
3010         printf("You may not set MNPOM to a value larger than MXPOM = %d.\n", MBGEN.mxpom);
3011         return;
3012     }
3013
3014     MBGEN.mnpom = val;
3015 }
3016
3017 /**************************************************************************/
3018
3019 Int_t TIsajet::GetMNPOM() const
3020 {
3021     return MBGEN.mnpom;
3022 }
3023
3024 /**************************************************************************/
3025
3026 void TIsajet::SetMXPOM(Int_t val)
3027 {
3028     if (val < MBGEN.mnpom) {
3029         printf("Error in TIsajet::SetMXPOM : \n");
3030         printf("You may not set MXPOM to a value less than MNPOM = %d.\n", MBGEN.mnpom);
3031         return;
3032     }
3033
3034     MBGEN.mxpom = val;
3035 }
3036
3037 /**************************************************************************/
3038
3039 Int_t TIsajet::GetMXPOM() const
3040 {
3041     return MBGEN.mxpom;
3042 }
3043
3044 /**************************************************************************/
3045
3046 Float_t TIsajet::GetPDIFFR() const
3047 {
3048     return MBGEN.pdiffr;
3049 }
3050
3051 /**************************************************************************/
3052
3053 Int_t TIsajet::GetNPOM() const
3054 {
3055     return MBGEN.npom;
3056 }
3057
3058 /**************************************************************************/
3059
3060 Float_t TIsajet::GetXBARY(Int_t index) const
3061 {
3062     Int_t length = (sizeof MBGEN.xbary / sizeof MBGEN.xbary[0]);
3063     if ((index < 0) || (index >= length)) {
3064         printf ("Error in TIsajet::GetXBARY : \n");
3065         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3066         return 0;
3067     }
3068
3069     return MBGEN.xbary[index];
3070 }
3071
3072 /**************************************************************************/
3073
3074 Float_t TIsajet::GetDXBARY(Int_t index) const
3075 {
3076     Int_t length = (sizeof MBGEN.dxbary / sizeof MBGEN.dxbary[0]);
3077     if ((index < 0) || (index >= length)) {
3078         printf ("Error in TIsajet::GetDXBARY : \n");
3079         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3080         return 0;
3081     }
3082
3083     return MBGEN.dxbary[index];
3084 }
3085
3086 /**************************************************************************/
3087
3088 Float_t TIsajet::GetXPOM(Int_t index1, Int_t index2) const
3089 {
3090     Int_t elem_Size = sizeof MBGEN.xpom[0][0];
3091     Int_t sec_Dim_Length = (sizeof MBGEN.xpom[0] / elem_Size);
3092     Int_t fst_Dim_Length = (sizeof MBGEN.xpom / (elem_Size * sec_Dim_Length));
3093
3094     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
3095         printf ("Error in TIsajet::GetXPOM : \n");
3096         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
3097         return 0;
3098     }
3099
3100     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
3101         printf ("Error in TIsajet::GetXPOM : \n");
3102         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
3103         return 0;
3104     }
3105
3106     return MBGEN.xpom[index1][index2];
3107 }
3108
3109 /**************************************************************************/
3110
3111 // Ends MBGEN access.
3112 // Begins MGLIMS access.
3113
3114 /**************************************************************************/
3115
3116 void TIsajet::SetEHMGMN(Float_t val)
3117 {
3118     if (val > MGLIMS.ehmgmx) {
3119         printf("Error in TIsajet::SetEHMGMN : \n");
3120         printf("You may not set EHMGMN to a value larger than EHMGMX = %f.\n", MGLIMS.ehmgmx);
3121         return;
3122     }
3123
3124     MGLIMS.ehmgmn = val;
3125 }
3126
3127 /**************************************************************************/
3128
3129 Float_t TIsajet::GetEHMGMN() const
3130 {
3131     return MGLIMS.ehmgmn;
3132 }
3133
3134 /**************************************************************************/
3135
3136 void TIsajet::SetEHMGMX(Float_t val)
3137 {
3138     if (val < MGLIMS.ehmgmn) {
3139         printf("Error in TIsajet::SetEHMGMX : \n");
3140         printf("You may not set EHMGMX to a value less than EHMGMN = %f.\n", MGLIMS.ehmgmn);
3141         return;
3142     }
3143
3144     MGLIMS.ehmgmx = val;
3145 }
3146
3147 /**************************************************************************/
3148
3149 Float_t TIsajet::GetEHMGMX() const
3150 {
3151     return MGLIMS.ehmgmx;
3152 }
3153
3154 /**************************************************************************/
3155
3156 Float_t TIsajet::GetYHMGMN() const
3157 {
3158     return MGLIMS.yhmgmn;
3159 }
3160
3161 /**************************************************************************/
3162
3163 Float_t TIsajet::GetYHMGMX() const
3164 {
3165     return MGLIMS.yhmgmx;
3166 }
3167
3168 /**************************************************************************/
3169
3170 void TIsajet::SetAMIJMN(Float_t val, Int_t index1, Int_t index2)
3171 {
3172     Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3173     Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3174
3175     if ((index1 < 0) || (index1 >= row_num)) {
3176         printf ("Error in TIsajet::SetAMIJMN : \n");
3177         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3178         return;
3179     }
3180
3181     if ((index2 < 0) || (index2 >= col_num)) {
3182         printf ("Error in TIsajet::SetAMIJMN : \n");
3183         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3184         return;
3185     }
3186
3187     if (val > MGLIMS.amijmx[index1][index2]) {
3188         printf("Error in TIsajet::SetAMIJMN : \n");
3189         printf("You may not set AMIJMN to a value larger than AMIJMX = %f.\n", MGLIMS.amijmx[index1][index2]);
3190         return;
3191     }
3192
3193     MGLIMS.amijmn[index1][index2] = val;
3194 }
3195
3196 /**************************************************************************/
3197
3198 void TIsajet::SetAllAMIJMN(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
3199 {
3200     for (Int_t i = 0; i < 2; i++) {
3201         for (Int_t j = 0; j < 3; j++) {
3202             SetAMIJMN(val[i][j], i, j);
3203         }
3204     }
3205 }
3206
3207 /**************************************************************************/
3208
3209 void TIsajet::SetColumnAMIJMN(const Float_t val[], Int_t col)
3210 {
3211     Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3212     Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3213
3214     if ((col < 0) || (col >= col_num)) {
3215         printf ("Error in TIsajet::SetColumnAMIJMN : \n");
3216         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
3217         return;
3218     }
3219
3220     for (Int_t i = 0; i < row_num; i++) {
3221         SetAMIJMN(val[i], i, col);
3222     }
3223 }
3224
3225 /**************************************************************************/
3226
3227 Float_t TIsajet::GetAMIJMN(Int_t index1, Int_t index2) const
3228 {
3229     Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3230     Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3231
3232     if ((index1 < 0) || (index1 >= row_num)) {
3233         printf ("Error in TIsajet::GetAMIJMN : \n");
3234         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3235         return 0;
3236     }
3237
3238     if ((index2 < 0) || (index2 >= col_num)) {
3239         printf ("Error in TIsajet::GetAMIJMN : \n");
3240         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3241         return 0;
3242     }
3243
3244     return MGLIMS.amijmn[index1][index2];
3245 }
3246
3247 /**************************************************************************/
3248
3249 void TIsajet::SetAMIJMX(Float_t val, Int_t index1, Int_t index2)
3250 {
3251     Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3252     Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3253
3254     if ((index1 < 0) || (index1 >= row_num)) {
3255         printf ("Error in TIsajet::SetAMIJMX : \n");
3256         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3257         return;
3258     }
3259
3260     if ((index2 < 0) || (index2 >= col_num)) {
3261         printf ("Error in TIsajet::SetAMIJMX : \n");
3262         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3263         return;
3264     }
3265
3266     if (val < MGLIMS.amijmn[index1][index2]) {
3267         printf("Error in TIsajet::SetAMIJMX : \n");
3268         printf("You may not set AMIJMX to a value less than AMIJMN = %f.\n", MGLIMS.amijmn[index1][index2]);
3269         return;
3270     }
3271
3272     MGLIMS.amijmx[index1][index2] = val;
3273 }
3274
3275 /**************************************************************************/
3276
3277 void TIsajet::SetAllAMIJMX(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
3278 {
3279     for (Int_t i = 0; i < 2; i++) {
3280         for (Int_t j = 0; j < 3; j++) {
3281             SetAMIJMX(val[i][j], i, j);
3282         }
3283     }
3284 }
3285
3286 /**************************************************************************/
3287
3288 void TIsajet::SetColumnAMIJMX(const Float_t val[], Int_t col)
3289 {
3290     Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3291     Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3292
3293     if ((col < 0) || (col >= col_num)) {
3294         printf ("Error in TIsajet::SetColumnAMIJMX : \n");
3295         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
3296         return;
3297     }
3298
3299     for (Int_t i = 0; i < row_num; i++) {
3300         SetAMIJMX(val[i], i, col);
3301     }
3302 }
3303
3304 /**************************************************************************/
3305
3306 Float_t TIsajet::GetAMIJMX(Int_t index1, Int_t index2) const
3307 {
3308     Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3309     Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3310
3311     if ((index1 < 0) || (index1 >= row_num)) {
3312         printf ("Error in TIsajet::GetAMIJMX : \n");
3313         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3314         return 0;
3315     }
3316
3317     if ((index2 < 0) || (index2 >= col_num)) {
3318         printf ("Error in TIsajet::GetAMIJMX : \n");
3319         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3320         return 0;
3321     }
3322
3323     return MGLIMS.amijmx[index1][index2];
3324 }
3325
3326 /**************************************************************************/
3327
3328 Bool_t TIsajet::GetFIXMIJ(Int_t index1, Int_t index2) const
3329 {
3330     Int_t elem_Size = sizeof MGLIMS.fixmij[0][0];
3331     Int_t sec_Dim_Length = (sizeof MGLIMS.fixmij[0] / elem_Size);
3332     Int_t fst_Dim_Length = (sizeof MGLIMS.fixmij / (elem_Size * sec_Dim_Length));
3333
3334     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
3335         printf ("Error in TIsajet::GetFIXMIJ : \n");
3336         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
3337         return 0;
3338     }
3339
3340     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
3341         printf ("Error in TIsajet::GetFIXMIJ : \n");
3342         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
3343         return 0;
3344     }
3345
3346     return MGLIMS.fixmij[index1][index2];
3347 }
3348
3349 /**************************************************************************/
3350
3351 // Ends MGLIMS access.
3352 // Begins NODCAY access.
3353
3354 /**************************************************************************/
3355
3356 void TIsajet::SetNODCAY(Bool_t val)
3357 {
3358     NODCAY.nodcay = val;
3359     setNodcay = true;
3360 }
3361
3362 /**************************************************************************/
3363
3364 Bool_t TIsajet::GetNODCAY() const
3365 {
3366     return NODCAY.nodcay;
3367 }
3368
3369 /**************************************************************************/
3370
3371 void TIsajet::SetNOETA(Bool_t val)
3372 {
3373     NODCAY.noeta = val;
3374     setNoeta = true;
3375 }
3376
3377 /**************************************************************************/
3378
3379 Bool_t TIsajet::GetNOETA() const
3380 {
3381     return NODCAY.noeta;
3382 }
3383
3384 /**************************************************************************/
3385
3386 void TIsajet::SetNOPI0(Bool_t val)
3387 {
3388     NODCAY.nopi0 = val;
3389     setNopi0 = true;
3390 }
3391
3392 /**************************************************************************/
3393
3394 Bool_t TIsajet::GetNOPI0() const
3395 {
3396     return NODCAY.nopi0;
3397 }
3398
3399 /**************************************************************************/
3400
3401 void TIsajet::SetNONUNU(Bool_t val)
3402 {
3403     NODCAY.nonunu = val;
3404 }
3405
3406 /**************************************************************************/
3407
3408 Bool_t TIsajet::GetNONUNU() const
3409 {
3410     return NODCAY.nonunu;
3411 }
3412
3413 /**************************************************************************/
3414
3415 void TIsajet::SetNOEVOL(Bool_t val)
3416 {
3417     NODCAY.noevol = val;
3418     setNoevolve = true;
3419 }
3420
3421 /**************************************************************************/
3422
3423 Bool_t TIsajet::GetNOEVOL() const
3424 {
3425     return NODCAY.noevol;
3426 }
3427
3428 /**************************************************************************/
3429
3430 void TIsajet::SetNOHADR(Bool_t val)
3431 {
3432     NODCAY.nohadr = val;
3433     setNohadron = true;
3434 }
3435
3436 /**************************************************************************/
3437
3438 Bool_t TIsajet::GetNOHADR() const
3439 {
3440     return NODCAY.nohadr;
3441 }
3442
3443 /**************************************************************************/
3444
3445 void TIsajet::SetNOGRAV(Bool_t val)
3446 {
3447     NODCAY.nograv = val;
3448 }
3449
3450 /**************************************************************************/
3451
3452 Bool_t TIsajet::GetNOGRAV() const
3453 {
3454     return NODCAY.nograv;
3455 }
3456
3457 /**************************************************************************/
3458
3459 // Ends NODCAY access.
3460 // Begins PARTCL access.
3461
3462 /**************************************************************************/
3463
3464 Int_t TIsajet::GetNPTCL() const
3465 {
3466     return PARTCL.nptcl;
3467 }
3468
3469 /**************************************************************************/
3470
3471 Float_t TIsajet::GetPX(Int_t index) const
3472 {
3473     if ((index < 0) || (index >= PARTCL.nptcl)) {
3474         printf ("Error in TIsajet::GetPX : \n");
3475         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3476         return 0;
3477     }
3478
3479     return PARTCL.pptcl[index][0];
3480 }
3481
3482 /**************************************************************************/
3483
3484 Float_t TIsajet::GetPY(Int_t index) const
3485 {
3486     if ((index < 0) || (index >= PARTCL.nptcl)) {
3487         printf ("Error in TIsajet::GetPY : \n");
3488         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3489         return 0;
3490     }
3491
3492     return PARTCL.pptcl[index][1];
3493 }
3494
3495 /**************************************************************************/
3496
3497 Float_t TIsajet::GetPZ(Int_t index) const
3498 {
3499     if ((index < 0) || (index >= PARTCL.nptcl)) {
3500         printf ("Error in TIsajet::GetPZ : \n");
3501         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3502         return 0;
3503     }
3504
3505     return PARTCL.pptcl[index][2];
3506 }
3507
3508 /**************************************************************************/
3509
3510 Float_t TIsajet::GetP0(Int_t index) const
3511 {
3512     if ((index < 0) || (index >= PARTCL.nptcl)) {
3513         printf ("Error in TIsajet::GetP0 : \n");
3514         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3515         return 0;
3516     }
3517
3518     return PARTCL.pptcl[index][3];
3519 }
3520
3521 /**************************************************************************/
3522
3523 Float_t TIsajet::GetMASS(Int_t index) const
3524 {
3525     if ((index < 0) || (index >= PARTCL.nptcl)) {
3526         printf ("Error in TIsajet::GetMASS : \n");
3527         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3528         return 0;
3529     }
3530
3531     return PARTCL.pptcl[index][4];
3532 }
3533
3534 /**************************************************************************/
3535
3536 Float_t TIsajet::GetORIG(Int_t index) const
3537 {
3538     if ((index < 0) || (index >= PARTCL.nptcl)) {
3539         printf ("Error in TIsajet::GetORIG : \n");
3540         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3541         return 0;
3542     }
3543
3544     return PARTCL.iorig[index];
3545 }
3546
3547 /**************************************************************************/
3548
3549 Float_t TIsajet::GetIDENT(Int_t index) const
3550 {
3551     if ((index < 0) || (index >= PARTCL.nptcl)) {
3552         printf ("Error in TIsajet::GetIDENT : \n");
3553         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3554         return 0;
3555     }
3556
3557     return PARTCL.ident[index];
3558 }
3559
3560 /**************************************************************************/
3561
3562 Float_t TIsajet::GetIDCAY(Int_t index) const
3563 {
3564     if ((index < 0) || (index >= PARTCL.nptcl)) {
3565         printf ("Error in TIsajet::GetIDCAY : \n");
3566         printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3567         return 0;
3568     }
3569
3570     return PARTCL.idcay[index];
3571 }
3572
3573 /**************************************************************************/
3574
3575 // Ends PARTCL access.
3576 // Begins PRIMAR access.
3577
3578 /**************************************************************************/
3579
3580 Int_t TIsajet::GetNJET() const
3581 {
3582     return PRIMAR.njet;
3583 }
3584
3585 /**************************************************************************/
3586
3587 Float_t TIsajet::GetSCM() const
3588 {
3589     return PRIMAR.scm;
3590 }
3591
3592 /**************************************************************************/
3593
3594 Float_t TIsajet::GetHALFE() const
3595 {
3596     return PRIMAR.halfe;
3597 }
3598
3599 /**************************************************************************/
3600
3601 void TIsajet::SetECM(Float_t val)
3602 {
3603     if (val < 0) {
3604         printf ("Error in TIsajet::SetECM :\n");
3605         printf ("Cannot set energy to a negative value.\n");
3606         return;
3607     }
3608
3609     PRIMAR.ecm = val;
3610     PRIMAR.scm = val*val;
3611     PRIMAR.halfe = val / 2;
3612 }
3613
3614 /**************************************************************************/
3615
3616 Float_t TIsajet::GetECM() const
3617 {
3618     return PRIMAR.ecm;
3619 }
3620
3621 /**************************************************************************/
3622
3623 void TIsajet::SetIDIN(Int_t val, Int_t index)
3624 {
3625     Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3626     if ((index < 0) || (index >= length)) {
3627         printf ("Error in TIsajet::SetIDIN : \n");
3628         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3629         return;
3630     }
3631
3632     if ((val = 1120) || (val = 1220) || (val = -1120) || (val = -1220)) {
3633         PRIMAR.idin[index] = val;
3634     }
3635     else {
3636         printf ("Error in TIsajet::SetIDIN : \n");
3637         printf ("Invalid input value %d. Possible values are 1120, 1220, -1120, -1220.\n", val);
3638         return;
3639     }
3640
3641     setBeams = true;
3642 }
3643
3644 /**************************************************************************/
3645
3646 void TIsajet::SetIDIN(const Char_t val[], Int_t index)
3647 {
3648     Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3649     if ((index < 0) || (index >= length)) {
3650         printf ("Error in TIsajet::SetIDIN : \n");
3651         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3652         return;
3653     }
3654
3655     if (!strcmp("P", val)) {
3656         PRIMAR.idin[index] = 1120;
3657     }
3658     else if (!strcmp("AP", val)) {
3659         PRIMAR.idin[index] = -1120;
3660     }
3661     else if (!strcmp("N", val)) {
3662         PRIMAR.idin[index] = 1220;
3663     }
3664     else if (!strcmp("AN", val)) {
3665         PRIMAR.idin[index] = -1220;
3666     }
3667     else {
3668         printf ("Error in TIsajet::SetIDIN : \n");
3669         printf ("Invalid input string %s. Possible strings are P, AP, N, and AN.\n", val);
3670         return;
3671     }
3672 }
3673
3674 /**************************************************************************/
3675
3676 Int_t TIsajet::GetIDIN(Int_t index) const
3677 {
3678     Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3679     if ((index < 0) || (index >= length)) {
3680         printf ("Error in TIsajet::GetIDIN : \n");
3681         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3682         return 0;
3683     }
3684
3685     return PRIMAR.idin[index];
3686 }
3687
3688 /**************************************************************************/
3689
3690 Int_t TIsajet::GetNEVENT() const
3691 {
3692     return PRIMAR.nevent;
3693 }
3694
3695 /**************************************************************************/
3696
3697 void TIsajet::SetNTRIES(Int_t val)
3698 {
3699     PRIMAR.ntries = val;
3700 }
3701
3702 /**************************************************************************/
3703
3704 Int_t TIsajet::GetNTRIES() const
3705 {
3706     return PRIMAR.ntries;
3707 }
3708
3709 /**************************************************************************/
3710
3711 void TIsajet::SetNSIGMA(Int_t val)
3712 {
3713     PRIMAR.nsigma = val;
3714     setNsigma = true;
3715 }
3716
3717 /**************************************************************************/
3718
3719 Int_t TIsajet::GetNSIGMA() const
3720 {
3721     return PRIMAR.nsigma;
3722 }
3723
3724 /**************************************************************************/
3725
3726 // Ends PRIMAR access.
3727 // Begins QCDPAR access.
3728
3729 /**************************************************************************/
3730
3731 void TIsajet::SetALAM(Float_t val)
3732 {
3733     QCDPAR.alam = val;
3734     QCDPAR.alam2 = val*val;
3735     setLambda = true;
3736 }
3737
3738 /**************************************************************************/
3739
3740 Float_t TIsajet::GetALAM() const
3741 {
3742     return QCDPAR.alam;
3743 }
3744
3745 /**************************************************************************/
3746
3747 Float_t TIsajet::GetALAM2() const
3748 {
3749     return QCDPAR.alam2;
3750 }
3751
3752 /**************************************************************************/
3753
3754 void TIsajet::SetCUTJET(Float_t val)
3755 {
3756     QCDPAR.cutjet = val;
3757     setCutjet = true;
3758 }
3759
3760 /**************************************************************************/
3761
3762 Float_t TIsajet::GetCUTJET() const
3763 {
3764     return QCDPAR.cutjet;
3765 }
3766
3767 /**************************************************************************/
3768
3769 void TIsajet::SetISTRUC(Int_t val)
3770 {
3771     if ((val < 1) || (val > 6)) {
3772         printf ("Error in TIsajet::SetISTRUC : \n");
3773         printf ("Invalid input value %d. Possible values are 1 through 6.\n", val);
3774         return;
3775     }
3776     QCDPAR.istruc = val;
3777 }
3778
3779 /**************************************************************************/
3780
3781 void TIsajet::SetISTRUC(const Char_t val[])
3782 {
3783     if (!strcmp("OWENS", val)) {
3784         QCDPAR.istruc = 1;
3785     }
3786     else if (!strcmp("BAIER", val)) {
3787         QCDPAR.istruc = 2;
3788     }
3789     else if ((!strcmp("EICHTEN", val)) || (!strcmp("EHLQ", val))) {
3790         QCDPAR.istruc = 3;
3791     }
3792     else if ((!strcmp("DUKE", val)) || (!strcmp("DO", val))) {
3793         QCDPAR.istruc = 4;
3794     }
3795     else if (!strcmp("CTEQ2L", val)) {
3796         QCDPAR.istruc = 5;
3797     }
3798     else if ((!strcmp("CTEQ", val)) || (!strcmp("CTEQ3L", val))) {
3799         QCDPAR.istruc = 6;
3800     }
3801     else {
3802         printf ("Error in TIsajet::SetISTRUC : \n");
3803         printf ("Invalid input string %s. Possible strings are OWENS, BAIER, EICHTEN, \n", val);
3804         printf ("EHLQ, DUKE, DO, CTEQ2L, CTEQ, and CTEQ3L.\n");
3805         return;
3806     }
3807 }
3808
3809 /**************************************************************************/
3810
3811 Int_t TIsajet::GetISTRUC() const
3812 {
3813     return QCDPAR.istruc;
3814 }
3815
3816 /**************************************************************************/
3817
3818 // Ends QCDPAR access.
3819 // Begins QLMASS access.
3820
3821 /**************************************************************************/
3822
3823 void TIsajet::SetAMLEP(Float_t val, Int_t index)
3824 {
3825     Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3826     if ((index < 0) || (index >= length)) {
3827         printf ("Error in TIsajet::SetAMLEP : \n");
3828         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3829         return;
3830     }
3831
3832     if (((index < 5) && (index > 7)) &&
3833         ((index < 21) && (index > 26)) &&
3834         ((index < 29) && (index > 36)) &&
3835         ((index < 39) && (index > 40)) &&
3836         ((index < 63) && (index > 71)))
3837         {
3838             printf ("Error in TIsajet::SetAMLEP : \n");
3839             printf ("Index %d may not be set by the user. Valid indices are : \n", index);
3840             printf ("5-7, 21-26, 29-36, 39-40 and 63-71.\n");
3841             return;
3842         }
3843
3844     QLMASS.amlep[index] = val;
3845 }
3846
3847 /**************************************************************************/
3848
3849 Float_t TIsajet::GetAMLEP(Int_t index) const
3850 {
3851     Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3852     if ((index < 0) || (index >= length)) {
3853         printf ("Error in TIsajet::GetAMLEP : \n");
3854         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3855         return 0;
3856     }
3857     if   ((index < 5) || (index > 71) ||
3858           ((index > 7)  && (index < 21)) ||
3859           ((index > 26)  && (index < 29)) ||
3860           ((index > 36)  && (index < 39)) ||
3861           ((index > 40)  && (index < 63)))
3862         {
3863             printf ("Possible error in TIsajet::GetAMLEP : \n");
3864             printf ("Index %d may not be set by the user. Valid indices are : \n", index);
3865             printf ("5-7, 21-26, 29-36, 39-40 and 63-71. \n");
3866             printf ("To return the value of this index, use GetAnyAMLEP(Int_t index).\n");
3867             return 0;
3868         }
3869
3870
3871     return QLMASS.amlep[index];
3872 }
3873
3874 /**************************************************************************/
3875
3876 Float_t TIsajet::GetAnyAMLEP(Int_t index) const
3877 {
3878     Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3879     if ((index < 0) || (index >= length)) {
3880         printf ("Error in TIsajet::GetAnyAMLEP : \n");
3881         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3882         return 0;
3883     }
3884
3885     return QLMASS.amlep[index];
3886 }
3887
3888 /**************************************************************************/
3889
3890 void TIsajet::SetTquarkMass(Float_t val)
3891 {
3892     QLMASS.amlep[5] = val;
3893 }
3894
3895 /**************************************************************************/
3896
3897 Float_t TIsajet::GetTquarkMass() const
3898 {
3899     return QLMASS.amlep[5];
3900 }
3901
3902 /**************************************************************************/
3903
3904 void TIsajet::SetXquarkMass(Float_t val)
3905 {
3906     QLMASS.amlep[6] = val;
3907 }
3908
3909 /**************************************************************************/
3910
3911 Float_t TIsajet::GetXquarkMass() const
3912 {
3913     return QLMASS.amlep[6];
3914 }
3915
3916 /**************************************************************************/
3917
3918 void TIsajet::SetYquarkMass(Float_t val)
3919 {
3920     QLMASS.amlep[7] = val;
3921 }
3922
3923 /**************************************************************************/
3924
3925 Float_t TIsajet::GetYquarkMass() const
3926 {
3927     return QLMASS.amlep[7];
3928 }
3929
3930 /**************************************************************************/
3931
3932 void TIsajet::SetUtildeMass(Float_t val)
3933 {
3934     QLMASS.amlep[21] = val;
3935 }
3936
3937 /**************************************************************************/
3938
3939 Float_t TIsajet::GetUtildeMass() const
3940 {
3941     return QLMASS.amlep[21];
3942 }
3943
3944 /**************************************************************************/
3945
3946 void TIsajet::SetDtildeMass(Float_t val)
3947 {
3948     QLMASS.amlep[22] = val;
3949 }
3950
3951 /**************************************************************************/
3952
3953 Float_t TIsajet::GetDtildeMass() const
3954 {
3955     return QLMASS.amlep[22];
3956 }
3957
3958 /**************************************************************************/
3959
3960 void TIsajet::SetStildeMass(Float_t val)
3961 {
3962     QLMASS.amlep[23] = val;
3963 }
3964
3965 /**************************************************************************/
3966
3967 Float_t TIsajet::GetStildeMass() const
3968 {
3969     return QLMASS.amlep[23];
3970 }
3971
3972 /**************************************************************************/
3973
3974 void TIsajet::SetCtildeMass(Float_t val)
3975 {
3976     QLMASS.amlep[24] = val;
3977 }
3978
3979 /**************************************************************************/
3980
3981 Float_t TIsajet::GetCtildeMass() const
3982 {
3983     return QLMASS.amlep[24];
3984 }
3985
3986 /**************************************************************************/
3987
3988 void TIsajet::SetBtildeMass(Float_t val)
3989 {
3990     QLMASS.amlep[25] = val;
3991 }
3992
3993 /**************************************************************************/
3994
3995 Float_t TIsajet::GetBtildeMass() const
3996 {
3997     return QLMASS.amlep[25];
3998 }
3999
4000 /**************************************************************************/
4001
4002 void TIsajet::SetTtildeMass(Float_t val)
4003 {
4004     QLMASS.amlep[26] = val;
4005 }
4006
4007 /**************************************************************************/
4008
4009 Float_t TIsajet::GetTtildeMass() const
4010 {
4011     return QLMASS.amlep[26];
4012 }
4013
4014 /**************************************************************************/
4015
4016 void TIsajet::SetGtildeMass(Float_t val)
4017 {
4018     QLMASS.amlep[29] = val;
4019 }
4020
4021 /**************************************************************************/
4022
4023 Float_t TIsajet::GetGtildeMass() const
4024 {
4025     return QLMASS.amlep[29];
4026 }
4027
4028 /**************************************************************************/
4029
4030 void TIsajet::SetGammatildeMass(Float_t val)
4031 {
4032     QLMASS.amlep[30] = val;
4033 }
4034
4035 /**************************************************************************/
4036
4037 Float_t TIsajet::GetGammatildeMass() const
4038 {
4039     return QLMASS.amlep[30];
4040 }
4041
4042 /**************************************************************************/
4043
4044 void TIsajet::SetNuEtildeMass(Float_t val)
4045 {
4046     QLMASS.amlep[31] = val;
4047 }
4048
4049 /**************************************************************************/
4050
4051 Float_t TIsajet::GetNuEtildeMass() const
4052 {
4053     return QLMASS.amlep[31];
4054 }
4055
4056 /**************************************************************************/
4057
4058 void TIsajet::SetEtildeMass(Float_t val)
4059 {
4060     QLMASS.amlep[32] = val;
4061 }
4062
4063 /**************************************************************************/
4064
4065 Float_t TIsajet::GetEtildeMass() const
4066 {
4067     return QLMASS.amlep[32];
4068 }
4069
4070 /**************************************************************************/
4071
4072 void TIsajet::SetNuMutildeMass(Float_t val)
4073 {
4074     QLMASS.amlep[33] = val;
4075 }
4076
4077 /**************************************************************************/
4078
4079 Float_t TIsajet::GetNuMutildeMass() const
4080 {
4081     return QLMASS.amlep[33];
4082 }
4083
4084 /**************************************************************************/
4085
4086 void TIsajet::SetMutildeMass(Float_t val)
4087 {
4088     QLMASS.amlep[34] = val;
4089 }
4090
4091 /**************************************************************************/
4092
4093 Float_t TIsajet::GetMutildeMass() const
4094 {
4095     return QLMASS.amlep[34];
4096 }
4097
4098 /**************************************************************************/
4099
4100 void TIsajet::SetNuTautildeMass(Float_t val)
4101 {
4102     QLMASS.amlep[35] = val;
4103 }
4104
4105 /**************************************************************************/
4106
4107 Float_t TIsajet::GetNuTautildeMass() const
4108 {
4109     return QLMASS.amlep[35];
4110 }
4111
4112 /**************************************************************************/
4113
4114 void TIsajet::SetTautildeMass(Float_t val)
4115 {
4116     QLMASS.amlep[36] = val;
4117 }
4118
4119 /**************************************************************************/
4120
4121 Float_t TIsajet::GetTautildeMass() const
4122 {
4123     return QLMASS.amlep[36];
4124 }
4125
4126 /**************************************************************************/
4127
4128 void TIsajet::SetWplustildeMass(Float_t val)
4129 {
4130     QLMASS.amlep[39] = val;
4131 }
4132
4133 /**************************************************************************/
4134
4135 Float_t TIsajet::GetWplustildeMass() const
4136 {
4137     return QLMASS.amlep[39];
4138 }
4139
4140 /**************************************************************************/
4141
4142 void TIsajet::SetZ0tildeMass(Float_t val)
4143 {
4144     QLMASS.amlep[40] = val;
4145 }
4146
4147 /**************************************************************************/
4148
4149 Float_t TIsajet::GetZ0tildeMass() const
4150 {
4151     return QLMASS.amlep[40];
4152 }
4153
4154 /**************************************************************************/
4155
4156 void TIsajet::SetHiggsMesonMass(Float_t val, Int_t index)
4157 {
4158     if ((index < 1) || (index > 9)) {
4159         printf ("Error in TIsajet::SetHiggsMesonMass : \n");
4160         printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
4161         return;
4162     }
4163
4164     QLMASS.amlep[62 + index] = val;
4165 }
4166
4167 /**************************************************************************/
4168
4169 Float_t TIsajet::GetHiggsMesonMass(Int_t index) const
4170 {
4171     if ((index < 1) || (index > 9)) {
4172         printf ("Error in TIsajet::GetHiggsMesonMass : \n");
4173         printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
4174         return 0;
4175     }
4176
4177     return QLMASS.amlep[62 + index];
4178 }
4179
4180 /**************************************************************************/
4181
4182 Int_t TIsajet::GetNQLEP() const
4183 {
4184     return QLMASS.nqlep;
4185 }
4186
4187 /**************************************************************************/
4188
4189 Int_t TIsajet::GetNMES() const
4190 {
4191     return QLMASS.nmes;
4192 }
4193
4194 /**************************************************************************/
4195
4196 Int_t TIsajet::GetNBARY() const
4197 {
4198     return QLMASS.nbary;
4199 }
4200
4201 /**************************************************************************/
4202
4203 // Ends QLMASS access.
4204 // Begins SEED access.
4205
4206 /**************************************************************************/
4207
4208 void TIsajet::SetSEED(const Char_t val[24])
4209 {
4210     Int_t length = (sizeof SEED.xseed / sizeof SEED.xseed[0]);
4211
4212     for (Int_t i = 0; i < length; i++) {
4213         SEED.xseed[i] = val[i];
4214     }
4215 }
4216
4217 /**************************************************************************/
4218
4219 Char_t* TIsajet::GetSEED() const
4220 {
4221     return SEED.xseed;
4222 }
4223
4224 /**************************************************************************/
4225
4226 // Ends SEED access - short and sweet, wasn't it?
4227 // Begins SUGNU access, an entirely different business.
4228
4229 /**************************************************************************/
4230
4231 void TIsajet::SetXNUSUG(Float_t val, Int_t index)
4232 {
4233     Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
4234     if ((index < 0) || (index >= length)) {
4235         printf ("Error in TIsajet::SetXNUSUG : \n");
4236         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4237         return;
4238     }
4239
4240     SUGNU.xnusug[index] = val;
4241 }
4242
4243 /**************************************************************************/
4244
4245 Float_t TIsajet::GetXNUSUG(Int_t index) const
4246 {
4247     Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
4248     if ((index < 0) || (index >= length)) {
4249         printf ("Error in TIsajet::GetXNUSUG : \n");
4250         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4251         return 0;
4252     }
4253
4254     return SUGNU.xnusug[index];
4255 }
4256
4257 /**************************************************************************/
4258
4259 void TIsajet::SetGauginoMass(Float_t val, Int_t index)
4260 {
4261     if ((index < 1) || (index > 9)) {
4262         printf ("Error in TIsajet::SetGauginoMass : \n");
4263         printf ("Invalid gaugino number %d; range is 1-3.\n", index);
4264         return;
4265     }
4266
4267     SUGNU.xnusug[index-1] = val;
4268 }
4269
4270 /**************************************************************************/
4271
4272 Float_t TIsajet::GetGauginoMass(Int_t index) const
4273 {
4274     if ((index < 1) || (index > 3)) {
4275         printf ("Error in TIsajet::GetGauginoMass : \n");
4276         printf ("Invalid gaugino number %d; range is 1-3.\n", index);
4277         return 0;
4278     }
4279
4280     return SUGNU.xnusug[index-1];
4281 }
4282
4283 /**************************************************************************/
4284
4285 void TIsajet::SetAtau(Float_t val)
4286 {
4287     SUGNU.xnusug[3] = val;
4288 }
4289
4290 /**************************************************************************/
4291
4292 Float_t TIsajet::GetAtau() const
4293 {
4294     return SUGNU.xnusug[3];
4295 }
4296
4297 /**************************************************************************/
4298
4299 void TIsajet::SetAb(Float_t val)
4300 {
4301     SUGNU.xnusug[4] = val;
4302 }
4303
4304 /**************************************************************************/
4305
4306 Float_t TIsajet::GetAb() const
4307 {
4308     return SUGNU.xnusug[4];
4309 }
4310
4311 /**************************************************************************/
4312
4313 void TIsajet::SetAt(Float_t val)
4314 {
4315     SUGNU.xnusug[5] = val;
4316 }
4317
4318 /**************************************************************************/
4319
4320 Float_t TIsajet::GetAt() const
4321 {
4322     return SUGNU.xnusug[5];
4323 }
4324
4325 /**************************************************************************/
4326
4327 void TIsajet::SetHiggsDmass(Float_t val)
4328 {
4329     SUGNU.xnusug[6] = val;
4330 }
4331
4332 /**************************************************************************/
4333
4334 Float_t TIsajet::GetHiggsDmass() const
4335 {
4336     return SUGNU.xnusug[6];
4337 }
4338
4339 /**************************************************************************/
4340
4341 void TIsajet::SetHiggsUmass(Float_t val)
4342 {
4343     SUGNU.xnusug[7] = val;
4344 }
4345
4346 /**************************************************************************/
4347
4348 Float_t TIsajet::GetHiggsUmass() const
4349 {
4350     return SUGNU.xnusug[7];
4351 }
4352
4353 /**************************************************************************/
4354
4355 void TIsajet::SetERmass(Float_t val)
4356 {
4357     SUGNU.xnusug[8] = val;
4358 }
4359
4360 /**************************************************************************/
4361
4362 Float_t TIsajet::GetERmass() const
4363 {
4364     return SUGNU.xnusug[8];
4365 }
4366
4367 /**************************************************************************/
4368
4369 void TIsajet::SetELmass(Float_t val)
4370 {
4371     SUGNU.xnusug[9] = val;
4372 }
4373
4374 /**************************************************************************/
4375
4376 Float_t TIsajet::GetELmass() const
4377 {
4378     return SUGNU.xnusug[9];
4379 }
4380
4381 /**************************************************************************/
4382
4383 void TIsajet::SetDRmass(Float_t val)
4384 {
4385     SUGNU.xnusug[10] = val;
4386 }
4387
4388 /**************************************************************************/
4389
4390 Float_t TIsajet::GetDRmass() const
4391 {
4392     return SUGNU.xnusug[10];
4393 }
4394
4395 /**************************************************************************/
4396
4397 void TIsajet::SetURmass(Float_t val)
4398 {
4399     SUGNU.xnusug[11] = val;
4400 }
4401
4402 /**************************************************************************/
4403
4404 Float_t TIsajet::GetURmass() const
4405 {
4406     return SUGNU.xnusug[11];
4407 }
4408
4409 /**************************************************************************/
4410
4411 void TIsajet::SetULmass(Float_t val)
4412 {
4413     SUGNU.xnusug[12] = val;
4414 }
4415
4416 /**************************************************************************/
4417
4418 Float_t TIsajet::GetULmass() const
4419 {
4420     return SUGNU.xnusug[12];
4421 }
4422
4423 /**************************************************************************/
4424
4425 void TIsajet::SetTauRmass(Float_t val)
4426 {
4427     SUGNU.xnusug[13] = val;
4428 }
4429
4430 /**************************************************************************/
4431
4432 Float_t TIsajet::GetTauRmass() const
4433 {
4434     return SUGNU.xnusug[13];
4435 }
4436
4437 /**************************************************************************/
4438
4439 void TIsajet::SetTauLmass(Float_t val)
4440 {
4441     SUGNU.xnusug[14] = val;
4442 }
4443
4444 /**************************************************************************/
4445
4446 Float_t TIsajet::GetTauLmass() const
4447 {
4448     return SUGNU.xnusug[14];
4449 }
4450
4451 /**************************************************************************/
4452
4453 void TIsajet::SetBRmass(Float_t val)
4454 {
4455     SUGNU.xnusug[15] = val;
4456 }
4457
4458 /**************************************************************************/
4459
4460 Float_t TIsajet::GetBRmass() const
4461 {
4462     return SUGNU.xnusug[15];
4463 }
4464
4465 /**************************************************************************/
4466
4467 void TIsajet::SetTRmass(Float_t val)
4468 {
4469     SUGNU.xnusug[16] = val;
4470 }
4471
4472 /**************************************************************************/
4473
4474 Float_t TIsajet::GetTRmass() const
4475 {
4476     return SUGNU.xnusug[16];
4477 }
4478
4479 /**************************************************************************/
4480
4481 void TIsajet::SetTLmass(Float_t val)
4482 {
4483     SUGNU.xnusug[17] = val;
4484 }
4485
4486 /**************************************************************************/
4487
4488 Float_t TIsajet::GetTLmass() const
4489 {
4490     return SUGNU.xnusug[17];
4491 }
4492
4493 /**************************************************************************/
4494
4495 // Ends XNUSUG access.
4496 // Begins TCPAR access.
4497
4498 /**************************************************************************/
4499
4500 void TIsajet::SetTCMRHO(Float_t val)
4501 {
4502     TCPAR.tcmrho = val;
4503 }
4504
4505 /**************************************************************************/
4506
4507 Float_t TIsajet::GetTCMRHO() const
4508 {
4509     return TCPAR.tcmrho;
4510 }
4511
4512 /**************************************************************************/
4513
4514 void TIsajet::SetTCGRHO(Float_t val)
4515 {
4516     TCPAR.tcgrho = val;
4517 }
4518
4519 /**************************************************************************/
4520
4521 Float_t TIsajet::GetTCGRHO() const
4522 {
4523     return TCPAR.tcgrho;
4524 }
4525
4526 /**************************************************************************/
4527
4528 // Ends TCPAR access.
4529 // Begins TYPES access.
4530
4531 /**************************************************************************/
4532
4533 Int_t TIsajet::GetLOC(Int_t index) const
4534 {
4535     Int_t length = (sizeof TYPES.loc / sizeof TYPES.loc[0]);
4536     if ((index < 0) || (index >= length)) {
4537         printf ("Error in TIsajet::GetLOC : \n");
4538         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4539         return 0;
4540     }
4541
4542     return TYPES.loc[index];
4543 }
4544
4545 /**************************************************************************/
4546
4547 Int_t TIsajet::GetNTYP() const
4548 {
4549     return TYPES.ntyp;
4550 }
4551
4552 /**************************************************************************/
4553
4554 Int_t TIsajet::GetNJTTYP(Int_t index) const
4555 {
4556     Int_t length = (sizeof TYPES.njttyp / sizeof TYPES.njttyp[0]);
4557     if ((index < 0) || (index >= length)) {
4558         printf ("Error in TIsajet::GetNJTYP : \n");
4559         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4560         return 0;
4561     }
4562
4563     return TYPES.njttyp[index];
4564 }
4565
4566 /**************************************************************************/
4567
4568 Int_t TIsajet::GetNWWTYP(Int_t index) const
4569 {
4570     Int_t length = (sizeof TYPES.nwwtyp / sizeof TYPES.nwwtyp[0]);
4571     if ((index < 0) || (index >= length)) {
4572         printf ("Error in TIsajet::GetNWWTYP : \n");
4573         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4574         return 0;
4575     }
4576
4577     return TYPES.nwwtyp[index];
4578 }
4579
4580 /**************************************************************************/
4581
4582 Int_t TIsajet::GetNWMODE(Int_t index) const
4583 {
4584     Int_t length = (sizeof TYPES.nwmode / sizeof TYPES.nwmode[0]);
4585     if ((index < 0) || (index >= length)) {
4586         printf ("Error in TIsajet::GetNWMODE : \n");
4587         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4588         return 0;
4589     }
4590
4591     return TYPES.nwmode[index];
4592 }
4593
4594 /**************************************************************************/
4595
4596 // Ends TYPES access.
4597 // Begins XMSSM access.
4598
4599 /**************************************************************************/
4600
4601 Bool_t TIsajet::GetGOMSSM() const
4602 {
4603     return XMSSM.gomssm;
4604 }
4605
4606 /**************************************************************************/
4607
4608 Bool_t TIsajet::GetGOSUG() const
4609 {
4610     return XMSSM.gosug;
4611 }
4612
4613 /**************************************************************************/
4614
4615 Bool_t TIsajet::GetGOGMSB() const
4616 {
4617     return XMSSM.gogmsb;
4618 }
4619
4620 /**************************************************************************/
4621
4622 Bool_t TIsajet::GetGOAMSB() const
4623 {
4624     return XMSSM.goamsb;
4625 }
4626
4627 /**************************************************************************/
4628
4629 Bool_t TIsajet::GetAL3UNI() const
4630 {
4631     return XMSSM.al3uni;
4632 }
4633
4634 /**************************************************************************/
4635
4636 void TIsajet::SetXGLSS(Float_t val)
4637 {
4638     XMSSM.xglss = val;
4639 }
4640
4641 /**************************************************************************/
4642
4643 Float_t TIsajet::GetXGLSS() const
4644 {
4645     return XMSSM.xglss;
4646 }
4647
4648 /**************************************************************************/
4649
4650 void TIsajet::SetXMUSS(Float_t val)
4651 {
4652     XMSSM.xmuss = val;
4653 }
4654
4655 /**************************************************************************/
4656
4657 Float_t TIsajet::GetXMUSS() const
4658 {
4659     return XMSSM.xmuss;
4660 }
4661
4662 /**************************************************************************/
4663
4664 void TIsajet::SetXHASS(Float_t val)
4665 {
4666     XMSSM.xhass = val;
4667 }
4668
4669 /**************************************************************************/
4670
4671 Float_t TIsajet::GetXHASS() const
4672 {
4673     return XMSSM.xhass;
4674 }
4675
4676 /**************************************************************************/
4677
4678 void TIsajet::SetXTBSS(Float_t val)
4679 {
4680     XMSSM.xtbss = val;
4681 }
4682
4683 /**************************************************************************/
4684
4685 Float_t TIsajet::GetXTBSS() const
4686 {
4687     return XMSSM.xtbss;
4688 }
4689
4690 /**************************************************************************/
4691
4692 void TIsajet::SetXQ1SS(Float_t val)
4693 {
4694     XMSSM.xq1ss = val;
4695 }
4696
4697 /**************************************************************************/
4698
4699 Float_t TIsajet::GetXQ1SS() const
4700 {
4701     return XMSSM.xq1ss;
4702 }
4703
4704 /**************************************************************************/
4705
4706 void TIsajet::SetXDRSS(Float_t val)
4707 {
4708     XMSSM.xdrss = val;
4709 }
4710
4711 /**************************************************************************/
4712
4713 Float_t TIsajet::GetXDRSS() const
4714 {
4715     return XMSSM.xdrss;
4716 }
4717
4718 /**************************************************************************/
4719
4720 void TIsajet::SetXURSS(Float_t val)
4721 {
4722     XMSSM.xurss = val;
4723 }
4724
4725 /**************************************************************************/
4726
4727 Float_t TIsajet::GetXURSS() const
4728 {
4729     return XMSSM.xurss;
4730 }
4731
4732 /**************************************************************************/
4733
4734 void TIsajet::SetXL1SS(Float_t val)
4735 {
4736     XMSSM.xl1ss = val;
4737 }
4738
4739 /**************************************************************************/
4740
4741 Float_t TIsajet::GetXL1SS() const
4742 {
4743     return XMSSM.xl1ss;
4744 }
4745
4746 /**************************************************************************/
4747
4748 void TIsajet::SetXERSS(Float_t val)
4749 {
4750     XMSSM.xerss = val;
4751 }
4752
4753 /**************************************************************************/
4754
4755 Float_t TIsajet::GetXERSS() const
4756 {
4757     return XMSSM.xerss;
4758 }
4759
4760 /**************************************************************************/
4761
4762 void TIsajet::SetXQ2SS(Float_t val)
4763 {
4764     XMSSM.xq2ss = val;
4765 }
4766
4767 /**************************************************************************/
4768
4769 Float_t TIsajet::GetXQ2SS() const
4770 {
4771     return XMSSM.xq2ss;
4772 }
4773
4774 /**************************************************************************/
4775
4776 void TIsajet::SetXSRSS(Float_t val)
4777 {
4778     XMSSM.xsrss = val;
4779 }
4780
4781 /**************************************************************************/
4782
4783 Float_t TIsajet::GetXSRSS() const
4784 {
4785     return XMSSM.xsrss;
4786 }
4787
4788 /**************************************************************************/
4789
4790 void TIsajet::SetXCRSS(Float_t val)
4791 {
4792     XMSSM.xcrss = val;
4793 }
4794
4795 /**************************************************************************/
4796
4797 Float_t TIsajet::GetXCRSS() const
4798 {
4799     return XMSSM.xcrss;
4800 }
4801
4802 /**************************************************************************/
4803
4804 void TIsajet::SetXL2SS(Float_t val)
4805 {
4806     XMSSM.xl2ss = val;
4807 }
4808
4809 /**************************************************************************/
4810
4811 Float_t TIsajet::GetXL2SS() const
4812 {
4813     return XMSSM.xl2ss;
4814 }
4815
4816 /**************************************************************************/
4817
4818 void TIsajet::SetXMRSS(Float_t val)
4819 {
4820     XMSSM.xmrss = val;
4821 }
4822
4823 /**************************************************************************/
4824
4825 Float_t TIsajet::GetXMRSS() const
4826 {
4827     return XMSSM.xmrss;
4828 }
4829
4830 /**************************************************************************/
4831
4832 void TIsajet::SetXQ3SS(Float_t val)
4833 {
4834     XMSSM.xq3ss = val;
4835 }
4836
4837 /**************************************************************************/
4838
4839 Float_t TIsajet::GetXQ3SS() const
4840 {
4841     return XMSSM.xq3ss;
4842 }
4843
4844 /**************************************************************************/
4845
4846 void TIsajet::SetXBRSS(Float_t val)
4847 {
4848     XMSSM.xbrss = val;
4849 }
4850
4851 /**************************************************************************/
4852
4853 Float_t TIsajet::GetXBRSS() const
4854 {
4855     return XMSSM.xbrss;
4856 }
4857
4858 /**************************************************************************/
4859
4860 void TIsajet::SetXTRSS(Float_t val)
4861 {
4862     XMSSM.xtrss = val;
4863 }
4864
4865 /**************************************************************************/
4866
4867 Float_t TIsajet::GetXTRSS() const
4868 {
4869     return XMSSM.xtrss;
4870 }
4871
4872 /**************************************************************************/
4873
4874 void TIsajet::SetXL3SS(Float_t val)
4875 {
4876     XMSSM.xl3ss = val;
4877 }
4878
4879 /**************************************************************************/
4880
4881 Float_t TIsajet::GetXL3SS() const
4882 {
4883     return XMSSM.xl3ss;
4884 }
4885
4886 /**************************************************************************/
4887
4888 void TIsajet::SetXTARSS(Float_t val)
4889 {
4890     XMSSM.xtarss = val;
4891 }
4892
4893 /**************************************************************************/
4894
4895 Float_t TIsajet::GetXTARSS() const
4896 {
4897     return XMSSM.xtarss;
4898 }
4899
4900 /**************************************************************************/
4901
4902 void TIsajet::SetXATSS(Float_t val)
4903 {
4904     XMSSM.xatss = val;
4905 }
4906
4907 /**************************************************************************/
4908
4909 Float_t TIsajet::GetXATSS() const
4910 {
4911     return XMSSM.xatss;
4912 }
4913
4914 /**************************************************************************/
4915
4916 void TIsajet::SetXABSS(Float_t val)
4917 {
4918     XMSSM.xabss = val;
4919 }
4920
4921 /**************************************************************************/
4922
4923 Float_t TIsajet::GetXABSS() const
4924 {
4925     return XMSSM.xabss;
4926 }
4927
4928 /**************************************************************************/
4929
4930 void TIsajet::SetXATASS(Float_t val)
4931 {
4932     XMSSM.xatass = val;
4933 }
4934
4935 /**************************************************************************/
4936
4937 Float_t TIsajet::GetXATASS() const
4938 {
4939     return XMSSM.xatass;
4940 }
4941
4942 /**************************************************************************/
4943
4944 void TIsajet::SetXM1SS(Float_t val)
4945 {
4946     XMSSM.xm1ss = val;
4947 }
4948
4949 /**************************************************************************/
4950
4951 Float_t TIsajet::GetXM1SS() const
4952 {
4953     return XMSSM.xm1ss;
4954 }
4955
4956 /**************************************************************************/
4957
4958 void TIsajet::SetXM2SS(Float_t val)
4959 {
4960     XMSSM.xm2ss = val;
4961 }
4962
4963 /**************************************************************************/
4964
4965 Float_t TIsajet::GetXM2SS() const
4966 {
4967     return XMSSM.xm2ss;
4968 }
4969
4970 /**************************************************************************/
4971
4972 void TIsajet::SetXM0SU(Float_t val)
4973 {
4974     XMSSM.xm0su = val;
4975 }
4976
4977 /**************************************************************************/
4978
4979 Float_t TIsajet::GetXM0SU() const
4980 {
4981     return XMSSM.xm0su;
4982 }
4983
4984 /**************************************************************************/
4985
4986 void TIsajet::SetXMHSU(Float_t val)
4987 {
4988     XMSSM.xmhsu = val;
4989 }
4990
4991 /**************************************************************************/
4992
4993 Float_t TIsajet::GetXMHSU() const
4994 {
4995     return XMSSM.xmhsu;
4996 }
4997
4998 /**************************************************************************/
4999
5000 void TIsajet::SetXA0SU(Float_t val)
5001 {
5002     XMSSM.xa0su = val;
5003 }
5004
5005 /**************************************************************************/
5006
5007 Float_t TIsajet::GetXA0SU() const
5008 {
5009     return XMSSM.xa0su;
5010 }
5011
5012 /**************************************************************************/
5013
5014 void TIsajet::SetXTGBSU(Float_t val)
5015 {
5016     XMSSM.xtgbsu = val;
5017 }
5018
5019 /**************************************************************************/
5020
5021 Float_t TIsajet::GetXTGBSU() const
5022 {
5023     return XMSSM.xtgbsu;
5024 }
5025
5026 /**************************************************************************/
5027
5028 void TIsajet::SetXSMUSU(Float_t val)
5029 {
5030     XMSSM.xsmusu = val;
5031 }
5032
5033 /**************************************************************************/
5034
5035 Float_t TIsajet::GetXSMUSU() const
5036 {
5037     return XMSSM.xsmusu;
5038 }
5039
5040 /**************************************************************************/
5041
5042 void TIsajet::SetXLAMGM(Float_t val)
5043 {
5044     XMSSM.xlamgm = val;
5045 }
5046
5047 /**************************************************************************/
5048
5049 Float_t TIsajet::GetXLAMGM() const
5050 {
5051     return XMSSM.xlamgm;
5052 }
5053
5054 /**************************************************************************/
5055
5056 void TIsajet::SetXMESGM(Float_t val)
5057 {
5058     XMSSM.xmesgm = val;
5059 }
5060
5061 /**************************************************************************/
5062
5063 Float_t TIsajet::GetXMESGM() const
5064 {
5065     return XMSSM.xmesgm;
5066 }
5067
5068 /**************************************************************************/
5069
5070 void TIsajet::SetXN5GM(Float_t val)
5071 {
5072     XMSSM.xn5gm = val;
5073 }
5074
5075 /**************************************************************************/
5076
5077 Float_t TIsajet::GetXN5GM() const
5078 {
5079     return XMSSM.xn5gm;
5080 }
5081
5082 /**************************************************************************/
5083
5084 void TIsajet::SetXCMGV(Float_t val)
5085 {
5086     XMSSM.xcmgv = val;
5087 }
5088
5089 /**************************************************************************/
5090
5091 Float_t TIsajet::GetXCMGV() const
5092 {
5093     return XMSSM.xcmgv;
5094 }
5095
5096 /**************************************************************************/
5097
5098 void TIsajet::SetMGVTO(Float_t val)
5099 {
5100     XMSSM.mgvto = val;
5101 }
5102
5103 /**************************************************************************/
5104
5105 Float_t TIsajet::GetMGVTO() const
5106 {
5107     return XMSSM.mgvto;
5108 }
5109
5110 /**************************************************************************/
5111
5112 void TIsajet::SetXRSLGM(Float_t val)
5113 {
5114     XMSSM.xrslgm = val;
5115 }
5116
5117 /**************************************************************************/
5118
5119 Float_t TIsajet::GetXRSLGM() const
5120 {
5121     return XMSSM.xrslgm;
5122 }
5123
5124 /**************************************************************************/
5125
5126 void TIsajet::SetXDHDGM(Float_t val)
5127 {
5128     XMSSM.xdhdgm = val;
5129 }
5130
5131 /**************************************************************************/
5132
5133 Float_t TIsajet::GetXDHDGM() const
5134 {
5135     return XMSSM.xdhdgm;
5136 }
5137
5138 /**************************************************************************/
5139
5140 void TIsajet::SetXDHUGM(Float_t val)
5141 {
5142     XMSSM.xdhugm = val;
5143 }
5144
5145 /**************************************************************************/
5146
5147 Float_t TIsajet::GetXDHUGM() const
5148 {
5149     return XMSSM.xdhugm;
5150 }
5151
5152 /**************************************************************************/
5153
5154 void TIsajet::SetXDYGM(Float_t val)
5155 {
5156     XMSSM.xdygm = val;
5157 }
5158
5159 /**************************************************************************/
5160
5161 Float_t TIsajet::GetXDYGM() const
5162 {
5163     return XMSSM.xdygm;
5164 }
5165
5166 /**************************************************************************/
5167
5168 void TIsajet::SetXN51GM(Float_t val)
5169 {
5170     XMSSM.xn51gm = val;
5171 }
5172
5173 /**************************************************************************/
5174
5175 Float_t TIsajet::GetXN51GM() const
5176 {
5177     return XMSSM.xn51gm;
5178 }
5179
5180 /**************************************************************************/
5181
5182 void TIsajet::SetXN52GM(Float_t val)
5183 {
5184     XMSSM.xn52gm = val;
5185 }
5186
5187 /**************************************************************************/
5188
5189 Float_t TIsajet::GetXN52GM() const
5190 {
5191     return XMSSM.xn52gm;
5192 }
5193
5194 /**************************************************************************/
5195
5196 void TIsajet::SetXN53GM(Float_t val)
5197 {
5198     XMSSM.xn53gm = val;
5199 }
5200
5201 /**************************************************************************/
5202
5203 Float_t TIsajet::GetXN53GM() const
5204 {
5205     return XMSSM.xn53gm;
5206 }
5207
5208 /**************************************************************************/
5209
5210 void TIsajet::SetXMN3NR(Float_t val)
5211 {
5212     XMSSM.xmn3nr = val;
5213 }
5214
5215 /**************************************************************************/
5216
5217 Float_t TIsajet::GetXMN3NR() const
5218 {
5219     return XMSSM.xmn3nr;
5220 }
5221
5222 /**************************************************************************/
5223
5224 void TIsajet::SetXMAJNR(Float_t val)
5225 {
5226     XMSSM.xmajnr = val;
5227 }
5228
5229 /**************************************************************************/
5230
5231 Float_t TIsajet::GetXMAJNR() const
5232 {
5233     return XMSSM.xmajnr;
5234 }
5235
5236 /**************************************************************************/
5237
5238 void TIsajet::SetXANSS(Float_t val)
5239 {
5240     XMSSM.xanss = val;
5241 }
5242
5243 /**************************************************************************/
5244
5245 Float_t TIsajet::GetXANSS() const
5246 {
5247     return XMSSM.xanss;
5248 }
5249
5250 /**************************************************************************/
5251
5252 void TIsajet::SetXNRSS(Float_t val)
5253 {
5254     XMSSM.xnrss = val;
5255 }
5256
5257 /**************************************************************************/
5258
5259 Float_t TIsajet::GetXNRSS() const
5260 {
5261     return XMSSM.xnrss;
5262 }
5263
5264 /**************************************************************************/
5265
5266 void TIsajet::SetXSBCS(Float_t val)
5267 {
5268     XMSSM.xsbcs = val;
5269 }
5270
5271 /**************************************************************************/
5272
5273 Float_t TIsajet::GetXSBCS() const
5274 {
5275     return XMSSM.xsbcs;
5276 }
5277
5278 /**************************************************************************/
5279
5280 // Ends XMSSM access.
5281 // Begins XTYPES access.
5282
5283 /**************************************************************************/
5284
5285 Char_t* TIsajet::GetPARTYP(Int_t index) const
5286 {
5287     Int_t length = (sizeof XTYPES.partyp / sizeof XTYPES.partyp[0]);
5288     if ((index < 0) || (index >= length)) {
5289         printf ("Error in TIsajet::GetPARTYP : \n");
5290         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5291         return 0;
5292     }
5293
5294     return XTYPES.partyp[index];
5295 }
5296
5297 /**************************************************************************/
5298
5299 void TIsajet::SetTITLE(Char_t *val)
5300 {
5301     title = XTYPES.title = val;
5302 }
5303
5304 /**************************************************************************/
5305 Char_t* TIsajet::GetTITLE() const
5306 {
5307     return XTYPES.title;
5308 }
5309
5310 /**************************************************************************/
5311
5312 void TIsajet::SetJETYP(Int_t index, Char_t val[])
5313 {
5314     Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
5315     Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
5316
5317     if ((index < 0) || (index >= row_num)) {
5318         printf ("Error in TIsajet::SetJETYP : \n");
5319         printf ("Invalid array row index %d; range is 0-%d.\n", index, row_num-1);
5320         return;
5321     }
5322
5323     if (TYPES.njttyp[index] >= col_num) {
5324         printf ("Error in TIsajet::SetJETYP : \n");
5325         printf ("Cannot set more than %d jet types.\n", col_num-1);
5326         return;
5327     }
5328
5329     if ((!strcmp(val, "ALL")) || (!strcmp(val, "GL")) ||
5330         (!strcmp(val, "UP")) || (!strcmp(val, "UB")) ||
5331         (!strcmp(val, "DN")) || (!strcmp(val, "DB")) ||
5332         (!strcmp(val, "ST")) || (!strcmp(val, "SB")) ||
5333         (!strcmp(val, "CH")) || (!strcmp(val, "CB")) ||
5334         (!strcmp(val, "BT")) || (!strcmp(val, "BB")) ||
5335         (!strcmp(val, "TP")) || (!strcmp(val, "TB")) ||
5336         (!strcmp(val, "X")) || (!strcmp(val, "XB")) ||
5337         (!strcmp(val, "Y")) || (!strcmp(val, "YB")) ||
5338         (!strcmp(val, "E-")) || (!strcmp(val, "E+")) ||
5339         (!strcmp(val, "MU-")) || (!strcmp(val, "MU+")) ||
5340         (!strcmp(val, "TAU-")) || (!strcmp(val, "TAU+")) ||
5341         (!strcmp(val, "NUS")) || (!strcmp(val, "GM")) ||
5342         (!strcmp(val, "W+")) || (!strcmp(val, "W-")) ||
5343         (!strcmp(val, "Z0"))) {
5344
5345         XTYPES.jetyp[index][TYPES.njttyp[index]++] = val;
5346     }
5347     else {
5348         printf ("Error in TIsajet::SetJETYP : \n");
5349         printf ("Invalid jet type %s; valid types are\n", val);
5350         printf ("ALL, GL, UP, UB, DN, DB, ST, SB,\n");
5351         printf ("CH, CB, BT, BB, TP, TB, X, XB, Y, YB,\n");
5352         printf ("E-, E+, MU-, MU+, TAU-, TAU+, NUS, GM,\n");
5353         printf ("W+, W- and Z0.\n");
5354         return;
5355     }
5356
5357     if (index == 0) setJettype1 = true;
5358     else if (index == 1) setJettype2 = true;
5359     else if (index == 2) setJettype3 = true;
5360 }
5361
5362 /**************************************************************************/
5363
5364 Char_t* TIsajet::GetJETYP(Int_t index1, Int_t index2) const
5365 {
5366     Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
5367     Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
5368
5369     if ((index1 < 0) || (index1 >= row_num)) {
5370         printf ("Error in TIsajet::GetJETYP : \n");
5371         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5372         return 0;
5373     }
5374
5375     if ((index2 < 0) || (index2 >= col_num)) {
5376         printf ("Error in TIsajet::GetJETYP : \n");
5377         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5378         return 0;
5379     }
5380
5381     return XTYPES.jetyp[index1][index2];
5382 }
5383
5384 /**************************************************************************/
5385
5386 void TIsajet::SetWWTYP(Char_t val[], Int_t index1, Int_t index2)
5387 {
5388     Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5389     Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5390
5391     if ((index1 < 0) || (index1 >= row_num)) {
5392         printf ("Error in TIsajet::SetWWTYP : \n");
5393         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5394         return;
5395     }
5396
5397     if ((index2 < 0) || (index2 >= col_num)) {
5398         printf ("Error in TIsajet::SetWWTYP : \n");
5399         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5400         return;
5401     }
5402
5403     XTYPES.wwtyp[index1][index2] = val;
5404 }
5405
5406 /**************************************************************************/
5407
5408 void TIsajet::SetAllWWTYP(Char_t* val[2][30])
5409 {
5410     for (Int_t i = 0; i < 2; i++) {
5411         for (Int_t j = 0; j < 30; j++) {
5412             SetWWTYP(val[i][j], i, j);
5413         }
5414     }
5415 }
5416
5417 /**************************************************************************/
5418
5419 void TIsajet::SetColumnWWTYP(Char_t* val[], Int_t col)
5420 {
5421     Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5422     Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5423
5424     if ((col < 0) || (col >= col_num)) {
5425         printf ("Error in TIsajet::SetColumnWWTYP : \n");
5426         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
5427         return;
5428     }
5429
5430     for (Int_t i = 0; i < row_num; i++) {
5431         SetWWTYP(val[i], i, col);
5432     }
5433 }
5434
5435 /**************************************************************************/
5436
5437 Char_t* TIsajet::GetWWTYP(Int_t index1, Int_t index2) const
5438 {
5439     Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5440     Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5441
5442     if ((index1 < 0) || (index1 >= row_num)) {
5443         printf ("Error in TIsajet::GetWWTYP : \n");
5444         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5445         return 0;
5446     }
5447
5448     if ((index2 < 0) || (index2 >= col_num)) {
5449         printf ("Error in TIsajet::GetWWTYP : \n");
5450         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5451         return 0;
5452     }
5453
5454     return XTYPES.wwtyp[index1][index2];
5455 }
5456
5457 /**************************************************************************/
5458
5459 void TIsajet::SetWMODES(Char_t val[], Int_t index1, Int_t index2)
5460 {
5461     Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5462     Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5463
5464     if ((index1 < 0) || (index1 >= row_num)) {
5465         printf ("Error in TIsajet::SetWMODES : \n");
5466         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5467         return;
5468     }
5469
5470     if ((index2 < 0) || (index2 >= col_num)) {
5471         printf ("Error in TIsajet::SetWMODES : \n");
5472         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5473         return;
5474     }
5475
5476     XTYPES.wmodes[index1][index2] = val;
5477 }
5478
5479 /**************************************************************************/
5480
5481 void TIsajet::SetAllWMODES(Char_t* val[2][30])
5482 {
5483     for (Int_t i = 0; i < 2; i++) {
5484         for (Int_t j = 0; j < 30; j++) {
5485             SetWMODES(val[i][j], i, j);
5486         }
5487     }
5488 }
5489
5490 /**************************************************************************/
5491
5492 void TIsajet::SetColumnWMODES(Char_t* val[], Int_t col)
5493 {
5494     Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5495     Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5496
5497     if ((col < 0) || (col >= col_num)) {
5498         printf ("Error in TIsajet::SetColumnWMODES : \n");
5499         printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
5500         return;
5501     }
5502
5503     for (Int_t i = 0; i < row_num; i++) {
5504         SetWMODES(val[i], i, col);
5505     }
5506 }
5507
5508 /**************************************************************************/
5509
5510 Char_t* TIsajet::GetWMODES(Int_t index1, Int_t index2) const
5511 {
5512     Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5513     Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5514
5515     if ((index1 < 0) || (index1 >= row_num)) {
5516         printf ("Error in TIsajet::GetWMODES : \n");
5517         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5518         return 0;
5519     }
5520
5521     if ((index2 < 0) || (index2 >= col_num)) {
5522         printf ("Error in TIsajet::GetWMODES : \n");
5523         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5524         return 0;
5525     }
5526
5527     return XTYPES.wmodes[index1][index2];
5528 }
5529
5530 /**************************************************************************/
5531
5532 // Ends XTYPES access.
5533 // Begins WCON access.
5534
5535 /**************************************************************************/
5536
5537 void TIsajet::SetSIN2W(Float_t val)
5538 {
5539     WCON.sin2w = val;
5540 }
5541
5542 /**************************************************************************/
5543
5544 Float_t TIsajet::GetSIN2W() const
5545 {
5546     return WCON.sin2w;
5547 }
5548
5549 /**************************************************************************/
5550
5551 void TIsajet::SetWMASS(Float_t w, Float_t z)
5552 {
5553
5554 // This is how the FORTRAN does it. Don't ask me why.
5555
5556     WCON.wmass[0] = 0;
5557     WCON.wmass[1] = WCON.wmass[2] = w;
5558     WCON.wmass[3] = z;
5559 }
5560
5561 /**************************************************************************/
5562
5563 Float_t TIsajet::GetWMASS(Int_t index) const
5564 {
5565     Int_t length = (sizeof WCON.wmass / sizeof WCON.wmass[0]);
5566     if ((index < 0) || (index >= length)) {
5567         printf ("Error in TIsajet::GetWMASS : \n");
5568         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5569         return 0;
5570     }
5571
5572     return WCON.wmass[index];
5573 }
5574
5575 /**************************************************************************/
5576
5577 void TIsajet::SetWMass(Float_t val)
5578 {
5579     WCON.wmass[1] = WCON.wmass[2] = val;
5580 }
5581
5582 /**************************************************************************/
5583
5584 void TIsajet::SetZMass(Float_t val)
5585 {
5586     WCON.wmass[3]  = val;
5587 }
5588
5589 /**************************************************************************/
5590
5591 Float_t TIsajet::GetWGAM(Int_t index) const
5592 {
5593     Int_t length = (sizeof WCON.wgam / sizeof WCON.wgam[0]);
5594     if ((index < 0) || (index >= length)) {
5595         printf ("Error in TIsajet::GetWGAM : \n");
5596         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5597         return 0;
5598     }
5599
5600     return WCON.wgam[index];
5601 }
5602
5603 /**************************************************************************/
5604
5605 Float_t TIsajet::GetAQ(Int_t index1, Int_t index2) const
5606 {
5607     Int_t col_num = (sizeof WCON.aq[0] / sizeof WCON.aq[0][0]);
5608     Int_t row_num = (sizeof WCON.aq / (sizeof WCON.aq[0][0] * col_num));
5609
5610     if ((index1 < 0) || (index1 >= row_num)) {
5611         printf ("Error in TIsajet::GetAQ : \n");
5612         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5613         return 0;
5614     }
5615
5616     if ((index2 < 0) || (index2 >= col_num)) {
5617         printf ("Error in TIsajet::GetAQ : \n");
5618         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5619         return 0;
5620     }
5621
5622     return WCON.aq[index1][index2];
5623 }
5624
5625 /**************************************************************************/
5626
5627 Float_t TIsajet::GetBQ(Int_t index1, Int_t index2) const
5628 {
5629     Int_t col_num = (sizeof WCON.bq[0] / sizeof WCON.bq[0][0]);
5630     Int_t row_num = (sizeof WCON.bq / (sizeof WCON.bq[0][0] * col_num));
5631
5632     if ((index1 < 0) || (index1 >= row_num)) {
5633         printf ("Error in TIsajet::GetBQ : \n");
5634         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5635         return 0;
5636     }
5637
5638     if ((index2 < 0) || (index2 >= col_num)) {
5639         printf ("Error in TIsajet::GetBQ : \n");
5640         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5641         return 0;
5642     }
5643
5644     return WCON.bq[index1][index2];
5645 }
5646
5647 /**************************************************************************/
5648
5649 Float_t TIsajet::GetCOUT(Int_t index) const
5650 {
5651     Int_t length = (sizeof WCON.cout / sizeof WCON.cout[0]);
5652     if ((index < 0) || (index >= length)) {
5653         printf ("Error in TIsajet::GetCOUT : \n");
5654         printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5655         return 0;
5656     }
5657
5658     return WCON.cout[index];
5659 }
5660
5661 /**************************************************************************/
5662
5663 Int_t TIsajet::GetMATCH() const
5664 {
5665     return WCON.match;
5666 }
5667
5668 /**************************************************************************/
5669
5670 Float_t TIsajet::GetWCBR(Int_t index1, Int_t index2) const
5671 {
5672     Int_t col_num = (sizeof WCON.wcbr[0] / sizeof WCON.wcbr[0][0]);
5673     Int_t row_num = (sizeof WCON.wcbr / (sizeof WCON.wcbr[0][0] * col_num));
5674
5675     if ((index1 < 0) || (index1 >= row_num)) {
5676         printf ("Error in TIsajet::GetWCBR : \n");
5677         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5678         return 0;
5679     }
5680
5681     if ((index2 < 0) || (index2 >= col_num)) {
5682         printf ("Error in TIsajet::GetWCBR : \n");
5683         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5684         return 0;
5685     }
5686
5687     return WCON.wcbr[index1][index2];
5688 }
5689
5690 /**************************************************************************/
5691
5692 void TIsajet::SetCUTOFF(Float_t val)
5693 {
5694     WCON.cutoff = val;
5695 }
5696
5697 /**************************************************************************/
5698
5699 Float_t TIsajet::GetCUTOFF() const
5700 {
5701     return WCON.cutoff;
5702 }
5703
5704 /**************************************************************************/
5705
5706 void TIsajet::SetCUTPOW(Float_t val)
5707 {
5708     WCON.cutpow = val;
5709 }
5710
5711 /**************************************************************************/
5712
5713 Float_t TIsajet::GetCUTPOW() const
5714 {
5715     return WCON.cutpow;
5716 }
5717
5718 /**************************************************************************/
5719
5720 Float_t TIsajet::GetTBRWW(Int_t index1, Int_t index2) const
5721 {
5722     Int_t col_num = (sizeof WCON.tbrww[0] / sizeof WCON.tbrww[0][0]);
5723     Int_t row_num = (sizeof WCON.tbrww / (sizeof WCON.tbrww[0][0] * col_num));
5724
5725     if ((index1 < 0) || (index1 >= row_num)) {
5726         printf ("Error in TIsajet::GetTBRWW : \n");
5727         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5728         return 0;
5729     }
5730
5731     if ((index2 < 0) || (index2 >= col_num)) {
5732         printf ("Error in TIsajet::GetTBRWW : \n");
5733         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5734         return 0;
5735     }
5736
5737     return WCON.tbrww[index1][index2];
5738 }
5739
5740 /**************************************************************************/
5741
5742 Float_t TIsajet::GetRBRWW(Int_t index1, Int_t index2, Int_t index3) const
5743 {
5744     Int_t elem_Size = sizeof WCON.rbrww[0][0][0];
5745     Int_t thd_Dim_Length = (sizeof WCON.rbrww[0][0] / elem_Size);
5746     Int_t sec_Dim_Length = (sizeof WCON.rbrww[0] / (elem_Size * thd_Dim_Length));
5747     Int_t fst_Dim_Length = (sizeof WCON.rbrww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
5748
5749     if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
5750         printf ("Error in TIsajet::GetRBRWW : \n");
5751         printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
5752         return 0;
5753     }
5754
5755     if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
5756         printf ("Error in TIsajet::GetRBRWW : \n");
5757         printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
5758         return 0;
5759     }
5760
5761     if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
5762         printf ("Error in TIsajet::GetRBRWW : \n");
5763         printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
5764         return 0;
5765     }
5766
5767     return WCON.rbrww[index1][index2][index3];
5768
5769 }
5770
5771 /**************************************************************************/
5772
5773 Float_t TIsajet::GetEZ() const
5774 {
5775     return WCON.ez;
5776 }
5777
5778 /**************************************************************************/
5779
5780 Float_t TIsajet::GetAQDP(Int_t index1, Int_t index2) const
5781 {
5782     Int_t col_num = (sizeof WCON.aqdp[0] / sizeof WCON.aqdp[0][0]);
5783     Int_t row_num = (sizeof WCON.aqdp / (sizeof WCON.aqdp[0][0] * col_num));
5784
5785     if ((index1 < 0) || (index1 >= row_num)) {
5786         printf ("Error in TIsajet::GetAQDP : \n");
5787         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5788         return 0;
5789     }
5790
5791     if ((index2 < 0) || (index2 >= col_num)) {
5792         printf ("Error in TIsajet::GetAQDP : \n");
5793         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5794         return 0;
5795     }
5796
5797     return WCON.aqdp[index1][index2];
5798 }
5799
5800 /**************************************************************************/
5801
5802 Float_t TIsajet::GetBQDP(Int_t index1, Int_t index2) const
5803 {
5804     Int_t col_num = (sizeof WCON.bqdp[0] / sizeof WCON.bqdp[0][0]);
5805     Int_t row_num = (sizeof WCON.bqdp / (sizeof WCON.bqdp[0][0] * col_num));
5806
5807     if ((index1 < 0) || (index1 >= row_num)) {
5808         printf ("Error in TIsajet::GetBQDP : \n");
5809         printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5810         return 0;
5811     }
5812
5813     if ((index2 < 0) || (index2 >= col_num)) {
5814         printf ("Error in TIsajet::GetBQDP : \n");
5815         printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5816         return 0;
5817     }
5818
5819     return WCON.bqdp[index1][index2];
5820 }
5821
5822 /**************************************************************************/
5823
5824 Float_t TIsajet::GetEZDP() const
5825 {
5826     return WCON.ezdp;
5827 }
5828
5829 /**************************************************************************/
5830
5831 void TIsajet::SetWFUDGE(Float_t val)
5832 {
5833     WCON.wfudge = val;
5834 }
5835
5836 /**************************************************************************/
5837
5838 Float_t TIsajet::GetWFUDGE() const
5839 {
5840     return WCON.wfudge;
5841 }
5842
5843 /**************************************************************************/
5844
5845 // Ends WCON access.
5846
5847 #ifndef WIN32
5848 # define isaini  isaini_
5849 # define isaevt  isaevt_
5850 # define isabeg  isabeg_
5851 # define isabg2  isabg2_
5852 # define openfiles openfiles_
5853 # define pdfinit pdfinit_
5854 # define ranf    ranf_
5855 # define type_of_call
5856 #else
5857 # define isaini  ISAINI
5858 # define isaevt  ISAEVT
5859 # define isabeg  ISABEG
5860 # define isabg2  ISABG2
5861 # define openfiles OPENFILES
5862 # define pdfinit PDFINIT
5863 # define ranf    RANF
5864 # define type_of_call _stdcall
5865 #endif
5866
5867 extern "C" void type_of_call isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n);
5868 extern "C" void type_of_call isaevt(Int_t& j, Int_t& k, Int_t& m);
5869 extern "C" void type_of_call openfiles();
5870 extern "C" void type_of_call pdfinit();
5871 extern "C" void type_of_call isabeg(Int_t& ifl);
5872 extern "C" void type_of_call isabg2(Int_t& ifl);
5873
5874 void TIsajet::Isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n)
5875 {
5876     isaini(j, k, m, n);
5877 }
5878
5879 void TIsajet::Isaevt(Int_t& j, Int_t& k, Int_t& m)
5880 {
5881     isaevt(j, k, m);
5882 }
5883
5884 void TIsajet::Openfiles()
5885 {
5886     openfiles();
5887 }
5888
5889 void TIsajet::PDFinit()
5890 {
5891     pdfinit(pdfpar, pdfval);
5892 }
5893
5894 void TIsajet::Isabeg(Int_t& ifl)
5895 {
5896     isabeg(ifl);
5897 }
5898
5899 void TIsajet::Isabg2(Int_t& ifl)
5900 {
5901     isabg2(ifl);
5902 }
5903
5904 extern "C" {
5905     Double_t type_of_call ranf(Int_t & /*idum*/)
5906     {
5907         Float_t r;
5908         do r=sRandom->Rndm(); while(0 >= r || r >= 1);
5909         return r;
5910     }
5911 }
5912
5913
5914
5915
5916
5917
5918
5919
5920
5921
5922