herwig.h

Go to the documentation of this file.

#ifndef HERWIG_INC
#define HERWIG_INC

//-------------------------HERWIG common block -------------------------------------
// COMMON block stuff, that doesn't come with the HerwigWrapper6_4.h ....

/*C Arrays for particle properties (NMXRES = max no of particles defined)
      PARAMETER(NMXRES=500)
      COMMON/HWPROP/RLTIM(0:NMXRES),RMASS(0:NMXRES),RSPIN(0:NMXRES),
     & ICHRG(0:NMXRES),IDPDG(0:NMXRES),IFLAV(0:NMXRES),NRES,
     & VTOCDK(0:NMXRES),VTORDK(0:NMXRES),
     & QORQQB(0:NMXRES),QBORQQ(0:NMXRES) */

static const int nmxres = 500+1; // we need NMXRES+1 entries ...
extern "C" {
  extern struct {
    double RLTIM[nmxres], RMASS[nmxres], RSPIN[nmxres];
    int ICHRG[nmxres], IDPDG[nmxres],IFLAV[nmxres], NRES;
    int VTOCDK[nmxres], VTORDK[nmxres], QORQQB[nmxres], QBORQQ[nmxres];    
  } hwprop_;
}
#define hwprop hwprop_

/*C Parameters for Sudakov form factors
C (NMXSUD= max no of entries in lookup table)
      PARAMETER (NMXSUD=1024)
      COMMON/HWUSUD/ACCUR,QEV(NMXSUD,6),SUD(NMXSUD,6),INTER,NQEV,NSUD,
      & SUDORD*/

static const int nmxsud = 1024;
extern "C" {
  extern struct {
    double ACCUR, QEV[6][nmxsud],SUD[6][nmxsud];
    int INTER, NQEV, NSUD, SUDORD;
  } hwusud_;
}
#define hwusud hwusud_

/*C  New parameters for version 6.203
      DOUBLE PRECISION ABWGT,ABWSUM,AVABW
      INTEGER NNEGWT,NNEGEV
      LOGICAL NEGWTS
      COMMON/HW6203/ABWGT,ABWSUM,AVABW,NNEGWT,NNEGEV,NEGWTS */

extern"C" {
  extern struct {
    double ABWGT, ABWSUM, AVABW;
    int NNEGWT,NNEGEV,NEGWTS;
  } hw6203_;
}
#define hw6203 hw6203_


/*CHARACTER*20
     & AUTPDF
     COMMON/HWPRCH/AUTPDF(2),BDECAY   */

extern "C" {
  extern struct {
    char AUTPDF[2][20],BDECAY[4];
  } hwprch_;
}
#define hwprch hwprch_

/*C Parameters for minimum bias/soft underlying event
      COMMON/HWMINB/
      & PMBN1,PMBN2,PMBN3,PMBK1,PMBK2,PMBM1,PMBM2,PMBP1,PMBP2,PMBP3  */

extern "C" {
  extern struct {
    double PMBN1,PMBN2,PMBN3,PMBK1,PMBK2,PMBM1,PMBM2,PMBP1,PMBP2,PMBP3;
  } hwminb_;
}
#define hwminb hwminb_

/*C Variables controling mixing and vertex information
C--VTXPIP should have been a 5-vector, problems with NAG compiler
      COMMON/HWDIST/EXAG,GEV2MM,HBAR,PLTCUT,VMIN2,VTXPIP(5),XMIX(2),
      & XMRCT(2),YMIX(2),YMRCT(2),IOPDKL,MAXDKL,MIXING,PIPSMR */

extern "C" {
  extern struct {
    double EXAG,GEV2MM,HBAR,PLTCUT,VMIN2,VTXPIP[5],XMIX[2],XMRCT[2],YMIX[2],YMRCT[2];
    int IOPDKL,MAXDKL,MIXING,PIPSMR;
  } hwdist_;
}
#define hwdist hwdist_

/*      PARAMETER(NMXCDK=4000)
      COMMON/HWUCLU/CLDKWT(NMXCDK),CTHRPW(12,12),PRECO,RESN(12,12),
      & RMIN(12,12),LOCN(12,12),NCLDK(NMXCDK),NRECO,CLRECO  */

