TIsajet/TIsajet.cxx

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