TIsajet/TIsajet.cxx

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