static const int nmxcdk=4000;
extern "C" {
  extern struct {
    double CLDKWT[nmxcdk],CTHRPW[12][12],PRECO,RESN[12][12], RMIN[12][12];
    int LOCN[12][12],NCLDK[nmxcdk], NRECO,CLRECO;
  } hwuclu_;
}
#define hwuclu hwuclu_ 

/*C Weights used in cluster decays
      COMMON/HWUWTS/REPWT(0:3,0:4,0:4),SNGWT,DECWT,QWT(3),PWT(12),
      & SWTEF(NMXRES)  */

extern "C" {
  extern struct {
    double REPWT[5][5][4],SNGWT,DECWT,QWT[3],PWT[12],SWTEF[nmxres];
  } hwuwts_;
}
#define hwuwts hwuwts_

/*C  Other new parameters for version 6.2
      DOUBLE PRECISION VIPWID,DXRCYL,DXZMAX,DXRSPH
      LOGICAL WZRFR,FIX4JT
      INTEGER IMSSM,IHIGGS,PARITY,LRSUSY
      COMMON/HW6202/VIPWID(3),DXRCYL,DXZMAX,DXRSPH,WZRFR,FIX4JT,
      & IMSSM,IHIGGS,PARITY,LRSUSY   */

extern "C" {
  extern struct {
    double VIPWID[3], DXRCYL,DXZMAX,DXRSPH;
    int WZRFR,FIX4JT,IMSSM,IHIGGS,PARITY,LRSUSY;
  } hw6202_;
}
#define hw6202 hw6202_

/*      PARAMETER (MODMAX=50)
      COMMON/HWBOSC/ALPFAC,BRHIG(12),ENHANC(12),GAMMAX,RHOHEP(3,NMXHEP),
      & IOPHIG,MODBOS(MODMAX)  */

static const int hepevt_size = 4000; // check in HerwigWrapper
static const int modmax = 50;
extern "C" {
  extern struct {
    double ALPFAC, BRHIG[12], ENHANC[12], GAMMAX, RHOHEP[hepevt_size][3];
    int IOPHIG, MODBOS[modmax];
  } hwbosc_;
}
#define hwbosc hwbosc_

/*      COMMON/HWHARD/ASFIXD,CLQ(7,6),COSS,COSTH,CTMAX,DISF(13,2),EMLST,
     & EMMAX,EMMIN,EMPOW,EMSCA,EPOLN(3),GCOEF(7),GPOLN,OMEGA0,PHOMAS,
     & PPOLN(3),PTMAX,PTMIN,PTPOW,Q2MAX,Q2MIN,Q2POW,Q2WWMN,Q2WWMX,QLIM,
     & SINS,THMAX,Y4JT,TMNISR,TQWT,XX(2),XLMIN,XXMIN,YBMAX,YBMIN,YJMAX,
     & YJMIN,YWWMAX,YWWMIN,WHMIN,ZJMAX,ZMXISR,IAPHIG,IBRN(2),IBSH,
     & ICO(10),IDCMF,IDN(10),IFLMAX,IFLMIN,IHPRO,IPRO,MAPQ(6),MAXFL,
     & BGSHAT,COLISR,FSTEVT,FSTWGT,GENEV,HVFCEN,TPOL,DURHAM   */

extern "C" {
  extern struct {
    double ASFIXD,CLQ[6][7],COSS,COSTH,CTMAX,DISF[2][13],EMLST, EMMAX,EMMIN,EMPOW,EMSCA,EPOLN[3],GCOEF[7],GPOLN,OMEGA0,PHOMAS, PPOLN[3],PTMAX,PTMIN,PTPOW,Q2MAX,Q2MIN,Q2POW,Q2WWMN,Q2WWMX,QLIM, SINS,THMAX,Y4JT,TMNISR,TQWT,XX[2],XLMIN,XXMIN,YBMAX,YBMIN,YJMAX,YJMIN,YWWMAX,YWWMIN,WHMIN,ZJMAX,ZMXISR;
    int IAPHIG,IBRN[2],IBSH, ICO[10],IDCMF,IDN[10],IFLMAX,IFLMIN,IHPRO,IPRO,MAPQ[6],MAXFL,BGSHAT,COLISR,FSTEVT,FSTWGT,GENEV,HVFCEN,TPOL,DURHAM;
  } hwhard_;
}
#define hwhard hwhard_

/*C other HERWIG branching, event and hard subprocess common blocks
  COMMON/HWBRCH/ANOMSC(2,2),HARDST,PTINT(3,2),XFACT,INHAD,JNHAD,
  & NSPAC(7),ISLENT,BREIT,FROST,USECMF */

