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