From 2d8d4543d0efa1cf60388aac4671831e39cc9f27 Mon Sep 17 00:00:00 2001 From: morsch Date: Mon, 15 Jul 2002 17:10:29 +0000 Subject: [PATCH] Interface to HERWIG --- THerwig/HCommon.h | 469 ++++++++++++++++++++++++ THerwig/Herwig6Calls.h | 473 ++++++++++++++++++++++++ THerwig/Makefile | 99 +++++ THerwig/THerwig6.cxx | 446 +++++++++++++++++++++++ THerwig/THerwig6.h | 765 +++++++++++++++++++++++++++++++++++++++ THerwig/THerwigLinkDef.h | 9 + THerwig/libTHerwig.pkg | 7 + 7 files changed, 2268 insertions(+) create mode 100644 THerwig/HCommon.h create mode 100644 THerwig/Herwig6Calls.h create mode 100644 THerwig/Makefile create mode 100644 THerwig/THerwig6.cxx create mode 100644 THerwig/THerwig6.h create mode 100644 THerwig/THerwigLinkDef.h create mode 100644 THerwig/libTHerwig.pkg diff --git a/THerwig/HCommon.h b/THerwig/HCommon.h new file mode 100644 index 00000000000..c5943951647 --- /dev/null +++ b/THerwig/HCommon.h @@ -0,0 +1,469 @@ +// Translation of Fortran commons from the Herwig6 +// f77 program into c++ structures to be used in ROOT +// and declaration of Fortran functions as extern +// C functions to be called from the class Herwig6 +// author: j. g. contreras jgcn@moni.mda.cinvestav.mx +// date: december 22, 2000 + +int const NMXHEP = 2000; + +struct Hepevt_t { + int NEVHEP; + int NHEP; + int ISTHEP[NMXHEP]; + int IDHEP[NMXHEP]; + int JMOHEP[NMXHEP][2]; + int JDAHEP[NMXHEP][2]; + double PHEP[NMXHEP][5]; + double VHEP[NMXHEP][4]; +}; + +struct Hwbeam_t { + int IPART1; + int IPART2; +}; + +struct Hwbmch_t { + char PART1[8]; + char PART2[8]; +}; + +struct Hwproc_t { + double EBEAM1; + double EBEAM2; + double PBEAM1; + double PBEAM2; + int IPROC; + int MAXEV; +}; + +struct Hwpram_t { + double AFCH[2][16]; + double ALPHEM; + double B1LIM; + double BETAF; + double BTCLM; + double CAFAC; + double CFFAC; + double CLMAX; + double CLPOW; + double CLSMR[2]; + double CSPEED; + double ENSOF; + double ETAMIX; + double F0MIX; + double F1MIX; + double F2MIX; + double GAMH; + double GAMW; + double GAMZ; + double GAMZP; + double GEV2NB; + double H1MIX; + double PDIQK; + double PGSMX; + double PGSPL[4]; + double PHIMIX; + double PIFAC; + double PRSOF; + double PSPLT[2]; + double PTRMS; + double PXRMS; + double QCDL3; + double QCDL5; + double QCDLAM; + double QDIQK; + double QFCH[16]; + double QG; + double QSPAC; + double QV; + double SCABI; + double SWEIN; + double TMTOP; + double VFCH[2][16]; + double VCKM[3][3]; + double VGCUT; + double VQCUT; + double VPCUT; + double ZBINM; + double EFFMIN; + double OMHMIX; + double ET2MIX; + double PH3MIX; + double GCUTME; + int IOPREM; + int IPRINT; + int ISPAC; + int LRSUD; + int LWSUD; + int MODPDF[2]; + int NBTRY; + int NCOLO; + int NCTRY; + int NDTRY; + int NETRY; + int NFLAV; + int NGSPL; + int NSTRU; + int NSTRY; + int NZBIN; + int IOP4JT[2]; + int NPRFMT; + int AZSOFT; + int AZSPIN; + int CLDIR[2]; + int HARDME; + int NOSPAC; + int PRNDEC; + int PRVTX; + int SOFTME; + int ZPRIME; + int PRNDEF; + int PRNTEX; + int PRNWEB; +}; + +struct Hwprch_t { + char AUTPDF[2][20]; + char BDECAY[4]; +}; + +int const NMXPAR = 500; + +struct Hwpart_t { + int NEVPAR; + int NPAR; + int ISTPAR[NMXPAR]; + int IDPAR[NMXPAR]; + int JMOPAR[NMXPAR][2]; + int JDAPAR[NMXPAR][2]; + double PPAR[NMXPAR][5]; + double VPAR[NMXPAR][4]; +}; + +struct Hwparp_t { + double DECPAR[NMXPAR][2]; + double PHIPAR[NMXPAR][2]; + double RHOPAR[NMXPAR][2]; + int TMPAR[NMXPAR]; +}; + +int const MODMAX = 5; + +struct Hwbosc_t { + double ALPFAC; + double BRHIG[12]; + double ENHANC[12]; + double GAMMAX; + double RHOHEP[NMXHEP][3]; + int IOPHIG; + int MODBOS[MODMAX]; +}; + +struct Hwparc_t { + int JCOPAR[NMXPAR][4]; +}; + +struct Hwbrch_t { + double ANOMSC[2][2]; + double HARDST; + double PTINT[2][3]; + double XFACT; + int INHAD; + int JNHAD; + int NSPAC[7]; + int ISLENT; + int BREIT; + int FROST; + int USECMF; +}; + +struct Hwevnt_t { + double AVWGT; + double EVWGT; + double GAMWT; + double TLOUT; + double WBIGST; + double WGTMAX; + double WGTSUM; + double WSQSUM; + int IDHW[NMXHEP]; + int IERROR; + int ISTAT; + int LWEVT; + int MAXER; + int MAXPR; + int NOWGT; + int NRN[2]; + int NUMER; + int NUMERU; + int NWGTS; + int GENSOF; +}; + +struct Hwhard_t { + double ASFIXD; + double CLQ[6][7]; + double COSS; + double COSTH; + double CTMAX; + double DISF[2][13]; + double EMLST; + double EMMAX; + double EMMIN; + double EMPOW; + double EMSCA; + double EPOLN[3]; + double GCOEF[7]; + double GPOLN; + double OMEGA0; + double PHOMAS; + double PPOLN[3]; + double PTMAX; + double PTMIN; + double PTPOW; + double Q2MAX; + double Q2MIN; + double Q2POW; + double Q2WWMN; + double Q2WWMX; + double QLIM; + double SINS; + double THMAX; + double Y4JT; + double TMNISR; + double TQWT; + double XX[2]; + double XLMIN; + double XXMIN; + double YBMAX; + double YBMIN; + double YJMAX; + double YJMIN; + double YWWMAX; + double YWWMIN; + double WHMIN; + double ZJMAX; + double ZMXISR; + int IAPHIG; + int IBRN[2]; + int IBSH; + int ICO[10]; + int IDCMF; + int IDN[10]; + int IFLMAX; + int IFLMIN; + int IHPRO; + int IPRO; + int MAPQ[10]; + int MAXFL; + int BGSHAT; + int COLISR; + int FSTEVT; + int FSTWGT; + int GENEV; + int HVFCEN; + int TPOL; + int DURHAM; +}; + +int const NMXRES = 500; + +struct Hwprop_t { + double RLTIM[NMXRES+1]; + double RMASS[NMXRES+1]; + double RSPIN[NMXRES+1]; + int ICHRG[NMXRES+1]; + int IDPDG[NMXRES+1]; + int IFLAV[NMXRES+1]; + int NRES; + int VTOCDK[NMXRES+1]; + int VTORDK[NMXRES+1]; + int QORQQB[NMXRES+1]; + int QBORQQ[NMXRES+1]; +}; + +struct Hwunam_t { + char RNAME[NMXRES+1][8]; + char TXNAME[NMXRES+1][2][37]; +}; + +int const NMXDKS = 4000; +int const NMXMOD = 200; + +struct Hwupdt_t { + double BRFRAC[NMXDKS]; + double CMMOM[NMXDKS]; + double DKLTM[NMXRES]; + int IDK[NMXDKS]; + int IDKPRD[NMXDKS][5]; + int LNEXT[NMXDKS]; + int LSTRT[NMXRES]; + int NDKYS; + int NME[NMXDKS]; + int NMODES[NMXRES]; + int NPRODS[NMXDKS]; + int DKPSET; + int RSTAB[NMXRES+1]; +}; + +struct Hwuwts_t { + double REPWT[5][4][4]; + double SNGWT; + double DECWT; + double QWT[3]; + double PWT[12]; + double SWTEF[NMXRES]; +}; + +int const NMXCDK = 4000; + +struct Hwuclu_t { + double CLDKWT[NMXCDK]; + double CTHRPW[12][12]; + double PRECO; + double RESN[12][12]; + double RMIN[12][12]; + int LOCN[12][12]; + int NCLDK[NMXCDK]; + int NRECO; + int CLRECO; +}; + +struct Hwdist_t { + double EXAG; + double GEV2MM; + double HBAR; + double PLTCUT; + double VMIN2; + double VTXPIP[4]; + double XMIX[2]; + double XMRCT[2]; + double YMIX[2]; + double YMRCT[2]; + int IOPDKL; + int MAXDKL; + int MIXING; + int PIPSMR; +}; + +int const NMXQDK=20; + +struct Hwqdks_t { + double VTXQDK[NMXQDK][4]; + int IMQDK[NMXQDK]; + int LOCQ[NMXQDK]; + int NQDK; +}; + +int const NMXSUD = 1024; + +struct Hwusud_t { + double ACCUR; + double QEV[6][NMXSUD]; + double SUD[6][NMXSUD]; + int INTER; + int NQEV; + int NSUD; + int SUDORD; +}; + +struct Hwsusy_t { + double TANB; + double ALPHAH; + double COSBPA; + double SINBPA; + double COSBMA; + double SINBMA; + double COSA; + double SINA; + double COSB; + double SINB; + double COTB; + double ZMIXSS[4][4]; + double ZMXNSS[4][4]; + double ZSGNSS[4]; + double LFCH[16]; + double RFCH[16]; + double SLFCH[4][16]; + double SRFCH[4][16]; + double WMXUSS[2][2]; + double WMXVSS[2][2]; + double WSGNSS[2]; + double QMIXSS[2][2][6]; + double LMIXSS[2][2][6]; + double THETAT; + double THETAB; + double THETAL; + double ATSS; + double ABSS; + double ALSS; + double MUSS; + double FACTSS; + double GHWWSS[3]; + double GHZZSS[3]; + double GHDDSS[4]; + double GHUUSS[4]; + double GHWHSS[3]; + double GHSQSS[2][2][6][4]; + double XLMNSS; + double RMMNSS; + double IMSSM; + double SENHNC[24]; + double SSPARITY; + int SUSYIN; +}; + +struct Hwrpar_t { + double LAMDA1[3][3][3]; + double LAMDA2[3][3][3]; + double LAMDA3[3][3][3]; + int HRDCOL[5][2]; + int RPARTY; + int COLUPD; +}; + +struct Hwminb_t { + double PMBN1; + double PMBN2; + double PMBN3; + double PMBK1; + double PMBK2; + double PMBM1; + double PMBM2; + double PMBP1; + double PMBP2; + double PMBP3; +}; + +int const NMXCL = 500; + +struct Hwclus_t { + double PPCL[NMXCL][5]; + int IDCL[NMXCL]; + int NCL; +}; + + +extern "C" { + void hwigin_(); + void hwuinc_(); + void hwusta_(char * name, int); + void hweini_(); + void hwuine_(); + void hwepro_(); + void hwbgen_(); + void hwdhob_(); + void hwcfor_(); + void hwcdec_(); + void hwdhad_(); + void hwdhvy_(); + void hwmevt_(); + void hwufne_(); + void hwefin_(); +} + + + + + diff --git a/THerwig/Herwig6Calls.h b/THerwig/Herwig6Calls.h new file mode 100644 index 00000000000..09331dd6761 --- /dev/null +++ b/THerwig/Herwig6Calls.h @@ -0,0 +1,473 @@ +#ifndef ROOT_Herwig6Calls +#define ROOT_Herwig6Calls + +// Translation of Fortran commons from the Herwig6 +// f77 program into c++ structures to be used in ROOT +// and declaration of Fortran functions as extern +// C functions to be called from the class Herwig6 +// author: j. g. contreras jgcn@moni.mda.cinvestav.mx +// date: december 22, 2000 + +int const NMXHEP = 2000; + +struct Hepevt_t { + int NEVHEP; + int NHEP; + int ISTHEP[NMXHEP]; + int IDHEP[NMXHEP]; + int JMOHEP[NMXHEP][2]; + int JDAHEP[NMXHEP][2]; + double PHEP[NMXHEP][5]; + double VHEP[NMXHEP][4]; +}; + +struct Hwbeam_t { + int IPART1; + int IPART2; +}; + +struct Hwbmch_t { + char PART1[8]; + char PART2[8]; +}; + +struct Hwproc_t { + double EBEAM1; + double EBEAM2; + double PBEAM1; + double PBEAM2; + int IPROC; + int MAXEV; +}; + +struct Hwpram_t { + double AFCH[2][16]; + double ALPHEM; + double B1LIM; + double BETAF; + double BTCLM; + double CAFAC; + double CFFAC; + double CLMAX; + double CLPOW; + double CLSMR[2]; + double CSPEED; + double ENSOF; + double ETAMIX; + double F0MIX; + double F1MIX; + double F2MIX; + double GAMH; + double GAMW; + double GAMZ; + double GAMZP; + double GEV2NB; + double H1MIX; + double PDIQK; + double PGSMX; + double PGSPL[4]; + double PHIMIX; + double PIFAC; + double PRSOF; + double PSPLT[2]; + double PTRMS; + double PXRMS; + double QCDL3; + double QCDL5; + double QCDLAM; + double QDIQK; + double QFCH[16]; + double QG; + double QSPAC; + double QV; + double SCABI; + double SWEIN; + double TMTOP; + double VFCH[2][16]; + double VCKM[3][3]; + double VGCUT; + double VQCUT; + double VPCUT; + double ZBINM; + double EFFMIN; + double OMHMIX; + double ET2MIX; + double PH3MIX; + double GCUTME; + int IOPREM; + int IPRINT; + int ISPAC; + int LRSUD; + int LWSUD; + int MODPDF[2]; + int NBTRY; + int NCOLO; + int NCTRY; + int NDTRY; + int NETRY; + int NFLAV; + int NGSPL; + int NSTRU; + int NSTRY; + int NZBIN; + int IOP4JT[2]; + int NPRFMT; + int AZSOFT; + int AZSPIN; + int CLDIR[2]; + int HARDME; + int NOSPAC; + int PRNDEC; + int PRVTX; + int SOFTME; + int ZPRIME; + int PRNDEF; + int PRNTEX; + int PRNWEB; +}; + +struct Hwprch_t { + char AUTPDF[2][20]; + char BDECAY[4]; +}; + +int const NMXPAR = 500; + +struct Hwpart_t { + int NEVPAR; + int NPAR; + int ISTPAR[NMXPAR]; + int IDPAR[NMXPAR]; + int JMOPAR[NMXPAR][2]; + int JDAPAR[NMXPAR][2]; + double PPAR[NMXPAR][5]; + double VPAR[NMXPAR][4]; +}; + +struct Hwparp_t { + double DECPAR[NMXPAR][2]; + double PHIPAR[NMXPAR][2]; + double RHOPAR[NMXPAR][2]; + int TMPAR[NMXPAR]; +}; + +int const MODMAX = 5; + +struct Hwbosc_t { + double ALPFAC; + double BRHIG[12]; + double ENHANC[12]; + double GAMMAX; + double RHOHEP[NMXHEP][3]; + int IOPHIG; + int MODBOS[MODMAX]; +}; + +struct Hwparc_t { + int JCOPAR[NMXPAR][4]; +}; + +struct Hwbrch_t { + double ANOMSC[2][2]; + double HARDST; + double PTINT[2][3]; + double XFACT; + int INHAD; + int JNHAD; + int NSPAC[7]; + int ISLENT; + int BREIT; + int FROST; + int USECMF; +}; + +struct Hwevnt_t { + double AVWGT; + double EVWGT; + double GAMWT; + double TLOUT; + double WBIGST; + double WGTMAX; + double WGTSUM; + double WSQSUM; + int IDHW[NMXHEP]; + int IERROR; + int ISTAT; + int LWEVT; + int MAXER; + int MAXPR; + int NOWGT; + int NRN[2]; + int NUMER; + int NUMERU; + int NWGTS; + int GENSOF; +}; + +struct Hwhard_t { + double ASFIXD; + double CLQ[6][7]; + double COSS; + double COSTH; + double CTMAX; + double DISF[2][13]; + double EMLST; + double EMMAX; + double EMMIN; + double EMPOW; + double EMSCA; + double EPOLN[3]; + double GCOEF[7]; + double GPOLN; + double OMEGA0; + double PHOMAS; + double PPOLN[3]; + double PTMAX; + double PTMIN; + double PTPOW; + double Q2MAX; + double Q2MIN; + double Q2POW; + double Q2WWMN; + double Q2WWMX; + double QLIM; + double SINS; + double THMAX; + double Y4JT; + double TMNISR; + double TQWT; + double XX[2]; + double XLMIN; + double XXMIN; + double YBMAX; + double YBMIN; + double YJMAX; + double YJMIN; + double YWWMAX; + double YWWMIN; + double WHMIN; + double ZJMAX; + double ZMXISR; + int IAPHIG; + int IBRN[2]; + int IBSH; + int ICO[10]; + int IDCMF; + int IDN[10]; + int IFLMAX; + int IFLMIN; + int IHPRO; + int IPRO; + int MAPQ[10]; + int MAXFL; + int BGSHAT; + int COLISR; + int FSTEVT; + int FSTWGT; + int GENEV; + int HVFCEN; + int TPOL; + int DURHAM; +}; + +int const NMXRES = 500; + +struct Hwprop_t { + double RLTIM[NMXRES+1]; + double RMASS[NMXRES+1]; + double RSPIN[NMXRES+1]; + int ICHRG[NMXRES+1]; + int IDPDG[NMXRES+1]; + int IFLAV[NMXRES+1]; + int NRES; + int VTOCDK[NMXRES+1]; + int VTORDK[NMXRES+1]; + int QORQQB[NMXRES+1]; + int QBORQQ[NMXRES+1]; +}; + +struct Hwunam_t { + char RNAME[NMXRES+1][8]; + char TXNAME[NMXRES+1][2][37]; +}; + +int const NMXDKS = 4000; +int const NMXMOD = 200; + +struct Hwupdt_t { + double BRFRAC[NMXDKS]; + double CMMOM[NMXDKS]; + double DKLTM[NMXRES]; + int IDK[NMXDKS]; + int IDKPRD[NMXDKS][5]; + int LNEXT[NMXDKS]; + int LSTRT[NMXRES]; + int NDKYS; + int NME[NMXDKS]; + int NMODES[NMXRES]; + int NPRODS[NMXDKS]; + int DKPSET; + int RSTAB[NMXRES+1]; +}; + +struct Hwuwts_t { + double REPWT[5][4][4]; + double SNGWT; + double DECWT; + double QWT[3]; + double PWT[12]; + double SWTEF[NMXRES]; +}; + +int const NMXCDK = 4000; + +struct Hwuclu_t { + double CLDKWT[NMXCDK]; + double CTHRPW[12][12]; + double PRECO; + double RESN[12][12]; + double RMIN[12][12]; + int LOCN[12][12]; + int NCLDK[NMXCDK]; + int NRECO; + int CLRECO; +}; + +struct Hwdist_t { + double EXAG; + double GEV2MM; + double HBAR; + double PLTCUT; + double VMIN2; + double VTXPIP[4]; + double XMIX[2]; + double XMRCT[2]; + double YMIX[2]; + double YMRCT[2]; + int IOPDKL; + int MAXDKL; + int MIXING; + int PIPSMR; +}; + +int const NMXQDK=20; + +struct Hwqdks_t { + double VTXQDK[NMXQDK][4]; + int IMQDK[NMXQDK]; + int LOCQ[NMXQDK]; + int NQDK; +}; + +int const NMXSUD = 1024; + +struct Hwusud_t { + double ACCUR; + double QEV[6][NMXSUD]; + double SUD[6][NMXSUD]; + int INTER; + int NQEV; + int NSUD; + int SUDORD; +}; + +struct Hwsusy_t { + double TANB; + double ALPHAH; + double COSBPA; + double SINBPA; + double COSBMA; + double SINBMA; + double COSA; + double SINA; + double COSB; + double SINB; + double COTB; + double ZMIXSS[4][4]; + double ZMXNSS[4][4]; + double ZSGNSS[4]; + double LFCH[16]; + double RFCH[16]; + double SLFCH[4][16]; + double SRFCH[4][16]; + double WMXUSS[2][2]; + double WMXVSS[2][2]; + double WSGNSS[2]; + double QMIXSS[2][2][6]; + double LMIXSS[2][2][6]; + double THETAT; + double THETAB; + double THETAL; + double ATSS; + double ABSS; + double ALSS; + double MUSS; + double FACTSS; + double GHWWSS[3]; + double GHZZSS[3]; + double GHDDSS[4]; + double GHUUSS[4]; + double GHWHSS[3]; + double GHSQSS[2][2][6][4]; + double XLMNSS; + double RMMNSS; + double IMSSM; + double SENHNC[24]; + double SSPARITY; + int SUSYIN; +}; + +struct Hwrpar_t { + double LAMDA1[3][3][3]; + double LAMDA2[3][3][3]; + double LAMDA3[3][3][3]; + int HRDCOL[5][2]; + int RPARTY; + int COLUPD; +}; + +struct Hwminb_t { + double PMBN1; + double PMBN2; + double PMBN3; + double PMBK1; + double PMBK2; + double PMBM1; + double PMBM2; + double PMBP1; + double PMBP2; + double PMBP3; +}; + +int const NMXCL = 500; + +struct Hwclus_t { + double PPCL[NMXCL][5]; + int IDCL[NMXCL]; + int NCL; +}; + + +extern "C" { + void hwigin_(); + void hwuinc_(); + void hwusta_(char * name, int); + void hweini_(); + void hwuine_(); + void hwepro_(); + void hwbgen_(); + void hwdhob_(); + void hwcfor_(); + void hwcdec_(); + void hwdhad_(); + void hwdhvy_(); + void hwmevt_(); + void hwufne_(); + void hwefin_(); +} + + +#endif + + + diff --git a/THerwig/Makefile b/THerwig/Makefile new file mode 100644 index 00000000000..340c5ada471 --- /dev/null +++ b/THerwig/Makefile @@ -0,0 +1,99 @@ + +############################### THerwig6 Makefile ############################## + +# Include machine specific definitions + +include $(ALICE_ROOT)/conf/GeneralDef +include $(ALICE_ROOT)/conf/MachineDef.$(ALICE_TARGET) + +PACKAGE = THerwig6 + +# FORTRAN sources + +FSRCS = + +# C++ sources + +SRCS = THerwig6.cxx + +# C++ Headers + +HDRS = $(SRCS:.cxx=.h) THerwig6LinkDef.h + +# Library dictionary + +DICT = THerwig6Cint.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)/libTHerwig6.$(SL) +ALIBRARY = $(LIBDIR)/libTHerwig6.a + +default: $(SLIBRARY) + +$(LIBDIR)/libTHerwig6.$(SL): $(OBJS) + +$(DICT): $(HDRS) + +depend: $(SRCS) $(FSRCS) + +HEADERS = THerwig6.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/THerwig/THerwig6.cxx b/THerwig/THerwig6.cxx new file mode 100644 index 00000000000..52209ac4de4 --- /dev/null +++ b/THerwig/THerwig6.cxx @@ -0,0 +1,446 @@ + +// definition of c++ Class THerwig6 to be used in ROOT +// this is a c++ interface to the F77 Herwig6 program +// author: j. g. contreras jgcn@moni.mda.cinvestav.mx +// date: december 22, 2000 + +#include +#include "THerwig6.h" +#include "TClonesArray.h" +#include "TParticle.h" + + +ClassImp(THerwig6) + +extern "C" { + void* herwig6_common_block_address_(char*, int len); + void herwig6_open_fortran_file_ (int* lun, char* name, int); + void herwig6_close_fortran_file_(int* lun); +} + + +THerwig6::THerwig6() : TGenerator("Herwig6","Herwig6") { + +// THerwig6 constructor: creates a TClonesArray in which it will store all +// particles. Note that there may be only one functional THerwig6 object +// at a time, so it's not use to create more than one instance of it. + + delete fParticles; // was allocated as TObjArray in TGenerator + + fParticles = new TClonesArray("TParticle",50); + + // initialize common-blocks + fHepevt = (Hepevt_t*) herwig6_common_block_address_((char*)"HEPEVT",6); + fHwbeam = (Hwbeam_t*) herwig6_common_block_address_((char*)"HWBEAM",6); + fHwbmch = (Hwbmch_t*) herwig6_common_block_address_((char*)"HWBMCH",6); + fHwproc = (Hwproc_t*) herwig6_common_block_address_((char*)"HWPROC",6); + fHwpram = (Hwpram_t*) herwig6_common_block_address_((char*)"HWPRAM",6); + fHwprch = (Hwprch_t*) herwig6_common_block_address_((char*)"HWPRCH",6); + fHwpart = (Hwpart_t*) herwig6_common_block_address_((char*)"HWPART",6); + fHwparp = (Hwparp_t*) herwig6_common_block_address_((char*)"HWPARP",6); + fHwbosc = (Hwbosc_t*) herwig6_common_block_address_((char*)"HWBOSC",6); + fHwparc = (Hwparc_t*) herwig6_common_block_address_((char*)"HWPARC",6); + fHwbrch = (Hwbrch_t*) herwig6_common_block_address_((char*)"HWBRCH",6); + fHwevnt = (Hwevnt_t*) herwig6_common_block_address_((char*)"HWEVNT",6); + fHwhard = (Hwhard_t*) herwig6_common_block_address_((char*)"HWHARD",6); + fHwprop = (Hwprop_t*) herwig6_common_block_address_((char*)"HWPROP",6); + fHwunam = (Hwunam_t*) herwig6_common_block_address_((char*)"HWUNAM",6); + fHwupdt = (Hwupdt_t*) herwig6_common_block_address_((char*)"HWUPDT",6); + fHwuwts = (Hwuwts_t*) herwig6_common_block_address_((char*)"HWUWTS",6); + fHwuclu = (Hwuclu_t*) herwig6_common_block_address_((char*)"HWUCLU",6); + fHwdist = (Hwdist_t*) herwig6_common_block_address_((char*)"HWDIST",6); + fHwqdks = (Hwqdks_t*) herwig6_common_block_address_((char*)"HWQDKS",6); + fHwusud = (Hwusud_t*) herwig6_common_block_address_((char*)"HWUSUD",6); + fHwsusy = (Hwsusy_t*) herwig6_common_block_address_((char*)"HWSUSY",6); + fHwrpar = (Hwrpar_t*) herwig6_common_block_address_((char*)"HWRPAR",6); + fHwminb = (Hwminb_t*) herwig6_common_block_address_((char*)"HWMINB",6); + fHwclus = (Hwclus_t*) herwig6_common_block_address_((char*)"HWCLUS",6); + } + +//------------------------------------------------------------------------------ + THerwig6::~THerwig6() + { +// Destroys the object, deletes and disposes all TParticles currently on list. + + if (fParticles) { + fParticles->Delete(); + delete fParticles; + fParticles = 0; + } + } + +//______________________________________________________________________________ +void THerwig6::GenerateEvent() +{ + + //initialize event + hwuine_(); + // generate hard subprocess + hwepro_(); + // generate parton cascades + hwbgen_(); + // do heavy objects decay + hwdhob_(); + // do cluster formation + hwcfor_(); + // do cluster decays + hwcdec_(); + // do unstable particle decays + hwdhad_(); + // do heavy flavor hadrons decay + hwdhvy_(); + // add soft underlying event + hwmevt_(); + // finish event + hwufne_(); +} + +//______________________________________________________________________________ +void THerwig6::OpenFortranFile(int lun, char* name) { + herwig6_open_fortran_file_(&lun, name, strlen(name)); +} + +//______________________________________________________________________________ +void THerwig6::CloseFortranFile(int lun) { + herwig6_close_fortran_file_(&lun); +} + +void THerwig6::Initialize(const char *beam, const char *target, double pbeam1, double pbeam2, int iproc) + +{ + // perform the initialization for Herwig6 + // sets correct title. + // after calling this method all parameters are set to their default + // values. If you want to modify any parameter you have to set the new + // value after calling Initialize and before PrepareRun. + + char cbeam[8]; + strncpy(cbeam,beam,8); + char ctarget[8]; + strncpy(ctarget,target,8); + printf("\n Initializing Herwig !! \n"); + if ( (!strncmp(beam, "E+" ,2)) && + (!strncmp(beam, "E-" ,2)) && + (!strncmp(beam, "MU+" ,3)) && + (!strncmp(beam, "MU-" ,3)) && + (!strncmp(beam, "NUE" ,3)) && + (!strncmp(beam, "NUEB" ,4)) && + (!strncmp(beam, "NUMU" ,4)) && + (!strncmp(beam, "NMUB" ,4)) && + (!strncmp(beam, "NTAU" ,4)) && + (!strncmp(beam, "NTAB" ,4)) && + (!strncmp(beam, "GAMA" ,4)) && + (!strncmp(beam, "P ",8)) && + (!strncmp(beam, "PBAR ",8)) && + (!strncmp(beam, "N" ,1)) && + (!strncmp(beam, "NBAR" ,4)) && + (!strncmp(beam, "PI+" ,3)) && + (!strncmp(beam, "PI-" ,3)) ) { + printf("WARNING! In THerwig6:Initialize():\n"); + printf(" specified beam=%s is unrecognized .\n",beam); + printf(" resetting to \"P\" ."); + sprintf(cbeam,"P"); + } + + if ( (!strncmp(target, "E+" ,2)) && + (!strncmp(target, "E-" ,2)) && + (!strncmp(target, "MU+" ,3)) && + (!strncmp(target, "MU-" ,3)) && + (!strncmp(target, "NUE" ,3)) && + (!strncmp(target, "NUEB" ,4)) && + (!strncmp(target, "NUMU" ,4)) && + (!strncmp(target, "NMUB" ,4)) && + (!strncmp(target, "NTAU" ,4)) && + (!strncmp(target, "NTAB" ,4)) && + (!strncmp(target, "GAMA" ,4)) && + (!strncmp(target, "P ",8)) && + (!strncmp(target, "PBAR ",8)) && + (!strncmp(target, "N" ,1)) && + (!strncmp(target, "NBAR" ,4)) && + (!strncmp(target, "PI+" ,3)) && + (!strncmp(target, "PI-" ,3)) ) { + printf("WARNING! In THerwig6:Initialize():\n"); + printf(" specified target=%s is unrecognized .\n",target); + printf(" resetting to \"P\" ."); + sprintf(ctarget,"P"); + } + + // initialization: + // type of beams + strncpy(fHwbmch->PART1,beam,8); + strncpy(fHwbmch->PART2,target,8); + // momentum of beams + fHwproc->PBEAM1=pbeam1; + fHwproc->PBEAM2=pbeam2; + // process to generate + fHwproc->IPROC=iproc; + // not used in the class definition + fHwproc->MAXEV=1; + + // reset all parameters + hwigin_(); + + // set correct title + char atitle[132]; + double win=pbeam1+pbeam2; + printf("\n %s - %s at %g GeV",beam,target,win); + sprintf(atitle,"%s-%s at %g GeV",cbeam,ctarget,win); + SetTitle(atitle); +} + +void THerwig6::PrepareRun() +{ + // compute parameter dependent constants + hwuinc_(); + // initialize elementary processes + hweini_(); +} + +//______________________________________________________________________________ +TObjArray* THerwig6::ImportParticles(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 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. +// + fParticles->Clear(); + Int_t numpart = fHepevt->NHEP; + TClonesArray &a = *((TClonesArray*)fParticles); + if (!strcmp(option,"") || !strcmp(option,"Final")) { + for (Int_t i = 0; i<=numpart; i++) { + if (fHepevt->ISTHEP[i] == 1) { +// +// Use the common block values for the TParticle constructor +// + new(a[i]) TParticle( + fHepevt->IDHEP[i], + fHepevt->ISTHEP[i], + fHepevt->JMOHEP[i][0]-1, + fHepevt->JMOHEP[i][1]-1, + fHepevt->JDAHEP[i][0]-1, + fHepevt->JDAHEP[i][1]-1, + + fHepevt->PHEP[i][0], + fHepevt->PHEP[i][1], + fHepevt->PHEP[i][2], + fHepevt->PHEP[i][3], + fHepevt->VHEP[i][0], + fHepevt->VHEP[i][1], + fHepevt->VHEP[i][2], + fHepevt->VHEP[i][3]); + } + } + } + else if (!strcmp(option,"All")) { + for (Int_t i = 0; i<=numpart; i++) { + new(a[i]) TParticle( + fHepevt->IDHEP[i], + fHepevt->ISTHEP[i], + fHepevt->JMOHEP[i][0]-1, + fHepevt->JMOHEP[i][1]-1, + fHepevt->JDAHEP[i][0]-1, + fHepevt->JDAHEP[i][1]-1, + + fHepevt->PHEP[i][0], + fHepevt->PHEP[i][1], + fHepevt->PHEP[i][2], + fHepevt->PHEP[i][3], + fHepevt->VHEP[i][0], + fHepevt->VHEP[i][1], + fHepevt->VHEP[i][2], + fHepevt->VHEP[i][3]); + } + } + return fParticles; +} + +//______________________________________________________________________________ +Int_t THerwig6::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 store 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(); + Int_t numpart = fHepevt->NHEP; + if (!strcmp(option,"") || !strcmp(option,"Final")) { + for (Int_t i = 0; i< numpart; i++) { + if (fHepevt->ISTHEP[i] == 1) { +// +// Use the common block values for the TParticle constructor +// + new(Particles[i]) TParticle( + fHepevt->IDHEP[i], + fHepevt->ISTHEP[i], + fHepevt->JMOHEP[i][0]-1, + fHepevt->JMOHEP[i][1]-1, + fHepevt->JDAHEP[i][0]-1, + fHepevt->JDAHEP[i][1]-1, + + fHepevt->PHEP[i][0], + fHepevt->PHEP[i][1], + fHepevt->PHEP[i][2], + fHepevt->PHEP[i][3], + fHepevt->VHEP[i][0], + fHepevt->VHEP[i][1], + fHepevt->VHEP[i][2], + fHepevt->VHEP[i][3]); + } + } + } + else if (!strcmp(option,"All")) { + for (Int_t i = 0; i< numpart; i++) { + new(Particles[i]) TParticle( + fHepevt->IDHEP[i], + fHepevt->ISTHEP[i], + fHepevt->JMOHEP[i][0]-1, + fHepevt->JMOHEP[i][1]-1, + fHepevt->JDAHEP[i][0]-1, + fHepevt->JDAHEP[i][1]-1, + + fHepevt->PHEP[i][0], + fHepevt->PHEP[i][1], + fHepevt->PHEP[i][2], + fHepevt->PHEP[i][3], + fHepevt->VHEP[i][0], + fHepevt->VHEP[i][1], + fHepevt->VHEP[i][2], + fHepevt->VHEP[i][3]); + } + } + return numpart; +} + +void THerwig6::Hwigin() +{ + hwigin_(); +} + +void THerwig6::Hwuinc() +{ + hwuinc_(); +} + +void THerwig6::Hwusta(char* name) + +{ + hwusta_(name,8); +} + +void THerwig6::Hweini() + +{ + hweini_(); +} + +void THerwig6::Hwuine() + +{ + hwuine_(); +} + +void THerwig6::Hwepro() + +{ + hwepro_(); +} + +void THerwig6::Hwbgen() + +{ + hwbgen_(); +} + +void THerwig6::Hwdhob() + +{ + hwdhob_(); +} + +void THerwig6::Hwcfor() + +{ + hwcfor_(); +} + +void THerwig6::Hwcdec() + +{ + hwcdec_(); +} + +void THerwig6::Hwdhad() + +{ + hwdhad_(); +} + +void THerwig6::Hwdhvy() + +{ + hwdhvy_(); +} + +void THerwig6::Hwmevt() + +{ + hwmevt_(); +} + +void THerwig6::Hwufne() + +{ + hwufne_(); +} + +void THerwig6::Hwefin() + +{ + hwefin_(); +} + +void THerwig6::SetupTest() +{ + // exampe of running herwig and generating one event + // after changing some options + Initialize("P","PBAR",900.,900.,1500); + // here you can set some parameters + SetPTMIN(15.); // Min pt in hadronic jet production + SetYJMIN(-4.); // Min jet rapidity + SetYJMAX(4.); // Max jet rapidity + // after you set your wished parameters + // herwig can do its work + PrepareRun(); + int n_ev_to_generate=1; + for (int i=0;iPrint(); + }; + }; +} + + + + + diff --git a/THerwig/THerwig6.h b/THerwig/THerwig6.h new file mode 100644 index 00000000000..e2b9d516b51 --- /dev/null +++ b/THerwig/THerwig6.h @@ -0,0 +1,765 @@ +#ifndef ROOT_THerwig +#define ROOT_THerwig + +// declaration of c++ Class THerwig6 to be used in ROOT +// this is a c++ interface to the F77 Herwig6 program +// author: j. g. contreras jgcn@moni.mda.cinvestav.mx +// date: december 22, 2000 + +/* + + Class THerwig6 is an interface to the Herwig program + +C----------------------------------------------------------------------- +C H E R W I G +C +C a Monte Carlo event generator for simulating +C +---------------------------------------------------+ +C | Hadron Emission Reactions With Interfering Gluons | +C +---------------------------------------------------+ +C I.G. Knowles(*), G. Marchesini(+), M.H. Seymour($) and B.R. Webber(#) +C----------------------------------------------------------------------- +C with Minimal Supersymmetric Standard Model Matrix Elements by +C S. Moretti($) and K. Odagiri($) +C----------------------------------------------------------------------- +C R parity violating Supersymmetric Decays and Matrix Elements by +C P. Richardson(&) +C----------------------------------------------------------------------- +C matrix element corrections to top decay and Drell-Yan type processes +C by G. Corcella(+) +C----------------------------------------------------------------------- +C Deep Inelastic Scattering and Heavy Flavour Electroproduction by +C G. Abbiendi(@) and L. Stanco(%) +C----------------------------------------------------------------------- +C and Jet Photoproduction in Lepton-Hadron Collisions by J. Chyla(~) +C----------------------------------------------------------------------- +C(*) Department of Physics & Astronomy, University of Edinburgh +C(+) Dipartimento di Fisica, Universita di Milano +C($) Rutherford Appleton Laboratory +C(#) Cavendish Laboratory, Cambridge +C(&) Department of Physics, University of Oxford +C(@) Dipartimento di Fisica, Universita di Bologna +C(%) Dipartimento di Fisica, Universita di Padova +C(~) Institute of Physics, Prague +C----------------------------------------------------------------------- +C Version 6.100 - 16th December 1999 +C----------------------------------------------------------------------- +C Main reference: +C G.Marchesini, B.R.Webber, G.Abbiendi, I.G.Knowles, M.H.Seymour, +C and L.Stanco, Computer Physics Communications 67 (1992) 465. +C----------------------------------------------------------------------- +C Please send e-mail about this program to one of the authors at the +C following Internet addresses: +C I.Knowles@ed.ac.uk Giuseppe.Marchesini@mi.infn.it +C M.Seymour@rl.ac.uk webber@hep.phy.cam.ac.uk +C----------------------------------------------------------------------- +*/ + +/* declarations from ROOT */ +#include "TGenerator.h" +#include "TObjArray.h" + +// Translation of Fortran commons from the Herwig6 +// f77 program into c++ structures to be used in ROOT +// and declaration of Fortran functions as extern +// C functions to be called from the class Herwig6 +// author: j. g. contreras jgcn@moni.mda.cinvestav.mx +// date: december 22, 2000 + +int const NMXHEP = 2000; + +struct Hepevt_t { + int NEVHEP; + int NHEP; + int ISTHEP[NMXHEP]; + int IDHEP[NMXHEP]; + int JMOHEP[NMXHEP][2]; + int JDAHEP[NMXHEP][2]; + double PHEP[NMXHEP][5]; + double VHEP[NMXHEP][4]; +}; + +struct Hwbeam_t { + int IPART1; + int IPART2; +}; + +struct Hwbmch_t { + char PART1[8]; + char PART2[8]; +}; + +struct Hwproc_t { + double EBEAM1; + double EBEAM2; + double PBEAM1; + double PBEAM2; + int IPROC; + int MAXEV; +}; + +struct Hwpram_t { + double AFCH[2][16]; + double ALPHEM; + double B1LIM; + double BETAF; + double BTCLM; + double CAFAC; + double CFFAC; + double CLMAX; + double CLPOW; + double CLSMR[2]; + double CSPEED; + double ENSOF; + double ETAMIX; + double F0MIX; + double F1MIX; + double F2MIX; + double GAMH; + double GAMW; + double GAMZ; + double GAMZP; + double GEV2NB; + double H1MIX; + double PDIQK; + double PGSMX; + double PGSPL[4]; + double PHIMIX; + double PIFAC; + double PRSOF; + double PSPLT[2]; + double PTRMS; + double PXRMS; + double QCDL3; + double QCDL5; + double QCDLAM; + double QDIQK; + double QFCH[16]; + double QG; + double QSPAC; + double QV; + double SCABI; + double SWEIN; + double TMTOP; + double VFCH[2][16]; + double VCKM[3][3]; + double VGCUT; + double VQCUT; + double VPCUT; + double ZBINM; + double EFFMIN; + double OMHMIX; + double ET2MIX; + double PH3MIX; + double GCUTME; + int IOPREM; + int IPRINT; + int ISPAC; + int LRSUD; + int LWSUD; + int MODPDF[2]; + int NBTRY; + int NCOLO; + int NCTRY; + int NDTRY; + int NETRY; + int NFLAV; + int NGSPL; + int NSTRU; + int NSTRY; + int NZBIN; + int IOP4JT[2]; + int NPRFMT; + int AZSOFT; + int AZSPIN; + int CLDIR[2]; + int HARDME; + int NOSPAC; + int PRNDEC; + int PRVTX; + int SOFTME; + int ZPRIME; + int PRNDEF; + int PRNTEX; + int PRNWEB; +}; + +struct Hwprch_t { + char AUTPDF[2][20]; + char BDECAY[4]; +}; + +int const NMXPAR = 500; + +struct Hwpart_t { + int NEVPAR; + int NPAR; + int ISTPAR[NMXPAR]; + int IDPAR[NMXPAR]; + int JMOPAR[NMXPAR][2]; + int JDAPAR[NMXPAR][2]; + double PPAR[NMXPAR][5]; + double VPAR[NMXPAR][4]; +}; + +struct Hwparp_t { + double DECPAR[NMXPAR][2]; + double PHIPAR[NMXPAR][2]; + double RHOPAR[NMXPAR][2]; + int TMPAR[NMXPAR]; +}; + +int const MODMAX = 5; + +struct Hwbosc_t { + double ALPFAC; + double BRHIG[12]; + double ENHANC[12]; + double GAMMAX; + double RHOHEP[NMXHEP][3]; + int IOPHIG; + int MODBOS[MODMAX]; +}; + +struct Hwparc_t { + int JCOPAR[NMXPAR][4]; +}; + +struct Hwbrch_t { + double ANOMSC[2][2]; + double HARDST; + double PTINT[2][3]; + double XFACT; + int INHAD; + int JNHAD; + int NSPAC[7]; + int ISLENT; + int BREIT; + int FROST; + int USECMF; +}; + +struct Hwevnt_t { + double AVWGT; + double EVWGT; + double GAMWT; + double TLOUT; + double WBIGST; + double WGTMAX; + double WGTSUM; + double WSQSUM; + int IDHW[NMXHEP]; + int IERROR; + int ISTAT; + int LWEVT; + int MAXER; + int MAXPR; + int NOWGT; + int NRN[2]; + int NUMER; + int NUMERU; + int NWGTS; + int GENSOF; +}; + +struct Hwhard_t { + double ASFIXD; + double CLQ[6][7]; + double COSS; + double COSTH; + double CTMAX; + double DISF[2][13]; + double EMLST; + double EMMAX; + double EMMIN; + double EMPOW; + double EMSCA; + double EPOLN[3]; + double GCOEF[7]; + double GPOLN; + double OMEGA0; + double PHOMAS; + double PPOLN[3]; + double PTMAX; + double PTMIN; + double PTPOW; + double Q2MAX; + double Q2MIN; + double Q2POW; + double Q2WWMN; + double Q2WWMX; + double QLIM; + double SINS; + double THMAX; + double Y4JT; + double TMNISR; + double TQWT; + double XX[2]; + double XLMIN; + double XXMIN; + double YBMAX; + double YBMIN; + double YJMAX; + double YJMIN; + double YWWMAX; + double YWWMIN; + double WHMIN; + double ZJMAX; + double ZMXISR; + int IAPHIG; + int IBRN[2]; + int IBSH; + int ICO[10]; + int IDCMF; + int IDN[10]; + int IFLMAX; + int IFLMIN; + int IHPRO; + int IPRO; + int MAPQ[10]; + int MAXFL; + int BGSHAT; + int COLISR; + int FSTEVT; + int FSTWGT; + int GENEV; + int HVFCEN; + int TPOL; + int DURHAM; +}; + +int const NMXRES = 500; + +struct Hwprop_t { + double RLTIM[NMXRES+1]; + double RMASS[NMXRES+1]; + double RSPIN[NMXRES+1]; + int ICHRG[NMXRES+1]; + int IDPDG[NMXRES+1]; + int IFLAV[NMXRES+1]; + int NRES; + int VTOCDK[NMXRES+1]; + int VTORDK[NMXRES+1]; + int QORQQB[NMXRES+1]; + int QBORQQ[NMXRES+1]; +}; + +struct Hwunam_t { + char RNAME[NMXRES+1][8]; + char TXNAME[NMXRES+1][2][37]; +}; + +int const NMXDKS = 4000; +int const NMXMOD = 200; + +struct Hwupdt_t { + double BRFRAC[NMXDKS]; + double CMMOM[NMXDKS]; + double DKLTM[NMXRES]; + int IDK[NMXDKS]; + int IDKPRD[NMXDKS][5]; + int LNEXT[NMXDKS]; + int LSTRT[NMXRES]; + int NDKYS; + int NME[NMXDKS]; + int NMODES[NMXRES]; + int NPRODS[NMXDKS]; + int DKPSET; + int RSTAB[NMXRES+1]; +}; + +struct Hwuwts_t { + double REPWT[5][4][4]; + double SNGWT; + double DECWT; + double QWT[3]; + double PWT[12]; + double SWTEF[NMXRES]; +}; + +int const NMXCDK = 4000; + +struct Hwuclu_t { + double CLDKWT[NMXCDK]; + double CTHRPW[12][12]; + double PRECO; + double RESN[12][12]; + double RMIN[12][12]; + int LOCN[12][12]; + int NCLDK[NMXCDK]; + int NRECO; + int CLRECO; +}; + +struct Hwdist_t { + double EXAG; + double GEV2MM; + double HBAR; + double PLTCUT; + double VMIN2; + double VTXPIP[4]; + double XMIX[2]; + double XMRCT[2]; + double YMIX[2]; + double YMRCT[2]; + int IOPDKL; + int MAXDKL; + int MIXING; + int PIPSMR; +}; + +int const NMXQDK=20; + +struct Hwqdks_t { + double VTXQDK[NMXQDK][4]; + int IMQDK[NMXQDK]; + int LOCQ[NMXQDK]; + int NQDK; +}; + +int const NMXSUD = 1024; + +struct Hwusud_t { + double ACCUR; + double QEV[6][NMXSUD]; + double SUD[6][NMXSUD]; + int INTER; + int NQEV; + int NSUD; + int SUDORD; +}; + +struct Hwsusy_t { + double TANB; + double ALPHAH; + double COSBPA; + double SINBPA; + double COSBMA; + double SINBMA; + double COSA; + double SINA; + double COSB; + double SINB; + double COTB; + double ZMIXSS[4][4]; + double ZMXNSS[4][4]; + double ZSGNSS[4]; + double LFCH[16]; + double RFCH[16]; + double SLFCH[4][16]; + double SRFCH[4][16]; + double WMXUSS[2][2]; + double WMXVSS[2][2]; + double WSGNSS[2]; + double QMIXSS[2][2][6]; + double LMIXSS[2][2][6]; + double THETAT; + double THETAB; + double THETAL; + double ATSS; + double ABSS; + double ALSS; + double MUSS; + double FACTSS; + double GHWWSS[3]; + double GHZZSS[3]; + double GHDDSS[4]; + double GHUUSS[4]; + double GHWHSS[3]; + double GHSQSS[2][2][6][4]; + double XLMNSS; + double RMMNSS; + double IMSSM; + double SENHNC[24]; + double SSPARITY; + int SUSYIN; +}; + +struct Hwrpar_t { + double LAMDA1[3][3][3]; + double LAMDA2[3][3][3]; + double LAMDA3[3][3][3]; + int HRDCOL[5][2]; + int RPARTY; + int COLUPD; +}; + +struct Hwminb_t { + double PMBN1; + double PMBN2; + double PMBN3; + double PMBK1; + double PMBK2; + double PMBM1; + double PMBM2; + double PMBP1; + double PMBP2; + double PMBP3; +}; + +int const NMXCL = 500; + +struct Hwclus_t { + double PPCL[NMXCL][5]; + int IDCL[NMXCL]; + int NCL; +}; + + +extern "C" { + void hwigin_(); + void hwuinc_(); + void hwusta_(char * name, int); + void hweini_(); + void hwuine_(); + void hwepro_(); + void hwbgen_(); + void hwdhob_(); + void hwcfor_(); + void hwcdec_(); + void hwdhad_(); + void hwdhvy_(); + void hwmevt_(); + void hwufne_(); + void hwefin_(); +} + + + + + + +/* THerwig6 class declaration */ +class THerwig6 : public TGenerator { +protected: + // Standard hep common block + Hepevt_t* fHepevt; + // Herwig6 common-blocks + Hwbeam_t* fHwbeam; + Hwbmch_t* fHwbmch; + Hwproc_t* fHwproc; + Hwpram_t* fHwpram; + Hwprch_t* fHwprch; + Hwpart_t* fHwpart; + Hwparp_t* fHwparp; + Hwbosc_t* fHwbosc; + Hwparc_t* fHwparc; + Hwbrch_t* fHwbrch; + Hwevnt_t* fHwevnt; + Hwhard_t* fHwhard; + Hwprop_t* fHwprop; + Hwunam_t* fHwunam; + Hwupdt_t* fHwupdt; + Hwuwts_t* fHwuwts; + Hwuclu_t* fHwuclu; + Hwdist_t* fHwdist; + Hwqdks_t* fHwqdks; + Hwusud_t* fHwusud; + Hwsusy_t* fHwsusy; + Hwrpar_t* fHwrpar; + Hwminb_t* fHwminb; + Hwclus_t* fHwclus; +//---------------------------------------------------------------------------- +// functions: +//---------------------------------------------------------------------------- +public: + // ****** constructors and destructor + THerwig6(); + virtual ~THerwig6(); + + // acces to hep common block + Hepevt_t* GetHepevt () { return fHepevt; } + int GetNevhep () { return fHepevt->NEVHEP; } + int GetNhep () { return fHepevt->NHEP; } + int GetISTHEP (int i) { return fHepevt->ISTHEP[i-1]; } + int GetIDHEP (int i) { return fHepevt->IDHEP[i-1]; } + int GetJMOHEP (int i, int j) { return fHepevt->JMOHEP[i-1][j-1]; } + int GetJDAHEP (int i, int j) { return fHepevt->JDAHEP[i-1][j-1]; } + double GetPHEP (int i, int j) { return fHepevt->PHEP[i-1][j-1]; } + double GetVHEP (int i, int j) { return fHepevt->VHEP[i-1][j-1]; } + + // access to Herwig6 common-blocks + // WARNING: Some arrays start in 1, others in 0. Look up the manual! + + // /HWBEAM/ + + Hwbeam_t* GetHwbeam () { return fHwbeam; } + int GetIPART1 () { return fHwbeam->IPART1; } + int GetIPART2 () { return fHwbeam->IPART2; } + + // /HWBMCH/ + Hwbmch_t* GetHwbmch () { return fHwbmch; } + char* GetPART1 () { return fHwbmch->PART1; } + char* GetPART2 () { return fHwbmch->PART2; } + + + // /HWPROC/ + Hwproc_t* GetHwproc () { return fHwproc; } + double GetEBEAM1 () { return fHwproc->EBEAM1; } + double GetEBEAM2 () { return fHwproc->EBEAM2; } + double GetPBEAM1 () { return fHwproc->PBEAM1; } + double GetPBEAM2 () { return fHwproc->PBEAM2; } + int GetIPROC () { return fHwproc->IPROC; } + int GetMAXEV () { return fHwproc->MAXEV; } + + // /HWPRAM/ + Hwpram_t* GetHwpram () { return fHwpram; } + double GetQCDLAM () { return fHwpram->QCDLAM; } + void SetQCDLAM (double q) { fHwpram->QCDLAM = q; } + double GetVQCUT () { return fHwpram->VQCUT; } + void SetVQCUT (double v) { fHwpram->VQCUT = v; } + double GetVGCUT () { return fHwpram->VGCUT; } + void SetVGCUT (double v) { fHwpram->VGCUT = v; } + double GetVPCUT () { return fHwpram->VPCUT; } + void SetVPCUT (double v) { fHwpram->VPCUT = v; } + double GetCLMAX () { return fHwpram->CLMAX; } + void SetCLMAX (double c) { fHwpram->CLMAX = c; } + double GetCLPOW () { return fHwpram->CLPOW; } + void SetCLPOW (double c) { fHwpram->CLPOW = c; } + double GetPSPLT (int i) { return fHwpram->PSPLT[i-1];} + void SetPSPLT (int i, double p) { fHwpram->PSPLT[i-1] = p;} + double GetQDIQK () { return fHwpram->QDIQK; } + void SetQDIQK (double q) { fHwpram->QDIQK = q; } + double GetPDIQK () { return fHwpram->PDIQK; } + void SetPDIQK (double p) { fHwpram->PDIQK = p; } + double GetQSPAC () { return fHwpram->QSPAC; } + void SetQSPAC (double q) { fHwpram->QSPAC = q; } + double GetPTRMS () { return fHwpram->PTRMS; } + void SetPTRMS (double p) { fHwpram->PTRMS = p; } + double GetENSOF () { return fHwpram->ENSOF; } + void SetENSOF (double e) { fHwpram->ENSOF = e; } + int GetIPRINT () { return fHwpram->IPRINT; } + void SetIPRINT (int i) { fHwpram->IPRINT = i; } + int GetMODPDF (int i) { return fHwpram->MODPDF[i-1];} + void SetMODPDF (int i, int j) { fHwpram->MODPDF[i-1] = j; } + int GetNSTRU () { return fHwpram->NSTRU; } + void SetNSTRU (int i) { fHwpram->NSTRU = i; } + + // /HWPRCH/ + Hwprch_t* GetHwprch () { return fHwprch; } + char* GetAUTPDF (int i) { return fHwprch->AUTPDF[i-1]; } + void SetAUTPDF(int i,const char* s){ strncpy(fHwprch->AUTPDF[i-1],s,20);} + char* GetBDECAY () { return fHwprch->BDECAY; } + + // /HWPART/ + Hwpart_t* GetHwpart () { return fHwpart; } + + // /HWPARP/ + Hwparp_t* GetHwparp () { return fHwparp; } + + // /HWBOSC/ + Hwbosc_t* GetHwbosc () { return fHwbosc; } + + // /HWPARC/ + Hwparc_t* GetHwparc () { return fHwparc; } + + // /HWBRCH/ + Hwbrch_t* GetHwbrch () { return fHwbrch; } + + // /HWEVNT/ + Hwevnt_t* GetHwevnt () { return fHwevnt; } + double GetAVWGT () { return fHwevnt->AVWGT; } + int GetMAXPR () { return fHwevnt->MAXPR; } + void SetMAXPR (int i) { fHwevnt->MAXPR = i; } + int GetMAXER () { return fHwevnt->MAXER; } + void SetMAXER (int i) { fHwevnt->MAXER = i; } + int GetNRN (int i) { return fHwevnt->NRN[i-1]; } + void SetNRN (int i, int j) { fHwevnt->NRN[i-1] = j; } + + // /HWHARD/ + Hwhard_t* GetHwhard () { return fHwhard; } + double GetPTMIN () { return fHwhard->PTMIN; } + void SetPTMIN (double d) { fHwhard->PTMIN = d; } + double GetPTPOW () { return fHwhard->PTPOW; } + void SetPTPOW (double d) { fHwhard->PTPOW = d; } + double GetYJMIN () { return fHwhard->YJMIN; } + void SetYJMIN (double d) { fHwhard->YJMIN = d; } + double GetYJMAX () { return fHwhard->YJMAX; } + void SetYJMAX (double d) { fHwhard->YJMAX = d; } + double GetQ2MIN () { return fHwhard->Q2MIN; } + void SetQ2MIN (double d) { fHwhard->Q2MIN = d; } + double GetQ2MAX () { return fHwhard->Q2MAX; } + void SetQ2MAX (double d) { fHwhard->Q2MAX = d; } + double GetYBMIN () { return fHwhard->YBMIN; } + void SetYBMIN (double d) { fHwhard->YBMIN = d; } + double GetYBMAX () { return fHwhard->YBMAX; } + void SetYBMAX (double d) { fHwhard->YBMAX = d; } + double GetZJMAX () { return fHwhard->ZJMAX; } + void SetZJMAX (double d) { fHwhard->ZJMAX = d; } + + // /HWPROP/ + Hwprop_t* GetHwprop () { return fHwprop; } + double GetRMASS (int i) { return fHwprop->RMASS[i]; } + void SetRMASS (int i, double r) { fHwprop->RMASS[i] = r; } + + // /HWUNAM/ + Hwunam_t* GetHwunam () { return fHwunam; } + + // /HWUPDT/ + Hwupdt_t* GetHwupdt () { return fHwupdt; } + + // /HWUWTS/ + Hwuwts_t* GetHwuwts () { return fHwuwts; } + + // /HWUCLU/ + Hwuclu_t* GetHwuclu () { return fHwuclu; } + + // /HWDIST/ + Hwdist_t* GetHwdist () { return fHwdist; } + + // /HWQDKT/ + Hwqdks_t* GetHwqdkt () { return fHwqdks; } + + // /HWUSUD/ + Hwusud_t* GetHwusud () { return fHwusud; } + + // /HWSUSY/ + Hwsusy_t* GetHwsusy () { return fHwsusy; } + + // /HWRPAR/ + Hwrpar_t* GetHwrpar () { return fHwrpar; } + + // /HWMINB/ + Hwminb_t* GetHwminb () { return fHwminb; } + + // /HWCLUS/ + Hwclus_t* GetHwclus () { return fHwclus; } + + // Herwig6 routines + // the user would call + // Initialize + // change by himself the parameters s/he wants + // Hwusta to make stable the particles s/he wants + // PrepareRun + // GenerateEvent as many times as wished + // An example is given in SetupTest + + void GenerateEvent(); + void Initialize(const char *beam, const char *target, double pbeam1, double pbeam2, int iproc); + void PrepareRun(); + void OpenFortranFile(int lun, char* name); + void CloseFortranFile(int lun); + Int_t ImportParticles(TClonesArray *particles, Option_t *option=""); + TObjArray *ImportParticles(Option_t *option=""); + TObjArray *Particles() { return fParticles; } + void Hwigin(); + void Hwuinc(); + void Hwusta(char * name); + void Hweini(); + void Hwuine(); + void Hwepro(); + void Hwbgen(); + void Hwdhob(); + void Hwcfor(); + void Hwcdec(); + void Hwdhad(); + void Hwdhvy(); + void Hwmevt(); + void Hwufne(); + void Hwefin(); + void SetupTest(); + + ClassDef(THerwig6,0) //Interface to Herwig6.1 Event Generator +}; + +#endif diff --git a/THerwig/THerwigLinkDef.h b/THerwig/THerwigLinkDef.h new file mode 100644 index 00000000000..b8ab010699e --- /dev/null +++ b/THerwig/THerwigLinkDef.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 THerwig6+; + +#endif diff --git a/THerwig/libTHerwig.pkg b/THerwig/libTHerwig.pkg new file mode 100644 index 00000000000..d839e3b83dd --- /dev/null +++ b/THerwig/libTHerwig.pkg @@ -0,0 +1,7 @@ +SRCS= THerwig6.cxx + +HDRS= THerwig6.h + +DHDR:=THerwigLinkDef.h + +EXPORT:=THerwig6.h \ No newline at end of file -- 2.39.3