--- /dev/null
+#ifndef ROOT_ICommon
+#define ROOT_ICommon
+
+#ifndef __CFORTRAN_LOADED
+//*KEEP,cfortran.
+#include "cfortran.h"
+//*KEND.
+#endif
+
+extern "C" {
+
+/*========================================================================*/
+/* COMMON/DYLIM/QMIN,QMAX,QTMIN,QTMAX,YWMIN,YWMAX,XWMIN,XWMAX,THWMIN, */
+/* & THWMAX,PHWMIN,PHWMAX,SETLMQ(12) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Float_t qmin;
+ Float_t qmax;
+ Float_t qtmin;
+ Float_t qtmax;
+ Float_t ywmin;
+ Float_t ywmax;
+ Float_t xwmin;
+ Float_t xwmax;
+ Float_t thwmin;
+ Float_t thwmax;
+ Float_t phwmin;
+ Float_t phwmax;
+ Bool_t setlmq[12];
+ Bool_t ywset;
+ Bool_t thwset;
+} DylimCommon;
+
+#define DYLIM COMMON_BLOCK(DYLIM, dylim)
+COMMON_BLOCK_DEF(DylimCommon,DYLIM);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* qmin, qmax : Mass limits for W */
+/* qtmin, qtmax : q-subscript-t limits for W */
+/* ywmin, ywmax : Y limits for W. Cannot be set simultaneously with */
+/* thwmin, thwmax. */
+/* xwmin, xwmax : Feynman x limit for W */
+/* thwmin, thwmax : Theta limits for W. Cannot be set simultaneously */
+/* with ywmin, ywmax. */
+/* phwmin, phwmax : Phi limits for W */
+/* setlmq : */
+/* ywset, thwset : Logical flags internal to the interface. */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/EEPAR/SGMXEE,PLEP,PLEM,RSHMIN,RSHMAX,UPSLON,SIGZ,IBREM,IBEAM */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Float_t sgmxee;
+ Float_t plep;
+ Float_t plem;
+ Float_t rshmin;
+ Float_t rshmax;
+ Float_t upslon;
+ Float_t sigz;
+ Bool_t ibrem;
+ Bool_t ibeam;
+} EeparCommon;
+
+#define EEPAR COMMON_BLOCK(EEPAR, eepar)
+COMMON_BLOCK_DEF(EeparCommon,EEPAR);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* sgmxee */
+/* plep : Polarisation of positron beam (P-subscript-L of e-superscript-+ */
+/* plem : Polarisation of electron beam (P-subscript-L of e-superscript-- */
+/* */
+/* Brem- and beam-strahlung parameters */
+/* rshmin : minimum subprocess energy (root-s-hyphen-subscript-min) */
+/* rshmax : maximum subprocess energy (root-s-hyphen-subscript-max) */
+/* upslon : beamstrahlung parameter (UPSILON) */
+/* sigz : Longitudinal beam size in mm (sigma-subscript-z) */
+/* ibrem : True if EEBREM used */
+/* ibeam : True if EEBEAM used */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/FORCE/NFORCE,IFORCE(MXFORC),MFORCE(5,MXFORC),LOOK2(2,MXFORC), */
+/* & LOOKST(MXFORC),MEFORC(MXFORC) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ static const Int_t mxforc = 40;
+ Int_t nforce;
+ Int_t iforce[mxforc];
+ Int_t mforce[mxforc][5];
+ Int_t look2[mxforc][2];
+ Int_t lookst[mxforc];
+ Int_t meforc[mxforc];
+} ForceCommon;
+
+#define FORCE COMMON_BLOCK(FORCE, force)
+COMMON_BLOCK_DEF(ForceCommon,FORCE);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* mxforce : Size of forced-decay array */
+/* nforce : Number of forced decay paths */
+/* iforce : ID code for particle of forced decay */
+/* mforce : Mode(s) of forced decay */
+/* look2 */
+/* lookst */
+/* meforc : Matrix element of the forced decay */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/FRGPAR/PUD,PBARY,SIGQT,PEND,XGEN(8),PSPIN1(8),PMIX1(3,2), */
+/* & PMIX2(3,2),XGENSS(9) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Float_t pud;
+ Float_t pbary;
+ Float_t sigqt;
+ Float_t pend;
+ Float_t xgen[8];
+ Float_t pspin1[8];
+ Float_t pmix1[2][3];
+ Float_t pmix2[2][3];
+ Float_t xgenss[9];
+ Float_t *pmixx1[6];
+ Float_t *pmixx2[6];
+ Float_t *frpar[32];
+} FrgparCommon;
+
+#define FRGPAR COMMON_BLOCK(FRGPAR, frgpar)
+COMMON_BLOCK_DEF(FrgparCommon,FRGPAR);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Fragmentation parameters : */
+/* pud : */
+/* pbary : */
+/* sigqt : Internal k-subscript-t parameter for jet fragmentation (sigma) */
+/* pend : */
+/* xgen : Jet fragmentation, Peterson with epsilon = a(n) / m, n = 4-8 */
+/* pspin1 : */
+/* pmix1 : */
+/* pmix2 : */
+/* xgenss : Fragmentation of GLSS, UPSS etc with epsilon = a(n)/m-squared */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/HCON/ANWWWW(4,4,4),ADWWWW(2,4),AIWWWW(4),HMASS,HGAM,HGAMS(29), */
+/* & ETAHGG,MATCHH(29),ZSTARS(4,2),IHTYPE,HGAMSS(85,85) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Float_t anwwww[4][4][4];
+ Float_t adwwww[4][2];
+ Float_t aiwwww[4];
+ Float_t hmass;
+ Float_t hgam;
+ Float_t hgams[29];
+ Float_t etahgg;
+ Int_t matchh[29];
+ Float_t zstars[2][4];
+ Int_t ihtype;
+ Float_t hgamss[85][85];
+} HconCommon;
+
+#define HCON COMMON_BLOCK(HCON, hcon)
+COMMON_BLOCK_DEF(HconCommon,HCON);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* anwwww : */
+/* adwwww : */
+/* aiwwww : */
+/* hmass : */
+/* hgam : */
+/* hgams : */
+/* etahgg: */
+/* matchh : */
+/* zstars : */
+/* ihtype : MSSM Higgs type, either HL0, HH0 or HA0 */
+/* hgamss : */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/JETLIM/PMIN(MXLIM),PMAX(MXLIM),PTMIN(MXLIM),PTMAX(MXLIM), */
+/* & YJMIN(MXLIM),YJMAX(MXLIM),PHIMIN(MXLIM),PHIMAX(MXLIM), */
+/* & XJMIN(MXLIM),XJMAX(MXLIM),THMIN(MXLIM),THMAX(MXLIM), */
+/* & SETLMJ(12*MXLIM) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ static const Int_t mxlim = 8;
+ Float_t pmin[mxlim];
+ Float_t pmax[mxlim];
+ Float_t ptmin[mxlim];
+ Float_t ptmax[mxlim];
+ Float_t yjmin[mxlim];
+ Float_t yjmax[mxlim];
+ Float_t phimin[mxlim];
+ Float_t phimax[mxlim];
+ Float_t xjmin[mxlim];
+ Float_t xjmax[mxlim];
+ Float_t thmin[mxlim];
+ Float_t thmax[mxlim];
+ Bool_t setlmj[12*mxlim];
+} JetlimCommon;
+
+#define JETLIM COMMON_BLOCK(JETLIM, jetlim)
+COMMON_BLOCK_DEF(JetlimCommon,JETLIM);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Changes to mxlim should be echoed in MGLIMS and some of its access */
+/* routines. */
+/* pmin, pmax : Momentum limits for jets. */
+/* ptmin, ptmax : p-subscript-t limits for jets. */
+/* yjmin, yjmax : Y limits for each jet; not simultaneous to thmin, thmax.*/
+/* phimin, phimax : Phi limits for jets. */
+/* xjmin, xjmax : Feynman x limits for jets. */
+/* thmin, thmax : Theta limits for jets, not simultaneous with yjmin, */
+/* yjmax. */
+/* setlmj : */
+/* yjset, thset : Logical flags internal to the interface. */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/JETPAR/P(3),PT(3),YJ(3),PHI(3),XJ(3),TH(3),CTH(3),STH(3), */
+/* & JETTYP(3),SHAT,THAT,QSQ,X1,X2,PBEAM(2), */
+/* & QMW,QW,QTW,YW,XW,THW,QTMW,PHIW,SHAT1,THAT1,UHAT1,JWTYP, */
+/* & INITYP(2),ISIGS,PBEAMS(5) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Float_t p[3];
+ Float_t pt[3];
+ Float_t yj[3];
+ Float_t phi[3];
+ Float_t xj[3];
+ Float_t th[3];
+ Float_t cth[3];
+ Float_t sth[3];
+ Int_t jettyp[3];
+ Float_t shat;
+ Float_t that;
+ Float_t uhat;
+ Float_t qsq;
+ Float_t x1;
+ Float_t x2;
+ Float_t pbeam[2];
+ Float_t qmw;
+ Float_t qw;
+ Float_t qtw;
+ Float_t yw;
+ Float_t xw;
+ Float_t thw;
+ Float_t qtmw;
+ Float_t phiw;
+ Float_t shat1;
+ Float_t that1;
+ Float_t uhat1;
+ Int_t jwtyp;
+ Float_t alfqsq;
+ Float_t cthw;
+ Float_t sthw;
+ Float_t q0w;
+ Int_t inityp[2];
+ Int_t isigs;
+ Float_t pbeams[5];
+} JetparCommon;
+
+#define JETPAR COMMON_BLOCK(JETPAR, jetpar)
+COMMON_BLOCK_DEF(JetparCommon,JETPAR);
+
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* jwtyp : W type, either W+-, Z0 or GM. */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/KEYS/IKEY, KEYON, KEYS(MXKEYS) */
+/*------------------------------------------------------------------------*/
+
+typedef struct {
+ static const Int_t mxkeys = 20;
+ Bool_t keys[mxkeys];
+ Bool_t keyon;
+ Int_t ikey;
+ Char_t *reac;
+} KeysCommon;
+
+#define KEYS COMMON_BLOCK(KEYS, keys)
+COMMON_BLOCK_DEF(KeysCommon,KEYS);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* keys : Flag for process type. */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/KKGRAV/NEXTRAD,MASSD,KKGSD,SURFD,UVCUT */
+/*------------------------------------------------------------------------*/
+
+typedef struct {
+ Int_t nextrad;
+ Float_t massd;
+ Float_t kkgsd;
+ Float_t surfd;
+ Bool_t uvcut;
+} KkgravCommon;
+
+#define KKGRAV COMMON_BLOCK(KKGRAV, kkgrav)
+COMMON_BLOCK_DEF(KkgravCommon,KKGRAV);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* EXTRADIM process parameters : */
+/* nextrad : delta */
+/* massd : M-subscript-D */
+/* uvcut : Logical flag */
+/* */
+/* kkgsd : */
+/* surfd : */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/MBGEN/POMWT(LIMPOM),POMGEN(LIMPOM),MNPOM,MXPOM,PDIFFR,NPOM, */
+/* & XBARY(2),DXBARY(2),XPOM(LIMPOM,2) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ static const Int_t limpom = 20;
+ Float_t pomwt[limpom];
+ Float_t pomgen[limpom];
+ Int_t mnpom;
+ Int_t mxpom;
+ Float_t pdiffr;
+ Int_t npom;
+ Float_t xbary[2];
+ Float_t dxbary[2];
+ Float_t xpom[2][limpom];
+} MbgenCommon;
+
+#define MBGEN COMMON_BLOCK(MBGEN, mbgen)
+COMMON_BLOCK_DEF(MbgenCommon,MBGEN);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* pomwt */
+/* pomgen */
+/* mnpom, mxpom : Min and max number of cut pomerons. */
+/* pdiffr */
+/* npom */
+/* xbary */
+/* dxbary */
+/* xpom */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/MGLIMS/EHMGMN,EHMGMX,YHMGMN,YHMGMX,AMIJMN(MXLIM,MXLIM), */
+/* & AMIJMX(MXLIM,MXLIM),FIXMIJ(MXLIM,MXLIM) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ static const Int_t mxlim = 8;
+ Float_t ehmgmn;
+ Float_t ehmgmx;
+ Float_t yhmgmn;
+ Float_t yhmgmx;
+ Float_t amijmn[mxlim][mxlim];
+ Float_t amijmx[mxlim][mxlim];
+ Bool_t fixmij[mxlim][mxlim];
+} MglimsCommon;
+
+#define MGLIMS COMMON_BLOCK(MGLIMS, mglims)
+COMMON_BLOCK_DEF(MglimsCommon,MGLIMS);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Changes in mxlim should be echoed in JETLIM and in access routines for */
+/* amijmn and amijmx. */
+/* Limits for MadGraph multiparton processes */
+/* ehmgmn, ehmgmx : Mass range */
+/* yhmgmn, yhmgmx : */
+/* amijmn, amijmx : Multimet mass limits */
+/* fixmij : */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/NODCAY/NODCAY,NOETA,NOPI0,NONUNU,NOEVOL,NOHADR,NOGRAV */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Bool_t nodcay;
+ Bool_t noeta;
+ Bool_t nopi0;
+ Bool_t nonunu;
+ Bool_t noevol;
+ Bool_t nohadr;
+ Bool_t nograv;
+} NodcayCommon;
+
+#define NODCAY COMMON_BLOCK(NODCAY, nodcay)
+COMMON_BLOCK_DEF(NodcayCommon,NODCAY);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Booleans used to forbid decay channels. */
+/* nodcay : Suppress all decays */
+/* noeta : Suppress eta decays */
+/* nopi0 : Suppress pi-zero decays */
+/* nonunu : Suppess Z-zero neutrino decays */
+/* noevol : Suppress QCD evolution and hadronisation */
+/* nohadr : Suppress hadronisation of jets and beam jets */
+/* nograv : Suppress gravitino decays in GMSB model */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/PARTCL/NPTCL,PPTCL(5, MXPTCL),IORIG(MXPTCL),IDENT(MXPTCL), */
+/* & IDCAY(MXPTCL) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ static const Int_t mxptcl = 4000;
+ static const Int_t ipack = 10000;
+ Int_t nptcl;
+ Float_t pptcl[mxptcl][5];
+ Int_t iorig[mxptcl];
+ Int_t ident[mxptcl];
+ Int_t idcay[mxptcl];
+} PartclCommon;
+
+#define PARTCL COMMON_BLOCK(PARTCL, partcl)
+COMMON_BLOCK_DEF(PartclCommon,PARTCL);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Stores HEPEVT data. */
+/* nptcl : Number of particles. */
+/* pptcl : x, y, z, and 0 momentum of particles, and mass. */
+/* iorig : origin of particles. */
+/* ident : ID code. */
+/* idcay : ID of decay products. */
+/* mxptcl : Max number of particles. */
+/* ipack : Packing integer, used in decoding idcay. */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/PRIMAR/NJET,SCM,HALFE,ECM,IDIN(2),NEVENT,NTRIES,NSIGMA */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Int_t njet;
+ Float_t scm;
+ Float_t halfe;
+ Float_t ecm;
+ Int_t idin[2];
+ Int_t nevent;
+ Int_t ntries;
+ Int_t nsigma;
+} PrimarCommon;
+
+#define PRIMAR COMMON_BLOCK(PRIMAR, primar)
+COMMON_BLOCK_DEF(PrimarCommon,PRIMAR);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* njet : */
+/* scm : Square of the center-of-mass energy. */
+/* halfe : Half the center-of-mass energy. */
+/* ecm : Center-of-mass energy. */
+/* idin : Beam types 1 and 2. */
+/* nevent : Number of events to build. */
+/* ntries : Maximum number of tries to find a good event. */
+/* nsigma : Number of unevolved events for SIGF calculation. */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/PRTOUT/NEVPRT,NJUMP */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Int_t nevprt;
+ Int_t njump;
+} PrtoutCommon;
+
+#define PRTOUT COMMON_BLOCK(PRTOUT, prtout)
+COMMON_BLOCK_DEF(PrtoutCommon,PRTOUT);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* nevprt : Number of events to print */
+/* njump : Print every njump events. */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/QCDPAR/ALAM,ALAM2,CUTJET,ISTRUC */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Float_t alam;
+ Float_t alam2;
+ Float_t cutjet;
+ Int_t istruc;
+} QcdparCommon;
+
+#define QCDPAR COMMON_BLOCK(QCDPAR, qcdpar)
+COMMON_BLOCK_DEF(QcdparCommon,QCDPAR);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* alam : QCD scale (LAMBDA) */
+/* alam2 : Square of alam */
+/* cutjet : Cutoff mass for QCD jet evolution (mu-subscript-c) */
+/* istruc : Structure functions CTEQ3L, CTEQ2L, EHLQ or DO. */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/QLMASS/AMLEP(100),NQLEP,NMES,NBARY */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ static const Int_t nqlep = 61;
+ static const Int_t nmes = 2;
+ static const Int_t nbary = 2;
+ Float_t amlep[100];
+} QlmassCommon;
+
+#define QLMASS COMMON_BLOCK(QLMASS, qlmass)
+COMMON_BLOCK_DEF(QlmassCommon,QLMASS);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* amlep : (C++ indices, Fortran is one greater) */
+/* [5-7] : t, y and x quark mass (m-subscript-t, -y, -x) */
+/* [21-26] : Masses of u, d, s, c, b and t, all -tilde */
+/* [29] : g-tilde mass */
+/* [30] : gamma-tilde mass */
+/* [31-36] : Masses for nu-e, e, nu-mu, mu, nu-tau and tau, all -tilde */
+/* [39] : W-plus-tilde mass */
+/* [40] : Z-zero-tilde mass */
+/* [63-71] : Higgs meson masses, charges 0,0,0,0,0,1,1,2,2 */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/SEED/XSEED */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Char_t xseed[24];
+} SeedCommon;
+
+#define SEED COMMON_BLOCK(SEED, seed)
+COMMON_BLOCK_DEF(SeedCommon,SEED);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Random number seed */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/SUGNU/XNUSUG(18) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Float_t xnusug[18];
+} SugnuCommon;
+
+#define SUGNU COMMON_BLOCK(SUGNU, sugnu)
+COMMON_BLOCK_DEF(SugnuCommon,SUGNU);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Non-universal SUGRA terms : (C++ indexes again) */
+/* xnusug[0-2] : Gaugino masses */
+/* [3-5] : A terms (A-subscript-tau, -b, -t) */
+/* [6-7] : Higgs masses (M-subscript-H-subscript-d, -u) */
+/* [8-12] : 1st / 2nd generation masses (M-subscript-eR, -eL, -dR, */
+/* -uR, -uL) */
+/* [13-17] : 3rd generation masses (M-subscript-tau R, -tau L, -bR, */
+/* -tR, -tL) */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/TCPAR/TCMRHO,TCGRHO */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ Float_t tcmrho;
+ Float_t tcgrho;
+} TcparCommon;
+
+#define TCPAR COMMON_BLOCK(TCPAR, tcpar)
+COMMON_BLOCK_DEF(TcparCommon,TCPAR);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* tcmrho : Technicolor mass */
+/* tcgrho : Technicolor width */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/TYPES/LOC(100),NTYP,NJTTYP,NWWTYP(2),NWMODE(3) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ static const Int_t mxtype = 8;
+ Int_t loc[100];
+ Int_t ntyp;
+ Int_t njttyp[mxtype];
+ Int_t nwwtyp[2];
+ Int_t nwmode[3];
+} TypesCommon;
+
+#define TYPES COMMON_BLOCK(TYPES, types)
+COMMON_BLOCK_DEF(TypesCommon,TYPES);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Note : Any change in mxtype should be copied in xtypes. */
+/* loc : */
+/* ntyp : */
+/* njttyp : Number of jet types in jet [index]. */
+/* nwwtyp : */
+/* nwmode : */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/XMSSM/GOMSSM,GOSUG,GOGMSB,GOAMSB,AL3UNI, */
+/* & XGLSS,XMUSS,XHASS,XTBSS, */
+/* & XQ1SS,XDRSS,XURSS,XL1SS,XERSS, */
+/* & XQ2SS,XSRSS,XCRSS,XL2SS,XMRSS, */
+/* & XQ3SS,XBRSS,XTRSS,XL3SS,XTARSS,XATSS,XABSS,XATASS, */
+/* & XM1SS,XM2SS,XM0SU,XMHSU,XA0SU,XTGBSU,XSMUSU, */
+/* & XLAMGM,XMESGM,XN5GM,XCMGV,XMGVTO, */
+/* & XRSLGM,XDHDGM,XDHUGM,XDYGM,XN51GM,XN52GM,XN53GM, */
+/* & XMN3NR,XMAJNR,XANSS,XNRSS,XSBCS */
+/*------------------------------------------------------------------------*/
+
+typedef struct {
+ Bool_t gomssm;
+ Bool_t gosug;
+ Bool_t gogmsb;
+ Bool_t goamsb;
+ Bool_t al3uni;
+ Float_t xglss;
+ Float_t xmuss;
+ Float_t xhass;
+ Float_t xtbss;
+ Float_t xq1ss;
+ Float_t xdrss;
+ Float_t xurss;
+ Float_t xl1ss;
+ Float_t xerss;
+ Float_t xq2ss;
+ Float_t xsrss;
+ Float_t xcrss;
+ Float_t xl2ss;
+ Float_t xmrss;
+ Float_t xq3ss;
+ Float_t xbrss;
+ Float_t xtrss;
+ Float_t xl3ss;
+ Float_t xtarss;
+ Float_t xatss;
+ Float_t xabss;
+ Float_t xatass;
+ Float_t xm1ss;
+ Float_t xm2ss;
+ Float_t xm0su;
+ Float_t xmhsu;
+ Float_t xa0su;
+ Float_t xtgbsu;
+ Float_t xsmusu;
+ Float_t xlamgm;
+ Float_t xmesgm;
+ Float_t xn5gm;
+ Float_t xcmgv;
+ Float_t mgvto;
+ Float_t xrslgm;
+ Float_t xdhdgm;
+ Float_t xdhugm;
+ Float_t xdygm;
+ Float_t xn51gm;
+ Float_t xn52gm;
+ Float_t xn53gm;
+ Float_t xmn3nr;
+ Float_t xmajnr;
+ Float_t xanss;
+ Float_t xnrss;
+ Float_t xsbcs;
+
+} XmssmCommon;
+
+#define XMSSM COMMON_BLOCK(XMSSM, xmssm)
+COMMON_BLOCK_DEF(XmssmCommon,XMSSM);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Keyword flags : */
+/* gomssm : True if any of the MSSM* keywords or SUGRA, GMSB or AMSB have */
+/* been used. */
+/* gosug : True if SUGRA has been used. */
+/* gogmsb : True if GMSB has been used. */
+/* goamsb : True if AMSB has been used. */
+/* al3uni : True if AL3UNI has been used. */
+/* */
+/* MSSM parameters : */
+/* xglss : Gluino mass */
+/* xmuss : mu */
+/* xhass : A mass */
+/* xtbss : tan beta */
+/* */
+/* MSSM first generation : */
+/* xq1ss : q-subscript-1 mass */
+/* xdrss : d-subscript-r mass */
+/* xurss : u-subscript-r mass */
+/* xl1ss : l-subscript-1 mass */
+/* xerss : e-subscript-1 mass */
+/* */
+/* MSSM second generation : */
+/* xq2ss : q-subscript-2 mass */
+/* xsrss : s-subscript-r mass */
+/* xcrss : c-subscript-r mass */
+/* xl2ss : l-subscript-2 mass */
+/* xmrss : mu-subscript-r mass */
+/* */
+/* MSSM third generation : */
+/* xq3ss : q-subscript-3 mass */
+/* xbrss : b-subscript-r mass */
+/* xtrss : t-subscript-r mass */
+/* xl3ss : l-subscript-3 mass */
+/* xtarss : tau-subscript-r mass */
+/* xatss, xabss, xatass : A-subscript-t, -b, -tau mixings. */
+/* */
+/* MSSM gaugino masses */
+/* xm1ss, xm2ss : M-subscript-1, -2 */
+/* */
+/* Anomaly-mediated SUSY breaking / Minimal supergravity parameters : */
+/* xm0su : scalar mass (m-subscript-0) */
+/* xmhsu : gravitino mass (m-subscript-three halves) */
+/* xa0su : trilinear breaking term (A-subscript-0) */
+/* xtgbsu : VEV ratio (tan beta) */
+/* xsmusu : sign (sgn mu) */
+/* */
+/* GMSB messinger SUSY breaking */
+/* xlamgm : mass (LAMBDA-subscript-m) */
+/* xmesgm : */
+/* xn5gm : number of 5 + 5-bar (M-subscript-m) */
+/* xcmgv : gravitino scale (C-subscript-gr) */
+/* */
+/* Non-minimal GMSB parameters */
+/* xrslgm : gaugino mass multiplier (R-slash) */
+/* xdhdgm : Higgs mass shift (delta M-squared-subscript-Hd) */
+/* xdhugm : Higgs mass shift (delta M-squared-subscript-Hu) */
+/* xdygm : D-term mass-squared (D-subscript-Y of M) */
+/* xn51gm, xn52gm, xn53gm : independent gauge group messengers */
+/* (N-subscript-5-subscript-1, -2, -3) */
+/* SUGRA see-saw nu-effect */
+/* xmn3nr : nu-mass (m-subscript-nu-subscript-tau) */
+/* xmajnr : int. scale (M-subscript-N) */
+/* xanss : GUT scale (A-subscript-n) */
+/* xnrss : nu SSB terms (m-subscript-nu-tilde-subscript-R) */
+/* */
+/* xsbcs */
+/* */
+/* Gravitino mass */
+/* xmgvto : gravitino mass (M-subscript-gravitino) */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/XTYPES/PARTYP(40),TITLE(10),JETYP(30,MXTYPE),WWTYP(30,2), */
+/* & WMODES(30,3) */
+/*------------------------------------------------------------------------*/
+typedef struct {
+ static const Int_t mxtype = 8;
+ Char_t* partyp[40];
+ Char_t* title;
+ Char_t* jetyp[mxtype][30];
+ Char_t* wwtyp[2][30];
+ Char_t* wmodes[3][30];
+} XtypesCommon;
+
+#define XTYPES COMMON_BLOCK(XTYPES, xtypes)
+COMMON_BLOCK_DEF(XtypesCommon,XTYPES);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* Note : Any change in mxtype should be copied in types. */
+/* partyp */
+/* title */
+/* jetyp */
+/* wwtyp : Decay modes for WPAIR */
+/* wmodes : Decay modes for weak force carriers */
+/**************************************************************************/
+
+
+
+/*========================================================================*/
+/* COMMON/WCON/SIN2W,WMASS(4),WGAM(4),AQ(12,4),BQ(12,4),COUT(4), */
+/* & MATCH(25,4),WCBR(25,4),CUTOFF,CUTPOW,TBRWW(4,2), */
+/* & RBRWW(12,4,2),EZ,AQDP(12,4),BQDP(12,4),EZDP,WFUDGE */
+/*------------------------------------------------------------------------*/
+typedef struct {
+
+ Float_t sin2w;
+ Float_t wmass[4];
+ Float_t wgam[4];
+ Float_t aq[4][12];
+ Float_t bq[4][12];
+ Float_t cout[4];
+ Int_t match;
+ Float_t wcbr[4][25];
+ Float_t cutoff;
+ Float_t cutpow;
+ Float_t tbrww[2][4];
+ Float_t rbrww[2][4][12];
+ Float_t ez;
+ Float_t aqdp[4][12];
+ Float_t bqdp[4][12];
+ Float_t ezdp;
+ Float_t wfudge;
+} WconCommon;
+
+#define WCON COMMON_BLOCK(WCON, wcon)
+COMMON_BLOCK_DEF(WconCommon, WCON);
+
+/**************************************************************************/
+/* D E S C R I P T I O N : */
+/*------------------------------------------------------------------------*/
+/* sin2w : Weinberg angle (sin-squared(theta-subscript-W)) */
+/* wmass : W and Z masses */
+/* wgam : */
+/* aq : */
+/* bq : */
+/* cout : */
+/* match */
+/* wcbr */
+/* cutoff, cutpow : mu-square and nu, respectively, in formula */
+/* cutoff q*t-square = mu-square*Q-power-nu */
+/* for DRELLYAN events. */
+/* tbrww */
+/* rbrww */
+/* ez */
+/* aqdp */
+/* bqdp */
+/* ezdp */
+/* wfudge : Fudge factor for DRELLYAN evolution scale */
+/**************************************************************************/
+}
+
+#endif
+
+// Endfile.
+
+
+
+
+
+
+
+
--- /dev/null
+#include "TParticle.h"
+#include "TSystem.h"
+#include "TIsajet.h"
+#include "Icommon.h"
+#include "iostream.h"
+#include "fstream.h"
+#include "math.h"
+#include "TROOT.h"
+#include "TMath.h"
+
+ClassImp(TIsajet)
+
+/**************************************************************************/
+
+TIsajet::TIsajet() : TGenerator("Isajet", "Isajet")
+{
+// Default constructor
+// Set random number
+ if (!sRandom) sRandom=fRandom;
+
+// Initialising equivalence structures in FRGPAR :
+// EQUIVALENCE (PMIX1(1,1),PMIXX1(1))
+// EQUIVALENCE (PMIX2(1,1),PMIXX2(1))
+// EQUIVALENCE (FRPAR(1),PUD)
+
+ FRGPAR.pmixx1[0] = &FRGPAR.pmix1[0][0];
+ FRGPAR.pmixx2[0] = &FRGPAR.pmix2[0][0];
+ FRGPAR.frpar[0] = &FRGPAR.pud;
+
+ for (Int_t i = 1; i < 6; i++) {
+ FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
+ FRGPAR.pmixx1[i] = FRGPAR.pmixx1[i-1] + 1;
+ }
+
+ for (Int_t i = 1; i < 32; i++) {
+ FRGPAR.frpar[i] = FRGPAR.frpar[i-1] +1;
+ }
+
+// Internal logical flags ensuring that theta and y limits are not simultaneously set :
+
+ DYLIM.ywset = DYLIM.thwset = false;
+
+// Defaults :
+
+ title = ("Default title.");
+ jobtype = ("TWOJET");
+
+ RestoreDefaults();
+}
+
+/**************************************************************************/
+
+TIsajet::~TIsajet()
+{
+ // No housekeeping required at the moment.
+}
+
+/**************************************************************************/
+
+void TIsajet::Initialise()
+{
+
+// Writes parameter file and stores common block variables in
+// data members, according to booleans.
+// If TIsajet is being used in online-control mode, the parameter file is
+// unnecessary, hence the output is echoed to the screen instead.
+
+ const char *fname = gSystem->ExpandPathName("$ALICE_ROOT/ISAJET/data/myjob.par");
+ ofstream Write(fname, ios::out);
+
+ ostream *Writer = &Write;
+
+ if (online) Writer = &cout;
+
+ *Writer << title << '\n';
+ *Writer << PRIMAR.ecm << ',' << PRIMAR.nevent << ",1,1/\n";
+ *Writer << jobtype << '\n';
+
+ center_energy = PRIMAR.ecm;
+
+ if (setBeams) {
+ beam1_type = PRIMAR.idin[0];
+ beam2_type = PRIMAR.idin[1];
+
+ *Writer << "BEAMS\n";
+ if (PRIMAR.idin[0] == -1120) *Writer << "AP,";
+ else if (PRIMAR.idin[0] == 1220) *Writer << "N,";
+ else if (PRIMAR.idin[0] == -1220) *Writer << "AN,";
+ else *Writer << "P,";
+
+ if (PRIMAR.idin[1] == -1120) *Writer << "AP/\n";
+ else if (PRIMAR.idin[1] == 1220) *Writer << "N/\n";
+ else if (PRIMAR.idin[1] == -1220) *Writer << "AN/\n";
+ else *Writer << "P/\n";
+ }
+
+ if (setCutjet) {
+ cutoff_mass = QCDPAR.cutjet;
+ *Writer << "CUTJET\n" << QCDPAR.cutjet << "/\n";
+ }
+
+ if (setFragment) {
+ for (Int_t i = 0; i < 32; i++) frag_params[i] = *FRGPAR.frpar[i];
+
+ *Writer << "FRAGMENT\n";
+ for (Int_t i = 0; i < 31; i++) *Writer << FRGPAR.frpar[i] << ',';
+ *Writer << FRGPAR.frpar[31] << "/\n";
+ }
+
+ if (setJettype1) {
+ for (Int_t i = 0; i < TYPES.njttyp[0]; i++) jet1_type[i] = XTYPES.jetyp[0][i];
+ num_jet_type[0] = TYPES.njttyp[0];
+
+ *Writer << "JETTYPE1\n";
+ for (Int_t i = 0; i < TYPES.njttyp[0]-1; i++) *Writer << XTYPES.jetyp[0][i] << ',';
+ *Writer << XTYPES.jetyp[0][TYPES.njttyp[0]-1] << "/\n";
+ }
+ if (setJettype2) {
+ for (Int_t i = 0; i < TYPES.njttyp[1]; i++) jet2_type[i] = XTYPES.jetyp[1][i];
+ num_jet_type[0] = TYPES.njttyp[0];
+
+ *Writer << "JETTYPE2\n";
+ for (Int_t i = 0; i < TYPES.njttyp[1]-1; i++) *Writer << XTYPES.jetyp[1][i] << ',';
+ *Writer << XTYPES.jetyp[1][TYPES.njttyp[1]-1] << "/\n";
+ }
+ if (setJettype3) {
+ for (Int_t i = 0; i < TYPES.njttyp[2]; i++) jet3_type[i] = XTYPES.jetyp[2][i];
+ num_jet_type[0] = TYPES.njttyp[0];
+
+ *Writer << "JETTYPE3\n";
+ for (Int_t i = 0; i < TYPES.njttyp[2]-1; i++) *Writer << XTYPES.jetyp[2][i] << ',';
+ *Writer << XTYPES.jetyp[2][TYPES.njttyp[2]-1] << "/\n";
+ }
+
+
+ if (setLambda) {
+ qcd_lambda = QCDPAR.alam;
+ *Writer << "LAMBDA\n" << QCDPAR.alam << "/\n";
+ }
+
+
+ if (setNodcay) {
+ forbid_decay = NODCAY.nodcay;
+
+ *Writer << "NODCAY\n";
+ if (NODCAY.nodcay) *Writer << "TRUE/\n";
+ else *Writer << "FALSE/\n";
+ }
+
+ if (setNoeta) {
+ forbid_eta = NODCAY.noeta;
+
+ *Writer << "NOETA\n";
+ if (NODCAY.noeta) *Writer << "TRUE/\n";
+ else *Writer << "FALSE/\n";
+ }
+
+ if (setNoevolve) {
+ forbid_evolve = NODCAY.noevol;
+
+ *Writer << "NOEVOLVE\n";
+ if (NODCAY.noevol) *Writer << "TRUE/\n";
+ else *Writer << "FALSE/\n";
+ }
+
+ if (setNohadron) {
+ forbid_hadron = NODCAY.nohadr;
+
+ *Writer << "NOHADRON\n";
+ if (NODCAY.nohadr) *Writer << "TRUE/\n";
+ else *Writer << "FALSE/\n";
+ }
+
+ if (setNopi0) {
+ forbid_pi0 = NODCAY.nopi0;
+
+ *Writer << "NOPI0\n";
+ if (NODCAY.nopi0) *Writer << "TRUE/\n";
+ else *Writer << "FALSE/\n";
+ }
+
+ if (setNsigma) {
+ generate_sigma = PRIMAR.nsigma;
+ *Writer << "NSIGMA\n" << PRIMAR.nsigma << "/\n";
+ }
+
+ if (setP) {
+ for (Int_t i = 0; i < 3; i++) {
+ p_limits[2 * i] = JETLIM.pmin[i];
+ p_limits[2 * i + 1] = JETLIM.pmax[i];
+ }
+
+ *Writer << "P\n";
+ *Writer << JETLIM.pmin[0] << ',' << JETLIM.pmax[0] << ',';
+ *Writer << JETLIM.pmin[1] << ',' << JETLIM.pmax[1] << ',';
+ *Writer << JETLIM.pmin[2] << ',' << JETLIM.pmax[2] << "/\n";
+ }
+
+ if (setPhi) {
+ for (Int_t i = 0; i < 3; i++) {
+ phi_limits[2 * i] = JETLIM.phimin[i];
+ phi_limits[2 * i + 1] = JETLIM.phimax[i];
+ }
+
+ *Writer << "PHI\n";
+ *Writer << JETLIM.phimin[0] << ',' << JETLIM.phimax[0] << ',';
+ *Writer << JETLIM.phimin[1] << ',' << JETLIM.phimax[1] << ',';
+ *Writer << JETLIM.phimin[2] << ',' << JETLIM.phimax[2] << "/\n";
+ }
+
+ if (setPt) {
+ for (Int_t i = 0; i < 3; i++) {
+ pt_limits[2 * i] = JETLIM.ptmin[i];
+ pt_limits[2 * i + 1] = JETLIM.ptmax[i];
+ }
+
+ *Writer << "PT\n";
+ *Writer << JETLIM.ptmin[0] << ',' << JETLIM.ptmax[0] << ',';
+ *Writer << JETLIM.ptmin[1] << ',' << JETLIM.ptmax[1] << ',';
+ *Writer << JETLIM.ptmin[2] << ',' << JETLIM.ptmax[2] << "/\n";
+ }
+
+ if (setTheta) {
+ for (Int_t i = 0; i < 3; i++) {
+ theta_limits[2 * i] = JETLIM.thmin[i];
+ theta_limits[2 * i + 1] = JETLIM.thmax[i];
+ }
+
+ *Writer << "THETA\n";
+ *Writer << JETLIM.thmin[0] << ',' << JETLIM.thmax[0] << ',';
+ *Writer << JETLIM.thmin[1] << ',' << JETLIM.thmax[1] << ',';
+ *Writer << JETLIM.thmin[2] << ',' << JETLIM.thmax[2] << "/\n";
+ }
+
+ if (setX) {
+ for (Int_t i = 0; i < 3; i++) {
+ x_limits[2 * i] = JETLIM.xjmin[i];
+ x_limits[2 * i + 1] = JETLIM.xjmax[i];
+ }
+
+ *Writer << "X\n";
+ *Writer << JETLIM.xjmin[0] << ',' << JETLIM.xjmax[0] << ',';
+ *Writer << JETLIM.xjmin[1] << ',' << JETLIM.xjmax[1] << ',';
+ *Writer << JETLIM.xjmin[2] << ',' << JETLIM.xjmax[2] << "/\n";
+ }
+
+ if (setY) {
+ for (Int_t i = 0; i < 3; i++) {
+ y_limits[2 * i] = JETLIM.yjmin[i];
+ y_limits[2 * i + 1] = JETLIM.yjmax[i];
+ }
+
+ *Writer << "Y\n";
+ *Writer << JETLIM.yjmin[0] << ',' << JETLIM.yjmax[0] << ',';
+ *Writer << JETLIM.yjmin[1] << ',' << JETLIM.yjmax[1] << ',';
+ *Writer << JETLIM.yjmin[2] << ',' << JETLIM.yjmax[2] << "/\n";
+ }
+
+ if (setXgen) {
+ for (Int_t i = 0; i < 8; i++) peter_jet_frag[i] = FRGPAR.xgen[i];
+
+ *Writer << "XGEN\n";
+ for (Int_t i = 0; i < 7; i++) *Writer << FRGPAR.xgen[i] << ',';
+ *Writer << FRGPAR.xgen[7] << "/\n";
+ }
+
+ if (setPdf) {
+ *Writer << "PDFLIB\n";
+ for (Int_t i = 0; i < num_Pdf; i++) *Writer << "\'" << pdfpar[i] << "\'" << ',' << pdfval[i] << "/\n";
+ }
+
+
+ *Writer << "END\n";
+ *Writer << "STOP\n";
+ Write.close();
+
+// Stuff for online-control mode :
+
+ if (online) {
+ KEYS.reac = jobtype;
+ KEYS.keyon = false;
+ for (Int_t i = 0; i < KEYS.mxkeys; i++) KEYS.keys[i] = false;
+
+ if (!strcmp(KEYS.reac, "TWOJET")) {
+ KEYS.keys[0] = true;
+ KEYS.ikey = 1;
+ PRIMAR.njet = 2;
+ }
+ else if (!strcmp(KEYS.reac, "MINBIAS")) {
+ KEYS.keys[3] = true;
+ KEYS.ikey = 4;
+ PRIMAR.njet = 0;
+ }
+ else {
+ printf("Error in TIsajet::Initialise :\n");
+ printf("Invalid job type %s.\n", KEYS.reac);
+ printf("Only TWOJET and MINBIAS are currently supported for online mode.\n");
+ return;
+ }
+
+ if (setPdf) {
+ PDFinit();
+ }
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::Reload()
+{
+//
+// Sets the common block variables to the data member values.
+//
+
+ SetECM(center_energy);
+
+ if (setBeams) {
+ SetIDIN(0, beam1_type);
+ SetIDIN(1, beam2_type);
+ }
+
+ if (setCutjet) SetCUTJET(cutoff_mass);
+
+ if (setFragment) SetAllFRPAR(frag_params, 32);
+
+ if (setJettype1) for (Int_t i = 0; i < num_jet_type[0]; i++) SetJETYP(0, jet1_type[i]);
+
+ if (setJettype2) for (Int_t i = 0; i < num_jet_type[1]; i++) SetJETYP(1, jet2_type[i]);
+
+ if (setJettype3) for (Int_t i = 0; i < num_jet_type[2]; i++) SetJETYP(2, jet3_type[i]);
+
+ if (setLambda) SetALAM(qcd_lambda);
+
+ if (setNodcay) SetNODCAY(forbid_decay);
+
+ if (setNoeta) SetNOETA(forbid_eta);
+
+ if (setNoevolve) SetNOEVOL(forbid_evolve);
+
+ if (setNohadron) SetNOHADR(forbid_hadron);
+
+ if (setNopi0) SetNOPI0(forbid_pi0);
+
+ if (setNsigma) SetNSIGMA(generate_sigma);
+
+ if (setP) {
+ for (Int_t i = 0; i < 3; i++) {
+ SetPMIN(p_limits[2 * i], i);
+ SetPMAX(p_limits[2 * i + 1], i);
+ }
+ }
+
+ if (setPhi) {
+ for (Int_t i = 0; i < 3; i++) {
+ SetPHIMIN(phi_limits[2 * i], i);
+ SetPHIMAX(phi_limits[2 * i + 1], i);
+ }
+ }
+
+ if (setPt) {
+ for (Int_t i = 0; i < 3; i++) {
+ SetPTMIN(pt_limits[2 * i], i);
+ SetPTMAX(pt_limits[2 * i + 1], i);
+ }
+ }
+
+ if (setTheta) {
+ for (Int_t i = 0; i < 3; i++) {
+ SetTHMIN(theta_limits[2 * i], i);
+ SetTHMAX(theta_limits[2 * i + 1], i);
+ }
+ }
+
+ if (setX) {
+ for (Int_t i = 0; i < 3; i++) {
+ SetXJMIN(x_limits[2 * i], i);
+ SetXJMAX(x_limits[2 * i + 1], i);
+ }
+ }
+
+ if (setY) {
+ for (Int_t i = 0; i < 3; i++) {
+ SetYJMIN(y_limits[2 * i], i);
+ SetYJMAX(y_limits[2 * i + 1], i);
+ }
+ }
+
+ if (setXgen) SetAllXGEN(peter_jet_frag, 8);
+}
+
+/**************************************************************************/
+
+void TIsajet::RestoreDefaults()
+{
+// Booleans indicating which keywords should be written into the parameter file.
+
+ setBeams = setCutjet = setFragment = setJettype1 = false;
+ setJettype2 = setJettype3 = setLambda = setNodcay = false;
+ setNoeta = setNoevolve = setNohadron = setNopi0 = false;
+ setNsigma = setP = setPhi = setPt = setTheta = false;
+ setX = setXgen = setY = setPdf = false;
+ num_Pdf = 0;
+
+// Calling on FORTRAN for initialisation of variables
+
+ Openfiles();
+ Int_t a, b, c, d, e;
+
+ a = -54;
+ b = 0;
+ c = 51;
+ d = 53;
+
+ Isaini(a, b, c, d);
+ e = 0;
+ Isabeg(e);
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::ImportParticles(TClonesArray *particles, Option_t *option)
+{
+//
+// Default primary creation method. It reads the /HEPEVT/ common block which
+// has been filled by the GenerateEvent method. If the event generator does
+// not use the HEPEVT common block, this routine has to be overloaded by
+// the subclasses.
+// The function loops on the generated particles and stores them in
+// the TClonesArray pointed by the argument particles.
+// The default action is to store only the stable particles (ISTHEP = 1)
+// This can be demanded explicitly by setting the option = "Final"
+// If the option = "All", all the particles are stored.
+//
+ if (particles == 0) return 0;
+ TClonesArray &Particles = *particles;
+ Particles.Clear();
+ TDatabasePDG* converter = TDatabasePDG::Instance();
+ Int_t numpart = PARTCL.nptcl;
+ printf("\n TIsajet: ISAJET stack contains %d particles.", numpart);
+ printf("\n TIsajet: Total energy: %f ", PRIMAR.ecm);
+ Int_t nump = 0;
+ if ((!strcmp(option,"")) || (!strcmp(option,"Final"))) {
+ for (Int_t i = 0; i < numpart; i++) {
+
+ if (PARTCL.idcay[i] == 0) { // Check whether particle is stable.
+//
+// Use the common block values for the TParticle constructor
+//
+ nump++;
+ new(Particles[i]) TParticle(
+ converter->ConvertIsajetToPdg(PARTCL.ident[i]) , // PDG code
+ 0 , // Status - currently a default
+
+ -1, // Mothers and daughters - not used for stable particles
+ -1,
+ -1,
+ -1,
+
+ PARTCL.pptcl[i][0] , // x, y, z and 0 momenta
+ PARTCL.pptcl[i][1] ,
+ PARTCL.pptcl[i][2] ,
+ PARTCL.pptcl[i][3] ,
+
+ 0, // Velocities - currently not used.
+ 0,
+ 0,
+ 0);
+ }
+ }
+ }
+ else if (!strcmp(option,"All")) {
+ nump=numpart;
+ for (Int_t i = 0; i < numpart; i++) {
+
+ // Determine mother particle. Set to -1 if the particle originates from
+ // a parton or is a beam particle.
+
+ Int_t origin = PARTCL.iorig[i];
+ Int_t jet = origin / PARTCL.ipack;
+ origin = origin - (jet * PARTCL.ipack);
+
+ if (origin < 0) origin = 0;
+
+ // Determine first and last decay products. Both are -1 if the particle is stable.
+ // Note this means they are set to 0, because one is subtracted after decoding;
+ // this avoid off-by-one errors relative to the FORTRAN.
+
+ Int_t first_Daughter = 0;
+ Int_t last_Daughter = 0;
+
+ if (PARTCL.idcay[i] != 0) {
+ first_Daughter = PARTCL.idcay[i] / PARTCL.ipack;
+ last_Daughter = PARTCL.idcay[i] - (first_Daughter * PARTCL.ipack);
+ }
+ new(Particles[i]) TParticle(
+ converter->ConvertIsajetToPdg(PARTCL.ident[i]) ,
+ 0,
+
+ origin - 1,
+ -1,
+ first_Daughter - 1,
+ last_Daughter - 1,
+
+ PARTCL.pptcl[i][0] ,
+ PARTCL.pptcl[i][1] ,
+ PARTCL.pptcl[i][2] ,
+ PARTCL.pptcl[i][3] ,
+
+ 0,
+ 0,
+ 0,
+ 0);
+ }
+ }
+ return nump;
+}
+
+/**************************************************************************/
+
+void TIsajet::GenerateEvent()
+{
+ Int_t e, ok, done;
+
+// e = 0;
+
+// if (online) Isabg2(e);
+// else Isabeg(e);
+
+ e = 1;
+ Isaevt(e, ok, done);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetJobtype(Char_t *val)
+{
+ if ((!strcmp(val, "TWOJET")) || (!strcmp(val, "E+E-")) ||
+ (!strcmp(val, "DRELLYAN")) || (!strcmp(val, "MINBIAS")) ||
+ (!strcmp(val, "SUSY")) || (!strcmp(val, "WPAIR")) ||
+ (!strcmp(val, "HIGGS")) || (!strcmp(val, "PHOTON")) ||
+ (!strcmp(val, "TCOLOR")) || (!strcmp(val, "WHIGGS")) ||
+ (!strcmp(val, "EXTRADIM")) || (!strcmp(val, "ZJJ"))) {
+ jobtype = val;
+ }
+ else {
+ printf("Error in TIsajet::SetJobtype :\n");
+ printf("Invalid reaction keyword %s.\n", val);
+ printf("Valid keywords are : TWOJET, E+E-, DRELLYAN,\n");
+ printf("MINBIAS, SUSY, WPAIR, HIGGS, PHOTON, TCOLOR,\n");
+ printf("WHIGGS, EXTRADIM and ZJJ.\n");
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::GetJobtype() const
+{
+ printf ("Current job type is %s.\n", jobtype);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetOnline(Bool_t val)
+{
+ online = val;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetOnline() const
+{
+ return online;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPDF(Char_t *name, Float_t val)
+{
+ if (num_Pdf < 19) {
+ pdfpar[num_Pdf] = name;
+ pdfval[num_Pdf] = val;
+ num_Pdf++;
+ setPdf = true;
+ }
+ else {
+ printf ("Error in TIsajet::SetPDF :\n");
+ printf ("Maximum of twenty PDF parameters may be set.\n");
+ }
+}
+
+/**************************************************************************/
+
+// Access routines for common blocks.
+// Begins DYLIM access.
+
+/**************************************************************************/
+
+void TIsajet::SetQMIN(Float_t val)
+{
+ if (val > DYLIM.qmax) {
+ printf("Error in TIsajet::SetQMIN : \n");
+ printf("You may not set QMIN to a value larger than QMAX = %f.\n", DYLIM.qmax);
+ return;
+ }
+
+ DYLIM.qmin = val;
+ if (!DYLIM.ywset) SetYWLIMS();
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQMIN() const
+{
+ return DYLIM.qmin;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetQMAX(Float_t val)
+{
+ if (val < DYLIM.qmin) {
+ printf("Error in TIsajet::SetQMAX : \n");
+ printf("You may not set QMAX to a value less than QMIN = %f.\n", DYLIM.qmin);
+ return;
+ }
+
+ DYLIM.qmax = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQMAX() const
+{
+ return DYLIM.qmax;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetQTMIN(Float_t val)
+{
+ if (val > DYLIM.qtmax) {
+ printf("Error in TIsajet::SetQTMIN : \n");
+ printf("You may not set QTMIN to a value larger than QTMAX = %f.\n", DYLIM.qtmax);
+ return;
+ }
+ DYLIM.qtmin = val;
+ if (!DYLIM.ywset) SetYWLIMS();
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQTMIN() const
+{
+ return DYLIM.qtmin;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetQTMAX(Float_t val)
+{
+ if (val < DYLIM.qtmin) {
+ printf("Error in TIsajet::SetQTMAX : \n");
+ printf("You may not set QTMAX to a value less than QTMIN = %f.\n", DYLIM.qtmin);
+ return;
+ }
+
+ DYLIM.qtmax = val;
+ if (!DYLIM.ywset) SetYWLIMS();
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQTMAX() const
+{
+ return DYLIM.qtmax;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetYWMIN(Float_t val)
+{
+ if (val > DYLIM.ywmax) {
+ printf("Error in TIsajet::SetYWMIN : \n");
+ printf("You may not set YWMIN to a value larger than YWMAX = %f.\n", DYLIM.ywmax);
+ return;
+ }
+
+ if (DYLIM.thwset) {
+ printf("Error in TIsajet::SetYWMIN :\n");
+ printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMIN.\n");
+ }
+ else {
+ DYLIM.ywset = true;
+ DYLIM.ywmin = val;
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYWMIN() const
+{
+ return DYLIM.ywmin;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetYWMAX(Float_t val)
+{
+ if (val < DYLIM.ywmin) {
+ printf("Error in TIsajet::SetYWMAX : \n");
+ printf("You may not set YWMAX to a value less than YWMIN = %f.\n", DYLIM.ywmin);
+ return;
+ }
+
+ if (DYLIM.thwset) {
+ printf("Error in TIsajet::SetYWMAX :\n");
+ printf("May not set both theta and y limits. Use SetTHWLIMS, then set YWMAX.\n");
+ }
+ else {
+ DYLIM.ywset = true;
+ DYLIM.ywmax = val;
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYWMAX() const
+{
+ return DYLIM.ywmax;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetYWLIMS()
+{
+ Float_t rot = sqrt(DYLIM.qmin * DYLIM.qmin + DYLIM.qtmin * DYLIM.qtmin);
+ DYLIM.ywmax = acosh(PRIMAR.halfe / rot);
+ DYLIM.ywmin = -DYLIM.ywmax;
+ DYLIM.ywset = false;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXWMIN(Float_t val)
+{
+ if (val > DYLIM.xwmax) {
+ printf("Error in TIsajet::SetXWMIN : \n");
+ printf("You may not set XWMIN to a value larger than XWMAX = %f.\n", DYLIM.xwmax);
+ return;
+ }
+ DYLIM.xwmin = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXWMIN() const
+{
+ return DYLIM.xwmin;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXWMAX(Float_t val)
+{
+ if (val < DYLIM.xwmin) {
+ printf("Error in TIsajet::SetXWMAX : \n");
+ printf("You may not set XWMAX to a value less than XWMIN = %f.\n", DYLIM.xwmin);
+ return;
+ }
+
+ DYLIM.xwmax = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXWMAX() const
+{
+ return DYLIM.xwmax;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTHWMIN(Float_t val)
+{
+ if (val > DYLIM.thwmax) {
+ printf("Error in TIsajet::SetTHWMIN : \n");
+ printf("You may not set THWMIN to a value larger than THWMAX = %f.\n", DYLIM.thwmax);
+ return;
+ }
+
+ if (DYLIM.ywset) {
+ printf("Error in TIsajet::SetTHWMIN :\n");
+ printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMIN.\n");
+ }
+ else {
+ DYLIM.thwset = true;
+ DYLIM.thwmin = val;
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTHWMIN() const
+{
+ return DYLIM.thwmin;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTHWMAX(Float_t val)
+{
+ if (val < DYLIM.thwmin) {
+ printf("Error in TIsajet::SetTHWMAX : \n");
+ printf("You may not set THWMAX to a value less than THWMIN = %f.\n", DYLIM.thwmin);
+ return;
+ }
+
+ if (DYLIM.ywset) {
+ printf("Error in TIsajet::SetTHWMAX :\n");
+ printf("May not set both theta and y limits. Use SetYWLIMS, then set THWMAX.\n");
+ }
+ else {
+ DYLIM.thwset = true;
+ DYLIM.thwmax = val;
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTHWMAX() const
+{
+ return DYLIM.thwmax;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTHWLIMS()
+{
+ DYLIM.thwmin = 0;
+ DYLIM.thwmax = TMath::Pi();
+ DYLIM.thwset = false;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPHWMIN(Float_t val)
+{
+ if (val > DYLIM.phwmax) {
+ printf("Error in TIsajet::SetPHWMIN : \n");
+ printf("You may not set PHWMIN to a value larger than PHWMAX = %f.\n", DYLIM.phwmax);
+ return;
+ }
+ DYLIM.phwmin = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPHWMIN() const
+{
+ return DYLIM.phwmin;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPHWMAX(Float_t val)
+{
+ if (val < DYLIM.phwmin) {
+ printf("Error in TIsajet::SetPHWMAX : \n");
+ printf("You may not set PHWMAX to a value less than PHWMIN = %f.\n", DYLIM.phwmin);
+ return;
+ }
+
+ DYLIM.phwmax = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPHWMAX() const
+{
+ return DYLIM.phwmax;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetSETLMQ(Int_t index) const
+{
+ Int_t length = (sizeof DYLIM.setlmq / sizeof DYLIM.setlmq[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetSETLMQ : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return DYLIM.setlmq[index];
+}
+
+/**************************************************************************/
+
+// End of DYLIM access.
+// Begins EEPAR access.
+
+/**************************************************************************/
+
+void TIsajet::SetPLEP(Float_t val)
+{
+ EEPAR.plep = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPLEP() const
+{
+ return EEPAR.plep;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPLEM(Float_t val)
+{
+ EEPAR.plem = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPLEM() const
+{
+ return EEPAR.plem;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetRSHMIN(Float_t val)
+{
+ if (val > EEPAR.rshmax) {
+ printf("Error in TIsajet::SetRSHMIN : \n");
+ printf("You may not set RSHMIN to a value larger than RSHMAX = %f.\n", EEPAR.rshmax);
+ return;
+ }
+ EEPAR.rshmin = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetRSHMIN() const
+{
+ return EEPAR.rshmin;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetRSHMAX(Float_t val)
+{
+ if (val < EEPAR.rshmin) {
+ printf("Error in TIsajet::SetRSHMAX : \n");
+ printf("You may not set RSHMAX to a value less than RSHMIN = %f.\n", EEPAR.rshmin);
+ return;
+ }
+
+ EEPAR.rshmax = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetRSHMAX() const
+{
+ return EEPAR.rshmax;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetUPSLON(Float_t val)
+{
+ EEPAR.upslon = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetUPSLON() const
+{
+ return EEPAR.upslon;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetSIGZ(Float_t val)
+{
+ EEPAR.sigz = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSIGZ() const
+{
+ return EEPAR.sigz;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetIBREM() const
+{
+ return EEPAR.ibrem;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetIBEAM() const
+{
+ return EEPAR.ibeam;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSGMXEE() const
+{
+ return EEPAR.sgmxee;
+}
+
+/**************************************************************************/
+
+// End of EEPAR access.
+// Begins FORCE access.
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNFORCE() const
+{
+ return FORCE.nforce;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti = true)
+{
+ if (GetNFORCE() >= FORCE.mxforc - anti) {
+ printf ("ERROR in TIsajet::SetIFORCE :\n");
+ printf ("Cannot have more than %d forced decays.\n", FORCE.mxforc );
+ return;
+ }
+
+ if ((arraySize > 6) || (arraySize < 2)) {
+ printf ("Error in TIsajet::SetIFORCE : \n");
+ printf ("Invalid array size %d; must be 2-6.\n", arraySize);
+ return;
+ }
+
+ for (Int_t i = 0; i < FORCE.nforce; i++) {
+ if (FORCE.iforce[i] == val[0]) {
+ printf ("Error in TIsajet::SetIFORCE : \n");
+ printf ("Particle %d has already been forced, index %d.\n", val[0], i);
+ return;
+ }
+ }
+
+
+ FORCE.iforce[FORCE.nforce] = val[0];
+ for (Int_t i = 1; i < arraySize; i++) {
+ FORCE.mforce[FORCE.nforce][i-1] = val[i];
+ }
+
+ FORCE.nforce++;
+
+ printf ("Decay channel %d -> ", val[0]);
+ for (Int_t i = 1; i < arraySize; i++) {
+ printf ("%d, ", val[i]);
+ }
+ printf ("set. \n");
+
+ if (anti) {
+ Int_t antivals[arraySize];
+ for (Int_t i = 0; i < arraySize; i++){
+ antivals[i] = (0 - val[i]);
+ }
+ SetIFORCE(antivals, arraySize, false);
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::UnForce(Int_t index, Bool_t anti = true)
+{
+ if (FORCE.nforce == 0) {
+ printf ("Error in TIsajet::UnForce : \n");
+ printf ("No decays have been forced.\n");
+ return;
+ }
+
+ if ((index < 0) || (index >= FORCE.nforce)) {
+ printf ("Error in TIsajet::UnForce : \n");
+ printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
+ return;
+ }
+
+ Int_t particle_ID = FORCE.iforce[index];
+
+ for (Int_t i = index; i < FORCE.mxforc - 1; i++) {
+ FORCE.iforce[i] = FORCE.iforce[i+1];
+ for (Int_t j = 0; j < 5; j++) {
+ FORCE.mforce[i][j] = FORCE.mforce[i+1][j];
+ }
+ }
+ FORCE.iforce[FORCE.mxforc - 1] = 0;
+ for (Int_t j = 0; j < 5; j++) {
+ FORCE.mforce[FORCE.mxforc - 1][j] = 0;
+ }
+
+ FORCE.nforce--;
+
+ printf ("Decay of %d unforced.\n", particle_ID);
+
+ if (anti) UnForceID(-particle_ID, false);
+}
+
+/**************************************************************************/
+
+void TIsajet::UnForceID(Int_t particle_ID, Bool_t anti = true)
+{
+ if (FORCE.nforce == 0) {
+ printf ("Error in TIsajet::UnForceID : \n");
+ printf ("No decays have been forced.\n");
+ return;
+ }
+
+ for (Int_t i = 0; i < FORCE.nforce; i++) {
+ if (FORCE.iforce[i] == particle_ID) {
+ UnForce(i, anti);
+ return;
+ }
+ }
+
+ printf ("Error in TIsajet::UnForceID : \n");
+ printf ("Cannot find particle %d.\n", particle_ID);
+}
+
+/**************************************************************************/
+
+Int_t* TIsajet::GetIFORCE(Int_t index) const
+{
+ if (FORCE.nforce == 0) {
+ printf ("Error in TIsajet::GetIFORCE : \n");
+ printf ("No decays have been forced.\n");
+ return 0;
+ }
+
+ if ((index < 0) || (index >= FORCE.nforce)) {
+ printf ("Error in TIsajet::GetIFORCE : \n");
+ printf ("Invalid decay index %d; range is 0-%d.\n", index, FORCE.nforce-1);
+ return 0;
+ }
+
+ Int_t decay[6];
+ decay[0] = FORCE.iforce[index];
+
+ for (Int_t i = 1; i < 6; i++) {
+ decay[i] = FORCE.mforce[index][i-1];
+ }
+
+ return decay;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetMEFORC(Int_t index) const
+{
+ if (FORCE.nforce == 0) {
+ printf ("Error in TIsajet::GetMEFORCE : \n");
+ printf ("No decays have been forced.\n");
+ return 0;
+ }
+
+ if ((index < 0) || (index >= FORCE.nforce)) {
+ printf ("Error in TIsajet::GetMEFORC : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, FORCE.nforce-1);
+ return 0;
+ }
+
+ return FORCE.meforc[index];
+}
+
+/**************************************************************************/
+
+// End of FORCE access.
+// Begins FRGPAR access.
+
+/**************************************************************************/
+
+void TIsajet::SetFRPAR(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetFRPAR : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ *FRGPAR.frpar[index] = val;
+ setFragment = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllFRPAR(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllFRPAR : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetFRPAR(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetFRPAR(Int_t index) const
+{
+ Int_t length = (sizeof FRGPAR.frpar / sizeof FRGPAR.frpar[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetFRPAR : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return *FRGPAR.frpar[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPUD(Float_t val)
+{
+ SetFRPAR(val, 0);
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPUD() const
+{
+ return GetFRPAR(0);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPBARY(Float_t val)
+{
+ SetFRPAR(val, 1);
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPBARY() const
+{
+ return GetFRPAR(1);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetSIGQT(Float_t val)
+{
+ SetFRPAR(val, 2);
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSIGQT() const
+{
+ return GetFRPAR(2);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPEND(Float_t val)
+{
+ SetFRPAR(val, 3);
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPEND() const
+{
+ return GetFRPAR(3);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXGEN(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetXGEN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+ SetFRPAR(val, index + 4);
+ setXgen = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllXGEN(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllXGEN : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetXGEN(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXGEN(Int_t index) const
+{
+ Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetXGEN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return GetFRPAR(index + 4);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPSPIN1(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPSPIN1 : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ SetFRPAR(val, index + 12);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPSPIN1(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof FRGPAR.pspin1 / sizeof FRGPAR.pspin1[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPSPIN1 : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPSPIN1(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPSPIN1(Int_t index) const
+{
+ Int_t length = (sizeof FRGPAR.xgen / sizeof FRGPAR.xgen[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPSPIN1 : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return GetFRPAR(index + 12);
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPMIX1(Float_t val, Int_t index1, Int_t index2)
+{
+ Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
+ Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::SetPMIX1 : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::SetPMIX1 : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return;
+ }
+
+ FRGPAR.pmix1[index1][index2] = val;
+ setFragment = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPMIX1(const Float_t val[2][3])
+{
+ for (Int_t i = 0; i < 2; i++) {
+ for (Int_t j = 0; j < 3; j++) {
+ SetPMIX1(val[i][j], i, j);
+ }
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::SetColumnPMIX1(const Float_t val[], Int_t col)
+{
+ Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
+ Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
+
+ if ((col < 0) || (col >= col_num)) {
+ printf ("Error in TIsajet::SetColumnPMIX1 : \n");
+ printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
+ return;
+ }
+
+ for (Int_t i = 0; i < row_num; i++) {
+ SetPMIX1(val[i], i, col);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPMIX1(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof FRGPAR.pmix1[0] / sizeof FRGPAR.pmix1[0][0]);
+ Int_t row_num = (sizeof FRGPAR.pmix1 / (sizeof FRGPAR.pmix1[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetPMIX1 : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetPMIX1 : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return FRGPAR.pmix1[index1][index2];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPMIX2(Float_t val, Int_t index1, Int_t index2)
+{
+ Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
+ Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::SetPMIX2 : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::SetPMIX2 : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return;
+ }
+
+ FRGPAR.pmix2[index1][index2] = val;
+ setFragment = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPMIX2(const Float_t val[2][3])
+{
+ for (Int_t i = 0; i < 2; i++) {
+ for (Int_t j = 0; j < 3; j++) {
+ SetPMIX2(val[i][j], i, j);
+ }
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::SetColumnPMIX2(const Float_t val[], Int_t col)
+{
+ Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
+ Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
+
+ if ((col < 0) || (col >= col_num)) {
+ printf ("Error in TIsajet::SetColumnPMIX2 : \n");
+ printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
+ return;
+ }
+
+ for (Int_t i = 0; i < row_num; i++) {
+ SetPMIX2(val[i], i, col);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPMIX2(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof FRGPAR.pmix2[0] / sizeof FRGPAR.pmix2[0][0]);
+ Int_t row_num = (sizeof FRGPAR.pmix2 / (sizeof FRGPAR.pmix2[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetPMIX2 : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetPMIX2 : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return FRGPAR.pmix2[index1][index2];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPMIXX1(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPMIXX1 : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ *FRGPAR.pmixx1[index] = val;
+ setFragment = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPMIXX1(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPMIXX1 : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPMIXX1(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPMIXX1(Int_t index) const
+{
+ Int_t length = (sizeof FRGPAR.pmixx1 / sizeof FRGPAR.pmixx1[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPMIXX1 : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return *FRGPAR.pmixx1[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPMIXX2(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPMIXX2 : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ *FRGPAR.pmixx2[index] = val;
+ setFragment = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPMIXX2(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPMIXX2 : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPMIXX2(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPMIXX2(Int_t index) const
+{
+ Int_t length = (sizeof FRGPAR.pmixx2 / sizeof FRGPAR.pmixx2[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPMIXX2 : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return *FRGPAR.pmixx2[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXGENSS(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetXGENSS : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ FRGPAR.xgenss[index] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllXGENSS(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllXGENSS : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetXGENSS(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXGENSS(Int_t index) const
+{
+ Int_t length = (sizeof FRGPAR.xgenss / sizeof FRGPAR.xgenss[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetXGENSS : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return FRGPAR.xgenss[index];
+}
+
+/**************************************************************************/
+
+// End of FRGPAR access.
+// Begins HCON access.
+
+/**************************************************************************/
+
+Float_t TIsajet::GetANWWWW(Int_t index1, Int_t index2, Int_t index3) const
+{
+ Int_t elem_Size = sizeof HCON.anwwww[0][0][0];
+ Int_t thd_Dim_Length = (sizeof HCON.anwwww[0][0] / elem_Size);
+ Int_t sec_Dim_Length = (sizeof HCON.anwwww[0] / (elem_Size * thd_Dim_Length));
+ Int_t fst_Dim_Length = (sizeof HCON.anwwww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
+
+ if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
+ printf ("Error in TIsajet::GetANWWWW : \n");
+ printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
+ printf ("Error in TIsajet::GetANWWWW : \n");
+ printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
+ printf ("Error in TIsajet::GetANWWWW : \n");
+ printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
+ return 0;
+ }
+
+ return HCON.anwwww[index1][index2][index3];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetADWWWW(Int_t index1, Int_t index2) const
+{
+ Int_t elem_Size = sizeof HCON.adwwww[0][0];
+ Int_t sec_Dim_Length = (sizeof HCON.adwwww[0] / elem_Size);
+ Int_t fst_Dim_Length = (sizeof HCON.adwwww / (elem_Size * sec_Dim_Length));
+
+ if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
+ printf ("Error in TIsajet::GetADWWWW : \n");
+ printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
+ printf ("Error in TIsajet::GetADWWWW : \n");
+ printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
+ return 0;
+ }
+
+ return HCON.adwwww[index1][index2];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAIWWWW(Int_t index) const
+{
+ Int_t length = (sizeof HCON.aiwwww / sizeof HCON.aiwwww[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetAIWWWW : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return HCON.aiwwww[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetHMASS() const
+{
+ return HCON.hmass;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetHGAM() const
+{
+ return HCON.hgam;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetHGAMS(Int_t index) const
+{
+ Int_t length = (sizeof HCON.hgams / sizeof HCON.hgams[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetHGAMS : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return HCON.hgams[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetETAHGG() const
+{
+ return HCON.etahgg;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetMATCHH(Int_t index) const
+{
+ Int_t length = (sizeof HCON.matchh / sizeof HCON.matchh[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetMATCHH : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return HCON.matchh[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetZSTARS(Int_t index1, Int_t index2) const
+{
+ Int_t elem_Size = sizeof HCON.zstars[0][0];
+ Int_t sec_Dim_Length = (sizeof HCON.zstars[0] / elem_Size);
+ Int_t fst_Dim_Length = (sizeof HCON.zstars / (elem_Size * sec_Dim_Length));
+
+ if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
+ printf ("Error in TIsajet::GetZSTARS : \n");
+ printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
+ printf ("Error in TIsajet::GetZSTARS : \n");
+ printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
+ return 0;
+ }
+
+ return HCON.zstars[index1][index2];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetIHTYPE(Int_t val)
+{
+ if ((val < 82) || (val > 84)) {
+ printf ("Error in TIsajet::SetIHTYPE : \n");
+ printf ("Invalid input value %d. Possible values are 82, 83, 84.\n", val);
+ return;
+ }
+
+ HCON.ihtype = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetIHTYPE(Char_t val[])
+{
+ if (!strcmp("HL0", val)) {
+ HCON.ihtype = 82;
+ }
+ else if (!strcmp("HH0", val)) {
+ HCON.ihtype = 83;
+ }
+ else if (!strcmp("HA0", val)){
+ HCON.ihtype = 84;
+ }
+ else {
+ printf ("Error in TIsajet::SetIHTYPE : \n");
+ printf ("Invalid input string %s. Possible strings are HL0, HH0, HA0.\n", val);
+ }
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetIHTYPE() const
+{
+ return HCON.ihtype;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetHGAMSS(Int_t index1, Int_t index2) const
+{
+ Int_t elem_Size = sizeof HCON.hgamss[0][0];
+ Int_t sec_Dim_Length = (sizeof HCON.hgamss[0] / elem_Size);
+ Int_t fst_Dim_Length = (sizeof HCON.hgamss / (elem_Size * sec_Dim_Length));
+
+ if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
+ printf ("Error in TIsajet::GetHGAMSS : \n");
+ printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
+ printf ("Error in TIsajet::GetHGAMSS : \n");
+ printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
+ return 0;
+ }
+
+ return HCON.hgamss[index1][index2];
+}
+
+/**************************************************************************/
+
+// End of HCON access
+// Begins JETLIM access
+
+/**************************************************************************/
+
+void TIsajet::SetPMIN(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val > JETLIM.pmax[index]) {
+ printf("Error in TIsajet::SetPMIN : \n");
+ printf("You may not set PMIN to a value larger than PMAX = %f.\n", JETLIM.pmax[index]);
+ return;
+ }
+
+ JETLIM.pmin[index] = val;
+ setP = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPMIN(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPMIN : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPMIN(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPMIN(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.pmin / sizeof JETLIM.pmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.pmin[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPMAX(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val < JETLIM.pmin[index]) {
+ printf("Error in TIsajet::SetPMAX : \n");
+ printf("You may not set PMAX to a value larger than PMIN = %f.\n", JETLIM.pmin[index]);
+ return;
+ }
+
+ JETLIM.pmax[index] = val;
+ setP = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPMAX(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPMAX : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPMAX(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPMAX(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.pmax / sizeof JETLIM.pmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.pmax[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPTMIN(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPTMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+/* andreas 7/8/2001
+ if (val > JETLIM.ptmax[index]) {
+ printf("Error in TIsajet::SetPTMIN : \n");
+ printf("You may not set PTMIN to a value larger than PTMAX = %f.\n", JETLIM.ptmax[index]);
+ return;
+ }
+*/
+ JETLIM.ptmin[index] = val;
+// if (!setY) SetYJLIMS();
+// if (!setTheta) SetTHLIMS();
+ setPt = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPTMIN(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPTMIN : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPTMIN(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPTMIN(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.ptmin / sizeof JETLIM.ptmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPTMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.ptmin[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPTMAX(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPTMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val < JETLIM.ptmin[index]) {
+ printf("Error in TIsajet::SetPTMAX : \n");
+ printf("You may not set PTMAX to a value larger than PTMIN = %f.\n", JETLIM.ptmin[index]);
+ return;
+ }
+
+ JETLIM.ptmax[index] = val;
+ setPt = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPTMAX(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPTMAX : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPTMAX(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPTMAX(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.ptmax / sizeof JETLIM.ptmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPTMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.ptmax[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetYJMIN(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetYJMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val > JETLIM.yjmax[index]) {
+ printf("Error in TIsajet::SetYJMIN : \n");
+ printf("You may not set YJMIN to a value larger than YJMAX = %f.\n", JETLIM.yjmax[index]);
+ return;
+ }
+
+ if (setTheta) {
+ printf("Error in TIsajet::SetYJMIN :\n");
+ printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMIN.\n");
+ return;
+ }
+
+ setY = true;
+ JETLIM.yjmin[index] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllYJMIN(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllYJMIN : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetYJMIN(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYJMIN(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.yjmin / sizeof JETLIM.yjmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetYJMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.yjmin[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetYJMAX(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetYJMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val < JETLIM.yjmin[index]) {
+ printf("Error in TIsajet::SetYJMAX : \n");
+ printf("You may not set YJMAX to a value larger than YJMIN = %f.\n", JETLIM.yjmin[index]);
+ return;
+ }
+
+ if (setTheta) {
+ printf("Error in TIsajet::SetYJMAX :\n");
+ printf("May not set both theta and y limits. Use SetTHLIMS, then set YJMAX.\n");
+ return;
+ }
+
+ setY = true;
+ JETLIM.yjmax[index] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllYJMAX(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllYJMAX : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetYJMAX(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYJMAX(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.yjmax / sizeof JETLIM.yjmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetYJMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.yjmax[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetYJLIMS()
+{
+ for (Int_t i = 0; i < JETLIM.mxlim; i++) {
+ JETLIM.yjmax[i] = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
+ JETLIM.yjmax[i] = -JETLIM.yjmin[i];
+ }
+ setY = false;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPHIMIN(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPHIMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val > JETLIM.phimax[index]) {
+ printf("Error in TIsajet::SetPHIMIN : \n");
+ printf("You may not set PHIMIN to a value larger than PHIMAX = %f.\n", JETLIM.phimax[index]);
+ return;
+ }
+
+ JETLIM.phimin[index] = val;
+ setPhi = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPHIMIN(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPHIMIN : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPHIMIN(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPHIMIN(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.phimin / sizeof JETLIM.phimin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPHIMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.phimin[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetPHIMAX(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetPHIMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val < JETLIM.phimin[index]) {
+ printf("Error in TIsajet::SetPHIMAX : \n");
+ printf("You may not set PHIMAX to a value larger than PHIMIN = %f.\n", JETLIM.phimin[index]);
+ return;
+ }
+
+ JETLIM.phimax[index] = val;
+ setPhi = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllPHIMAX(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllPHIMAX : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetPHIMAX(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPHIMAX(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.phimax / sizeof JETLIM.phimax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPHIMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.phimax[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXJMIN(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetXJMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+ if (val > JETLIM.xjmax[index]) {
+ printf("Error in TIsajet::SetXJMIN : \n");
+ printf("You may not set XJMIN to a value larger than XJMAX = %f.\n", JETLIM.xjmax[index]);
+ return;
+ }
+
+ JETLIM.xjmin[index] = val;
+ setX = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllXJMIN(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllXJMIN : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetXJMIN(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXJMIN(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.xjmin / sizeof JETLIM.xjmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetXJMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.xjmin[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXJMAX(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetXJMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val < JETLIM.xjmin[index]) {
+ printf("Error in TIsajet::SetXJMAX : \n");
+ printf("You may not set XJMAX to a value larger than XJMIN = %f.\n", JETLIM.xjmin[index]);
+ return;
+ }
+
+ JETLIM.xjmax[index] = val;
+ setX = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllXJMAX(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllXJMAX : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetXJMAX(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXJMAX(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.xjmax / sizeof JETLIM.xjmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetXJMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.xjmax[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTHMIN(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetTHMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val > JETLIM.thmax[index]) {
+ printf("Error in TIsajet::SetTHMIN : \n");
+ printf("You may not set THMIN to a value larger than THMAX = %f.\n", JETLIM.thmax[index]);
+ return;
+ }
+
+ if (setY) {
+ printf("Error in TIsajet::SetTHMIN :\n");
+ printf("May not set both theta and y limits. Use SetYJLIMS, then set THMIN.\n");
+ return;
+ }
+
+ setTheta = true;
+ JETLIM.thmin[index] = val;
+
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllTHMIN(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllTHMIN : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetTHMIN(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTHMIN(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.thmin / sizeof JETLIM.thmin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetTHMIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.thmin[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTHMAX(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetTHMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (val < JETLIM.thmin[index]) {
+ printf("Error in TIsajet::SetTHMAX : \n");
+ printf("You may not set THMAX to a value larger than THMIN = %f.\n", JETLIM.thmin[index]);
+ return;
+ }
+
+ if (setY) {
+ printf("Error in TIsajet::SetTHMAX :\n");
+ printf("May not set both theta and y limits. Use SetYJLIMS, then set THMAX.\n");
+ return;
+ }
+
+ setTheta = true;
+ JETLIM.thmax[index] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllTHMAX(const Float_t val[], Int_t arraySize)
+{
+ Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
+ if (arraySize != length) {
+ printf ("Error in TIsajet::SetAllTHMAX : \n");
+ printf ("Array must have %d elements.\n", length);
+ return;
+ }
+
+ for (Int_t i = 0; i < arraySize; i++) {
+ SetTHMAX(val[i], i);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTHMAX(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.thmax / sizeof JETLIM.thmax[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetTHMAX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.thmax[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTHLIMS()
+{
+ Float_t tmin;
+ for (Int_t i = 0; i < JETLIM.mxlim; i++) {
+ tmin = acosh(PRIMAR.halfe / JETLIM.ptmin[i]);
+ JETLIM.thmin[i] = 2*atan(exp(tmin));
+ JETLIM.thmax[i] = 2*atan(exp(-tmin));
+ }
+ setTheta = false;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetSETLMJ(Int_t index) const
+{
+ Int_t length = (sizeof JETLIM.setlmj / sizeof JETLIM.setlmj[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetSETLMJ : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETLIM.setlmj[index];
+}
+
+/**************************************************************************/
+
+// Ends JETLIM access.
+// Begins JETPAR access.
+
+/**************************************************************************/
+
+Float_t TIsajet::GetP(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.p / sizeof JETPAR.p[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.p[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPT(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.pt / sizeof JETPAR.pt[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPT : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.pt[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYJ(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.yj / sizeof JETPAR.yj[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetYJ : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.yj[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPHI(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.phi / sizeof JETPAR.phi[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPHI : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.phi[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXJ(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.xj / sizeof JETPAR.xj[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetXJ : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.xj[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTH(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.th / sizeof JETPAR.th[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetTH : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.th[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetCTH(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.cth / sizeof JETPAR.cth[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetCTH : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.cth[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSTH(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.sth / sizeof JETPAR.sth[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetSTH : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.sth[index];
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetJETTYP(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.jettyp / sizeof JETPAR.jettyp[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetJETTYP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.jettyp[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSHAT() const
+{
+ return JETPAR.shat;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTHAT() const
+{
+ return JETPAR.that;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetUHAT() const
+{
+ return JETPAR.uhat;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQSQ() const
+{
+ return JETPAR.qsq;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetX1() const
+{
+ return JETPAR.x1;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetX2() const
+{
+ return JETPAR.x2;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPBEAM(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.pbeam / sizeof JETPAR.pbeam[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPBEAM : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.pbeam[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQMW() const
+{
+ return JETPAR.qmw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQW() const
+{
+ return JETPAR.qw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQTW() const
+{
+ return JETPAR.qtw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYW() const
+{
+ return JETPAR.yw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXW() const
+{
+ return JETPAR.xw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTHW() const
+{
+ return JETPAR.thw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQTMW() const
+{
+ return JETPAR.qtmw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPHIW() const
+{
+ return JETPAR.phiw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSHAT1() const
+{
+ return JETPAR.shat1;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTHAT1() const
+{
+ return JETPAR.that1;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetUHAT1() const
+{
+ return JETPAR.uhat1;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetJWTYP(Int_t val)
+{
+ if ((val < 1) || (val > 4) || (val == 2))
+ {
+ printf ("Error in TIsajet::SetJWTYP : \n");
+ printf ("Invalid value %d; range is 1, 3, and 4.\n", val);
+ return;
+ }
+
+ JETPAR.jwtyp = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetJWTYP(Char_t val[])
+{
+ Int_t value;
+
+ if (!strcmp(val, "GM")) value = 1;
+ else if (!strcmp(val, "W+")) value = 3;
+ else if (!strcmp(val, "W-")) value = 3;
+ else if (!strcmp(val, "Z0")) value = 4;
+ else
+ {
+ printf ("Error in TIsajet::SetJWTYP : \n");
+ printf ("Invalid value %s; possible are GM, Z0, W+ and W-.\n", val);
+ return;
+ }
+
+
+ JETPAR.jwtyp = value;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetJWTYP() const
+{
+ return JETPAR.jwtyp;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetALFQSQ() const
+{
+ return JETPAR.alfqsq;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetCTHW() const
+{
+ return JETPAR.cthw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSTHW() const
+{
+ return JETPAR.sthw;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetQ0W() const
+{
+ return JETPAR.q0w;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetINITYP(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.inityp / sizeof JETPAR.inityp[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetINITYP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.inityp[index];
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetISIGS() const
+{
+ return JETPAR.isigs;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPBEAMS(Int_t index) const
+{
+ Int_t length = (sizeof JETPAR.pbeams / sizeof JETPAR.pbeams[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPBEAMS : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return JETPAR.pbeams[index];
+}
+
+/**************************************************************************/
+
+// Ends JETPAR access.
+// Begins KKGRAV access.
+
+/**************************************************************************/
+
+void TIsajet::SetNEXTRAD(Int_t val)
+{
+ KKGRAV.nextrad = val;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNEXTRAD() const
+{
+ return KKGRAV.nextrad;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetMASSD(Float_t val)
+{
+ KKGRAV.massd = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetMASSD() const
+{
+ return KKGRAV.massd;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetKKGSD() const
+{
+ return KKGRAV.kkgsd;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSURFD() const
+{
+ return KKGRAV.surfd;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetUVCUT(Bool_t val)
+{
+ KKGRAV.uvcut = val;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetUVCUT() const
+{
+ return KKGRAV.uvcut;
+}
+
+/**************************************************************************/
+
+// Ends KKGRAV access.
+// Begins MBGEN access.
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPOMWT(Int_t index) const
+{
+ Int_t length = (sizeof MBGEN.pomwt / sizeof MBGEN.pomwt[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPOMWT : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return MBGEN.pomwt[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPOMGEN(Int_t index) const
+{
+ Int_t length = (sizeof MBGEN.pomgen / sizeof MBGEN.pomgen[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPOMGEN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return MBGEN.pomgen[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetMNPOM(Int_t val)
+{
+ if (val > MBGEN.mxpom) {
+ printf("Error in TIsajet::SetMNPOM : \n");
+ printf("You may not set MNPOM to a value larger than MXPOM = %d.\n", MBGEN.mxpom);
+ return;
+ }
+
+ MBGEN.mnpom = val;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetMNPOM() const
+{
+ return MBGEN.mnpom;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetMXPOM(Int_t val)
+{
+ if (val < MBGEN.mnpom) {
+ printf("Error in TIsajet::SetMXPOM : \n");
+ printf("You may not set MXPOM to a value less than MNPOM = %d.\n", MBGEN.mnpom);
+ return;
+ }
+
+ MBGEN.mxpom = val;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetMXPOM() const
+{
+ return MBGEN.mxpom;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPDIFFR() const
+{
+ return MBGEN.pdiffr;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNPOM() const
+{
+ return MBGEN.npom;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXBARY(Int_t index) const
+{
+ Int_t length = (sizeof MBGEN.xbary / sizeof MBGEN.xbary[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetXBARY : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return MBGEN.xbary[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetDXBARY(Int_t index) const
+{
+ Int_t length = (sizeof MBGEN.dxbary / sizeof MBGEN.dxbary[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetDXBARY : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return MBGEN.dxbary[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXPOM(Int_t index1, Int_t index2) const
+{
+ Int_t elem_Size = sizeof MBGEN.xpom[0][0];
+ Int_t sec_Dim_Length = (sizeof MBGEN.xpom[0] / elem_Size);
+ Int_t fst_Dim_Length = (sizeof MBGEN.xpom / (elem_Size * sec_Dim_Length));
+
+ if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
+ printf ("Error in TIsajet::GetXPOM : \n");
+ printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
+ printf ("Error in TIsajet::GetXPOM : \n");
+ printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
+ return 0;
+ }
+
+ return MBGEN.xpom[index1][index2];
+}
+
+/**************************************************************************/
+
+// Ends MBGEN access.
+// Begins MGLIMS access.
+
+/**************************************************************************/
+
+void TIsajet::SetEHMGMN(Float_t val)
+{
+ if (val > MGLIMS.ehmgmx) {
+ printf("Error in TIsajet::SetEHMGMN : \n");
+ printf("You may not set EHMGMN to a value larger than EHMGMX = %f.\n", MGLIMS.ehmgmx);
+ return;
+ }
+
+ MGLIMS.ehmgmn = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetEHMGMN() const
+{
+ return MGLIMS.ehmgmn;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetEHMGMX(Float_t val)
+{
+ if (val < MGLIMS.ehmgmn) {
+ printf("Error in TIsajet::SetEHMGMX : \n");
+ printf("You may not set EHMGMX to a value less than EHMGMN = %f.\n", MGLIMS.ehmgmn);
+ return;
+ }
+
+ MGLIMS.ehmgmx = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetEHMGMX() const
+{
+ return MGLIMS.ehmgmx;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYHMGMN() const
+{
+ return MGLIMS.yhmgmn;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYHMGMX() const
+{
+ return MGLIMS.yhmgmx;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAMIJMN(Float_t val, Int_t index1, Int_t index2)
+{
+ Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
+ Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::SetAMIJMN : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::SetAMIJMN : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return;
+ }
+
+ if (val > MGLIMS.amijmx[index1][index2]) {
+ printf("Error in TIsajet::SetAMIJMN : \n");
+ printf("You may not set AMIJMN to a value larger than AMIJMX = %f.\n", MGLIMS.amijmx[index1][index2]);
+ return;
+ }
+
+ MGLIMS.amijmn[index1][index2] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllAMIJMN(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
+{
+ for (Int_t i = 0; i < 2; i++) {
+ for (Int_t j = 0; j < 3; j++) {
+ SetAMIJMN(val[i][j], i, j);
+ }
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::SetColumnAMIJMN(const Float_t val[], Int_t col)
+{
+ Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
+ Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
+
+ if ((col < 0) || (col >= col_num)) {
+ printf ("Error in TIsajet::SetColumnAMIJMN : \n");
+ printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
+ return;
+ }
+
+ for (Int_t i = 0; i < row_num; i++) {
+ SetAMIJMN(val[i], i, col);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAMIJMN(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof MGLIMS.amijmn[0] / sizeof MGLIMS.amijmn[0][0]);
+ Int_t row_num = (sizeof MGLIMS.amijmn / (sizeof MGLIMS.amijmn[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetAMIJMN : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetAMIJMN : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return MGLIMS.amijmn[index1][index2];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAMIJMX(Float_t val, Int_t index1, Int_t index2)
+{
+ Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
+ Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::SetAMIJMX : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::SetAMIJMX : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return;
+ }
+
+ if (val < MGLIMS.amijmn[index1][index2]) {
+ printf("Error in TIsajet::SetAMIJMX : \n");
+ printf("You may not set AMIJMX to a value less than AMIJMN = %f.\n", MGLIMS.amijmn[index1][index2]);
+ return;
+ }
+
+ MGLIMS.amijmx[index1][index2] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllAMIJMX(const Float_t val[MGLIMS.mxlim][MGLIMS.mxlim])
+{
+ for (Int_t i = 0; i < 2; i++) {
+ for (Int_t j = 0; j < 3; j++) {
+ SetAMIJMX(val[i][j], i, j);
+ }
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::SetColumnAMIJMX(const Float_t val[], Int_t col)
+{
+ Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
+ Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
+
+ if ((col < 0) || (col >= col_num)) {
+ printf ("Error in TIsajet::SetColumnAMIJMX : \n");
+ printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
+ return;
+ }
+
+ for (Int_t i = 0; i < row_num; i++) {
+ SetAMIJMX(val[i], i, col);
+ }
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAMIJMX(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof MGLIMS.amijmx[0] / sizeof MGLIMS.amijmx[0][0]);
+ Int_t row_num = (sizeof MGLIMS.amijmx / (sizeof MGLIMS.amijmx[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetAMIJMX : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetAMIJMX : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return MGLIMS.amijmx[index1][index2];
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetFIXMIJ(Int_t index1, Int_t index2) const
+{
+ Int_t elem_Size = sizeof MGLIMS.fixmij[0][0];
+ Int_t sec_Dim_Length = (sizeof MGLIMS.fixmij[0] / elem_Size);
+ Int_t fst_Dim_Length = (sizeof MGLIMS.fixmij / (elem_Size * sec_Dim_Length));
+
+ if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
+ printf ("Error in TIsajet::GetFIXMIJ : \n");
+ printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
+ printf ("Error in TIsajet::GetFIXMIJ : \n");
+ printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
+ return 0;
+ }
+
+ return MGLIMS.fixmij[index1][index2];
+}
+
+/**************************************************************************/
+
+// Ends MGLIMS access.
+// Begins NODCAY access.
+
+/**************************************************************************/
+
+void TIsajet::SetNODCAY(Bool_t val)
+{
+ NODCAY.nodcay = val;
+ setNodcay = true;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetNODCAY() const
+{
+ return NODCAY.nodcay;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNOETA(Bool_t val)
+{
+ NODCAY.noeta = val;
+ setNoeta = true;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetNOETA() const
+{
+ return NODCAY.noeta;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNOPI0(Bool_t val)
+{
+ NODCAY.nopi0 = val;
+ setNopi0 = true;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetNOPI0() const
+{
+ return NODCAY.nopi0;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNONUNU(Bool_t val)
+{
+ NODCAY.nonunu = val;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetNONUNU() const
+{
+ return NODCAY.nonunu;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNOEVOL(Bool_t val)
+{
+ NODCAY.noevol = val;
+ setNoevolve = true;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetNOEVOL() const
+{
+ return NODCAY.noevol;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNOHADR(Bool_t val)
+{
+ NODCAY.nohadr = val;
+ setNohadron = true;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetNOHADR() const
+{
+ return NODCAY.nohadr;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNOGRAV(Bool_t val)
+{
+ NODCAY.nograv = val;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetNOGRAV() const
+{
+ return NODCAY.nograv;
+}
+
+/**************************************************************************/
+
+// Ends NODCAY access.
+// Begins PARTCL access.
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNPTCL() const
+{
+ return PARTCL.nptcl;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPX(Int_t index) const
+{
+ if ((index < 0) || (index >= PARTCL.nptcl)) {
+ printf ("Error in TIsajet::GetPX : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
+ return 0;
+ }
+
+ return PARTCL.pptcl[index][0];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPY(Int_t index) const
+{
+ if ((index < 0) || (index >= PARTCL.nptcl)) {
+ printf ("Error in TIsajet::GetPY : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
+ return 0;
+ }
+
+ return PARTCL.pptcl[index][1];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetPZ(Int_t index) const
+{
+ if ((index < 0) || (index >= PARTCL.nptcl)) {
+ printf ("Error in TIsajet::GetPZ : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
+ return 0;
+ }
+
+ return PARTCL.pptcl[index][2];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetP0(Int_t index) const
+{
+ if ((index < 0) || (index >= PARTCL.nptcl)) {
+ printf ("Error in TIsajet::GetP0 : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
+ return 0;
+ }
+
+ return PARTCL.pptcl[index][3];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetMASS(Int_t index) const
+{
+ if ((index < 0) || (index >= PARTCL.nptcl)) {
+ printf ("Error in TIsajet::GetMASS : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
+ return 0;
+ }
+
+ return PARTCL.pptcl[index][4];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetORIG(Int_t index) const
+{
+ if ((index < 0) || (index >= PARTCL.nptcl)) {
+ printf ("Error in TIsajet::GetORIG : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
+ return 0;
+ }
+
+ return PARTCL.iorig[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetIDENT(Int_t index) const
+{
+ if ((index < 0) || (index >= PARTCL.nptcl)) {
+ printf ("Error in TIsajet::GetIDENT : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
+ return 0;
+ }
+
+ return PARTCL.ident[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetIDCAY(Int_t index) const
+{
+ if ((index < 0) || (index >= PARTCL.nptcl)) {
+ printf ("Error in TIsajet::GetIDCAY : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, PARTCL.nptcl-1);
+ return 0;
+ }
+
+ return PARTCL.idcay[index];
+}
+
+/**************************************************************************/
+
+// Ends PARTCL access.
+// Begins PRIMAR access.
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNJET() const
+{
+ return PRIMAR.njet;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSCM() const
+{
+ return PRIMAR.scm;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetHALFE() const
+{
+ return PRIMAR.halfe;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetECM(Float_t val)
+{
+ if (val < 0) {
+ printf ("Error in TIsajet::SetECM :\n");
+ printf ("Cannot set energy to a negative value.\n");
+ return;
+ }
+
+ PRIMAR.ecm = val;
+ PRIMAR.scm = val*val;
+ PRIMAR.halfe = val / 2;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetECM() const
+{
+ return PRIMAR.ecm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetIDIN(Int_t val, Int_t index)
+{
+ Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetIDIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if ((val = 1120) || (val = 1220) || (val = -1120) || (val = -1220)) {
+ PRIMAR.idin[index] = val;
+ }
+ else {
+ printf ("Error in TIsajet::SetIDIN : \n");
+ printf ("Invalid input value %d. Possible values are 1120, 1220, -1120, -1220.\n", val);
+ return;
+ }
+
+ setBeams = true;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetIDIN(const Char_t val[], Int_t index)
+{
+ Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetIDIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (!strcmp("P", val)) {
+ PRIMAR.idin[index] = 1120;
+ }
+ else if (!strcmp("AP", val)) {
+ PRIMAR.idin[index] = -1120;
+ }
+ else if (!strcmp("N", val)) {
+ PRIMAR.idin[index] = 1220;
+ }
+ else if (!strcmp("AN", val)) {
+ PRIMAR.idin[index] = -1220;
+ }
+ else {
+ printf ("Error in TIsajet::SetIDIN : \n");
+ printf ("Invalid input string %s. Possible strings are P, AP, N, and AN.\n", val);
+ return;
+ }
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetIDIN(Int_t index) const
+{
+ Int_t length = (sizeof PRIMAR.idin / sizeof PRIMAR.idin[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetIDIN : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return PRIMAR.idin[index];
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNEVENT() const
+{
+ return PRIMAR.nevent;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNTRIES(Int_t val)
+{
+ PRIMAR.ntries = val;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNTRIES() const
+{
+ return PRIMAR.ntries;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNSIGMA(Int_t val)
+{
+ PRIMAR.nsigma = val;
+ setNsigma = true;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNSIGMA() const
+{
+ return PRIMAR.nsigma;
+}
+
+/**************************************************************************/
+
+// Ends PRIMAR access.
+// Begins QCDPAR access.
+
+/**************************************************************************/
+
+void TIsajet::SetALAM(Float_t val)
+{
+ QCDPAR.alam = val;
+ QCDPAR.alam2 = val*val;
+ setLambda = true;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetALAM() const
+{
+ return QCDPAR.alam;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetALAM2() const
+{
+ return QCDPAR.alam2;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetCUTJET(Float_t val)
+{
+ QCDPAR.cutjet = val;
+ setCutjet = true;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetCUTJET() const
+{
+ return QCDPAR.cutjet;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetISTRUC(Int_t val)
+{
+ if ((val < 1) || (val > 6)) {
+ printf ("Error in TIsajet::SetISTRUC : \n");
+ printf ("Invalid input value %d. Possible values are 1 through 6.\n", val);
+ return;
+ }
+ QCDPAR.istruc = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetISTRUC(const Char_t val[])
+{
+ if (!strcmp("OWENS", val)) {
+ QCDPAR.istruc = 1;
+ }
+ else if (!strcmp("BAIER", val)) {
+ QCDPAR.istruc = 2;
+ }
+ else if ((!strcmp("EICHTEN", val)) || (!strcmp("EHLQ", val))) {
+ QCDPAR.istruc = 3;
+ }
+ else if ((!strcmp("DUKE", val)) || (!strcmp("DO", val))) {
+ QCDPAR.istruc = 4;
+ }
+ else if (!strcmp("CTEQ2L", val)) {
+ QCDPAR.istruc = 5;
+ }
+ else if ((!strcmp("CTEQ", val)) || (!strcmp("CTEQ3L", val))) {
+ QCDPAR.istruc = 6;
+ }
+ else {
+ printf ("Error in TIsajet::SetISTRUC : \n");
+ printf ("Invalid input string %s. Possible strings are OWENS, BAIER, EICHTEN, \n", val);
+ printf ("EHLQ, DUKE, DO, CTEQ2L, CTEQ, and CTEQ3L.\n");
+ return;
+ }
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetISTRUC() const
+{
+ return QCDPAR.istruc;
+}
+
+/**************************************************************************/
+
+// Ends QCDPAR access.
+// Begins QLMASS access.
+
+/**************************************************************************/
+
+void TIsajet::SetAMLEP(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetAMLEP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ if (((index < 5) && (index > 7)) &&
+ ((index < 21) && (index > 26)) &&
+ ((index < 29) && (index > 36)) &&
+ ((index < 39) && (index > 40)) &&
+ ((index < 63) && (index > 71)))
+ {
+ printf ("Error in TIsajet::SetAMLEP : \n");
+ printf ("Index %d may not be set by the user. Valid indices are : \n", index);
+ printf ("5-7, 21-26, 29-36, 39-40 and 63-71.\n");
+ return;
+ }
+
+ QLMASS.amlep[index] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAMLEP(Int_t index) const
+{
+ Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetAMLEP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+ if ((index < 5) || (index > 71) ||
+ ((index > 7) && (index < 21)) ||
+ ((index > 26) && (index < 29)) ||
+ ((index > 36) && (index < 39)) ||
+ ((index > 40) && (index < 63)))
+ {
+ printf ("Possible error in TIsajet::GetAMLEP : \n");
+ printf ("Index %d may not be set by the user. Valid indices are : \n", index);
+ printf ("5-7, 21-26, 29-36, 39-40 and 63-71. \n");
+ printf ("To return the value of this index, use GetAnyAMLEP(Int_t index).\n");
+ return 0;
+ }
+
+
+ return QLMASS.amlep[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAnyAMLEP(Int_t index) const
+{
+ Int_t length = (sizeof QLMASS.amlep / sizeof QLMASS.amlep[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetAnyAMLEP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return QLMASS.amlep[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTquarkMass(Float_t val)
+{
+ QLMASS.amlep[5] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTquarkMass() const
+{
+ return QLMASS.amlep[5];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXquarkMass(Float_t val)
+{
+ QLMASS.amlep[6] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXquarkMass() const
+{
+ return QLMASS.amlep[6];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetYquarkMass(Float_t val)
+{
+ QLMASS.amlep[7] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetYquarkMass() const
+{
+ return QLMASS.amlep[7];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetUtildeMass(Float_t val)
+{
+ QLMASS.amlep[21] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetUtildeMass() const
+{
+ return QLMASS.amlep[21];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetDtildeMass(Float_t val)
+{
+ QLMASS.amlep[22] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetDtildeMass() const
+{
+ return QLMASS.amlep[22];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetStildeMass(Float_t val)
+{
+ QLMASS.amlep[23] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetStildeMass() const
+{
+ return QLMASS.amlep[23];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetCtildeMass(Float_t val)
+{
+ QLMASS.amlep[24] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetCtildeMass() const
+{
+ return QLMASS.amlep[24];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetBtildeMass(Float_t val)
+{
+ QLMASS.amlep[25] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetBtildeMass() const
+{
+ return QLMASS.amlep[25];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTtildeMass(Float_t val)
+{
+ QLMASS.amlep[26] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTtildeMass() const
+{
+ return QLMASS.amlep[26];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetGtildeMass(Float_t val)
+{
+ QLMASS.amlep[29] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetGtildeMass() const
+{
+ return QLMASS.amlep[29];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetGammatildeMass(Float_t val)
+{
+ QLMASS.amlep[30] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetGammatildeMass() const
+{
+ return QLMASS.amlep[30];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNuEtildeMass(Float_t val)
+{
+ QLMASS.amlep[31] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetNuEtildeMass() const
+{
+ return QLMASS.amlep[31];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetEtildeMass(Float_t val)
+{
+ QLMASS.amlep[32] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetEtildeMass() const
+{
+ return QLMASS.amlep[32];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNuMutildeMass(Float_t val)
+{
+ QLMASS.amlep[33] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetNuMutildeMass() const
+{
+ return QLMASS.amlep[33];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetMutildeMass(Float_t val)
+{
+ QLMASS.amlep[34] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetMutildeMass() const
+{
+ return QLMASS.amlep[34];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetNuTautildeMass(Float_t val)
+{
+ QLMASS.amlep[35] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetNuTautildeMass() const
+{
+ return QLMASS.amlep[35];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTautildeMass(Float_t val)
+{
+ QLMASS.amlep[36] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTautildeMass() const
+{
+ return QLMASS.amlep[36];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetWplustildeMass(Float_t val)
+{
+ QLMASS.amlep[39] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetWplustildeMass() const
+{
+ return QLMASS.amlep[39];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetZ0tildeMass(Float_t val)
+{
+ QLMASS.amlep[40] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetZ0tildeMass() const
+{
+ return QLMASS.amlep[40];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetHiggsMesonMass(Float_t val, Int_t index)
+{
+ if ((index < 1) || (index > 9)) {
+ printf ("Error in TIsajet::SetHiggsMesonMass : \n");
+ printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
+ return;
+ }
+
+ QLMASS.amlep[62 + index] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetHiggsMesonMass(Int_t index) const
+{
+ if ((index < 1) || (index > 9)) {
+ printf ("Error in TIsajet::GetHiggsMesonMass : \n");
+ printf ("Invalid Higgs meson number index %d; range is 1-9.\n", index);
+ return 0;
+ }
+
+ return QLMASS.amlep[62 + index];
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNQLEP() const
+{
+ return QLMASS.nqlep;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNMES() const
+{
+ return QLMASS.nmes;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNBARY() const
+{
+ return QLMASS.nbary;
+}
+
+/**************************************************************************/
+
+// Ends QLMASS access.
+// Begins SEED access.
+
+/**************************************************************************/
+
+void TIsajet::SetSEED(const Char_t val[24])
+{
+ Int_t length = (sizeof SEED.xseed / sizeof SEED.xseed[0]);
+
+ for (Int_t i = 0; i < length; i++) {
+ SEED.xseed[i] = val[i];
+ }
+}
+
+/**************************************************************************/
+
+Char_t* TIsajet::GetSEED() const
+{
+ return SEED.xseed;
+}
+
+/**************************************************************************/
+
+// Ends SEED access - short and sweet, wasn't it?
+// Begins SUGNU access, an entirely different business.
+
+/**************************************************************************/
+
+void TIsajet::SetXNUSUG(Float_t val, Int_t index)
+{
+ Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::SetXNUSUG : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return;
+ }
+
+ SUGNU.xnusug[index] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXNUSUG(Int_t index) const
+{
+ Int_t length = (sizeof SUGNU.xnusug / sizeof SUGNU.xnusug[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetXNUSUG : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return SUGNU.xnusug[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetGauginoMass(Float_t val, Int_t index)
+{
+ if ((index < 1) || (index > 9)) {
+ printf ("Error in TIsajet::SetGauginoMass : \n");
+ printf ("Invalid gaugino number %d; range is 1-3.\n", index);
+ return;
+ }
+
+ SUGNU.xnusug[index-1] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetGauginoMass(Int_t index) const
+{
+ if ((index < 1) || (index > 3)) {
+ printf ("Error in TIsajet::GetGauginoMass : \n");
+ printf ("Invalid gaugino number %d; range is 1-3.\n", index);
+ return 0;
+ }
+
+ return SUGNU.xnusug[index-1];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAtau(Float_t val)
+{
+ SUGNU.xnusug[3] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAtau() const
+{
+ return SUGNU.xnusug[3];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAb(Float_t val)
+{
+ SUGNU.xnusug[4] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAb() const
+{
+ return SUGNU.xnusug[4];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAt(Float_t val)
+{
+ SUGNU.xnusug[5] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAt() const
+{
+ return SUGNU.xnusug[5];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetHiggsDmass(Float_t val)
+{
+ SUGNU.xnusug[6] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetHiggsDmass() const
+{
+ return SUGNU.xnusug[6];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetHiggsUmass(Float_t val)
+{
+ SUGNU.xnusug[7] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetHiggsUmass() const
+{
+ return SUGNU.xnusug[7];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetERmass(Float_t val)
+{
+ SUGNU.xnusug[8] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetERmass() const
+{
+ return SUGNU.xnusug[8];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetELmass(Float_t val)
+{
+ SUGNU.xnusug[9] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetELmass() const
+{
+ return SUGNU.xnusug[9];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetDRmass(Float_t val)
+{
+ SUGNU.xnusug[10] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetDRmass() const
+{
+ return SUGNU.xnusug[10];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetURmass(Float_t val)
+{
+ SUGNU.xnusug[11] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetURmass() const
+{
+ return SUGNU.xnusug[11];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetULmass(Float_t val)
+{
+ SUGNU.xnusug[12] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetULmass() const
+{
+ return SUGNU.xnusug[12];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTauRmass(Float_t val)
+{
+ SUGNU.xnusug[13] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTauRmass() const
+{
+ return SUGNU.xnusug[13];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTauLmass(Float_t val)
+{
+ SUGNU.xnusug[14] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTauLmass() const
+{
+ return SUGNU.xnusug[14];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetBRmass(Float_t val)
+{
+ SUGNU.xnusug[15] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetBRmass() const
+{
+ return SUGNU.xnusug[15];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTRmass(Float_t val)
+{
+ SUGNU.xnusug[16] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTRmass() const
+{
+ return SUGNU.xnusug[16];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTLmass(Float_t val)
+{
+ SUGNU.xnusug[17] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTLmass() const
+{
+ return SUGNU.xnusug[17];
+}
+
+/**************************************************************************/
+
+// Ends XNUSUG access.
+// Begins TCPAR access.
+
+/**************************************************************************/
+
+void TIsajet::SetTCMRHO(Float_t val)
+{
+ TCPAR.tcmrho = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTCMRHO() const
+{
+ return TCPAR.tcmrho;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTCGRHO(Float_t val)
+{
+ TCPAR.tcgrho = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTCGRHO() const
+{
+ return TCPAR.tcgrho;
+}
+
+/**************************************************************************/
+
+// Ends TCPAR access.
+// Begins TYPES access.
+
+/**************************************************************************/
+
+Int_t TIsajet::GetLOC(Int_t index) const
+{
+ Int_t length = (sizeof TYPES.loc / sizeof TYPES.loc[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetLOC : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return TYPES.loc[index];
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNTYP() const
+{
+ return TYPES.ntyp;
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNJTTYP(Int_t index) const
+{
+ Int_t length = (sizeof TYPES.njttyp / sizeof TYPES.njttyp[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetNJTYP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return TYPES.njttyp[index];
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNWWTYP(Int_t index) const
+{
+ Int_t length = (sizeof TYPES.nwwtyp / sizeof TYPES.nwwtyp[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetNWWTYP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return TYPES.nwwtyp[index];
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetNWMODE(Int_t index) const
+{
+ Int_t length = (sizeof TYPES.nwmode / sizeof TYPES.nwmode[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetNWMODE : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return TYPES.nwmode[index];
+}
+
+/**************************************************************************/
+
+// Ends TYPES access.
+// Begins XMSSM access.
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetGOMSSM() const
+{
+ return XMSSM.gomssm;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetGOSUG() const
+{
+ return XMSSM.gosug;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetGOGMSB() const
+{
+ return XMSSM.gogmsb;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetGOAMSB() const
+{
+ return XMSSM.goamsb;
+}
+
+/**************************************************************************/
+
+Bool_t TIsajet::GetAL3UNI() const
+{
+ return XMSSM.al3uni;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXGLSS(Float_t val)
+{
+ XMSSM.xglss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXGLSS() const
+{
+ return XMSSM.xglss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXMUSS(Float_t val)
+{
+ XMSSM.xmuss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXMUSS() const
+{
+ return XMSSM.xmuss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXHASS(Float_t val)
+{
+ XMSSM.xhass = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXHASS() const
+{
+ return XMSSM.xhass;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXTBSS(Float_t val)
+{
+ XMSSM.xtbss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXTBSS() const
+{
+ return XMSSM.xtbss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXQ1SS(Float_t val)
+{
+ XMSSM.xq1ss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXQ1SS() const
+{
+ return XMSSM.xq1ss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXDRSS(Float_t val)
+{
+ XMSSM.xdrss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXDRSS() const
+{
+ return XMSSM.xdrss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXURSS(Float_t val)
+{
+ XMSSM.xurss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXURSS() const
+{
+ return XMSSM.xurss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXL1SS(Float_t val)
+{
+ XMSSM.xl1ss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXL1SS() const
+{
+ return XMSSM.xl1ss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXERSS(Float_t val)
+{
+ XMSSM.xerss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXERSS() const
+{
+ return XMSSM.xerss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXQ2SS(Float_t val)
+{
+ XMSSM.xq2ss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXQ2SS() const
+{
+ return XMSSM.xq2ss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXSRSS(Float_t val)
+{
+ XMSSM.xsrss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXSRSS() const
+{
+ return XMSSM.xsrss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXCRSS(Float_t val)
+{
+ XMSSM.xcrss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXCRSS() const
+{
+ return XMSSM.xcrss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXL2SS(Float_t val)
+{
+ XMSSM.xl2ss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXL2SS() const
+{
+ return XMSSM.xl2ss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXMRSS(Float_t val)
+{
+ XMSSM.xmrss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXMRSS() const
+{
+ return XMSSM.xmrss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXQ3SS(Float_t val)
+{
+ XMSSM.xq3ss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXQ3SS() const
+{
+ return XMSSM.xq3ss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXBRSS(Float_t val)
+{
+ XMSSM.xbrss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXBRSS() const
+{
+ return XMSSM.xbrss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXTRSS(Float_t val)
+{
+ XMSSM.xtrss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXTRSS() const
+{
+ return XMSSM.xtrss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXL3SS(Float_t val)
+{
+ XMSSM.xl3ss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXL3SS() const
+{
+ return XMSSM.xl3ss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXTARSS(Float_t val)
+{
+ XMSSM.xtarss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXTARSS() const
+{
+ return XMSSM.xtarss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXATSS(Float_t val)
+{
+ XMSSM.xatss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXATSS() const
+{
+ return XMSSM.xatss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXABSS(Float_t val)
+{
+ XMSSM.xabss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXABSS() const
+{
+ return XMSSM.xabss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXATASS(Float_t val)
+{
+ XMSSM.xatass = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXATASS() const
+{
+ return XMSSM.xatass;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXM1SS(Float_t val)
+{
+ XMSSM.xm1ss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXM1SS() const
+{
+ return XMSSM.xm1ss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXM2SS(Float_t val)
+{
+ XMSSM.xm2ss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXM2SS() const
+{
+ return XMSSM.xm2ss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXM0SU(Float_t val)
+{
+ XMSSM.xm0su = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXM0SU() const
+{
+ return XMSSM.xm0su;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXMHSU(Float_t val)
+{
+ XMSSM.xmhsu = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXMHSU() const
+{
+ return XMSSM.xmhsu;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXA0SU(Float_t val)
+{
+ XMSSM.xa0su = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXA0SU() const
+{
+ return XMSSM.xa0su;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXTGBSU(Float_t val)
+{
+ XMSSM.xtgbsu = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXTGBSU() const
+{
+ return XMSSM.xtgbsu;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXSMUSU(Float_t val)
+{
+ XMSSM.xsmusu = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXSMUSU() const
+{
+ return XMSSM.xsmusu;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXLAMGM(Float_t val)
+{
+ XMSSM.xlamgm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXLAMGM() const
+{
+ return XMSSM.xlamgm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXMESGM(Float_t val)
+{
+ XMSSM.xmesgm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXMESGM() const
+{
+ return XMSSM.xmesgm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXN5GM(Float_t val)
+{
+ XMSSM.xn5gm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXN5GM() const
+{
+ return XMSSM.xn5gm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXCMGV(Float_t val)
+{
+ XMSSM.xcmgv = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXCMGV() const
+{
+ return XMSSM.xcmgv;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetMGVTO(Float_t val)
+{
+ XMSSM.mgvto = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetMGVTO() const
+{
+ return XMSSM.mgvto;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXRSLGM(Float_t val)
+{
+ XMSSM.xrslgm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXRSLGM() const
+{
+ return XMSSM.xrslgm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXDHDGM(Float_t val)
+{
+ XMSSM.xdhdgm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXDHDGM() const
+{
+ return XMSSM.xdhdgm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXDHUGM(Float_t val)
+{
+ XMSSM.xdhugm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXDHUGM() const
+{
+ return XMSSM.xdhugm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXDYGM(Float_t val)
+{
+ XMSSM.xdygm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXDYGM() const
+{
+ return XMSSM.xdygm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXN51GM(Float_t val)
+{
+ XMSSM.xn51gm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXN51GM() const
+{
+ return XMSSM.xn51gm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXN52GM(Float_t val)
+{
+ XMSSM.xn52gm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXN52GM() const
+{
+ return XMSSM.xn52gm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXN53GM(Float_t val)
+{
+ XMSSM.xn53gm = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXN53GM() const
+{
+ return XMSSM.xn53gm;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXMN3NR(Float_t val)
+{
+ XMSSM.xmn3nr = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXMN3NR() const
+{
+ return XMSSM.xmn3nr;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXMAJNR(Float_t val)
+{
+ XMSSM.xmajnr = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXMAJNR() const
+{
+ return XMSSM.xmajnr;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXANSS(Float_t val)
+{
+ XMSSM.xanss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXANSS() const
+{
+ return XMSSM.xanss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXNRSS(Float_t val)
+{
+ XMSSM.xnrss = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXNRSS() const
+{
+ return XMSSM.xnrss;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetXSBCS(Float_t val)
+{
+ XMSSM.xsbcs = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetXSBCS() const
+{
+ return XMSSM.xsbcs;
+}
+
+/**************************************************************************/
+
+// Ends XMSSM access.
+// Begins XTYPES access.
+
+/**************************************************************************/
+
+Char_t* TIsajet::GetPARTYP(Int_t index) const
+{
+ Int_t length = (sizeof XTYPES.partyp / sizeof XTYPES.partyp[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetPARTYP : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return XTYPES.partyp[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetTITLE(Char_t *val)
+{
+ title = XTYPES.title = val;
+}
+
+/**************************************************************************/
+Char_t* TIsajet::GetTITLE() const
+{
+ return XTYPES.title;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetJETYP(Int_t index, Char_t val[])
+{
+ Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
+ Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
+
+ if ((index < 0) || (index >= row_num)) {
+ printf ("Error in TIsajet::SetJETYP : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index, row_num-1);
+ return;
+ }
+
+ if (TYPES.njttyp[index] >= col_num) {
+ printf ("Error in TIsajet::SetJETYP : \n");
+ printf ("Cannot set more than %d jet types.\n", col_num-1);
+ return;
+ }
+
+ if ((!strcmp(val, "ALL")) || (!strcmp(val, "GL")) ||
+ (!strcmp(val, "UP")) || (!strcmp(val, "UB")) ||
+ (!strcmp(val, "DN")) || (!strcmp(val, "DB")) ||
+ (!strcmp(val, "ST")) || (!strcmp(val, "SB")) ||
+ (!strcmp(val, "CH")) || (!strcmp(val, "CB")) ||
+ (!strcmp(val, "BT")) || (!strcmp(val, "BB")) ||
+ (!strcmp(val, "TP")) || (!strcmp(val, "TB")) ||
+ (!strcmp(val, "X")) || (!strcmp(val, "XB")) ||
+ (!strcmp(val, "Y")) || (!strcmp(val, "YB")) ||
+ (!strcmp(val, "E-")) || (!strcmp(val, "E+")) ||
+ (!strcmp(val, "MU-")) || (!strcmp(val, "MU+")) ||
+ (!strcmp(val, "TAU-")) || (!strcmp(val, "TAU+")) ||
+ (!strcmp(val, "NUS")) || (!strcmp(val, "GM")) ||
+ (!strcmp(val, "W+")) || (!strcmp(val, "W-")) ||
+ (!strcmp(val, "Z0"))) {
+
+ XTYPES.jetyp[index][TYPES.njttyp[index]++] = val;
+ }
+ else {
+ printf ("Error in TIsajet::SetJETYP : \n");
+ printf ("Invalid jet type %s; valid types are\n", val);
+ printf ("ALL, GL, UP, UB, DN, DB, ST, SB,\n");
+ printf ("CH, CB, BT, BB, TP, TB, X, XB, Y, YB,\n");
+ printf ("E-, E+, MU-, MU+, TAU-, TAU+, NUS, GM,\n");
+ printf ("W+, W- and Z0.\n");
+ return;
+ }
+
+ if (index == 0) setJettype1 = true;
+ else if (index == 1) setJettype2 = true;
+ else if (index == 2) setJettype3 = true;
+}
+
+/**************************************************************************/
+
+Char_t* TIsajet::GetJETYP(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof XTYPES.jetyp[0] / sizeof XTYPES.jetyp[0][0]);
+ Int_t row_num = (sizeof XTYPES.jetyp / (sizeof XTYPES.jetyp[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetJETYP : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetJETYP : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return XTYPES.jetyp[index1][index2];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetWWTYP(Char_t val[], Int_t index1, Int_t index2)
+{
+ Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
+ Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::SetWWTYP : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::SetWWTYP : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return;
+ }
+
+ XTYPES.wwtyp[index1][index2] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllWWTYP(Char_t* val[2][30])
+{
+ for (Int_t i = 0; i < 2; i++) {
+ for (Int_t j = 0; j < 30; j++) {
+ SetWWTYP(val[i][j], i, j);
+ }
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::SetColumnWWTYP(Char_t* val[], Int_t col)
+{
+ Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
+ Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
+
+ if ((col < 0) || (col >= col_num)) {
+ printf ("Error in TIsajet::SetColumnWWTYP : \n");
+ printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
+ return;
+ }
+
+ for (Int_t i = 0; i < row_num; i++) {
+ SetWWTYP(val[i], i, col);
+ }
+}
+
+/**************************************************************************/
+
+Char_t* TIsajet::GetWWTYP(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof XTYPES.wwtyp[0] / sizeof XTYPES.wwtyp[0][0]);
+ Int_t row_num = (sizeof XTYPES.wwtyp / (sizeof XTYPES.wwtyp[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetWWTYP : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetWWTYP : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return XTYPES.wwtyp[index1][index2];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetWMODES(Char_t val[], Int_t index1, Int_t index2)
+{
+ Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
+ Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::SetWMODES : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::SetWMODES : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return;
+ }
+
+ XTYPES.wmodes[index1][index2] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetAllWMODES(Char_t* val[2][30])
+{
+ for (Int_t i = 0; i < 2; i++) {
+ for (Int_t j = 0; j < 30; j++) {
+ SetWMODES(val[i][j], i, j);
+ }
+ }
+}
+
+/**************************************************************************/
+
+void TIsajet::SetColumnWMODES(Char_t* val[], Int_t col)
+{
+ Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
+ Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
+
+ if ((col < 0) || (col >= col_num)) {
+ printf ("Error in TIsajet::SetColumnWMODES : \n");
+ printf ("Invalid column index %d, range is 0-%d.\n", col, col_num-1);
+ return;
+ }
+
+ for (Int_t i = 0; i < row_num; i++) {
+ SetWMODES(val[i], i, col);
+ }
+}
+
+/**************************************************************************/
+
+Char_t* TIsajet::GetWMODES(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof XTYPES.wmodes[0] / sizeof XTYPES.wmodes[0][0]);
+ Int_t row_num = (sizeof XTYPES.wmodes / (sizeof XTYPES.wmodes[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetWMODES : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetWMODES : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return XTYPES.wmodes[index1][index2];
+}
+
+/**************************************************************************/
+
+// Ends XTYPES access.
+// Begins WCON access.
+
+/**************************************************************************/
+
+void TIsajet::SetSIN2W(Float_t val)
+{
+ WCON.sin2w = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetSIN2W() const
+{
+ return WCON.sin2w;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetWMASS(Float_t w, Float_t z)
+{
+
+// This is how the FORTRAN does it. Don't ask me why.
+
+ WCON.wmass[0] = 0;
+ WCON.wmass[1] = WCON.wmass[2] = w;
+ WCON.wmass[3] = z;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetWMASS(Int_t index) const
+{
+ Int_t length = (sizeof WCON.wmass / sizeof WCON.wmass[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetWMASS : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return WCON.wmass[index];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetWMass(Float_t val)
+{
+ WCON.wmass[1] = WCON.wmass[2] = val;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetZMass(Float_t val)
+{
+ WCON.wmass[3] = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetWGAM(Int_t index) const
+{
+ Int_t length = (sizeof WCON.wgam / sizeof WCON.wgam[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetWGAM : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return WCON.wgam[index];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAQ(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof WCON.aq[0] / sizeof WCON.aq[0][0]);
+ Int_t row_num = (sizeof WCON.aq / (sizeof WCON.aq[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetAQ : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetAQ : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return WCON.aq[index1][index2];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetBQ(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof WCON.bq[0] / sizeof WCON.bq[0][0]);
+ Int_t row_num = (sizeof WCON.bq / (sizeof WCON.bq[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetBQ : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetBQ : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return WCON.bq[index1][index2];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetCOUT(Int_t index) const
+{
+ Int_t length = (sizeof WCON.cout / sizeof WCON.cout[0]);
+ if ((index < 0) || (index >= length)) {
+ printf ("Error in TIsajet::GetCOUT : \n");
+ printf ("Invalid array index %d; range is 0-%d.\n", index, length-1);
+ return 0;
+ }
+
+ return WCON.cout[index];
+}
+
+/**************************************************************************/
+
+Int_t TIsajet::GetMATCH() const
+{
+ return WCON.match;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetWCBR(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof WCON.wcbr[0] / sizeof WCON.wcbr[0][0]);
+ Int_t row_num = (sizeof WCON.wcbr / (sizeof WCON.wcbr[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetWCBR : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetWCBR : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return WCON.wcbr[index1][index2];
+}
+
+/**************************************************************************/
+
+void TIsajet::SetCUTOFF(Float_t val)
+{
+ WCON.cutoff = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetCUTOFF() const
+{
+ return WCON.cutoff;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetCUTPOW(Float_t val)
+{
+ WCON.cutpow = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetCUTPOW() const
+{
+ return WCON.cutpow;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetTBRWW(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof WCON.tbrww[0] / sizeof WCON.tbrww[0][0]);
+ Int_t row_num = (sizeof WCON.tbrww / (sizeof WCON.tbrww[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetTBRWW : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetTBRWW : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return WCON.tbrww[index1][index2];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetRBRWW(Int_t index1, Int_t index2, Int_t index3) const
+{
+ Int_t elem_Size = sizeof WCON.rbrww[0][0][0];
+ Int_t thd_Dim_Length = (sizeof WCON.rbrww[0][0] / elem_Size);
+ Int_t sec_Dim_Length = (sizeof WCON.rbrww[0] / (elem_Size * thd_Dim_Length));
+ Int_t fst_Dim_Length = (sizeof WCON.rbrww / (elem_Size * thd_Dim_Length * sec_Dim_Length));
+
+ if ((index1 < 0) || (index1 >= fst_Dim_Length)) {
+ printf ("Error in TIsajet::GetRBRWW : \n");
+ printf ("Invalid first index %d; range is 0-%d.\n", index1, fst_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= sec_Dim_Length)) {
+ printf ("Error in TIsajet::GetRBRWW : \n");
+ printf ("Invalid second index %d; range is 0-%d.\n", index2, sec_Dim_Length-1);
+ return 0;
+ }
+
+ if ((index3 < 0) || (index3 >= thd_Dim_Length)) {
+ printf ("Error in TIsajet::GetRBRWW : \n");
+ printf ("Invalid third index %d; range is 0-%d.\n", index3, thd_Dim_Length-1);
+ return 0;
+ }
+
+ return WCON.rbrww[index1][index2][index3];
+
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetEZ() const
+{
+ return WCON.ez;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetAQDP(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof WCON.aqdp[0] / sizeof WCON.aqdp[0][0]);
+ Int_t row_num = (sizeof WCON.aqdp / (sizeof WCON.aqdp[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetAQDP : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetAQDP : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return WCON.aqdp[index1][index2];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetBQDP(Int_t index1, Int_t index2) const
+{
+ Int_t col_num = (sizeof WCON.bqdp[0] / sizeof WCON.bqdp[0][0]);
+ Int_t row_num = (sizeof WCON.bqdp / (sizeof WCON.bqdp[0][0] * col_num));
+
+ if ((index1 < 0) || (index1 >= row_num)) {
+ printf ("Error in TIsajet::GetBQDP : \n");
+ printf ("Invalid array row index %d; range is 0-%d.\n", index1, row_num-1);
+ return 0;
+ }
+
+ if ((index2 < 0) || (index2 >= col_num)) {
+ printf ("Error in TIsajet::GetBQDP : \n");
+ printf ("Invalid array column index %d; range is 0-%d.\n", index2, col_num-1);
+ return 0;
+ }
+
+ return WCON.bqdp[index1][index2];
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetEZDP() const
+{
+ return WCON.ezdp;
+}
+
+/**************************************************************************/
+
+void TIsajet::SetWFUDGE(Float_t val)
+{
+ WCON.wfudge = val;
+}
+
+/**************************************************************************/
+
+Float_t TIsajet::GetWFUDGE() const
+{
+ return WCON.wfudge;
+}
+
+/**************************************************************************/
+
+// Ends WCON access.
+
+#ifndef WIN32
+# define isaini isaini_
+# define isaevt isaevt_
+# define isabeg isabeg_
+# define isabg2 isabg2_
+# define openfiles openfiles_
+# define pdfinit pdfinit_
+# define ranf ranf_
+# define type_of_call
+#else
+# define isaini ISAINI
+# define isaevt ISAEVT
+# define isabeg ISABEG
+# define isabg2 ISABG2
+# define openfiles OPENFILES
+# define pdfinit PDFINIT
+# define ranf RANF
+# define type_of_call _stdcall
+#endif
+
+extern "C" void type_of_call isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n);
+extern "C" void type_of_call isaevt(Int_t& j, Int_t& k, Int_t& m);
+extern "C" void type_of_call openfiles();
+extern "C" void type_of_call pdfinit();
+extern "C" void type_of_call isabeg(Int_t& ifl);
+extern "C" void type_of_call isabg2(Int_t& ifl);
+
+void TIsajet::Isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n)
+{
+ isaini(j, k, m, n);
+}
+
+void TIsajet::Isaevt(Int_t& j, Int_t& k, Int_t& m)
+{
+ isaevt(j, k, m);
+}
+
+void TIsajet::Openfiles()
+{
+ openfiles();
+}
+
+void TIsajet::PDFinit()
+{
+ pdfinit(pdfpar, pdfval);
+}
+
+void TIsajet::Isabeg(Int_t& ifl)
+{
+ isabeg(ifl);
+}
+
+void TIsajet::Isabg2(Int_t& ifl)
+{
+ isabg2(ifl);
+}
+
+extern "C" {
+ Double_t type_of_call ranf(Int_t & /*idum*/)
+ {
+ Float_t r;
+ do r=sRandom->Rndm(); while(0 >= r || r >= 1);
+ return r;
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+#ifndef ROOT_TIsajet
+#define ROOT_TIsajet
+
+/**************************************************************************/
+/* */
+/* TIsajet */
+/* */
+/* This class implements an interface to the Isajet event generator. */
+/* */
+/**************************************************************************/
+
+#ifndef ROOT_TGenerator
+#include "TGenerator.h"
+#include "AliRndm.h"
+#endif
+
+class TIsajet : public TGenerator , public AliRndm
+{
+//
+ private:
+
+ Char_t *title, *jobtype;
+ Char_t* pdfpar[20];
+ Float_t pdfval[20];
+ Int_t num_Pdf;
+ Int_t beam1_type, beam2_type;
+ Float_t cutoff_mass;
+ Float_t center_energy;
+ Float_t frag_params[32];
+ Char_t *jet1_type[30], *jet2_type[30], *jet3_type[30];
+ Int_t num_jet_type[3];
+ Float_t qcd_lambda;
+ Bool_t forbid_decay, forbid_eta, forbid_evolve, forbid_hadron, forbid_pi0;
+ Int_t generate_sigma;
+ Float_t p_limits[6];
+ Float_t phi_limits[6];
+ Float_t pt_limits[6];
+ Float_t theta_limits[6];
+ Float_t x_limits[6];
+ Float_t y_limits[6];
+ Float_t peter_jet_frag[8];
+
+ Bool_t setCutjet, setBeams, setFragment, setJettype1;
+ Bool_t setJettype2, setJettype3, setLambda, setNodcay;
+ Bool_t setNoeta, setNoevolve, setNohadron, setNopi0;
+ Bool_t setNsigma, setP, setPhi, setPt, setTheta;
+ Bool_t setX, setXgen, setY, setPdf, online;
+
+ public:
+
+ TIsajet();
+// TIsajet(Float_t Energy_CM);
+ virtual ~TIsajet();
+
+ virtual void Initialise();
+
+ virtual void Reload();
+
+ virtual void RestoreDefaults();
+
+ virtual Int_t ImportParticles(TClonesArray *particles, Option_t *option = "");
+
+ virtual void GenerateEvent();
+
+ virtual void SetJobtype(Char_t *val);
+ virtual void GetJobtype() const;
+
+ virtual void SetOnline(Bool_t val);
+ virtual Bool_t GetOnline() const;
+
+ virtual void SetPDF(Char_t *name, Float_t val);
+
+ virtual void Isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n);
+
+ virtual void Isaevt(Int_t& j, Int_t& k, Int_t& m);
+
+ virtual void Openfiles();
+
+ virtual void PDFinit();
+
+ virtual void Isabeg(Int_t& ifl);
+
+ virtual void Isabg2(Int_t& ifl);
+
+// Parameters for the event.
+// Variable explanations in Icommon.h
+// Common block DYLIM access routines :
+
+ virtual void SetQMIN(Float_t val);
+ virtual Float_t GetQMIN() const;
+
+ virtual void SetQMAX(Float_t val);
+ virtual Float_t GetQMAX() const;
+
+ virtual void SetQTMIN(Float_t val);
+ virtual Float_t GetQTMIN() const;
+
+ virtual void SetQTMAX(Float_t val);
+ virtual Float_t GetQTMAX() const;
+
+ virtual void SetYWMIN(Float_t val);
+ virtual Float_t GetYWMIN() const;
+
+ virtual void SetYWMAX(Float_t val);
+ virtual Float_t GetYWMAX() const;
+
+ virtual void SetYWLIMS();
+
+// YWMIN and YWMAX default to a function of QMIN, QTMIN; they are recalculated
+// whenever either value is set, unless they have been fixed by hand (ie using
+// their setters).
+
+ virtual void SetXWMIN(Float_t val);
+ virtual Float_t GetXWMIN() const;
+
+ virtual void SetXWMAX(Float_t val);
+ virtual Float_t GetXWMAX() const;
+
+ virtual void SetTHWMIN(Float_t val);
+ virtual Float_t GetTHWMIN() const;
+
+ virtual void SetTHWMAX(Float_t val);
+ virtual Float_t GetTHWMAX() const;
+
+ virtual void SetTHWLIMS();
+
+ virtual void SetPHWMIN(Float_t val);
+ virtual Float_t GetPHWMIN() const;
+
+ virtual void SetPHWMAX(Float_t val);
+ virtual Float_t GetPHWMAX() const;
+
+ virtual Bool_t GetSETLMQ(Int_t index) const;
+
+// Ends DYLIM
+// Common block EEPAR access routines
+
+ virtual void SetPLEP(Float_t val);
+ virtual Float_t GetPLEP() const;
+
+ virtual void SetPLEM(Float_t val);
+ virtual Float_t GetPLEM() const;
+
+ virtual void SetRSHMIN(Float_t val);
+ virtual Float_t GetRSHMIN() const;
+
+ virtual void SetRSHMAX(Float_t val);
+ virtual Float_t GetRSHMAX() const;
+
+ virtual void SetUPSLON(Float_t val);
+ virtual Float_t GetUPSLON() const;
+
+ virtual void SetSIGZ(Float_t val);
+ virtual Float_t GetSIGZ() const;
+
+ virtual Bool_t GetIBREM() const;
+
+ virtual Bool_t GetIBEAM() const;
+
+ virtual Float_t GetSGMXEE() const;
+
+// Ends EEPAR
+// Common block FORCE access routines
+
+ virtual Int_t GetNFORCE() const;
+
+ virtual void SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti = true);
+ virtual void UnForce(Int_t index, Bool_t anti = true);
+ virtual void UnForceID(Int_t particle_ID, Bool_t anti = true);
+// If anti is false, the antiparticle's decay is not forced / unforced.
+
+ virtual Int_t* GetIFORCE(Int_t index) const;
+
+ virtual Int_t GetMEFORC(Int_t index) const;
+
+// Ends FORCE
+// Common block FRGPAR access routines
+
+ virtual void SetFRPAR(Float_t val, Int_t index);
+ virtual void SetAllFRPAR(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetFRPAR(Int_t index) const;
+
+ virtual void SetPUD(Float_t val);
+ virtual Float_t GetPUD() const;
+
+ virtual void SetPBARY(Float_t val);
+ virtual Float_t GetPBARY() const;
+
+ virtual void SetSIGQT(Float_t val);
+ virtual Float_t GetSIGQT() const;
+
+ virtual void SetPEND(Float_t val);
+ virtual Float_t GetPEND() const;
+
+ virtual void SetXGEN(Float_t val, Int_t index);
+ virtual void SetAllXGEN(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetXGEN(Int_t index) const;
+
+ virtual void SetPSPIN1(Float_t val, Int_t index);
+ virtual void SetAllPSPIN1(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPSPIN1(Int_t index) const;
+
+ virtual void SetPMIX1(Float_t val, Int_t index1, Int_t index2);
+ virtual void SetAllPMIX1(const Float_t val[2][3]);
+ virtual void SetColumnPMIX1(const Float_t val[], Int_t col);
+ virtual Float_t GetPMIX1(Int_t index1, Int_t index2) const;
+
+ virtual void SetPMIX2(Float_t val, Int_t index1, Int_t index2);
+ virtual void SetAllPMIX2(const Float_t val[2][3]);
+ virtual void SetColumnPMIX2(const Float_t val[], Int_t col);
+ virtual Float_t GetPMIX2(Int_t index1, Int_t index2) const;
+
+ virtual void SetPMIXX1(Float_t val, Int_t index);
+ virtual void SetAllPMIXX1(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPMIXX1(Int_t index) const;
+
+ virtual void SetPMIXX2(Float_t val, Int_t index);
+ virtual void SetAllPMIXX2(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPMIXX2(Int_t index) const;
+
+ virtual void SetXGENSS(Float_t val, Int_t index);
+ virtual void SetAllXGENSS(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetXGENSS(Int_t index) const;
+
+// Ends FRGPAR
+// Common block HCON access routines
+
+ virtual Float_t GetANWWWW(Int_t index1, Int_t index2, Int_t index3) const;
+
+ virtual Float_t GetADWWWW(Int_t index1, Int_t index2) const;
+
+ virtual Float_t GetAIWWWW(Int_t index) const;
+
+ virtual Float_t GetHMASS() const;
+
+ virtual Float_t GetHGAM() const;
+
+ virtual Float_t GetHGAMS(Int_t index) const;
+
+ virtual Float_t GetETAHGG() const;
+
+ virtual Int_t GetMATCHH(Int_t index) const;
+
+ virtual Float_t GetZSTARS(Int_t index1, Int_t index2) const;
+
+ virtual void SetIHTYPE(Int_t val);
+ virtual void SetIHTYPE(Char_t val[]);
+ virtual Int_t GetIHTYPE() const;
+
+ virtual Float_t GetHGAMSS(Int_t index1, Int_t index2) const;
+
+// Ends HCON
+// Common block JETLIM access routines
+
+ virtual void SetPMIN(Float_t val, Int_t index);
+ virtual void SetAllPMIN(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPMIN(Int_t index) const;
+
+ virtual void SetPMAX(Float_t val, Int_t index);
+ virtual void SetAllPMAX(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPMAX(Int_t index) const;
+
+ virtual void SetPTMIN(Float_t val, Int_t index);
+ virtual void SetAllPTMIN(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPTMIN(Int_t index) const;
+
+ virtual void SetPTMAX(Float_t val, Int_t index);
+ virtual void SetAllPTMAX(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPTMAX(Int_t index) const;
+
+ virtual void SetYJMIN(Float_t val, Int_t index);
+ virtual void SetAllYJMIN(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetYJMIN(Int_t index) const;
+
+ virtual void SetYJMAX(Float_t val, Int_t index);
+ virtual void SetAllYJMAX(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetYJMAX(Int_t index) const;
+
+ virtual void SetYJLIMS();
+
+// YJMIN and YJMAX default to a function of PTMIN; but if either has
+// been set by hand, SetYJLIMS is not called when PTMIN is set.
+
+ virtual void SetPHIMIN(Float_t val, Int_t index);
+ virtual void SetAllPHIMIN(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPHIMIN(Int_t index) const;
+
+ virtual void SetPHIMAX(Float_t val, Int_t index);
+ virtual void SetAllPHIMAX(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetPHIMAX(Int_t index) const;
+
+ virtual void SetXJMIN(Float_t val, Int_t index);
+ virtual void SetAllXJMIN(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetXJMIN(Int_t index) const;
+
+ virtual void SetXJMAX(Float_t val, Int_t index);
+ virtual void SetAllXJMAX(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetXJMAX(Int_t index) const;
+
+ virtual void SetTHMIN(Float_t val, Int_t index);
+ virtual void SetAllTHMIN(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetTHMIN(Int_t index) const;
+
+ virtual void SetTHLIMS();
+
+ virtual void SetTHMAX(Float_t val, Int_t index);
+ virtual void SetAllTHMAX(const Float_t val[], Int_t arraySize);
+ virtual Float_t GetTHMAX(Int_t index) const;
+
+ virtual Bool_t GetSETLMJ(Int_t index) const;
+
+// Ends JETLIM
+// Common block JETPAR access routines
+
+ virtual Float_t GetP(Int_t index) const;
+
+ virtual Float_t GetPT(Int_t index) const;
+
+ virtual Float_t GetYJ(Int_t index) const;
+
+ virtual Float_t GetPHI(Int_t index) const;
+
+ virtual Float_t GetXJ(Int_t index) const;
+
+ virtual Float_t GetTH(Int_t index) const;
+
+ virtual Float_t GetCTH(Int_t index) const;
+
+ virtual Float_t GetSTH(Int_t index) const;
+
+ virtual Int_t GetJETTYP(Int_t index) const;
+
+ virtual Float_t GetSHAT() const;
+
+ virtual Float_t GetTHAT() const;
+
+ virtual Float_t GetUHAT() const;
+
+ virtual Float_t GetQSQ() const;
+
+ virtual Float_t GetX1() const;
+
+ virtual Float_t GetX2() const;
+
+ virtual Float_t GetPBEAM(Int_t index) const;
+
+ virtual Float_t GetQMW() const;
+
+ virtual Float_t GetQW() const;
+
+ virtual Float_t GetQTW() const;
+
+ virtual Float_t GetYW() const;
+
+ virtual Float_t GetXW() const;
+
+ virtual Float_t GetTHW() const;
+
+ virtual Float_t GetQTMW() const;
+
+ virtual Float_t GetPHIW() const;
+
+ virtual Float_t GetSHAT1() const;
+
+ virtual Float_t GetTHAT1() const;
+
+ virtual Float_t GetUHAT1() const;
+
+ virtual void SetJWTYP(Int_t val);
+ virtual void SetJWTYP(Char_t val[]);
+ virtual Int_t GetJWTYP() const;
+
+ virtual Float_t GetALFQSQ() const;
+
+ virtual Float_t GetCTHW() const;
+
+ virtual Float_t GetSTHW() const;
+
+ virtual Float_t GetQ0W() const;
+
+ virtual Int_t GetINITYP(Int_t index) const;
+
+ virtual Int_t GetISIGS() const;
+
+ virtual Float_t GetPBEAMS(Int_t index) const;
+
+// Ends JETPAR
+// Common block KKGRAV access routines
+
+ virtual void SetNEXTRAD(Int_t val);
+ virtual Int_t GetNEXTRAD() const;
+
+ virtual void SetMASSD(Float_t val);
+ virtual Float_t GetMASSD() const;
+
+ virtual Float_t GetKKGSD() const;
+
+ virtual Float_t GetSURFD() const;
+
+ virtual void SetUVCUT(Bool_t val);
+ virtual Bool_t GetUVCUT() const;
+
+// Ends KKGRAV
+// Common block MBGEN access routines
+
+ virtual Float_t GetPOMWT(Int_t index) const;
+
+ virtual Float_t GetPOMGEN(Int_t index) const;
+
+ virtual void SetMNPOM(Int_t val);
+ virtual Int_t GetMNPOM() const;
+
+ virtual void SetMXPOM(Int_t val);
+ virtual Int_t GetMXPOM() const;
+
+ virtual Float_t GetPDIFFR() const;
+
+ virtual Int_t GetNPOM() const;
+
+ virtual Float_t GetXBARY(Int_t index) const;
+
+ virtual Float_t GetDXBARY(Int_t index) const;
+
+ virtual Float_t GetXPOM(Int_t index1, Int_t index2) const;
+
+// Ends MBGEN
+// Common block MGLIMS access routines
+
+ virtual void SetEHMGMN(Float_t val);
+ virtual Float_t GetEHMGMN() const;
+
+ virtual void SetEHMGMX(Float_t val);
+ virtual Float_t GetEHMGMX() const;
+
+ virtual Float_t GetYHMGMN() const;
+
+ virtual Float_t GetYHMGMX() const;
+
+// The eights in the All-setters correspond to MGLIMS.mxlim, but the
+// compiler will not recognize it here.
+
+ virtual void SetAMIJMN(Float_t val, Int_t index1, Int_t index2);
+ virtual void SetAllAMIJMN(const Float_t val[8][8]);
+ virtual void SetColumnAMIJMN(const Float_t val[], Int_t col);
+ virtual Float_t GetAMIJMN(Int_t index1, Int_t index2) const;
+
+ virtual void SetAMIJMX(Float_t val, Int_t index1, Int_t index2);
+ virtual void SetAllAMIJMX(const Float_t val[8][8]);
+ virtual void SetColumnAMIJMX(const Float_t val[], Int_t col);
+ virtual Float_t GetAMIJMX(Int_t index1, Int_t index2) const;
+
+ virtual Bool_t GetFIXMIJ(Int_t index1, Int_t index2) const;
+
+// End MGLIMS
+// Common block NODCAY access routines
+
+ virtual void SetNODCAY(Bool_t val);
+ virtual Bool_t GetNODCAY() const;
+
+ virtual void SetNOETA(Bool_t val);
+ virtual Bool_t GetNOETA() const;
+
+ virtual void SetNOPI0(Bool_t val);
+ virtual Bool_t GetNOPI0() const;
+
+ virtual void SetNONUNU(Bool_t val);
+ virtual Bool_t GetNONUNU() const;
+
+ virtual void SetNOEVOL(Bool_t val);
+ virtual Bool_t GetNOEVOL() const;
+
+ virtual void SetNOHADR(Bool_t val);
+ virtual Bool_t GetNOHADR() const;
+
+ virtual void SetNOGRAV(Bool_t val);
+ virtual Bool_t GetNOGRAV() const;
+
+// Ends NODCAY
+// Common block PARTCL access routines (get-only block)
+
+ virtual Int_t GetNPTCL() const;
+
+ virtual Float_t GetPX(Int_t index) const;
+ virtual Float_t GetPY(Int_t index) const;
+ virtual Float_t GetPZ(Int_t index) const;
+ virtual Float_t GetP0(Int_t index) const;
+ virtual Float_t GetMASS(Int_t index) const;
+
+ virtual Float_t GetORIG(Int_t index) const;
+ virtual Float_t GetIDENT(Int_t index) const;
+ virtual Float_t GetIDCAY(Int_t index) const;
+
+// Ends PARTCL
+// Common block PRIMAR access routines
+
+ virtual Int_t GetNJET() const;
+
+ virtual Float_t GetSCM() const;
+
+ virtual Float_t GetHALFE() const;
+
+ virtual void SetECM(Float_t val);
+ virtual Float_t GetECM() const;
+
+ virtual void SetIDIN(Int_t val, Int_t index);
+ virtual void SetIDIN(const Char_t val[], Int_t index);
+ virtual Int_t GetIDIN(Int_t index) const;
+
+ virtual Int_t GetNEVENT() const;
+
+ virtual void SetNTRIES(Int_t val);
+ virtual Int_t GetNTRIES() const;
+
+ virtual void SetNSIGMA(Int_t val);
+ virtual Int_t GetNSIGMA()const;
+
+// Ends PRIMAR
+// Common block QCDPAR access routines
+
+ virtual void SetALAM(Float_t val);
+ virtual Float_t GetALAM() const;
+
+ virtual Float_t GetALAM2() const;
+
+ virtual void SetCUTJET(Float_t val);
+ virtual Float_t GetCUTJET() const;
+
+ virtual void SetISTRUC(Int_t val);
+ virtual void SetISTRUC(const Char_t val[]);
+ virtual Int_t GetISTRUC() const;
+
+// Ends QCDPAR
+// Common block QLMASS access routines
+
+// AMLEP has no All-setter for the good and simple reason that
+// not all of its entries should be set. GetAnyAMLEP returns those
+// indices that cannot be set by the user.
+
+
+ virtual void SetAMLEP(Float_t val, Int_t index);
+ virtual Float_t GetAnyAMLEP(Int_t index) const;
+ virtual Float_t GetAMLEP(Int_t index) const;
+
+ virtual void SetTquarkMass(Float_t val);
+ virtual Float_t GetTquarkMass() const;
+
+ virtual void SetXquarkMass(Float_t val);
+ virtual Float_t GetXquarkMass() const;
+
+ virtual void SetYquarkMass(Float_t val);
+ virtual Float_t GetYquarkMass() const;
+
+ virtual void SetUtildeMass(Float_t val);
+ virtual Float_t GetUtildeMass() const;
+
+ virtual void SetDtildeMass(Float_t val);
+ virtual Float_t GetDtildeMass() const;
+
+ virtual void SetStildeMass(Float_t val);
+ virtual Float_t GetStildeMass() const;
+
+ virtual void SetCtildeMass(Float_t val);
+ virtual Float_t GetCtildeMass() const;
+
+ virtual void SetBtildeMass(Float_t val);
+ virtual Float_t GetBtildeMass() const;
+
+ virtual void SetTtildeMass(Float_t val);
+ virtual Float_t GetTtildeMass() const;
+
+ virtual void SetGtildeMass(Float_t val);
+ virtual Float_t GetGtildeMass() const;
+
+ virtual void SetGammatildeMass(Float_t val);
+ virtual Float_t GetGammatildeMass() const;
+
+ virtual void SetNuEtildeMass(Float_t val);
+ virtual Float_t GetNuEtildeMass() const;
+
+ virtual void SetEtildeMass(Float_t val);
+ virtual Float_t GetEtildeMass() const;
+
+ virtual void SetNuMutildeMass(Float_t val);
+ virtual Float_t GetNuMutildeMass() const;
+
+ virtual void SetMutildeMass(Float_t val);
+ virtual Float_t GetMutildeMass() const;
+
+ virtual void SetNuTautildeMass(Float_t val);
+ virtual Float_t GetNuTautildeMass() const;
+
+ virtual void SetTautildeMass(Float_t val);
+ virtual Float_t GetTautildeMass() const;
+
+ virtual void SetWplustildeMass(Float_t val);
+ virtual Float_t GetWplustildeMass() const;
+
+ virtual void SetZ0tildeMass(Float_t val);
+ virtual Float_t GetZ0tildeMass() const;
+
+ virtual void SetHiggsMesonMass(Float_t val, Int_t index);
+ virtual Float_t GetHiggsMesonMass(Int_t index) const;
+
+ virtual Int_t GetNQLEP() const;
+
+ virtual Int_t GetNMES() const;
+
+ virtual Int_t GetNBARY() const;
+
+// Ends QLMASS
+// Common block SEED access routines
+
+ virtual void SetSEED(const Char_t val[24]);
+ virtual Char_t* GetSEED() const;
+
+// Ends SEED
+// Common block SUGNU access routines
+
+ virtual void SetXNUSUG(Float_t val, Int_t index);
+ virtual Float_t GetXNUSUG(Int_t index) const;
+
+ virtual void SetGauginoMass(Float_t val, Int_t index);
+ virtual Float_t GetGauginoMass(Int_t index) const;
+
+ virtual void SetAtau(Float_t val);
+ virtual Float_t GetAtau() const;
+
+ virtual void SetAb(Float_t val);
+ virtual Float_t GetAb() const;
+
+ virtual void SetAt(Float_t val);
+ virtual Float_t GetAt() const;
+
+ virtual void SetHiggsDmass(Float_t val);
+ virtual Float_t GetHiggsDmass() const;
+
+ virtual void SetHiggsUmass(Float_t val);
+ virtual Float_t GetHiggsUmass() const;
+
+ virtual void SetERmass(Float_t val);
+ virtual Float_t GetERmass() const;
+
+ virtual void SetELmass(Float_t val);
+ virtual Float_t GetELmass() const;
+
+ virtual void SetDRmass(Float_t val);
+ virtual Float_t GetDRmass() const;
+
+ virtual void SetURmass(Float_t val);
+ virtual Float_t GetURmass() const;
+
+ virtual void SetULmass(Float_t val);
+ virtual Float_t GetULmass() const;
+
+ virtual void SetTauRmass(Float_t val);
+ virtual Float_t GetTauRmass() const;
+
+ virtual void SetTauLmass(Float_t val);
+ virtual Float_t GetTauLmass() const;
+
+ virtual void SetBRmass(Float_t val);
+ virtual Float_t GetBRmass() const;
+
+ virtual void SetTRmass(Float_t val);
+ virtual Float_t GetTRmass() const;
+
+ virtual void SetTLmass(Float_t val);
+ virtual Float_t GetTLmass() const;
+
+// Ends XNUSUG
+// Common block TCPAR access routines
+
+ virtual void SetTCMRHO(Float_t val);
+ virtual Float_t GetTCMRHO() const;
+
+ virtual void SetTCGRHO(Float_t val);
+ virtual Float_t GetTCGRHO() const;
+
+// Ends TCPAR
+// Common block TYPES access routines
+
+ virtual Int_t GetLOC(Int_t index) const;
+
+ virtual Int_t GetNTYP() const;
+
+ virtual Int_t GetNJTTYP(Int_t index) const;
+
+ virtual Int_t GetNWWTYP(Int_t index) const;
+
+ virtual Int_t GetNWMODE(Int_t index) const;
+
+// Ends TYPES
+// Common block XMSSM access routines
+
+ virtual Bool_t GetGOMSSM() const;
+
+ virtual Bool_t GetGOSUG() const;
+
+ virtual Bool_t GetGOGMSB() const;
+
+ virtual Bool_t GetGOAMSB() const;
+
+ virtual Bool_t GetAL3UNI() const;
+
+ virtual void SetXGLSS(Float_t val);
+ virtual Float_t GetXGLSS() const;
+
+ virtual void SetXMUSS(Float_t val);
+ virtual Float_t GetXMUSS() const;
+
+ virtual void SetXHASS(Float_t val);
+ virtual Float_t GetXHASS() const;
+
+ virtual void SetXTBSS(Float_t val);
+ virtual Float_t GetXTBSS() const;
+
+ virtual void SetXQ1SS(Float_t val);
+ virtual Float_t GetXQ1SS() const;
+
+ virtual void SetXDRSS(Float_t val);
+ virtual Float_t GetXDRSS() const;
+
+ virtual void SetXURSS(Float_t val);
+ virtual Float_t GetXURSS() const;
+
+ virtual void SetXL1SS(Float_t val);
+ virtual Float_t GetXL1SS() const;
+
+ virtual void SetXERSS(Float_t val);
+ virtual Float_t GetXERSS() const;
+
+ virtual void SetXQ2SS(Float_t val);
+ virtual Float_t GetXQ2SS() const;
+
+ virtual void SetXSRSS(Float_t val);
+ virtual Float_t GetXSRSS() const;
+
+ virtual void SetXCRSS(Float_t val);
+ virtual Float_t GetXCRSS() const;
+
+ virtual void SetXL2SS(Float_t val);
+ virtual Float_t GetXL2SS() const;
+
+ virtual void SetXMRSS(Float_t val);
+ virtual Float_t GetXMRSS() const;
+
+ virtual void SetXQ3SS(Float_t val);
+ virtual Float_t GetXQ3SS() const;
+
+ virtual void SetXBRSS(Float_t val);
+ virtual Float_t GetXBRSS() const;
+
+ virtual void SetXTRSS(Float_t val);
+ virtual Float_t GetXTRSS() const;
+
+ virtual void SetXL3SS(Float_t val);
+ virtual Float_t GetXL3SS() const;
+
+ virtual void SetXTARSS(Float_t val);
+ virtual Float_t GetXTARSS() const;
+
+ virtual void SetXATSS(Float_t val);
+ virtual Float_t GetXATSS() const;
+
+ virtual void SetXABSS(Float_t val);
+ virtual Float_t GetXABSS() const;
+
+ virtual void SetXATASS(Float_t val);
+ virtual Float_t GetXATASS() const;
+
+ virtual void SetXM1SS(Float_t val);
+ virtual Float_t GetXM1SS() const;
+
+ virtual void SetXM2SS(Float_t val);
+ virtual Float_t GetXM2SS() const;
+
+ virtual void SetXM0SU(Float_t val);
+ virtual Float_t GetXM0SU() const;
+
+ virtual void SetXMHSU(Float_t val);
+ virtual Float_t GetXMHSU() const;
+
+ virtual void SetXA0SU(Float_t val);
+ virtual Float_t GetXA0SU() const;
+
+ virtual void SetXTGBSU(Float_t val);
+ virtual Float_t GetXTGBSU() const;
+
+ virtual void SetXSMUSU(Float_t val);
+ virtual Float_t GetXSMUSU() const;
+
+ virtual void SetXLAMGM(Float_t val);
+ virtual Float_t GetXLAMGM() const;
+
+ virtual void SetXMESGM(Float_t val);
+ virtual Float_t GetXMESGM() const;
+
+ virtual void SetXN5GM(Float_t val);
+ virtual Float_t GetXN5GM() const;
+
+ virtual void SetXCMGV(Float_t val);
+ virtual Float_t GetXCMGV() const;
+
+ virtual void SetMGVTO(Float_t val);
+ virtual Float_t GetMGVTO() const;
+
+ virtual void SetXRSLGM(Float_t val);
+ virtual Float_t GetXRSLGM() const;
+
+ virtual void SetXDHDGM(Float_t val);
+ virtual Float_t GetXDHDGM() const;
+
+ virtual void SetXDHUGM(Float_t val);
+ virtual Float_t GetXDHUGM() const;
+
+ virtual void SetXDYGM(Float_t val);
+ virtual Float_t GetXDYGM() const;
+
+ virtual void SetXN51GM(Float_t val);
+ virtual Float_t GetXN51GM() const;
+
+ virtual void SetXN52GM(Float_t val);
+ virtual Float_t GetXN52GM() const;
+
+ virtual void SetXN53GM(Float_t val);
+ virtual Float_t GetXN53GM() const;
+
+ virtual void SetXMN3NR(Float_t val);
+ virtual Float_t GetXMN3NR() const;
+
+ virtual void SetXMAJNR(Float_t val);
+ virtual Float_t GetXMAJNR() const;
+
+ virtual void SetXANSS(Float_t val);
+ virtual Float_t GetXANSS() const;
+
+ virtual void SetXNRSS(Float_t val);
+ virtual Float_t GetXNRSS() const;
+
+ virtual void SetXSBCS(Float_t val);
+ virtual Float_t GetXSBCS() const;
+
+// Ends XMSSM
+// Common block XTYPES access routines
+
+ virtual Char_t* GetPARTYP(Int_t index) const;
+
+ virtual void SetTITLE(Char_t *val);
+ virtual Char_t* GetTITLE() const;
+
+ virtual void SetJETYP(Int_t index, Char_t val[]);
+ virtual Char_t* GetJETYP(Int_t index1, Int_t index2) const;
+
+ virtual void SetWWTYP(Char_t val[], Int_t index1, Int_t index2);
+ virtual void SetAllWWTYP(Char_t* val[2][30]);
+ virtual void SetColumnWWTYP(Char_t* val[], Int_t col);
+ virtual Char_t* GetWWTYP(Int_t index1, Int_t index2) const;
+
+ virtual void SetWMODES(Char_t val[], Int_t index1, Int_t index2);
+ virtual void SetAllWMODES(Char_t* val[2][30]);
+ virtual void SetColumnWMODES(Char_t* val[], Int_t col);
+ virtual Char_t* GetWMODES(Int_t index1, Int_t index2) const;
+
+// Ends XTYPES
+// Common block WCON access routines
+
+ virtual void SetSIN2W(Float_t val);
+ virtual Float_t GetSIN2W() const;
+
+ virtual void SetWMASS(Float_t w, Float_t z);
+ virtual Float_t GetWMASS(Int_t index) const;
+
+ virtual void SetWMass(Float_t val);
+
+ virtual void SetZMass(Float_t val);
+
+
+ virtual Float_t GetWGAM(Int_t index) const;
+
+ virtual Float_t GetAQ(Int_t index1, Int_t index2) const;
+
+ virtual Float_t GetBQ(Int_t index1, Int_t index2) const;
+
+ virtual Float_t GetCOUT(Int_t index) const;
+
+ virtual Int_t GetMATCH() const;
+
+ virtual Float_t GetWCBR(Int_t index1, Int_t index2) const;
+
+ virtual void SetCUTOFF(Float_t val);
+ virtual Float_t GetCUTOFF() const;
+
+ virtual void SetCUTPOW(Float_t val);
+ virtual Float_t GetCUTPOW() const;
+
+ virtual Float_t GetTBRWW(Int_t index1, Int_t index2) const;
+
+ virtual Float_t GetRBRWW(Int_t index1, Int_t index2, Int_t index3) const;
+
+ virtual Float_t GetEZ() const;
+
+ virtual Float_t GetAQDP(Int_t index1, Int_t index2) const;
+
+ virtual Float_t GetBQDP(Int_t index1, Int_t index2) const;
+
+ virtual Float_t GetEZDP() const;
+
+ virtual void SetWFUDGE(Float_t val);
+ virtual Float_t GetWFUDGE() const;
+
+// Ends WCON
+
+ ClassDef(TIsajet,1)
+ };
+
+
+
+#endif
+
+// Endfile.
+
+
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff