Interface to HERWIG
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 15 Jul 2002 17:10:29 +0000 (17:10 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 15 Jul 2002 17:10:29 +0000 (17:10 +0000)
THerwig/HCommon.h [new file with mode: 0644]
THerwig/Herwig6Calls.h [new file with mode: 0644]
THerwig/Makefile [new file with mode: 0644]
THerwig/THerwig6.cxx [new file with mode: 0644]
THerwig/THerwig6.h [new file with mode: 0644]
THerwig/THerwigLinkDef.h [new file with mode: 0644]
THerwig/libTHerwig.pkg [new file with mode: 0644]

diff --git a/THerwig/HCommon.h b/THerwig/HCommon.h
new file mode 100644 (file)
index 0000000..c594395
--- /dev/null
@@ -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 (file)
index 0000000..09331dd
--- /dev/null
@@ -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 (file)
index 0000000..340c5ad
--- /dev/null
@@ -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 (file)
index 0000000..52209ac
--- /dev/null
@@ -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 <stream.h>
+#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;i<n_ev_to_generate;i++)
+    {
+      GenerateEvent();
+      // do your stuff. For ex:
+      int n_of_par=GetNumberOfParticles(); // from TGenerator
+      for (int j=0; j<n_of_par; j++)
+       {
+         TParticle* p=GetParticle(j);
+         // here you do whatever you want with the particle
+         p->Print();
+       };
+    };
+}
+
+
+
+
+
diff --git a/THerwig/THerwig6.h b/THerwig/THerwig6.h
new file mode 100644 (file)
index 0000000..e2b9d51
--- /dev/null
@@ -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 (file)
index 0000000..b8ab010
--- /dev/null
@@ -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 (file)
index 0000000..d839e3b
--- /dev/null
@@ -0,0 +1,7 @@
+SRCS= THerwig6.cxx
+
+HDRS= THerwig6.h
+
+DHDR:=THerwigLinkDef.h
+
+EXPORT:=THerwig6.h
\ No newline at end of file