From 7dae8538a4a11064c602a65784d156fefdc9e1a4 Mon Sep 17 00:00:00 2001 From: morsch Date: Mon, 10 Dec 2001 11:10:32 +0000 Subject: [PATCH] First commit. --- TIsajet/Icommon.h | 915 ++++++ TIsajet/Makefile | 87 + TIsajet/TIsajet.cxx | 5923 ++++++++++++++++++++++++++++++++++++++ TIsajet/TIsajet.h | 922 ++++++ TIsajet/TIsajetCint.h | 41 + TIsajet/TIsajetLinkDef.h | 9 + 6 files changed, 7897 insertions(+) create mode 100644 TIsajet/Icommon.h create mode 100644 TIsajet/Makefile create mode 100644 TIsajet/TIsajet.cxx create mode 100644 TIsajet/TIsajet.h create mode 100644 TIsajet/TIsajetCint.h create mode 100644 TIsajet/TIsajetLinkDef.h diff --git a/TIsajet/Icommon.h b/TIsajet/Icommon.h new file mode 100644 index 00000000000..486e2e19c03 --- /dev/null +++ b/TIsajet/Icommon.h @@ -0,0 +1,915 @@ +#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. + + + + + + + + diff --git a/TIsajet/Makefile b/TIsajet/Makefile new file mode 100644 index 00000000000..8bfdb5c9fbd --- /dev/null +++ b/TIsajet/Makefile @@ -0,0 +1,87 @@ +############################### THijing Makefile ############################## + +# Include machine specific definitions + +include $(ALICE_ROOT)/conf/GeneralDef +include $(ALICE_ROOT)/conf/MachineDef.$(ALICE_TARGET) + +PACKAGE = TIsajet + +# FORTRAN sources + +FSRCS = + +# C++ sources + +SRCS = TIsajet.cxx + +# C++ Headers + +HDRS = $(SRCS:.cxx=.h) TIsajetLinkDef.h + +# Library dictionary + +DICT = TIsajetCint.cxx +DICTH = $(DICT:.cxx=.h) +DICTO = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(DICT)) + +# Objects + +OBJS = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(FOBJS) $(DICTO) + +# FORTRAN Objectrs + +FOBJS = $(patsubst %.F,tgt_$(ALICE_TARGET)/%.o,$(FSRCS)) + +# C Objects + +COBJS = $(patsubst %.c,tgt_$(ALICE_TARGET)/%.o,$(CSRCS)) + +# C++ Objects + +OBJS = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(DICTO) + +# C++ compilation flags + +CXXFLAGS = $(CXXOPTS) -I$(ROOTSYS)/include -I. -I$(ALICE_ROOT)/include/ + +# FORTRAN compilation flags + +FFLAGS = $(FOPT) + +##### TARGETS ##### + +# Target + +SLIBRARY = $(LIBDIR)/libTIsajet.$(SL) +ALIBRARY = $(LIBDIR)/libTIsajet.a + +default: $(SLIBRARY) + +$(LIBDIR)/libTIsajet.$(SL): $(OBJS) + +$(DICT): $(HDRS) + +depend: $(SRCS) $(FSRCS) + +HEADERS = TIsajet.h + +TOCLEAN = $(OBJS) *Cint.cxx *Cint.h + +CHECKS = $(patsubst %.cxx,check/%.viol,$(SRCS)) + +############################### General Macros ################################ + +include $(ALICE_ROOT)/conf/GeneralMacros + +############################ Dependencies ##################################### + +-include tgt_$(ALICE_TARGET)/Make-depend + + + + + + + + diff --git a/TIsajet/TIsajet.cxx b/TIsajet/TIsajet.cxx new file mode 100644 index 00000000000..24d575af2a5 --- /dev/null +++ b/TIsajet/TIsajet.cxx @@ -0,0 +1,5923 @@ +#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; + } +} + + + + + + + + + + + diff --git a/TIsajet/TIsajet.h b/TIsajet/TIsajet.h new file mode 100644 index 00000000000..6570dc12627 --- /dev/null +++ b/TIsajet/TIsajet.h @@ -0,0 +1,922 @@ +#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. + + diff --git a/TIsajet/TIsajetCint.h b/TIsajet/TIsajetCint.h new file mode 100644 index 00000000000..d6bb84711e2 --- /dev/null +++ b/TIsajet/TIsajetCint.h @@ -0,0 +1,41 @@ +/******************************************************************** +* TIsajetCint.h +********************************************************************/ +#ifdef __CINT__ +#error TIsajetCint.h/C is only for compilation. Abort cint. +#endif +#include +#include +#include +#include +#include +#define G__ANSIHEADER +#define G__DICTIONARY +#include "G__ci.h" +extern "C" { +extern void G__cpp_setup_tagtableTIsajetCint(); +extern void G__cpp_setup_inheritanceTIsajetCint(); +extern void G__cpp_setup_typetableTIsajetCint(); +extern void G__cpp_setup_memvarTIsajetCint(); +extern void G__cpp_setup_globalTIsajetCint(); +extern void G__cpp_setup_memfuncTIsajetCint(); +extern void G__cpp_setup_funcTIsajetCint(); +extern void G__set_cpp_environmentTIsajetCint(); +} + + +#include "TROOT.h" +#include "TMemberInspector.h" +#include "TIsajet.h" + +#ifndef G__MEMFUNCBODY +#endif + +extern G__linked_taginfo G__TIsajetCintLN_TClass; +extern G__linked_taginfo G__TIsajetCintLN_TObject; +extern G__linked_taginfo G__TIsajetCintLN_TNamed; +extern G__linked_taginfo G__TIsajetCintLN_TGenerator; +extern G__linked_taginfo G__TIsajetCintLN_AliRndm; +extern G__linked_taginfo G__TIsajetCintLN_TIsajet; + +/* STUB derived class for protected member access */ diff --git a/TIsajet/TIsajetLinkDef.h b/TIsajet/TIsajetLinkDef.h new file mode 100644 index 00000000000..333ce8e13e4 --- /dev/null +++ b/TIsajet/TIsajetLinkDef.h @@ -0,0 +1,9 @@ +#ifdef __CINT__ + +#pragma link off all globals; +#pragma link off all classes; +#pragma link off all functions; + +#pragma link C++ class TIsajet+; + +#endif -- 2.31.1