12 static TRandom * sRandom;
14 /**************************************************************************/
16 TIsajet::TIsajet() : TGenerator("Isajet", "Isajet")
18 // Default constructor
20 if (!sRandom) sRandom=fRandom;
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)
27 FRGPAR.pmixx1[0] = &FRGPAR.pmix1[0][0];
28 FRGPAR.pmixx2[0] = &FRGPAR.pmix2[0][0];
29 FRGPAR.frpar[0] = &FRGPAR.pud;
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;
36 for (Int_t i = 1; i < 32; i++) {
37 FRGPAR.frpar[i] = FRGPAR.frpar[i-1] +1;
40 // Internal logical flags ensuring that theta and y limits are not simultaneously set :
42 DYLIM.ywset = DYLIM.thwset = false;
46 title = ("Default title.");
52 /**************************************************************************/
56 // No housekeeping required at the moment.
59 /**************************************************************************/
61 void TIsajet::Initialise()
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.
69 const char *fname = gSystem->ExpandPathName("$ALICE_ROOT/ISAJET/data/myjob.par");
70 ofstream Write(fname, ios::out);
72 ostream *Writer = &Write;
74 if (online) Writer = &cout;
76 *Writer << title << '\n';
77 *Writer << PRIMAR.ecm << ',' << PRIMAR.nevent << ",1,1/\n";
78 *Writer << jobtype << '\n';
80 center_energy = PRIMAR.ecm;
83 beam1_type = PRIMAR.idin[0];
84 beam2_type = PRIMAR.idin[1];
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,";
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";
99 cutoff_mass = QCDPAR.cutjet;
100 *Writer << "CUTJET\n" << QCDPAR.cutjet << "/\n";
104 for (Int_t i = 0; i < 32; i++) frag_params[i] = *FRGPAR.frpar[i];
106 *Writer << "FRAGMENT\n";
107 for (Int_t i = 0; i < 31; i++) *Writer << FRGPAR.frpar[i] << ',';
108 *Writer << FRGPAR.frpar[31] << "/\n";
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];
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";
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];
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";
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];
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";
138 qcd_lambda = QCDPAR.alam;
139 *Writer << "LAMBDA\n" << QCDPAR.alam << "/\n";
144 forbid_decay = NODCAY.nodcay;
146 *Writer << "NODCAY\n";
147 if (NODCAY.nodcay) *Writer << "TRUE/\n";
148 else *Writer << "FALSE/\n";
152 forbid_eta = NODCAY.noeta;
154 *Writer << "NOETA\n";
155 if (NODCAY.noeta) *Writer << "TRUE/\n";
156 else *Writer << "FALSE/\n";
160 forbid_evolve = NODCAY.noevol;
162 *Writer << "NOEVOLVE\n";
163 if (NODCAY.noevol) *Writer << "TRUE/\n";
164 else *Writer << "FALSE/\n";
168 forbid_hadron = NODCAY.nohadr;
170 *Writer << "NOHADRON\n";
171 if (NODCAY.nohadr) *Writer << "TRUE/\n";
172 else *Writer << "FALSE/\n";
176 forbid_pi0 = NODCAY.nopi0;
178 *Writer << "NOPI0\n";
179 if (NODCAY.nopi0) *Writer << "TRUE/\n";
180 else *Writer << "FALSE/\n";
184 generate_sigma = PRIMAR.nsigma;
185 *Writer << "NSIGMA\n" << PRIMAR.nsigma << "/\n";
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];
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";
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];
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";
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];
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";
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];
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";
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];
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";
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];
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";
261 for (Int_t i = 0; i < 8; i++) peter_jet_frag[i] = FRGPAR.xgen[i];
264 for (Int_t i = 0; i < 7; i++) *Writer << FRGPAR.xgen[i] << ',';
265 *Writer << FRGPAR.xgen[7] << "/\n";
269 *Writer << "PDFLIB\n";
270 for (Int_t i = 0; i < num_Pdf; i++) *Writer << "\'" << pdfpar[i] << "\'" << ',' << pdfval[i] << "/\n";
278 // Stuff for online-control mode :
283 for (Int_t i = 0; i < KEYS.mxkeys; i++) KEYS.keys[i] = false;
285 if (!strcmp(KEYS.reac, "TWOJET")) {
290 else if (!strcmp(KEYS.reac, "MINBIAS")) {
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");
308 /**************************************************************************/
310 void TIsajet::Reload()
313 // Sets the common block variables to the data member values.
316 SetECM(center_energy);
319 SetIDIN(0, beam1_type);
320 SetIDIN(1, beam2_type);
323 if (setCutjet) SetCUTJET(cutoff_mass);
325 if (setFragment) SetAllFRPAR(frag_params, 32);
327 if (setJettype1) for (Int_t i = 0; i < num_jet_type[0]; i++) SetJETYP(0, jet1_type[i]);
329 if (setJettype2) for (Int_t i = 0; i < num_jet_type[1]; i++) SetJETYP(1, jet2_type[i]);
331 if (setJettype3) for (Int_t i = 0; i < num_jet_type[2]; i++) SetJETYP(2, jet3_type[i]);
333 if (setLambda) SetALAM(qcd_lambda);
335 if (setNodcay) SetNODCAY(forbid_decay);
337 if (setNoeta) SetNOETA(forbid_eta);
339 if (setNoevolve) SetNOEVOL(forbid_evolve);
341 if (setNohadron) SetNOHADR(forbid_hadron);
343 if (setNopi0) SetNOPI0(forbid_pi0);
345 if (setNsigma) SetNSIGMA(generate_sigma);
348 for (Int_t i = 0; i < 3; i++) {
349 SetPMIN(p_limits[2 * i], i);
350 SetPMAX(p_limits[2 * i + 1], i);
355 for (Int_t i = 0; i < 3; i++) {
356 SetPHIMIN(phi_limits[2 * i], i);
357 SetPHIMAX(phi_limits[2 * i + 1], i);
362 for (Int_t i = 0; i < 3; i++) {
363 SetPTMIN(pt_limits[2 * i], i);
364 SetPTMAX(pt_limits[2 * i + 1], i);
369 for (Int_t i = 0; i < 3; i++) {
370 SetTHMIN(theta_limits[2 * i], i);
371 SetTHMAX(theta_limits[2 * i + 1], i);
376 for (Int_t i = 0; i < 3; i++) {
377 SetXJMIN(x_limits[2 * i], i);
378 SetXJMAX(x_limits[2 * i + 1], i);
383 for (Int_t i = 0; i < 3; i++) {
384 SetYJMIN(y_limits[2 * i], i);
385 SetYJMAX(y_limits[2 * i + 1], i);
389 if (setXgen) SetAllXGEN(peter_jet_frag, 8);
392 /**************************************************************************/
394 void TIsajet::RestoreDefaults()
396 // Booleans indicating which keywords should be written into the parameter file.
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;
405 // Calling on FORTRAN for initialisation of variables
420 /**************************************************************************/
422 Int_t TIsajet::ImportParticles(TClonesArray *particles, Option_t *option)
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
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.
435 if (particles == 0) return 0;
436 TClonesArray &Particles = *particles;
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);
443 if ((!strcmp(option,"")) || (!strcmp(option,"Final"))) {
444 for (Int_t i = 0; i < numpart; i++) {
446 if (PARTCL.idcay[i] == 0) { // Check whether particle is stable.
448 // Use the common block values for the TParticle constructor
451 new(Particles[i]) TParticle(
452 converter->ConvertIsajetToPdg(PARTCL.ident[i]) , // PDG code
453 0 , // Status - currently a default
455 -1, // Mothers and daughters - not used for stable particles
460 PARTCL.pptcl[i][0] , // x, y, z and 0 momenta
465 0, // Velocities - currently not used.
472 else if (!strcmp(option,"All")) {
474 for (Int_t i = 0; i < numpart; i++) {
476 // Determine mother particle. Set to -1 if the particle originates from
477 // a parton or is a beam particle.
479 Int_t origin = PARTCL.iorig[i];
480 Int_t jet = origin / PARTCL.ipack;
481 origin = origin - (jet * PARTCL.ipack);
483 if (origin < 0) origin = 0;
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.
489 Int_t first_Daughter = 0;
490 Int_t last_Daughter = 0;
492 if (PARTCL.idcay[i] != 0) {
493 first_Daughter = PARTCL.idcay[i] / PARTCL.ipack;
494 last_Daughter = PARTCL.idcay[i] - (first_Daughter * PARTCL.ipack);
496 new(Particles[i]) TParticle(
497 converter->ConvertIsajetToPdg(PARTCL.ident[i]) ,
519 /**************************************************************************/
521 void TIsajet::GenerateEvent()
527 // if (online) Isabg2(e);
534 /**************************************************************************/
536 void TIsajet::SetJobtype(Char_t *val)
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"))) {
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");
555 /**************************************************************************/
557 void TIsajet::GetJobtype() const
559 printf ("Current job type is %s.\n", jobtype);
562 /**************************************************************************/
564 void TIsajet::SetOnline(Bool_t val)
569 /**************************************************************************/
571 Bool_t TIsajet::GetOnline() const
576 /**************************************************************************/
578 void TIsajet::SetPDF(Char_t *name, Float_t val)
581 pdfpar[num_Pdf] = name;
582 pdfval[num_Pdf] = val;
587 printf ("Error in TIsajet::SetPDF :\n");
588 printf ("Maximum of twenty PDF parameters may be set.\n");
592 /**************************************************************************/
594 // Access routines for common blocks.
595 // Begins DYLIM access.
597 /**************************************************************************/
599 void TIsajet::SetQMIN(Float_t val)
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);
608 if (!DYLIM.ywset) SetYWLIMS();
611 /**************************************************************************/
613 Float_t TIsajet::GetQMIN() const
618 /**************************************************************************/
620 void TIsajet::SetQMAX(Float_t val)
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);
631 /**************************************************************************/
633 Float_t TIsajet::GetQMAX() const
638 /**************************************************************************/
640 void TIsajet::SetQTMIN(Float_t val)
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);
648 if (!DYLIM.ywset) SetYWLIMS();
651 /**************************************************************************/
653 Float_t TIsajet::GetQTMIN() const
658 /**************************************************************************/
660 void TIsajet::SetQTMAX(Float_t val)
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);
669 if (!DYLIM.ywset) SetYWLIMS();
672 /**************************************************************************/
674 Float_t TIsajet::GetQTMAX() const
679 /**************************************************************************/
681 void TIsajet::SetYWMIN(Float_t val)
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);
690 printf("Error in TIsajet::SetYWMIN :\n");
691 printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMIN.\n");
699 /**************************************************************************/
701 Float_t TIsajet::GetYWMIN() const
706 /**************************************************************************/
708 void TIsajet::SetYWMAX(Float_t val)
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);
717 printf("Error in TIsajet::SetYWMAX :\n");
718 printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMAX.\n");
726 /**************************************************************************/
728 Float_t TIsajet::GetYWMAX() const
733 /**************************************************************************/
735 void TIsajet::SetYWLIMS()
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;
743 /**************************************************************************/
745 void TIsajet::SetXWMIN(Float_t val)
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);
755 /**************************************************************************/
757 Float_t TIsajet::GetXWMIN() const
762 /**************************************************************************/
764 void TIsajet::SetXWMAX(Float_t val)
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);
775 /**************************************************************************/
777 Float_t TIsajet::GetXWMAX() const
782 /**************************************************************************/
784 void TIsajet::SetTHWMIN(Float_t val)
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);
793 printf("Error in TIsajet::SetTHWMIN :\n");
794 printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMIN.\n");
802 /**************************************************************************/
804 Float_t TIsajet::GetTHWMIN() const
809 /**************************************************************************/
811 void TIsajet::SetTHWMAX(Float_t val)
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);
820 printf("Error in TIsajet::SetTHWMAX :\n");
821 printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMAX.\n");
829 /**************************************************************************/
831 Float_t TIsajet::GetTHWMAX() const
836 /**************************************************************************/
838 void TIsajet::SetTHWLIMS()
841 DYLIM.thwmax = TMath::Pi();
842 DYLIM.thwset = false;
845 /**************************************************************************/
847 void TIsajet::SetPHWMIN(Float_t val)
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);
857 /**************************************************************************/
859 Float_t TIsajet::GetPHWMIN() const
864 /**************************************************************************/
866 void TIsajet::SetPHWMAX(Float_t val)
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);
877 /**************************************************************************/
879 Float_t TIsajet::GetPHWMAX() const
884 /**************************************************************************/
886 Bool_t TIsajet::GetSETLMQ(Int_t index) const
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);
895 return DYLIM.setlmq[index];
898 /**************************************************************************/
900 // End of DYLIM access.
901 // Begins EEPAR access.
903 /**************************************************************************/
905 void TIsajet::SetPLEP(Float_t val)
910 /**************************************************************************/
912 Float_t TIsajet::GetPLEP() const
917 /**************************************************************************/
919 void TIsajet::SetPLEM(Float_t val)
924 /**************************************************************************/
926 Float_t TIsajet::GetPLEM() const
931 /**************************************************************************/
933 void TIsajet::SetRSHMIN(Float_t val)
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);
943 /**************************************************************************/
945 Float_t TIsajet::GetRSHMIN() const
950 /**************************************************************************/
952 void TIsajet::SetRSHMAX(Float_t val)
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);
963 /**************************************************************************/
965 Float_t TIsajet::GetRSHMAX() const
970 /**************************************************************************/
972 void TIsajet::SetUPSLON(Float_t val)
977 /**************************************************************************/
979 Float_t TIsajet::GetUPSLON() const
984 /**************************************************************************/
986 void TIsajet::SetSIGZ(Float_t val)
991 /**************************************************************************/
993 Float_t TIsajet::GetSIGZ() const
998 /**************************************************************************/
1000 Bool_t TIsajet::GetIBREM() const
1005 /**************************************************************************/
1007 Bool_t TIsajet::GetIBEAM() const
1012 /**************************************************************************/
1014 Float_t TIsajet::GetSGMXEE() const
1016 return EEPAR.sgmxee;
1019 /**************************************************************************/
1021 // End of EEPAR access.
1022 // Begins FORCE access.
1024 /**************************************************************************/
1026 Int_t TIsajet::GetNFORCE() const
1028 return FORCE.nforce;
1031 /**************************************************************************/
1033 void TIsajet::SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti)
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 );
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);
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);
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];
1063 printf ("Decay channel %d -> ", val[0]);
1064 for (Int_t i = 1; i < arraySize; i++) {
1065 printf ("%d, ", val[i]);
1070 Int_t* antivals = new Int_t[arraySize];
1071 for (Int_t i = 0; i < arraySize; i++){
1072 antivals[i] = (0 - val[i]);
1074 SetIFORCE(antivals, arraySize, false);
1078 /**************************************************************************/
1080 void TIsajet::UnForce(Int_t index, Bool_t anti)
1082 if (FORCE.nforce == 0) {
1083 printf ("Error in TIsajet::UnForce : \n");
1084 printf ("No decays have been forced.\n");
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);
1094 Int_t particle_ID = FORCE.iforce[index];
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];
1102 FORCE.iforce[FORCE.mxforc - 1] = 0;
1103 for (Int_t j = 0; j < 5; j++) {
1104 FORCE.mforce[FORCE.mxforc - 1][j] = 0;
1109 printf ("Decay of %d unforced.\n", particle_ID);
1111 if (anti) UnForceID(-particle_ID, false);
1114 /**************************************************************************/
1116 void TIsajet::UnForceID(Int_t particle_ID, Bool_t anti)
1118 if (FORCE.nforce == 0) {
1119 printf ("Error in TIsajet::UnForceID : \n");
1120 printf ("No decays have been forced.\n");
1124 for (Int_t i = 0; i < FORCE.nforce; i++) {
1125 if (FORCE.iforce[i] == particle_ID) {
1131 printf ("Error in TIsajet::UnForceID : \n");
1132 printf ("Cannot find particle %d.\n", particle_ID);
1135 /**************************************************************************/
1137 Int_t* TIsajet::GetIFORCE(Int_t index) const
1139 if (FORCE.nforce == 0) {
1140 printf ("Error in TIsajet::GetIFORCE : \n");
1141 printf ("No decays have been forced.\n");
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);
1151 Int_t* decay = new Int_t[6];
1152 decay[0] = FORCE.iforce[index];
1154 for (Int_t i = 1; i < 6; i++) {
1155 decay[i] = FORCE.mforce[index][i-1];
1161 /**************************************************************************/
1163 Int_t TIsajet::GetMEFORC(Int_t index) const
1165 if (FORCE.nforce == 0) {
1166 printf ("Error in TIsajet::GetMEFORCE : \n");
1167 printf ("No decays have been forced.\n");
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);
1177 return FORCE.meforc[index];
1180 /**************************************************************************/
1182 // End of FORCE access.
1183 // Begins FRGPAR access.
1185 /**************************************************************************/
1187 void TIsajet::SetFRPAR(Float_t val, Int_t index)
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);
1196 *FRGPAR.frpar[index] = val;
1200 /**************************************************************************/
1202 void TIsajet::SetAllFRPAR(const Float_t val[], Int_t arraySize)
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);
1211 for (Int_t i = 0; i < arraySize; i++) {
1212 SetFRPAR(val[i], i);
1216 /**************************************************************************/
1218 Float_t TIsajet::GetFRPAR(Int_t index) const
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);
1227 return *FRGPAR.frpar[index];
1230 /**************************************************************************/
1232 void TIsajet::SetPUD(Float_t val)
1237 /**************************************************************************/
1239 Float_t TIsajet::GetPUD() const
1244 /**************************************************************************/
1246 void TIsajet::SetPBARY(Float_t val)
1251 /**************************************************************************/
1253 Float_t TIsajet::GetPBARY() const
1258 /**************************************************************************/
1260 void TIsajet::SetSIGQT(Float_t val)
1265 /**************************************************************************/
1267 Float_t TIsajet::GetSIGQT() const
1272 /**************************************************************************/
1274 void TIsajet::SetPEND(Float_t val)
1279 /**************************************************************************/
1281 Float_t TIsajet::GetPEND() const
1286 /**************************************************************************/
1288 void TIsajet::SetXGEN(Float_t val, Int_t index)
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);
1296 SetFRPAR(val, index + 4);
1300 /**************************************************************************/
1302 void TIsajet::SetAllXGEN(const Float_t val[], Int_t arraySize)
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);
1311 for (Int_t i = 0; i < arraySize; i++) {
1316 /**************************************************************************/
1318 Float_t TIsajet::GetXGEN(Int_t index) const
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);
1327 return GetFRPAR(index + 4);
1330 /**************************************************************************/
1332 void TIsajet::SetPSPIN1(Float_t val, Int_t index)
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);
1341 SetFRPAR(val, index + 12);
1344 /**************************************************************************/
1346 void TIsajet::SetAllPSPIN1(const Float_t val[], Int_t arraySize)
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);
1355 for (Int_t i = 0; i < arraySize; i++) {
1356 SetPSPIN1(val[i], i);
1360 /**************************************************************************/
1362 Float_t TIsajet::GetPSPIN1(Int_t index) const
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);
1371 return GetFRPAR(index + 12);
1374 /**************************************************************************/
1376 void TIsajet::SetPMIX1(Float_t val, Int_t index1, Int_t index2)
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));
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);
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);
1393 FRGPAR.pmix1[index1][index2] = val;
1397 /**************************************************************************/
1399 void TIsajet::SetAllPMIX1(const Float_t val[2][3])
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);
1408 /**************************************************************************/
1410 void TIsajet::SetColumnPMIX1(const Float_t val[], Int_t col)
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));
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);
1421 for (Int_t i = 0; i < row_num; i++) {
1422 SetPMIX1(val[i], i, col);
1426 /**************************************************************************/
1428 Float_t TIsajet::GetPMIX1(Int_t index1, Int_t index2) const
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));
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);
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);
1445 return FRGPAR.pmix1[index1][index2];
1448 /**************************************************************************/
1450 void TIsajet::SetPMIX2(Float_t val, Int_t index1, Int_t index2)
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));
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);
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);
1467 FRGPAR.pmix2[index1][index2] = val;
1471 /**************************************************************************/
1473 void TIsajet::SetAllPMIX2(const Float_t val[2][3])
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);
1482 /**************************************************************************/
1484 void TIsajet::SetColumnPMIX2(const Float_t val[], Int_t col)
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));
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);
1495 for (Int_t i = 0; i < row_num; i++) {
1496 SetPMIX2(val[i], i, col);
1500 /**************************************************************************/
1502 Float_t TIsajet::GetPMIX2(Int_t index1, Int_t index2) const
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));
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);
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);
1519 return FRGPAR.pmix2[index1][index2];
1522 /**************************************************************************/
1524 void TIsajet::SetPMIXX1(Float_t val, Int_t index)
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);
1533 *FRGPAR.pmixx1[index] = val;
1537 /**************************************************************************/
1539 void TIsajet::SetAllPMIXX1(const Float_t val[], Int_t arraySize)
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);
1548 for (Int_t i = 0; i < arraySize; i++) {
1549 SetPMIXX1(val[i], i);
1553 /**************************************************************************/
1555 Float_t TIsajet::GetPMIXX1(Int_t index) const
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);
1564 return *FRGPAR.pmixx1[index];
1567 /**************************************************************************/
1569 void TIsajet::SetPMIXX2(Float_t val, Int_t index)
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);
1578 *FRGPAR.pmixx2[index] = val;
1582 /**************************************************************************/
1584 void TIsajet::SetAllPMIXX2(const Float_t val[], Int_t arraySize)
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);
1593 for (Int_t i = 0; i < arraySize; i++) {
1594 SetPMIXX2(val[i], i);
1598 /**************************************************************************/
1600 Float_t TIsajet::GetPMIXX2(Int_t index) const
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);
1609 return *FRGPAR.pmixx2[index];
1612 /**************************************************************************/
1614 void TIsajet::SetXGENSS(Float_t val, Int_t index)
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);
1623 FRGPAR.xgenss[index] = val;
1626 /**************************************************************************/
1628 void TIsajet::SetAllXGENSS(const Float_t val[], Int_t arraySize)
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);
1637 for (Int_t i = 0; i < arraySize; i++) {
1638 SetXGENSS(val[i], i);
1642 /**************************************************************************/
1644 Float_t TIsajet::GetXGENSS(Int_t index) const
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);
1653 return FRGPAR.xgenss[index];
1656 /**************************************************************************/
1658 // End of FRGPAR access.
1659 // Begins HCON access.
1661 /**************************************************************************/
1663 Float_t TIsajet::GetANWWWW(Int_t index1, Int_t index2, Int_t index3) const
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));
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);
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);
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);
1688 return HCON.anwwww[index1][index2][index3];
1691 /**************************************************************************/
1693 Float_t TIsajet::GetADWWWW(Int_t index1, Int_t index2) const
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));
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);
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);
1711 return HCON.adwwww[index1][index2];
1714 /**************************************************************************/
1716 Float_t TIsajet::GetAIWWWW(Int_t index) const
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);
1725 return HCON.aiwwww[index];
1728 /**************************************************************************/
1730 Float_t TIsajet::GetHMASS() const
1735 /**************************************************************************/
1737 Float_t TIsajet::GetHGAM() const
1742 /**************************************************************************/
1744 Float_t TIsajet::GetHGAMS(Int_t index) const
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);
1753 return HCON.hgams[index];
1756 /**************************************************************************/
1758 Float_t TIsajet::GetETAHGG() const
1763 /**************************************************************************/
1765 Int_t TIsajet::GetMATCHH(Int_t index) const
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);
1774 return HCON.matchh[index];
1777 /**************************************************************************/
1779 Float_t TIsajet::GetZSTARS(Int_t index1, Int_t index2) const
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));
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);
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);
1797 return HCON.zstars[index1][index2];
1800 /**************************************************************************/
1802 void TIsajet::SetIHTYPE(Int_t val)
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);
1813 /**************************************************************************/
1815 void TIsajet::SetIHTYPE(Char_t val[])
1817 if (!strcmp("HL0", val)) {
1820 else if (!strcmp("HH0", val)) {
1823 else if (!strcmp("HA0", val)){
1827 printf ("Error in TIsajet::SetIHTYPE : \n");
1828 printf ("Invalid input string %s. Possible strings are HL0, HH0, HA0.\n", val);
1832 /**************************************************************************/
1834 Int_t TIsajet::GetIHTYPE() const
1839 /**************************************************************************/
1841 Float_t TIsajet::GetHGAMSS(Int_t index1, Int_t index2) const
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));
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);
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);
1859 return HCON.hgamss[index1][index2];
1862 /**************************************************************************/
1864 // End of HCON access
1865 // Begins JETLIM access
1867 /**************************************************************************/
1869 void TIsajet::SetPMIN(Float_t val, Int_t index)
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);
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]);
1884 JETLIM.pmin[index] = val;
1888 /**************************************************************************/
1890 void TIsajet::SetAllPMIN(const Float_t val[], Int_t arraySize)
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);
1899 for (Int_t i = 0; i < arraySize; i++) {
1904 /**************************************************************************/
1906 Float_t TIsajet::GetPMIN(Int_t index) const
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);
1915 return JETLIM.pmin[index];
1918 /**************************************************************************/
1920 void TIsajet::SetPMAX(Float_t val, Int_t index)
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);
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]);
1935 JETLIM.pmax[index] = val;
1939 /**************************************************************************/
1941 void TIsajet::SetAllPMAX(const Float_t val[], Int_t arraySize)
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);
1950 for (Int_t i = 0; i < arraySize; i++) {
1955 /**************************************************************************/
1957 Float_t TIsajet::GetPMAX(Int_t index) const
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);
1966 return JETLIM.pmax[index];
1969 /**************************************************************************/
1971 void TIsajet::SetPTMIN(Float_t val, Int_t index)
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);
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]);
1986 JETLIM.ptmin[index] = val;
1987 // if (!setY) SetYJLIMS();
1988 // if (!setTheta) SetTHLIMS();
1992 /**************************************************************************/
1994 void TIsajet::SetAllPTMIN(const Float_t val[], Int_t arraySize)
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);
2003 for (Int_t i = 0; i < arraySize; i++) {
2004 SetPTMIN(val[i], i);
2008 /**************************************************************************/
2010 Float_t TIsajet::GetPTMIN(Int_t index) const
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);
2019 return JETLIM.ptmin[index];
2022 /**************************************************************************/
2024 void TIsajet::SetPTMAX(Float_t val, Int_t index)
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);
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]);
2039 JETLIM.ptmax[index] = val;
2043 /**************************************************************************/
2045 void TIsajet::SetAllPTMAX(const Float_t val[], Int_t arraySize)
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);
2054 for (Int_t i = 0; i < arraySize; i++) {
2055 SetPTMAX(val[i], i);
2059 /**************************************************************************/
2061 Float_t TIsajet::GetPTMAX(Int_t index) const
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);
2070 return JETLIM.ptmax[index];
2073 /**************************************************************************/
2075 void TIsajet::SetYJMIN(Float_t val, Int_t index)
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);
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]);
2091 printf("Error in TIsajet::SetYJMIN :\n");
2092 printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMIN.\n");
2097 JETLIM.yjmin[index] = val;
2100 /**************************************************************************/
2102 void TIsajet::SetAllYJMIN(const Float_t val[], Int_t arraySize)
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);
2111 for (Int_t i = 0; i < arraySize; i++) {
2112 SetYJMIN(val[i], i);
2116 /**************************************************************************/
2118 Float_t TIsajet::GetYJMIN(Int_t index) const
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);
2127 return JETLIM.yjmin[index];
2130 /**************************************************************************/
2132 void TIsajet::SetYJMAX(Float_t val, Int_t index)
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);
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]);
2148 printf("Error in TIsajet::SetYJMAX :\n");
2149 printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMAX.\n");
2154 JETLIM.yjmax[index] = val;
2157 /**************************************************************************/
2159 void TIsajet::SetAllYJMAX(const Float_t val[], Int_t arraySize)
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);
2168 for (Int_t i = 0; i < arraySize; i++) {
2169 SetYJMAX(val[i], i);
2173 /**************************************************************************/
2175 Float_t TIsajet::GetYJMAX(Int_t index) const
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);
2184 return JETLIM.yjmax[index];
2187 /**************************************************************************/
2189 void TIsajet::SetYJLIMS()
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];
2198 /**************************************************************************/
2200 void TIsajet::SetPHIMIN(Float_t val, Int_t index)
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);
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]);
2215 JETLIM.phimin[index] = val;
2219 /**************************************************************************/
2221 void TIsajet::SetAllPHIMIN(const Float_t val[], Int_t arraySize)
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);
2230 for (Int_t i = 0; i < arraySize; i++) {
2231 SetPHIMIN(val[i], i);
2235 /**************************************************************************/
2237 Float_t TIsajet::GetPHIMIN(Int_t index) const
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);
2246 return JETLIM.phimin[index];
2249 /**************************************************************************/
2251 void TIsajet::SetPHIMAX(Float_t val, Int_t index)
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);
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]);
2266 JETLIM.phimax[index] = val;
2270 /**************************************************************************/
2272 void TIsajet::SetAllPHIMAX(const Float_t val[], Int_t arraySize)
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);
2281 for (Int_t i = 0; i < arraySize; i++) {
2282 SetPHIMAX(val[i], i);
2286 /**************************************************************************/
2288 Float_t TIsajet::GetPHIMAX(Int_t index) const
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);
2297 return JETLIM.phimax[index];
2300 /**************************************************************************/
2302 void TIsajet::SetXJMIN(Float_t val, Int_t index)
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);
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]);
2316 JETLIM.xjmin[index] = val;
2320 /**************************************************************************/
2322 void TIsajet::SetAllXJMIN(const Float_t val[], Int_t arraySize)
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);
2331 for (Int_t i = 0; i < arraySize; i++) {
2332 SetXJMIN(val[i], i);
2336 /**************************************************************************/
2338 Float_t TIsajet::GetXJMIN(Int_t index) const
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);
2347 return JETLIM.xjmin[index];
2350 /**************************************************************************/
2352 void TIsajet::SetXJMAX(Float_t val, Int_t index)
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);
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]);
2367 JETLIM.xjmax[index] = val;
2371 /**************************************************************************/
2373 void TIsajet::SetAllXJMAX(const Float_t val[], Int_t arraySize)
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);
2382 for (Int_t i = 0; i < arraySize; i++) {
2383 SetXJMAX(val[i], i);
2387 /**************************************************************************/
2389 Float_t TIsajet::GetXJMAX(Int_t index) const
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);
2398 return JETLIM.xjmax[index];
2401 /**************************************************************************/
2403 void TIsajet::SetTHMIN(Float_t val, Int_t index)
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);
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]);
2419 printf("Error in TIsajet::SetTHMIN :\n");
2420 printf("May not set both theta and y limits. Use SetYJLIMS, then set THMIN.\n");
2425 JETLIM.thmin[index] = val;
2429 /**************************************************************************/
2431 void TIsajet::SetAllTHMIN(const Float_t val[], Int_t arraySize)
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);
2440 for (Int_t i = 0; i < arraySize; i++) {
2441 SetTHMIN(val[i], i);
2445 /**************************************************************************/
2447 Float_t TIsajet::GetTHMIN(Int_t index) const
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);
2456 return JETLIM.thmin[index];
2459 /**************************************************************************/
2461 void TIsajet::SetTHMAX(Float_t val, Int_t index)
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);
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]);
2477 printf("Error in TIsajet::SetTHMAX :\n");
2478 printf("May not set both theta and y limits. Use SetYJLIMS, then set THMAX.\n");
2483 JETLIM.thmax[index] = val;
2486 /**************************************************************************/
2488 void TIsajet::SetAllTHMAX(const Float_t val[], Int_t arraySize)
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);
2497 for (Int_t i = 0; i < arraySize; i++) {
2498 SetTHMAX(val[i], i);
2502 /**************************************************************************/
2504 Float_t TIsajet::GetTHMAX(Int_t index) const
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);
2513 return JETLIM.thmax[index];
2516 /**************************************************************************/
2518 void TIsajet::SetTHLIMS()
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));
2529 /**************************************************************************/
2531 Bool_t TIsajet::GetSETLMJ(Int_t index) const
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);
2540 return JETLIM.setlmj[index];
2543 /**************************************************************************/
2545 // Ends JETLIM access.
2546 // Begins JETPAR access.
2548 /**************************************************************************/
2550 Float_t TIsajet::GetP(Int_t index) const
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);
2559 return JETPAR.p[index];
2562 /**************************************************************************/
2564 Float_t TIsajet::GetPT(Int_t index) const
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);
2573 return JETPAR.pt[index];
2576 /**************************************************************************/
2578 Float_t TIsajet::GetYJ(Int_t index) const
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);
2587 return JETPAR.yj[index];
2590 /**************************************************************************/
2592 Float_t TIsajet::GetPHI(Int_t index) const
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);
2601 return JETPAR.phi[index];
2604 /**************************************************************************/
2606 Float_t TIsajet::GetXJ(Int_t index) const
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);
2615 return JETPAR.xj[index];
2618 /**************************************************************************/
2620 Float_t TIsajet::GetTH(Int_t index) const
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);
2629 return JETPAR.th[index];
2632 /**************************************************************************/
2634 Float_t TIsajet::GetCTH(Int_t index) const
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);
2643 return JETPAR.cth[index];
2646 /**************************************************************************/
2648 Float_t TIsajet::GetSTH(Int_t index) const
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);
2657 return JETPAR.sth[index];
2660 /**************************************************************************/
2662 Int_t TIsajet::GetJETTYP(Int_t index) const
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);
2671 return JETPAR.jettyp[index];
2674 /**************************************************************************/
2676 Float_t TIsajet::GetSHAT() const
2681 /**************************************************************************/
2683 Float_t TIsajet::GetTHAT() const
2688 /**************************************************************************/
2690 Float_t TIsajet::GetUHAT() const
2695 /**************************************************************************/
2697 Float_t TIsajet::GetQSQ() const
2702 /**************************************************************************/
2704 Float_t TIsajet::GetX1() const
2709 /**************************************************************************/
2711 Float_t TIsajet::GetX2() const
2716 /**************************************************************************/
2718 Float_t TIsajet::GetPBEAM(Int_t index) const
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);
2727 return JETPAR.pbeam[index];
2730 /**************************************************************************/
2732 Float_t TIsajet::GetQMW() const
2737 /**************************************************************************/
2739 Float_t TIsajet::GetQW() const
2744 /**************************************************************************/
2746 Float_t TIsajet::GetQTW() const
2751 /**************************************************************************/
2753 Float_t TIsajet::GetYW() const
2758 /**************************************************************************/
2760 Float_t TIsajet::GetXW() const
2765 /**************************************************************************/
2767 Float_t TIsajet::GetTHW() const
2772 /**************************************************************************/
2774 Float_t TIsajet::GetQTMW() const
2779 /**************************************************************************/
2781 Float_t TIsajet::GetPHIW() const
2786 /**************************************************************************/
2788 Float_t TIsajet::GetSHAT1() const
2790 return JETPAR.shat1;
2793 /**************************************************************************/
2795 Float_t TIsajet::GetTHAT1() const
2797 return JETPAR.that1;
2800 /**************************************************************************/
2802 Float_t TIsajet::GetUHAT1() const
2804 return JETPAR.uhat1;
2807 /**************************************************************************/
2809 void TIsajet::SetJWTYP(Int_t val)
2811 if ((val < 1) || (val > 4) || (val == 2))
2813 printf ("Error in TIsajet::SetJWTYP : \n");
2814 printf ("Invalid value %d; range is 1, 3, and 4.\n", val);
2821 /**************************************************************************/
2823 void TIsajet::SetJWTYP(Char_t val[])
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;
2833 printf ("Error in TIsajet::SetJWTYP : \n");
2834 printf ("Invalid value %s; possible are GM, Z0, W+ and W-.\n", val);
2839 JETPAR.jwtyp = value;
2842 /**************************************************************************/
2844 Int_t TIsajet::GetJWTYP() const
2846 return JETPAR.jwtyp;
2849 /**************************************************************************/
2851 Float_t TIsajet::GetALFQSQ() const
2853 return JETPAR.alfqsq;
2856 /**************************************************************************/
2858 Float_t TIsajet::GetCTHW() const
2863 /**************************************************************************/
2865 Float_t TIsajet::GetSTHW() const
2870 /**************************************************************************/
2872 Float_t TIsajet::GetQ0W() const
2877 /**************************************************************************/
2879 Int_t TIsajet::GetINITYP(Int_t index) const
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);
2888 return JETPAR.inityp[index];
2891 /**************************************************************************/
2893 Int_t TIsajet::GetISIGS() const
2895 return JETPAR.isigs;
2898 /**************************************************************************/
2900 Float_t TIsajet::GetPBEAMS(Int_t index) const
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);
2909 return JETPAR.pbeams[index];
2912 /**************************************************************************/
2914 // Ends JETPAR access.
2915 // Begins KKGRAV access.
2917 /**************************************************************************/
2919 void TIsajet::SetNEXTRAD(Int_t val)
2921 KKGRAV.nextrad = val;
2924 /**************************************************************************/
2926 Int_t TIsajet::GetNEXTRAD() const
2928 return KKGRAV.nextrad;
2931 /**************************************************************************/
2933 void TIsajet::SetMASSD(Float_t val)
2938 /**************************************************************************/
2940 Float_t TIsajet::GetMASSD() const
2942 return KKGRAV.massd;
2945 /**************************************************************************/
2947 Float_t TIsajet::GetKKGSD() const
2949 return KKGRAV.kkgsd;
2952 /**************************************************************************/
2954 Float_t TIsajet::GetSURFD() const
2956 return KKGRAV.surfd;
2959 /**************************************************************************/
2961 void TIsajet::SetUVCUT(Bool_t val)
2966 /**************************************************************************/
2968 Bool_t TIsajet::GetUVCUT() const
2970 return KKGRAV.uvcut;
2973 /**************************************************************************/
2975 // Ends KKGRAV access.
2976 // Begins MBGEN access.
2978 /**************************************************************************/
2980 Float_t TIsajet::GetPOMWT(Int_t index) const
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);
2989 return MBGEN.pomwt[index];
2992 /**************************************************************************/
2994 Float_t TIsajet::GetPOMGEN(Int_t index) const
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);
3003 return MBGEN.pomgen[index];
3006 /**************************************************************************/
3008 void TIsajet::SetMNPOM(Int_t val)
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);
3019 /**************************************************************************/
3021 Int_t TIsajet::GetMNPOM() const
3026 /**************************************************************************/
3028 void TIsajet::SetMXPOM(Int_t val)
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);
3039 /**************************************************************************/
3041 Int_t TIsajet::GetMXPOM() const
3046 /**************************************************************************/
3048 Float_t TIsajet::GetPDIFFR() const
3050 return MBGEN.pdiffr;
3053 /**************************************************************************/
3055 Int_t TIsajet::GetNPOM() const
3060 /**************************************************************************/
3062 Float_t TIsajet::GetXBARY(Int_t index) const
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);
3071 return MBGEN.xbary[index];
3074 /**************************************************************************/
3076 Float_t TIsajet::GetDXBARY(Int_t index) const
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);
3085 return MBGEN.dxbary[index];
3088 /**************************************************************************/
3090 Float_t TIsajet::GetXPOM(Int_t index1, Int_t index2) const
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));
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);
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);
3108 return MBGEN.xpom[index1][index2];
3111 /**************************************************************************/
3113 // Ends MBGEN access.
3114 // Begins MGLIMS access.
3116 /**************************************************************************/
3118 void TIsajet::SetEHMGMN(Float_t val)
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);
3126 MGLIMS.ehmgmn = val;
3129 /**************************************************************************/
3131 Float_t TIsajet::GetEHMGMN() const
3133 return MGLIMS.ehmgmn;
3136 /**************************************************************************/
3138 void TIsajet::SetEHMGMX(Float_t val)
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);
3146 MGLIMS.ehmgmx = val;
3149 /**************************************************************************/
3151 Float_t TIsajet::GetEHMGMX() const
3153 return MGLIMS.ehmgmx;
3156 /**************************************************************************/
3158 Float_t TIsajet::GetYHMGMN() const
3160 return MGLIMS.yhmgmn;
3163 /**************************************************************************/
3165 Float_t TIsajet::GetYHMGMX() const
3167 return MGLIMS.yhmgmx;
3170 /**************************************************************************/
3172 void TIsajet::SetAMIJMN(Float_t val, Int_t index1, Int_t index2)
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));
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);
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);
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]);
3195 MGLIMS.amijmn[index1][index2] = val;
3198 /**************************************************************************/
3200 void TIsajet::SetAllAMIJMN(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
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);
3209 /**************************************************************************/
3211 void TIsajet::SetColumnAMIJMN(const Float_t val[], Int_t col)
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));
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);
3222 for (Int_t i = 0; i < row_num; i++) {
3223 SetAMIJMN(val[i], i, col);
3227 /**************************************************************************/
3229 Float_t TIsajet::GetAMIJMN(Int_t index1, Int_t index2) const
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));
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);
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);
3246 return MGLIMS.amijmn[index1][index2];
3249 /**************************************************************************/
3251 void TIsajet::SetAMIJMX(Float_t val, Int_t index1, Int_t index2)
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));
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);
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);
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]);
3274 MGLIMS.amijmx[index1][index2] = val;
3277 /**************************************************************************/
3279 void TIsajet::SetAllAMIJMX(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
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);
3288 /**************************************************************************/
3290 void TIsajet::SetColumnAMIJMX(const Float_t val[], Int_t col)
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));
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);
3301 for (Int_t i = 0; i < row_num; i++) {
3302 SetAMIJMX(val[i], i, col);
3306 /**************************************************************************/
3308 Float_t TIsajet::GetAMIJMX(Int_t index1, Int_t index2) const
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));
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);
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);
3325 return MGLIMS.amijmx[index1][index2];
3328 /**************************************************************************/
3330 Bool_t TIsajet::GetFIXMIJ(Int_t index1, Int_t index2) const
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));
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);
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);
3348 return MGLIMS.fixmij[index1][index2];
3351 /**************************************************************************/
3353 // Ends MGLIMS access.
3354 // Begins NODCAY access.
3356 /**************************************************************************/
3358 void TIsajet::SetNODCAY(Bool_t val)
3360 NODCAY.nodcay = val;
3364 /**************************************************************************/
3366 Bool_t TIsajet::GetNODCAY() const
3368 return NODCAY.nodcay;
3371 /**************************************************************************/
3373 void TIsajet::SetNOETA(Bool_t val)
3379 /**************************************************************************/
3381 Bool_t TIsajet::GetNOETA() const
3383 return NODCAY.noeta;
3386 /**************************************************************************/
3388 void TIsajet::SetNOPI0(Bool_t val)
3394 /**************************************************************************/
3396 Bool_t TIsajet::GetNOPI0() const
3398 return NODCAY.nopi0;
3401 /**************************************************************************/
3403 void TIsajet::SetNONUNU(Bool_t val)
3405 NODCAY.nonunu = val;
3408 /**************************************************************************/
3410 Bool_t TIsajet::GetNONUNU() const
3412 return NODCAY.nonunu;
3415 /**************************************************************************/
3417 void TIsajet::SetNOEVOL(Bool_t val)
3419 NODCAY.noevol = val;
3423 /**************************************************************************/
3425 Bool_t TIsajet::GetNOEVOL() const
3427 return NODCAY.noevol;
3430 /**************************************************************************/
3432 void TIsajet::SetNOHADR(Bool_t val)
3434 NODCAY.nohadr = val;
3438 /**************************************************************************/
3440 Bool_t TIsajet::GetNOHADR() const
3442 return NODCAY.nohadr;
3445 /**************************************************************************/
3447 void TIsajet::SetNOGRAV(Bool_t val)
3449 NODCAY.nograv = val;
3452 /**************************************************************************/
3454 Bool_t TIsajet::GetNOGRAV() const
3456 return NODCAY.nograv;
3459 /**************************************************************************/
3461 // Ends NODCAY access.
3462 // Begins PARTCL access.
3464 /**************************************************************************/
3466 Int_t TIsajet::GetNPTCL() const
3468 return PARTCL.nptcl;
3471 /**************************************************************************/
3473 Float_t TIsajet::GetPX(Int_t index) const
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);
3481 return PARTCL.pptcl[index][0];
3484 /**************************************************************************/
3486 Float_t TIsajet::GetPY(Int_t index) const
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);
3494 return PARTCL.pptcl[index][1];
3497 /**************************************************************************/
3499 Float_t TIsajet::GetPZ(Int_t index) const
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);
3507 return PARTCL.pptcl[index][2];
3510 /**************************************************************************/
3512 Float_t TIsajet::GetP0(Int_t index) const
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);
3520 return PARTCL.pptcl[index][3];
3523 /**************************************************************************/
3525 Float_t TIsajet::GetMASS(Int_t index) const
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);
3533 return PARTCL.pptcl[index][4];
3536 /**************************************************************************/
3538 Float_t TIsajet::GetORIG(Int_t index) const
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);
3546 return PARTCL.iorig[index];
3549 /**************************************************************************/
3551 Float_t TIsajet::GetIDENT(Int_t index) const
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);
3559 return PARTCL.ident[index];
3562 /**************************************************************************/
3564 Float_t TIsajet::GetIDCAY(Int_t index) const
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);
3572 return PARTCL.idcay[index];
3575 /**************************************************************************/
3577 // Ends PARTCL access.
3578 // Begins PRIMAR access.
3580 /**************************************************************************/
3582 Int_t TIsajet::GetNJET() const
3587 /**************************************************************************/
3589 Float_t TIsajet::GetSCM() const
3594 /**************************************************************************/
3596 Float_t TIsajet::GetHALFE() const
3598 return PRIMAR.halfe;
3601 /**************************************************************************/
3603 void TIsajet::SetECM(Float_t val)
3606 printf ("Error in TIsajet::SetECM :\n");
3607 printf ("Cannot set energy to a negative value.\n");
3612 PRIMAR.scm = val*val;
3613 PRIMAR.halfe = val / 2;
3616 /**************************************************************************/
3618 Float_t TIsajet::GetECM() const
3623 /**************************************************************************/
3625 void TIsajet::SetIDIN(Int_t val, Int_t index)
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);
3634 if ((val = 1120) || (val = 1220) || (val = -1120) || (val = -1220)) {
3635 PRIMAR.idin[index] = val;
3638 printf ("Error in TIsajet::SetIDIN : \n");
3639 printf ("Invalid input value %d. Possible values are 1120, 1220, -1120, -1220.\n", val);
3646 /**************************************************************************/
3648 void TIsajet::SetIDIN(const Char_t val[], Int_t index)
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);
3657 if (!strcmp("P", val)) {
3658 PRIMAR.idin[index] = 1120;
3660 else if (!strcmp("AP", val)) {
3661 PRIMAR.idin[index] = -1120;
3663 else if (!strcmp("N", val)) {
3664 PRIMAR.idin[index] = 1220;
3666 else if (!strcmp("AN", val)) {
3667 PRIMAR.idin[index] = -1220;
3670 printf ("Error in TIsajet::SetIDIN : \n");
3671 printf ("Invalid input string %s. Possible strings are P, AP, N, and AN.\n", val);
3676 /**************************************************************************/
3678 Int_t TIsajet::GetIDIN(Int_t index) const
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);
3687 return PRIMAR.idin[index];
3690 /**************************************************************************/
3692 Int_t TIsajet::GetNEVENT() const
3694 return PRIMAR.nevent;
3697 /**************************************************************************/
3699 void TIsajet::SetNTRIES(Int_t val)
3701 PRIMAR.ntries = val;
3704 /**************************************************************************/
3706 Int_t TIsajet::GetNTRIES() const
3708 return PRIMAR.ntries;
3711 /**************************************************************************/
3713 void TIsajet::SetNSIGMA(Int_t val)
3715 PRIMAR.nsigma = val;
3719 /**************************************************************************/
3721 Int_t TIsajet::GetNSIGMA() const
3723 return PRIMAR.nsigma;
3726 /**************************************************************************/
3728 // Ends PRIMAR access.
3729 // Begins QCDPAR access.
3731 /**************************************************************************/
3733 void TIsajet::SetALAM(Float_t val)
3736 QCDPAR.alam2 = val*val;
3740 /**************************************************************************/
3742 Float_t TIsajet::GetALAM() const
3747 /**************************************************************************/
3749 Float_t TIsajet::GetALAM2() const
3751 return QCDPAR.alam2;
3754 /**************************************************************************/
3756 void TIsajet::SetCUTJET(Float_t val)
3758 QCDPAR.cutjet = val;
3762 /**************************************************************************/
3764 Float_t TIsajet::GetCUTJET() const
3766 return QCDPAR.cutjet;
3769 /**************************************************************************/
3771 void TIsajet::SetISTRUC(Int_t val)
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);
3778 QCDPAR.istruc = val;
3781 /**************************************************************************/
3783 void TIsajet::SetISTRUC(const Char_t val[])
3785 if (!strcmp("OWENS", val)) {
3788 else if (!strcmp("BAIER", val)) {
3791 else if ((!strcmp("EICHTEN", val)) || (!strcmp("EHLQ", val))) {
3794 else if ((!strcmp("DUKE", val)) || (!strcmp("DO", val))) {
3797 else if (!strcmp("CTEQ2L", val)) {
3800 else if ((!strcmp("CTEQ", val)) || (!strcmp("CTEQ3L", val))) {
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");
3811 /**************************************************************************/
3813 Int_t TIsajet::GetISTRUC() const
3815 return QCDPAR.istruc;
3818 /**************************************************************************/
3820 // Ends QCDPAR access.
3821 // Begins QLMASS access.
3823 /**************************************************************************/
3825 void TIsajet::SetAMLEP(Float_t val, Int_t index)
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);
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)))
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");
3846 QLMASS.amlep[index] = val;
3849 /**************************************************************************/
3851 Float_t TIsajet::GetAMLEP(Int_t index) const
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);
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)))
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");
3873 return QLMASS.amlep[index];
3876 /**************************************************************************/
3878 Float_t TIsajet::GetAnyAMLEP(Int_t index) const
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);
3887 return QLMASS.amlep[index];
3890 /**************************************************************************/
3892 void TIsajet::SetTquarkMass(Float_t val)
3894 QLMASS.amlep[5] = val;
3897 /**************************************************************************/
3899 Float_t TIsajet::GetTquarkMass() const
3901 return QLMASS.amlep[5];
3904 /**************************************************************************/
3906 void TIsajet::SetXquarkMass(Float_t val)
3908 QLMASS.amlep[6] = val;
3911 /**************************************************************************/
3913 Float_t TIsajet::GetXquarkMass() const
3915 return QLMASS.amlep[6];
3918 /**************************************************************************/
3920 void TIsajet::SetYquarkMass(Float_t val)
3922 QLMASS.amlep[7] = val;
3925 /**************************************************************************/
3927 Float_t TIsajet::GetYquarkMass() const
3929 return QLMASS.amlep[7];
3932 /**************************************************************************/
3934 void TIsajet::SetUtildeMass(Float_t val)
3936 QLMASS.amlep[21] = val;
3939 /**************************************************************************/
3941 Float_t TIsajet::GetUtildeMass() const
3943 return QLMASS.amlep[21];
3946 /**************************************************************************/
3948 void TIsajet::SetDtildeMass(Float_t val)
3950 QLMASS.amlep[22] = val;
3953 /**************************************************************************/
3955 Float_t TIsajet::GetDtildeMass() const
3957 return QLMASS.amlep[22];
3960 /**************************************************************************/
3962 void TIsajet::SetStildeMass(Float_t val)
3964 QLMASS.amlep[23] = val;
3967 /**************************************************************************/
3969 Float_t TIsajet::GetStildeMass() const
3971 return QLMASS.amlep[23];
3974 /**************************************************************************/
3976 void TIsajet::SetCtildeMass(Float_t val)
3978 QLMASS.amlep[24] = val;
3981 /**************************************************************************/
3983 Float_t TIsajet::GetCtildeMass() const
3985 return QLMASS.amlep[24];
3988 /**************************************************************************/
3990 void TIsajet::SetBtildeMass(Float_t val)
3992 QLMASS.amlep[25] = val;
3995 /**************************************************************************/
3997 Float_t TIsajet::GetBtildeMass() const
3999 return QLMASS.amlep[25];
4002 /**************************************************************************/
4004 void TIsajet::SetTtildeMass(Float_t val)
4006 QLMASS.amlep[26] = val;
4009 /**************************************************************************/
4011 Float_t TIsajet::GetTtildeMass() const
4013 return QLMASS.amlep[26];
4016 /**************************************************************************/
4018 void TIsajet::SetGtildeMass(Float_t val)
4020 QLMASS.amlep[29] = val;
4023 /**************************************************************************/
4025 Float_t TIsajet::GetGtildeMass() const
4027 return QLMASS.amlep[29];
4030 /**************************************************************************/
4032 void TIsajet::SetGammatildeMass(Float_t val)
4034 QLMASS.amlep[30] = val;
4037 /**************************************************************************/
4039 Float_t TIsajet::GetGammatildeMass() const
4041 return QLMASS.amlep[30];
4044 /**************************************************************************/
4046 void TIsajet::SetNuEtildeMass(Float_t val)
4048 QLMASS.amlep[31] = val;
4051 /**************************************************************************/
4053 Float_t TIsajet::GetNuEtildeMass() const
4055 return QLMASS.amlep[31];
4058 /**************************************************************************/
4060 void TIsajet::SetEtildeMass(Float_t val)
4062 QLMASS.amlep[32] = val;
4065 /**************************************************************************/
4067 Float_t TIsajet::GetEtildeMass() const
4069 return QLMASS.amlep[32];
4072 /**************************************************************************/
4074 void TIsajet::SetNuMutildeMass(Float_t val)
4076 QLMASS.amlep[33] = val;
4079 /**************************************************************************/
4081 Float_t TIsajet::GetNuMutildeMass() const
4083 return QLMASS.amlep[33];
4086 /**************************************************************************/
4088 void TIsajet::SetMutildeMass(Float_t val)
4090 QLMASS.amlep[34] = val;
4093 /**************************************************************************/
4095 Float_t TIsajet::GetMutildeMass() const
4097 return QLMASS.amlep[34];
4100 /**************************************************************************/
4102 void TIsajet::SetNuTautildeMass(Float_t val)
4104 QLMASS.amlep[35] = val;
4107 /**************************************************************************/
4109 Float_t TIsajet::GetNuTautildeMass() const
4111 return QLMASS.amlep[35];
4114 /**************************************************************************/
4116 void TIsajet::SetTautildeMass(Float_t val)
4118 QLMASS.amlep[36] = val;
4121 /**************************************************************************/
4123 Float_t TIsajet::GetTautildeMass() const
4125 return QLMASS.amlep[36];
4128 /**************************************************************************/
4130 void TIsajet::SetWplustildeMass(Float_t val)
4132 QLMASS.amlep[39] = val;
4135 /**************************************************************************/
4137 Float_t TIsajet::GetWplustildeMass() const
4139 return QLMASS.amlep[39];
4142 /**************************************************************************/
4144 void TIsajet::SetZ0tildeMass(Float_t val)
4146 QLMASS.amlep[40] = val;
4149 /**************************************************************************/
4151 Float_t TIsajet::GetZ0tildeMass() const
4153 return QLMASS.amlep[40];
4156 /**************************************************************************/
4158 void TIsajet::SetHiggsMesonMass(Float_t val, Int_t index)
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);
4166 QLMASS.amlep[62 + index] = val;
4169 /**************************************************************************/
4171 Float_t TIsajet::GetHiggsMesonMass(Int_t index) const
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);
4179 return QLMASS.amlep[62 + index];
4182 /**************************************************************************/
4184 Int_t TIsajet::GetNQLEP() const
4186 return QLMASS.nqlep;
4189 /**************************************************************************/
4191 Int_t TIsajet::GetNMES() const
4196 /**************************************************************************/
4198 Int_t TIsajet::GetNBARY() const
4200 return QLMASS.nbary;
4203 /**************************************************************************/
4205 // Ends QLMASS access.
4206 // Begins SEED access.
4208 /**************************************************************************/
4210 void TIsajet::SetSEED(const Char_t val[24])
4212 Int_t length = (sizeof SEED.xseed / sizeof SEED.xseed[0]);
4214 for (Int_t i = 0; i < length; i++) {
4215 SEED.xseed[i] = val[i];
4219 /**************************************************************************/
4221 Char_t* TIsajet::GetSEED() const
4226 /**************************************************************************/
4228 // Ends SEED access - short and sweet, wasn't it?
4229 // Begins SUGNU access, an entirely different business.
4231 /**************************************************************************/
4233 void TIsajet::SetXNUSUG(Float_t val, Int_t index)
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);
4242 SUGNU.xnusug[index] = val;
4245 /**************************************************************************/
4247 Float_t TIsajet::GetXNUSUG(Int_t index) const
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);
4256 return SUGNU.xnusug[index];
4259 /**************************************************************************/
4261 void TIsajet::SetGauginoMass(Float_t val, Int_t index)
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);
4269 SUGNU.xnusug[index-1] = val;
4272 /**************************************************************************/
4274 Float_t TIsajet::GetGauginoMass(Int_t index) const
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);
4282 return SUGNU.xnusug[index-1];
4285 /**************************************************************************/
4287 void TIsajet::SetAtau(Float_t val)
4289 SUGNU.xnusug[3] = val;
4292 /**************************************************************************/
4294 Float_t TIsajet::GetAtau() const
4296 return SUGNU.xnusug[3];
4299 /**************************************************************************/
4301 void TIsajet::SetAb(Float_t val)
4303 SUGNU.xnusug[4] = val;
4306 /**************************************************************************/
4308 Float_t TIsajet::GetAb() const
4310 return SUGNU.xnusug[4];
4313 /**************************************************************************/
4315 void TIsajet::SetAt(Float_t val)
4317 SUGNU.xnusug[5] = val;
4320 /**************************************************************************/
4322 Float_t TIsajet::GetAt() const
4324 return SUGNU.xnusug[5];
4327 /**************************************************************************/
4329 void TIsajet::SetHiggsDmass(Float_t val)
4331 SUGNU.xnusug[6] = val;
4334 /**************************************************************************/
4336 Float_t TIsajet::GetHiggsDmass() const
4338 return SUGNU.xnusug[6];
4341 /**************************************************************************/
4343 void TIsajet::SetHiggsUmass(Float_t val)
4345 SUGNU.xnusug[7] = val;
4348 /**************************************************************************/
4350 Float_t TIsajet::GetHiggsUmass() const
4352 return SUGNU.xnusug[7];
4355 /**************************************************************************/
4357 void TIsajet::SetERmass(Float_t val)
4359 SUGNU.xnusug[8] = val;
4362 /**************************************************************************/
4364 Float_t TIsajet::GetERmass() const
4366 return SUGNU.xnusug[8];
4369 /**************************************************************************/
4371 void TIsajet::SetELmass(Float_t val)
4373 SUGNU.xnusug[9] = val;
4376 /**************************************************************************/
4378 Float_t TIsajet::GetELmass() const
4380 return SUGNU.xnusug[9];
4383 /**************************************************************************/
4385 void TIsajet::SetDRmass(Float_t val)
4387 SUGNU.xnusug[10] = val;
4390 /**************************************************************************/
4392 Float_t TIsajet::GetDRmass() const
4394 return SUGNU.xnusug[10];
4397 /**************************************************************************/
4399 void TIsajet::SetURmass(Float_t val)
4401 SUGNU.xnusug[11] = val;
4404 /**************************************************************************/
4406 Float_t TIsajet::GetURmass() const
4408 return SUGNU.xnusug[11];
4411 /**************************************************************************/
4413 void TIsajet::SetULmass(Float_t val)
4415 SUGNU.xnusug[12] = val;
4418 /**************************************************************************/
4420 Float_t TIsajet::GetULmass() const
4422 return SUGNU.xnusug[12];
4425 /**************************************************************************/
4427 void TIsajet::SetTauRmass(Float_t val)
4429 SUGNU.xnusug[13] = val;
4432 /**************************************************************************/
4434 Float_t TIsajet::GetTauRmass() const
4436 return SUGNU.xnusug[13];
4439 /**************************************************************************/
4441 void TIsajet::SetTauLmass(Float_t val)
4443 SUGNU.xnusug[14] = val;
4446 /**************************************************************************/
4448 Float_t TIsajet::GetTauLmass() const
4450 return SUGNU.xnusug[14];
4453 /**************************************************************************/
4455 void TIsajet::SetBRmass(Float_t val)
4457 SUGNU.xnusug[15] = val;
4460 /**************************************************************************/
4462 Float_t TIsajet::GetBRmass() const
4464 return SUGNU.xnusug[15];
4467 /**************************************************************************/
4469 void TIsajet::SetTRmass(Float_t val)
4471 SUGNU.xnusug[16] = val;
4474 /**************************************************************************/
4476 Float_t TIsajet::GetTRmass() const
4478 return SUGNU.xnusug[16];
4481 /**************************************************************************/
4483 void TIsajet::SetTLmass(Float_t val)
4485 SUGNU.xnusug[17] = val;
4488 /**************************************************************************/
4490 Float_t TIsajet::GetTLmass() const
4492 return SUGNU.xnusug[17];
4495 /**************************************************************************/
4497 // Ends XNUSUG access.
4498 // Begins TCPAR access.
4500 /**************************************************************************/
4502 void TIsajet::SetTCMRHO(Float_t val)
4507 /**************************************************************************/
4509 Float_t TIsajet::GetTCMRHO() const
4511 return TCPAR.tcmrho;
4514 /**************************************************************************/
4516 void TIsajet::SetTCGRHO(Float_t val)
4521 /**************************************************************************/
4523 Float_t TIsajet::GetTCGRHO() const
4525 return TCPAR.tcgrho;
4528 /**************************************************************************/
4530 // Ends TCPAR access.
4531 // Begins TYPES access.
4533 /**************************************************************************/
4535 Int_t TIsajet::GetLOC(Int_t index) const
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);
4544 return TYPES.loc[index];
4547 /**************************************************************************/
4549 Int_t TIsajet::GetNTYP() const
4554 /**************************************************************************/
4556 Int_t TIsajet::GetNJTTYP(Int_t index) const
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);
4565 return TYPES.njttyp[index];
4568 /**************************************************************************/
4570 Int_t TIsajet::GetNWWTYP(Int_t index) const
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);
4579 return TYPES.nwwtyp[index];
4582 /**************************************************************************/
4584 Int_t TIsajet::GetNWMODE(Int_t index) const
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);
4593 return TYPES.nwmode[index];
4596 /**************************************************************************/
4598 // Ends TYPES access.
4599 // Begins XMSSM access.
4601 /**************************************************************************/
4603 Bool_t TIsajet::GetGOMSSM() const
4605 return XMSSM.gomssm;
4608 /**************************************************************************/
4610 Bool_t TIsajet::GetGOSUG() const
4615 /**************************************************************************/
4617 Bool_t TIsajet::GetGOGMSB() const
4619 return XMSSM.gogmsb;
4622 /**************************************************************************/
4624 Bool_t TIsajet::GetGOAMSB() const
4626 return XMSSM.goamsb;
4629 /**************************************************************************/
4631 Bool_t TIsajet::GetAL3UNI() const
4633 return XMSSM.al3uni;
4636 /**************************************************************************/
4638 void TIsajet::SetXGLSS(Float_t val)
4643 /**************************************************************************/
4645 Float_t TIsajet::GetXGLSS() const
4650 /**************************************************************************/
4652 void TIsajet::SetXMUSS(Float_t val)
4657 /**************************************************************************/
4659 Float_t TIsajet::GetXMUSS() const
4664 /**************************************************************************/
4666 void TIsajet::SetXHASS(Float_t val)
4671 /**************************************************************************/
4673 Float_t TIsajet::GetXHASS() const
4678 /**************************************************************************/
4680 void TIsajet::SetXTBSS(Float_t val)
4685 /**************************************************************************/
4687 Float_t TIsajet::GetXTBSS() const
4692 /**************************************************************************/
4694 void TIsajet::SetXQ1SS(Float_t val)
4699 /**************************************************************************/
4701 Float_t TIsajet::GetXQ1SS() const
4706 /**************************************************************************/
4708 void TIsajet::SetXDRSS(Float_t val)
4713 /**************************************************************************/
4715 Float_t TIsajet::GetXDRSS() const
4720 /**************************************************************************/
4722 void TIsajet::SetXURSS(Float_t val)
4727 /**************************************************************************/
4729 Float_t TIsajet::GetXURSS() const
4734 /**************************************************************************/
4736 void TIsajet::SetXL1SS(Float_t val)
4741 /**************************************************************************/
4743 Float_t TIsajet::GetXL1SS() const
4748 /**************************************************************************/
4750 void TIsajet::SetXERSS(Float_t val)
4755 /**************************************************************************/
4757 Float_t TIsajet::GetXERSS() const
4762 /**************************************************************************/
4764 void TIsajet::SetXQ2SS(Float_t val)
4769 /**************************************************************************/
4771 Float_t TIsajet::GetXQ2SS() const
4776 /**************************************************************************/
4778 void TIsajet::SetXSRSS(Float_t val)
4783 /**************************************************************************/
4785 Float_t TIsajet::GetXSRSS() const
4790 /**************************************************************************/
4792 void TIsajet::SetXCRSS(Float_t val)
4797 /**************************************************************************/
4799 Float_t TIsajet::GetXCRSS() const
4804 /**************************************************************************/
4806 void TIsajet::SetXL2SS(Float_t val)
4811 /**************************************************************************/
4813 Float_t TIsajet::GetXL2SS() const
4818 /**************************************************************************/
4820 void TIsajet::SetXMRSS(Float_t val)
4825 /**************************************************************************/
4827 Float_t TIsajet::GetXMRSS() const
4832 /**************************************************************************/
4834 void TIsajet::SetXQ3SS(Float_t val)
4839 /**************************************************************************/
4841 Float_t TIsajet::GetXQ3SS() const
4846 /**************************************************************************/
4848 void TIsajet::SetXBRSS(Float_t val)
4853 /**************************************************************************/
4855 Float_t TIsajet::GetXBRSS() const
4860 /**************************************************************************/
4862 void TIsajet::SetXTRSS(Float_t val)
4867 /**************************************************************************/
4869 Float_t TIsajet::GetXTRSS() const
4874 /**************************************************************************/
4876 void TIsajet::SetXL3SS(Float_t val)
4881 /**************************************************************************/
4883 Float_t TIsajet::GetXL3SS() const
4888 /**************************************************************************/
4890 void TIsajet::SetXTARSS(Float_t val)
4895 /**************************************************************************/
4897 Float_t TIsajet::GetXTARSS() const
4899 return XMSSM.xtarss;
4902 /**************************************************************************/
4904 void TIsajet::SetXATSS(Float_t val)
4909 /**************************************************************************/
4911 Float_t TIsajet::GetXATSS() const
4916 /**************************************************************************/
4918 void TIsajet::SetXABSS(Float_t val)
4923 /**************************************************************************/
4925 Float_t TIsajet::GetXABSS() const
4930 /**************************************************************************/
4932 void TIsajet::SetXATASS(Float_t val)
4937 /**************************************************************************/
4939 Float_t TIsajet::GetXATASS() const
4941 return XMSSM.xatass;
4944 /**************************************************************************/
4946 void TIsajet::SetXM1SS(Float_t val)
4951 /**************************************************************************/
4953 Float_t TIsajet::GetXM1SS() const
4958 /**************************************************************************/
4960 void TIsajet::SetXM2SS(Float_t val)
4965 /**************************************************************************/
4967 Float_t TIsajet::GetXM2SS() const
4972 /**************************************************************************/
4974 void TIsajet::SetXM0SU(Float_t val)
4979 /**************************************************************************/
4981 Float_t TIsajet::GetXM0SU() const
4986 /**************************************************************************/
4988 void TIsajet::SetXMHSU(Float_t val)
4993 /**************************************************************************/
4995 Float_t TIsajet::GetXMHSU() const
5000 /**************************************************************************/
5002 void TIsajet::SetXA0SU(Float_t val)
5007 /**************************************************************************/
5009 Float_t TIsajet::GetXA0SU() const
5014 /**************************************************************************/
5016 void TIsajet::SetXTGBSU(Float_t val)
5021 /**************************************************************************/
5023 Float_t TIsajet::GetXTGBSU() const
5025 return XMSSM.xtgbsu;
5028 /**************************************************************************/
5030 void TIsajet::SetXSMUSU(Float_t val)
5035 /**************************************************************************/
5037 Float_t TIsajet::GetXSMUSU() const
5039 return XMSSM.xsmusu;
5042 /**************************************************************************/
5044 void TIsajet::SetXLAMGM(Float_t val)
5049 /**************************************************************************/
5051 Float_t TIsajet::GetXLAMGM() const
5053 return XMSSM.xlamgm;
5056 /**************************************************************************/
5058 void TIsajet::SetXMESGM(Float_t val)
5063 /**************************************************************************/
5065 Float_t TIsajet::GetXMESGM() const
5067 return XMSSM.xmesgm;
5070 /**************************************************************************/
5072 void TIsajet::SetXN5GM(Float_t val)
5077 /**************************************************************************/
5079 Float_t TIsajet::GetXN5GM() const
5084 /**************************************************************************/
5086 void TIsajet::SetXCMGV(Float_t val)
5091 /**************************************************************************/
5093 Float_t TIsajet::GetXCMGV() const
5098 /**************************************************************************/
5100 void TIsajet::SetMGVTO(Float_t val)
5105 /**************************************************************************/
5107 Float_t TIsajet::GetMGVTO() const
5112 /**************************************************************************/
5114 void TIsajet::SetXRSLGM(Float_t val)
5119 /**************************************************************************/
5121 Float_t TIsajet::GetXRSLGM() const
5123 return XMSSM.xrslgm;
5126 /**************************************************************************/
5128 void TIsajet::SetXDHDGM(Float_t val)
5133 /**************************************************************************/
5135 Float_t TIsajet::GetXDHDGM() const
5137 return XMSSM.xdhdgm;
5140 /**************************************************************************/
5142 void TIsajet::SetXDHUGM(Float_t val)
5147 /**************************************************************************/
5149 Float_t TIsajet::GetXDHUGM() const
5151 return XMSSM.xdhugm;
5154 /**************************************************************************/
5156 void TIsajet::SetXDYGM(Float_t val)
5161 /**************************************************************************/
5163 Float_t TIsajet::GetXDYGM() const
5168 /**************************************************************************/
5170 void TIsajet::SetXN51GM(Float_t val)
5175 /**************************************************************************/
5177 Float_t TIsajet::GetXN51GM() const
5179 return XMSSM.xn51gm;
5182 /**************************************************************************/
5184 void TIsajet::SetXN52GM(Float_t val)
5189 /**************************************************************************/
5191 Float_t TIsajet::GetXN52GM() const
5193 return XMSSM.xn52gm;
5196 /**************************************************************************/
5198 void TIsajet::SetXN53GM(Float_t val)
5203 /**************************************************************************/
5205 Float_t TIsajet::GetXN53GM() const
5207 return XMSSM.xn53gm;
5210 /**************************************************************************/
5212 void TIsajet::SetXMN3NR(Float_t val)
5217 /**************************************************************************/
5219 Float_t TIsajet::GetXMN3NR() const
5221 return XMSSM.xmn3nr;
5224 /**************************************************************************/
5226 void TIsajet::SetXMAJNR(Float_t val)
5231 /**************************************************************************/
5233 Float_t TIsajet::GetXMAJNR() const
5235 return XMSSM.xmajnr;
5238 /**************************************************************************/
5240 void TIsajet::SetXANSS(Float_t val)
5245 /**************************************************************************/
5247 Float_t TIsajet::GetXANSS() const
5252 /**************************************************************************/
5254 void TIsajet::SetXNRSS(Float_t val)
5259 /**************************************************************************/
5261 Float_t TIsajet::GetXNRSS() const
5266 /**************************************************************************/
5268 void TIsajet::SetXSBCS(Float_t val)
5273 /**************************************************************************/
5275 Float_t TIsajet::GetXSBCS() const
5280 /**************************************************************************/
5282 // Ends XMSSM access.
5283 // Begins XTYPES access.
5285 /**************************************************************************/
5287 Char_t* TIsajet::GetPARTYP(Int_t index) const
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);
5296 return XTYPES.partyp[index];
5299 /**************************************************************************/
5301 void TIsajet::SetTITLE(Char_t *val)
5303 title = XTYPES.title = val;
5306 /**************************************************************************/
5307 Char_t* TIsajet::GetTITLE() const
5309 return XTYPES.title;
5312 /**************************************************************************/
5314 void TIsajet::SetJETYP(Int_t index, Char_t val[])
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));
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);
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);
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"))) {
5347 XTYPES.jetyp[index][TYPES.njttyp[index]++] = val;
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");
5359 if (index == 0) setJettype1 = true;
5360 else if (index == 1) setJettype2 = true;
5361 else if (index == 2) setJettype3 = true;
5364 /**************************************************************************/
5366 Char_t* TIsajet::GetJETYP(Int_t index1, Int_t index2) const
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));
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);
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);
5383 return XTYPES.jetyp[index1][index2];
5386 /**************************************************************************/
5388 void TIsajet::SetWWTYP(Char_t val[], Int_t index1, Int_t index2)
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));
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);
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);
5405 XTYPES.wwtyp[index1][index2] = val;
5408 /**************************************************************************/
5410 void TIsajet::SetAllWWTYP(Char_t* val[2][30])
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);
5419 /**************************************************************************/
5421 void TIsajet::SetColumnWWTYP(Char_t* val[], Int_t col)
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));
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);
5432 for (Int_t i = 0; i < row_num; i++) {
5433 SetWWTYP(val[i], i, col);
5437 /**************************************************************************/
5439 Char_t* TIsajet::GetWWTYP(Int_t index1, Int_t index2) const
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));
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);
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);
5456 return XTYPES.wwtyp[index1][index2];
5459 /**************************************************************************/
5461 void TIsajet::SetWMODES(Char_t val[], Int_t index1, Int_t index2)
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));
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);
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);
5478 XTYPES.wmodes[index1][index2] = val;
5481 /**************************************************************************/
5483 void TIsajet::SetAllWMODES(Char_t* val[2][30])
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);
5492 /**************************************************************************/
5494 void TIsajet::SetColumnWMODES(Char_t* val[], Int_t col)
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));
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);
5505 for (Int_t i = 0; i < row_num; i++) {
5506 SetWMODES(val[i], i, col);
5510 /**************************************************************************/
5512 Char_t* TIsajet::GetWMODES(Int_t index1, Int_t index2) const
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));
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);
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);
5529 return XTYPES.wmodes[index1][index2];
5532 /**************************************************************************/
5534 // Ends XTYPES access.
5535 // Begins WCON access.
5537 /**************************************************************************/
5539 void TIsajet::SetSIN2W(Float_t val)
5544 /**************************************************************************/
5546 Float_t TIsajet::GetSIN2W() const
5551 /**************************************************************************/
5553 void TIsajet::SetWMASS(Float_t w, Float_t z)
5556 // This is how the FORTRAN does it. Don't ask me why.
5559 WCON.wmass[1] = WCON.wmass[2] = w;
5563 /**************************************************************************/
5565 Float_t TIsajet::GetWMASS(Int_t index) const
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);
5574 return WCON.wmass[index];
5577 /**************************************************************************/
5579 void TIsajet::SetWMass(Float_t val)
5581 WCON.wmass[1] = WCON.wmass[2] = val;
5584 /**************************************************************************/
5586 void TIsajet::SetZMass(Float_t val)
5588 WCON.wmass[3] = val;
5591 /**************************************************************************/
5593 Float_t TIsajet::GetWGAM(Int_t index) const
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);
5602 return WCON.wgam[index];
5605 /**************************************************************************/
5607 Float_t TIsajet::GetAQ(Int_t index1, Int_t index2) const
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));
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);
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);
5624 return WCON.aq[index1][index2];
5627 /**************************************************************************/
5629 Float_t TIsajet::GetBQ(Int_t index1, Int_t index2) const
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));
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);
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);
5646 return WCON.bq[index1][index2];
5649 /**************************************************************************/
5651 Float_t TIsajet::GetCOUT(Int_t index) const
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);
5660 return WCON.cout[index];
5663 /**************************************************************************/
5665 Int_t TIsajet::GetMATCH() const
5670 /**************************************************************************/
5672 Float_t TIsajet::GetWCBR(Int_t index1, Int_t index2) const
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));
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);
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);
5689 return WCON.wcbr[index1][index2];
5692 /**************************************************************************/
5694 void TIsajet::SetCUTOFF(Float_t val)
5699 /**************************************************************************/
5701 Float_t TIsajet::GetCUTOFF() const
5706 /**************************************************************************/
5708 void TIsajet::SetCUTPOW(Float_t val)
5713 /**************************************************************************/
5715 Float_t TIsajet::GetCUTPOW() const
5720 /**************************************************************************/
5722 Float_t TIsajet::GetTBRWW(Int_t index1, Int_t index2) const
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));
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);
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);
5739 return WCON.tbrww[index1][index2];
5742 /**************************************************************************/
5744 Float_t TIsajet::GetRBRWW(Int_t index1, Int_t index2, Int_t index3) const
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));
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);
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);
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);
5769 return WCON.rbrww[index1][index2][index3];
5773 /**************************************************************************/
5775 Float_t TIsajet::GetEZ() const
5780 /**************************************************************************/
5782 Float_t TIsajet::GetAQDP(Int_t index1, Int_t index2) const
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));
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);
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);
5799 return WCON.aqdp[index1][index2];
5802 /**************************************************************************/
5804 Float_t TIsajet::GetBQDP(Int_t index1, Int_t index2) const
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));
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);
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);
5821 return WCON.bqdp[index1][index2];
5824 /**************************************************************************/
5826 Float_t TIsajet::GetEZDP() const
5831 /**************************************************************************/
5833 void TIsajet::SetWFUDGE(Float_t val)
5838 /**************************************************************************/
5840 Float_t TIsajet::GetWFUDGE() const
5845 /**************************************************************************/
5847 // Ends WCON access.
5850 # define isaini isaini_
5851 # define isaevt isaevt_
5852 # define isabeg isabeg_
5853 # define isabg2 isabg2_
5854 # define openfiles openfiles_
5855 # define pdfinit pdfinit_
5857 # define type_of_call
5859 # define isaini ISAINI
5860 # define isaevt ISAEVT
5861 # define isabeg ISABEG
5862 # define isabg2 ISABG2
5863 # define openfiles OPENFILES
5864 # define pdfinit PDFINIT
5866 # define type_of_call _stdcall
5869 extern "C" void type_of_call isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n);
5870 extern "C" void type_of_call isaevt(Int_t& j, Int_t& k, Int_t& m);
5871 extern "C" void type_of_call openfiles();
5872 extern "C" void type_of_call pdfinit(Int_t &, Int_t &);
5873 extern "C" void type_of_call isabeg(Int_t& ifl);
5874 extern "C" void type_of_call isabg2(Int_t& ifl);
5876 void TIsajet::Isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n)
5881 void TIsajet::Isaevt(Int_t& j, Int_t& k, Int_t& m)
5886 void TIsajet::Openfiles()
5891 void TIsajet::PDFinit(Int_t& pdfpar, Int_t& pdfval )
5893 pdfinit(pdfpar, pdfval);
5896 void TIsajet::Isabeg(Int_t& ifl)
5901 void TIsajet::Isabg2(Int_t& ifl)
5907 Double_t type_of_call ranf(Int_t & /*idum*/)
5910 do r=sRandom->Rndm(); while(0 >= r || r >= 1);