1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // Interface to the Isajet MonteCarlo //
23 #include "TParticle.h"
24 #include "TClonesArray.h"
28 #include "Riostream.h"
35 static TRandom * sRandom;
37 /**************************************************************************/
39 TIsajet::TIsajet() : TGenerator("Isajet", "Isajet")
41 // Default constructor
43 if (!sRandom) sRandom=fRandom;
45 // Initialising equivalence structures in FRGPAR :
46 // EQUIVALENCE (PMIX1(1,1),PMIXX1(1))
47 // EQUIVALENCE (PMIX2(1,1),PMIXX2(1))
48 // EQUIVALENCE (FRPAR(1),PUD)
50 FRGPAR.pmixx1[0] = &FRGPAR.pmix1[0][0];
51 FRGPAR.pmixx2[0] = &FRGPAR.pmix2[0][0];
52 FRGPAR.frpar[0] = &FRGPAR.pud;
54 for (Int_t i = 1; i < 6; i++) {
55 FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
56 FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
59 for (Int_t i = 1; i < 32; i++) {
60 FRGPAR.frpar[i] = FRGPAR.frpar[i-1] +1;
63 // Internal logical flags ensuring that theta and y limits are not simultaneously set :
65 DYLIM.ywset = DYLIM.thwset = false;
69 title = ("Default title.");
75 /**************************************************************************/
79 // No housekeeping required at the moment.
82 /**************************************************************************/
84 void TIsajet::Initialise()
87 // Writes parameter file and stores common block variables in
88 // data members, according to booleans.
89 // If TIsajet is being used in online-control mode, the parameter file is
90 // unnecessary, hence the output is echoed to the screen instead.
92 const char *fname = gSystem->ExpandPathName("$ALICE_ROOT/ISAJET/data/myjob.par");
93 ofstream Write(fname, ios::out);
95 ostream *Writer = &Write;
97 if (online) Writer = &cout;
99 *Writer << title << '\n';
100 *Writer << PRIMAR.ecm << ',' << PRIMAR.nevent << ",1,1/\n";
101 *Writer << jobtype << '\n';
103 center_energy = PRIMAR.ecm;
106 beam1_type = PRIMAR.idin[0];
107 beam2_type = PRIMAR.idin[1];
109 *Writer << "BEAMS\n";
110 if (PRIMAR.idin[0] == -1120) *Writer << "AP,";
111 else if (PRIMAR.idin[0] == 1220) *Writer << "N,";
112 else if (PRIMAR.idin[0] == -1220) *Writer << "AN,";
113 else *Writer << "P,";
115 if (PRIMAR.idin[1] == -1120) *Writer << "AP/\n";
116 else if (PRIMAR.idin[1] == 1220) *Writer << "N/\n";
117 else if (PRIMAR.idin[1] == -1220) *Writer << "AN/\n";
118 else *Writer << "P/\n";
122 cutoff_mass = QCDPAR.cutjet;
123 *Writer << "CUTJET\n" << QCDPAR.cutjet << "/\n";
127 for (Int_t i = 0; i < 32; i++) frag_params[i] = *FRGPAR.frpar[i];
129 *Writer << "FRAGMENT\n";
130 for (Int_t i = 0; i < 31; i++) *Writer << FRGPAR.frpar[i] << ',';
131 *Writer << FRGPAR.frpar[31] << "/\n";
135 for (Int_t i = 0; i < TYPES.njttyp[0]; i++) jet1_type[i] = XTYPES.jetyp[0][i];
136 num_jet_type[0] = TYPES.njttyp[0];
138 *Writer << "JETTYPE1\n";
139 for (Int_t i = 0; i < TYPES.njttyp[0]-1; i++) *Writer << XTYPES.jetyp[0][i] << ',';
140 *Writer << XTYPES.jetyp[0][TYPES.njttyp[0]-1] << "/\n";
143 for (Int_t i = 0; i < TYPES.njttyp[1]; i++) jet2_type[i] = XTYPES.jetyp[1][i];
144 num_jet_type[0] = TYPES.njttyp[0];
146 *Writer << "JETTYPE2\n";
147 for (Int_t i = 0; i < TYPES.njttyp[1]-1; i++) *Writer << XTYPES.jetyp[1][i] << ',';
148 *Writer << XTYPES.jetyp[1][TYPES.njttyp[1]-1] << "/\n";
151 for (Int_t i = 0; i < TYPES.njttyp[2]; i++) jet3_type[i] = XTYPES.jetyp[2][i];
152 num_jet_type[0] = TYPES.njttyp[0];
154 *Writer << "JETTYPE3\n";
155 for (Int_t i = 0; i < TYPES.njttyp[2]-1; i++) *Writer << XTYPES.jetyp[2][i] << ',';
156 *Writer << XTYPES.jetyp[2][TYPES.njttyp[2]-1] << "/\n";
161 qcd_lambda = QCDPAR.alam;
162 *Writer << "LAMBDA\n" << QCDPAR.alam << "/\n";
167 forbid_decay = NODCAY.nodcay;
169 *Writer << "NODCAY\n";
170 if (NODCAY.nodcay) *Writer << "TRUE/\n";
171 else *Writer << "FALSE/\n";
175 forbid_eta = NODCAY.noeta;
177 *Writer << "NOETA\n";
178 if (NODCAY.noeta) *Writer << "TRUE/\n";
179 else *Writer << "FALSE/\n";
183 forbid_evolve = NODCAY.noevol;
185 *Writer << "NOEVOLVE\n";
186 if (NODCAY.noevol) *Writer << "TRUE/\n";
187 else *Writer << "FALSE/\n";
191 forbid_hadron = NODCAY.nohadr;
193 *Writer << "NOHADRON\n";
194 if (NODCAY.nohadr) *Writer << "TRUE/\n";
195 else *Writer << "FALSE/\n";
199 forbid_pi0 = NODCAY.nopi0;
201 *Writer << "NOPI0\n";
202 if (NODCAY.nopi0) *Writer << "TRUE/\n";
203 else *Writer << "FALSE/\n";
207 generate_sigma = PRIMAR.nsigma;
208 *Writer << "NSIGMA\n" << PRIMAR.nsigma << "/\n";
212 for (Int_t i = 0; i < 3; i++) {
213 p_limits[2 * i] = JETLIM.pmin[i];
214 p_limits[2 * i + 1] = JETLIM.pmax[i];
218 *Writer << JETLIM.pmin[0] << ',' << JETLIM.pmax[0] << ',';
219 *Writer << JETLIM.pmin[1] << ',' << JETLIM.pmax[1] << ',';
220 *Writer << JETLIM.pmin[2] << ',' << JETLIM.pmax[2] << "/\n";
224 for (Int_t i = 0; i < 3; i++) {
225 phi_limits[2 * i] = JETLIM.phimin[i];
226 phi_limits[2 * i + 1] = JETLIM.phimax[i];
230 *Writer << JETLIM.phimin[0] << ',' << JETLIM.phimax[0] << ',';
231 *Writer << JETLIM.phimin[1] << ',' << JETLIM.phimax[1] << ',';
232 *Writer << JETLIM.phimin[2] << ',' << JETLIM.phimax[2] << "/\n";
236 for (Int_t i = 0; i < 3; i++) {
237 pt_limits[2 * i] = JETLIM.ptmin[i];
238 pt_limits[2 * i + 1] = JETLIM.ptmax[i];
242 *Writer << JETLIM.ptmin[0] << ',' << JETLIM.ptmax[0] << ',';
243 *Writer << JETLIM.ptmin[1] << ',' << JETLIM.ptmax[1] << ',';
244 *Writer << JETLIM.ptmin[2] << ',' << JETLIM.ptmax[2] << "/\n";
248 for (Int_t i = 0; i < 3; i++) {
249 theta_limits[2 * i] = JETLIM.thmin[i];
250 theta_limits[2 * i + 1] = JETLIM.thmax[i];
253 *Writer << "THETA\n";
254 *Writer << JETLIM.thmin[0] << ',' << JETLIM.thmax[0] << ',';
255 *Writer << JETLIM.thmin[1] << ',' << JETLIM.thmax[1] << ',';
256 *Writer << JETLIM.thmin[2] << ',' << JETLIM.thmax[2] << "/\n";
260 for (Int_t i = 0; i < 3; i++) {
261 x_limits[2 * i] = JETLIM.xjmin[i];
262 x_limits[2 * i + 1] = JETLIM.xjmax[i];
266 *Writer << JETLIM.xjmin[0] << ',' << JETLIM.xjmax[0] << ',';
267 *Writer << JETLIM.xjmin[1] << ',' << JETLIM.xjmax[1] << ',';
268 *Writer << JETLIM.xjmin[2] << ',' << JETLIM.xjmax[2] << "/\n";
272 for (Int_t i = 0; i < 3; i++) {
273 y_limits[2 * i] = JETLIM.yjmin[i];
274 y_limits[2 * i + 1] = JETLIM.yjmax[i];
278 *Writer << JETLIM.yjmin[0] << ',' << JETLIM.yjmax[0] << ',';
279 *Writer << JETLIM.yjmin[1] << ',' << JETLIM.yjmax[1] << ',';
280 *Writer << JETLIM.yjmin[2] << ',' << JETLIM.yjmax[2] << "/\n";
284 for (Int_t i = 0; i < 8; i++) peter_jet_frag[i] = FRGPAR.xgen[i];
287 for (Int_t i = 0; i < 7; i++) *Writer << FRGPAR.xgen[i] << ',';
288 *Writer << FRGPAR.xgen[7] << "/\n";
292 *Writer << "PDFLIB\n";
293 for (Int_t i = 0; i < num_Pdf; i++) *Writer << "\'" << pdfpar[i] << "\'" << ',' << pdfval[i] << "/\n";
301 // Stuff for online-control mode :
306 for (Int_t i = 0; i < KEYS.mxkeys; i++) KEYS.keys[i] = false;
308 if (!strcmp(KEYS.reac, "TWOJET")) {
313 else if (!strcmp(KEYS.reac, "MINBIAS")) {
319 printf("Error in TIsajet::Initialise :\n");
320 printf("Invalid job type %s.\n", KEYS.reac);
321 printf("Only TWOJET and MINBIAS are currently supported for online mode.\n");
331 /**************************************************************************/
333 void TIsajet::Reload()
336 // Sets the common block variables to the data member values.
339 SetECM(center_energy);
342 SetIDIN(0, beam1_type);
343 SetIDIN(1, beam2_type);
346 if (setCutjet) SetCUTJET(cutoff_mass);
348 if (setFragment) SetAllFRPAR(frag_params, 32);
350 if (setJettype1) for (Int_t i = 0; i < num_jet_type[0]; i++) SetJETYP(0, jet1_type[i]);
352 if (setJettype2) for (Int_t i = 0; i < num_jet_type[1]; i++) SetJETYP(1, jet2_type[i]);
354 if (setJettype3) for (Int_t i = 0; i < num_jet_type[2]; i++) SetJETYP(2, jet3_type[i]);
356 if (setLambda) SetALAM(qcd_lambda);
358 if (setNodcay) SetNODCAY(forbid_decay);
360 if (setNoeta) SetNOETA(forbid_eta);
362 if (setNoevolve) SetNOEVOL(forbid_evolve);
364 if (setNohadron) SetNOHADR(forbid_hadron);
366 if (setNopi0) SetNOPI0(forbid_pi0);
368 if (setNsigma) SetNSIGMA(generate_sigma);
371 for (Int_t i = 0; i < 3; i++) {
372 SetPMIN(p_limits[2 * i], i);
373 SetPMAX(p_limits[2 * i + 1], i);
378 for (Int_t i = 0; i < 3; i++) {
379 SetPHIMIN(phi_limits[2 * i], i);
380 SetPHIMAX(phi_limits[2 * i + 1], i);
385 for (Int_t i = 0; i < 3; i++) {
386 SetPTMIN(pt_limits[2 * i], i);
387 SetPTMAX(pt_limits[2 * i + 1], i);
392 for (Int_t i = 0; i < 3; i++) {
393 SetTHMIN(theta_limits[2 * i], i);
394 SetTHMAX(theta_limits[2 * i + 1], i);
399 for (Int_t i = 0; i < 3; i++) {
400 SetXJMIN(x_limits[2 * i], i);
401 SetXJMAX(x_limits[2 * i + 1], i);
406 for (Int_t i = 0; i < 3; i++) {
407 SetYJMIN(y_limits[2 * i], i);
408 SetYJMAX(y_limits[2 * i + 1], i);
412 if (setXgen) SetAllXGEN(peter_jet_frag, 8);
415 /**************************************************************************/
417 void TIsajet::RestoreDefaults()
419 // Booleans indicating which keywords should be written into the parameter file.
421 setBeams = setCutjet = setFragment = setJettype1 = false;
422 setJettype2 = setJettype3 = setLambda = setNodcay = false;
423 setNoeta = setNoevolve = setNohadron = setNopi0 = false;
424 setNsigma = setP = setPhi = setPt = setTheta = false;
425 setX = setXgen = setY = setPdf = false;
428 // Calling on FORTRAN for initialisation of variables
443 /**************************************************************************/
445 Int_t TIsajet::ImportParticles(TClonesArray *particles, Option_t *option)
448 // Default primary creation method. It reads the /HEPEVT/ common block which
449 // has been filled by the GenerateEvent method. If the event generator does
450 // not use the HEPEVT common block, this routine has to be overloaded by
452 // The function loops on the generated particles and stores them in
453 // the TClonesArray pointed by the argument particles.
454 // The default action is to store only the stable particles (ISTHEP = 1)
455 // This can be demanded explicitly by setting the option = "Final"
456 // If the option = "All", all the particles are stored.
458 if (particles == 0) return 0;
459 TClonesArray &Particles = *particles;
461 TDatabasePDG* converter = TDatabasePDG::Instance();
462 Int_t numpart = PARTCL.nptcl;
463 printf("\n TIsajet: ISAJET stack contains %d particles.", numpart);
464 printf("\n TIsajet: Total energy: %f ", PRIMAR.ecm);
466 if ((!strcmp(option,"")) || (!strcmp(option,"Final"))) {
467 for (Int_t i = 0; i < numpart; i++) {
469 if (PARTCL.idcay[i] == 0) { // Check whether particle is stable.
471 // Use the common block values for the TParticle constructor
474 new(Particles[i]) TParticle(
475 converter->ConvertIsajetToPdg(PARTCL.ident[i]) , // PDG code
476 0 , // Status - currently a default
478 -1, // Mothers and daughters - not used for stable particles
483 PARTCL.pptcl[i][0] , // x, y, z and 0 momenta
488 0, // Velocities - currently not used.
495 else if (!strcmp(option,"All")) {
497 for (Int_t i = 0; i < numpart; i++) {
499 // Determine mother particle. Set to -1 if the particle originates from
500 // a parton or is a beam particle.
502 Int_t origin = PARTCL.iorig[i];
503 Int_t jet = origin / PARTCL.ipack;
504 origin = origin - (jet * PARTCL.ipack);
506 if (origin < 0) origin = 0;
508 // Determine first and last decay products. Both are -1 if the particle is stable.
509 // Note this means they are set to 0, because one is subtracted after decoding;
510 // this avoid off-by-one errors relative to the FORTRAN.
512 Int_t first_Daughter = 0;
513 Int_t last_Daughter = 0;
515 if (PARTCL.idcay[i] != 0) {
516 first_Daughter = PARTCL.idcay[i] / PARTCL.ipack;
517 last_Daughter = PARTCL.idcay[i] - (first_Daughter * PARTCL.ipack);
519 new(Particles[i]) TParticle(
520 converter->ConvertIsajetToPdg(PARTCL.ident[i]) ,
542 /**************************************************************************/
544 void TIsajet::GenerateEvent()
550 // if (online) Isabg2(e);
557 /**************************************************************************/
559 void TIsajet::SetJobtype(Char_t *val)
561 if ((!strcmp(val, "TWOJET")) || (!strcmp(val, "E+E-")) ||
562 (!strcmp(val, "DRELLYAN")) || (!strcmp(val, "MINBIAS")) ||
563 (!strcmp(val, "SUSY")) || (!strcmp(val, "WPAIR")) ||
564 (!strcmp(val, "HIGGS")) || (!strcmp(val, "PHOTON")) ||
565 (!strcmp(val, "TCOLOR")) || (!strcmp(val, "WHIGGS")) ||
566 (!strcmp(val, "EXTRADIM")) || (!strcmp(val, "ZJJ"))) {
570 printf("Error in TIsajet::SetJobtype :\n");
571 printf("Invalid reaction keyword %s.\n", val);
572 printf("Valid keywords are : TWOJET, E+E-, DRELLYAN,\n");
573 printf("MINBIAS, SUSY, WPAIR, HIGGS, PHOTON, TCOLOR,\n");
574 printf("WHIGGS, EXTRADIM and ZJJ.\n");
578 /**************************************************************************/
580 void TIsajet::GetJobtype() const
582 printf ("Current job type is %s.\n", jobtype);
585 /**************************************************************************/
587 void TIsajet::SetOnline(Bool_t val)
592 /**************************************************************************/
594 Bool_t TIsajet::GetOnline() const
599 /**************************************************************************/
601 void TIsajet::SetPDF(Char_t *name, Float_t val)
604 pdfpar[num_Pdf] = name;
605 pdfval[num_Pdf] = val;
610 printf ("Error in TIsajet::SetPDF :\n");
611 printf ("Maximum of twenty PDF parameters may be set.\n");
615 /**************************************************************************/
617 // Access routines for common blocks.
618 // Begins DYLIM access.
620 /**************************************************************************/
622 void TIsajet::SetQMIN(Float_t val)
624 if (val > DYLIM.qmax) {
625 printf("Error in TIsajet::SetQMIN : \n");
626 printf("You may not set QMIN to a value larger than QMAX = %f.\n", DYLIM.qmax);
631 if (!DYLIM.ywset) SetYWLIMS();
634 /**************************************************************************/
636 Float_t TIsajet::GetQMIN() const
641 /**************************************************************************/
643 void TIsajet::SetQMAX(Float_t val)
645 if (val < DYLIM.qmin) {
646 printf("Error in TIsajet::SetQMAX : \n");
647 printf("You may not set QMAX to a value less than QMIN = %f.\n", DYLIM.qmin);
654 /**************************************************************************/
656 Float_t TIsajet::GetQMAX() const
661 /**************************************************************************/
663 void TIsajet::SetQTMIN(Float_t val)
665 if (val > DYLIM.qtmax) {
666 printf("Error in TIsajet::SetQTMIN : \n");
667 printf("You may not set QTMIN to a value larger than QTMAX = %f.\n", DYLIM.qtmax);
671 if (!DYLIM.ywset) SetYWLIMS();
674 /**************************************************************************/
676 Float_t TIsajet::GetQTMIN() const
681 /**************************************************************************/
683 void TIsajet::SetQTMAX(Float_t val)
685 if (val < DYLIM.qtmin) {
686 printf("Error in TIsajet::SetQTMAX : \n");
687 printf("You may not set QTMAX to a value less than QTMIN = %f.\n", DYLIM.qtmin);
692 if (!DYLIM.ywset) SetYWLIMS();
695 /**************************************************************************/
697 Float_t TIsajet::GetQTMAX() const
702 /**************************************************************************/
704 void TIsajet::SetYWMIN(Float_t val)
706 if (val > DYLIM.ywmax) {
707 printf("Error in TIsajet::SetYWMIN : \n");
708 printf("You may not set YWMIN to a value larger than YWMAX = %f.\n", DYLIM.ywmax);
713 printf("Error in TIsajet::SetYWMIN :\n");
714 printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMIN.\n");
722 /**************************************************************************/
724 Float_t TIsajet::GetYWMIN() const
729 /**************************************************************************/
731 void TIsajet::SetYWMAX(Float_t val)
733 if (val < DYLIM.ywmin) {
734 printf("Error in TIsajet::SetYWMAX : \n");
735 printf("You may not set YWMAX to a value less than YWMIN = %f.\n", DYLIM.ywmin);
740 printf("Error in TIsajet::SetYWMAX :\n");
741 printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMAX.\n");
749 /**************************************************************************/
751 Float_t TIsajet::GetYWMAX() const
756 /**************************************************************************/
758 void TIsajet::SetYWLIMS()
760 Float_t rot = sqrt(DYLIM.qmin * DYLIM.qmin + DYLIM.qtmin * DYLIM.qtmin);
761 DYLIM.ywmax = acosh(PRIMAR.halfe / rot);
762 DYLIM.ywmin = -DYLIM.ywmax;
766 /**************************************************************************/
768 void TIsajet::SetXWMIN(Float_t val)
770 if (val > DYLIM.xwmax) {
771 printf("Error in TIsajet::SetXWMIN : \n");
772 printf("You may not set XWMIN to a value larger than XWMAX = %f.\n", DYLIM.xwmax);
778 /**************************************************************************/
780 Float_t TIsajet::GetXWMIN() const
785 /**************************************************************************/
787 void TIsajet::SetXWMAX(Float_t val)
789 if (val < DYLIM.xwmin) {
790 printf("Error in TIsajet::SetXWMAX : \n");
791 printf("You may not set XWMAX to a value less than XWMIN = %f.\n", DYLIM.xwmin);
798 /**************************************************************************/
800 Float_t TIsajet::GetXWMAX() const
805 /**************************************************************************/
807 void TIsajet::SetTHWMIN(Float_t val)
809 if (val > DYLIM.thwmax) {
810 printf("Error in TIsajet::SetTHWMIN : \n");
811 printf("You may not set THWMIN to a value larger than THWMAX = %f.\n", DYLIM.thwmax);
816 printf("Error in TIsajet::SetTHWMIN :\n");
817 printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMIN.\n");
825 /**************************************************************************/
827 Float_t TIsajet::GetTHWMIN() const
832 /**************************************************************************/
834 void TIsajet::SetTHWMAX(Float_t val)
836 if (val < DYLIM.thwmin) {
837 printf("Error in TIsajet::SetTHWMAX : \n");
838 printf("You may not set THWMAX to a value less than THWMIN = %f.\n", DYLIM.thwmin);
843 printf("Error in TIsajet::SetTHWMAX :\n");
844 printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMAX.\n");
852 /**************************************************************************/
854 Float_t TIsajet::GetTHWMAX() const
859 /**************************************************************************/
861 void TIsajet::SetTHWLIMS()
864 DYLIM.thwmax = TMath::Pi();
865 DYLIM.thwset = false;
868 /**************************************************************************/
870 void TIsajet::SetPHWMIN(Float_t val)
872 if (val > DYLIM.phwmax) {
873 printf("Error in TIsajet::SetPHWMIN : \n");
874 printf("You may not set PHWMIN to a value larger than PHWMAX = %f.\n", DYLIM.phwmax);
880 /**************************************************************************/
882 Float_t TIsajet::GetPHWMIN() const
887 /**************************************************************************/
889 void TIsajet::SetPHWMAX(Float_t val)
891 if (val < DYLIM.phwmin) {
892 printf("Error in TIsajet::SetPHWMAX : \n");
893 printf("You may not set PHWMAX to a value less than PHWMIN = %f.\n", DYLIM.phwmin);
900 /**************************************************************************/
902 Float_t TIsajet::GetPHWMAX() const
907 /**************************************************************************/
909 Bool_t TIsajet::GetSETLMQ(Int_t index) const
911 Int_t length = (sizeof DYLIM.setlmq / sizeof DYLIM.setlmq[0]);
912 if ((index < 0) || (index >= length)) {
913 printf ("Error in TIsajet::GetSETLMQ : \n");
914 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
918 return DYLIM.setlmq[index];
921 /**************************************************************************/
923 // End of DYLIM access.
924 // Begins EEPAR access.
926 /**************************************************************************/
928 void TIsajet::SetPLEP(Float_t val)
933 /**************************************************************************/
935 Float_t TIsajet::GetPLEP() const
940 /**************************************************************************/
942 void TIsajet::SetPLEM(Float_t val)
947 /**************************************************************************/
949 Float_t TIsajet::GetPLEM() const
954 /**************************************************************************/
956 void TIsajet::SetRSHMIN(Float_t val)
958 if (val > EEPAR.rshmax) {
959 printf("Error in TIsajet::SetRSHMIN : \n");
960 printf("You may not set RSHMIN to a value larger than RSHMAX = %f.\n", EEPAR.rshmax);
966 /**************************************************************************/
968 Float_t TIsajet::GetRSHMIN() const
973 /**************************************************************************/
975 void TIsajet::SetRSHMAX(Float_t val)
977 if (val < EEPAR.rshmin) {
978 printf("Error in TIsajet::SetRSHMAX : \n");
979 printf("You may not set RSHMAX to a value less than RSHMIN = %f.\n", EEPAR.rshmin);
986 /**************************************************************************/
988 Float_t TIsajet::GetRSHMAX() const
993 /**************************************************************************/
995 void TIsajet::SetUPSLON(Float_t val)
1000 /**************************************************************************/
1002 Float_t TIsajet::GetUPSLON() const
1004 return EEPAR.upslon;
1007 /**************************************************************************/
1009 void TIsajet::SetSIGZ(Float_t val)
1014 /**************************************************************************/
1016 Float_t TIsajet::GetSIGZ() const
1021 /**************************************************************************/
1023 Bool_t TIsajet::GetIBREM() const
1028 /**************************************************************************/
1030 Bool_t TIsajet::GetIBEAM() const
1035 /**************************************************************************/
1037 Float_t TIsajet::GetSGMXEE() const
1039 return EEPAR.sgmxee;
1042 /**************************************************************************/
1044 // End of EEPAR access.
1045 // Begins FORCE access.
1047 /**************************************************************************/
1049 Int_t TIsajet::GetNFORCE() const
1051 return FORCE.nforce;
1054 /**************************************************************************/
1056 void TIsajet::SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti)
1058 if (GetNFORCE() >= FORCE.mxforc - anti) {
1059 printf ("ERROR in TIsajet::SetIFORCE :\n");
1060 printf ("Cannot have more than %d forced decays.\n", FORCE.mxforc );
1064 if ((arraySize > 6) || (arraySize < 2)) {
1065 printf ("Error in TIsajet::SetIFORCE : \n");
1066 printf ("Invalid array size %d; must be 2-6.\n", arraySize);
1070 for (Int_t i = 0; i < FORCE.nforce; i++) {
1071 if (FORCE.iforce[i] == val[0]) {
1072 printf ("Error in TIsajet::SetIFORCE : \n");
1073 printf ("Particle %d has already been forced, index %d.\n", val[0], i);
1079 FORCE.iforce[FORCE.nforce] = val[0];
1080 for (Int_t i = 1; i < arraySize; i++) {
1081 FORCE.mforce[FORCE.nforce][i-1] = val[i];
1086 printf ("Decay channel %d -> ", val[0]);
1087 for (Int_t i = 1; i < arraySize; i++) {
1088 printf ("%d, ", val[i]);
1093 Int_t* antivals = new Int_t[arraySize];
1094 for (Int_t i = 0; i < arraySize; i++){
1095 antivals[i] = (0 - val[i]);
1097 SetIFORCE(antivals, arraySize, false);
1101 /**************************************************************************/
1103 void TIsajet::UnForce(Int_t index, Bool_t anti)
1105 if (FORCE.nforce == 0) {
1106 printf ("Error in TIsajet::UnForce : \n");
1107 printf ("No decays have been forced.\n");
1111 if ((index < 0) || (index >= FORCE.nforce)) {
1112 printf ("Error in TIsajet::UnForce : \n");
1113 printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1117 Int_t particle_ID = FORCE.iforce[index];
1119 for (Int_t i = index; i < FORCE.mxforc - 1; i++) {
1120 FORCE.iforce[i] = FORCE.iforce[i+1];
1121 for (Int_t j = 0; j < 5; j++) {
1122 FORCE.mforce[i][j] = FORCE.mforce[i+1][j];
1125 FORCE.iforce[FORCE.mxforc - 1] = 0;
1126 for (Int_t j = 0; j < 5; j++) {
1127 FORCE.mforce[FORCE.mxforc - 1][j] = 0;
1132 printf ("Decay of %d unforced.\n", particle_ID);
1134 if (anti) UnForceID(-particle_ID, false);
1137 /**************************************************************************/
1139 void TIsajet::UnForceID(Int_t particle_ID, Bool_t anti)
1141 if (FORCE.nforce == 0) {
1142 printf ("Error in TIsajet::UnForceID : \n");
1143 printf ("No decays have been forced.\n");
1147 for (Int_t i = 0; i < FORCE.nforce; i++) {
1148 if (FORCE.iforce[i] == particle_ID) {
1154 printf ("Error in TIsajet::UnForceID : \n");
1155 printf ("Cannot find particle %d.\n", particle_ID);
1158 /**************************************************************************/
1160 Int_t* TIsajet::GetIFORCE(Int_t index) const
1162 if (FORCE.nforce == 0) {
1163 printf ("Error in TIsajet::GetIFORCE : \n");
1164 printf ("No decays have been forced.\n");
1168 if ((index < 0) || (index >= FORCE.nforce)) {
1169 printf ("Error in TIsajet::GetIFORCE : \n");
1170 printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1174 Int_t* decay = new Int_t[6];
1175 decay[0] = FORCE.iforce[index];
1177 for (Int_t i = 1; i < 6; i++) {
1178 decay[i] = FORCE.mforce[index][i-1];
1184 /**************************************************************************/
1186 Int_t TIsajet::GetMEFORC(Int_t index) const
1188 if (FORCE.nforce == 0) {
1189 printf ("Error in TIsajet::GetMEFORCE : \n");
1190 printf ("No decays have been forced.\n");
1194 if ((index < 0) || (index >= FORCE.nforce)) {
1195 printf ("Error in TIsajet::GetMEFORC : \n");
1196 printf ("Invalid array index %d; range is 0-%d.\n", index, FORCE.nforce-1);
1200 return FORCE.meforc[index];
1203 /**************************************************************************/
1205 // End of FORCE access.
1206 // Begins FRGPAR access.
1208 /**************************************************************************/
1210 void TIsajet::SetFRPAR(Float_t val, Int_t index)
1212 Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1213 if ((index < 0) || (index >= length)) {
1214 printf ("Error in TIsajet::SetFRPAR : \n");
1215 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1219 *FRGPAR.frpar[index] = val;
1223 /**************************************************************************/
1225 void TIsajet::SetAllFRPAR(const Float_t val[], Int_t arraySize)
1227 Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1228 if (arraySize != length) {
1229 printf ("Error in TIsajet::SetAllFRPAR : \n");
1230 printf ("Array must have %d elements.\n", length);
1234 for (Int_t i = 0; i < arraySize; i++) {
1235 SetFRPAR(val[i], i);
1239 /**************************************************************************/
1241 Float_t TIsajet::GetFRPAR(Int_t index) const
1243 Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
1244 if ((index < 0) || (index >= length)) {
1245 printf ("Error in TIsajet::GetFRPAR : \n");
1246 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1250 return *FRGPAR.frpar[index];
1253 /**************************************************************************/
1255 void TIsajet::SetPUD(Float_t val)
1260 /**************************************************************************/
1262 Float_t TIsajet::GetPUD() const
1267 /**************************************************************************/
1269 void TIsajet::SetPBARY(Float_t val)
1274 /**************************************************************************/
1276 Float_t TIsajet::GetPBARY() const
1281 /**************************************************************************/
1283 void TIsajet::SetSIGQT(Float_t val)
1288 /**************************************************************************/
1290 Float_t TIsajet::GetSIGQT() const
1295 /**************************************************************************/
1297 void TIsajet::SetPEND(Float_t val)
1302 /**************************************************************************/
1304 Float_t TIsajet::GetPEND() const
1309 /**************************************************************************/
1311 void TIsajet::SetXGEN(Float_t val, Int_t index)
1313 Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1314 if ((index < 0) || (index >= length)) {
1315 printf ("Error in TIsajet::SetXGEN : \n");
1316 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1319 SetFRPAR(val, index + 4);
1323 /**************************************************************************/
1325 void TIsajet::SetAllXGEN(const Float_t val[], Int_t arraySize)
1327 Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1328 if (arraySize != length) {
1329 printf ("Error in TIsajet::SetAllXGEN : \n");
1330 printf ("Array must have %d elements.\n", length);
1334 for (Int_t i = 0; i < arraySize; i++) {
1339 /**************************************************************************/
1341 Float_t TIsajet::GetXGEN(Int_t index) const
1343 Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1344 if ((index < 0) || (index >= length)) {
1345 printf ("Error in TIsajet::GetXGEN : \n");
1346 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1350 return GetFRPAR(index + 4);
1353 /**************************************************************************/
1355 void TIsajet::SetPSPIN1(Float_t val, Int_t index)
1357 Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
1358 if ((index < 0) || (index >= length)) {
1359 printf ("Error in TIsajet::SetPSPIN1 : \n");
1360 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1364 SetFRPAR(val, index + 12);
1367 /**************************************************************************/
1369 void TIsajet::SetAllPSPIN1(const Float_t val[], Int_t arraySize)
1371 Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
1372 if (arraySize != length) {
1373 printf ("Error in TIsajet::SetAllPSPIN1 : \n");
1374 printf ("Array must have %d elements.\n", length);
1378 for (Int_t i = 0; i < arraySize; i++) {
1379 SetPSPIN1(val[i], i);
1383 /**************************************************************************/
1385 Float_t TIsajet::GetPSPIN1(Int_t index) const
1387 Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
1388 if ((index < 0) || (index >= length)) {
1389 printf ("Error in TIsajet::GetPSPIN1 : \n");
1390 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1394 return GetFRPAR(index + 12);
1397 /**************************************************************************/
1399 void TIsajet::SetPMIX1(Float_t val, Int_t index1, Int_t index2)
1401 Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1402 Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1404 if ((index1 < 0) || (index1 >= row_num)) {
1405 printf ("Error in TIsajet::SetPMIX1 : \n");
1406 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1410 if ((index2 < 0) || (index2 >= col_num)) {
1411 printf ("Error in TIsajet::SetPMIX1 : \n");
1412 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1416 FRGPAR.pmix1[index1][index2] = val;
1420 /**************************************************************************/
1422 void TIsajet::SetAllPMIX1(const Float_t val[2][3])
1424 for (Int_t i = 0; i < 2; i++) {
1425 for (Int_t j = 0; j < 3; j++) {
1426 SetPMIX1(val[i][j], i, j);
1431 /**************************************************************************/
1433 void TIsajet::SetColumnPMIX1(const Float_t val[], Int_t col)
1435 Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1436 Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1438 if ((col < 0) || (col >= col_num)) {
1439 printf ("Error in TIsajet::SetColumnPMIX1 : \n");
1440 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
1444 for (Int_t i = 0; i < row_num; i++) {
1445 SetPMIX1(val[i], i, col);
1449 /**************************************************************************/
1451 Float_t TIsajet::GetPMIX1(Int_t index1, Int_t index2) const
1453 Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
1454 Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
1456 if ((index1 < 0) || (index1 >= row_num)) {
1457 printf ("Error in TIsajet::GetPMIX1 : \n");
1458 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1462 if ((index2 < 0) || (index2 >= col_num)) {
1463 printf ("Error in TIsajet::GetPMIX1 : \n");
1464 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1468 return FRGPAR.pmix1[index1][index2];
1471 /**************************************************************************/
1473 void TIsajet::SetPMIX2(Float_t val, Int_t index1, Int_t index2)
1475 Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1476 Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1478 if ((index1 < 0) || (index1 >= row_num)) {
1479 printf ("Error in TIsajet::SetPMIX2 : \n");
1480 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1484 if ((index2 < 0) || (index2 >= col_num)) {
1485 printf ("Error in TIsajet::SetPMIX2 : \n");
1486 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1490 FRGPAR.pmix2[index1][index2] = val;
1494 /**************************************************************************/
1496 void TIsajet::SetAllPMIX2(const Float_t val[2][3])
1498 for (Int_t i = 0; i < 2; i++) {
1499 for (Int_t j = 0; j < 3; j++) {
1500 SetPMIX2(val[i][j], i, j);
1505 /**************************************************************************/
1507 void TIsajet::SetColumnPMIX2(const Float_t val[], Int_t col)
1509 Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1510 Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1512 if ((col < 0) || (col >= col_num)) {
1513 printf ("Error in TIsajet::SetColumnPMIX2 : \n");
1514 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
1518 for (Int_t i = 0; i < row_num; i++) {
1519 SetPMIX2(val[i], i, col);
1523 /**************************************************************************/
1525 Float_t TIsajet::GetPMIX2(Int_t index1, Int_t index2) const
1527 Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
1528 Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
1530 if ((index1 < 0) || (index1 >= row_num)) {
1531 printf ("Error in TIsajet::GetPMIX2 : \n");
1532 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
1536 if ((index2 < 0) || (index2 >= col_num)) {
1537 printf ("Error in TIsajet::GetPMIX2 : \n");
1538 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
1542 return FRGPAR.pmix2[index1][index2];
1545 /**************************************************************************/
1547 void TIsajet::SetPMIXX1(Float_t val, Int_t index)
1549 Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1550 if ((index < 0) || (index >= length)) {
1551 printf ("Error in TIsajet::SetPMIXX1 : \n");
1552 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1556 *FRGPAR.pmixx1[index] = val;
1560 /**************************************************************************/
1562 void TIsajet::SetAllPMIXX1(const Float_t val[], Int_t arraySize)
1564 Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1565 if (arraySize != length) {
1566 printf ("Error in TIsajet::SetAllPMIXX1 : \n");
1567 printf ("Array must have %d elements.\n", length);
1571 for (Int_t i = 0; i < arraySize; i++) {
1572 SetPMIXX1(val[i], i);
1576 /**************************************************************************/
1578 Float_t TIsajet::GetPMIXX1(Int_t index) const
1580 Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
1581 if ((index < 0) || (index >= length)) {
1582 printf ("Error in TIsajet::GetPMIXX1 : \n");
1583 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1587 return *FRGPAR.pmixx1[index];
1590 /**************************************************************************/
1592 void TIsajet::SetPMIXX2(Float_t val, Int_t index)
1594 Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1595 if ((index < 0) || (index >= length)) {
1596 printf ("Error in TIsajet::SetPMIXX2 : \n");
1597 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1601 *FRGPAR.pmixx2[index] = val;
1605 /**************************************************************************/
1607 void TIsajet::SetAllPMIXX2(const Float_t val[], Int_t arraySize)
1609 Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1610 if (arraySize != length) {
1611 printf ("Error in TIsajet::SetAllPMIXX2 : \n");
1612 printf ("Array must have %d elements.\n", length);
1616 for (Int_t i = 0; i < arraySize; i++) {
1617 SetPMIXX2(val[i], i);
1621 /**************************************************************************/
1623 Float_t TIsajet::GetPMIXX2(Int_t index) const
1625 Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
1626 if ((index < 0) || (index >= length)) {
1627 printf ("Error in TIsajet::GetPMIXX2 : \n");
1628 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1632 return *FRGPAR.pmixx2[index];
1635 /**************************************************************************/
1637 void TIsajet::SetXGENSS(Float_t val, Int_t index)
1639 Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1640 if ((index < 0) || (index >= length)) {
1641 printf ("Error in TIsajet::SetXGENSS : \n");
1642 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1646 FRGPAR.xgenss[index] = val;
1649 /**************************************************************************/
1651 void TIsajet::SetAllXGENSS(const Float_t val[], Int_t arraySize)
1653 Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1654 if (arraySize != length) {
1655 printf ("Error in TIsajet::SetAllXGENSS : \n");
1656 printf ("Array must have %d elements.\n", length);
1660 for (Int_t i = 0; i < arraySize; i++) {
1661 SetXGENSS(val[i], i);
1665 /**************************************************************************/
1667 Float_t TIsajet::GetXGENSS(Int_t index) const
1669 Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
1670 if ((index < 0) || (index >= length)) {
1671 printf ("Error in TIsajet::GetXGENSS : \n");
1672 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1676 return FRGPAR.xgenss[index];
1679 /**************************************************************************/
1681 // End of FRGPAR access.
1682 // Begins HCON access.
1684 /**************************************************************************/
1686 Float_t TIsajet::GetANWWWW(Int_t index1, Int_t index2, Int_t index3) const
1688 Int_t elem_Size = sizeof HCON.anwwww[0][0][0];
1689 Int_t thd_Dim_Length = (sizeof HCON.anwwww[0][0] / elem_Size);
1690 Int_t sec_Dim_Length = (sizeof HCON.anwwww[0] / (elem_Size * thd_Dim_Length));
1691 Int_t fst_Dim_Length = (sizeof HCON.anwwww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
1693 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1694 printf ("Error in TIsajet::GetANWWWW : \n");
1695 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1699 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1700 printf ("Error in TIsajet::GetANWWWW : \n");
1701 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1705 if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
1706 printf ("Error in TIsajet::GetANWWWW : \n");
1707 printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
1711 return HCON.anwwww[index1][index2][index3];
1714 /**************************************************************************/
1716 Float_t TIsajet::GetADWWWW(Int_t index1, Int_t index2) const
1718 Int_t elem_Size = sizeof HCON.adwwww[0][0];
1719 Int_t sec_Dim_Length = (sizeof HCON.adwwww[0] / elem_Size);
1720 Int_t fst_Dim_Length = (sizeof HCON.adwwww / (elem_Size * sec_Dim_Length));
1722 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1723 printf ("Error in TIsajet::GetADWWWW : \n");
1724 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1728 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1729 printf ("Error in TIsajet::GetADWWWW : \n");
1730 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1734 return HCON.adwwww[index1][index2];
1737 /**************************************************************************/
1739 Float_t TIsajet::GetAIWWWW(Int_t index) const
1741 Int_t length = (sizeof HCON.aiwwww / sizeof HCON.aiwwww[0]);
1742 if ((index < 0) || (index >= length)) {
1743 printf ("Error in TIsajet::GetAIWWWW : \n");
1744 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1748 return HCON.aiwwww[index];
1751 /**************************************************************************/
1753 Float_t TIsajet::GetHMASS() const
1758 /**************************************************************************/
1760 Float_t TIsajet::GetHGAM() const
1765 /**************************************************************************/
1767 Float_t TIsajet::GetHGAMS(Int_t index) const
1769 Int_t length = (sizeof HCON.hgams / sizeof HCON.hgams[0]);
1770 if ((index < 0) || (index >= length)) {
1771 printf ("Error in TIsajet::GetHGAMS : \n");
1772 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1776 return HCON.hgams[index];
1779 /**************************************************************************/
1781 Float_t TIsajet::GetETAHGG() const
1786 /**************************************************************************/
1788 Int_t TIsajet::GetMATCHH(Int_t index) const
1790 Int_t length = (sizeof HCON.matchh / sizeof HCON.matchh[0]);
1791 if ((index < 0) || (index >= length)) {
1792 printf ("Error in TIsajet::GetMATCHH : \n");
1793 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1797 return HCON.matchh[index];
1800 /**************************************************************************/
1802 Float_t TIsajet::GetZSTARS(Int_t index1, Int_t index2) const
1804 Int_t elem_Size = sizeof HCON.zstars[0][0];
1805 Int_t sec_Dim_Length = (sizeof HCON.zstars[0] / elem_Size);
1806 Int_t fst_Dim_Length = (sizeof HCON.zstars / (elem_Size * sec_Dim_Length));
1808 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1809 printf ("Error in TIsajet::GetZSTARS : \n");
1810 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1814 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1815 printf ("Error in TIsajet::GetZSTARS : \n");
1816 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1820 return HCON.zstars[index1][index2];
1823 /**************************************************************************/
1825 void TIsajet::SetIHTYPE(Int_t val)
1827 if ((val < 82) || (val > 84)) {
1828 printf ("Error in TIsajet::SetIHTYPE : \n");
1829 printf ("Invalid input value %d. Possible values are 82, 83, 84.\n", val);
1836 /**************************************************************************/
1838 void TIsajet::SetIHTYPE(Char_t val[])
1840 if (!strcmp("HL0", val)) {
1843 else if (!strcmp("HH0", val)) {
1846 else if (!strcmp("HA0", val)){
1850 printf ("Error in TIsajet::SetIHTYPE : \n");
1851 printf ("Invalid input string %s. Possible strings are HL0, HH0, HA0.\n", val);
1855 /**************************************************************************/
1857 Int_t TIsajet::GetIHTYPE() const
1862 /**************************************************************************/
1864 Float_t TIsajet::GetHGAMSS(Int_t index1, Int_t index2) const
1866 Int_t elem_Size = sizeof HCON.hgamss[0][0];
1867 Int_t sec_Dim_Length = (sizeof HCON.hgamss[0] / elem_Size);
1868 Int_t fst_Dim_Length = (sizeof HCON.hgamss / (elem_Size * sec_Dim_Length));
1870 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
1871 printf ("Error in TIsajet::GetHGAMSS : \n");
1872 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
1876 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
1877 printf ("Error in TIsajet::GetHGAMSS : \n");
1878 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
1882 return HCON.hgamss[index1][index2];
1885 /**************************************************************************/
1887 // End of HCON access
1888 // Begins JETLIM access
1890 /**************************************************************************/
1892 void TIsajet::SetPMIN(Float_t val, Int_t index)
1894 Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1895 if ((index < 0) || (index >= length)) {
1896 printf ("Error in TIsajet::SetPMIN : \n");
1897 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1901 if (val > JETLIM.pmax[index]) {
1902 printf("Error in TIsajet::SetPMIN : \n");
1903 printf("You may not set PMIN to a value larger than PMAX = %f.\n", JETLIM.pmax[index]);
1907 JETLIM.pmin[index] = val;
1911 /**************************************************************************/
1913 void TIsajet::SetAllPMIN(const Float_t val[], Int_t arraySize)
1915 Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1916 if (arraySize != length) {
1917 printf ("Error in TIsajet::SetAllPMIN : \n");
1918 printf ("Array must have %d elements.\n", length);
1922 for (Int_t i = 0; i < arraySize; i++) {
1927 /**************************************************************************/
1929 Float_t TIsajet::GetPMIN(Int_t index) const
1931 Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
1932 if ((index < 0) || (index >= length)) {
1933 printf ("Error in TIsajet::GetPMIN : \n");
1934 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1938 return JETLIM.pmin[index];
1941 /**************************************************************************/
1943 void TIsajet::SetPMAX(Float_t val, Int_t index)
1945 Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1946 if ((index < 0) || (index >= length)) {
1947 printf ("Error in TIsajet::SetPMAX : \n");
1948 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1952 if (val < JETLIM.pmin[index]) {
1953 printf("Error in TIsajet::SetPMAX : \n");
1954 printf("You may not set PMAX to a value larger than PMIN = %f.\n", JETLIM.pmin[index]);
1958 JETLIM.pmax[index] = val;
1962 /**************************************************************************/
1964 void TIsajet::SetAllPMAX(const Float_t val[], Int_t arraySize)
1966 Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1967 if (arraySize != length) {
1968 printf ("Error in TIsajet::SetAllPMAX : \n");
1969 printf ("Array must have %d elements.\n", length);
1973 for (Int_t i = 0; i < arraySize; i++) {
1978 /**************************************************************************/
1980 Float_t TIsajet::GetPMAX(Int_t index) const
1982 Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
1983 if ((index < 0) || (index >= length)) {
1984 printf ("Error in TIsajet::GetPMAX : \n");
1985 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
1989 return JETLIM.pmax[index];
1992 /**************************************************************************/
1994 void TIsajet::SetPTMIN(Float_t val, Int_t index)
1996 Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
1997 if ((index < 0) || (index >= length)) {
1998 printf ("Error in TIsajet::SetPTMIN : \n");
1999 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2003 if (val > JETLIM.ptmax[index]) {
2004 printf("Error in TIsajet::SetPTMIN : \n");
2005 printf("You may not set PTMIN to a value larger than PTMAX = %f.\n", JETLIM.ptmax[index]);
2009 JETLIM.ptmin[index] = val;
2010 // if (!setY) SetYJLIMS();
2011 // if (!setTheta) SetTHLIMS();
2015 /**************************************************************************/
2017 void TIsajet::SetAllPTMIN(const Float_t val[], Int_t arraySize)
2019 Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
2020 if (arraySize != length) {
2021 printf ("Error in TIsajet::SetAllPTMIN : \n");
2022 printf ("Array must have %d elements.\n", length);
2026 for (Int_t i = 0; i < arraySize; i++) {
2027 SetPTMIN(val[i], i);
2031 /**************************************************************************/
2033 Float_t TIsajet::GetPTMIN(Int_t index) const
2035 Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
2036 if ((index < 0) || (index >= length)) {
2037 printf ("Error in TIsajet::GetPTMIN : \n");
2038 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2042 return JETLIM.ptmin[index];
2045 /**************************************************************************/
2047 void TIsajet::SetPTMAX(Float_t val, Int_t index)
2049 Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2050 if ((index < 0) || (index >= length)) {
2051 printf ("Error in TIsajet::SetPTMAX : \n");
2052 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2056 if (val < JETLIM.ptmin[index]) {
2057 printf("Error in TIsajet::SetPTMAX : \n");
2058 printf("You may not set PTMAX to a value larger than PTMIN = %f.\n", JETLIM.ptmin[index]);
2062 JETLIM.ptmax[index] = val;
2066 /**************************************************************************/
2068 void TIsajet::SetAllPTMAX(const Float_t val[], Int_t arraySize)
2070 Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2071 if (arraySize != length) {
2072 printf ("Error in TIsajet::SetAllPTMAX : \n");
2073 printf ("Array must have %d elements.\n", length);
2077 for (Int_t i = 0; i < arraySize; i++) {
2078 SetPTMAX(val[i], i);
2082 /**************************************************************************/
2084 Float_t TIsajet::GetPTMAX(Int_t index) const
2086 Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
2087 if ((index < 0) || (index >= length)) {
2088 printf ("Error in TIsajet::GetPTMAX : \n");
2089 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2093 return JETLIM.ptmax[index];
2096 /**************************************************************************/
2098 void TIsajet::SetYJMIN(Float_t val, Int_t index)
2100 Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2101 if ((index < 0) || (index >= length)) {
2102 printf ("Error in TIsajet::SetYJMIN : \n");
2103 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2107 if (val > JETLIM.yjmax[index]) {
2108 printf("Error in TIsajet::SetYJMIN : \n");
2109 printf("You may not set YJMIN to a value larger than YJMAX = %f.\n", JETLIM.yjmax[index]);
2114 printf("Error in TIsajet::SetYJMIN :\n");
2115 printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMIN.\n");
2120 JETLIM.yjmin[index] = val;
2123 /**************************************************************************/
2125 void TIsajet::SetAllYJMIN(const Float_t val[], Int_t arraySize)
2127 Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2128 if (arraySize != length) {
2129 printf ("Error in TIsajet::SetAllYJMIN : \n");
2130 printf ("Array must have %d elements.\n", length);
2134 for (Int_t i = 0; i < arraySize; i++) {
2135 SetYJMIN(val[i], i);
2139 /**************************************************************************/
2141 Float_t TIsajet::GetYJMIN(Int_t index) const
2143 Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
2144 if ((index < 0) || (index >= length)) {
2145 printf ("Error in TIsajet::GetYJMIN : \n");
2146 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2150 return JETLIM.yjmin[index];
2153 /**************************************************************************/
2155 void TIsajet::SetYJMAX(Float_t val, Int_t index)
2157 Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2158 if ((index < 0) || (index >= length)) {
2159 printf ("Error in TIsajet::SetYJMAX : \n");
2160 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2164 if (val < JETLIM.yjmin[index]) {
2165 printf("Error in TIsajet::SetYJMAX : \n");
2166 printf("You may not set YJMAX to a value larger than YJMIN = %f.\n", JETLIM.yjmin[index]);
2171 printf("Error in TIsajet::SetYJMAX :\n");
2172 printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMAX.\n");
2177 JETLIM.yjmax[index] = val;
2180 /**************************************************************************/
2182 void TIsajet::SetAllYJMAX(const Float_t val[], Int_t arraySize)
2184 Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2185 if (arraySize != length) {
2186 printf ("Error in TIsajet::SetAllYJMAX : \n");
2187 printf ("Array must have %d elements.\n", length);
2191 for (Int_t i = 0; i < arraySize; i++) {
2192 SetYJMAX(val[i], i);
2196 /**************************************************************************/
2198 Float_t TIsajet::GetYJMAX(Int_t index) const
2200 Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
2201 if ((index < 0) || (index >= length)) {
2202 printf ("Error in TIsajet::GetYJMAX : \n");
2203 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2207 return JETLIM.yjmax[index];
2210 /**************************************************************************/
2212 void TIsajet::SetYJLIMS()
2214 for (Int_t i = 0; i < JETLIM.mxlim; i++) {
2215 JETLIM.yjmax[i] = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
2216 JETLIM.yjmax[i] = -JETLIM.yjmin[i];
2221 /**************************************************************************/
2223 void TIsajet::SetPHIMIN(Float_t val, Int_t index)
2225 Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2226 if ((index < 0) || (index >= length)) {
2227 printf ("Error in TIsajet::SetPHIMIN : \n");
2228 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2232 if (val > JETLIM.phimax[index]) {
2233 printf("Error in TIsajet::SetPHIMIN : \n");
2234 printf("You may not set PHIMIN to a value larger than PHIMAX = %f.\n", JETLIM.phimax[index]);
2238 JETLIM.phimin[index] = val;
2242 /**************************************************************************/
2244 void TIsajet::SetAllPHIMIN(const Float_t val[], Int_t arraySize)
2246 Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2247 if (arraySize != length) {
2248 printf ("Error in TIsajet::SetAllPHIMIN : \n");
2249 printf ("Array must have %d elements.\n", length);
2253 for (Int_t i = 0; i < arraySize; i++) {
2254 SetPHIMIN(val[i], i);
2258 /**************************************************************************/
2260 Float_t TIsajet::GetPHIMIN(Int_t index) const
2262 Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
2263 if ((index < 0) || (index >= length)) {
2264 printf ("Error in TIsajet::GetPHIMIN : \n");
2265 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2269 return JETLIM.phimin[index];
2272 /**************************************************************************/
2274 void TIsajet::SetPHIMAX(Float_t val, Int_t index)
2276 Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2277 if ((index < 0) || (index >= length)) {
2278 printf ("Error in TIsajet::SetPHIMAX : \n");
2279 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2283 if (val < JETLIM.phimin[index]) {
2284 printf("Error in TIsajet::SetPHIMAX : \n");
2285 printf("You may not set PHIMAX to a value larger than PHIMIN = %f.\n", JETLIM.phimin[index]);
2289 JETLIM.phimax[index] = val;
2293 /**************************************************************************/
2295 void TIsajet::SetAllPHIMAX(const Float_t val[], Int_t arraySize)
2297 Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2298 if (arraySize != length) {
2299 printf ("Error in TIsajet::SetAllPHIMAX : \n");
2300 printf ("Array must have %d elements.\n", length);
2304 for (Int_t i = 0; i < arraySize; i++) {
2305 SetPHIMAX(val[i], i);
2309 /**************************************************************************/
2311 Float_t TIsajet::GetPHIMAX(Int_t index) const
2313 Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
2314 if ((index < 0) || (index >= length)) {
2315 printf ("Error in TIsajet::GetPHIMAX : \n");
2316 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2320 return JETLIM.phimax[index];
2323 /**************************************************************************/
2325 void TIsajet::SetXJMIN(Float_t val, Int_t index)
2327 Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2328 if ((index < 0) || (index >= length)) {
2329 printf ("Error in TIsajet::SetXJMIN : \n");
2330 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2333 if (val > JETLIM.xjmax[index]) {
2334 printf("Error in TIsajet::SetXJMIN : \n");
2335 printf("You may not set XJMIN to a value larger than XJMAX = %f.\n", JETLIM.xjmax[index]);
2339 JETLIM.xjmin[index] = val;
2343 /**************************************************************************/
2345 void TIsajet::SetAllXJMIN(const Float_t val[], Int_t arraySize)
2347 Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2348 if (arraySize != length) {
2349 printf ("Error in TIsajet::SetAllXJMIN : \n");
2350 printf ("Array must have %d elements.\n", length);
2354 for (Int_t i = 0; i < arraySize; i++) {
2355 SetXJMIN(val[i], i);
2359 /**************************************************************************/
2361 Float_t TIsajet::GetXJMIN(Int_t index) const
2363 Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
2364 if ((index < 0) || (index >= length)) {
2365 printf ("Error in TIsajet::GetXJMIN : \n");
2366 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2370 return JETLIM.xjmin[index];
2373 /**************************************************************************/
2375 void TIsajet::SetXJMAX(Float_t val, Int_t index)
2377 Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2378 if ((index < 0) || (index >= length)) {
2379 printf ("Error in TIsajet::SetXJMAX : \n");
2380 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2384 if (val < JETLIM.xjmin[index]) {
2385 printf("Error in TIsajet::SetXJMAX : \n");
2386 printf("You may not set XJMAX to a value larger than XJMIN = %f.\n", JETLIM.xjmin[index]);
2390 JETLIM.xjmax[index] = val;
2394 /**************************************************************************/
2396 void TIsajet::SetAllXJMAX(const Float_t val[], Int_t arraySize)
2398 Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2399 if (arraySize != length) {
2400 printf ("Error in TIsajet::SetAllXJMAX : \n");
2401 printf ("Array must have %d elements.\n", length);
2405 for (Int_t i = 0; i < arraySize; i++) {
2406 SetXJMAX(val[i], i);
2410 /**************************************************************************/
2412 Float_t TIsajet::GetXJMAX(Int_t index) const
2414 Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
2415 if ((index < 0) || (index >= length)) {
2416 printf ("Error in TIsajet::GetXJMAX : \n");
2417 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2421 return JETLIM.xjmax[index];
2424 /**************************************************************************/
2426 void TIsajet::SetTHMIN(Float_t val, Int_t index)
2428 Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2429 if ((index < 0) || (index >= length)) {
2430 printf ("Error in TIsajet::SetTHMIN : \n");
2431 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2435 if (val > JETLIM.thmax[index]) {
2436 printf("Error in TIsajet::SetTHMIN : \n");
2437 printf("You may not set THMIN to a value larger than THMAX = %f.\n", JETLIM.thmax[index]);
2442 printf("Error in TIsajet::SetTHMIN :\n");
2443 printf("May not set both theta and y limits. Use SetYJLIMS, then set THMIN.\n");
2448 JETLIM.thmin[index] = val;
2452 /**************************************************************************/
2454 void TIsajet::SetAllTHMIN(const Float_t val[], Int_t arraySize)
2456 Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2457 if (arraySize != length) {
2458 printf ("Error in TIsajet::SetAllTHMIN : \n");
2459 printf ("Array must have %d elements.\n", length);
2463 for (Int_t i = 0; i < arraySize; i++) {
2464 SetTHMIN(val[i], i);
2468 /**************************************************************************/
2470 Float_t TIsajet::GetTHMIN(Int_t index) const
2472 Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
2473 if ((index < 0) || (index >= length)) {
2474 printf ("Error in TIsajet::GetTHMIN : \n");
2475 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2479 return JETLIM.thmin[index];
2482 /**************************************************************************/
2484 void TIsajet::SetTHMAX(Float_t val, Int_t index)
2486 Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2487 if ((index < 0) || (index >= length)) {
2488 printf ("Error in TIsajet::SetTHMAX : \n");
2489 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2493 if (val < JETLIM.thmin[index]) {
2494 printf("Error in TIsajet::SetTHMAX : \n");
2495 printf("You may not set THMAX to a value larger than THMIN = %f.\n", JETLIM.thmin[index]);
2500 printf("Error in TIsajet::SetTHMAX :\n");
2501 printf("May not set both theta and y limits. Use SetYJLIMS, then set THMAX.\n");
2506 JETLIM.thmax[index] = val;
2509 /**************************************************************************/
2511 void TIsajet::SetAllTHMAX(const Float_t val[], Int_t arraySize)
2513 Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2514 if (arraySize != length) {
2515 printf ("Error in TIsajet::SetAllTHMAX : \n");
2516 printf ("Array must have %d elements.\n", length);
2520 for (Int_t i = 0; i < arraySize; i++) {
2521 SetTHMAX(val[i], i);
2525 /**************************************************************************/
2527 Float_t TIsajet::GetTHMAX(Int_t index) const
2529 Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
2530 if ((index < 0) || (index >= length)) {
2531 printf ("Error in TIsajet::GetTHMAX : \n");
2532 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2536 return JETLIM.thmax[index];
2539 /**************************************************************************/
2541 void TIsajet::SetTHLIMS()
2544 for (Int_t i = 0; i < JETLIM.mxlim; i++) {
2545 tmin = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
2546 JETLIM.thmin[i] = 2*atan(exp(tmin));
2547 JETLIM.thmax[i] = 2*atan(exp(-tmin));
2552 /**************************************************************************/
2554 Bool_t TIsajet::GetSETLMJ(Int_t index) const
2556 Int_t length = (sizeof JETLIM.setlmj / sizeof JETLIM.setlmj[0]);
2557 if ((index < 0) || (index >= length)) {
2558 printf ("Error in TIsajet::GetSETLMJ : \n");
2559 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2563 return JETLIM.setlmj[index];
2566 /**************************************************************************/
2568 // Ends JETLIM access.
2569 // Begins JETPAR access.
2571 /**************************************************************************/
2573 Float_t TIsajet::GetP(Int_t index) const
2575 Int_t length = (sizeof JETPAR.p / sizeof JETPAR.p[0]);
2576 if ((index < 0) || (index >= length)) {
2577 printf ("Error in TIsajet::GetP : \n");
2578 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2582 return JETPAR.p[index];
2585 /**************************************************************************/
2587 Float_t TIsajet::GetPT(Int_t index) const
2589 Int_t length = (sizeof JETPAR.pt / sizeof JETPAR.pt[0]);
2590 if ((index < 0) || (index >= length)) {
2591 printf ("Error in TIsajet::GetPT : \n");
2592 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2596 return JETPAR.pt[index];
2599 /**************************************************************************/
2601 Float_t TIsajet::GetYJ(Int_t index) const
2603 Int_t length = (sizeof JETPAR.yj / sizeof JETPAR.yj[0]);
2604 if ((index < 0) || (index >= length)) {
2605 printf ("Error in TIsajet::GetYJ : \n");
2606 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2610 return JETPAR.yj[index];
2613 /**************************************************************************/
2615 Float_t TIsajet::GetPHI(Int_t index) const
2617 Int_t length = (sizeof JETPAR.phi / sizeof JETPAR.phi[0]);
2618 if ((index < 0) || (index >= length)) {
2619 printf ("Error in TIsajet::GetPHI : \n");
2620 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2624 return JETPAR.phi[index];
2627 /**************************************************************************/
2629 Float_t TIsajet::GetXJ(Int_t index) const
2631 Int_t length = (sizeof JETPAR.xj / sizeof JETPAR.xj[0]);
2632 if ((index < 0) || (index >= length)) {
2633 printf ("Error in TIsajet::GetXJ : \n");
2634 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2638 return JETPAR.xj[index];
2641 /**************************************************************************/
2643 Float_t TIsajet::GetTH(Int_t index) const
2645 Int_t length = (sizeof JETPAR.th / sizeof JETPAR.th[0]);
2646 if ((index < 0) || (index >= length)) {
2647 printf ("Error in TIsajet::GetTH : \n");
2648 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2652 return JETPAR.th[index];
2655 /**************************************************************************/
2657 Float_t TIsajet::GetCTH(Int_t index) const
2659 Int_t length = (sizeof JETPAR.cth / sizeof JETPAR.cth[0]);
2660 if ((index < 0) || (index >= length)) {
2661 printf ("Error in TIsajet::GetCTH : \n");
2662 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2666 return JETPAR.cth[index];
2669 /**************************************************************************/
2671 Float_t TIsajet::GetSTH(Int_t index) const
2673 Int_t length = (sizeof JETPAR.sth / sizeof JETPAR.sth[0]);
2674 if ((index < 0) || (index >= length)) {
2675 printf ("Error in TIsajet::GetSTH : \n");
2676 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2680 return JETPAR.sth[index];
2683 /**************************************************************************/
2685 Int_t TIsajet::GetJETTYP(Int_t index) const
2687 Int_t length = (sizeof JETPAR.jettyp / sizeof JETPAR.jettyp[0]);
2688 if ((index < 0) || (index >= length)) {
2689 printf ("Error in TIsajet::GetJETTYP : \n");
2690 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2694 return JETPAR.jettyp[index];
2697 /**************************************************************************/
2699 Float_t TIsajet::GetSHAT() const
2704 /**************************************************************************/
2706 Float_t TIsajet::GetTHAT() const
2711 /**************************************************************************/
2713 Float_t TIsajet::GetUHAT() const
2718 /**************************************************************************/
2720 Float_t TIsajet::GetQSQ() const
2725 /**************************************************************************/
2727 Float_t TIsajet::GetX1() const
2732 /**************************************************************************/
2734 Float_t TIsajet::GetX2() const
2739 /**************************************************************************/
2741 Float_t TIsajet::GetPBEAM(Int_t index) const
2743 Int_t length = (sizeof JETPAR.pbeam / sizeof JETPAR.pbeam[0]);
2744 if ((index < 0) || (index >= length)) {
2745 printf ("Error in TIsajet::GetPBEAM : \n");
2746 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2750 return JETPAR.pbeam[index];
2753 /**************************************************************************/
2755 Float_t TIsajet::GetQMW() const
2760 /**************************************************************************/
2762 Float_t TIsajet::GetQW() const
2767 /**************************************************************************/
2769 Float_t TIsajet::GetQTW() const
2774 /**************************************************************************/
2776 Float_t TIsajet::GetYW() const
2781 /**************************************************************************/
2783 Float_t TIsajet::GetXW() const
2788 /**************************************************************************/
2790 Float_t TIsajet::GetTHW() const
2795 /**************************************************************************/
2797 Float_t TIsajet::GetQTMW() const
2802 /**************************************************************************/
2804 Float_t TIsajet::GetPHIW() const
2809 /**************************************************************************/
2811 Float_t TIsajet::GetSHAT1() const
2813 return JETPAR.shat1;
2816 /**************************************************************************/
2818 Float_t TIsajet::GetTHAT1() const
2820 return JETPAR.that1;
2823 /**************************************************************************/
2825 Float_t TIsajet::GetUHAT1() const
2827 return JETPAR.uhat1;
2830 /**************************************************************************/
2832 void TIsajet::SetJWTYP(Int_t val)
2834 if ((val < 1) || (val > 4) || (val == 2))
2836 printf ("Error in TIsajet::SetJWTYP : \n");
2837 printf ("Invalid value %d; range is 1, 3, and 4.\n", val);
2844 /**************************************************************************/
2846 void TIsajet::SetJWTYP(Char_t val[])
2850 if (!strcmp(val, "GM")) value = 1;
2851 else if (!strcmp(val, "W+")) value = 3;
2852 else if (!strcmp(val, "W-")) value = 3;
2853 else if (!strcmp(val, "Z0")) value = 4;
2856 printf ("Error in TIsajet::SetJWTYP : \n");
2857 printf ("Invalid value %s; possible are GM, Z0, W+ and W-.\n", val);
2862 JETPAR.jwtyp = value;
2865 /**************************************************************************/
2867 Int_t TIsajet::GetJWTYP() const
2869 return JETPAR.jwtyp;
2872 /**************************************************************************/
2874 Float_t TIsajet::GetALFQSQ() const
2876 return JETPAR.alfqsq;
2879 /**************************************************************************/
2881 Float_t TIsajet::GetCTHW() const
2886 /**************************************************************************/
2888 Float_t TIsajet::GetSTHW() const
2893 /**************************************************************************/
2895 Float_t TIsajet::GetQ0W() const
2900 /**************************************************************************/
2902 Int_t TIsajet::GetINITYP(Int_t index) const
2904 Int_t length = (sizeof JETPAR.inityp / sizeof JETPAR.inityp[0]);
2905 if ((index < 0) || (index >= length)) {
2906 printf ("Error in TIsajet::GetINITYP : \n");
2907 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2911 return JETPAR.inityp[index];
2914 /**************************************************************************/
2916 Int_t TIsajet::GetISIGS() const
2918 return JETPAR.isigs;
2921 /**************************************************************************/
2923 Float_t TIsajet::GetPBEAMS(Int_t index) const
2925 Int_t length = (sizeof JETPAR.pbeams / sizeof JETPAR.pbeams[0]);
2926 if ((index < 0) || (index >= length)) {
2927 printf ("Error in TIsajet::GetPBEAMS : \n");
2928 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
2932 return JETPAR.pbeams[index];
2935 /**************************************************************************/
2937 // Ends JETPAR access.
2938 // Begins KKGRAV access.
2940 /**************************************************************************/
2942 void TIsajet::SetNEXTRAD(Int_t val)
2944 KKGRAV.nextrad = val;
2947 /**************************************************************************/
2949 Int_t TIsajet::GetNEXTRAD() const
2951 return KKGRAV.nextrad;
2954 /**************************************************************************/
2956 void TIsajet::SetMASSD(Float_t val)
2961 /**************************************************************************/
2963 Float_t TIsajet::GetMASSD() const
2965 return KKGRAV.massd;
2968 /**************************************************************************/
2970 Float_t TIsajet::GetKKGSD() const
2972 return KKGRAV.kkgsd;
2975 /**************************************************************************/
2977 Float_t TIsajet::GetSURFD() const
2979 return KKGRAV.surfd;
2982 /**************************************************************************/
2984 void TIsajet::SetUVCUT(Bool_t val)
2989 /**************************************************************************/
2991 Bool_t TIsajet::GetUVCUT() const
2993 return KKGRAV.uvcut;
2996 /**************************************************************************/
2998 // Ends KKGRAV access.
2999 // Begins MBGEN access.
3001 /**************************************************************************/
3003 Float_t TIsajet::GetPOMWT(Int_t index) const
3005 Int_t length = (sizeof MBGEN.pomwt / sizeof MBGEN.pomwt[0]);
3006 if ((index < 0) || (index >= length)) {
3007 printf ("Error in TIsajet::GetPOMWT : \n");
3008 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3012 return MBGEN.pomwt[index];
3015 /**************************************************************************/
3017 Float_t TIsajet::GetPOMGEN(Int_t index) const
3019 Int_t length = (sizeof MBGEN.pomgen / sizeof MBGEN.pomgen[0]);
3020 if ((index < 0) || (index >= length)) {
3021 printf ("Error in TIsajet::GetPOMGEN : \n");
3022 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3026 return MBGEN.pomgen[index];
3029 /**************************************************************************/
3031 void TIsajet::SetMNPOM(Int_t val)
3033 if (val > MBGEN.mxpom) {
3034 printf("Error in TIsajet::SetMNPOM : \n");
3035 printf("You may not set MNPOM to a value larger than MXPOM = %d.\n", MBGEN.mxpom);
3042 /**************************************************************************/
3044 Int_t TIsajet::GetMNPOM() const
3049 /**************************************************************************/
3051 void TIsajet::SetMXPOM(Int_t val)
3053 if (val < MBGEN.mnpom) {
3054 printf("Error in TIsajet::SetMXPOM : \n");
3055 printf("You may not set MXPOM to a value less than MNPOM = %d.\n", MBGEN.mnpom);
3062 /**************************************************************************/
3064 Int_t TIsajet::GetMXPOM() const
3069 /**************************************************************************/
3071 Float_t TIsajet::GetPDIFFR() const
3073 return MBGEN.pdiffr;
3076 /**************************************************************************/
3078 Int_t TIsajet::GetNPOM() const
3083 /**************************************************************************/
3085 Float_t TIsajet::GetXBARY(Int_t index) const
3087 Int_t length = (sizeof MBGEN.xbary / sizeof MBGEN.xbary[0]);
3088 if ((index < 0) || (index >= length)) {
3089 printf ("Error in TIsajet::GetXBARY : \n");
3090 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3094 return MBGEN.xbary[index];
3097 /**************************************************************************/
3099 Float_t TIsajet::GetDXBARY(Int_t index) const
3101 Int_t length = (sizeof MBGEN.dxbary / sizeof MBGEN.dxbary[0]);
3102 if ((index < 0) || (index >= length)) {
3103 printf ("Error in TIsajet::GetDXBARY : \n");
3104 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3108 return MBGEN.dxbary[index];
3111 /**************************************************************************/
3113 Float_t TIsajet::GetXPOM(Int_t index1, Int_t index2) const
3115 Int_t elem_Size = sizeof MBGEN.xpom[0][0];
3116 Int_t sec_Dim_Length = (sizeof MBGEN.xpom[0] / elem_Size);
3117 Int_t fst_Dim_Length = (sizeof MBGEN.xpom / (elem_Size * sec_Dim_Length));
3119 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
3120 printf ("Error in TIsajet::GetXPOM : \n");
3121 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
3125 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
3126 printf ("Error in TIsajet::GetXPOM : \n");
3127 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
3131 return MBGEN.xpom[index1][index2];
3134 /**************************************************************************/
3136 // Ends MBGEN access.
3137 // Begins MGLIMS access.
3139 /**************************************************************************/
3141 void TIsajet::SetEHMGMN(Float_t val)
3143 if (val > MGLIMS.ehmgmx) {
3144 printf("Error in TIsajet::SetEHMGMN : \n");
3145 printf("You may not set EHMGMN to a value larger than EHMGMX = %f.\n", MGLIMS.ehmgmx);
3149 MGLIMS.ehmgmn = val;
3152 /**************************************************************************/
3154 Float_t TIsajet::GetEHMGMN() const
3156 return MGLIMS.ehmgmn;
3159 /**************************************************************************/
3161 void TIsajet::SetEHMGMX(Float_t val)
3163 if (val < MGLIMS.ehmgmn) {
3164 printf("Error in TIsajet::SetEHMGMX : \n");
3165 printf("You may not set EHMGMX to a value less than EHMGMN = %f.\n", MGLIMS.ehmgmn);
3169 MGLIMS.ehmgmx = val;
3172 /**************************************************************************/
3174 Float_t TIsajet::GetEHMGMX() const
3176 return MGLIMS.ehmgmx;
3179 /**************************************************************************/
3181 Float_t TIsajet::GetYHMGMN() const
3183 return MGLIMS.yhmgmn;
3186 /**************************************************************************/
3188 Float_t TIsajet::GetYHMGMX() const
3190 return MGLIMS.yhmgmx;
3193 /**************************************************************************/
3195 void TIsajet::SetAMIJMN(Float_t val, Int_t index1, Int_t index2)
3197 Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3198 Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3200 if ((index1 < 0) || (index1 >= row_num)) {
3201 printf ("Error in TIsajet::SetAMIJMN : \n");
3202 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3206 if ((index2 < 0) || (index2 >= col_num)) {
3207 printf ("Error in TIsajet::SetAMIJMN : \n");
3208 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3212 if (val > MGLIMS.amijmx[index1][index2]) {
3213 printf("Error in TIsajet::SetAMIJMN : \n");
3214 printf("You may not set AMIJMN to a value larger than AMIJMX = %f.\n", MGLIMS.amijmx[index1][index2]);
3218 MGLIMS.amijmn[index1][index2] = val;
3221 /**************************************************************************/
3223 void TIsajet::SetAllAMIJMN(const Float_t val[8][8])
3225 for (Int_t i = 0; i < 2; i++) {
3226 for (Int_t j = 0; j < 3; j++) {
3227 SetAMIJMN(val[i][j], i, j);
3232 /**************************************************************************/
3234 void TIsajet::SetColumnAMIJMN(const Float_t val[], Int_t col)
3236 Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3237 Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3239 if ((col < 0) || (col >= col_num)) {
3240 printf ("Error in TIsajet::SetColumnAMIJMN : \n");
3241 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
3245 for (Int_t i = 0; i < row_num; i++) {
3246 SetAMIJMN(val[i], i, col);
3250 /**************************************************************************/
3252 Float_t TIsajet::GetAMIJMN(Int_t index1, Int_t index2) const
3254 Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
3255 Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
3257 if ((index1 < 0) || (index1 >= row_num)) {
3258 printf ("Error in TIsajet::GetAMIJMN : \n");
3259 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3263 if ((index2 < 0) || (index2 >= col_num)) {
3264 printf ("Error in TIsajet::GetAMIJMN : \n");
3265 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3269 return MGLIMS.amijmn[index1][index2];
3272 /**************************************************************************/
3274 void TIsajet::SetAMIJMX(Float_t val, Int_t index1, Int_t index2)
3276 Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3277 Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3279 if ((index1 < 0) || (index1 >= row_num)) {
3280 printf ("Error in TIsajet::SetAMIJMX : \n");
3281 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3285 if ((index2 < 0) || (index2 >= col_num)) {
3286 printf ("Error in TIsajet::SetAMIJMX : \n");
3287 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3291 if (val < MGLIMS.amijmn[index1][index2]) {
3292 printf("Error in TIsajet::SetAMIJMX : \n");
3293 printf("You may not set AMIJMX to a value less than AMIJMN = %f.\n", MGLIMS.amijmn[index1][index2]);
3297 MGLIMS.amijmx[index1][index2] = val;
3300 /**************************************************************************/
3302 void TIsajet::SetAllAMIJMX(const Float_t val[8][8])
3304 for (Int_t i = 0; i < 2; i++) {
3305 for (Int_t j = 0; j < 3; j++) {
3306 SetAMIJMX(val[i][j], i, j);
3311 /**************************************************************************/
3313 void TIsajet::SetColumnAMIJMX(const Float_t val[], Int_t col)
3315 Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3316 Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3318 if ((col < 0) || (col >= col_num)) {
3319 printf ("Error in TIsajet::SetColumnAMIJMX : \n");
3320 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
3324 for (Int_t i = 0; i < row_num; i++) {
3325 SetAMIJMX(val[i], i, col);
3329 /**************************************************************************/
3331 Float_t TIsajet::GetAMIJMX(Int_t index1, Int_t index2) const
3333 Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
3334 Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
3336 if ((index1 < 0) || (index1 >= row_num)) {
3337 printf ("Error in TIsajet::GetAMIJMX : \n");
3338 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
3342 if ((index2 < 0) || (index2 >= col_num)) {
3343 printf ("Error in TIsajet::GetAMIJMX : \n");
3344 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
3348 return MGLIMS.amijmx[index1][index2];
3351 /**************************************************************************/
3353 Bool_t TIsajet::GetFIXMIJ(Int_t index1, Int_t index2) const
3355 Int_t elem_Size = sizeof MGLIMS.fixmij[0][0];
3356 Int_t sec_Dim_Length = (sizeof MGLIMS.fixmij[0] / elem_Size);
3357 Int_t fst_Dim_Length = (sizeof MGLIMS.fixmij / (elem_Size * sec_Dim_Length));
3359 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
3360 printf ("Error in TIsajet::GetFIXMIJ : \n");
3361 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
3365 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
3366 printf ("Error in TIsajet::GetFIXMIJ : \n");
3367 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
3371 return MGLIMS.fixmij[index1][index2];
3374 /**************************************************************************/
3376 // Ends MGLIMS access.
3377 // Begins NODCAY access.
3379 /**************************************************************************/
3381 void TIsajet::SetNODCAY(Bool_t val)
3383 NODCAY.nodcay = val;
3387 /**************************************************************************/
3389 Bool_t TIsajet::GetNODCAY() const
3391 return NODCAY.nodcay;
3394 /**************************************************************************/
3396 void TIsajet::SetNOETA(Bool_t val)
3402 /**************************************************************************/
3404 Bool_t TIsajet::GetNOETA() const
3406 return NODCAY.noeta;
3409 /**************************************************************************/
3411 void TIsajet::SetNOPI0(Bool_t val)
3417 /**************************************************************************/
3419 Bool_t TIsajet::GetNOPI0() const
3421 return NODCAY.nopi0;
3424 /**************************************************************************/
3426 void TIsajet::SetNONUNU(Bool_t val)
3428 NODCAY.nonunu = val;
3431 /**************************************************************************/
3433 Bool_t TIsajet::GetNONUNU() const
3435 return NODCAY.nonunu;
3438 /**************************************************************************/
3440 void TIsajet::SetNOEVOL(Bool_t val)
3442 NODCAY.noevol = val;
3446 /**************************************************************************/
3448 Bool_t TIsajet::GetNOEVOL() const
3450 return NODCAY.noevol;
3453 /**************************************************************************/
3455 void TIsajet::SetNOHADR(Bool_t val)
3457 NODCAY.nohadr = val;
3461 /**************************************************************************/
3463 Bool_t TIsajet::GetNOHADR() const
3465 return NODCAY.nohadr;
3468 /**************************************************************************/
3470 void TIsajet::SetNOGRAV(Bool_t val)
3472 NODCAY.nograv = val;
3475 /**************************************************************************/
3477 Bool_t TIsajet::GetNOGRAV() const
3479 return NODCAY.nograv;
3482 /**************************************************************************/
3484 // Ends NODCAY access.
3485 // Begins PARTCL access.
3487 /**************************************************************************/
3489 Int_t TIsajet::GetNPTCL() const
3491 return PARTCL.nptcl;
3494 /**************************************************************************/
3496 Float_t TIsajet::GetPX(Int_t index) const
3498 if ((index < 0) || (index >= PARTCL.nptcl)) {
3499 printf ("Error in TIsajet::GetPX : \n");
3500 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3504 return PARTCL.pptcl[index][0];
3507 /**************************************************************************/
3509 Float_t TIsajet::GetPY(Int_t index) const
3511 if ((index < 0) || (index >= PARTCL.nptcl)) {
3512 printf ("Error in TIsajet::GetPY : \n");
3513 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3517 return PARTCL.pptcl[index][1];
3520 /**************************************************************************/
3522 Float_t TIsajet::GetPZ(Int_t index) const
3524 if ((index < 0) || (index >= PARTCL.nptcl)) {
3525 printf ("Error in TIsajet::GetPZ : \n");
3526 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3530 return PARTCL.pptcl[index][2];
3533 /**************************************************************************/
3535 Float_t TIsajet::GetP0(Int_t index) const
3537 if ((index < 0) || (index >= PARTCL.nptcl)) {
3538 printf ("Error in TIsajet::GetP0 : \n");
3539 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3543 return PARTCL.pptcl[index][3];
3546 /**************************************************************************/
3548 Float_t TIsajet::GetMASS(Int_t index) const
3550 if ((index < 0) || (index >= PARTCL.nptcl)) {
3551 printf ("Error in TIsajet::GetMASS : \n");
3552 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3556 return PARTCL.pptcl[index][4];
3559 /**************************************************************************/
3561 Float_t TIsajet::GetORIG(Int_t index) const
3563 if ((index < 0) || (index >= PARTCL.nptcl)) {
3564 printf ("Error in TIsajet::GetORIG : \n");
3565 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3569 return PARTCL.iorig[index];
3572 /**************************************************************************/
3574 Float_t TIsajet::GetIDENT(Int_t index) const
3576 if ((index < 0) || (index >= PARTCL.nptcl)) {
3577 printf ("Error in TIsajet::GetIDENT : \n");
3578 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3582 return PARTCL.ident[index];
3585 /**************************************************************************/
3587 Float_t TIsajet::GetIDCAY(Int_t index) const
3589 if ((index < 0) || (index >= PARTCL.nptcl)) {
3590 printf ("Error in TIsajet::GetIDCAY : \n");
3591 printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
3595 return PARTCL.idcay[index];
3598 /**************************************************************************/
3600 // Ends PARTCL access.
3601 // Begins PRIMAR access.
3603 /**************************************************************************/
3605 Int_t TIsajet::GetNJET() const
3610 /**************************************************************************/
3612 Float_t TIsajet::GetSCM() const
3617 /**************************************************************************/
3619 Float_t TIsajet::GetHALFE() const
3621 return PRIMAR.halfe;
3624 /**************************************************************************/
3626 void TIsajet::SetECM(Float_t val)
3629 printf ("Error in TIsajet::SetECM :\n");
3630 printf ("Cannot set energy to a negative value.\n");
3635 PRIMAR.scm = val*val;
3636 PRIMAR.halfe = val / 2;
3639 /**************************************************************************/
3641 Float_t TIsajet::GetECM() const
3646 /**************************************************************************/
3648 void TIsajet::SetIDIN(Int_t val, Int_t index)
3650 Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3651 if ((index < 0) || (index >= length)) {
3652 printf ("Error in TIsajet::SetIDIN : \n");
3653 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3657 if ((val = 1120) || (val = 1220) || (val = -1120) || (val = -1220)) {
3658 PRIMAR.idin[index] = val;
3661 printf ("Error in TIsajet::SetIDIN : \n");
3662 printf ("Invalid input value %d. Possible values are 1120, 1220, -1120, -1220.\n", val);
3669 /**************************************************************************/
3671 void TIsajet::SetIDIN(const Char_t val[], Int_t index)
3673 Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3674 if ((index < 0) || (index >= length)) {
3675 printf ("Error in TIsajet::SetIDIN : \n");
3676 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3680 if (!strcmp("P", val)) {
3681 PRIMAR.idin[index] = 1120;
3683 else if (!strcmp("AP", val)) {
3684 PRIMAR.idin[index] = -1120;
3686 else if (!strcmp("N", val)) {
3687 PRIMAR.idin[index] = 1220;
3689 else if (!strcmp("AN", val)) {
3690 PRIMAR.idin[index] = -1220;
3693 printf ("Error in TIsajet::SetIDIN : \n");
3694 printf ("Invalid input string %s. Possible strings are P, AP, N, and AN.\n", val);
3699 /**************************************************************************/
3701 Int_t TIsajet::GetIDIN(Int_t index) const
3703 Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
3704 if ((index < 0) || (index >= length)) {
3705 printf ("Error in TIsajet::GetIDIN : \n");
3706 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3710 return PRIMAR.idin[index];
3713 /**************************************************************************/
3715 Int_t TIsajet::GetNEVENT() const
3717 return PRIMAR.nevent;
3720 /**************************************************************************/
3722 void TIsajet::SetNTRIES(Int_t val)
3724 PRIMAR.ntries = val;
3727 /**************************************************************************/
3729 Int_t TIsajet::GetNTRIES() const
3731 return PRIMAR.ntries;
3734 /**************************************************************************/
3736 void TIsajet::SetNSIGMA(Int_t val)
3738 PRIMAR.nsigma = val;
3742 /**************************************************************************/
3744 Int_t TIsajet::GetNSIGMA() const
3746 return PRIMAR.nsigma;
3749 /**************************************************************************/
3751 // Ends PRIMAR access.
3752 // Begins QCDPAR access.
3754 /**************************************************************************/
3756 void TIsajet::SetALAM(Float_t val)
3759 QCDPAR.alam2 = val*val;
3763 /**************************************************************************/
3765 Float_t TIsajet::GetALAM() const
3770 /**************************************************************************/
3772 Float_t TIsajet::GetALAM2() const
3774 return QCDPAR.alam2;
3777 /**************************************************************************/
3779 void TIsajet::SetCUTJET(Float_t val)
3781 QCDPAR.cutjet = val;
3785 /**************************************************************************/
3787 Float_t TIsajet::GetCUTJET() const
3789 return QCDPAR.cutjet;
3792 /**************************************************************************/
3794 void TIsajet::SetISTRUC(Int_t val)
3796 if ((val < 1) || (val > 6)) {
3797 printf ("Error in TIsajet::SetISTRUC : \n");
3798 printf ("Invalid input value %d. Possible values are 1 through 6.\n", val);
3801 QCDPAR.istruc = val;
3804 /**************************************************************************/
3806 void TIsajet::SetISTRUC(const Char_t val[])
3808 if (!strcmp("OWENS", val)) {
3811 else if (!strcmp("BAIER", val)) {
3814 else if ((!strcmp("EICHTEN", val)) || (!strcmp("EHLQ", val))) {
3817 else if ((!strcmp("DUKE", val)) || (!strcmp("DO", val))) {
3820 else if (!strcmp("CTEQ2L", val)) {
3823 else if ((!strcmp("CTEQ", val)) || (!strcmp("CTEQ3L", val))) {
3827 printf ("Error in TIsajet::SetISTRUC : \n");
3828 printf ("Invalid input string %s. Possible strings are OWENS, BAIER, EICHTEN, \n", val);
3829 printf ("EHLQ, DUKE, DO, CTEQ2L, CTEQ, and CTEQ3L.\n");
3834 /**************************************************************************/
3836 Int_t TIsajet::GetISTRUC() const
3838 return QCDPAR.istruc;
3841 /**************************************************************************/
3843 // Ends QCDPAR access.
3844 // Begins QLMASS access.
3846 /**************************************************************************/
3848 void TIsajet::SetAMLEP(Float_t val, Int_t index)
3850 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3851 if ((index < 0) || (index >= length)) {
3852 printf ("Error in TIsajet::SetAMLEP : \n");
3853 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3857 if (((index < 5) && (index > 7)) &&
3858 ((index < 21) && (index > 26)) &&
3859 ((index < 29) && (index > 36)) &&
3860 ((index < 39) && (index > 40)) &&
3861 ((index < 63) && (index > 71)))
3863 printf ("Error in TIsajet::SetAMLEP : \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");
3869 QLMASS.amlep[index] = val;
3872 /**************************************************************************/
3874 Float_t TIsajet::GetAMLEP(Int_t index) const
3876 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3877 if ((index < 0) || (index >= length)) {
3878 printf ("Error in TIsajet::GetAMLEP : \n");
3879 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3882 if ((index < 5) || (index > 71) ||
3883 ((index > 7) && (index < 21)) ||
3884 ((index > 26) && (index < 29)) ||
3885 ((index > 36) && (index < 39)) ||
3886 ((index > 40) && (index < 63)))
3888 printf ("Possible error in TIsajet::GetAMLEP : \n");
3889 printf ("Index %d may not be set by the user. Valid indices are : \n", index);
3890 printf ("5-7, 21-26, 29-36, 39-40 and 63-71. \n");
3891 printf ("To return the value of this index, use GetAnyAMLEP(Int_t index).\n");
3896 return QLMASS.amlep[index];
3899 /**************************************************************************/
3901 Float_t TIsajet::GetAnyAMLEP(Int_t index) const
3903 Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
3904 if ((index < 0) || (index >= length)) {
3905 printf ("Error in TIsajet::GetAnyAMLEP : \n");
3906 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
3910 return QLMASS.amlep[index];
3913 /**************************************************************************/
3915 void TIsajet::SetTquarkMass(Float_t val)
3917 QLMASS.amlep[5] = val;
3920 /**************************************************************************/
3922 Float_t TIsajet::GetTquarkMass() const
3924 return QLMASS.amlep[5];
3927 /**************************************************************************/
3929 void TIsajet::SetXquarkMass(Float_t val)
3931 QLMASS.amlep[6] = val;
3934 /**************************************************************************/
3936 Float_t TIsajet::GetXquarkMass() const
3938 return QLMASS.amlep[6];
3941 /**************************************************************************/
3943 void TIsajet::SetYquarkMass(Float_t val)
3945 QLMASS.amlep[7] = val;
3948 /**************************************************************************/
3950 Float_t TIsajet::GetYquarkMass() const
3952 return QLMASS.amlep[7];
3955 /**************************************************************************/
3957 void TIsajet::SetUtildeMass(Float_t val)
3959 QLMASS.amlep[21] = val;
3962 /**************************************************************************/
3964 Float_t TIsajet::GetUtildeMass() const
3966 return QLMASS.amlep[21];
3969 /**************************************************************************/
3971 void TIsajet::SetDtildeMass(Float_t val)
3973 QLMASS.amlep[22] = val;
3976 /**************************************************************************/
3978 Float_t TIsajet::GetDtildeMass() const
3980 return QLMASS.amlep[22];
3983 /**************************************************************************/
3985 void TIsajet::SetStildeMass(Float_t val)
3987 QLMASS.amlep[23] = val;
3990 /**************************************************************************/
3992 Float_t TIsajet::GetStildeMass() const
3994 return QLMASS.amlep[23];
3997 /**************************************************************************/
3999 void TIsajet::SetCtildeMass(Float_t val)
4001 QLMASS.amlep[24] = val;
4004 /**************************************************************************/
4006 Float_t TIsajet::GetCtildeMass() const
4008 return QLMASS.amlep[24];
4011 /**************************************************************************/
4013 void TIsajet::SetBtildeMass(Float_t val)
4015 QLMASS.amlep[25] = val;
4018 /**************************************************************************/
4020 Float_t TIsajet::GetBtildeMass() const
4022 return QLMASS.amlep[25];
4025 /**************************************************************************/
4027 void TIsajet::SetTtildeMass(Float_t val)
4029 QLMASS.amlep[26] = val;
4032 /**************************************************************************/
4034 Float_t TIsajet::GetTtildeMass() const
4036 return QLMASS.amlep[26];
4039 /**************************************************************************/
4041 void TIsajet::SetGtildeMass(Float_t val)
4043 QLMASS.amlep[29] = val;
4046 /**************************************************************************/
4048 Float_t TIsajet::GetGtildeMass() const
4050 return QLMASS.amlep[29];
4053 /**************************************************************************/
4055 void TIsajet::SetGammatildeMass(Float_t val)
4057 QLMASS.amlep[30] = val;
4060 /**************************************************************************/
4062 Float_t TIsajet::GetGammatildeMass() const
4064 return QLMASS.amlep[30];
4067 /**************************************************************************/
4069 void TIsajet::SetNuEtildeMass(Float_t val)
4071 QLMASS.amlep[31] = val;
4074 /**************************************************************************/
4076 Float_t TIsajet::GetNuEtildeMass() const
4078 return QLMASS.amlep[31];
4081 /**************************************************************************/
4083 void TIsajet::SetEtildeMass(Float_t val)
4085 QLMASS.amlep[32] = val;
4088 /**************************************************************************/
4090 Float_t TIsajet::GetEtildeMass() const
4092 return QLMASS.amlep[32];
4095 /**************************************************************************/
4097 void TIsajet::SetNuMutildeMass(Float_t val)
4099 QLMASS.amlep[33] = val;
4102 /**************************************************************************/
4104 Float_t TIsajet::GetNuMutildeMass() const
4106 return QLMASS.amlep[33];
4109 /**************************************************************************/
4111 void TIsajet::SetMutildeMass(Float_t val)
4113 QLMASS.amlep[34] = val;
4116 /**************************************************************************/
4118 Float_t TIsajet::GetMutildeMass() const
4120 return QLMASS.amlep[34];
4123 /**************************************************************************/
4125 void TIsajet::SetNuTautildeMass(Float_t val)
4127 QLMASS.amlep[35] = val;
4130 /**************************************************************************/
4132 Float_t TIsajet::GetNuTautildeMass() const
4134 return QLMASS.amlep[35];
4137 /**************************************************************************/
4139 void TIsajet::SetTautildeMass(Float_t val)
4141 QLMASS.amlep[36] = val;
4144 /**************************************************************************/
4146 Float_t TIsajet::GetTautildeMass() const
4148 return QLMASS.amlep[36];
4151 /**************************************************************************/
4153 void TIsajet::SetWplustildeMass(Float_t val)
4155 QLMASS.amlep[39] = val;
4158 /**************************************************************************/
4160 Float_t TIsajet::GetWplustildeMass() const
4162 return QLMASS.amlep[39];
4165 /**************************************************************************/
4167 void TIsajet::SetZ0tildeMass(Float_t val)
4169 QLMASS.amlep[40] = val;
4172 /**************************************************************************/
4174 Float_t TIsajet::GetZ0tildeMass() const
4176 return QLMASS.amlep[40];
4179 /**************************************************************************/
4181 void TIsajet::SetHiggsMesonMass(Float_t val, Int_t index)
4183 if ((index < 1) || (index > 9)) {
4184 printf ("Error in TIsajet::SetHiggsMesonMass : \n");
4185 printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
4189 QLMASS.amlep[62 + index] = val;
4192 /**************************************************************************/
4194 Float_t TIsajet::GetHiggsMesonMass(Int_t index) const
4196 if ((index < 1) || (index > 9)) {
4197 printf ("Error in TIsajet::GetHiggsMesonMass : \n");
4198 printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
4202 return QLMASS.amlep[62 + index];
4205 /**************************************************************************/
4207 Int_t TIsajet::GetNQLEP() const
4209 return QLMASS.nqlep;
4212 /**************************************************************************/
4214 Int_t TIsajet::GetNMES() const
4219 /**************************************************************************/
4221 Int_t TIsajet::GetNBARY() const
4223 return QLMASS.nbary;
4226 /**************************************************************************/
4228 // Ends QLMASS access.
4229 // Begins SEED access.
4231 /**************************************************************************/
4233 void TIsajet::SetSEED(const Char_t val[24])
4235 Int_t length = (sizeof SEED.xseed / sizeof SEED.xseed[0]);
4237 for (Int_t i = 0; i < length; i++) {
4238 SEED.xseed[i] = val[i];
4242 /**************************************************************************/
4244 Char_t* TIsajet::GetSEED() const
4249 /**************************************************************************/
4251 // Ends SEED access - short and sweet, wasn't it?
4252 // Begins SUGNU access, an entirely different business.
4254 /**************************************************************************/
4256 void TIsajet::SetXNUSUG(Float_t val, Int_t index)
4258 Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
4259 if ((index < 0) || (index >= length)) {
4260 printf ("Error in TIsajet::SetXNUSUG : \n");
4261 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4265 SUGNU.xnusug[index] = val;
4268 /**************************************************************************/
4270 Float_t TIsajet::GetXNUSUG(Int_t index) const
4272 Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
4273 if ((index < 0) || (index >= length)) {
4274 printf ("Error in TIsajet::GetXNUSUG : \n");
4275 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4279 return SUGNU.xnusug[index];
4282 /**************************************************************************/
4284 void TIsajet::SetGauginoMass(Float_t val, Int_t index)
4286 if ((index < 1) || (index > 9)) {
4287 printf ("Error in TIsajet::SetGauginoMass : \n");
4288 printf ("Invalid gaugino number %d; range is 1-3.\n", index);
4292 SUGNU.xnusug[index-1] = val;
4295 /**************************************************************************/
4297 Float_t TIsajet::GetGauginoMass(Int_t index) const
4299 if ((index < 1) || (index > 3)) {
4300 printf ("Error in TIsajet::GetGauginoMass : \n");
4301 printf ("Invalid gaugino number %d; range is 1-3.\n", index);
4305 return SUGNU.xnusug[index-1];
4308 /**************************************************************************/
4310 void TIsajet::SetAtau(Float_t val)
4312 SUGNU.xnusug[3] = val;
4315 /**************************************************************************/
4317 Float_t TIsajet::GetAtau() const
4319 return SUGNU.xnusug[3];
4322 /**************************************************************************/
4324 void TIsajet::SetAb(Float_t val)
4326 SUGNU.xnusug[4] = val;
4329 /**************************************************************************/
4331 Float_t TIsajet::GetAb() const
4333 return SUGNU.xnusug[4];
4336 /**************************************************************************/
4338 void TIsajet::SetAt(Float_t val)
4340 SUGNU.xnusug[5] = val;
4343 /**************************************************************************/
4345 Float_t TIsajet::GetAt() const
4347 return SUGNU.xnusug[5];
4350 /**************************************************************************/
4352 void TIsajet::SetHiggsDmass(Float_t val)
4354 SUGNU.xnusug[6] = val;
4357 /**************************************************************************/
4359 Float_t TIsajet::GetHiggsDmass() const
4361 return SUGNU.xnusug[6];
4364 /**************************************************************************/
4366 void TIsajet::SetHiggsUmass(Float_t val)
4368 SUGNU.xnusug[7] = val;
4371 /**************************************************************************/
4373 Float_t TIsajet::GetHiggsUmass() const
4375 return SUGNU.xnusug[7];
4378 /**************************************************************************/
4380 void TIsajet::SetERmass(Float_t val)
4382 SUGNU.xnusug[8] = val;
4385 /**************************************************************************/
4387 Float_t TIsajet::GetERmass() const
4389 return SUGNU.xnusug[8];
4392 /**************************************************************************/
4394 void TIsajet::SetELmass(Float_t val)
4396 SUGNU.xnusug[9] = val;
4399 /**************************************************************************/
4401 Float_t TIsajet::GetELmass() const
4403 return SUGNU.xnusug[9];
4406 /**************************************************************************/
4408 void TIsajet::SetDRmass(Float_t val)
4410 SUGNU.xnusug[10] = val;
4413 /**************************************************************************/
4415 Float_t TIsajet::GetDRmass() const
4417 return SUGNU.xnusug[10];
4420 /**************************************************************************/
4422 void TIsajet::SetURmass(Float_t val)
4424 SUGNU.xnusug[11] = val;
4427 /**************************************************************************/
4429 Float_t TIsajet::GetURmass() const
4431 return SUGNU.xnusug[11];
4434 /**************************************************************************/
4436 void TIsajet::SetULmass(Float_t val)
4438 SUGNU.xnusug[12] = val;
4441 /**************************************************************************/
4443 Float_t TIsajet::GetULmass() const
4445 return SUGNU.xnusug[12];
4448 /**************************************************************************/
4450 void TIsajet::SetTauRmass(Float_t val)
4452 SUGNU.xnusug[13] = val;
4455 /**************************************************************************/
4457 Float_t TIsajet::GetTauRmass() const
4459 return SUGNU.xnusug[13];
4462 /**************************************************************************/
4464 void TIsajet::SetTauLmass(Float_t val)
4466 SUGNU.xnusug[14] = val;
4469 /**************************************************************************/
4471 Float_t TIsajet::GetTauLmass() const
4473 return SUGNU.xnusug[14];
4476 /**************************************************************************/
4478 void TIsajet::SetBRmass(Float_t val)
4480 SUGNU.xnusug[15] = val;
4483 /**************************************************************************/
4485 Float_t TIsajet::GetBRmass() const
4487 return SUGNU.xnusug[15];
4490 /**************************************************************************/
4492 void TIsajet::SetTRmass(Float_t val)
4494 SUGNU.xnusug[16] = val;
4497 /**************************************************************************/
4499 Float_t TIsajet::GetTRmass() const
4501 return SUGNU.xnusug[16];
4504 /**************************************************************************/
4506 void TIsajet::SetTLmass(Float_t val)
4508 SUGNU.xnusug[17] = val;
4511 /**************************************************************************/
4513 Float_t TIsajet::GetTLmass() const
4515 return SUGNU.xnusug[17];
4518 /**************************************************************************/
4520 // Ends XNUSUG access.
4521 // Begins TCPAR access.
4523 /**************************************************************************/
4525 void TIsajet::SetTCMRHO(Float_t val)
4530 /**************************************************************************/
4532 Float_t TIsajet::GetTCMRHO() const
4534 return TCPAR.tcmrho;
4537 /**************************************************************************/
4539 void TIsajet::SetTCGRHO(Float_t val)
4544 /**************************************************************************/
4546 Float_t TIsajet::GetTCGRHO() const
4548 return TCPAR.tcgrho;
4551 /**************************************************************************/
4553 // Ends TCPAR access.
4554 // Begins TYPES access.
4556 /**************************************************************************/
4558 Int_t TIsajet::GetLOC(Int_t index) const
4560 Int_t length = (sizeof TYPES.loc / sizeof TYPES.loc[0]);
4561 if ((index < 0) || (index >= length)) {
4562 printf ("Error in TIsajet::GetLOC : \n");
4563 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4567 return TYPES.loc[index];
4570 /**************************************************************************/
4572 Int_t TIsajet::GetNTYP() const
4577 /**************************************************************************/
4579 Int_t TIsajet::GetNJTTYP(Int_t index) const
4581 Int_t length = (sizeof TYPES.njttyp / sizeof TYPES.njttyp[0]);
4582 if ((index < 0) || (index >= length)) {
4583 printf ("Error in TIsajet::GetNJTYP : \n");
4584 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4588 return TYPES.njttyp[index];
4591 /**************************************************************************/
4593 Int_t TIsajet::GetNWWTYP(Int_t index) const
4595 Int_t length = (sizeof TYPES.nwwtyp / sizeof TYPES.nwwtyp[0]);
4596 if ((index < 0) || (index >= length)) {
4597 printf ("Error in TIsajet::GetNWWTYP : \n");
4598 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4602 return TYPES.nwwtyp[index];
4605 /**************************************************************************/
4607 Int_t TIsajet::GetNWMODE(Int_t index) const
4609 Int_t length = (sizeof TYPES.nwmode / sizeof TYPES.nwmode[0]);
4610 if ((index < 0) || (index >= length)) {
4611 printf ("Error in TIsajet::GetNWMODE : \n");
4612 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
4616 return TYPES.nwmode[index];
4619 /**************************************************************************/
4621 // Ends TYPES access.
4622 // Begins XMSSM access.
4624 /**************************************************************************/
4626 Bool_t TIsajet::GetGOMSSM() const
4628 return XMSSM.gomssm;
4631 /**************************************************************************/
4633 Bool_t TIsajet::GetGOSUG() const
4638 /**************************************************************************/
4640 Bool_t TIsajet::GetGOGMSB() const
4642 return XMSSM.gogmsb;
4645 /**************************************************************************/
4647 Bool_t TIsajet::GetGOAMSB() const
4649 return XMSSM.goamsb;
4652 /**************************************************************************/
4654 Bool_t TIsajet::GetAL3UNI() const
4656 return XMSSM.al3uni;
4659 /**************************************************************************/
4661 void TIsajet::SetXGLSS(Float_t val)
4666 /**************************************************************************/
4668 Float_t TIsajet::GetXGLSS() const
4673 /**************************************************************************/
4675 void TIsajet::SetXMUSS(Float_t val)
4680 /**************************************************************************/
4682 Float_t TIsajet::GetXMUSS() const
4687 /**************************************************************************/
4689 void TIsajet::SetXHASS(Float_t val)
4694 /**************************************************************************/
4696 Float_t TIsajet::GetXHASS() const
4701 /**************************************************************************/
4703 void TIsajet::SetXTBSS(Float_t val)
4708 /**************************************************************************/
4710 Float_t TIsajet::GetXTBSS() const
4715 /**************************************************************************/
4717 void TIsajet::SetXQ1SS(Float_t val)
4722 /**************************************************************************/
4724 Float_t TIsajet::GetXQ1SS() const
4729 /**************************************************************************/
4731 void TIsajet::SetXDRSS(Float_t val)
4736 /**************************************************************************/
4738 Float_t TIsajet::GetXDRSS() const
4743 /**************************************************************************/
4745 void TIsajet::SetXURSS(Float_t val)
4750 /**************************************************************************/
4752 Float_t TIsajet::GetXURSS() const
4757 /**************************************************************************/
4759 void TIsajet::SetXL1SS(Float_t val)
4764 /**************************************************************************/
4766 Float_t TIsajet::GetXL1SS() const
4771 /**************************************************************************/
4773 void TIsajet::SetXERSS(Float_t val)
4778 /**************************************************************************/
4780 Float_t TIsajet::GetXERSS() const
4785 /**************************************************************************/
4787 void TIsajet::SetXQ2SS(Float_t val)
4792 /**************************************************************************/
4794 Float_t TIsajet::GetXQ2SS() const
4799 /**************************************************************************/
4801 void TIsajet::SetXSRSS(Float_t val)
4806 /**************************************************************************/
4808 Float_t TIsajet::GetXSRSS() const
4813 /**************************************************************************/
4815 void TIsajet::SetXCRSS(Float_t val)
4820 /**************************************************************************/
4822 Float_t TIsajet::GetXCRSS() const
4827 /**************************************************************************/
4829 void TIsajet::SetXL2SS(Float_t val)
4834 /**************************************************************************/
4836 Float_t TIsajet::GetXL2SS() const
4841 /**************************************************************************/
4843 void TIsajet::SetXMRSS(Float_t val)
4848 /**************************************************************************/
4850 Float_t TIsajet::GetXMRSS() const
4855 /**************************************************************************/
4857 void TIsajet::SetXQ3SS(Float_t val)
4862 /**************************************************************************/
4864 Float_t TIsajet::GetXQ3SS() const
4869 /**************************************************************************/
4871 void TIsajet::SetXBRSS(Float_t val)
4876 /**************************************************************************/
4878 Float_t TIsajet::GetXBRSS() const
4883 /**************************************************************************/
4885 void TIsajet::SetXTRSS(Float_t val)
4890 /**************************************************************************/
4892 Float_t TIsajet::GetXTRSS() const
4897 /**************************************************************************/
4899 void TIsajet::SetXL3SS(Float_t val)
4904 /**************************************************************************/
4906 Float_t TIsajet::GetXL3SS() const
4911 /**************************************************************************/
4913 void TIsajet::SetXTARSS(Float_t val)
4918 /**************************************************************************/
4920 Float_t TIsajet::GetXTARSS() const
4922 return XMSSM.xtarss;
4925 /**************************************************************************/
4927 void TIsajet::SetXATSS(Float_t val)
4932 /**************************************************************************/
4934 Float_t TIsajet::GetXATSS() const
4939 /**************************************************************************/
4941 void TIsajet::SetXABSS(Float_t val)
4946 /**************************************************************************/
4948 Float_t TIsajet::GetXABSS() const
4953 /**************************************************************************/
4955 void TIsajet::SetXATASS(Float_t val)
4960 /**************************************************************************/
4962 Float_t TIsajet::GetXATASS() const
4964 return XMSSM.xatass;
4967 /**************************************************************************/
4969 void TIsajet::SetXM1SS(Float_t val)
4974 /**************************************************************************/
4976 Float_t TIsajet::GetXM1SS() const
4981 /**************************************************************************/
4983 void TIsajet::SetXM2SS(Float_t val)
4988 /**************************************************************************/
4990 Float_t TIsajet::GetXM2SS() const
4995 /**************************************************************************/
4997 void TIsajet::SetXM0SU(Float_t val)
5002 /**************************************************************************/
5004 Float_t TIsajet::GetXM0SU() const
5009 /**************************************************************************/
5011 void TIsajet::SetXMHSU(Float_t val)
5016 /**************************************************************************/
5018 Float_t TIsajet::GetXMHSU() const
5023 /**************************************************************************/
5025 void TIsajet::SetXA0SU(Float_t val)
5030 /**************************************************************************/
5032 Float_t TIsajet::GetXA0SU() const
5037 /**************************************************************************/
5039 void TIsajet::SetXTGBSU(Float_t val)
5044 /**************************************************************************/
5046 Float_t TIsajet::GetXTGBSU() const
5048 return XMSSM.xtgbsu;
5051 /**************************************************************************/
5053 void TIsajet::SetXSMUSU(Float_t val)
5058 /**************************************************************************/
5060 Float_t TIsajet::GetXSMUSU() const
5062 return XMSSM.xsmusu;
5065 /**************************************************************************/
5067 void TIsajet::SetXLAMGM(Float_t val)
5072 /**************************************************************************/
5074 Float_t TIsajet::GetXLAMGM() const
5076 return XMSSM.xlamgm;
5079 /**************************************************************************/
5081 void TIsajet::SetXMESGM(Float_t val)
5086 /**************************************************************************/
5088 Float_t TIsajet::GetXMESGM() const
5090 return XMSSM.xmesgm;
5093 /**************************************************************************/
5095 void TIsajet::SetXN5GM(Float_t val)
5100 /**************************************************************************/
5102 Float_t TIsajet::GetXN5GM() const
5107 /**************************************************************************/
5109 void TIsajet::SetXCMGV(Float_t val)
5114 /**************************************************************************/
5116 Float_t TIsajet::GetXCMGV() const
5121 /**************************************************************************/
5123 void TIsajet::SetMGVTO(Float_t val)
5128 /**************************************************************************/
5130 Float_t TIsajet::GetMGVTO() const
5135 /**************************************************************************/
5137 void TIsajet::SetXRSLGM(Float_t val)
5142 /**************************************************************************/
5144 Float_t TIsajet::GetXRSLGM() const
5146 return XMSSM.xrslgm;
5149 /**************************************************************************/
5151 void TIsajet::SetXDHDGM(Float_t val)
5156 /**************************************************************************/
5158 Float_t TIsajet::GetXDHDGM() const
5160 return XMSSM.xdhdgm;
5163 /**************************************************************************/
5165 void TIsajet::SetXDHUGM(Float_t val)
5170 /**************************************************************************/
5172 Float_t TIsajet::GetXDHUGM() const
5174 return XMSSM.xdhugm;
5177 /**************************************************************************/
5179 void TIsajet::SetXDYGM(Float_t val)
5184 /**************************************************************************/
5186 Float_t TIsajet::GetXDYGM() const
5191 /**************************************************************************/
5193 void TIsajet::SetXN51GM(Float_t val)
5198 /**************************************************************************/
5200 Float_t TIsajet::GetXN51GM() const
5202 return XMSSM.xn51gm;
5205 /**************************************************************************/
5207 void TIsajet::SetXN52GM(Float_t val)
5212 /**************************************************************************/
5214 Float_t TIsajet::GetXN52GM() const
5216 return XMSSM.xn52gm;
5219 /**************************************************************************/
5221 void TIsajet::SetXN53GM(Float_t val)
5226 /**************************************************************************/
5228 Float_t TIsajet::GetXN53GM() const
5230 return XMSSM.xn53gm;
5233 /**************************************************************************/
5235 void TIsajet::SetXMN3NR(Float_t val)
5240 /**************************************************************************/
5242 Float_t TIsajet::GetXMN3NR() const
5244 return XMSSM.xmn3nr;
5247 /**************************************************************************/
5249 void TIsajet::SetXMAJNR(Float_t val)
5254 /**************************************************************************/
5256 Float_t TIsajet::GetXMAJNR() const
5258 return XMSSM.xmajnr;
5261 /**************************************************************************/
5263 void TIsajet::SetXANSS(Float_t val)
5268 /**************************************************************************/
5270 Float_t TIsajet::GetXANSS() const
5275 /**************************************************************************/
5277 void TIsajet::SetXNRSS(Float_t val)
5282 /**************************************************************************/
5284 Float_t TIsajet::GetXNRSS() const
5289 /**************************************************************************/
5291 void TIsajet::SetXSBCS(Float_t val)
5296 /**************************************************************************/
5298 Float_t TIsajet::GetXSBCS() const
5303 /**************************************************************************/
5305 // Ends XMSSM access.
5306 // Begins XTYPES access.
5308 /**************************************************************************/
5310 Char_t* TIsajet::GetPARTYP(Int_t index) const
5312 Int_t length = (sizeof XTYPES.partyp / sizeof XTYPES.partyp[0]);
5313 if ((index < 0) || (index >= length)) {
5314 printf ("Error in TIsajet::GetPARTYP : \n");
5315 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5319 return XTYPES.partyp[index];
5322 /**************************************************************************/
5324 void TIsajet::SetTITLE(Char_t *val)
5326 title = XTYPES.title = val;
5329 /**************************************************************************/
5330 Char_t* TIsajet::GetTITLE() const
5332 return XTYPES.title;
5335 /**************************************************************************/
5337 void TIsajet::SetJETYP(Int_t index, Char_t val[])
5339 Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
5340 Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
5342 if ((index < 0) || (index >= row_num)) {
5343 printf ("Error in TIsajet::SetJETYP : \n");
5344 printf ("Invalid array row index %d; range is 0-%d.\n", index, row_num-1);
5348 if (TYPES.njttyp[index] >= col_num) {
5349 printf ("Error in TIsajet::SetJETYP : \n");
5350 printf ("Cannot set more than %d jet types.\n", col_num-1);
5354 if ((!strcmp(val, "ALL")) || (!strcmp(val, "GL")) ||
5355 (!strcmp(val, "UP")) || (!strcmp(val, "UB")) ||
5356 (!strcmp(val, "DN")) || (!strcmp(val, "DB")) ||
5357 (!strcmp(val, "ST")) || (!strcmp(val, "SB")) ||
5358 (!strcmp(val, "CH")) || (!strcmp(val, "CB")) ||
5359 (!strcmp(val, "BT")) || (!strcmp(val, "BB")) ||
5360 (!strcmp(val, "TP")) || (!strcmp(val, "TB")) ||
5361 (!strcmp(val, "X")) || (!strcmp(val, "XB")) ||
5362 (!strcmp(val, "Y")) || (!strcmp(val, "YB")) ||
5363 (!strcmp(val, "E-")) || (!strcmp(val, "E+")) ||
5364 (!strcmp(val, "MU-")) || (!strcmp(val, "MU+")) ||
5365 (!strcmp(val, "TAU-")) || (!strcmp(val, "TAU+")) ||
5366 (!strcmp(val, "NUS")) || (!strcmp(val, "GM")) ||
5367 (!strcmp(val, "W+")) || (!strcmp(val, "W-")) ||
5368 (!strcmp(val, "Z0"))) {
5370 XTYPES.jetyp[index][TYPES.njttyp[index]++] = val;
5373 printf ("Error in TIsajet::SetJETYP : \n");
5374 printf ("Invalid jet type %s; valid types are\n", val);
5375 printf ("ALL, GL, UP, UB, DN, DB, ST, SB,\n");
5376 printf ("CH, CB, BT, BB, TP, TB, X, XB, Y, YB,\n");
5377 printf ("E-, E+, MU-, MU+, TAU-, TAU+, NUS, GM,\n");
5378 printf ("W+, W- and Z0.\n");
5382 if (index == 0) setJettype1 = true;
5383 else if (index == 1) setJettype2 = true;
5384 else if (index == 2) setJettype3 = true;
5387 /**************************************************************************/
5389 Char_t* TIsajet::GetJETYP(Int_t index1, Int_t index2) const
5391 Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
5392 Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
5394 if ((index1 < 0) || (index1 >= row_num)) {
5395 printf ("Error in TIsajet::GetJETYP : \n");
5396 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5400 if ((index2 < 0) || (index2 >= col_num)) {
5401 printf ("Error in TIsajet::GetJETYP : \n");
5402 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5406 return XTYPES.jetyp[index1][index2];
5409 /**************************************************************************/
5411 void TIsajet::SetWWTYP(Char_t val[], Int_t index1, Int_t index2)
5413 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5414 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5416 if ((index1 < 0) || (index1 >= row_num)) {
5417 printf ("Error in TIsajet::SetWWTYP : \n");
5418 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5422 if ((index2 < 0) || (index2 >= col_num)) {
5423 printf ("Error in TIsajet::SetWWTYP : \n");
5424 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5428 XTYPES.wwtyp[index1][index2] = val;
5431 /**************************************************************************/
5433 void TIsajet::SetAllWWTYP(Char_t* val[2][30])
5435 for (Int_t i = 0; i < 2; i++) {
5436 for (Int_t j = 0; j < 30; j++) {
5437 SetWWTYP(val[i][j], i, j);
5442 /**************************************************************************/
5444 void TIsajet::SetColumnWWTYP(Char_t* val[], Int_t col)
5446 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5447 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5449 if ((col < 0) || (col >= col_num)) {
5450 printf ("Error in TIsajet::SetColumnWWTYP : \n");
5451 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
5455 for (Int_t i = 0; i < row_num; i++) {
5456 SetWWTYP(val[i], i, col);
5460 /**************************************************************************/
5462 Char_t* TIsajet::GetWWTYP(Int_t index1, Int_t index2) const
5464 Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
5465 Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
5467 if ((index1 < 0) || (index1 >= row_num)) {
5468 printf ("Error in TIsajet::GetWWTYP : \n");
5469 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5473 if ((index2 < 0) || (index2 >= col_num)) {
5474 printf ("Error in TIsajet::GetWWTYP : \n");
5475 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5479 return XTYPES.wwtyp[index1][index2];
5482 /**************************************************************************/
5484 void TIsajet::SetWMODES(Char_t val[], Int_t index1, Int_t index2)
5486 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5487 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5489 if ((index1 < 0) || (index1 >= row_num)) {
5490 printf ("Error in TIsajet::SetWMODES : \n");
5491 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5495 if ((index2 < 0) || (index2 >= col_num)) {
5496 printf ("Error in TIsajet::SetWMODES : \n");
5497 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5501 XTYPES.wmodes[index1][index2] = val;
5504 /**************************************************************************/
5506 void TIsajet::SetAllWMODES(Char_t* val[2][30])
5508 for (Int_t i = 0; i < 2; i++) {
5509 for (Int_t j = 0; j < 30; j++) {
5510 SetWMODES(val[i][j], i, j);
5515 /**************************************************************************/
5517 void TIsajet::SetColumnWMODES(Char_t* val[], Int_t col)
5519 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5520 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5522 if ((col < 0) || (col >= col_num)) {
5523 printf ("Error in TIsajet::SetColumnWMODES : \n");
5524 printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
5528 for (Int_t i = 0; i < row_num; i++) {
5529 SetWMODES(val[i], i, col);
5533 /**************************************************************************/
5535 Char_t* TIsajet::GetWMODES(Int_t index1, Int_t index2) const
5537 Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
5538 Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
5540 if ((index1 < 0) || (index1 >= row_num)) {
5541 printf ("Error in TIsajet::GetWMODES : \n");
5542 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5546 if ((index2 < 0) || (index2 >= col_num)) {
5547 printf ("Error in TIsajet::GetWMODES : \n");
5548 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5552 return XTYPES.wmodes[index1][index2];
5555 /**************************************************************************/
5557 // Ends XTYPES access.
5558 // Begins WCON access.
5560 /**************************************************************************/
5562 void TIsajet::SetSIN2W(Float_t val)
5567 /**************************************************************************/
5569 Float_t TIsajet::GetSIN2W() const
5574 /**************************************************************************/
5576 void TIsajet::SetWMASS(Float_t w, Float_t z)
5579 // This is how the FORTRAN does it. Don't ask me why.
5582 WCON.wmass[1] = WCON.wmass[2] = w;
5586 /**************************************************************************/
5588 Float_t TIsajet::GetWMASS(Int_t index) const
5590 Int_t length = (sizeof WCON.wmass / sizeof WCON.wmass[0]);
5591 if ((index < 0) || (index >= length)) {
5592 printf ("Error in TIsajet::GetWMASS : \n");
5593 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5597 return WCON.wmass[index];
5600 /**************************************************************************/
5602 void TIsajet::SetWMass(Float_t val)
5604 WCON.wmass[1] = WCON.wmass[2] = val;
5607 /**************************************************************************/
5609 void TIsajet::SetZMass(Float_t val)
5611 WCON.wmass[3] = val;
5614 /**************************************************************************/
5616 Float_t TIsajet::GetWGAM(Int_t index) const
5618 Int_t length = (sizeof WCON.wgam / sizeof WCON.wgam[0]);
5619 if ((index < 0) || (index >= length)) {
5620 printf ("Error in TIsajet::GetWGAM : \n");
5621 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5625 return WCON.wgam[index];
5628 /**************************************************************************/
5630 Float_t TIsajet::GetAQ(Int_t index1, Int_t index2) const
5632 Int_t col_num = (sizeof WCON.aq[0] / sizeof WCON.aq[0][0]);
5633 Int_t row_num = (sizeof WCON.aq / (sizeof WCON.aq[0][0] * col_num));
5635 if ((index1 < 0) || (index1 >= row_num)) {
5636 printf ("Error in TIsajet::GetAQ : \n");
5637 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5641 if ((index2 < 0) || (index2 >= col_num)) {
5642 printf ("Error in TIsajet::GetAQ : \n");
5643 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5647 return WCON.aq[index1][index2];
5650 /**************************************************************************/
5652 Float_t TIsajet::GetBQ(Int_t index1, Int_t index2) const
5654 Int_t col_num = (sizeof WCON.bq[0] / sizeof WCON.bq[0][0]);
5655 Int_t row_num = (sizeof WCON.bq / (sizeof WCON.bq[0][0] * col_num));
5657 if ((index1 < 0) || (index1 >= row_num)) {
5658 printf ("Error in TIsajet::GetBQ : \n");
5659 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5663 if ((index2 < 0) || (index2 >= col_num)) {
5664 printf ("Error in TIsajet::GetBQ : \n");
5665 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5669 return WCON.bq[index1][index2];
5672 /**************************************************************************/
5674 Float_t TIsajet::GetCOUT(Int_t index) const
5676 Int_t length = (sizeof WCON.cout / sizeof WCON.cout[0]);
5677 if ((index < 0) || (index >= length)) {
5678 printf ("Error in TIsajet::GetCOUT : \n");
5679 printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
5683 return WCON.cout[index];
5686 /**************************************************************************/
5688 Int_t TIsajet::GetMATCH() const
5693 /**************************************************************************/
5695 Float_t TIsajet::GetWCBR(Int_t index1, Int_t index2) const
5697 Int_t col_num = (sizeof WCON.wcbr[0] / sizeof WCON.wcbr[0][0]);
5698 Int_t row_num = (sizeof WCON.wcbr / (sizeof WCON.wcbr[0][0] * col_num));
5700 if ((index1 < 0) || (index1 >= row_num)) {
5701 printf ("Error in TIsajet::GetWCBR : \n");
5702 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5706 if ((index2 < 0) || (index2 >= col_num)) {
5707 printf ("Error in TIsajet::GetWCBR : \n");
5708 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5712 return WCON.wcbr[index1][index2];
5715 /**************************************************************************/
5717 void TIsajet::SetCUTOFF(Float_t val)
5722 /**************************************************************************/
5724 Float_t TIsajet::GetCUTOFF() const
5729 /**************************************************************************/
5731 void TIsajet::SetCUTPOW(Float_t val)
5736 /**************************************************************************/
5738 Float_t TIsajet::GetCUTPOW() const
5743 /**************************************************************************/
5745 Float_t TIsajet::GetTBRWW(Int_t index1, Int_t index2) const
5747 Int_t col_num = (sizeof WCON.tbrww[0] / sizeof WCON.tbrww[0][0]);
5748 Int_t row_num = (sizeof WCON.tbrww / (sizeof WCON.tbrww[0][0] * col_num));
5750 if ((index1 < 0) || (index1 >= row_num)) {
5751 printf ("Error in TIsajet::GetTBRWW : \n");
5752 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5756 if ((index2 < 0) || (index2 >= col_num)) {
5757 printf ("Error in TIsajet::GetTBRWW : \n");
5758 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5762 return WCON.tbrww[index1][index2];
5765 /**************************************************************************/
5767 Float_t TIsajet::GetRBRWW(Int_t index1, Int_t index2, Int_t index3) const
5769 Int_t elem_Size = sizeof WCON.rbrww[0][0][0];
5770 Int_t thd_Dim_Length = (sizeof WCON.rbrww[0][0] / elem_Size);
5771 Int_t sec_Dim_Length = (sizeof WCON.rbrww[0] / (elem_Size * thd_Dim_Length));
5772 Int_t fst_Dim_Length = (sizeof WCON.rbrww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
5774 if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
5775 printf ("Error in TIsajet::GetRBRWW : \n");
5776 printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
5780 if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
5781 printf ("Error in TIsajet::GetRBRWW : \n");
5782 printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
5786 if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
5787 printf ("Error in TIsajet::GetRBRWW : \n");
5788 printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
5792 return WCON.rbrww[index1][index2][index3];
5796 /**************************************************************************/
5798 Float_t TIsajet::GetEZ() const
5803 /**************************************************************************/
5805 Float_t TIsajet::GetAQDP(Int_t index1, Int_t index2) const
5807 Int_t col_num = (sizeof WCON.aqdp[0] / sizeof WCON.aqdp[0][0]);
5808 Int_t row_num = (sizeof WCON.aqdp / (sizeof WCON.aqdp[0][0] * col_num));
5810 if ((index1 < 0) || (index1 >= row_num)) {
5811 printf ("Error in TIsajet::GetAQDP : \n");
5812 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5816 if ((index2 < 0) || (index2 >= col_num)) {
5817 printf ("Error in TIsajet::GetAQDP : \n");
5818 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5822 return WCON.aqdp[index1][index2];
5825 /**************************************************************************/
5827 Float_t TIsajet::GetBQDP(Int_t index1, Int_t index2) const
5829 Int_t col_num = (sizeof WCON.bqdp[0] / sizeof WCON.bqdp[0][0]);
5830 Int_t row_num = (sizeof WCON.bqdp / (sizeof WCON.bqdp[0][0] * col_num));
5832 if ((index1 < 0) || (index1 >= row_num)) {
5833 printf ("Error in TIsajet::GetBQDP : \n");
5834 printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
5838 if ((index2 < 0) || (index2 >= col_num)) {
5839 printf ("Error in TIsajet::GetBQDP : \n");
5840 printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
5844 return WCON.bqdp[index1][index2];
5847 /**************************************************************************/
5849 Float_t TIsajet::GetEZDP() const
5854 /**************************************************************************/
5856 void TIsajet::SetWFUDGE(Float_t val)
5861 /**************************************************************************/
5863 Float_t TIsajet::GetWFUDGE() const
5868 /**************************************************************************/
5870 // Ends WCON access.
5873 # define isaini isaini_
5874 # define isaevt isaevt_
5875 # define isabeg isabeg_
5876 # define isabg2 isabg2_
5877 # define openfiles openfiles_
5878 # define pdfinit pdfinit_
5880 # define type_of_call
5882 # define isaini ISAINI
5883 # define isaevt ISAEVT
5884 # define isabeg ISABEG
5885 # define isabg2 ISABG2
5886 # define openfiles OPENFILES
5887 # define pdfinit PDFINIT
5889 # define type_of_call _stdcall
5892 extern "C" void type_of_call isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n);
5893 extern "C" void type_of_call isaevt(Int_t& j, Int_t& k, Int_t& m);
5894 extern "C" void type_of_call openfiles();
5895 extern "C" void type_of_call pdfinit(Int_t &, Int_t &);
5896 extern "C" void type_of_call isabeg(Int_t& ifl);
5897 extern "C" void type_of_call isabg2(Int_t& ifl);
5899 void TIsajet::Isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n)
5904 void TIsajet::Isaevt(Int_t& j, Int_t& k, Int_t& m)
5909 void TIsajet::Openfiles()
5914 void TIsajet::PDFinit(Int_t& pdfpar, Int_t& pdfval )
5916 pdfinit(pdfpar, pdfval);
5919 void TIsajet::Isabeg(Int_t& ifl)
5924 void TIsajet::Isabg2(Int_t& ifl)
5930 Double_t type_of_call ranf(Int_t & /*idum*/)
5933 do r=sRandom->Rndm(); while(0 >= r || r >= 1);