Changes related to the initialization of random numbers generators. Now one can use...
[u/mrichter/AliRoot.git] / TIsajet / TIsajet.cxx
CommitLineData
7dae8538 1#include "TParticle.h"
2#include "TSystem.h"
3#include "TIsajet.h"
4#include "Icommon.h"
eae0fe66 5#include "Riostream.h"
7dae8538 6#include "math.h"
7#include "TROOT.h"
8#include "TMath.h"
9
10ClassImp(TIsajet)
11
7cdba479 12static TRandom * sRandom;
13
7dae8538 14/**************************************************************************/
15
16TIsajet::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
54TIsajet::~TIsajet()
55{
56 // No housekeeping required at the moment.
57}
58
59/**************************************************************************/
60
61void 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
310void 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
394void 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
422Int_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
521void 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
536void 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
557void TIsajet::GetJobtype() const
558{
559 printf ("Current job type is %s.\n", jobtype);
560}
561
562/**************************************************************************/
563
564void TIsajet::SetOnline(Bool_t val)
565{
566 online = val;
567}
568
569/**************************************************************************/
570
571Bool_t TIsajet::GetOnline() const
572{
573 return online;
574}
575
576/**************************************************************************/
577
578void 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
599void 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
613Float_t TIsajet::GetQMIN() const
614{
615 return DYLIM.qmin;
616}
617
618/**************************************************************************/
619
620void 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
633Float_t TIsajet::GetQMAX() const
634{
635 return DYLIM.qmax;
636}
637
638/**************************************************************************/
639
640void 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
653Float_t TIsajet::GetQTMIN() const
654{
655 return DYLIM.qtmin;
656}
657
658/**************************************************************************/
659
660void 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
674Float_t TIsajet::GetQTMAX() const
675{
676 return DYLIM.qtmax;
677}
678
679/**************************************************************************/
680
681void 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
701Float_t TIsajet::GetYWMIN() const
702{
703 return DYLIM.ywmin;
704}
705
706/**************************************************************************/
707
708void 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
728Float_t TIsajet::GetYWMAX() const
729{
730 return DYLIM.ywmax;
731}
732
733/**************************************************************************/
734
735void 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
745void 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
757Float_t TIsajet::GetXWMIN() const
758{
759 return DYLIM.xwmin;
760}
761
762/**************************************************************************/
763
764void 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
777Float_t TIsajet::GetXWMAX() const
778{
779 return DYLIM.xwmax;
780}
781
782/**************************************************************************/
783
784void 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
804Float_t TIsajet::GetTHWMIN() const
805{
806 return DYLIM.thwmin;
807}
808
809/**************************************************************************/
810
811void 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
831Float_t TIsajet::GetTHWMAX() const
832{
833 return DYLIM.thwmax;
834}
835
836/**************************************************************************/
837
838void TIsajet::SetTHWLIMS()
839{
840 DYLIM.thwmin = 0;
841 DYLIM.thwmax = TMath::Pi();
842 DYLIM.thwset = false;
843}
844
845/**************************************************************************/
846
847void 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
859Float_t TIsajet::GetPHWMIN() const
860{
861 return DYLIM.phwmin;
862}
863
864/**************************************************************************/
865
866void 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
879Float_t TIsajet::GetPHWMAX() const
880{
881 return DYLIM.phwmax;
882}
883
884/**************************************************************************/
885
886Bool_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
905void TIsajet::SetPLEP(Float_t val)
906{
907 EEPAR.plep = val;
908}
909
910/**************************************************************************/
911
912Float_t TIsajet::GetPLEP() const
913{
914 return EEPAR.plep;
915}
916
917/**************************************************************************/
918
919void TIsajet::SetPLEM(Float_t val)
920{
921 EEPAR.plem = val;
922}
923
924/**************************************************************************/
925
926Float_t TIsajet::GetPLEM() const
927{
928 return EEPAR.plem;
929}
930
931/**************************************************************************/
932
933void 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
945Float_t TIsajet::GetRSHMIN() const
946{
947 return EEPAR.rshmin;
948}
949
950/**************************************************************************/
951
952void 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
965Float_t TIsajet::GetRSHMAX() const
966{
967 return EEPAR.rshmax;
968}
969
970/**************************************************************************/
971
972void TIsajet::SetUPSLON(Float_t val)
973{
974 EEPAR.upslon = val;
975}
976
977/**************************************************************************/
978
979Float_t TIsajet::GetUPSLON() const
980{
981 return EEPAR.upslon;
982}
983
984/**************************************************************************/
985
986void TIsajet::SetSIGZ(Float_t val)
987{
988 EEPAR.sigz = val;
989}
990
991/**************************************************************************/
992
993Float_t TIsajet::GetSIGZ() const
994{
995 return EEPAR.sigz;
996}
997
998/**************************************************************************/
999
1000Bool_t TIsajet::GetIBREM() const
1001{
1002 return EEPAR.ibrem;
1003}
1004
1005/**************************************************************************/
1006
1007Bool_t TIsajet::GetIBEAM() const
1008{
1009 return EEPAR.ibeam;
1010}
1011
1012/**************************************************************************/
1013
1014Float_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
1026Int_t TIsajet::GetNFORCE() const
1027{
1028 return FORCE.nforce;
1029}
1030
1031/**************************************************************************/
1032
1033void 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
1080void 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
1116void 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
1137Int_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
1163Int_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
1187void 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
1202void 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
1218Float_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
1232void TIsajet::SetPUD(Float_t val)
1233{
1234 SetFRPAR(val, 0);
1235}
1236
1237/**************************************************************************/
1238
1239Float_t TIsajet::GetPUD() const
1240{
1241 return GetFRPAR(0);
1242}
1243
1244/**************************************************************************/
1245
1246void TIsajet::SetPBARY(Float_t val)
1247{
1248 SetFRPAR(val, 1);
1249}
1250
1251/**************************************************************************/
1252
1253Float_t TIsajet::GetPBARY() const
1254{
1255 return GetFRPAR(1);
1256}
1257
1258/**************************************************************************/
1259
1260void TIsajet::SetSIGQT(Float_t val)
1261{
1262 SetFRPAR(val, 2);
1263}
1264
1265/**************************************************************************/
1266
1267Float_t TIsajet::GetSIGQT() const
1268{
1269 return GetFRPAR(2);
1270}
1271
1272/**************************************************************************/
1273
1274void TIsajet::SetPEND(Float_t val)
1275{
1276 SetFRPAR(val, 3);
1277}
1278
1279/**************************************************************************/
1280
1281Float_t TIsajet::GetPEND() const
1282{
1283 return GetFRPAR(3);
1284}
1285
1286/**************************************************************************/
1287
1288void 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
1302void 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
1318Float_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
1332void 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
1346void 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
1362Float_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
1376void 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
1399void 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
1410void 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
1428Float_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
1450void 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
1473void 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
1484void 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
1502Float_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
1524void 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
1539void 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
1555Float_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
1569void 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
1584void 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
1600Float_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
1614void 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
1628void 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
1644Float_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
1663Float_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
1693Float_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
1716Float_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
1730Float_t TIsajet::GetHMASS() const
1731{
1732 return HCON.hmass;
1733}
1734
1735/**************************************************************************/
1736
1737Float_t TIsajet::GetHGAM() const
1738{
1739 return HCON.hgam;
1740}
1741
1742/**************************************************************************/
1743
1744Float_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
1758Float_t TIsajet::GetETAHGG() const
1759{
1760 return HCON.etahgg;
1761}
1762
1763/**************************************************************************/
1764
1765Int_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
1779Float_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
1802void 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
1815void 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
1834Int_t TIsajet::GetIHTYPE() const
1835{
1836 return HCON.ihtype;
1837}
1838
1839/**************************************************************************/
1840
1841Float_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
1869void 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
1890void 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
1906Float_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
1920void 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
1941void 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
1957Float_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
1971void 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
1994void 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
2010Float_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
2024void 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
2045void 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
2061Float_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
2075void 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
2102void 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
2118Float_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
2132void 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
2159void 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
2175Float_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
2189void 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
2200void 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
2221void 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
2237Float_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
2251void 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
2272void 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
2288Float_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
2302void 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
2322void 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
2338Float_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
2352void 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
2373void 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
2389Float_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
2403void 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
2431void 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
2447Float_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
2461void 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
2488void 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
2504Float_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
2518void 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
2531Bool_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
2550Float_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
2564Float_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
2578Float_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
2592Float_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
2606Float_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
2620Float_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
2634Float_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
2648Float_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
2662Int_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
2676Float_t TIsajet::GetSHAT() const
2677{
2678 return JETPAR.shat;
2679}
2680
2681/**************************************************************************/
2682
2683Float_t TIsajet::GetTHAT() const
2684{
2685 return JETPAR.that;
2686}
2687
2688/**************************************************************************/
2689
2690Float_t TIsajet::GetUHAT() const
2691{
2692 return JETPAR.uhat;
2693}
2694
2695/**************************************************************************/
2696
2697Float_t TIsajet::GetQSQ() const
2698{
2699 return JETPAR.qsq;
2700}
2701
2702/**************************************************************************/
2703
2704Float_t TIsajet::GetX1() const
2705{
2706 return JETPAR.x1;
2707}
2708
2709/**************************************************************************/
2710
2711Float_t TIsajet::GetX2() const
2712{
2713 return JETPAR.x2;
2714}
2715
2716/**************************************************************************/
2717
2718Float_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
2732Float_t TIsajet::GetQMW() const
2733{
2734 return JETPAR.qmw;
2735}
2736
2737/**************************************************************************/
2738
2739Float_t TIsajet::GetQW() const
2740{
2741 return JETPAR.qw;
2742}
2743
2744/**************************************************************************/
2745
2746Float_t TIsajet::GetQTW() const
2747{
2748 return JETPAR.qtw;
2749}
2750
2751/**************************************************************************/
2752
2753Float_t TIsajet::GetYW() const
2754{
2755 return JETPAR.yw;
2756}
2757
2758/**************************************************************************/
2759
2760Float_t TIsajet::GetXW() const
2761{
2762 return JETPAR.xw;
2763}
2764
2765/**************************************************************************/
2766
2767Float_t TIsajet::GetTHW() const
2768{
2769 return JETPAR.thw;
2770}
2771
2772/**************************************************************************/
2773
2774Float_t TIsajet::GetQTMW() const
2775{
2776 return JETPAR.qtmw;
2777}
2778
2779/**************************************************************************/
2780
2781Float_t TIsajet::GetPHIW() const
2782{
2783 return JETPAR.phiw;
2784}
2785
2786/**************************************************************************/
2787
2788Float_t TIsajet::GetSHAT1() const
2789{
2790 return JETPAR.shat1;
2791}
2792
2793/**************************************************************************/
2794
2795Float_t TIsajet::GetTHAT1() const
2796{
2797 return JETPAR.that1;
2798}
2799
2800/**************************************************************************/
2801
2802Float_t TIsajet::GetUHAT1() const
2803{
2804 return JETPAR.uhat1;
2805}
2806
2807/**************************************************************************/
2808
2809void 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
2823void 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
2844Int_t TIsajet::GetJWTYP() const
2845{
2846 return JETPAR.jwtyp;
2847}
2848
2849/**************************************************************************/
2850
2851Float_t TIsajet::GetALFQSQ() const
2852{
2853 return JETPAR.alfqsq;
2854}
2855
2856/**************************************************************************/
2857
2858Float_t TIsajet::GetCTHW() const
2859{
2860 return JETPAR.cthw;
2861}
2862
2863/**************************************************************************/
2864
2865Float_t TIsajet::GetSTHW() const
2866{
2867 return JETPAR.sthw;
2868}
2869
2870/**************************************************************************/
2871
2872Float_t TIsajet::GetQ0W() const
2873{
2874 return JETPAR.q0w;
2875}
2876
2877/**************************************************************************/
2878
2879Int_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
2893Int_t TIsajet::GetISIGS() const
2894{
2895 return JETPAR.isigs;
2896}
2897
2898/**************************************************************************/
2899
2900Float_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
2919void TIsajet::SetNEXTRAD(Int_t val)
2920{
2921 KKGRAV.nextrad = val;
2922}
2923
2924/**************************************************************************/
2925
2926Int_t TIsajet::GetNEXTRAD() const
2927{
2928 return KKGRAV.nextrad;
2929}
2930
2931/**************************************************************************/
2932
2933void TIsajet::SetMASSD(Float_t val)
2934{
2935 KKGRAV.massd = val;
2936}
2937
2938/**************************************************************************/
2939
2940Float_t TIsajet::GetMASSD() const
2941{
2942 return KKGRAV.massd;
2943}
2944
2945/**************************************************************************/
2946
2947Float_t TIsajet::GetKKGSD() const
2948{
2949 return KKGRAV.kkgsd;
2950}
2951
2952/**************************************************************************/
2953
2954Float_t TIsajet::GetSURFD() const
2955{
2956 return KKGRAV.surfd;
2957}
2958
2959/**************************************************************************/
2960
2961void TIsajet::SetUVCUT(Bool_t val)
2962{
2963 KKGRAV.uvcut = val;
2964}
2965
2966/**************************************************************************/
2967
2968Bool_t TIsajet::GetUVCUT() const
2969{
2970 return KKGRAV.uvcut;
2971}
2972
2973/**************************************************************************/
2974
2975// Ends KKGRAV access.
2976// Begins MBGEN access.
2977
2978/**************************************************************************/
2979
2980Float_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
2994Float_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
3008void 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
3021Int_t TIsajet::GetMNPOM() const
3022{
3023 return MBGEN.mnpom;
3024}
3025
3026/**************************************************************************/
3027
3028void 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
3041Int_t TIsajet::GetMXPOM() const
3042{
3043 return MBGEN.mxpom;
3044}
3045
3046/**************************************************************************/
3047
3048Float_t TIsajet::GetPDIFFR() const
3049{
3050 return MBGEN.pdiffr;
3051}
3052
3053/**************************************************************************/
3054
3055Int_t TIsajet::GetNPOM() const
3056{
3057 return MBGEN.npom;
3058}
3059
3060/**************************************************************************/
3061
3062Float_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
3076Float_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
3090Float_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
3118void 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
3131Float_t TIsajet::GetEHMGMN() const
3132{
3133 return MGLIMS.ehmgmn;
3134}
3135
3136/**************************************************************************/
3137
3138void 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
3151Float_t TIsajet::GetEHMGMX() const
3152{
3153 return MGLIMS.ehmgmx;
3154}
3155
3156/**************************************************************************/
3157
3158Float_t TIsajet::GetYHMGMN() const
3159{
3160 return MGLIMS.yhmgmn;
3161}
3162
3163/**************************************************************************/
3164
3165Float_t TIsajet::GetYHMGMX() const
3166{
3167 return MGLIMS.yhmgmx;
3168}
3169
3170/**************************************************************************/
3171
3172void 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
3200void 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
3211void 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
3229Float_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
3251void 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
3279void 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
3290void 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
3308Float_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
3330Bool_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
3358void TIsajet::SetNODCAY(Bool_t val)
3359{
3360 NODCAY.nodcay = val;
3361 setNodcay = true;
3362}
3363
3364/**************************************************************************/
3365
3366Bool_t TIsajet::GetNODCAY() const
3367{
3368 return NODCAY.nodcay;
3369}
3370
3371/**************************************************************************/
3372
3373void TIsajet::SetNOETA(Bool_t val)
3374{
3375 NODCAY.noeta = val;
3376 setNoeta = true;
3377}
3378
3379/**************************************************************************/
3380
3381Bool_t TIsajet::GetNOETA() const
3382{
3383 return NODCAY.noeta;
3384}
3385
3386/**************************************************************************/
3387
3388void TIsajet::SetNOPI0(Bool_t val)
3389{
3390 NODCAY.nopi0 = val;
3391 setNopi0 = true;
3392}
3393
3394/**************************************************************************/
3395
3396Bool_t TIsajet::GetNOPI0() const
3397{
3398 return NODCAY.nopi0;
3399}
3400
3401/**************************************************************************/
3402
3403void TIsajet::SetNONUNU(Bool_t val)
3404{
3405 NODCAY.nonunu = val;
3406}
3407
3408/**************************************************************************/
3409
3410Bool_t TIsajet::GetNONUNU() const
3411{
3412 return NODCAY.nonunu;
3413}
3414
3415/**************************************************************************/
3416
3417void TIsajet::SetNOEVOL(Bool_t val)
3418{
3419 NODCAY.noevol = val;
3420 setNoevolve = true;
3421}
3422
3423/**************************************************************************/
3424
3425Bool_t TIsajet::GetNOEVOL() const
3426{
3427 return NODCAY.noevol;
3428}
3429
3430/**************************************************************************/
3431
3432void TIsajet::SetNOHADR(Bool_t val)
3433{
3434 NODCAY.nohadr = val;
3435 setNohadron = true;
3436}
3437
3438/**************************************************************************/
3439
3440Bool_t TIsajet::GetNOHADR() const
3441{
3442 return NODCAY.nohadr;
3443}
3444
3445/**************************************************************************/
3446
3447void TIsajet::SetNOGRAV(Bool_t val)
3448{
3449 NODCAY.nograv = val;
3450}
3451
3452/**************************************************************************/
3453
3454Bool_t TIsajet::GetNOGRAV() const
3455{
3456 return NODCAY.nograv;
3457}
3458
3459/**************************************************************************/
3460
3461// Ends NODCAY access.
3462// Begins PARTCL access.
3463
3464/**************************************************************************/
3465
3466Int_t TIsajet::GetNPTCL() const
3467{
3468 return PARTCL.nptcl;
3469}
3470
3471/**************************************************************************/
3472
3473Float_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
3486Float_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
3499Float_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
3512Float_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
3525Float_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
3538Float_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
3551Float_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
3564Float_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
3582Int_t TIsajet::GetNJET() const
3583{
3584 return PRIMAR.njet;
3585}
3586
3587/**************************************************************************/
3588
3589Float_t TIsajet::GetSCM() const
3590{
3591 return PRIMAR.scm;
3592}
3593
3594/**************************************************************************/
3595
3596Float_t TIsajet::GetHALFE() const
3597{
3598 return PRIMAR.halfe;
3599}
3600
3601/**************************************************************************/
3602
3603void 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
3618Float_t TIsajet::GetECM() const
3619{
3620 return PRIMAR.ecm;
3621}
3622
3623/**************************************************************************/
3624
3625void 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
3648void 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
3678Int_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
3692Int_t TIsajet::GetNEVENT() const
3693{
3694 return PRIMAR.nevent;
3695}
3696
3697/**************************************************************************/
3698
3699void TIsajet::SetNTRIES(Int_t val)
3700{
3701 PRIMAR.ntries = val;
3702}
3703
3704/**************************************************************************/
3705
3706Int_t TIsajet::GetNTRIES() const
3707{
3708 return PRIMAR.ntries;
3709}
3710
3711/**************************************************************************/
3712
3713void TIsajet::SetNSIGMA(Int_t val)
3714{
3715 PRIMAR.nsigma = val;
3716 setNsigma = true;
3717}
3718
3719/**************************************************************************/
3720
3721Int_t TIsajet::GetNSIGMA() const
3722{
3723 return PRIMAR.nsigma;
3724}
3725
3726/**************************************************************************/
3727
3728// Ends PRIMAR access.
3729// Begins QCDPAR access.
3730
3731/**************************************************************************/
3732
3733void TIsajet::SetALAM(Float_t val)
3734{
3735 QCDPAR.alam = val;
3736 QCDPAR.alam2 = val*val;
3737 setLambda = true;
3738}
3739
3740/**************************************************************************/
3741
3742Float_t TIsajet::GetALAM() const
3743{
3744 return QCDPAR.alam;
3745}
3746
3747/**************************************************************************/
3748
3749Float_t TIsajet::GetALAM2() const
3750{
3751 return QCDPAR.alam2;
3752}
3753
3754/**************************************************************************/
3755
3756void TIsajet::SetCUTJET(Float_t val)
3757{
3758 QCDPAR.cutjet = val;
3759 setCutjet = true;
3760}
3761
3762/**************************************************************************/
3763
3764Float_t TIsajet::GetCUTJET() const
3765{
3766 return QCDPAR.cutjet;
3767}
3768
3769/**************************************************************************/
3770
3771void TIsajet::SetISTRUC(Int_t val)
3772{
3773 if ((val < 1) || (val > 6)) {
3774 printf ("Error in TIsajet::SetISTRUC : \n");
3775 printf ("Invalid input value %d. Possible values are 1 through 6.\n", val);
3776 return;
3777 }
3778 QCDPAR.istruc = val;
3779}
3780
3781/**************************************************************************/
3782
3783void TIsajet::SetISTRUC(const Char_t val[])
3784{
3785 if (!strcmp("OWENS", val)) {
3786 QCDPAR.istruc = 1;
3787 }
3788 else if (!strcmp("BAIER", val)) {
3789 QCDPAR.istruc = 2;
3790 }
3791 else if ((!strcmp("EICHTEN", val)) || (!strcmp("EHLQ", val))) {
3792 QCDPAR.istruc = 3;
3793 }
3794 else if ((!strcmp("DUKE", val)) || (!strcmp("DO", val))) {
3795 QCDPAR.istruc = 4;
3796 }
3797 else if (!strcmp("CTEQ2L", val)) {
3798 QCDPAR.istruc = 5;
3799 }
3800 else if ((!strcmp("CTEQ", val)) || (!strcmp("CTEQ3L", val))) {
3801 QCDPAR.istruc = 6;
3802 }
3803 else {
3804 printf ("Error in TIsajet::SetISTRUC : \n");
3805 printf ("Invalid input string %s. Possible strings are OWENS, BAIER, EICHTEN, \n", val);
3806 printf ("EHLQ, DUKE, DO, CTEQ2L, CTEQ, and CTEQ3L.\n");
3807 return;
3808 }
3809}
3810
3811/**************************************************************************/
3812
3813Int_t TIsajet::GetISTRUC() const
3814{
3815 return QCDPAR.istruc;
3816}
3817
3818/**************************************************************************/
3819
3820// Ends QCDPAR access.
3821// Begins QLMASS access.
3822
3823/**************************************************************************/
3824
3825void TIsajet::SetAMLEP(Float_t val, Int_t index)
3826{
3827 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3828 if ((index < 0) || (index >= length)) {
3829 printf ("Error in TIsajet::SetAMLEP : \n");
3830 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3831 return;
3832 }
3833
3834 if (((index < 5) && (index > 7)) &&
3835 ((index < 21) && (index > 26)) &&
3836 ((index < 29) && (index > 36)) &&
3837 ((index < 39) && (index > 40)) &&
3838 ((index < 63) && (index > 71)))
3839 {
3840 printf ("Error in TIsajet::SetAMLEP : \n");
3841 printf ("Index %d may not be set by the user. Valid indices are : \n", index);
3842 printf ("5-7, 21-26, 29-36, 39-40 and 63-71.\n");
3843 return;
3844 }
3845
3846 QLMASS.amlep[index] = val;
3847}
3848
3849/**************************************************************************/
3850
3851Float_t TIsajet::GetAMLEP(Int_t index) const
3852{
3853 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3854 if ((index < 0) || (index >= length)) {
3855 printf ("Error in TIsajet::GetAMLEP : \n");
3856 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3857 return 0;
3858 }
3859 if ((index < 5) || (index > 71) ||
3860 ((index > 7) && (index < 21)) ||
3861 ((index > 26) && (index < 29)) ||
3862 ((index > 36) && (index < 39)) ||
3863 ((index > 40) && (index < 63)))
3864 {
3865 printf ("Possible error in TIsajet::GetAMLEP : \n");
3866 printf ("Index %d may not be set by the user. Valid indices are : \n", index);
3867 printf ("5-7, 21-26, 29-36, 39-40 and 63-71. \n");
3868 printf ("To return the value of this index, use GetAnyAMLEP(Int_t index).\n");
3869 return 0;
3870 }
3871
3872
3873 return QLMASS.amlep[index];
3874}
3875
3876/**************************************************************************/
3877
3878Float_t TIsajet::GetAnyAMLEP(Int_t index) const
3879{
3880 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3881 if ((index < 0) || (index >= length)) {
3882 printf ("Error in TIsajet::GetAnyAMLEP : \n");
3883 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3884 return 0;
3885 }
3886
3887 return QLMASS.amlep[index];
3888}
3889
3890/**************************************************************************/
3891
3892void TIsajet::SetTquarkMass(Float_t val)
3893{
3894 QLMASS.amlep[5] = val;
3895}
3896
3897/**************************************************************************/
3898
3899Float_t TIsajet::GetTquarkMass() const
3900{
3901 return QLMASS.amlep[5];
3902}
3903
3904/**************************************************************************/
3905
3906void TIsajet::SetXquarkMass(Float_t val)
3907{
3908 QLMASS.amlep[6] = val;
3909}
3910
3911/**************************************************************************/
3912
3913Float_t TIsajet::GetXquarkMass() const
3914{
3915 return QLMASS.amlep[6];
3916}
3917
3918/**************************************************************************/
3919
3920void TIsajet::SetYquarkMass(Float_t val)
3921{
3922 QLMASS.amlep[7] = val;
3923}
3924
3925/**************************************************************************/
3926
3927Float_t TIsajet::GetYquarkMass() const
3928{
3929 return QLMASS.amlep[7];
3930}
3931
3932/**************************************************************************/
3933
3934void TIsajet::SetUtildeMass(Float_t val)
3935{
3936 QLMASS.amlep[21] = val;
3937}
3938
3939/**************************************************************************/
3940
3941Float_t TIsajet::GetUtildeMass() const
3942{
3943 return QLMASS.amlep[21];
3944}
3945
3946/**************************************************************************/
3947
3948void TIsajet::SetDtildeMass(Float_t val)
3949{
3950 QLMASS.amlep[22] = val;
3951}
3952
3953/**************************************************************************/
3954
3955Float_t TIsajet::GetDtildeMass() const
3956{
3957 return QLMASS.amlep[22];
3958}
3959