]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TIsajet/TIsajet.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Updated PaintContour() method
[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) {
ff118c7c 303// PDFinit();
7dae8538 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
ff118c7c 1033void TIsajet::SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti)
7dae8538 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) {
ff118c7c 1070 Int_t* antivals = new Int_t[arraySize];
7dae8538 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
ff118c7c 1080void TIsajet::UnForce(Int_t index, Bool_t anti)
7dae8538 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
ff118c7c 1116void TIsajet::UnForceID(Int_t particle_ID, Bool_t anti)
7dae8538 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
ff118c7c 1151 Int_t* decay = new Int_t[6];
7dae8538 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
3960/**************************************************************************/
3961
3962void TIsajet::SetStildeMass(Float_t val)
3963{
3964 QLMASS.amlep[23] = val;
3965}
3966
3967/**************************************************************************/
3968
3969Float_t TIsajet::GetStildeMass() const
3970{
3971 return QLMASS.amlep[23];
3972}
3973
3974/**************************************************************************/
3975
3976void TIsajet::SetCtildeMass(Float_t val)
3977{
3978 QLMASS.amlep[24] = val;
3979}
3980
3981/**************************************************************************/
3982
3983Float_t TIsajet::GetCtildeMass() const
3984{
3985 return QLMASS.amlep[24];
3986}
3987
3988/**************************************************************************/
3989
3990void TIsajet::SetBtildeMass(Float_t val)
3991{
3992 QLMASS.amlep[25] = val;
3993}
3994
3995/**************************************************************************/
3996
3997Float_t TIsajet::GetBtildeMass() const
3998{
3999 return QLMASS.amlep[25];
4000}
4001
4002/**************************************************************************/
4003
4004void TIsajet::SetTtildeMass(Float_t val)
4005{
4006 QLMASS.amlep[26] = val;
4007}
4008
4009/**************************************************************************/
4010
4011Float_t TIsajet::GetTtildeMass() const
4012{
4013 return QLMASS.amlep[26];
4014}
4015
4016/**************************************************************************/
4017
4018void TIsajet::SetGtildeMass(Float_t val)
4019{
4020 QLMASS.amlep[29] = val;
4021}
4022
4023/**************************************************************************/
4024
4025Float_t TIsajet::GetGtildeMass() const
4026{
4027 return QLMASS.amlep[29];
4028}
4029
4030/**************************************************************************/
4031
4032void TIsajet::SetGammatildeMass(Float_t val)
4033{
4034 QLMASS.amlep[30] = val;
4035}
4036
4037/**************************************************************************/
4038
4039Float_t TIsajet::GetGammatildeMass() const
4040{
4041 return QLMASS.amlep[30];
4042}
4043
4044/**************************************************************************/
4045
4046void TIsajet::SetNuEtildeMass(Float_t val)
4047{
4048 QLMASS.amlep[31] = val;
4049}
4050
4051/**************************************************************************/
4052
4053Float_t TIsajet::GetNuEtildeMass() const
4054{
4055 return QLMASS.amlep[31];
4056}
4057
4058/**************************************************************************/
4059
4060void TIsajet::SetEtildeMass(Float_t val)
4061{
4062 QLMASS.amlep[32] = val;
4063}
4064
4065/**************************************************************************/
4066
4067Float_t TIsajet::GetEtildeMass() const
4068{
4069 return QLMASS.amlep[32];
4070}
4071
4072/**************************************************************************/
4073
4074void TIsajet::SetNuMutildeMass(Float_t val)
4075{
4076 QLMASS.amlep[33] = val;
4077}
4078
4079/**************************************************************************/
4080
4081Float_t TIsajet::GetNuMutildeMass() const
4082{
4083 return QLMASS.amlep[33];
4084}
4085
4086/**************************************************************************/
4087
4088void TIsajet::SetMutildeMass(Float_t val)
4089{
4090 QLMASS.amlep[34] = val;
4091}
4092
4093/**************************************************************************/
4094
4095Float_t TIsajet::GetMutildeMass() const
4096{
4097 return QLMASS.amlep[34];
4098}
4099
4100/**************************************************************************/
4101
4102void TIsajet::SetNuTautildeMass(Float_t val)
4103{
4104 QLMASS.amlep[35] = val;
4105}
4106
4107/**************************************************************************/
4108
4109Float_t TIsajet::GetNuTautildeMass() const
4110{
4111 return QLMASS.amlep[35];
4112}
4113
4114/**************************************************************************/
4115
4116void TIsajet::SetTautildeMass(Float_t val)
4117{
4118 QLMASS.amlep[36] = val;
4119}
4120
4121/**************************************************************************/
4122
4123Float_t TIsajet::GetTautildeMass() const
4124{
4125 return QLMASS.amlep[36];
4126}
4127
4128/**************************************************************************/
4129
4130void TIsajet::SetWplustildeMass(Float_t val)
4131{
4132 QLMASS.amlep[39] = val;
4133}
4134
4135/**************************************************************************/
4136
4137Float_t TIsajet::GetWplustildeMass() const
4138{
4139 return QLMASS.amlep[39];
4140}
4141
4142/**************************************************************************/
4143
4144void TIsajet::SetZ0tildeMass(Float_t val)
4145{
4146 QLMASS.amlep[40] = val;
4147}
4148
4149/**************************************************************************/
4150
4151Float_t TIsajet::GetZ0tildeMass() const
4152{
4153 return QLMASS.amlep[40];
4154}
4155
4156/**************************************************************************/
4157
4158void TIsajet::SetHiggsMesonMass(Float_t val, Int_t index)
4159{
4160 if ((index < 1) || (index > 9)) {
4161 printf ("Error in TIsajet::SetHiggsMesonMass : \n");
4162 printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
4163 return;
4164 }
4165
4166 QLMASS.amlep[62 + index] = val;
4167}
4168
4169/**************************************************************************/
4170
4171Float_t TIsajet::GetHiggsMesonMass(Int_t index) const
4172{
4173 if ((index < 1) || (index > 9)) {
4174 printf ("Error in TIsajet::GetHiggsMesonMass : \n");
4175 printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
4176 return 0;
4177 }
4178
4179 return QLMASS.amlep[62 + index];
4180}
4181
4182/**************************************************************************/
4183
4184Int_t TIsajet::GetNQLEP() const
4185{
4186 return QLMASS.nqlep;
4187}
4188
4189/**************************************************************************/
4190
4191Int_t TIsajet::GetNMES() const
4192{
4193 return QLMASS.nmes;
4194}
4195
4196/**************************************************************************/
4197
4198Int_t TIsajet::GetNBARY() const
4199{
4200 return QLMASS.nbary;
4201}
4202
4203/**************************************************************************/
4204
4205// Ends QLMASS access.
4206// Begins SEED access.
4207
4208/**************************************************************************/
4209
4210void TIsajet::SetSEED(const Char_t val[24])
4211{
4212 Int_t length = (sizeof SEED.xseed / sizeof SEED.xseed[0]);
4213
4214 for (Int_t i = 0; i < length; i++) {
4215 SEED.xseed[i] = val[i];
4216 }
4217}
4218
4219/**************************************************************************/
4220
4221Char_t* TIsajet::GetSEED() const
4222{
4223 return SEED.xseed;
4224}
4225
4226/**************************************************************************/
4227
4228// Ends SEED access - short and sweet, wasn't it?
4229// Begins SUGNU access, an entirely different business.
4230
4231/**************************************************************************/
4232
4233void TIsajet::SetXNUSUG(Float_t val, Int_t index)
4234{
4235 Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
4236 if ((index < 0) || (index >= length)) {
4237 printf ("Error in TIsajet::SetXNUSUG : \n");
4238 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4239 return;
4240 }
4241
4242 SUGNU.xnusug[index] = val;
4243}
4244
4245/**************************************************************************/
4246
4247Float_t TIsajet::GetXNUSUG(Int_t index) const
4248{
4249 Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
4250 if ((index < 0) || (index >= length)) {
4251 printf ("Error in TIsajet::GetXNUSUG : \n");
4252 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4253 return 0;
4254 }
4255
4256 return SUGNU.xnusug[index];
4257}
4258
4259/**************************************************************************/
4260
4261void TIsajet::SetGauginoMass(Float_t val, Int_t index)
4262{
4263 if ((index < 1) || (index > 9)) {
4264 printf ("Error in TIsajet::SetGauginoMass : \n");
4265 printf ("Invalid gaugino number %d; range is 1-3.\n", index);
4266 return;
4267 }
4268
4269 SUGNU.xnusug[index-1] = val;
4270}
4271
4272/**************************************************************************/
4273
4274Float_t TIsajet::GetGauginoMass(Int_t index) const
4275{
4276 if ((index < 1) || (index > 3)) {
4277 printf ("Error in TIsajet::GetGauginoMass : \n");
4278 printf ("Invalid gaugino number %d; range is 1-3.\n", index);
4279 return 0;
4280 }
4281
4282 return SUGNU.xnusug[index-1];
4283}
4284
4285/**************************************************************************/
4286
4287void TIsajet::SetAtau(Float_t val)
4288{
4289 SUGNU.xnusug[3] = val;
4290}
4291
4292/**************************************************************************/
4293
4294Float_t TIsajet::GetAtau() const
4295{
4296 return SUGNU.xnusug[3];
4297}
4298
4299/**************************************************************************/
4300
4301void TIsajet::SetAb(Float_t val)
4302{
4303 SUGNU.xnusug[4] = val;
4304}
4305
4306/**************************************************************************/
4307
4308Float_t TIsajet::GetAb() const
4309{
4310 return SUGNU.xnusug[4];
4311}
4312
4313/**************************************************************************/
4314
4315void TIsajet::SetAt(Float_t val)
4316{
4317 SUGNU.xnusug[5] = val;
4318}
4319
4320/**************************************************************************/
4321
4322Float_t TIsajet::GetAt() const
4323{
4324 return SUGNU.xnusug[5];
4325}
4326
4327/**************************************************************************/
4328
4329void TIsajet::SetHiggsDmass(Float_t val)
4330{
4331 SUGNU.xnusug[6] = val;
4332}
4333
4334/**************************************************************************/
4335
4336Float_t TIsajet::GetHiggsDmass() const
4337{
4338 return SUGNU.xnusug[6];
4339}
4340
4341/**************************************************************************/
4342
4343void TIsajet::SetHiggsUmass(Float_t val)
4344{
4345 SUGNU.xnusug[7] = val;
4346}
4347
4348/**************************************************************************/
4349
4350Float_t TIsajet::GetHiggsUmass() const
4351{
4352 return SUGNU.xnusug[7];
4353}
4354
4355/**************************************************************************/
4356
4357void TIsajet::SetERmass(Float_t val)
4358{
4359 SUGNU.xnusug[8] = val;
4360}
4361
4362/**************************************************************************/
4363
4364Float_t TIsajet::GetERmass() const
4365{
4366 return SUGNU.xnusug[8];
4367}
4368
4369/**************************************************************************/
4370
4371void TIsajet::SetELmass(Float_t val)
4372{
4373 SUGNU.xnusug[9] = val;
4374}
4375
4376/**************************************************************************/
4377
4378Float_t TIsajet::GetELmass() const
4379{
4380 return SUGNU.xnusug[9];
4381}
4382
4383/**************************************************************************/
4384
4385void TIsajet::SetDRmass(Float_t val)
4386{
4387 SUGNU.xnusug[10] = val;
4388}
4389
4390/**************************************************************************/
4391
4392Float_t TIsajet::GetDRmass() const
4393{
4394 return SUGNU.xnusug[10];
4395}
4396
4397/**************************************************************************/
4398
4399void TIsajet::SetURmass(Float_t val)
4400{
4401 SUGNU.xnusug[11] = val;
4402}
4403
4404/**************************************************************************/
4405
4406Float_t TIsajet::GetURmass() const
4407{
4408 return SUGNU.xnusug[11];
4409}
4410
4411/**************************************************************************/
4412
4413void TIsajet::SetULmass(Float_t val)
4414{
4415 SUGNU.xnusug[12] = val;
4416}
4417
4418/**************************************************************************/
4419
4420Float_t TIsajet::GetULmass() const
4421{
4422 return SUGNU.xnusug[12];
4423}
4424
4425/**************************************************************************/
4426
4427void TIsajet::SetTauRmass(Float_t val)
4428{
4429 SUGNU.xnusug[13] = val;
4430}
4431
4432/**************************************************************************/
4433
4434Float_t TIsajet::GetTauRmass() const
4435{
4436 return SUGNU.xnusug[13];
4437}
4438
4439/**************************************************************************/
4440
4441void TIsajet::SetTauLmass(Float_t val)
4442{
4443 SUGNU.xnusug[14] = val;
4444}
4445
4446/**************************************************************************/
4447
4448Float_t TIsajet::GetTauLmass() const
4449{
4450 return SUGNU.xnusug[14];
4451}
4452
4453/**************************************************************************/
4454
4455void TIsajet::SetBRmass(Float_t val)
4456{
4457 SUGNU.xnusug[15] = val;
4458}
4459
4460/**************************************************************************/
4461
4462Float_t TIsajet::GetBRmass() const
4463{
4464 return SUGNU.xnusug[15];
4465}
4466
4467/**************************************************************************/
4468
4469void TIsajet::SetTRmass(Float_t val)
4470{
4471 SUGNU.xnusug[16] = val;
4472}
4473
4474/**************************************************************************/
4475
4476Float_t TIsajet::GetTRmass() const
4477{
4478 return SUGNU.xnusug[16];
4479}
4480
4481/**************************************************************************/
4482
4483void TIsajet::SetTLmass(Float_t val)
4484{
4485 SUGNU.xnusug[17] = val;
4486}
4487
4488/**************************************************************************/
4489
4490Float_t TIsajet::GetTLmass() const
4491{
4492 return SUGNU.xnusug[17];
4493}
4494
4495/**************************************************************************/
4496
4497// Ends XNUSUG access.
4498// Begins TCPAR access.
4499
4500/**************************************************************************/
4501
4502void TIsajet::SetTCMRHO(Float_t val)
4503{
4504 TCPAR.tcmrho = val;
4505}
4506
4507/**************************************************************************/
4508
4509Float_t TIsajet::GetTCMRHO() const
4510{
4511 return TCPAR.tcmrho;
4512}
4513
4514/**************************************************************************/
4515
4516void TIsajet::SetTCGRHO(Float_t val)
4517{
4518 TCPAR.tcgrho = val;
4519}
4520
4521/**************************************************************************/
4522
4523Float_t TIsajet::GetTCGRHO() const
4524{
4525 return TCPAR.tcgrho;
4526}
4527
4528/**************************************************************************/
4529
4530// Ends TCPAR access.
4531// Begins TYPES access.
4532
4533/**************************************************************************/
4534
4535Int_t TIsajet::GetLOC(Int_t index) const
4536{
4537 Int_t length = (sizeof TYPES.loc / sizeof TYPES.loc[0]);
4538 if ((index < 0) || (index >= length)) {
4539 printf ("Error in TIsajet::GetLOC : \n");
4540 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4541 return 0;
4542 }
4543
4544 return TYPES.loc[index];
4545}
4546
4547/**************************************************************************/
4548
4549Int_t TIsajet::GetNTYP() const
4550{
4551 return TYPES.ntyp;
4552}
4553
4554/**************************************************************************/
4555
4556Int_t TIsajet::GetNJTTYP(Int_t index) const
4557{
4558 Int_t length = (sizeof TYPES.njttyp / sizeof TYPES.njttyp[0]);
4559 if ((index < 0) || (index >= length)) {
4560 printf ("Error in TIsajet::GetNJTYP : \n");
4561 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4562 return 0;
4563 }
4564
4565 return TYPES.njttyp[index];
4566}
4567
4568/**************************************************************************/
4569
4570Int_t TIsajet::GetNWWTYP(Int_t index) const
4571{
4572 Int_t length = (sizeof TYPES.nwwtyp / sizeof TYPES.nwwtyp[0]);
4573 if ((index < 0) || (index >= length)) {
4574 printf ("Error in TIsajet::GetNWWTYP : \n");
4575 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4576 return 0;
4577 }
4578
4579 return TYPES.nwwtyp[index];
4580}
4581
4582/**************************************************************************/
4583
4584Int_t TIsajet::GetNWMODE(Int_t index) const
4585{
4586 Int_t length = (sizeof TYPES.nwmode / sizeof TYPES.nwmode[0]);
4587 if ((index < 0) || (index >= length)) {
4588 printf ("Error in TIsajet::GetNWMODE : \n");
4589 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4590 return 0;
4591 }
4592
4593 return TYPES.nwmode[index];
4594}
4595
4596/**************************************************************************/
4597
4598// Ends TYPES access.
4599// Begins XMSSM access.
4600
4601/**************************************************************************/
4602
4603Bool_t TIsajet::GetGOMSSM() const
4604{
4605 return XMSSM.gomssm;
4606}
4607
4608/**************************************************************************/
4609
4610Bool_t TIsajet::GetGOSUG() const
4611{
4612 return XMSSM.gosug;
4613}
4614
4615/**************************************************************************/
4616
4617Bool_t TIsajet::GetGOGMSB() const
4618{
4619 return XMSSM.gogmsb;
4620}
4621
4622/**************************************************************************/
4623
4624Bool_t TIsajet::GetGOAMSB() const
4625{
4626 return XMSSM.goamsb;
4627}
4628
4629/**************************************************************************/
4630
4631Bool_t TIsajet::GetAL3UNI() const
4632{
4633 return XMSSM.al3uni;
4634}
4635
4636/**************************************************************************/
4637
4638void TIsajet::SetXGLSS(Float_t val)
4639{
4640 XMSSM.xglss = val;
4641}
4642
4643/**************************************************************************/
4644
4645Float_t TIsajet::GetXGLSS() const
4646{
4647 return XMSSM.xglss;
4648}
4649
4650/**************************************************************************/
4651
4652void TIsajet::SetXMUSS(Float_t val)
4653{
4654 XMSSM.xmuss = val;
4655}
4656
4657/**************************************************************************/
4658
4659Float_t TIsajet::GetXMUSS() const
4660{
4661 return XMSSM.xmuss;
4662}
4663
4664/**************************************************************************/
4665
4666void TIsajet::SetXHASS(Float_t val)
4667{
4668 XMSSM.xhass = val;
4669}
4670
4671/**************************************************************************/
4672
4673Float_t TIsajet::GetXHASS() const
4674{
4675 return XMSSM.xhass;
4676}
4677
4678/**************************************************************************/
4679
4680void TIsajet::SetXTBSS(Float_t val)
4681{
4682 XMSSM.xtbss = val;
4683}
4684
4685/**************************************************************************/
4686
4687Float_t TIsajet::GetXTBSS() const
4688{
4689 return XMSSM.xtbss;
4690}
4691
4692/**************************************************************************/
4693
4694void TIsajet::SetXQ1SS(Float_t val)
4695{
4696 XMSSM.xq1ss = val;
4697}
4698
4699/**************************************************************************/
4700
4701Float_t TIsajet::GetXQ1SS() const
4702{
4703 return XMSSM.xq1ss;
4704}
4705
4706/**************************************************************************/
4707
4708void TIsajet::SetXDRSS(Float_t val)
4709{
4710 XMSSM.xdrss = val;
4711}
4712
4713/**************************************************************************/
4714
4715Float_t TIsajet::GetXDRSS() const
4716{
4717 return XMSSM.xdrss;
4718}
4719
4720/**************************************************************************/
4721
4722void TIsajet::SetXURSS(Float_t val)
4723{
4724 XMSSM.xurss = val;
4725}
4726
4727/**************************************************************************/
4728
4729Float_t TIsajet::GetXURSS() const
4730{
4731 return XMSSM.xurss;
4732}
4733
4734/**************************************************************************/
4735
4736void TIsajet::SetXL1SS(Float_t val)
4737{
4738 XMSSM.xl1ss = val;
4739}
4740
4741/**************************************************************************/
4742
4743Float_t TIsajet::GetXL1SS() const
4744{
4745 return XMSSM.xl1ss;
4746}
4747
4748/**************************************************************************/
4749
4750void TIsajet::SetXERSS(Float_t val)
4751{
4752 XMSSM.xerss = val;
4753}
4754
4755/**************************************************************************/
4756
4757Float_t TIsajet::GetXERSS() const
4758{
4759 return XMSSM.xerss;
4760}
4761
4762/**************************************************************************/
4763
4764void TIsajet::SetXQ2SS(Float_t val)
4765{
4766 XMSSM.xq2ss = val;
4767}
4768
4769/**************************************************************************/
4770
4771Float_t TIsajet::GetXQ2SS() const
4772{
4773 return XMSSM.xq2ss;
4774}
4775
4776/**************************************************************************/
4777
4778void TIsajet::SetXSRSS(Float_t val)
4779{
4780 XMSSM.xsrss = val;
4781}
4782
4783/**************************************************************************/
4784
4785Float_t TIsajet::GetXSRSS() const
4786{
4787 return XMSSM.xsrss;
4788}
4789
4790/**************************************************************************/
4791
4792void TIsajet::SetXCRSS(Float_t val)
4793{
4794 XMSSM.xcrss = val;
4795}
4796
4797/**************************************************************************/
4798
4799Float_t TIsajet::GetXCRSS() const
4800{
4801 return XMSSM.xcrss;
4802}
4803
4804/**************************************************************************/
4805
4806void TIsajet::SetXL2SS(Float_t val)
4807{
4808 XMSSM.xl2ss = val;
4809}
4810
4811/**************************************************************************/
4812
4813Float_t TIsajet::GetXL2SS() const
4814{
4815 return XMSSM.xl2ss;
4816}
4817
4818/**************************************************************************/
4819
4820void TIsajet::SetXMRSS(Float_t val)
4821{
4822 XMSSM.xmrss = val;
4823}
4824
4825/**************************************************************************/
4826
4827Float_t TIsajet::GetXMRSS() const
4828{
4829 return XMSSM.xmrss;
4830}
4831
4832/**************************************************************************/
4833
4834void TIsajet::SetXQ3SS(Float_t val)
4835{
4836 XMSSM.xq3ss = val;
4837}
4838
4839/**************************************************************************/
4840
4841Float_t TIsajet::GetXQ3SS() const
4842{
4843 return XMSSM.xq3ss;
4844}
4845
4846/**************************************************************************/
4847
4848void TIsajet::SetXBRSS(Float_t val)
4849{
4850 XMSSM.xbrss = val;
4851}
4852
4853/**************************************************************************/
4854
4855Float_t TIsajet::GetXBRSS() const
4856{
4857 return XMSSM.xbrss;
4858}
4859
4860/**************************************************************************/
4861
4862void TIsajet::SetXTRSS(Float_t val)
4863{
4864 XMSSM.xtrss = val;
4865}
4866
4867/**************************************************************************/
4868
4869Float_t TIsajet::GetXTRSS() const
4870{
4871 return XMSSM.xtrss;
4872}
4873
4874/**************************************************************************/
4875
4876void TIsajet::SetXL3SS(Float_t val)
4877{
4878 XMSSM.xl3ss = val;
4879}
4880
4881/**************************************************************************/
4882
4883Float_t TIsajet::GetXL3SS() const
4884{
4885 return XMSSM.xl3ss;
4886}
4887
4888/**************************************************************************/
4889
4890void TIsajet::SetXTARSS(Float_t val)
4891{
4892 XMSSM.xtarss = val;
4893}
4894
4895/**************************************************************************/
4896
4897Float_t TIsajet::GetXTARSS() const
4898{
4899 return XMSSM.xtarss;
4900}
4901
4902/**************************************************************************/
4903
4904void TIsajet::SetXATSS(Float_t val)
4905{
4906 XMSSM.xatss = val;
4907}
4908
4909/**************************************************************************/
4910
4911Float_t TIsajet::GetXATSS() const
4912{
4913 return XMSSM.xatss;
4914}
4915
4916/**************************************************************************/
4917
4918void TIsajet::SetXABSS(Float_t val)
4919{
4920 XMSSM.xabss = val;
4921}
4922
4923/**************************************************************************/
4924
4925Float_t TIsajet::GetXABSS() const
4926{
4927 return XMSSM.xabss;
4928}
4929
4930/**************************************************************************/
4931
4932void TIsajet::SetXATASS(Float_t val)
4933{
4934 XMSSM.xatass = val;
4935}
4936
4937/**************************************************************************/
4938
4939Float_t TIsajet::GetXATASS() const
4940{
4941 return XMSSM.xatass;
4942}
4943
4944/**************************************************************************/
4945
4946void TIsajet::SetXM1SS(Float_t val)
4947{
4948 XMSSM.xm1ss = val;
4949}
4950
4951/**************************************************************************/
4952
4953Float_t TIsajet::GetXM1SS() const
4954{
4955 return XMSSM.xm1ss;
4956}
4957
4958/**************************************************************************/
4959
4960void TIsajet::SetXM2SS(Float_t val)
4961{
4962 XMSSM.xm2ss = val;
4963}
4964
4965/**************************************************************************/
4966
4967Float_t TIsajet::GetXM2SS() const
4968{
4969 return XMSSM.xm2ss;
4970}
4971
4972/**************************************************************************/
4973
4974void TIsajet::SetXM0SU(Float_t val)
4975{
4976 XMSSM.xm0su = val;
4977}
4978
4979/**************************************************************************/
4980
4981Float_t TIsajet::GetXM0SU() const
4982{
4983 return XMSSM.xm0su;
4984}
4985
4986/**************************************************************************/
4987
4988void TIsajet::SetXMHSU(Float_t val)
4989{
4990 XMSSM.xmhsu = val;
4991}
4992
4993/**************************************************************************/
4994
4995Float_t TIsajet::GetXMHSU() const
4996{
4997 return XMSSM.xmhsu;
4998}
4999
5000/**************************************************************************/
5001
5002void TIsajet::SetXA0SU(Float_t val)
5003{
5004 XMSSM.xa0su = val;
5005}
5006
5007/**************************************************************************/
5008
5009Float_t TIsajet::GetXA0SU() const
5010{
5011 return XMSSM.xa0su;
5012}
5013
5014/**************************************************************************/
5015
5016void TIsajet::SetXTGBSU(Float_t val)
5017{
5018 XMSSM.xtgbsu = val;
5019}
5020
5021/**************************************************************************/
5022
5023Float_t TIsajet::GetXTGBSU() const
5024{
5025 return XMSSM.xtgbsu;
5026}
5027
5028/**************************************************************************/
5029
5030void TIsajet::SetXSMUSU(Float_t val)
5031{
5032 XMSSM.xsmusu = val;
5033}
5034
5035/**************************************************************************/
5036
5037Float_t TIsajet::GetXSMUSU() const
5038{
5039 return XMSSM.xsmusu;
5040}
5041
5042/**************************************************************************/
5043
5044void TIsajet::SetXLAMGM(Float_t val)
5045{
5046 XMSSM.xlamgm = val;
5047}
5048
5049/**************************************************************************/
5050
5051Float_t TIsajet::GetXLAMGM() const
5052{
5053 return XMSSM.xlamgm;
5054}
5055
5056/**************************************************************************/
5057
5058void TIsajet::SetXMESGM(Float_t val)
5059{
5060 XMSSM.xmesgm = val;
5061}
5062
5063/**************************************************************************/
5064
5065Float_t TIsajet::GetXMESGM() const
5066{
5067 return XMSSM.xmesgm;
5068}
5069
5070/**************************************************************************/
5071
5072void TIsajet::SetXN5GM(Float_t val)
5073{
5074 XMSSM.xn5gm = val;
5075}
5076
5077/**************************************************************************/
5078
5079Float_t TIsajet::GetXN5GM() const
5080{
5081 return XMSSM.xn5gm;
5082}
5083
5084/**************************************************************************/
5085
5086void TIsajet::SetXCMGV(Float_t val)
5087{
5088 XMSSM.xcmgv = val;
5089}
5090
5091/**************************************************************************/
5092
5093Float_t TIsajet::GetXCMGV() const
5094{
5095 return XMSSM.xcmgv;
5096}
5097
5098/**************************************************************************/
5099
5100void TIsajet::SetMGVTO(Float_t val)
5101{
5102 XMSSM.mgvto = val;
5103}
5104
5105/**************************************************************************/
5106
5107Float_t TIsajet::GetMGVTO() const
5108{
5109 return XMSSM.mgvto;
5110}
5111
5112/**************************************************************************/
5113
5114void TIsajet::SetXRSLGM(Float_t val)
5115{
5116 XMSSM.xrslgm = val;
5117}
5118
5119/**************************************************************************/
5120
5121Float_t TIsajet::GetXRSLGM() const
5122{
5123 return XMSSM.xrslgm;
5124}
5125
5126/**************************************************************************/
5127
5128void TIsajet::SetXDHDGM(Float_t val)
5129{
5130 XMSSM.xdhdgm = val;
5131}
5132
5133/**************************************************************************/
5134
5135Float_t TIsajet::GetXDHDGM() const
5136{
5137 return XMSSM.xdhdgm;
5138}
5139
5140/**************************************************************************/
5141
5142void TIsajet::SetXDHUGM(Float_t val)
5143{
5144 XMSSM.xdhugm = val;
5145}
5146
5147/**************************************************************************/
5148
5149Float_t TIsajet::GetXDHUGM() const
5150{
5151 return XMSSM.xdhugm;
5152}
5153
5154/**************************************************************************/
5155
5156void TIsajet::SetXDYGM(Float_t val)
5157{
5158 XMSSM.xdygm = val;
5159}
5160
5161/**************************************************************************/
5162
5163Float_t TIsajet::GetXDYGM() const
5164{
5165 return XMSSM.xdygm;
5166}
5167
5168/**************************************************************************/
5169
5170void TIsajet::SetXN51GM(Float_t val)
5171{
5172 XMSSM.xn51gm = val;
5173}
5174
5175/**************************************************************************/
5176
5177Float_t TIsajet::GetXN51GM() const
5178{
5179 return XMSSM.xn51gm;
5180}
5181
5182/**************************************************************************/
5183
5184void TIsajet::SetXN52GM(Float_t val)
5185{
5186 XMSSM.xn52gm = val;
5187}
5188
5189/**************************************************************************/
5190
5191Float_t TIsajet::GetXN52GM() const
5192{
5193 return XMSSM.xn52gm;
5194}
5195
5196/**************************************************************************/
5197
5198void TIsajet::SetXN53GM(Float_t val)
5199{
5200 XMSSM.xn53gm = val;
5201}
5202
5203/**************************************************************************/
5204
5205Float_t TIsajet::GetXN53GM() const
5206{
5207 return XMSSM.xn53gm;
5208}
5209
5210/**************************************************************************/
5211
5212void TIsajet::SetXMN3NR(Float_t val)
5213{
5214 XMSSM.xmn3nr = val;
5215}
5216
5217/**************************************************************************/
5218
5219Float_t TIsajet::GetXMN3NR() const
5220{
5221 return XMSSM.xmn3nr;
5222}
5223
5224/**************************************************************************/
5225
5226void TIsajet::SetXMAJNR(Float_t val)
5227{
5228 XMSSM.xmajnr = val;
5229}
5230
5231/**************************************************************************/
5232
5233Float_t TIsajet::GetXMAJNR() const
5234{
5235 return XMSSM.xmajnr;
5236}
5237
5238/**************************************************************************/
5239
5240void TIsajet::SetXANSS(Float_t val)
5241{
5242 XMSSM.xanss = val;
5243}
5244
5245/**************************************************************************/
5246
5247Float_t TIsajet::GetXANSS() const
5248{
5249 return XMSSM.xanss;
5250}
5251
5252/**************************************************************************/
5253
5254void TIsajet::SetXNRSS(Float_t val)
5255{
5256 XMSSM.xnrss = val;
5257}
5258
5259/**************************************************************************/
5260
5261Float_t TIsajet::GetXNRSS() const
5262{
5263 return XMSSM.xnrss;
5264}
5265
5266/**************************************************************************/
5267
5268void TIsajet::SetXSBCS(Float_t val)
5269{
5270 XMSSM.xsbcs = val;
5271}
5272
5273/**************************************************************************/
5274
5275Float_t TIsajet::GetXSBCS() const
5276{
5277 return XMSSM.xsbcs;
5278}
5279
5280/**************************************************************************/
5281
5282// Ends XMSSM access.
5283// Begins XTYPES access.
5284
5285/**************************************************************************/
5286
5287Char_t* TIsajet::GetPARTYP(Int_t index) const
5288{
5289 Int_t length = (sizeof XTYPES.partyp / sizeof XTYPES.partyp[0]);
5290 if ((index < 0) || (index >= length)) {
5291 printf ("Error in TIsajet::GetPARTYP : \n");
5292 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5293 return 0;
5294 }
5295
5296 return XTYPES.partyp[index];
5297}
5298
5299/**************************************************************************/
5300
5301void TIsajet::SetTITLE(Char_t *val)
5302{
5303 title = XTYPES.title = val;
5304}
5305
5306/**************************************************************************/
5307Char_t* TIsajet::GetTITLE() const
5308{
5309 return XTYPES.title;
5310}
5311
5312/**************************************************************************/
5313
5314void TIsajet::SetJETYP(Int_t index, Char_t val[])
5315{
5316 Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
5317 Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
5318
5319 if ((index < 0) || (index >= row_num)) {
5320 printf ("Error in TIsajet::SetJETYP : \n");
5321 printf ("Invalid array row index %d; range is 0-%d.\n", index, row_num-1);
5322 return;
5323 }
5324
5325 if (TYPES.njttyp[index] >= col_num) {
5326 printf ("Error in TIsajet::SetJETYP : \n");
5327 printf ("Cannot set more than %d jet types.\n", col_num-1);
5328 return;
5329 }
5330
5331 if ((!strcmp(val, "ALL")) || (!strcmp(val, "GL")) ||
5332 (!strcmp(val, "UP")) || (!strcmp(val, "UB")) ||
5333 (!strcmp(val, "DN")) || (!strcmp(val, "DB")) ||
5334 (!strcmp(val, "ST")) || (!strcmp(val, "SB")) ||
5335 (!strcmp(val, "CH")) || (!strcmp(val, "CB")) ||
5336 (!strcmp(val, "BT")) || (!strcmp(val, "BB")) ||
5337 (!strcmp(val, "TP")) || (!strcmp(val, "TB")) ||
5338 (!strcmp(val, "X")) || (!strcmp(val, "XB")) ||
5339 (!strcmp(val, "Y")) || (!strcmp(val, "YB")) ||
5340 (!strcmp(val, "E-")) || (!strcmp(val, "E+")) ||
5341 (!strcmp(val, "MU-")) || (!strcmp(val, "MU+")) ||
5342 (!strcmp(val, "TAU-")) || (!strcmp(val, "TAU+")) ||
5343 (!strcmp(val, "NUS")) || (!strcmp(val, "GM")) ||
5344 (!strcmp(val, "W+")) || (!strcmp(val, "W-")) ||
5345 (!strcmp(val, "Z0"))) {
5346
5347 XTYPES.jetyp[index][TYPES.njttyp[index]++] = val;
5348 }
5349 else {
5350 printf ("Error in TIsajet::SetJETYP : \n");
5351 printf ("Invalid jet type %s; valid types are\n", val);
5352 printf ("ALL, GL, UP, UB, DN, DB, ST, SB,\n");
5353 printf ("CH, CB, BT, BB, TP, TB, X, XB, Y, YB,\n");
5354 printf ("E-, E+, MU-, MU+, TAU-, TAU+, NUS, GM,\n");
5355 printf ("W+, W- and Z0.\n");
5356 return;
5357 }
5358
5359 if (index == 0) setJettype1 = true;
5360 else if (index == 1) setJettype2 = true;
5361 else if (index == 2) setJettype3 = true;
5362}
5363
5364/**************************************************************************/
5365
5366Char_t* TIsajet::GetJETYP(Int_t index1, Int_t index2) const
5367{
5368 Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
5369 Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
5370
5371 if ((index1 < 0) || (index1 >= row_num)) {
5372 printf ("Error in TIsajet::GetJETYP : \n");
5373 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5374 return 0;
5375 }
5376
5377 if ((index2 < 0) || (index2 >= col_num)) {
5378 printf ("Error in TIsajet::GetJETYP : \n");
5379 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5380 return 0;
5381 }
5382
5383 return XTYPES.jetyp[index1][index2];
5384}
5385
5386/**************************************************************************/
5387
5388void TIsajet::SetWWTYP(Char_t val[], Int_t index1, Int_t index2)
5389{
5390 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5391 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5392
5393 if ((index1 < 0) || (index1 >= row_num)) {
5394 printf ("Error in TIsajet::SetWWTYP : \n");
5395 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5396 return;
5397 }
5398
5399 if ((index2 < 0) || (index2 >= col_num)) {
5400 printf ("Error in TIsajet::SetWWTYP : \n");
5401 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5402 return;
5403 }
5404
5405 XTYPES.wwtyp[index1][index2] = val;
5406}
5407
5408/**************************************************************************/
5409
5410void TIsajet::SetAllWWTYP(Char_t* val[2][30])
5411{
5412 for (Int_t i = 0; i < 2; i++) {
5413 for (Int_t j = 0; j < 30; j++) {
5414 SetWWTYP(val[i][j], i, j);
5415 }
5416 }
5417}
5418
5419/**************************************************************************/
5420
5421void TIsajet::SetColumnWWTYP(Char_t* val[], Int_t col)
5422{
5423 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5424 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5425
5426 if ((col < 0) || (col >= col_num)) {
5427 printf ("Error in TIsajet::SetColumnWWTYP : \n");
5428 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
5429 return;
5430 }
5431
5432 for (Int_t i = 0; i < row_num; i++) {
5433 SetWWTYP(val[i], i, col);
5434 }
5435}
5436
5437/**************************************************************************/
5438
5439Char_t* TIsajet::GetWWTYP(Int_t index1, Int_t index2) const
5440{
5441 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5442 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5443
5444 if ((index1 < 0) || (index1 >= row_num)) {
5445 printf ("Error in TIsajet::GetWWTYP : \n");
5446 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5447 return 0;
5448 }
5449
5450 if ((index2 < 0) || (index2 >= col_num)) {
5451 printf ("Error in TIsajet::GetWWTYP : \n");
5452 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5453 return 0;
5454 }
5455
5456 return XTYPES.wwtyp[index1][index2];
5457}
5458
5459/**************************************************************************/
5460
5461void TIsajet::SetWMODES(Char_t val[], Int_t index1, Int_t index2)
5462{
5463 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5464 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5465
5466 if ((index1 < 0) || (index1 >= row_num)) {
5467 printf ("Error in TIsajet::SetWMODES : \n");
5468 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5469 return;
5470 }
5471
5472 if ((index2 < 0) || (index2 >= col_num)) {
5473 printf ("Error in TIsajet::SetWMODES : \n");
5474 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5475 return;
5476 }
5477
5478 XTYPES.wmodes[index1][index2] = val;
5479}
5480
5481/**************************************************************************/
5482
5483void TIsajet::SetAllWMODES(Char_t* val[2][30])
5484{
5485 for (Int_t i = 0; i < 2; i++) {
5486 for (Int_t j = 0; j < 30; j++) {
5487 SetWMODES(val[i][j], i, j);
5488 }
5489 }
5490}
5491
5492/**************************************************************************/
5493
5494void TIsajet::SetColumnWMODES(Char_t* val[], Int_t col)
5495{
5496 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5497 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5498
5499 if ((col < 0) || (col >= col_num)) {
5500 printf ("Error in TIsajet::SetColumnWMODES : \n");
5501 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
5502 return;
5503 }
5504
5505 for (Int_t i = 0; i < row_num; i++) {
5506 SetWMODES(val[i], i, col);
5507 }
5508}
5509
5510/**************************************************************************/
5511
5512Char_t* TIsajet::GetWMODES(Int_t index1, Int_t index2) const
5513{
5514 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5515 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5516
5517 if ((index1 < 0) || (index1 >= row_num)) {
5518 printf ("Error in TIsajet::GetWMODES : \n");
5519 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5520 return 0;
5521 }
5522
5523 if ((index2 < 0) || (index2 >= col_num)) {
5524 printf ("Error in TIsajet::GetWMODES : \n");
5525 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5526 return 0;
5527 }
5528
5529 return XTYPES.wmodes[index1][index2];
5530}
5531
5532/**************************************************************************/
5533
5534// Ends XTYPES access.
5535// Begins WCON access.
5536
5537/**************************************************************************/
5538
5539void TIsajet::SetSIN2W(Float_t val)
5540{
5541 WCON.sin2w = val;
5542}
5543
5544/**************************************************************************/
5545
5546Float_t TIsajet::GetSIN2W() const
5547{
5548 return WCON.sin2w;
5549}
5550
5551/**************************************************************************/
5552
5553void TIsajet::SetWMASS(Float_t w, Float_t z)
5554{
5555
5556// This is how the FORTRAN does it. Don't ask me why.
5557
5558 WCON.wmass[0] = 0;
5559 WCON.wmass[1] = WCON.wmass[2] = w;
5560 WCON.wmass[3] = z;
5561}
5562
5563/**************************************************************************/
5564
5565Float_t TIsajet::GetWMASS(Int_t index) const
5566{
5567 Int_t length = (sizeof WCON.wmass / sizeof WCON.wmass[0]);
5568 if ((index < 0) || (index >= length)) {
5569 printf ("Error in TIsajet::GetWMASS : \n");
5570 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5571 return 0;
5572 }
5573
5574 return WCON.wmass[index];
5575}
5576
5577/**************************************************************************/
5578
5579void TIsajet::SetWMass(Float_t val)
5580{
5581 WCON.wmass[1] = WCON.wmass[2] = val;
5582}
5583
5584/**************************************************************************/
5585
5586void TIsajet::SetZMass(Float_t val)
5587{
5588 WCON.wmass[3] = val;
5589}
5590
5591/**************************************************************************/
5592
5593Float_t TIsajet::GetWGAM(Int_t index) const
5594{
5595 Int_t length = (sizeof WCON.wgam / sizeof WCON.wgam[0]);
5596 if ((index < 0) || (index >= length)) {
5597 printf ("Error in TIsajet::GetWGAM : \n");
5598 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5599 return 0;
5600 }
5601
5602 return WCON.wgam[index];
5603}
5604
5605/**************************************************************************/
5606
5607Float_t TIsajet::GetAQ(Int_t index1, Int_t index2) const
5608{
5609 Int_t col_num = (sizeof WCON.aq[0] / sizeof WCON.aq[0][0]);
5610 Int_t row_num = (sizeof WCON.aq / (sizeof WCON.aq[0][0] * col_num));
5611
5612 if ((index1 < 0) || (index1 >= row_num)) {
5613 printf ("Error in TIsajet::GetAQ : \n");
5614 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5615 return 0;
5616 }
5617
5618 if ((index2 < 0) || (index2 >= col_num)) {
5619 printf ("Error in TIsajet::GetAQ : \n");
5620 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5621 return 0;
5622 }
5623
5624 return WCON.aq[index1][index2];
5625}
5626
5627/**************************************************************************/
5628
5629Float_t TIsajet::GetBQ(Int_t index1, Int_t index2) const
5630{
5631 Int_t col_num = (sizeof WCON.bq[0] / sizeof WCON.bq[0][0]);
5632 Int_t row_num = (sizeof WCON.bq / (sizeof WCON.bq[0][0] * col_num));
5633
5634 if ((index1 < 0) || (index1 >= row_num)) {
5635 printf ("Error in TIsajet::GetBQ : \n");
5636 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5637 return 0;
5638 }
5639
5640 if ((index2 < 0) || (index2 >= col_num)) {
5641 printf ("Error in TIsajet::GetBQ : \n");
5642 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5643 return 0;
5644 }
5645
5646 return WCON.bq[index1][index2];
5647}
5648
5649/**************************************************************************/
5650
5651Float_t TIsajet::GetCOUT(Int_t index) const
5652{
5653 Int_t length = (sizeof WCON.cout / sizeof WCON.cout[0]);
5654 if ((index < 0) || (index >= length)) {
5655 printf ("Error in TIsajet::GetCOUT : \n");
5656 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5657 return 0;
5658 }
5659
5660 return WCON.cout[index];
5661}
5662
5663/**************************************************************************/
5664
5665Int_t TIsajet::GetMATCH() const
5666{
5667 return WCON.match;
5668}
5669
5670/**************************************************************************/
5671
5672Float_t TIsajet::GetWCBR(Int_t index1, Int_t index2) const
5673{
5674 Int_t col_num = (sizeof WCON.wcbr[0] / sizeof WCON.wcbr[0][0]);
5675 Int_t row_num = (sizeof WCON.wcbr / (sizeof WCON.wcbr[0][0] * col_num));
5676
5677 if ((index1 < 0) || (index1 >= row_num)) {
5678 printf ("Error in TIsajet::GetWCBR : \n");
5679 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5680 return 0;
5681 }
5682
5683 if ((index2 < 0) || (index2 >= col_num)) {
5684 printf ("Error in TIsajet::GetWCBR : \n");
5685 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5686 return 0;
5687 }
5688
5689 return WCON.wcbr[index1][index2];
5690}
5691
5692/**************************************************************************/
5693
5694void TIsajet::SetCUTOFF(Float_t val)
5695{
5696 WCON.cutoff = val;
5697}
5698
5699/**************************************************************************/
5700
5701Float_t TIsajet::GetCUTOFF() const
5702{
5703 return WCON.cutoff;
5704}
5705
5706/**************************************************************************/
5707
5708void TIsajet::SetCUTPOW(Float_t val)
5709{
5710 WCON.cutpow = val;
5711}
5712
5713/**************************************************************************/
5714
5715Float_t TIsajet::GetCUTPOW() const
5716{
5717 return WCON.cutpow;
5718}
5719
5720/**************************************************************************/
5721
5722Float_t TIsajet::GetTBRWW(Int_t index1, Int_t index2) const
5723{
5724 Int_t col_num = (sizeof WCON.tbrww[0] / sizeof WCON.tbrww[0][0]);
5725 Int_t row_num = (sizeof WCON.tbrww / (sizeof WCON.tbrww[0][0] * col_num));
5726
5727 if ((index1 < 0) || (index1 >= row_num)) {
5728 printf ("Error in TIsajet::GetTBRWW : \n");
5729 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5730 return 0;
5731 }
5732
5733 if ((index2 < 0) || (index2 >= col_num)) {
5734 printf ("Error in TIsajet::GetTBRWW : \n");
5735 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5736 return 0;
5737 }
5738
5739 return WCON.tbrww[index1][index2];
5740}
5741
5742/**************************************************************************/
5743
5744Float_t TIsajet::GetRBRWW(Int_t index1, Int_t index2, Int_t index3) const
5745{
5746 Int_t elem_Size = sizeof WCON.rbrww[0][0][0];
5747 Int_t thd_Dim_Length = (sizeof WCON.rbrww[0][0] / elem_Size);
5748 Int_t sec_Dim_Length = (sizeof WCON.rbrww[0] / (elem_Size * thd_Dim_Length));
5749 Int_t fst_Dim_Length = (sizeof WCON.rbrww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
5750
5751 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
5752 printf ("Error in TIsajet::GetRBRWW : \n");
5753 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
5754 return 0;
5755 }
5756
5757 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
5758 printf ("Error in TIsajet::GetRBRWW : \n");
5759 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
5760 return 0;
5761 }
5762
5763 if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
5764 printf ("Error in TIsajet::GetRBRWW : \n");
5765 printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
5766 return 0;
5767 }
5768
5769 return WCON.rbrww[index1][index2][index3];
5770
5771}
5772
5773/**************************************************************************/
5774
5775Float_t TIsajet::GetEZ() const
5776{
5777 return WCON.ez;
5778}
5779
5780/**************************************************************************/
5781
5782Float_t TIsajet::GetAQDP(Int_t index1, Int_t index2) const
5783{
5784 Int_t col_num = (sizeof WCON.aqdp[0] / sizeof WCON.aqdp[0][0]);
5785 Int_t row_num = (sizeof WCON.aqdp / (sizeof WCON.aqdp[0][0] * col_num));
5786
5787 if ((index1 < 0) || (index1 >= row_num)) {
5788 printf ("Error in TIsajet::GetAQDP : \n");
5789 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5790 return 0;
5791 }
5792
5793 if ((index2 < 0) || (index2 >= col_num)) {
5794 printf ("Error in TIsajet::GetAQDP : \n");
5795 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5796 return 0;
5797 }
5798
5799 return WCON.aqdp[index1][index2];
5800}
5801
5802/**************************************************************************/
5803
5804Float_t TIsajet::GetBQDP(Int_t index1, Int_t index2) const
5805{
5806 Int_t col_num = (sizeof WCON.bqdp[0] / sizeof WCON.bqdp[0][0]);
5807 Int_t row_num = (sizeof WCON.bqdp / (sizeof WCON.bqdp[0][0] * col_num));
5808
5809 if ((index1 < 0) || (index1 >= row_num)) {
5810 printf ("Error in TIsajet::GetBQDP : \n");
5811 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5812 return 0;
5813 }
5814
5815 if ((index2 < 0) || (index2 >= col_num)) {
5816 printf ("Error in TIsajet::GetBQDP : \n");
5817 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5818 return 0;
5819 }
5820
5821 return WCON.bqdp[index1][index2];
5822}
5823
5824/**************************************************************************/
5825
5826Float_t TIsajet::GetEZDP() const
5827{
5828 return WCON.ezdp;
5829}
5830
5831/**************************************************************************/
5832
5833void TIsajet::SetWFUDGE(Float_t val)
5834{
5835 WCON.wfudge = val;
5836}
5837
5838/**************************************************************************/
5839
5840Float_t TIsajet::GetWFUDGE() const
5841{
5842 return WCON.wfudge;
5843}
5844
5845/**************************************************************************/
5846
5847// Ends WCON access.
5848
5849#ifndef WIN32
5850# define isaini isaini_
5851# define isaevt isaevt_
5852# define isabeg isabeg_
5853# define isabg2 isabg2_
5854# define openfiles openfiles_
5855# define pdfinit pdfinit_
5856# define ranf ranf_
5857# define type_of_call
5858#else
5859# define isaini ISAINI
5860# define isaevt ISAEVT
5861# define isabeg ISABEG
5862# define isabg2 ISABG2
5863# define openfiles OPENFILES
5864# define pdfinit PDFINIT
5865# define ranf RANF
5866# define type_of_call _stdcall
5867#endif
5868
5869extern "C" void type_of_call isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n);
5870extern "C" void type_of_call isaevt(Int_t& j, Int_t& k, Int_t& m);
5871extern "C" void type_of_call openfiles();
ff118c7c 5872extern "C" void type_of_call pdfinit(Int_t &, Int_t &);
7dae8538 5873extern "C" void type_of_call isabeg(Int_t& ifl);
5874extern "C" void type_of_call isabg2(Int_t& ifl);
5875
5876void TIsajet::Isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n)
5877{
5878 isaini(j, k, m, n);
5879}
5880
5881void TIsajet::Isaevt(Int_t& j, Int_t& k, Int_t& m)
5882{
5883 isaevt(j, k, m);
5884}
5885
5886void TIsajet::Openfiles()
5887{
5888 openfiles();
5889}
5890
ff118c7c 5891void TIsajet::PDFinit(Int_t& pdfpar, Int_t& pdfval )
7dae8538 5892{
5893 pdfinit(pdfpar, pdfval);
5894}
5895
5896void TIsajet::Isabeg(Int_t& ifl)
5897{
5898 isabeg(ifl);
5899}
5900
5901void TIsajet::Isabg2(Int_t& ifl)
5902{
5903 isabg2(ifl);
5904}
5905
5906extern "C" {
5907 Double_t type_of_call ranf(Int_t & /*idum*/)
5908 {
5909 Float_t r;
5910 do r=sRandom->Rndm(); while(0 >= r || r >= 1);
5911 return r;
5912 }
5913}
5914
5915
5916
5917
5918
5919
5920
5921
5922
5923
5924