extern "C" {
  extern struct {
    double ANOMSC[2][2],HARDST,PTINT[2][3],XFACT;
    int INHAD,JNHAD,NSPAC[7],ISLENT,BREIT,FROST,USECMF;
  } hwbrch_;
}
#define hwbrch hwbrch_

/*      LOGICAL PRESPL
    COMMON /HW6500/ PRESPL   */

extern "C" {
  extern struct {
    int PRESPL;
  } hw6500_;
}
#define hw6500 hw6500_

/*C R-Parity violating parameters and colours
      COMMON /HWRPAR/ LAMDA1(3,3,3),LAMDA2(3,3,3),
      &                LAMDA3(3,3,3),HRDCOL(2,5),RPARTY,COLUPD   */

extern "C" {
  extern struct {
    double LAMDA1[3][3][3],LAMDA2[3][3][3],LAMDA3[3][3][3];
    int HRDCOL[5][2],RPARTY,COLUPD;
  } hwrpar_;
}
#define hwrpar hwrpar_

/*C SUSY parameters
      COMMON/HWSUSY/
     & TANB,ALPHAH,COSBPA,SINBPA,COSBMA,SINBMA,COSA,SINA,COSB,SINB,COTB,
     & ZMIXSS(4,4),ZMXNSS(4,4),ZSGNSS(4), LFCH(16),RFCH(16),
     & SLFCH(16,4),SRFCH(16,4), WMXUSS(2,2),WMXVSS(2,2), WSGNSS(2),
     & QMIXSS(6,2,2),LMIXSS(6,2,2),
     & THETAT,THETAB,THETAL,ATSS,ABSS,ALSS,MUSS,FACTSS,
     & GHWWSS(3),GHZZSS(3),GHDDSS(4),GHUUSS(4),GHWHSS(3),
     & GHSQSS(4,6,2,2),XLMNSS,RMMNSS,DMSSM,SENHNC(24),SSPARITY,SUSYIN  */

extern "C" {
  extern struct {
    double TANB,ALPHAH,COSBPA,SINBPA,COSBMA,SINBMA,COSA,SINA,COSB,SINB,COTB,ZMIXSS[4][4],ZMXNSS[4][4],ZSGNSS[4], LFCH[16],RFCH[16],SLFCH[4][16],SRFCH[4][16], WMXUSS[2][2],WMXVSS[2][2], WSGNSS[2],QMIXSS[2][2][6],LMIXSS[2][2][6],THETAT,THETAB,THETAL,ATSS,ABSS,ALSS,MUSS,FACTSS,GHWWSS[3],GHZZSS[3],GHDDSS[4],GHUUSS[4],GHWHSS[3],GHSQSS[2][2][6][4],XLMNSS,RMMNSS,DMSSM,SENHNC[24],SSPARITY;
    int SUSYIN;
  } hwsusy_;
}
#define hwsusy hwsusy_

/*INTEGER NDECSY,NSEARCH,LRDEC,LWDEC
      LOGICAL SYSPIN,THREEB,FOURB
      CHARACTER *6 TAUDEC
      COMMON /HWDSPN/NDECSY,NSEARCH,LRDEC,LWDEC,SYSPIN,THREEB,
      & FOURB,TAUDEC */

extern "C" {
  extern struct {
    int NDECSY,NSEARCH,LRDEC,LWDEC,SYSPIN,THREEB,FOURB;
    char TAUDEC[6];
  } hwdspn_;
}

#define hwdspn hwdspn_

/*C--common block for Les Houches interface to store information we need
C
      INTEGER MAXHRP
      PARAMETER (MAXHRP=100)
      DOUBLE PRECISION LHWGT(MAXHRP),LHWGTS(MAXHRP),LHMXSM,
     &     LHXSCT(MAXHRP),LHXERR(MAXHRP),LHXMAX(MAXHRP)
      INTEGER LHIWGT(MAXHRP),ITYPLH,LHNEVT(MAXHRP)
      LOGICAL LHSOFT,LHGLSF 
      COMMON /HWGUPR/LHWGT,LHWGTS,LHXSCT,LHXERR,LHXMAX,LHMXSM,LHIWGT,
      &     LHNEVT,ITYPLH,LHSOFT,LHGLSF  */

