12 /**************************************************************************/
14 TIsajet::TIsajet() : TGenerator("Isajet", "Isajet")
16 // Default constructor
18 if (!sRandom) sRandom=fRandom;
20 // Initialising equivalence structures in FRGPAR :
21 // EQUIVALENCE (PMIX1(1,1),PMIXX1(1))
22 // EQUIVALENCE (PMIX2(1,1),PMIXX2(1))
23 // EQUIVALENCE (FRPAR(1),PUD)
25 FRGPAR.pmixx1[0] = &FRGPAR.pmix1[0][0];
26 FRGPAR.pmixx2[0] = &FRGPAR.pmix2[0][0];
27 FRGPAR.frpar[0] = &FRGPAR.pud;
29 for (Int_t i = 1; i < 6; i++) {
30 FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
31 FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
34 for (Int_t i = 1; i < 32; i++) {
35 FRGPAR.frpar[i] = FRGPAR.frpar[i-1] +1;
38 // Internal logical flags ensuring that theta and y limits are not simultaneously set :
40 DYLIM.ywset = DYLIM.thwset = false;
44 title = ("Default title.");
50 /**************************************************************************/
54 // No housekeeping required at the moment.
57 /**************************************************************************/
59 void TIsajet::Initialise()
62 // Writes parameter file and stores common block variables in
63 // data members, according to booleans.
64 // If TIsajet is being used in online-control mode, the parameter file is
65 // unnecessary, hence the output is echoed to the screen instead.
67 const char *fname = gSystem->ExpandPathName("$ALICE_ROOT/ISAJET/data/myjob.par");
68 ofstream Write(fname, ios::out);
70 ostream *Writer = &Write;
72 if (online) Writer = &cout;
74 *Writer << title << '\n';
75 *Writer << PRIMAR.ecm << ',' << PRIMAR.nevent << ",1,1/\n";
76 *Writer << jobtype << '\n';
78 center_energy = PRIMAR.ecm;
81 beam1_type = PRIMAR.idin[0];
82 beam2_type = PRIMAR.idin[1];
85 if (PRIMAR.idin[0] == -1120) *Writer << "AP,";
86 else if (PRIMAR.idin[0] == 1220) *Writer << "N,";
87 else if (PRIMAR.idin[0] == -1220) *Writer << "AN,";
90 if (PRIMAR.idin[1] == -1120) *Writer << "AP/\n";
91 else if (PRIMAR.idin[1] == 1220) *Writer << "N/\n";
92 else if (PRIMAR.idin[1] == -1220) *Writer << "AN/\n";
93 else *Writer << "P/\n";
97 cutoff_mass = QCDPAR.cutjet;
98 *Writer << "CUTJET\n" << QCDPAR.cutjet << "/\n";
102 for (Int_t i = 0; i < 32; i++) frag_params[i] = *FRGPAR.frpar[i];
104 *Writer << "FRAGMENT\n";
105 for (Int_t i = 0; i < 31; i++) *Writer << FRGPAR.frpar[i] << ',';
106 *Writer << FRGPAR.frpar[31] << "/\n";
110 for (Int_t i = 0; i < TYPES.njttyp[0]; i++) jet1_type[i] = XTYPES.jetyp[0][i];
111 num_jet_type[0] = TYPES.njttyp[0];
113 *Writer << "JETTYPE1\n";
114 for (Int_t i = 0; i < TYPES.njttyp[0]-1; i++) *Writer << XTYPES.jetyp[0][i] << ',';
115 *Writer << XTYPES.jetyp[0][TYPES.njttyp[0]-1] << "/\n";
118 for (Int_t i = 0; i < TYPES.njttyp[1]; i++) jet2_type[i] = XTYPES.jetyp[1][i];
119 num_jet_type[0] = TYPES.njttyp[0];
121 *Writer << "JETTYPE2\n";
122 for (Int_t i = 0; i < TYPES.njttyp[1]-1; i++) *Writer << XTYPES.jetyp[1][i] << ',';
123 *Writer << XTYPES.jetyp[1][TYPES.njttyp[1]-1] << "/\n";
126 for (Int_t i = 0; i < TYPES.njttyp[2]; i++) jet3_type[i] = XTYPES.jetyp[2][i];
127 num_jet_type[0] = TYPES.njttyp[0];
129 *Writer << "JETTYPE3\n";
130 for (Int_t i = 0; i < TYPES.njttyp[2]-1; i++) *Writer << XTYPES.jetyp[2][i] << ',';
131 *Writer << XTYPES.jetyp[2][TYPES.njttyp[2]-1] << "/\n";
136 qcd_lambda = QCDPAR.alam;
137 *Writer << "LAMBDA\n" << QCDPAR.alam << "/\n";
142 forbid_decay = NODCAY.nodcay;
144 *Writer << "NODCAY\n";
145 if (NODCAY.nodcay) *Writer << "TRUE/\n";
146 else *Writer << "FALSE/\n";
150 forbid_eta = NODCAY.noeta;
152 *Writer << "NOETA\n";
153 if (NODCAY.noeta) *Writer << "TRUE/\n";
154 else *Writer << "FALSE/\n";
158 forbid_evolve = NODCAY.noevol;
160 *Writer << "NOEVOLVE\n";
161 if (NODCAY.noevol) *Writer << "TRUE/\n";
162 else *Writer << "FALSE/\n";
166 forbid_hadron = NODCAY.nohadr;
168 *Writer << "NOHADRON\n";
169 if (NODCAY.nohadr) *Writer << "TRUE/\n";
170 else *Writer << "FALSE/\n";
174 forbid_pi0 = NODCAY.nopi0;
176 *Writer << "NOPI0\n";
177 if (NODCAY.nopi0) *Writer << "TRUE/\n";
178 else *Writer << "FALSE/\n";
182 generate_sigma = PRIMAR.nsigma;
183 *Writer << "NSIGMA\n" << PRIMAR.nsigma << "/\n";
187 for (Int_t i = 0; i < 3; i++) {
188 p_limits[2 * i] = JETLIM.pmin[i];
189 p_limits[2 * i + 1] = JETLIM.pmax[i];
193 *Writer << JETLIM.pmin[0] << ',' << JETLIM.pmax[0] << ',';
194 *Writer << JETLIM.pmin[1] << ',' << JETLIM.pmax[1] << ',';
195 *Writer << JETLIM.pmin[2] << ',' << JETLIM.pmax[2] << "/\n";
199 for (Int_t i = 0; i < 3; i++) {
200 phi_limits[2 * i] = JETLIM.phimin[i];
201 phi_limits[2 * i + 1] = JETLIM.phimax[i];
205 *Writer << JETLIM.phimin[0] << ',' << JETLIM.phimax[0] << ',';
206 *Writer << JETLIM.phimin[1] << ',' << JETLIM.phimax[1] << ',';
207 *Writer << JETLIM.phimin[2] << ',' << JETLIM.phimax[2] << "/\n";
211 for (Int_t i = 0; i < 3; i++) {
212 pt_limits[2 * i] = JETLIM.ptmin[i];
213 pt_limits[2 * i + 1] = JETLIM.ptmax[i];
217 *Writer << JETLIM.ptmin[0] << ',' << JETLIM.ptmax[0] << ',';
218 *Writer << JETLIM.ptmin[1] << ',' << JETLIM.ptmax[1] << ',';
219 *Writer << JETLIM.ptmin[2] << ',' << JETLIM.ptmax[2] << "/\n";
223 for (Int_t i = 0; i < 3; i++) {
224 theta_limits[2 * i] = JETLIM.thmin[i];
225 theta_limits[2 * i + 1] = JETLIM.thmax[i];
228 *Writer << "THETA\n";
229 *Writer << JETLIM.thmin[0] << ',' << JETLIM.thmax[0] << ',';
230 *Writer << JETLIM.thmin[1] << ',' << JETLIM.thmax[1] << ',';
231 *Writer << JETLIM.thmin[2] << ',' << JETLIM.thmax[2] << "/\n";
235 for (Int_t i = 0; i < 3; i++) {
236 x_limits[2 * i] = JETLIM.xjmin[i];
237 x_limits[2 * i + 1] = JETLIM.xjmax[i];
241 *Writer << JETLIM.xjmin[0] << ',' << JETLIM.xjmax[0] << ',';
242 *Writer << JETLIM.xjmin[1] << ',' << JETLIM.xjmax[1] << ',';
243 *Writer << JETLIM.xjmin[2] << ',' << JETLIM.xjmax[2] << "/\n";
247 for (Int_t i = 0; i < 3; i++) {
248 y_limits[2 * i] = JETLIM.yjmin[i];
249 y_limits[2 * i + 1] = JETLIM.yjmax[i];
253 *Writer << JETLIM.yjmin[0] << ',' << JETLIM.yjmax[0] << ',';
254 *Writer << JETLIM.yjmin[1] << ',' << JETLIM.yjmax[1] << ',';
255 *Writer << JETLIM.yjmin[2] << ',' << JETLIM.yjmax[2] << "/\n";
259 for (Int_t i = 0; i < 8; i++) peter_jet_frag[i] = FRGPAR.xgen[i];
262 for (Int_t i = 0; i < 7; i++) *Writer << FRGPAR.xgen[i] << ',';
263 *Writer << FRGPAR.xgen[7] << "/\n";
267 *Writer << "PDFLIB\n";
268 for (Int_t i = 0; i < num_Pdf; i++) *Writer << "\'" << pdfpar[i] << "\'" << ',' << pdfval[i] << "/\n";
276 // Stuff for online-control mode :
281 for (Int_t i = 0; i < KEYS.mxkeys; i++) KEYS.keys[i] = false;
283 if (!strcmp(KEYS.reac, "TWOJET")) {
288 else if (!strcmp(KEYS.reac, "MINBIAS")) {
294 printf("Error in TIsajet::Initialise :\n");
295 printf("Invalid job type %s.\n", KEYS.reac);
296 printf("Only TWOJET and MINBIAS are currently supported for online mode.\n");
306 /**************************************************************************/
308 void TIsajet::Reload()
311 // Sets the common block variables to the data member values.
314 SetECM(center_energy);
317 SetIDIN(0, beam1_type);
318 SetIDIN(1, beam2_type);
321 if (setCutjet) SetCUTJET(cutoff_mass);
323 if (setFragment) SetAllFRPAR(frag_params, 32);
325 if (setJettype1) for (Int_t i = 0; i < num_jet_type[0]; i++) SetJETYP(0, jet1_type[i]);
327 if (setJettype2) for (Int_t i = 0; i < num_jet_type[1]; i++) SetJETYP(1, jet2_type[i]);
329 if (setJettype3) for (Int_t i = 0; i < num_jet_type[2]; i++) SetJETYP(2, jet3_type[i]);
331 if (setLambda) SetALAM(qcd_lambda);
333 if (setNodcay) SetNODCAY(forbid_decay);
335 if (setNoeta) SetNOETA(forbid_eta);
337 if (setNoevolve) SetNOEVOL(forbid_evolve);
339 if (setNohadron) SetNOHADR(forbid_hadron);
341 if (setNopi0) SetNOPI0(forbid_pi0);
343 if (setNsigma) SetNSIGMA(generate_sigma);
346 for (Int_t i = 0; i < 3; i++) {
347 SetPMIN(p_limits[2 * i], i);
348 SetPMAX(p_limits[2 * i + 1], i);
353 for (Int_t i = 0; i < 3; i++) {
354 SetPHIMIN(phi_limits[2 * i], i);
355 SetPHIMAX(phi_limits[2 * i + 1], i);
360 for (Int_t i = 0; i < 3; i++) {
361 SetPTMIN(pt_limits[2 * i], i);
362 SetPTMAX(pt_limits[2 * i + 1], i);
367 for (Int_t i = 0; i < 3; i++) {
368 SetTHMIN(theta_limits[2 * i], i);
369 SetTHMAX(theta_limits[2 * i + 1], i);
374 for (Int_t i = 0; i < 3; i++) {
375 SetXJMIN(x_limits[2 * i], i);
376 SetXJMAX(x_limits[2 * i + 1], i);
381 for (Int_t i = 0; i < 3; i++) {
382 SetYJMIN(y_limits[2 * i], i);
383 SetYJMAX(y_limits[2 * i + 1], i);
387 if (setXgen) SetAllXGEN(peter_jet_frag, 8);
390 /**************************************************************************/
392 void TIsajet::RestoreDefaults()
394 // Booleans indicating which keywords should be written into the parameter file.
396 setBeams = setCutjet = setFragment = setJettype1 = false;
397 setJettype2 = setJettype3 = setLambda = setNodcay = false;
398 setNoeta = setNoevolve = setNohadron = setNopi0 = false;
399 setNsigma = setP = setPhi = setPt = setTheta = false;
400 setX = setXgen = setY = setPdf = false;
403 // Calling on FORTRAN for initialisation of variables
418 /**************************************************************************/
420 Int_t TIsajet::ImportParticles(TClonesArray *particles, Option_t *option)
423 // Default primary creation method. It reads the /HEPEVT/ common block which
424 // has been filled by the GenerateEvent method. If the event generator does
425 // not use the HEPEVT common block, this routine has to be overloaded by
427 // The function loops on the generated particles and stores them in
428 // the TClonesArray pointed by the argument particles.
429 // The default action is to store only the stable particles (ISTHEP = 1)
430 // This can be demanded explicitly by setting the option = "Final"
431 // If the option = "All", all the particles are stored.
433 if (particles == 0) return 0;
434 TClonesArray &Particles = *particles;
436 TDatabasePDG* converter = TDatabasePDG::Instance();
437 Int_t numpart = PARTCL.nptcl;
438 printf("\n TIsajet: ISAJET stack contains %d particles.", numpart);
439 printf("\n TIsajet: Total energy: %f ", PRIMAR.ecm);
441 if ((!strcmp(option,"")) || (!strcmp(option,"Final"))) {
442 for (Int_t i = 0; i < numpart; i++) {
444 if (PARTCL.idcay[i] == 0) { // Check whether particle is stable.
446 // Use the common block values for the TParticle constructor
449 new(Particles[i]) TParticle(
450 converter->ConvertIsajetToPdg(PARTCL.ident[i]) , // PDG code
451 0 , // Status - currently a default
453 -1, // Mothers and daughters - not used for stable particles
458 PARTCL.pptcl[i][0] , // x, y, z and 0 momenta
463 0, // Velocities - currently not used.
470 else if (!strcmp(option,"All")) {
472 for (Int_t i = 0; i < numpart; i++) {
474 // Determine mother particle. Set to -1 if the particle originates from
475 // a parton or is a beam particle.
477 Int_t origin = PARTCL.iorig[i];
478 Int_t jet = origin / PARTCL.ipack;
479 origin = origin - (jet * PARTCL.ipack);
481 if (origin < 0) origin = 0;
483 // Determine first and last decay products. Both are -1 if the particle is stable.
484 // Note this means they are set to 0, because one is subtracted after decoding;
485 // this avoid off-by-one errors relative to the FORTRAN.
487 Int_t first_Daughter = 0;
488 Int_t last_Daughter = 0;
490 if (PARTCL.idcay[i] != 0) {
491 first_Daughter = PARTCL.idcay[i] / PARTCL.ipack;
492 last_Daughter = PARTCL.idcay[i] - (first_Daughter * PARTCL.ipack);
494 new(Particles[i]) TParticle(
495 converter->ConvertIsajetToPdg(PARTCL.ident[i]) ,
517 /**************************************************************************/
519 void TIsajet::GenerateEvent()
525 // if (online) Isabg2(e);
532 /**************************************************************************/
534 void TIsajet::SetJobtype(Char_t *val)
536 if ((!strcmp(val, "TWOJET")) || (!strcmp(val, "E+E-")) ||
537 (!strcmp(val, "DRELLYAN")) || (!strcmp(val, "MINBIAS")) ||
538 (!strcmp(val, "SUSY")) || (!strcmp(val, "WPAIR")) ||
539 (!strcmp(val, "HIGGS")) || (!strcmp(val, "PHOTON")) ||
540 (!strcmp(val, "TCOLOR")) || (!strcmp(val, "WHIGGS")) ||
541 (!strcmp(val, "EXTRADIM")) || (!strcmp(val, "ZJJ"))) {
545 printf("Error in TIsajet::SetJobtype :\n");
546 printf("Invalid reaction keyword %s.\n", val);
547 printf("Valid keywords are : TWOJET, E+E-, DRELLYAN,\n");
548 printf("MINBIAS, SUSY, WPAIR, HIGGS, PHOTON, TCOLOR,\n");
549 printf("WHIGGS, EXTRADIM and ZJJ.\n");
553 /**************************************************************************/
555 void TIsajet::GetJobtype() const
557 printf ("Current job type is %s.\n", jobtype);
560 /**************************************************************************/
562 void TIsajet::SetOnline(Bool_t val)
567 /**************************************************************************/
569 Bool_t TIsajet::GetOnline() const
574 /**************************************************************************/
576 void TIsajet::SetPDF(Char_t *name, Float_t val)
579 pdfpar[num_Pdf] = name;
580 pdfval[num_Pdf] = val;
585 printf ("Error in TIsajet::SetPDF :\n");
586 printf ("Maximum of twenty PDF parameters may be set.\n");
590 /**************************************************************************/
592 // Access routines for common blocks.
593 // Begins DYLIM access.
595 /**************************************************************************/
597 void TIsajet::SetQMIN(Float_t val)
599 if (val > DYLIM.qmax) {
600 printf("Error in TIsajet::SetQMIN : \n");
601 printf("You may not set QMIN to a value larger than QMAX = %f.\n", DYLIM.qmax);
606 if (!DYLIM.ywset) SetYWLIMS();
609 /**************************************************************************/
611 Float_t TIsajet::GetQMIN() const
616 /**************************************************************************/
618 void TIsajet::SetQMAX(Float_t val)
620 if (val < DYLIM.qmin) {
621 printf("Error in TIsajet::SetQMAX : \n");
622 printf("You may not set QMAX to a value less than QMIN = %f.\n", DYLIM.qmin);
629 /**************************************************************************/
631 Float_t TIsajet::GetQMAX() const
636 /**************************************************************************/
638 void TIsajet::SetQTMIN(Float_t val)
640 if (val > DYLIM.qtmax) {
641 printf("Error in TIsajet::SetQTMIN : \n");
642 printf("You may not set QTMIN to a value larger than QTMAX = %f.\n", DYLIM.qtmax);
646 if (!DYLIM.ywset) SetYWLIMS();
649 /**************************************************************************/
651 Float_t TIsajet::GetQTMIN() const
656 /**************************************************************************/
658 void TIsajet::SetQTMAX(Float_t val)
660 if (val < DYLIM.qtmin) {
661 printf("Error in TIsajet::SetQTMAX : \n");
662 printf("You may not set QTMAX to a value less than QTMIN = %f.\n", DYLIM.qtmin);
667 if (!DYLIM.ywset) SetYWLIMS();
670 /**************************************************************************/
672 Float_t TIsajet::GetQTMAX() const
677 /**************************************************************************/
679 void TIsajet::SetYWMIN(Float_t val)
681 if (val > DYLIM.ywmax) {
682 printf("Error in TIsajet::SetYWMIN : \n");
683 printf("You may not set YWMIN to a value larger than YWMAX = %f.\n", DYLIM.ywmax);
688 printf("Error in TIsajet::SetYWMIN :\n");
689 printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMIN.\n");
697 /**************************************************************************/
699 Float_t TIsajet::GetYWMIN() const
704 /**************************************************************************/
706 void TIsajet::SetYWMAX(Float_t val)
708 if (val < DYLIM.ywmin) {
709 printf("Error in TIsajet::SetYWMAX : \n");
710 printf("You may not set YWMAX to a value less than YWMIN = %f.\n", DYLIM.ywmin);
715 printf("Error in TIsajet::SetYWMAX :\n");
716 printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMAX.\n");
724 /**************************************************************************/
726 Float_t TIsajet::GetYWMAX() const
731 /**************************************************************************/
733 void TIsajet::SetYWLIMS()
735 Float_t rot = sqrt(DYLIM.qmin * DYLIM.qmin + DYLIM.qtmin * DYLIM.qtmin);
736 DYLIM.ywmax = acosh(PRIMAR.halfe / rot);
737 DYLIM.ywmin = -DYLIM.ywmax;
741 /**************************************************************************/
743 void TIsajet::SetXWMIN(Float_t val)
745 if (val > DYLIM.xwmax) {
746 printf("Error in TIsajet::SetXWMIN : \n");
747 printf("You may not set XWMIN to a value larger than XWMAX = %f.\n", DYLIM.xwmax);
753 /**************************************************************************/
755 Float_t TIsajet::GetXWMIN() const
760 /**************************************************************************/
762 void TIsajet::SetXWMAX(Float_t val)
764 if (val < DYLIM.xwmin) {
765 printf("Error in TIsajet::SetXWMAX : \n");
766 printf("You may not set XWMAX to a value less than XWMIN = %f.\n", DYLIM.xwmin);
773 /**************************************************************************/
775 Float_t TIsajet::GetXWMAX() const
780 /**************************************************************************/
782 void TIsajet::SetTHWMIN(Float_t val)
784 if (val > DYLIM.thwmax) {
785 printf("Error in TIsajet::SetTHWMIN : \n");
786 printf("You may not set THWMIN to a value larger than THWMAX = %f.\n", DYLIM.thwmax);
791 printf("Error in TIsajet::SetTHWMIN :\n");
792 printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMIN.\n");
800 /**************************************************************************/
802 Float_t TIsajet::GetTHWMIN() const
807 /**************************************************************************/
809 void TIsajet::SetTHWMAX(Float_t val)
811 if (val < DYLIM.thwmin) {
812 printf("Error in TIsajet::SetTHWMAX : \n");
813 printf("You may not set THWMAX to a value less than THWMIN = %f.\n", DYLIM.thwmin);
818 printf("Error in TIsajet::SetTHWMAX :\n");
819 printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMAX.\n");
827 /**************************************************************************/
829 Float_t TIsajet::GetTHWMAX() const
834 /**************************************************************************/
836 void TIsajet::SetTHWLIMS()
839 DYLIM.thwmax = TMath::Pi();
840 DYLIM.thwset = false;
843 /**************************************************************************/
845 void TIsajet::SetPHWMIN(Float_t val)
847 if (val > DYLIM.phwmax) {
848 printf("Error in TIsajet::SetPHWMIN : \n");
849 printf("You may not set PHWMIN to a value larger than PHWMAX = %f.\n", DYLIM.phwmax);
855 /**************************************************************************/
857 Float_t TIsajet::GetPHWMIN() const
862 /**************************************************************************/
864 void TIsajet::SetPHWMAX(Float_t val)
866 if (val < DYLIM.phwmin) {
867 printf("Error in TIsajet::SetPHWMAX : \n");
868 printf("You may not set PHWMAX to a value less than PHWMIN = %f.\n", DYLIM.phwmin);
875 /**************************************************************************/
877 Float_t TIsajet::GetPHWMAX() const
882 /**************************************************************************/
884 Bool_t TIsajet::GetSETLMQ(Int_t index) const
886 Int_t length = (sizeof DYLIM.setlmq / sizeof DYLIM.setlmq[0]);
887 if ((index < 0) || (index >= length)) {
888 printf ("Error in TIsajet::GetSETLMQ : \n");
889 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
893 return DYLIM.setlmq[index];
896 /**************************************************************************/
898 // End of DYLIM access.
899 // Begins EEPAR access.
901 /**************************************************************************/
903 void TIsajet::SetPLEP(Float_t val)
908 /**************************************************************************/
910 Float_t TIsajet::GetPLEP() const
915 /**************************************************************************/
917 void TIsajet::SetPLEM(Float_t val)
922 /**************************************************************************/
924 Float_t TIsajet::GetPLEM() const
929 /**************************************************************************/
931 void TIsajet::SetRSHMIN(Float_t val)
933 if (val > EEPAR.rshmax) {
934 printf("Error in TIsajet::SetRSHMIN : \n");
935 printf("You may not set RSHMIN to a value larger than RSHMAX = %f.\n", EEPAR.rshmax);
941 /**************************************************************************/
943 Float_t TIsajet::GetRSHMIN() const
948 /**************************************************************************/
950 void TIsajet::SetRSHMAX(Float_t val)
952 if (val < EEPAR.rshmin) {
953 printf("Error in TIsajet::SetRSHMAX : \n");
954 printf("You may not set RSHMAX to a value less than RSHMIN = %f.\n", EEPAR.rshmin);
961 /**************************************************************************/
963 Float_t TIsajet::GetRSHMAX() const
968 /**************************************************************************/
970 void TIsajet::SetUPSLON(Float_t val)
975 /**************************************************************************/
977 Float_t TIsajet::GetUPSLON() const
982 /**************************************************************************/
984 void TIsajet::SetSIGZ(Float_t val)
989 /**************************************************************************/
991 Float_t TIsajet::GetSIGZ() const
996 /**************************************************************************/
998 Bool_t TIsajet::GetIBREM() const
1003 /**************************************************************************/
1005 Bool_t TIsajet::GetIBEAM() const
1010 /**************************************************************************/
1012 Float_t TIsajet::GetSGMXEE() const
1014 return EEPAR.sgmxee;
1017 /**************************************************************************/
1019 // End of EEPAR access.
1020 // Begins FORCE access.
1022 /**************************************************************************/
1024 Int_t TIsajet::GetNFORCE() const
1026 return FORCE.nforce;
1029 /**************************************************************************/
1031 void TIsajet::SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti = true)
1033 if (GetNFORCE() >= FORCE.mxforc - anti) {
1034 printf ("ERROR in TIsajet::SetIFORCE :\n");
1035 printf ("Cannot have more than %d forced decays.\n", FORCE.mxforc );
1039 if ((arraySize > 6) || (arraySize < 2)) {
1040 printf ("Error in TIsajet::SetIFORCE : \n");
1041 printf ("Invalid array size %d; must be 2-6.\n", arraySize);
1045 for (Int_t i = 0; i < FORCE.nforce; i++) {
1046 if (FORCE.iforce[i] == val[0]) {
1047 printf ("Error in TIsajet::SetIFORCE : \n");
1048 printf ("Particle %d has already been forced, index %d.\n", val[0], i);
1054 FORCE.iforce[FORCE.nforce] = val[0];
1055 for (Int_t i = 1; i < arraySize; i++) {
1056 FORCE.mforce[FORCE.nforce][i-1] = val[i];
1061 printf ("Decay channel %d -> ", val[0]);
1062 for (Int_t i = 1; i < arraySize; i++) {
1063 printf ("%d, ", val[i]);
1068 Int_t antivals[arraySize];
1069 for (Int_t i = 0; i < arraySize; i++){
1070 antivals[i] = (0 - val[i]);
1072 SetIFORCE(antivals, arraySize, false);
1076 /**************************************************************************/
1078 void TIsajet::UnForce(Int_t index, Bool_t anti = true)
1080 if (FORCE.nforce == 0) {
1081 printf ("Error in TIsajet::UnForce : \n");
1082 printf ("No decays have been forced.\n");
1086 if ((index < 0) || (index >= FORCE.nforce)) {
1087 printf ("Error in TIsajet::UnForce : \n");
1088 printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1092 Int_t particle_ID = FORCE.iforce[index];
1094 for (Int_t i = index; i < FORCE.mxforc - 1; i++) {
1095 FORCE.iforce[i] = FORCE.iforce[i+1];
1096 for (Int_t j = 0; j < 5; j++) {
1097 FORCE.mforce[i][j] = FORCE.mforce[i+1][j];
1100 FORCE.iforce[FORCE.mxforc - 1] = 0;
1101 for (Int_t j = 0; j < 5; j++) {
1102 FORCE.mforce[FORCE.mxforc - 1][j] = 0;
1107 printf ("Decay of %d unforced.\n", particle_ID);
1109 if (anti) UnForceID(-particle_ID, false);
1112 /**************************************************************************/
1114 void TIsajet::UnForceID(Int_t particle_ID, Bool_t anti = true)
1116 if (FORCE.nforce == 0) {
1117 printf ("Error in TIsajet::UnForceID : \n");
1118 printf ("No decays have been forced.\n");
1122 for (Int_t i = 0; i < FORCE.nforce; i++) {
1123 if (FORCE.iforce[i] == particle_ID) {
1129 printf ("Error in TIsajet::UnForceID : \n");
1130 printf ("Cannot find particle %d.\n", particle_ID);
1133 /**************************************************************************/
1135 Int_t* TIsajet::GetIFORCE(Int_t index) const
1137 if (FORCE.nforce == 0) {
1138 printf ("Error in TIsajet::GetIFORCE : \n");
1139 printf ("No decays have been forced.\n");
1143 if ((index < 0) || (index >= FORCE.nforce)) {
1144 printf ("Error in TIsajet::GetIFORCE : \n");
1145 printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1150 decay[0] = FORCE.iforce[index];
1152 for (Int_t i = 1; i < 6; i++) {
1153 decay[i] = FORCE.mforce[index][i-1];
1159 /**************************************************************************/
1161 Int_t TIsajet::GetMEFORC(Int_t index) const
1163 if (FORCE.nforce == 0) {
1164 printf ("Error in TIsajet::GetMEFORCE : \n");
1165 printf ("No decays have been forced.\n");
1169 if ((index < 0) || (index >= FORCE.nforce)) {
1170 printf ("Error in TIsajet::GetMEFORC : \n");
1171 printf ("Invalid array index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1175 return FORCE.meforc[index];
1178 /**************************************************************************/
1180 // End of FORCE access.
1181 // Begins FRGPAR access.
1183 /**************************************************************************/
1185 void TIsajet::SetFRPAR(Float_t val, Int_t index)
1187 Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1188 if ((index < 0) || (index >= length)) {
1189 printf ("Error in TIsajet::SetFRPAR : \n");
1190 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1194 *FRGPAR.frpar[index] = val;
1198 /**************************************************************************/
1200 void TIsajet::SetAllFRPAR(const Float_t val[], Int_t arraySize)
1202 Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1203 if (arraySize != length) {
1204 printf ("Error in TIsajet::SetAllFRPAR : \n");
1205 printf ("Array must have %d elements.\n", length);
1209 for (Int_t i = 0; i < arraySize; i++) {
1210 SetFRPAR(val[i], i);
1214 /**************************************************************************/
1216 Float_t TIsajet::GetFRPAR(Int_t index) const
1218 Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1219 if ((index < 0) || (index >= length)) {
1220 printf ("Error in TIsajet::GetFRPAR : \n");
1221 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1225 return *FRGPAR.frpar[index];
1228 /**************************************************************************/
1230 void TIsajet::SetPUD(Float_t val)
1235 /**************************************************************************/
1237 Float_t TIsajet::GetPUD() const
1242 /**************************************************************************/
1244 void TIsajet::SetPBARY(Float_t val)
1249 /**************************************************************************/
1251 Float_t TIsajet::GetPBARY() const
1256 /**************************************************************************/
1258 void TIsajet::SetSIGQT(Float_t val)
1263 /**************************************************************************/
1265 Float_t TIsajet::GetSIGQT() const
1270 /**************************************************************************/
1272 void TIsajet::SetPEND(Float_t val)
1277 /**************************************************************************/
1279 Float_t TIsajet::GetPEND() const
1284 /**************************************************************************/
1286 void TIsajet::SetXGEN(Float_t val, Int_t index)
1288 Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1289 if ((index < 0) || (index >= length)) {
1290 printf ("Error in TIsajet::SetXGEN : \n");
1291 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1294 SetFRPAR(val, index + 4);
1298 /**************************************************************************/
1300 void TIsajet::SetAllXGEN(const Float_t val[], Int_t arraySize)
1302 Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1303 if (arraySize != length) {
1304 printf ("Error in TIsajet::SetAllXGEN : \n");
1305 printf ("Array must have %d elements.\n", length);
1309 for (Int_t i = 0; i < arraySize; i++) {
1314 /**************************************************************************/
1316 Float_t TIsajet::GetXGEN(Int_t index) const
1318 Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1319 if ((index < 0) || (index >= length)) {
1320 printf ("Error in TIsajet::GetXGEN : \n");
1321 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1325 return GetFRPAR(index + 4);
1328 /**************************************************************************/
1330 void TIsajet::SetPSPIN1(Float_t val, Int_t index)
1332 Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
1333 if ((index < 0) || (index >= length)) {
1334 printf ("Error in TIsajet::SetPSPIN1 : \n");
1335 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1339 SetFRPAR(val, index + 12);
1342 /**************************************************************************/
1344 void TIsajet::SetAllPSPIN1(const Float_t val[], Int_t arraySize)
1346 Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
1347 if (arraySize != length) {
1348 printf ("Error in TIsajet::SetAllPSPIN1 : \n");
1349 printf ("Array must have %d elements.\n", length);
1353 for (Int_t i = 0; i < arraySize; i++) {
1354 SetPSPIN1(val[i], i);
1358 /**************************************************************************/
1360 Float_t TIsajet::GetPSPIN1(Int_t index) const
1362 Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1363 if ((index < 0) || (index >= length)) {
1364 printf ("Error in TIsajet::GetPSPIN1 : \n");
1365 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1369 return GetFRPAR(index + 12);
1372 /**************************************************************************/
1374 void TIsajet::SetPMIX1(Float_t val, Int_t index1, Int_t index2)
1376 Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1377 Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1379 if ((index1 < 0) || (index1 >= row_num)) {
1380 printf ("Error in TIsajet::SetPMIX1 : \n");
1381 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1385 if ((index2 < 0) || (index2 >= col_num)) {
1386 printf ("Error in TIsajet::SetPMIX1 : \n");
1387 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1391 FRGPAR.pmix1[index1][index2] = val;
1395 /**************************************************************************/
1397 void TIsajet::SetAllPMIX1(const Float_t val[2][3])
1399 for (Int_t i = 0; i < 2; i++) {
1400 for (Int_t j = 0; j < 3; j++) {
1401 SetPMIX1(val[i][j], i, j);
1406 /**************************************************************************/
1408 void TIsajet::SetColumnPMIX1(const Float_t val[], Int_t col)
1410 Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1411 Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1413 if ((col < 0) || (col >= col_num)) {
1414 printf ("Error in TIsajet::SetColumnPMIX1 : \n");
1415 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
1419 for (Int_t i = 0; i < row_num; i++) {
1420 SetPMIX1(val[i], i, col);
1424 /**************************************************************************/
1426 Float_t TIsajet::GetPMIX1(Int_t index1, Int_t index2) const
1428 Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1429 Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1431 if ((index1 < 0) || (index1 >= row_num)) {
1432 printf ("Error in TIsajet::GetPMIX1 : \n");
1433 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1437 if ((index2 < 0) || (index2 >= col_num)) {
1438 printf ("Error in TIsajet::GetPMIX1 : \n");
1439 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1443 return FRGPAR.pmix1[index1][index2];
1446 /**************************************************************************/
1448 void TIsajet::SetPMIX2(Float_t val, Int_t index1, Int_t index2)
1450 Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1451 Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1453 if ((index1 < 0) || (index1 >= row_num)) {
1454 printf ("Error in TIsajet::SetPMIX2 : \n");
1455 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1459 if ((index2 < 0) || (index2 >= col_num)) {
1460 printf ("Error in TIsajet::SetPMIX2 : \n");
1461 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1465 FRGPAR.pmix2[index1][index2] = val;
1469 /**************************************************************************/
1471 void TIsajet::SetAllPMIX2(const Float_t val[2][3])
1473 for (Int_t i = 0; i < 2; i++) {
1474 for (Int_t j = 0; j < 3; j++) {
1475 SetPMIX2(val[i][j], i, j);
1480 /**************************************************************************/
1482 void TIsajet::SetColumnPMIX2(const Float_t val[], Int_t col)
1484 Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1485 Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1487 if ((col < 0) || (col >= col_num)) {
1488 printf ("Error in TIsajet::SetColumnPMIX2 : \n");
1489 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
1493 for (Int_t i = 0; i < row_num; i++) {
1494 SetPMIX2(val[i], i, col);
1498 /**************************************************************************/
1500 Float_t TIsajet::GetPMIX2(Int_t index1, Int_t index2) const
1502 Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1503 Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1505 if ((index1 < 0) || (index1 >= row_num)) {
1506 printf ("Error in TIsajet::GetPMIX2 : \n");
1507 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1511 if ((index2 < 0) || (index2 >= col_num)) {
1512 printf ("Error in TIsajet::GetPMIX2 : \n");
1513 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1517 return FRGPAR.pmix2[index1][index2];
1520 /**************************************************************************/
1522 void TIsajet::SetPMIXX1(Float_t val, Int_t index)
1524 Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1525 if ((index < 0) || (index >= length)) {
1526 printf ("Error in TIsajet::SetPMIXX1 : \n");
1527 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1531 *FRGPAR.pmixx1[index] = val;
1535 /**************************************************************************/
1537 void TIsajet::SetAllPMIXX1(const Float_t val[], Int_t arraySize)
1539 Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1540 if (arraySize != length) {
1541 printf ("Error in TIsajet::SetAllPMIXX1 : \n");
1542 printf ("Array must have %d elements.\n", length);
1546 for (Int_t i = 0; i < arraySize; i++) {
1547 SetPMIXX1(val[i], i);
1551 /**************************************************************************/
1553 Float_t TIsajet::GetPMIXX1(Int_t index) const
1555 Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1556 if ((index < 0) || (index >= length)) {
1557 printf ("Error in TIsajet::GetPMIXX1 : \n");
1558 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1562 return *FRGPAR.pmixx1[index];
1565 /**************************************************************************/
1567 void TIsajet::SetPMIXX2(Float_t val, Int_t index)
1569 Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1570 if ((index < 0) || (index >= length)) {
1571 printf ("Error in TIsajet::SetPMIXX2 : \n");
1572 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1576 *FRGPAR.pmixx2[index] = val;
1580 /**************************************************************************/
1582 void TIsajet::SetAllPMIXX2(const Float_t val[], Int_t arraySize)
1584 Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1585 if (arraySize != length) {
1586 printf ("Error in TIsajet::SetAllPMIXX2 : \n");
1587 printf ("Array must have %d elements.\n", length);
1591 for (Int_t i = 0; i < arraySize; i++) {
1592 SetPMIXX2(val[i], i);
1596 /**************************************************************************/
1598 Float_t TIsajet::GetPMIXX2(Int_t index) const
1600 Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1601 if ((index < 0) || (index >= length)) {
1602 printf ("Error in TIsajet::GetPMIXX2 : \n");
1603 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1607 return *FRGPAR.pmixx2[index];
1610 /**************************************************************************/
1612 void TIsajet::SetXGENSS(Float_t val, Int_t index)
1614 Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1615 if ((index < 0) || (index >= length)) {
1616 printf ("Error in TIsajet::SetXGENSS : \n");
1617 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1621 FRGPAR.xgenss[index] = val;
1624 /**************************************************************************/
1626 void TIsajet::SetAllXGENSS(const Float_t val[], Int_t arraySize)
1628 Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1629 if (arraySize != length) {
1630 printf ("Error in TIsajet::SetAllXGENSS : \n");
1631 printf ("Array must have %d elements.\n", length);
1635 for (Int_t i = 0; i < arraySize; i++) {
1636 SetXGENSS(val[i], i);
1640 /**************************************************************************/
1642 Float_t TIsajet::GetXGENSS(Int_t index) const
1644 Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1645 if ((index < 0) || (index >= length)) {
1646 printf ("Error in TIsajet::GetXGENSS : \n");
1647 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1651 return FRGPAR.xgenss[index];
1654 /**************************************************************************/
1656 // End of FRGPAR access.
1657 // Begins HCON access.
1659 /**************************************************************************/
1661 Float_t TIsajet::GetANWWWW(Int_t index1, Int_t index2, Int_t index3) const
1663 Int_t elem_Size = sizeof HCON.anwwww[0][0][0];
1664 Int_t thd_Dim_Length = (sizeof HCON.anwwww[0][0] / elem_Size);
1665 Int_t sec_Dim_Length = (sizeof HCON.anwwww[0] / (elem_Size * thd_Dim_Length));
1666 Int_t fst_Dim_Length = (sizeof HCON.anwwww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
1668 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1669 printf ("Error in TIsajet::GetANWWWW : \n");
1670 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1674 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1675 printf ("Error in TIsajet::GetANWWWW : \n");
1676 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1680 if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
1681 printf ("Error in TIsajet::GetANWWWW : \n");
1682 printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
1686 return HCON.anwwww[index1][index2][index3];
1689 /**************************************************************************/
1691 Float_t TIsajet::GetADWWWW(Int_t index1, Int_t index2) const
1693 Int_t elem_Size = sizeof HCON.adwwww[0][0];
1694 Int_t sec_Dim_Length = (sizeof HCON.adwwww[0] / elem_Size);
1695 Int_t fst_Dim_Length = (sizeof HCON.adwwww / (elem_Size * sec_Dim_Length));
1697 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1698 printf ("Error in TIsajet::GetADWWWW : \n");
1699 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1703 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1704 printf ("Error in TIsajet::GetADWWWW : \n");
1705 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1709 return HCON.adwwww[index1][index2];
1712 /**************************************************************************/
1714 Float_t TIsajet::GetAIWWWW(Int_t index) const
1716 Int_t length = (sizeof HCON.aiwwww / sizeof HCON.aiwwww[0]);
1717 if ((index < 0) || (index >= length)) {
1718 printf ("Error in TIsajet::GetAIWWWW : \n");
1719 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1723 return HCON.aiwwww[index];
1726 /**************************************************************************/
1728 Float_t TIsajet::GetHMASS() const
1733 /**************************************************************************/
1735 Float_t TIsajet::GetHGAM() const
1740 /**************************************************************************/
1742 Float_t TIsajet::GetHGAMS(Int_t index) const
1744 Int_t length = (sizeof HCON.hgams / sizeof HCON.hgams[0]);
1745 if ((index < 0) || (index >= length)) {
1746 printf ("Error in TIsajet::GetHGAMS : \n");
1747 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1751 return HCON.hgams[index];
1754 /**************************************************************************/
1756 Float_t TIsajet::GetETAHGG() const
1761 /**************************************************************************/
1763 Int_t TIsajet::GetMATCHH(Int_t index) const
1765 Int_t length = (sizeof HCON.matchh / sizeof HCON.matchh[0]);
1766 if ((index < 0) || (index >= length)) {
1767 printf ("Error in TIsajet::GetMATCHH : \n");
1768 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1772 return HCON.matchh[index];
1775 /**************************************************************************/
1777 Float_t TIsajet::GetZSTARS(Int_t index1, Int_t index2) const
1779 Int_t elem_Size = sizeof HCON.zstars[0][0];
1780 Int_t sec_Dim_Length = (sizeof HCON.zstars[0] / elem_Size);
1781 Int_t fst_Dim_Length = (sizeof HCON.zstars / (elem_Size * sec_Dim_Length));
1783 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1784 printf ("Error in TIsajet::GetZSTARS : \n");
1785 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1789 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1790 printf ("Error in TIsajet::GetZSTARS : \n");
1791 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1795 return HCON.zstars[index1][index2];
1798 /**************************************************************************/
1800 void TIsajet::SetIHTYPE(Int_t val)
1802 if ((val < 82) || (val > 84)) {
1803 printf ("Error in TIsajet::SetIHTYPE : \n");
1804 printf ("Invalid input value %d. Possible values are 82, 83, 84.\n", val);
1811 /**************************************************************************/
1813 void TIsajet::SetIHTYPE(Char_t val[])
1815 if (!strcmp("HL0", val)) {
1818 else if (!strcmp("HH0", val)) {
1821 else if (!strcmp("HA0", val)){
1825 printf ("Error in TIsajet::SetIHTYPE : \n");
1826 printf ("Invalid input string %s. Possible strings are HL0, HH0, HA0.\n", val);
1830 /**************************************************************************/
1832 Int_t TIsajet::GetIHTYPE() const
1837 /**************************************************************************/
1839 Float_t TIsajet::GetHGAMSS(Int_t index1, Int_t index2) const
1841 Int_t elem_Size = sizeof HCON.hgamss[0][0];
1842 Int_t sec_Dim_Length = (sizeof HCON.hgamss[0] / elem_Size);
1843 Int_t fst_Dim_Length = (sizeof HCON.hgamss / (elem_Size * sec_Dim_Length));
1845 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1846 printf ("Error in TIsajet::GetHGAMSS : \n");
1847 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1851 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1852 printf ("Error in TIsajet::GetHGAMSS : \n");
1853 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1857 return HCON.hgamss[index1][index2];
1860 /**************************************************************************/
1862 // End of HCON access
1863 // Begins JETLIM access
1865 /**************************************************************************/
1867 void TIsajet::SetPMIN(Float_t val, Int_t index)
1869 Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1870 if ((index < 0) || (index >= length)) {
1871 printf ("Error in TIsajet::SetPMIN : \n");
1872 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1876 if (val > JETLIM.pmax[index]) {
1877 printf("Error in TIsajet::SetPMIN : \n");
1878 printf("You may not set PMIN to a value larger than PMAX = %f.\n", JETLIM.pmax[index]);
1882 JETLIM.pmin[index] = val;
1886 /**************************************************************************/
1888 void TIsajet::SetAllPMIN(const Float_t val[], Int_t arraySize)
1890 Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1891 if (arraySize != length) {
1892 printf ("Error in TIsajet::SetAllPMIN : \n");
1893 printf ("Array must have %d elements.\n", length);
1897 for (Int_t i = 0; i < arraySize; i++) {
1902 /**************************************************************************/
1904 Float_t TIsajet::GetPMIN(Int_t index) const
1906 Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1907 if ((index < 0) || (index >= length)) {
1908 printf ("Error in TIsajet::GetPMIN : \n");
1909 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1913 return JETLIM.pmin[index];
1916 /**************************************************************************/
1918 void TIsajet::SetPMAX(Float_t val, Int_t index)
1920 Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1921 if ((index < 0) || (index >= length)) {
1922 printf ("Error in TIsajet::SetPMAX : \n");
1923 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1927 if (val < JETLIM.pmin[index]) {
1928 printf("Error in TIsajet::SetPMAX : \n");
1929 printf("You may not set PMAX to a value larger than PMIN = %f.\n", JETLIM.pmin[index]);
1933 JETLIM.pmax[index] = val;
1937 /**************************************************************************/
1939 void TIsajet::SetAllPMAX(const Float_t val[], Int_t arraySize)
1941 Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1942 if (arraySize != length) {
1943 printf ("Error in TIsajet::SetAllPMAX : \n");
1944 printf ("Array must have %d elements.\n", length);
1948 for (Int_t i = 0; i < arraySize; i++) {
1953 /**************************************************************************/
1955 Float_t TIsajet::GetPMAX(Int_t index) const
1957 Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1958 if ((index < 0) || (index >= length)) {
1959 printf ("Error in TIsajet::GetPMAX : \n");
1960 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1964 return JETLIM.pmax[index];
1967 /**************************************************************************/
1969 void TIsajet::SetPTMIN(Float_t val, Int_t index)
1971 Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
1972 if ((index < 0) || (index >= length)) {
1973 printf ("Error in TIsajet::SetPTMIN : \n");
1974 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1978 if (val > JETLIM.ptmax[index]) {
1979 printf("Error in TIsajet::SetPTMIN : \n");
1980 printf("You may not set PTMIN to a value larger than PTMAX = %f.\n", JETLIM.ptmax[index]);
1984 JETLIM.ptmin[index] = val;
1985 // if (!setY) SetYJLIMS();
1986 // if (!setTheta) SetTHLIMS();
1990 /**************************************************************************/
1992 void TIsajet::SetAllPTMIN(const Float_t val[], Int_t arraySize)
1994 Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
1995 if (arraySize != length) {
1996 printf ("Error in TIsajet::SetAllPTMIN : \n");
1997 printf ("Array must have %d elements.\n", length);
2001 for (Int_t i = 0; i < arraySize; i++) {
2002 SetPTMIN(val[i], i);
2006 /**************************************************************************/
2008 Float_t TIsajet::GetPTMIN(Int_t index) const
2010 Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
2011 if ((index < 0) || (index >= length)) {
2012 printf ("Error in TIsajet::GetPTMIN : \n");
2013 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2017 return JETLIM.ptmin[index];
2020 /**************************************************************************/
2022 void TIsajet::SetPTMAX(Float_t val, Int_t index)
2024 Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2025 if ((index < 0) || (index >= length)) {
2026 printf ("Error in TIsajet::SetPTMAX : \n");
2027 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2031 if (val < JETLIM.ptmin[index]) {
2032 printf("Error in TIsajet::SetPTMAX : \n");
2033 printf("You may not set PTMAX to a value larger than PTMIN = %f.\n", JETLIM.ptmin[index]);
2037 JETLIM.ptmax[index] = val;
2041 /**************************************************************************/
2043 void TIsajet::SetAllPTMAX(const Float_t val[], Int_t arraySize)
2045 Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2046 if (arraySize != length) {
2047 printf ("Error in TIsajet::SetAllPTMAX : \n");
2048 printf ("Array must have %d elements.\n", length);
2052 for (Int_t i = 0; i < arraySize; i++) {
2053 SetPTMAX(val[i], i);
2057 /**************************************************************************/
2059 Float_t TIsajet::GetPTMAX(Int_t index) const
2061 Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2062 if ((index < 0) || (index >= length)) {
2063 printf ("Error in TIsajet::GetPTMAX : \n");
2064 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2068 return JETLIM.ptmax[index];
2071 /**************************************************************************/
2073 void TIsajet::SetYJMIN(Float_t val, Int_t index)
2075 Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2076 if ((index < 0) || (index >= length)) {
2077 printf ("Error in TIsajet::SetYJMIN : \n");
2078 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2082 if (val > JETLIM.yjmax[index]) {
2083 printf("Error in TIsajet::SetYJMIN : \n");
2084 printf("You may not set YJMIN to a value larger than YJMAX = %f.\n", JETLIM.yjmax[index]);
2089 printf("Error in TIsajet::SetYJMIN :\n");
2090 printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMIN.\n");
2095 JETLIM.yjmin[index] = val;
2098 /**************************************************************************/
2100 void TIsajet::SetAllYJMIN(const Float_t val[], Int_t arraySize)
2102 Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2103 if (arraySize != length) {
2104 printf ("Error in TIsajet::SetAllYJMIN : \n");
2105 printf ("Array must have %d elements.\n", length);
2109 for (Int_t i = 0; i < arraySize; i++) {
2110 SetYJMIN(val[i], i);
2114 /**************************************************************************/
2116 Float_t TIsajet::GetYJMIN(Int_t index) const
2118 Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2119 if ((index < 0) || (index >= length)) {
2120 printf ("Error in TIsajet::GetYJMIN : \n");
2121 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2125 return JETLIM.yjmin[index];
2128 /**************************************************************************/
2130 void TIsajet::SetYJMAX(Float_t val, Int_t index)
2132 Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2133 if ((index < 0) || (index >= length)) {
2134 printf ("Error in TIsajet::SetYJMAX : \n");
2135 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2139 if (val < JETLIM.yjmin[index]) {
2140 printf("Error in TIsajet::SetYJMAX : \n");
2141 printf("You may not set YJMAX to a value larger than YJMIN = %f.\n", JETLIM.yjmin[index]);
2146 printf("Error in TIsajet::SetYJMAX :\n");
2147 printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMAX.\n");
2152 JETLIM.yjmax[index] = val;
2155 /**************************************************************************/
2157 void TIsajet::SetAllYJMAX(const Float_t val[], Int_t arraySize)
2159 Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2160 if (arraySize != length) {
2161 printf ("Error in TIsajet::SetAllYJMAX : \n");
2162 printf ("Array must have %d elements.\n", length);
2166 for (Int_t i = 0; i < arraySize; i++) {
2167 SetYJMAX(val[i], i);
2171 /**************************************************************************/
2173 Float_t TIsajet::GetYJMAX(Int_t index) const
2175 Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2176 if ((index < 0) || (index >= length)) {
2177 printf ("Error in TIsajet::GetYJMAX : \n");
2178 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2182 return JETLIM.yjmax[index];
2185 /**************************************************************************/
2187 void TIsajet::SetYJLIMS()
2189 for (Int_t i = 0; i < JETLIM.mxlim; i++) {
2190 JETLIM.yjmax[i] = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
2191 JETLIM.yjmax[i] = -JETLIM.yjmin[i];
2196 /**************************************************************************/
2198 void TIsajet::SetPHIMIN(Float_t val, Int_t index)
2200 Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2201 if ((index < 0) || (index >= length)) {
2202 printf ("Error in TIsajet::SetPHIMIN : \n");
2203 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2207 if (val > JETLIM.phimax[index]) {
2208 printf("Error in TIsajet::SetPHIMIN : \n");
2209 printf("You may not set PHIMIN to a value larger than PHIMAX = %f.\n", JETLIM.phimax[index]);
2213 JETLIM.phimin[index] = val;
2217 /**************************************************************************/
2219 void TIsajet::SetAllPHIMIN(const Float_t val[], Int_t arraySize)
2221 Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2222 if (arraySize != length) {
2223 printf ("Error in TIsajet::SetAllPHIMIN : \n");
2224 printf ("Array must have %d elements.\n", length);
2228 for (Int_t i = 0; i < arraySize; i++) {
2229 SetPHIMIN(val[i], i);
2233 /**************************************************************************/
2235 Float_t TIsajet::GetPHIMIN(Int_t index) const
2237 Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2238 if ((index < 0) || (index >= length)) {
2239 printf ("Error in TIsajet::GetPHIMIN : \n");
2240 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2244 return JETLIM.phimin[index];
2247 /**************************************************************************/
2249 void TIsajet::SetPHIMAX(Float_t val, Int_t index)
2251 Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2252 if ((index < 0) || (index >= length)) {
2253 printf ("Error in TIsajet::SetPHIMAX : \n");
2254 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2258 if (val < JETLIM.phimin[index]) {
2259 printf("Error in TIsajet::SetPHIMAX : \n");
2260 printf("You may not set PHIMAX to a value larger than PHIMIN = %f.\n", JETLIM.phimin[index]);
2264 JETLIM.phimax[index] = val;
2268 /**************************************************************************/
2270 void TIsajet::SetAllPHIMAX(const Float_t val[], Int_t arraySize)
2272 Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2273 if (arraySize != length) {
2274 printf ("Error in TIsajet::SetAllPHIMAX : \n");
2275 printf ("Array must have %d elements.\n", length);
2279 for (Int_t i = 0; i < arraySize; i++) {
2280 SetPHIMAX(val[i], i);
2284 /**************************************************************************/
2286 Float_t TIsajet::GetPHIMAX(Int_t index) const
2288 Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2289 if ((index < 0) || (index >= length)) {
2290 printf ("Error in TIsajet::GetPHIMAX : \n");
2291 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2295 return JETLIM.phimax[index];
2298 /**************************************************************************/
2300 void TIsajet::SetXJMIN(Float_t val, Int_t index)
2302 Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2303 if ((index < 0) || (index >= length)) {
2304 printf ("Error in TIsajet::SetXJMIN : \n");
2305 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2308 if (val > JETLIM.xjmax[index]) {
2309 printf("Error in TIsajet::SetXJMIN : \n");
2310 printf("You may not set XJMIN to a value larger than XJMAX = %f.\n", JETLIM.xjmax[index]);
2314 JETLIM.xjmin[index] = val;
2318 /**************************************************************************/
2320 void TIsajet::SetAllXJMIN(const Float_t val[], Int_t arraySize)
2322 Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2323 if (arraySize != length) {
2324 printf ("Error in TIsajet::SetAllXJMIN : \n");
2325 printf ("Array must have %d elements.\n", length);
2329 for (Int_t i = 0; i < arraySize; i++) {
2330 SetXJMIN(val[i], i);
2334 /**************************************************************************/
2336 Float_t TIsajet::GetXJMIN(Int_t index) const
2338 Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2339 if ((index < 0) || (index >= length)) {
2340 printf ("Error in TIsajet::GetXJMIN : \n");
2341 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2345 return JETLIM.xjmin[index];
2348 /**************************************************************************/
2350 void TIsajet::SetXJMAX(Float_t val, Int_t index)
2352 Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2353 if ((index < 0) || (index >= length)) {
2354 printf ("Error in TIsajet::SetXJMAX : \n");
2355 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2359 if (val < JETLIM.xjmin[index]) {
2360 printf("Error in TIsajet::SetXJMAX : \n");
2361 printf("You may not set XJMAX to a value larger than XJMIN = %f.\n", JETLIM.xjmin[index]);
2365 JETLIM.xjmax[index] = val;
2369 /**************************************************************************/
2371 void TIsajet::SetAllXJMAX(const Float_t val[], Int_t arraySize)
2373 Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2374 if (arraySize != length) {
2375 printf ("Error in TIsajet::SetAllXJMAX : \n");
2376 printf ("Array must have %d elements.\n", length);
2380 for (Int_t i = 0; i < arraySize; i++) {
2381 SetXJMAX(val[i], i);
2385 /**************************************************************************/
2387 Float_t TIsajet::GetXJMAX(Int_t index) const
2389 Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2390 if ((index < 0) || (index >= length)) {
2391 printf ("Error in TIsajet::GetXJMAX : \n");
2392 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2396 return JETLIM.xjmax[index];
2399 /**************************************************************************/
2401 void TIsajet::SetTHMIN(Float_t val, Int_t index)
2403 Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2404 if ((index < 0) || (index >= length)) {
2405 printf ("Error in TIsajet::SetTHMIN : \n");
2406 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2410 if (val > JETLIM.thmax[index]) {
2411 printf("Error in TIsajet::SetTHMIN : \n");
2412 printf("You may not set THMIN to a value larger than THMAX = %f.\n", JETLIM.thmax[index]);
2417 printf("Error in TIsajet::SetTHMIN :\n");
2418 printf("May not set both theta and y limits. Use SetYJLIMS, then set THMIN.\n");
2423 JETLIM.thmin[index] = val;
2427 /**************************************************************************/
2429 void TIsajet::SetAllTHMIN(const Float_t val[], Int_t arraySize)
2431 Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2432 if (arraySize != length) {
2433 printf ("Error in TIsajet::SetAllTHMIN : \n");
2434 printf ("Array must have %d elements.\n", length);
2438 for (Int_t i = 0; i < arraySize; i++) {
2439 SetTHMIN(val[i], i);
2443 /**************************************************************************/
2445 Float_t TIsajet::GetTHMIN(Int_t index) const
2447 Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2448 if ((index < 0) || (index >= length)) {
2449 printf ("Error in TIsajet::GetTHMIN : \n");
2450 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2454 return JETLIM.thmin[index];
2457 /**************************************************************************/
2459 void TIsajet::SetTHMAX(Float_t val, Int_t index)
2461 Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2462 if ((index < 0) || (index >= length)) {
2463 printf ("Error in TIsajet::SetTHMAX : \n");
2464 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2468 if (val < JETLIM.thmin[index]) {
2469 printf("Error in TIsajet::SetTHMAX : \n");
2470 printf("You may not set THMAX to a value larger than THMIN = %f.\n", JETLIM.thmin[index]);
2475 printf("Error in TIsajet::SetTHMAX :\n");
2476 printf("May not set both theta and y limits. Use SetYJLIMS, then set THMAX.\n");
2481 JETLIM.thmax[index] = val;
2484 /**************************************************************************/
2486 void TIsajet::SetAllTHMAX(const Float_t val[], Int_t arraySize)
2488 Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2489 if (arraySize != length) {
2490 printf ("Error in TIsajet::SetAllTHMAX : \n");
2491 printf ("Array must have %d elements.\n", length);
2495 for (Int_t i = 0; i < arraySize; i++) {
2496 SetTHMAX(val[i], i);
2500 /**************************************************************************/
2502 Float_t TIsajet::GetTHMAX(Int_t index) const
2504 Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2505 if ((index < 0) || (index >= length)) {
2506 printf ("Error in TIsajet::GetTHMAX : \n");
2507 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2511 return JETLIM.thmax[index];
2514 /**************************************************************************/
2516 void TIsajet::SetTHLIMS()
2519 for (Int_t i = 0; i < JETLIM.mxlim; i++) {
2520 tmin = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
2521 JETLIM.thmin[i] = 2*atan(exp(tmin));
2522 JETLIM.thmax[i] = 2*atan(exp(-tmin));
2527 /**************************************************************************/
2529 Bool_t TIsajet::GetSETLMJ(Int_t index) const
2531 Int_t length = (sizeof JETLIM.setlmj / sizeof JETLIM.setlmj[0]);
2532 if ((index < 0) || (index >= length)) {
2533 printf ("Error in TIsajet::GetSETLMJ : \n");
2534 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2538 return JETLIM.setlmj[index];
2541 /**************************************************************************/
2543 // Ends JETLIM access.
2544 // Begins JETPAR access.
2546 /**************************************************************************/
2548 Float_t TIsajet::GetP(Int_t index) const
2550 Int_t length = (sizeof JETPAR.p / sizeof JETPAR.p[0]);
2551 if ((index < 0) || (index >= length)) {
2552 printf ("Error in TIsajet::GetP : \n");
2553 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2557 return JETPAR.p[index];
2560 /**************************************************************************/
2562 Float_t TIsajet::GetPT(Int_t index) const
2564 Int_t length = (sizeof JETPAR.pt / sizeof JETPAR.pt[0]);
2565 if ((index < 0) || (index >= length)) {
2566 printf ("Error in TIsajet::GetPT : \n");
2567 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2571 return JETPAR.pt[index];
2574 /**************************************************************************/
2576 Float_t TIsajet::GetYJ(Int_t index) const
2578 Int_t length = (sizeof JETPAR.yj / sizeof JETPAR.yj[0]);
2579 if ((index < 0) || (index >= length)) {
2580 printf ("Error in TIsajet::GetYJ : \n");
2581 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2585 return JETPAR.yj[index];
2588 /**************************************************************************/
2590 Float_t TIsajet::GetPHI(Int_t index) const
2592 Int_t length = (sizeof JETPAR.phi / sizeof JETPAR.phi[0]);
2593 if ((index < 0) || (index >= length)) {
2594 printf ("Error in TIsajet::GetPHI : \n");
2595 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2599 return JETPAR.phi[index];
2602 /**************************************************************************/
2604 Float_t TIsajet::GetXJ(Int_t index) const
2606 Int_t length = (sizeof JETPAR.xj / sizeof JETPAR.xj[0]);
2607 if ((index < 0) || (index >= length)) {
2608 printf ("Error in TIsajet::GetXJ : \n");
2609 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2613 return JETPAR.xj[index];
2616 /**************************************************************************/
2618 Float_t TIsajet::GetTH(Int_t index) const
2620 Int_t length = (sizeof JETPAR.th / sizeof JETPAR.th[0]);
2621 if ((index < 0) || (index >= length)) {
2622 printf ("Error in TIsajet::GetTH : \n");
2623 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2627 return JETPAR.th[index];
2630 /**************************************************************************/
2632 Float_t TIsajet::GetCTH(Int_t index) const
2634 Int_t length = (sizeof JETPAR.cth / sizeof JETPAR.cth[0]);
2635 if ((index < 0) || (index >= length)) {
2636 printf ("Error in TIsajet::GetCTH : \n");
2637 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2641 return JETPAR.cth[index];
2644 /**************************************************************************/
2646 Float_t TIsajet::GetSTH(Int_t index) const
2648 Int_t length = (sizeof JETPAR.sth / sizeof JETPAR.sth[0]);
2649 if ((index < 0) || (index >= length)) {
2650 printf ("Error in TIsajet::GetSTH : \n");
2651 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2655 return JETPAR.sth[index];
2658 /**************************************************************************/
2660 Int_t TIsajet::GetJETTYP(Int_t index) const
2662 Int_t length = (sizeof JETPAR.jettyp / sizeof JETPAR.jettyp[0]);
2663 if ((index < 0) || (index >= length)) {
2664 printf ("Error in TIsajet::GetJETTYP : \n");
2665 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2669 return JETPAR.jettyp[index];
2672 /**************************************************************************/
2674 Float_t TIsajet::GetSHAT() const
2679 /**************************************************************************/
2681 Float_t TIsajet::GetTHAT() const
2686 /**************************************************************************/
2688 Float_t TIsajet::GetUHAT() const
2693 /**************************************************************************/
2695 Float_t TIsajet::GetQSQ() const
2700 /**************************************************************************/
2702 Float_t TIsajet::GetX1() const
2707 /**************************************************************************/
2709 Float_t TIsajet::GetX2() const
2714 /**************************************************************************/
2716 Float_t TIsajet::GetPBEAM(Int_t index) const
2718 Int_t length = (sizeof JETPAR.pbeam / sizeof JETPAR.pbeam[0]);
2719 if ((index < 0) || (index >= length)) {
2720 printf ("Error in TIsajet::GetPBEAM : \n");
2721 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2725 return JETPAR.pbeam[index];
2728 /**************************************************************************/
2730 Float_t TIsajet::GetQMW() const
2735 /**************************************************************************/
2737 Float_t TIsajet::GetQW() const
2742 /**************************************************************************/
2744 Float_t TIsajet::GetQTW() const
2749 /**************************************************************************/
2751 Float_t TIsajet::GetYW() const
2756 /**************************************************************************/
2758 Float_t TIsajet::GetXW() const
2763 /**************************************************************************/
2765 Float_t TIsajet::GetTHW() const
2770 /**************************************************************************/
2772 Float_t TIsajet::GetQTMW() const
2777 /**************************************************************************/
2779 Float_t TIsajet::GetPHIW() const
2784 /**************************************************************************/
2786 Float_t TIsajet::GetSHAT1() const
2788 return JETPAR.shat1;
2791 /**************************************************************************/
2793 Float_t TIsajet::GetTHAT1() const
2795 return JETPAR.that1;
2798 /**************************************************************************/
2800 Float_t TIsajet::GetUHAT1() const
2802 return JETPAR.uhat1;
2805 /**************************************************************************/
2807 void TIsajet::SetJWTYP(Int_t val)
2809 if ((val < 1) || (val > 4) || (val == 2))
2811 printf ("Error in TIsajet::SetJWTYP : \n");
2812 printf ("Invalid value %d; range is 1, 3, and 4.\n", val);
2819 /**************************************************************************/
2821 void TIsajet::SetJWTYP(Char_t val[])
2825 if (!strcmp(val, "GM")) value = 1;
2826 else if (!strcmp(val, "W+")) value = 3;
2827 else if (!strcmp(val, "W-")) value = 3;
2828 else if (!strcmp(val, "Z0")) value = 4;
2831 printf ("Error in TIsajet::SetJWTYP : \n");
2832 printf ("Invalid value %s; possible are GM, Z0, W+ and W-.\n", val);
2837 JETPAR.jwtyp = value;
2840 /**************************************************************************/
2842 Int_t TIsajet::GetJWTYP() const
2844 return JETPAR.jwtyp;
2847 /**************************************************************************/
2849 Float_t TIsajet::GetALFQSQ() const
2851 return JETPAR.alfqsq;
2854 /**************************************************************************/
2856 Float_t TIsajet::GetCTHW() const
2861 /**************************************************************************/
2863 Float_t TIsajet::GetSTHW() const
2868 /**************************************************************************/
2870 Float_t TIsajet::GetQ0W() const
2875 /**************************************************************************/
2877 Int_t TIsajet::GetINITYP(Int_t index) const
2879 Int_t length = (sizeof JETPAR.inityp / sizeof JETPAR.inityp[0]);
2880 if ((index < 0) || (index >= length)) {
2881 printf ("Error in TIsajet::GetINITYP : \n");
2882 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2886 return JETPAR.inityp[index];
2889 /**************************************************************************/
2891 Int_t TIsajet::GetISIGS() const
2893 return JETPAR.isigs;
2896 /**************************************************************************/
2898 Float_t TIsajet::GetPBEAMS(Int_t index) const
2900 Int_t length = (sizeof JETPAR.pbeams / sizeof JETPAR.pbeams[0]);
2901 if ((index < 0) || (index >= length)) {
2902 printf ("Error in TIsajet::GetPBEAMS : \n");
2903 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2907 return JETPAR.pbeams[index];
2910 /**************************************************************************/
2912 // Ends JETPAR access.
2913 // Begins KKGRAV access.
2915 /**************************************************************************/
2917 void TIsajet::SetNEXTRAD(Int_t val)
2919 KKGRAV.nextrad = val;
2922 /**************************************************************************/
2924 Int_t TIsajet::GetNEXTRAD() const
2926 return KKGRAV.nextrad;
2929 /**************************************************************************/
2931 void TIsajet::SetMASSD(Float_t val)
2936 /**************************************************************************/
2938 Float_t TIsajet::GetMASSD() const
2940 return KKGRAV.massd;
2943 /**************************************************************************/
2945 Float_t TIsajet::GetKKGSD() const
2947 return KKGRAV.kkgsd;
2950 /**************************************************************************/
2952 Float_t TIsajet::GetSURFD() const
2954 return KKGRAV.surfd;
2957 /**************************************************************************/
2959 void TIsajet::SetUVCUT(Bool_t val)
2964 /**************************************************************************/
2966 Bool_t TIsajet::GetUVCUT() const
2968 return KKGRAV.uvcut;
2971 /**************************************************************************/
2973 // Ends KKGRAV access.
2974 // Begins MBGEN access.
2976 /**************************************************************************/
2978 Float_t TIsajet::GetPOMWT(Int_t index) const
2980 Int_t length = (sizeof MBGEN.pomwt / sizeof MBGEN.pomwt[0]);
2981 if ((index < 0) || (index >= length)) {
2982 printf ("Error in TIsajet::GetPOMWT : \n");
2983 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2987 return MBGEN.pomwt[index];
2990 /**************************************************************************/
2992 Float_t TIsajet::GetPOMGEN(Int_t index) const
2994 Int_t length = (sizeof MBGEN.pomgen / sizeof MBGEN.pomgen[0]);
2995 if ((index < 0) || (index >= length)) {
2996 printf ("Error in TIsajet::GetPOMGEN : \n");
2997 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3001 return MBGEN.pomgen[index];
3004 /**************************************************************************/
3006 void TIsajet::SetMNPOM(Int_t val)
3008 if (val > MBGEN.mxpom) {
3009 printf("Error in TIsajet::SetMNPOM : \n");
3010 printf("You may not set MNPOM to a value larger than MXPOM = %d.\n", MBGEN.mxpom);
3017 /**************************************************************************/
3019 Int_t TIsajet::GetMNPOM() const
3024 /**************************************************************************/
3026 void TIsajet::SetMXPOM(Int_t val)
3028 if (val < MBGEN.mnpom) {
3029 printf("Error in TIsajet::SetMXPOM : \n");
3030 printf("You may not set MXPOM to a value less than MNPOM = %d.\n", MBGEN.mnpom);
3037 /**************************************************************************/
3039 Int_t TIsajet::GetMXPOM() const
3044 /**************************************************************************/
3046 Float_t TIsajet::GetPDIFFR() const
3048 return MBGEN.pdiffr;
3051 /**************************************************************************/
3053 Int_t TIsajet::GetNPOM() const
3058 /**************************************************************************/
3060 Float_t TIsajet::GetXBARY(Int_t index) const
3062 Int_t length = (sizeof MBGEN.xbary / sizeof MBGEN.xbary[0]);
3063 if ((index < 0) || (index >= length)) {
3064 printf ("Error in TIsajet::GetXBARY : \n");
3065 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3069 return MBGEN.xbary[index];
3072 /**************************************************************************/
3074 Float_t TIsajet::GetDXBARY(Int_t index) const
3076 Int_t length = (sizeof MBGEN.dxbary / sizeof MBGEN.dxbary[0]);
3077 if ((index < 0) || (index >= length)) {
3078 printf ("Error in TIsajet::GetDXBARY : \n");
3079 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3083 return MBGEN.dxbary[index];
3086 /**************************************************************************/
3088 Float_t TIsajet::GetXPOM(Int_t index1, Int_t index2) const
3090 Int_t elem_Size = sizeof MBGEN.xpom[0][0];
3091 Int_t sec_Dim_Length = (sizeof MBGEN.xpom[0] / elem_Size);
3092 Int_t fst_Dim_Length = (sizeof MBGEN.xpom / (elem_Size * sec_Dim_Length));
3094 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
3095 printf ("Error in TIsajet::GetXPOM : \n");
3096 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
3100 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
3101 printf ("Error in TIsajet::GetXPOM : \n");
3102 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
3106 return MBGEN.xpom[index1][index2];
3109 /**************************************************************************/
3111 // Ends MBGEN access.
3112 // Begins MGLIMS access.
3114 /**************************************************************************/
3116 void TIsajet::SetEHMGMN(Float_t val)
3118 if (val > MGLIMS.ehmgmx) {
3119 printf("Error in TIsajet::SetEHMGMN : \n");
3120 printf("You may not set EHMGMN to a value larger than EHMGMX = %f.\n", MGLIMS.ehmgmx);
3124 MGLIMS.ehmgmn = val;
3127 /**************************************************************************/
3129 Float_t TIsajet::GetEHMGMN() const
3131 return MGLIMS.ehmgmn;
3134 /**************************************************************************/
3136 void TIsajet::SetEHMGMX(Float_t val)
3138 if (val < MGLIMS.ehmgmn) {
3139 printf("Error in TIsajet::SetEHMGMX : \n");
3140 printf("You may not set EHMGMX to a value less than EHMGMN = %f.\n", MGLIMS.ehmgmn);
3144 MGLIMS.ehmgmx = val;
3147 /**************************************************************************/
3149 Float_t TIsajet::GetEHMGMX() const
3151 return MGLIMS.ehmgmx;
3154 /**************************************************************************/
3156 Float_t TIsajet::GetYHMGMN() const
3158 return MGLIMS.yhmgmn;
3161 /**************************************************************************/
3163 Float_t TIsajet::GetYHMGMX() const
3165 return MGLIMS.yhmgmx;
3168 /**************************************************************************/
3170 void TIsajet::SetAMIJMN(Float_t val, Int_t index1, Int_t index2)
3172 Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3173 Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3175 if ((index1 < 0) || (index1 >= row_num)) {
3176 printf ("Error in TIsajet::SetAMIJMN : \n");
3177 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3181 if ((index2 < 0) || (index2 >= col_num)) {
3182 printf ("Error in TIsajet::SetAMIJMN : \n");
3183 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3187 if (val > MGLIMS.amijmx[index1][index2]) {
3188 printf("Error in TIsajet::SetAMIJMN : \n");
3189 printf("You may not set AMIJMN to a value larger than AMIJMX = %f.\n", MGLIMS.amijmx[index1][index2]);
3193 MGLIMS.amijmn[index1][index2] = val;
3196 /**************************************************************************/
3198 void TIsajet::SetAllAMIJMN(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
3200 for (Int_t i = 0; i < 2; i++) {
3201 for (Int_t j = 0; j < 3; j++) {
3202 SetAMIJMN(val[i][j], i, j);
3207 /**************************************************************************/
3209 void TIsajet::SetColumnAMIJMN(const Float_t val[], Int_t col)
3211 Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3212 Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3214 if ((col < 0) || (col >= col_num)) {
3215 printf ("Error in TIsajet::SetColumnAMIJMN : \n");
3216 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
3220 for (Int_t i = 0; i < row_num; i++) {
3221 SetAMIJMN(val[i], i, col);
3225 /**************************************************************************/
3227 Float_t TIsajet::GetAMIJMN(Int_t index1, Int_t index2) const
3229 Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3230 Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3232 if ((index1 < 0) || (index1 >= row_num)) {
3233 printf ("Error in TIsajet::GetAMIJMN : \n");
3234 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3238 if ((index2 < 0) || (index2 >= col_num)) {
3239 printf ("Error in TIsajet::GetAMIJMN : \n");
3240 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3244 return MGLIMS.amijmn[index1][index2];
3247 /**************************************************************************/
3249 void TIsajet::SetAMIJMX(Float_t val, Int_t index1, Int_t index2)
3251 Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3252 Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3254 if ((index1 < 0) || (index1 >= row_num)) {
3255 printf ("Error in TIsajet::SetAMIJMX : \n");
3256 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3260 if ((index2 < 0) || (index2 >= col_num)) {
3261 printf ("Error in TIsajet::SetAMIJMX : \n");
3262 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3266 if (val < MGLIMS.amijmn[index1][index2]) {
3267 printf("Error in TIsajet::SetAMIJMX : \n");
3268 printf("You may not set AMIJMX to a value less than AMIJMN = %f.\n", MGLIMS.amijmn[index1][index2]);
3272 MGLIMS.amijmx[index1][index2] = val;
3275 /**************************************************************************/
3277 void TIsajet::SetAllAMIJMX(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
3279 for (Int_t i = 0; i < 2; i++) {
3280 for (Int_t j = 0; j < 3; j++) {
3281 SetAMIJMX(val[i][j], i, j);
3286 /**************************************************************************/
3288 void TIsajet::SetColumnAMIJMX(const Float_t val[], Int_t col)
3290 Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3291 Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3293 if ((col < 0) || (col >= col_num)) {
3294 printf ("Error in TIsajet::SetColumnAMIJMX : \n");
3295 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
3299 for (Int_t i = 0; i < row_num; i++) {
3300 SetAMIJMX(val[i], i, col);
3304 /**************************************************************************/
3306 Float_t TIsajet::GetAMIJMX(Int_t index1, Int_t index2) const
3308 Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3309 Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3311 if ((index1 < 0) || (index1 >= row_num)) {
3312 printf ("Error in TIsajet::GetAMIJMX : \n");
3313 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3317 if ((index2 < 0) || (index2 >= col_num)) {
3318 printf ("Error in TIsajet::GetAMIJMX : \n");
3319 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3323 return MGLIMS.amijmx[index1][index2];
3326 /**************************************************************************/
3328 Bool_t TIsajet::GetFIXMIJ(Int_t index1, Int_t index2) const
3330 Int_t elem_Size = sizeof MGLIMS.fixmij[0][0];
3331 Int_t sec_Dim_Length = (sizeof MGLIMS.fixmij[0] / elem_Size);
3332 Int_t fst_Dim_Length = (sizeof MGLIMS.fixmij / (elem_Size * sec_Dim_Length));
3334 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
3335 printf ("Error in TIsajet::GetFIXMIJ : \n");
3336 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
3340 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
3341 printf ("Error in TIsajet::GetFIXMIJ : \n");
3342 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
3346 return MGLIMS.fixmij[index1][index2];
3349 /**************************************************************************/
3351 // Ends MGLIMS access.
3352 // Begins NODCAY access.
3354 /**************************************************************************/
3356 void TIsajet::SetNODCAY(Bool_t val)
3358 NODCAY.nodcay = val;
3362 /**************************************************************************/
3364 Bool_t TIsajet::GetNODCAY() const
3366 return NODCAY.nodcay;
3369 /**************************************************************************/
3371 void TIsajet::SetNOETA(Bool_t val)
3377 /**************************************************************************/
3379 Bool_t TIsajet::GetNOETA() const
3381 return NODCAY.noeta;
3384 /**************************************************************************/
3386 void TIsajet::SetNOPI0(Bool_t val)
3392 /**************************************************************************/
3394 Bool_t TIsajet::GetNOPI0() const
3396 return NODCAY.nopi0;
3399 /**************************************************************************/
3401 void TIsajet::SetNONUNU(Bool_t val)
3403 NODCAY.nonunu = val;
3406 /**************************************************************************/
3408 Bool_t TIsajet::GetNONUNU() const
3410 return NODCAY.nonunu;
3413 /**************************************************************************/
3415 void TIsajet::SetNOEVOL(Bool_t val)
3417 NODCAY.noevol = val;
3421 /**************************************************************************/
3423 Bool_t TIsajet::GetNOEVOL() const
3425 return NODCAY.noevol;
3428 /**************************************************************************/
3430 void TIsajet::SetNOHADR(Bool_t val)
3432 NODCAY.nohadr = val;
3436 /**************************************************************************/
3438 Bool_t TIsajet::GetNOHADR() const
3440 return NODCAY.nohadr;
3443 /**************************************************************************/
3445 void TIsajet::SetNOGRAV(Bool_t val)
3447 NODCAY.nograv = val;
3450 /**************************************************************************/
3452 Bool_t TIsajet::GetNOGRAV() const
3454 return NODCAY.nograv;
3457 /**************************************************************************/
3459 // Ends NODCAY access.
3460 // Begins PARTCL access.
3462 /**************************************************************************/
3464 Int_t TIsajet::GetNPTCL() const
3466 return PARTCL.nptcl;
3469 /**************************************************************************/
3471 Float_t TIsajet::GetPX(Int_t index) const
3473 if ((index < 0) || (index >= PARTCL.nptcl)) {
3474 printf ("Error in TIsajet::GetPX : \n");
3475 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3479 return PARTCL.pptcl[index][0];
3482 /**************************************************************************/
3484 Float_t TIsajet::GetPY(Int_t index) const
3486 if ((index < 0) || (index >= PARTCL.nptcl)) {
3487 printf ("Error in TIsajet::GetPY : \n");
3488 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3492 return PARTCL.pptcl[index][1];
3495 /**************************************************************************/
3497 Float_t TIsajet::GetPZ(Int_t index) const
3499 if ((index < 0) || (index >= PARTCL.nptcl)) {
3500 printf ("Error in TIsajet::GetPZ : \n");
3501 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3505 return PARTCL.pptcl[index][2];
3508 /**************************************************************************/
3510 Float_t TIsajet::GetP0(Int_t index) const
3512 if ((index < 0) || (index >= PARTCL.nptcl)) {
3513 printf ("Error in TIsajet::GetP0 : \n");
3514 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3518 return PARTCL.pptcl[index][3];
3521 /**************************************************************************/
3523 Float_t TIsajet::GetMASS(Int_t index) const
3525 if ((index < 0) || (index >= PARTCL.nptcl)) {
3526 printf ("Error in TIsajet::GetMASS : \n");
3527 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3531 return PARTCL.pptcl[index][4];
3534 /**************************************************************************/
3536 Float_t TIsajet::GetORIG(Int_t index) const
3538 if ((index < 0) || (index >= PARTCL.nptcl)) {
3539 printf ("Error in TIsajet::GetORIG : \n");
3540 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3544 return PARTCL.iorig[index];
3547 /**************************************************************************/
3549 Float_t TIsajet::GetIDENT(Int_t index) const
3551 if ((index < 0) || (index >= PARTCL.nptcl)) {
3552 printf ("Error in TIsajet::GetIDENT : \n");
3553 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3557 return PARTCL.ident[index];
3560 /**************************************************************************/
3562 Float_t TIsajet::GetIDCAY(Int_t index) const
3564 if ((index < 0) || (index >= PARTCL.nptcl)) {
3565 printf ("Error in TIsajet::GetIDCAY : \n");
3566 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3570 return PARTCL.idcay[index];
3573 /**************************************************************************/
3575 // Ends PARTCL access.
3576 // Begins PRIMAR access.
3578 /**************************************************************************/
3580 Int_t TIsajet::GetNJET() const
3585 /**************************************************************************/
3587 Float_t TIsajet::GetSCM() const
3592 /**************************************************************************/
3594 Float_t TIsajet::GetHALFE() const
3596 return PRIMAR.halfe;
3599 /**************************************************************************/
3601 void TIsajet::SetECM(Float_t val)
3604 printf ("Error in TIsajet::SetECM :\n");
3605 printf ("Cannot set energy to a negative value.\n");
3610 PRIMAR.scm = val*val;
3611 PRIMAR.halfe = val / 2;
3614 /**************************************************************************/
3616 Float_t TIsajet::GetECM() const
3621 /**************************************************************************/
3623 void TIsajet::SetIDIN(Int_t val, Int_t index)
3625 Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3626 if ((index < 0) || (index >= length)) {
3627 printf ("Error in TIsajet::SetIDIN : \n");
3628 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3632 if ((val = 1120) || (val = 1220) || (val = -1120) || (val = -1220)) {
3633 PRIMAR.idin[index] = val;
3636 printf ("Error in TIsajet::SetIDIN : \n");
3637 printf ("Invalid input value %d. Possible values are 1120, 1220, -1120, -1220.\n", val);
3644 /**************************************************************************/
3646 void TIsajet::SetIDIN(const Char_t val[], Int_t index)
3648 Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3649 if ((index < 0) || (index >= length)) {
3650 printf ("Error in TIsajet::SetIDIN : \n");
3651 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3655 if (!strcmp("P", val)) {
3656 PRIMAR.idin[index] = 1120;
3658 else if (!strcmp("AP", val)) {
3659 PRIMAR.idin[index] = -1120;
3661 else if (!strcmp("N", val)) {
3662 PRIMAR.idin[index] = 1220;
3664 else if (!strcmp("AN", val)) {
3665 PRIMAR.idin[index] = -1220;
3668 printf ("Error in TIsajet::SetIDIN : \n");
3669 printf ("Invalid input string %s. Possible strings are P, AP, N, and AN.\n", val);
3674 /**************************************************************************/
3676 Int_t TIsajet::GetIDIN(Int_t index) const
3678 Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3679 if ((index < 0) || (index >= length)) {
3680 printf ("Error in TIsajet::GetIDIN : \n");
3681 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3685 return PRIMAR.idin[index];
3688 /**************************************************************************/
3690 Int_t TIsajet::GetNEVENT() const
3692 return PRIMAR.nevent;
3695 /**************************************************************************/
3697 void TIsajet::SetNTRIES(Int_t val)
3699 PRIMAR.ntries = val;
3702 /**************************************************************************/
3704 Int_t TIsajet::GetNTRIES() const
3706 return PRIMAR.ntries;
3709 /**************************************************************************/
3711 void TIsajet::SetNSIGMA(Int_t val)
3713 PRIMAR.nsigma = val;
3717 /**************************************************************************/
3719 Int_t TIsajet::GetNSIGMA() const
3721 return PRIMAR.nsigma;
3724 /**************************************************************************/
3726 // Ends PRIMAR access.
3727 // Begins QCDPAR access.
3729 /**************************************************************************/
3731 void TIsajet::SetALAM(Float_t val)
3734 QCDPAR.alam2 = val*val;
3738 /**************************************************************************/
3740 Float_t TIsajet::GetALAM() const
3745 /**************************************************************************/
3747 Float_t TIsajet::GetALAM2() const
3749 return QCDPAR.alam2;
3752 /**************************************************************************/
3754 void TIsajet::SetCUTJET(Float_t val)
3756 QCDPAR.cutjet = val;
3760 /**************************************************************************/
3762 Float_t TIsajet::GetCUTJET() const
3764 return QCDPAR.cutjet;
3767 /**************************************************************************/
3769 void TIsajet::SetISTRUC(Int_t val)
3771 if ((val < 1) || (val > 6)) {
3772 printf ("Error in TIsajet::SetISTRUC : \n");
3773 printf ("Invalid input value %d. Possible values are 1 through 6.\n", val);
3776 QCDPAR.istruc = val;
3779 /**************************************************************************/
3781 void TIsajet::SetISTRUC(const Char_t val[])
3783 if (!strcmp("OWENS", val)) {
3786 else if (!strcmp("BAIER", val)) {
3789 else if ((!strcmp("EICHTEN", val)) || (!strcmp("EHLQ", val))) {
3792 else if ((!strcmp("DUKE", val)) || (!strcmp("DO", val))) {
3795 else if (!strcmp("CTEQ2L", val)) {
3798 else if ((!strcmp("CTEQ", val)) || (!strcmp("CTEQ3L", val))) {
3802 printf ("Error in TIsajet::SetISTRUC : \n");
3803 printf ("Invalid input string %s. Possible strings are OWENS, BAIER, EICHTEN, \n", val);
3804 printf ("EHLQ, DUKE, DO, CTEQ2L, CTEQ, and CTEQ3L.\n");
3809 /**************************************************************************/
3811 Int_t TIsajet::GetISTRUC() const
3813 return QCDPAR.istruc;
3816 /**************************************************************************/
3818 // Ends QCDPAR access.
3819 // Begins QLMASS access.
3821 /**************************************************************************/
3823 void TIsajet::SetAMLEP(Float_t val, Int_t index)
3825 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3826 if ((index < 0) || (index >= length)) {
3827 printf ("Error in TIsajet::SetAMLEP : \n");
3828 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3832 if (((index < 5) && (index > 7)) &&
3833 ((index < 21) && (index > 26)) &&
3834 ((index < 29) && (index > 36)) &&
3835 ((index < 39) && (index > 40)) &&
3836 ((index < 63) && (index > 71)))
3838 printf ("Error in TIsajet::SetAMLEP : \n");
3839 printf ("Index %d may not be set by the user. Valid indices are : \n", index);
3840 printf ("5-7, 21-26, 29-36, 39-40 and 63-71.\n");
3844 QLMASS.amlep[index] = val;
3847 /**************************************************************************/
3849 Float_t TIsajet::GetAMLEP(Int_t index) const
3851 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3852 if ((index < 0) || (index >= length)) {
3853 printf ("Error in TIsajet::GetAMLEP : \n");
3854 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3857 if ((index < 5) || (index > 71) ||
3858 ((index > 7) && (index < 21)) ||
3859 ((index > 26) && (index < 29)) ||
3860 ((index > 36) && (index < 39)) ||
3861 ((index > 40) && (index < 63)))
3863 printf ("Possible error in TIsajet::GetAMLEP : \n");
3864 printf ("Index %d may not be set by the user. Valid indices are : \n", index);
3865 printf ("5-7, 21-26, 29-36, 39-40 and 63-71. \n");
3866 printf ("To return the value of this index, use GetAnyAMLEP(Int_t index).\n");
3871 return QLMASS.amlep[index];
3874 /**************************************************************************/
3876 Float_t TIsajet::GetAnyAMLEP(Int_t index) const
3878 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3879 if ((index < 0) || (index >= length)) {
3880 printf ("Error in TIsajet::GetAnyAMLEP : \n");
3881 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3885 return QLMASS.amlep[index];
3888 /**************************************************************************/
3890 void TIsajet::SetTquarkMass(Float_t val)
3892 QLMASS.amlep[5] = val;
3895 /**************************************************************************/
3897 Float_t TIsajet::GetTquarkMass() const
3899 return QLMASS.amlep[5];
3902 /**************************************************************************/
3904 void TIsajet::SetXquarkMass(Float_t val)
3906 QLMASS.amlep[6] = val;
3909 /**************************************************************************/
3911 Float_t TIsajet::GetXquarkMass() const
3913 return QLMASS.amlep[6];
3916 /**************************************************************************/
3918 void TIsajet::SetYquarkMass(Float_t val)
3920 QLMASS.amlep[7] = val;
3923 /**************************************************************************/
3925 Float_t TIsajet::GetYquarkMass() const
3927 return QLMASS.amlep[7];
3930 /**************************************************************************/
3932 void TIsajet::SetUtildeMass(Float_t val)
3934 QLMASS.amlep[21] = val;
3937 /**************************************************************************/
3939 Float_t TIsajet::GetUtildeMass() const
3941 return QLMASS.amlep[21];
3944 /**************************************************************************/
3946 void TIsajet::SetDtildeMass(Float_t val)
3948 QLMASS.amlep[22] = val;
3951 /**************************************************************************/
3953 Float_t TIsajet::GetDtildeMass() const
3955 return QLMASS.amlep[22];
3958 /**************************************************************************/
3960 void TIsajet::SetStildeMass(Float_t val)
3962 QLMASS.amlep[23] = val;
3965 /**************************************************************************/
3967 Float_t TIsajet::GetStildeMass() const
3969 return QLMASS.amlep[23];
3972 /**************************************************************************/
3974 void TIsajet::SetCtildeMass(Float_t val)
3976 QLMASS.amlep[24] = val;
3979 /**************************************************************************/
3981 Float_t TIsajet::GetCtildeMass() const
3983 return QLMASS.amlep[24];
3986 /**************************************************************************/
3988 void TIsajet::SetBtildeMass(Float_t val)
3990 QLMASS.amlep[25] = val;
3993 /**************************************************************************/
3995 Float_t TIsajet::GetBtildeMass() const
3997 return QLMASS.amlep[25];
4000 /**************************************************************************/
4002 void TIsajet::SetTtildeMass(Float_t val)
4004 QLMASS.amlep[26] = val;
4007 /**************************************************************************/
4009 Float_t TIsajet::GetTtildeMass() const
4011 return QLMASS.amlep[26];
4014 /**************************************************************************/
4016 void TIsajet::SetGtildeMass(Float_t val)
4018 QLMASS.amlep[29] = val;
4021 /**************************************************************************/
4023 Float_t TIsajet::GetGtildeMass() const
4025 return QLMASS.amlep[29];
4028 /**************************************************************************/
4030 void TIsajet::SetGammatildeMass(Float_t val)
4032 QLMASS.amlep[30] = val;
4035 /**************************************************************************/
4037 Float_t TIsajet::GetGammatildeMass() const
4039 return QLMASS.amlep[30];
4042 /**************************************************************************/
4044 void TIsajet::SetNuEtildeMass(Float_t val)
4046 QLMASS.amlep[31] = val;
4049 /**************************************************************************/
4051 Float_t TIsajet::GetNuEtildeMass() const
4053 return QLMASS.amlep[31];
4056 /**************************************************************************/
4058 void TIsajet::SetEtildeMass(Float_t val)
4060 QLMASS.amlep[32] = val;
4063 /**************************************************************************/
4065 Float_t TIsajet::GetEtildeMass() const
4067 return QLMASS.amlep[32];
4070 /**************************************************************************/
4072 void TIsajet::SetNuMutildeMass(Float_t val)
4074 QLMASS.amlep[33] = val;
4077 /**************************************************************************/
4079 Float_t TIsajet::GetNuMutildeMass() const
4081 return QLMASS.amlep[33];
4084 /**************************************************************************/
4086 void TIsajet::SetMutildeMass(Float_t val)
4088 QLMASS.amlep[34] = val;
4091 /**************************************************************************/
4093 Float_t TIsajet::GetMutildeMass() const
4095 return QLMASS.amlep[34];
4098 /**************************************************************************/
4100 void TIsajet::SetNuTautildeMass(Float_t val)
4102 QLMASS.amlep[35] = val;
4105 /**************************************************************************/
4107 Float_t TIsajet::GetNuTautildeMass() const
4109 return QLMASS.amlep[35];
4112 /**************************************************************************/
4114 void TIsajet::SetTautildeMass(Float_t val)
4116 QLMASS.amlep[36] = val;
4119 /**************************************************************************/
4121 Float_t TIsajet::GetTautildeMass() const
4123 return QLMASS.amlep[36];
4126 /**************************************************************************/
4128 void TIsajet::SetWplustildeMass(Float_t val)
4130 QLMASS.amlep[39] = val;
4133 /**************************************************************************/
4135 Float_t TIsajet::GetWplustildeMass() const
4137 return QLMASS.amlep[39];
4140 /**************************************************************************/
4142 void TIsajet::SetZ0tildeMass(Float_t val)
4144 QLMASS.amlep[40] = val;
4147 /**************************************************************************/
4149 Float_t TIsajet::GetZ0tildeMass() const
4151 return QLMASS.amlep[40];
4154 /**************************************************************************/
4156 void TIsajet::SetHiggsMesonMass(Float_t val, Int_t index)
4158 if ((index < 1) || (index > 9)) {
4159 printf ("Error in TIsajet::SetHiggsMesonMass : \n");
4160 printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
4164 QLMASS.amlep[62 + index] = val;
4167 /**************************************************************************/
4169 Float_t TIsajet::GetHiggsMesonMass(Int_t index) const
4171 if ((index < 1) || (index > 9)) {
4172 printf ("Error in TIsajet::GetHiggsMesonMass : \n");
4173 printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
4177 return QLMASS.amlep[62 + index];
4180 /**************************************************************************/
4182 Int_t TIsajet::GetNQLEP() const
4184 return QLMASS.nqlep;
4187 /**************************************************************************/
4189 Int_t TIsajet::GetNMES() const
4194 /**************************************************************************/
4196 Int_t TIsajet::GetNBARY() const
4198 return QLMASS.nbary;
4201 /**************************************************************************/
4203 // Ends QLMASS access.
4204 // Begins SEED access.
4206 /**************************************************************************/
4208 void TIsajet::SetSEED(const Char_t val[24])
4210 Int_t length = (sizeof SEED.xseed / sizeof SEED.xseed[0]);
4212 for (Int_t i = 0; i < length; i++) {
4213 SEED.xseed[i] = val[i];
4217 /**************************************************************************/
4219 Char_t* TIsajet::GetSEED() const
4224 /**************************************************************************/
4226 // Ends SEED access - short and sweet, wasn't it?
4227 // Begins SUGNU access, an entirely different business.
4229 /**************************************************************************/
4231 void TIsajet::SetXNUSUG(Float_t val, Int_t index)
4233 Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
4234 if ((index < 0) || (index >= length)) {
4235 printf ("Error in TIsajet::SetXNUSUG : \n");
4236 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4240 SUGNU.xnusug[index] = val;
4243 /**************************************************************************/
4245 Float_t TIsajet::GetXNUSUG(Int_t index) const
4247 Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
4248 if ((index < 0) || (index >= length)) {
4249 printf ("Error in TIsajet::GetXNUSUG : \n");
4250 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4254 return SUGNU.xnusug[index];
4257 /**************************************************************************/
4259 void TIsajet::SetGauginoMass(Float_t val, Int_t index)
4261 if ((index < 1) || (index > 9)) {
4262 printf ("Error in TIsajet::SetGauginoMass : \n");
4263 printf ("Invalid gaugino number %d; range is 1-3.\n", index);
4267 SUGNU.xnusug[index-1] = val;
4270 /**************************************************************************/
4272 Float_t TIsajet::GetGauginoMass(Int_t index) const
4274 if ((index < 1) || (index > 3)) {
4275 printf ("Error in TIsajet::GetGauginoMass : \n");
4276 printf ("Invalid gaugino number %d; range is 1-3.\n", index);
4280 return SUGNU.xnusug[index-1];
4283 /**************************************************************************/
4285 void TIsajet::SetAtau(Float_t val)
4287 SUGNU.xnusug[3] = val;
4290 /**************************************************************************/
4292 Float_t TIsajet::GetAtau() const
4294 return SUGNU.xnusug[3];
4297 /**************************************************************************/
4299 void TIsajet::SetAb(Float_t val)
4301 SUGNU.xnusug[4] = val;
4304 /**************************************************************************/
4306 Float_t TIsajet::GetAb() const
4308 return SUGNU.xnusug[4];
4311 /**************************************************************************/
4313 void TIsajet::SetAt(Float_t val)
4315 SUGNU.xnusug[5] = val;
4318 /**************************************************************************/
4320 Float_t TIsajet::GetAt() const
4322 return SUGNU.xnusug[5];
4325 /**************************************************************************/
4327 void TIsajet::SetHiggsDmass(Float_t val)
4329 SUGNU.xnusug[6] = val;
4332 /**************************************************************************/
4334 Float_t TIsajet::GetHiggsDmass() const
4336 return SUGNU.xnusug[6];
4339 /**************************************************************************/
4341 void TIsajet::SetHiggsUmass(Float_t val)
4343 SUGNU.xnusug[7] = val;
4346 /**************************************************************************/
4348 Float_t TIsajet::GetHiggsUmass() const
4350 return SUGNU.xnusug[7];
4353 /**************************************************************************/
4355 void TIsajet::SetERmass(Float_t val)
4357 SUGNU.xnusug[8] = val;
4360 /**************************************************************************/
4362 Float_t TIsajet::GetERmass() const
4364 return SUGNU.xnusug[8];
4367 /**************************************************************************/
4369 void TIsajet::SetELmass(Float_t val)
4371 SUGNU.xnusug[9] = val;
4374 /**************************************************************************/
4376 Float_t TIsajet::GetELmass() const
4378 return SUGNU.xnusug[9];
4381 /**************************************************************************/
4383 void TIsajet::SetDRmass(Float_t val)
4385 SUGNU.xnusug[10] = val;
4388 /**************************************************************************/
4390 Float_t TIsajet::GetDRmass() const
4392 return SUGNU.xnusug[10];
4395 /**************************************************************************/
4397 void TIsajet::SetURmass(Float_t val)
4399 SUGNU.xnusug[11] = val;
4402 /**************************************************************************/
4404 Float_t TIsajet::GetURmass() const
4406 return SUGNU.xnusug[11];
4409 /**************************************************************************/
4411 void TIsajet::SetULmass(Float_t val)
4413 SUGNU.xnusug[12] = val;
4416 /**************************************************************************/
4418 Float_t TIsajet::GetULmass() const
4420 return SUGNU.xnusug[12];
4423 /**************************************************************************/
4425 void TIsajet::SetTauRmass(Float_t val)
4427 SUGNU.xnusug[13] = val;
4430 /**************************************************************************/
4432 Float_t TIsajet::GetTauRmass() const
4434 return SUGNU.xnusug[13];
4437 /**************************************************************************/
4439 void TIsajet::SetTauLmass(Float_t val)
4441 SUGNU.xnusug[14] = val;
4444 /**************************************************************************/
4446 Float_t TIsajet::GetTauLmass() const
4448 return SUGNU.xnusug[14];
4451 /**************************************************************************/
4453 void TIsajet::SetBRmass(Float_t val)
4455 SUGNU.xnusug[15] = val;
4458 /**************************************************************************/
4460 Float_t TIsajet::GetBRmass() const
4462 return SUGNU.xnusug[15];
4465 /**************************************************************************/
4467 void TIsajet::SetTRmass(Float_t val)
4469 SUGNU.xnusug[16] = val;
4472 /**************************************************************************/
4474 Float_t TIsajet::GetTRmass() const
4476 return SUGNU.xnusug[16];
4479 /**************************************************************************/
4481 void TIsajet::SetTLmass(Float_t val)
4483 SUGNU.xnusug[17] = val;
4486 /**************************************************************************/
4488 Float_t TIsajet::GetTLmass() const
4490 return SUGNU.xnusug[17];
4493 /**************************************************************************/
4495 // Ends XNUSUG access.
4496 // Begins TCPAR access.
4498 /**************************************************************************/
4500 void TIsajet::SetTCMRHO(Float_t val)
4505 /**************************************************************************/
4507 Float_t TIsajet::GetTCMRHO() const
4509 return TCPAR.tcmrho;
4512 /**************************************************************************/
4514 void TIsajet::SetTCGRHO(Float_t val)
4519 /**************************************************************************/
4521 Float_t TIsajet::GetTCGRHO() const
4523 return TCPAR.tcgrho;
4526 /**************************************************************************/
4528 // Ends TCPAR access.
4529 // Begins TYPES access.
4531 /**************************************************************************/
4533 Int_t TIsajet::GetLOC(Int_t index) const
4535 Int_t length = (sizeof TYPES.loc / sizeof TYPES.loc[0]);
4536 if ((index < 0) || (index >= length)) {
4537 printf ("Error in TIsajet::GetLOC : \n");
4538 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4542 return TYPES.loc[index];
4545 /**************************************************************************/
4547 Int_t TIsajet::GetNTYP() const
4552 /**************************************************************************/
4554 Int_t TIsajet::GetNJTTYP(Int_t index) const
4556 Int_t length = (sizeof TYPES.njttyp / sizeof TYPES.njttyp[0]);
4557 if ((index < 0) || (index >= length)) {
4558 printf ("Error in TIsajet::GetNJTYP : \n");
4559 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4563 return TYPES.njttyp[index];
4566 /**************************************************************************/
4568 Int_t TIsajet::GetNWWTYP(Int_t index) const
4570 Int_t length = (sizeof TYPES.nwwtyp / sizeof TYPES.nwwtyp[0]);
4571 if ((index < 0) || (index >= length)) {
4572 printf ("Error in TIsajet::GetNWWTYP : \n");
4573 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4577 return TYPES.nwwtyp[index];
4580 /**************************************************************************/
4582 Int_t TIsajet::GetNWMODE(Int_t index) const
4584 Int_t length = (sizeof TYPES.nwmode / sizeof TYPES.nwmode[0]);
4585 if ((index < 0) || (index >= length)) {
4586 printf ("Error in TIsajet::GetNWMODE : \n");
4587 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4591 return TYPES.nwmode[index];
4594 /**************************************************************************/
4596 // Ends TYPES access.
4597 // Begins XMSSM access.
4599 /**************************************************************************/
4601 Bool_t TIsajet::GetGOMSSM() const
4603 return XMSSM.gomssm;
4606 /**************************************************************************/
4608 Bool_t TIsajet::GetGOSUG() const
4613 /**************************************************************************/
4615 Bool_t TIsajet::GetGOGMSB() const
4617 return XMSSM.gogmsb;
4620 /**************************************************************************/
4622 Bool_t TIsajet::GetGOAMSB() const
4624 return XMSSM.goamsb;
4627 /**************************************************************************/
4629 Bool_t TIsajet::GetAL3UNI() const
4631 return XMSSM.al3uni;
4634 /**************************************************************************/
4636 void TIsajet::SetXGLSS(Float_t val)
4641 /**************************************************************************/
4643 Float_t TIsajet::GetXGLSS() const
4648 /**************************************************************************/
4650 void TIsajet::SetXMUSS(Float_t val)
4655 /**************************************************************************/
4657 Float_t TIsajet::GetXMUSS() const
4662 /**************************************************************************/
4664 void TIsajet::SetXHASS(Float_t val)
4669 /**************************************************************************/
4671 Float_t TIsajet::GetXHASS() const
4676 /**************************************************************************/
4678 void TIsajet::SetXTBSS(Float_t val)
4683 /**************************************************************************/
4685 Float_t TIsajet::GetXTBSS() const
4690 /**************************************************************************/
4692 void TIsajet::SetXQ1SS(Float_t val)
4697 /**************************************************************************/
4699 Float_t TIsajet::GetXQ1SS() const
4704 /**************************************************************************/
4706 void TIsajet::SetXDRSS(Float_t val)
4711 /**************************************************************************/
4713 Float_t TIsajet::GetXDRSS() const
4718 /**************************************************************************/
4720 void TIsajet::SetXURSS(Float_t val)
4725 /**************************************************************************/
4727 Float_t TIsajet::GetXURSS() const
4732 /**************************************************************************/
4734 void TIsajet::SetXL1SS(Float_t val)
4739 /**************************************************************************/
4741 Float_t TIsajet::GetXL1SS() const
4746 /**************************************************************************/
4748 void TIsajet::SetXERSS(Float_t val)
4753 /**************************************************************************/
4755 Float_t TIsajet::GetXERSS() const
4760 /**************************************************************************/
4762 void TIsajet::SetXQ2SS(Float_t val)
4767 /**************************************************************************/
4769 Float_t TIsajet::GetXQ2SS() const
4774 /**************************************************************************/
4776 void TIsajet::SetXSRSS(Float_t val)
4781 /**************************************************************************/
4783 Float_t TIsajet::GetXSRSS() const
4788 /**************************************************************************/
4790 void TIsajet::SetXCRSS(Float_t val)
4795 /**************************************************************************/
4797 Float_t TIsajet::GetXCRSS() const
4802 /**************************************************************************/
4804 void TIsajet::SetXL2SS(Float_t val)
4809 /**************************************************************************/
4811 Float_t TIsajet::GetXL2SS() const
4816 /**************************************************************************/
4818 void TIsajet::SetXMRSS(Float_t val)
4823 /**************************************************************************/
4825 Float_t TIsajet::GetXMRSS() const
4830 /**************************************************************************/
4832 void TIsajet::SetXQ3SS(Float_t val)
4837 /**************************************************************************/
4839 Float_t TIsajet::GetXQ3SS() const
4844 /**************************************************************************/
4846 void TIsajet::SetXBRSS(Float_t val)
4851 /**************************************************************************/
4853 Float_t TIsajet::GetXBRSS() const
4858 /**************************************************************************/
4860 void TIsajet::SetXTRSS(Float_t val)
4865 /**************************************************************************/
4867 Float_t TIsajet::GetXTRSS() const
4872 /**************************************************************************/
4874 void TIsajet::SetXL3SS(Float_t val)
4879 /**************************************************************************/
4881 Float_t TIsajet::GetXL3SS() const
4886 /**************************************************************************/
4888 void TIsajet::SetXTARSS(Float_t val)
4893 /**************************************************************************/
4895 Float_t TIsajet::GetXTARSS() const
4897 return XMSSM.xtarss;
4900 /**************************************************************************/
4902 void TIsajet::SetXATSS(Float_t val)
4907 /**************************************************************************/
4909 Float_t TIsajet::GetXATSS() const
4914 /**************************************************************************/
4916 void TIsajet::SetXABSS(Float_t val)
4921 /**************************************************************************/
4923 Float_t TIsajet::GetXABSS() const
4928 /**************************************************************************/
4930 void TIsajet::SetXATASS(Float_t val)
4935 /**************************************************************************/
4937 Float_t TIsajet::GetXATASS() const
4939 return XMSSM.xatass;
4942 /**************************************************************************/
4944 void TIsajet::SetXM1SS(Float_t val)
4949 /**************************************************************************/
4951 Float_t TIsajet::GetXM1SS() const
4956 /**************************************************************************/
4958 void TIsajet::SetXM2SS(Float_t val)
4963 /**************************************************************************/
4965 Float_t TIsajet::GetXM2SS() const
4970 /**************************************************************************/
4972 void TIsajet::SetXM0SU(Float_t val)
4977 /**************************************************************************/
4979 Float_t TIsajet::GetXM0SU() const
4984 /**************************************************************************/
4986 void TIsajet::SetXMHSU(Float_t val)
4991 /**************************************************************************/
4993 Float_t TIsajet::GetXMHSU() const
4998 /**************************************************************************/
5000 void TIsajet::SetXA0SU(Float_t val)
5005 /**************************************************************************/
5007 Float_t TIsajet::GetXA0SU() const
5012 /**************************************************************************/
5014 void TIsajet::SetXTGBSU(Float_t val)
5019 /**************************************************************************/
5021 Float_t TIsajet::GetXTGBSU() const
5023 return XMSSM.xtgbsu;
5026 /**************************************************************************/
5028 void TIsajet::SetXSMUSU(Float_t val)
5033 /**************************************************************************/
5035 Float_t TIsajet::GetXSMUSU() const
5037 return XMSSM.xsmusu;
5040 /**************************************************************************/
5042 void TIsajet::SetXLAMGM(Float_t val)
5047 /**************************************************************************/
5049 Float_t TIsajet::GetXLAMGM() const
5051 return XMSSM.xlamgm;
5054 /**************************************************************************/
5056 void TIsajet::SetXMESGM(Float_t val)
5061 /**************************************************************************/
5063 Float_t TIsajet::GetXMESGM() const
5065 return XMSSM.xmesgm;
5068 /**************************************************************************/
5070 void TIsajet::SetXN5GM(Float_t val)
5075 /**************************************************************************/
5077 Float_t TIsajet::GetXN5GM() const
5082 /**************************************************************************/
5084 void TIsajet::SetXCMGV(Float_t val)
5089 /**************************************************************************/
5091 Float_t TIsajet::GetXCMGV() const
5096 /**************************************************************************/
5098 void TIsajet::SetMGVTO(Float_t val)
5103 /**************************************************************************/
5105 Float_t TIsajet::GetMGVTO() const
5110 /**************************************************************************/
5112 void TIsajet::SetXRSLGM(Float_t val)
5117 /**************************************************************************/
5119 Float_t TIsajet::GetXRSLGM() const
5121 return XMSSM.xrslgm;
5124 /**************************************************************************/
5126 void TIsajet::SetXDHDGM(Float_t val)
5131 /**************************************************************************/
5133 Float_t TIsajet::GetXDHDGM() const
5135 return XMSSM.xdhdgm;
5138 /**************************************************************************/
5140 void TIsajet::SetXDHUGM(Float_t val)
5145 /**************************************************************************/
5147 Float_t TIsajet::GetXDHUGM() const
5149 return XMSSM.xdhugm;
5152 /**************************************************************************/
5154 void TIsajet::SetXDYGM(Float_t val)
5159 /**************************************************************************/
5161 Float_t TIsajet::GetXDYGM() const
5166 /**************************************************************************/
5168 void TIsajet::SetXN51GM(Float_t val)
5173 /**************************************************************************/
5175 Float_t TIsajet::GetXN51GM() const
5177 return XMSSM.xn51gm;
5180 /**************************************************************************/
5182 void TIsajet::SetXN52GM(Float_t val)
5187 /**************************************************************************/
5189 Float_t TIsajet::GetXN52GM() const
5191 return XMSSM.xn52gm;
5194 /**************************************************************************/
5196 void TIsajet::SetXN53GM(Float_t val)
5201 /**************************************************************************/
5203 Float_t TIsajet::GetXN53GM() const
5205 return XMSSM.xn53gm;
5208 /**************************************************************************/
5210 void TIsajet::SetXMN3NR(Float_t val)
5215 /**************************************************************************/
5217 Float_t TIsajet::GetXMN3NR() const
5219 return XMSSM.xmn3nr;
5222 /**************************************************************************/
5224 void TIsajet::SetXMAJNR(Float_t val)
5229 /**************************************************************************/
5231 Float_t TIsajet::GetXMAJNR() const
5233 return XMSSM.xmajnr;
5236 /**************************************************************************/
5238 void TIsajet::SetXANSS(Float_t val)
5243 /**************************************************************************/
5245 Float_t TIsajet::GetXANSS() const
5250 /**************************************************************************/
5252 void TIsajet::SetXNRSS(Float_t val)
5257 /**************************************************************************/
5259 Float_t TIsajet::GetXNRSS() const
5264 /**************************************************************************/
5266 void TIsajet::SetXSBCS(Float_t val)
5271 /**************************************************************************/
5273 Float_t TIsajet::GetXSBCS() const
5278 /**************************************************************************/
5280 // Ends XMSSM access.
5281 // Begins XTYPES access.
5283 /**************************************************************************/
5285 Char_t* TIsajet::GetPARTYP(Int_t index) const
5287 Int_t length = (sizeof XTYPES.partyp / sizeof XTYPES.partyp[0]);
5288 if ((index < 0) || (index >= length)) {
5289 printf ("Error in TIsajet::GetPARTYP : \n");
5290 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5294 return XTYPES.partyp[index];
5297 /**************************************************************************/
5299 void TIsajet::SetTITLE(Char_t *val)
5301 title = XTYPES.title = val;
5304 /**************************************************************************/
5305 Char_t* TIsajet::GetTITLE() const
5307 return XTYPES.title;
5310 /**************************************************************************/
5312 void TIsajet::SetJETYP(Int_t index, Char_t val[])
5314 Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
5315 Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
5317 if ((index < 0) || (index >= row_num)) {
5318 printf ("Error in TIsajet::SetJETYP : \n");
5319 printf ("Invalid array row index %d; range is 0-%d.\n", index, row_num-1);
5323 if (TYPES.njttyp[index] >= col_num) {
5324 printf ("Error in TIsajet::SetJETYP : \n");
5325 printf ("Cannot set more than %d jet types.\n", col_num-1);
5329 if ((!strcmp(val, "ALL")) || (!strcmp(val, "GL")) ||
5330 (!strcmp(val, "UP")) || (!strcmp(val, "UB")) ||
5331 (!strcmp(val, "DN")) || (!strcmp(val, "DB")) ||
5332 (!strcmp(val, "ST")) || (!strcmp(val, "SB")) ||
5333 (!strcmp(val, "CH")) || (!strcmp(val, "CB")) ||
5334 (!strcmp(val, "BT")) || (!strcmp(val, "BB")) ||
5335 (!strcmp(val, "TP")) || (!strcmp(val, "TB")) ||
5336 (!strcmp(val, "X")) || (!strcmp(val, "XB")) ||
5337 (!strcmp(val, "Y")) || (!strcmp(val, "YB")) ||
5338 (!strcmp(val, "E-")) || (!strcmp(val, "E+")) ||
5339 (!strcmp(val, "MU-")) || (!strcmp(val, "MU+")) ||
5340 (!strcmp(val, "TAU-")) || (!strcmp(val, "TAU+")) ||
5341 (!strcmp(val, "NUS")) || (!strcmp(val, "GM")) ||
5342 (!strcmp(val, "W+")) || (!strcmp(val, "W-")) ||
5343 (!strcmp(val, "Z0"))) {
5345 XTYPES.jetyp[index][TYPES.njttyp[index]++] = val;
5348 printf ("Error in TIsajet::SetJETYP : \n");
5349 printf ("Invalid jet type %s; valid types are\n", val);
5350 printf ("ALL, GL, UP, UB, DN, DB, ST, SB,\n");
5351 printf ("CH, CB, BT, BB, TP, TB, X, XB, Y, YB,\n");
5352 printf ("E-, E+, MU-, MU+, TAU-, TAU+, NUS, GM,\n");
5353 printf ("W+, W- and Z0.\n");
5357 if (index == 0) setJettype1 = true;
5358 else if (index == 1) setJettype2 = true;
5359 else if (index == 2) setJettype3 = true;
5362 /**************************************************************************/
5364 Char_t* TIsajet::GetJETYP(Int_t index1, Int_t index2) const
5366 Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
5367 Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
5369 if ((index1 < 0) || (index1 >= row_num)) {
5370 printf ("Error in TIsajet::GetJETYP : \n");
5371 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5375 if ((index2 < 0) || (index2 >= col_num)) {
5376 printf ("Error in TIsajet::GetJETYP : \n");
5377 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5381 return XTYPES.jetyp[index1][index2];
5384 /**************************************************************************/
5386 void TIsajet::SetWWTYP(Char_t val[], Int_t index1, Int_t index2)
5388 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5389 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5391 if ((index1 < 0) || (index1 >= row_num)) {
5392 printf ("Error in TIsajet::SetWWTYP : \n");
5393 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5397 if ((index2 < 0) || (index2 >= col_num)) {
5398 printf ("Error in TIsajet::SetWWTYP : \n");
5399 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5403 XTYPES.wwtyp[index1][index2] = val;
5406 /**************************************************************************/
5408 void TIsajet::SetAllWWTYP(Char_t* val[2][30])
5410 for (Int_t i = 0; i < 2; i++) {
5411 for (Int_t j = 0; j < 30; j++) {
5412 SetWWTYP(val[i][j], i, j);
5417 /**************************************************************************/
5419 void TIsajet::SetColumnWWTYP(Char_t* val[], Int_t col)
5421 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5422 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5424 if ((col < 0) || (col >= col_num)) {
5425 printf ("Error in TIsajet::SetColumnWWTYP : \n");
5426 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
5430 for (Int_t i = 0; i < row_num; i++) {
5431 SetWWTYP(val[i], i, col);
5435 /**************************************************************************/
5437 Char_t* TIsajet::GetWWTYP(Int_t index1, Int_t index2) const
5439 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5440 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5442 if ((index1 < 0) || (index1 >= row_num)) {
5443 printf ("Error in TIsajet::GetWWTYP : \n");
5444 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5448 if ((index2 < 0) || (index2 >= col_num)) {
5449 printf ("Error in TIsajet::GetWWTYP : \n");
5450 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5454 return XTYPES.wwtyp[index1][index2];
5457 /**************************************************************************/
5459 void TIsajet::SetWMODES(Char_t val[], Int_t index1, Int_t index2)
5461 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5462 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5464 if ((index1 < 0) || (index1 >= row_num)) {
5465 printf ("Error in TIsajet::SetWMODES : \n");
5466 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5470 if ((index2 < 0) || (index2 >= col_num)) {
5471 printf ("Error in TIsajet::SetWMODES : \n");
5472 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5476 XTYPES.wmodes[index1][index2] = val;
5479 /**************************************************************************/
5481 void TIsajet::SetAllWMODES(Char_t* val[2][30])
5483 for (Int_t i = 0; i < 2; i++) {
5484 for (Int_t j = 0; j < 30; j++) {
5485 SetWMODES(val[i][j], i, j);
5490 /**************************************************************************/
5492 void TIsajet::SetColumnWMODES(Char_t* val[], Int_t col)
5494 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5495 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5497 if ((col < 0) || (col >= col_num)) {
5498 printf ("Error in TIsajet::SetColumnWMODES : \n");
5499 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
5503 for (Int_t i = 0; i < row_num; i++) {
5504 SetWMODES(val[i], i, col);
5508 /**************************************************************************/
5510 Char_t* TIsajet::GetWMODES(Int_t index1, Int_t index2) const
5512 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5513 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5515 if ((index1 < 0) || (index1 >= row_num)) {
5516 printf ("Error in TIsajet::GetWMODES : \n");
5517 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5521 if ((index2 < 0) || (index2 >= col_num)) {
5522 printf ("Error in TIsajet::GetWMODES : \n");
5523 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5527 return XTYPES.wmodes[index1][index2];
5530 /**************************************************************************/
5532 // Ends XTYPES access.
5533 // Begins WCON access.
5535 /**************************************************************************/
5537 void TIsajet::SetSIN2W(Float_t val)
5542 /**************************************************************************/
5544 Float_t TIsajet::GetSIN2W() const
5549 /**************************************************************************/
5551 void TIsajet::SetWMASS(Float_t w, Float_t z)
5554 // This is how the FORTRAN does it. Don't ask me why.
5557 WCON.wmass[1] = WCON.wmass[2] = w;
5561 /**************************************************************************/
5563 Float_t TIsajet::GetWMASS(Int_t index) const
5565 Int_t length = (sizeof WCON.wmass / sizeof WCON.wmass[0]);
5566 if ((index < 0) || (index >= length)) {
5567 printf ("Error in TIsajet::GetWMASS : \n");
5568 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5572 return WCON.wmass[index];
5575 /**************************************************************************/
5577 void TIsajet::SetWMass(Float_t val)
5579 WCON.wmass[1] = WCON.wmass[2] = val;
5582 /**************************************************************************/
5584 void TIsajet::SetZMass(Float_t val)
5586 WCON.wmass[3] = val;
5589 /**************************************************************************/
5591 Float_t TIsajet::GetWGAM(Int_t index) const
5593 Int_t length = (sizeof WCON.wgam / sizeof WCON.wgam[0]);
5594 if ((index < 0) || (index >= length)) {
5595 printf ("Error in TIsajet::GetWGAM : \n");
5596 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5600 return WCON.wgam[index];
5603 /**************************************************************************/
5605 Float_t TIsajet::GetAQ(Int_t index1, Int_t index2) const
5607 Int_t col_num = (sizeof WCON.aq[0] / sizeof WCON.aq[0][0]);
5608 Int_t row_num = (sizeof WCON.aq / (sizeof WCON.aq[0][0] * col_num));
5610 if ((index1 < 0) || (index1 >= row_num)) {
5611 printf ("Error in TIsajet::GetAQ : \n");
5612 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5616 if ((index2 < 0) || (index2 >= col_num)) {
5617 printf ("Error in TIsajet::GetAQ : \n");
5618 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5622 return WCON.aq[index1][index2];
5625 /**************************************************************************/
5627 Float_t TIsajet::GetBQ(Int_t index1, Int_t index2) const
5629 Int_t col_num = (sizeof WCON.bq[0] / sizeof WCON.bq[0][0]);
5630 Int_t row_num = (sizeof WCON.bq / (sizeof WCON.bq[0][0] * col_num));
5632 if ((index1 < 0) || (index1 >= row_num)) {
5633 printf ("Error in TIsajet::GetBQ : \n");
5634 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5638 if ((index2 < 0) || (index2 >= col_num)) {
5639 printf ("Error in TIsajet::GetBQ : \n");
5640 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5644 return WCON.bq[index1][index2];
5647 /**************************************************************************/
5649 Float_t TIsajet::GetCOUT(Int_t index) const
5651 Int_t length = (sizeof WCON.cout / sizeof WCON.cout[0]);
5652 if ((index < 0) || (index >= length)) {
5653 printf ("Error in TIsajet::GetCOUT : \n");
5654 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5658 return WCON.cout[index];
5661 /**************************************************************************/
5663 Int_t TIsajet::GetMATCH() const
5668 /**************************************************************************/
5670 Float_t TIsajet::GetWCBR(Int_t index1, Int_t index2) const
5672 Int_t col_num = (sizeof WCON.wcbr[0] / sizeof WCON.wcbr[0][0]);
5673 Int_t row_num = (sizeof WCON.wcbr / (sizeof WCON.wcbr[0][0] * col_num));
5675 if ((index1 < 0) || (index1 >= row_num)) {
5676 printf ("Error in TIsajet::GetWCBR : \n");
5677 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5681 if ((index2 < 0) || (index2 >= col_num)) {
5682 printf ("Error in TIsajet::GetWCBR : \n");
5683 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5687 return WCON.wcbr[index1][index2];
5690 /**************************************************************************/
5692 void TIsajet::SetCUTOFF(Float_t val)
5697 /**************************************************************************/
5699 Float_t TIsajet::GetCUTOFF() const
5704 /**************************************************************************/
5706 void TIsajet::SetCUTPOW(Float_t val)
5711 /**************************************************************************/
5713 Float_t TIsajet::GetCUTPOW() const
5718 /**************************************************************************/
5720 Float_t TIsajet::GetTBRWW(Int_t index1, Int_t index2) const
5722 Int_t col_num = (sizeof WCON.tbrww[0] / sizeof WCON.tbrww[0][0]);
5723 Int_t row_num = (sizeof WCON.tbrww / (sizeof WCON.tbrww[0][0] * col_num));
5725 if ((index1 < 0) || (index1 >= row_num)) {
5726 printf ("Error in TIsajet::GetTBRWW : \n");
5727 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5731 if ((index2 < 0) || (index2 >= col_num)) {
5732 printf ("Error in TIsajet::GetTBRWW : \n");
5733 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5737 return WCON.tbrww[index1][index2];
5740 /**************************************************************************/
5742 Float_t TIsajet::GetRBRWW(Int_t index1, Int_t index2, Int_t index3) const
5744 Int_t elem_Size = sizeof WCON.rbrww[0][0][0];
5745 Int_t thd_Dim_Length = (sizeof WCON.rbrww[0][0] / elem_Size);
5746 Int_t sec_Dim_Length = (sizeof WCON.rbrww[0] / (elem_Size * thd_Dim_Length));
5747 Int_t fst_Dim_Length = (sizeof WCON.rbrww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
5749 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
5750 printf ("Error in TIsajet::GetRBRWW : \n");
5751 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
5755 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
5756 printf ("Error in TIsajet::GetRBRWW : \n");
5757 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
5761 if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
5762 printf ("Error in TIsajet::GetRBRWW : \n");
5763 printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
5767 return WCON.rbrww[index1][index2][index3];
5771 /**************************************************************************/
5773 Float_t TIsajet::GetEZ() const
5778 /**************************************************************************/
5780 Float_t TIsajet::GetAQDP(Int_t index1, Int_t index2) const
5782 Int_t col_num = (sizeof WCON.aqdp[0] / sizeof WCON.aqdp[0][0]);
5783 Int_t row_num = (sizeof WCON.aqdp / (sizeof WCON.aqdp[0][0] * col_num));
5785 if ((index1 < 0) || (index1 >= row_num)) {
5786 printf ("Error in TIsajet::GetAQDP : \n");
5787 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5791 if ((index2 < 0) || (index2 >= col_num)) {
5792 printf ("Error in TIsajet::GetAQDP : \n");
5793 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5797 return WCON.aqdp[index1][index2];
5800 /**************************************************************************/
5802 Float_t TIsajet::GetBQDP(Int_t index1, Int_t index2) const
5804 Int_t col_num = (sizeof WCON.bqdp[0] / sizeof WCON.bqdp[0][0]);
5805 Int_t row_num = (sizeof WCON.bqdp / (sizeof WCON.bqdp[0][0] * col_num));
5807 if ((index1 < 0) || (index1 >= row_num)) {
5808 printf ("Error in TIsajet::GetBQDP : \n");
5809 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5813 if ((index2 < 0) || (index2 >= col_num)) {
5814 printf ("Error in TIsajet::GetBQDP : \n");
5815 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5819 return WCON.bqdp[index1][index2];
5822 /**************************************************************************/
5824 Float_t TIsajet::GetEZDP() const
5829 /**************************************************************************/
5831 void TIsajet::SetWFUDGE(Float_t val)
5836 /**************************************************************************/
5838 Float_t TIsajet::GetWFUDGE() const
5843 /**************************************************************************/
5845 // Ends WCON access.
5848 # define isaini isaini_
5849 # define isaevt isaevt_
5850 # define isabeg isabeg_
5851 # define isabg2 isabg2_
5852 # define openfiles openfiles_
5853 # define pdfinit pdfinit_
5855 # define type_of_call
5857 # define isaini ISAINI
5858 # define isaevt ISAEVT
5859 # define isabeg ISABEG
5860 # define isabg2 ISABG2
5861 # define openfiles OPENFILES
5862 # define pdfinit PDFINIT
5864 # define type_of_call _stdcall
5867 extern "C" void type_of_call isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n);
5868 extern "C" void type_of_call isaevt(Int_t& j, Int_t& k, Int_t& m);
5869 extern "C" void type_of_call openfiles();
5870 extern "C" void type_of_call pdfinit();
5871 extern "C" void type_of_call isabeg(Int_t& ifl);
5872 extern "C" void type_of_call isabg2(Int_t& ifl);
5874 void TIsajet::Isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n)
5879 void TIsajet::Isaevt(Int_t& j, Int_t& k, Int_t& m)
5884 void TIsajet::Openfiles()
5889 void TIsajet::PDFinit()
5891 pdfinit(pdfpar, pdfval);
5894 void TIsajet::Isabeg(Int_t& ifl)
5899 void TIsajet::Isabg2(Int_t& ifl)
5905 Double_t type_of_call ranf(Int_t & /*idum*/)
5908 do r=sRandom->Rndm(); while(0 >= r || r >= 1);