static const int maxhrp = 100;
extern "C" {
  extern struct {
    double LHWGT[maxhrp],LHWGTS[maxhrp],LHMXSM,LHXSCT[maxhrp],LHXERR[maxhrp],LHXMAX[maxhrp];
    int LHIWGT,LHNEVT,ITYPLH,LHSOFT,LHGLSF;
  } hwgupr_;
}
#define hwgupr hwgupr_

/*C  New parameters for version 6.3
      INTEGER IMAXCH,IMAXOP
      PARAMETER (IMAXCH=20,IMAXOP=40)
      DOUBLE PRECISION MJJMIN,CHNPRB(IMAXCH)
      INTEGER IOPSTP,IOPSH
      LOGICAL OPTM,CHON(IMAXCH)
      COMMON/HW6300/MJJMIN,CHNPRB,IOPSTP,IOPSH,OPTM,CHON   */

static const int imaxch = 20;
extern "C" {
  extern struct {
    double MJJMIN,CHNPRB[imaxch];
    int IOPSTP,IOPSH,OPTM,CHON[imaxch];
  } hw6300_;
}
#define hw6300 hw6300_

//-------------------------- JIMMY COMMON BLOCK -------------------------------
/*
      DOUBLE PRECISION YGAMMA, JMZMIN, JMRAD, PTJIM
      DOUBLE PRECISION PHAD, JMU2, JMV2, SMALL, JMARRY
c     JMARRY is the array storing gamma-p xsec at various z, & 
c   max weight for each z
      DOUBLE PRECISION TOTSCAT, NLOST

      INTEGER MAXMS, NPSIMP, MSFLAG, JMPTYP, JCMVAR, NPROC
      LOGICAL ANOMOFF

      PARAMETER( NPROC = 117 )
      PARAMETER( MAXMS  = 100  )  ! Maximum multiple scatters
      PARAMETER( NPSIMP = 16 )  ! No. of Simpson rule (YBJ)
C                                 intervals (must be even)
      PARAMETER( SMALL  = 1.0D-20  )
      INTEGER JMOUT, JMBUG, FN_TYPE, NSCAT, JMUEO, MAXMSTRY
      PARAMETER(JMOUT = 6)
      COMMON / JMPARM /  PTJIM, YGAMMA, JMZMIN, JMRAD(264)
     &     ,PHAD, JMU2, JMV2, JMARRY( 6+MAXMS,0:NPSIMP )
     &     ,NLOST, TOTSCAT, ANOMOFF, JCMVAR, JMUEO
     &     ,JMPTYP(NPROC), JMBUG, FN_TYPE, MSFLAG, MAXMSTRY
      DOUBLE PRECISION JMPROC, JMVETO
      COMMON / JMEVNT/ JMPROC(NPROC)
     &,        JMVETO(2,13), NSCAT
*/

static const int NPROC = 117;
static const int MAXMS = 100;
static const int NPSIMP = 16;
static const double SMALL = 0.00000000000000000001;

extern "C" {
  extern struct {
    double PTJIM,YGAMMA,JMZMIN,JMRAD[264],PHAD,JMU2,JMV2,JMARRY[NPSIMP+1][6+MAXMS],
      NLOST,TOTSCAT;
    int ANAMOFF,JCMVAR,JMUEO,JMPTYP[NPROC],JMBUG,FN_TYPE,MSFLAG,MAXMSTRY;
  } jmparm_;
}
#define jmparm jmparm_

extern "C" {
  extern struct {
    double JMPROC[NPROC],JMVETO[13][2];
    int NSCAT;
  } jmevnt_;
}
#define jmevnt jmevnt_

//------------------------------ JIMMY functions -------------------------------------------------
extern "C" {
  void jimmin_(void);
  void jminit_(void);
  double hwmsct_(int*);
  void jmefin_(void);
}

#define jimmin jimmin_
#define jminit jminit_
#define hwmsct hwmsct_
#define jmefin jmefin_


//------------------------------ LHAPDF functions -------------------------------------------------

//MLM-style matching for aMC@NLO
extern "C" {
  extern struct {
    int n_match, max_multiplicity_flag;
    double matching_scale;
  } hwmatchpram_;
}
#define hwmatchpram hwmatchpram_

extern "C" {
  void hwmatch_(int*);
  void hwhdecay_();
}
#define hwmatch hwmatch_
#define hwhdecay hwhdecay_


#endif