[u/mrichter/AliRoot.git] / THerwig / HCommon.h

#ifndef HerwigCommon
#define HerwigCommon

#ifndef __CFORTRAN_LOADED
#include <cfortran.h>
#endif

extern "C" {
// 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

struct dcpx {double dr,di;};

int const NMXHEP = 4000;

typedef struct {
  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];
} HepevtCommon;

#define HEPEVT COMMON_BLOCK(HEPEVT, hepevt)
  COMMON_BLOCK_DEF(HepevtCommon, HEPEVT);


typedef struct {
  int IPART1;
  int IPART2;
} HwbeamCommon;

#define HWBEAM COMMON_BLOCK(HWBEAM, hwbeam)
  COMMON_BLOCK_DEF(HwbeamCommon, HWBEAM);

typedef struct {
  char PART1[8];
  char PART2[8];
} HwbmchCommon;

#define HWBMCH COMMON_BLOCK(HWBMCH, hwbmch)
  COMMON_BLOCK_DEF(HwbmchCommon, HWBMCH);


typedef struct {
  double EBEAM1;
  double EBEAM2;
  double PBEAM1;
  double PBEAM2;
  int    IPROC;
  int    MAXEV;
} HwprocCommon;

#define HWPROC COMMON_BLOCK(HWPROC, hwproc)
  COMMON_BLOCK_DEF(HwprocCommon, HWPROC);


typedef struct {
  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;
} HwpramCommon;

#define HWPRAM COMMON_BLOCK(HWPRAM, hwpram)
  COMMON_BLOCK_DEF(HwpramCommon, HWPRAM);

typedef struct {
  char AUTPDF[2][20];
  char BDECAY[4];
} HwprchCommon;

#define HWPRCH COMMON_BLOCK(HWPRCH, hwprch)
  COMMON_BLOCK_DEF(HwprchCommon, HWPRCH);

int const NMXPAR = 500;

typedef struct {
  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];
} HwpartCommon;

#define HWPART COMMON_BLOCK(HWPART, hwpart)
  COMMON_BLOCK_DEF(HwpartCommon, HWPART);

typedef struct {
  double DECPAR[NMXPAR][2];
  double PHIPAR[NMXPAR][2];
  double RHOPAR[NMXPAR][2];
  int TMPAR[NMXPAR];
} HwparpCommon;

#define HWPARP COMMON_BLOCK(HWPARP, hwparp)
  COMMON_BLOCK_DEF(HwparpCommon, HWPARP);

int const MODMAX = 50;

typedef struct {
  double  ALPFAC;
  double  BRHIG[12];
  double  ENHANC[12];
  double  GAMMAX;
  double  RHOHEP[NMXHEP][3];
  int     IOPHIG;
  int     MODBOS[MODMAX];
} HwboscCommon;

#define HWBOSC COMMON_BLOCK(HWBOSC, hwbosc)
  COMMON_BLOCK_DEF(HwboscCommon, HWBOSC);

typedef struct {
  int     JCOPAR[NMXPAR][4];
} HwparcCommon;

#define HWPARC COMMON_BLOCK(HWPARC, hwparc)
  COMMON_BLOCK_DEF(HwparcCommon, HWPARC);

typedef struct {
  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;
} HwbrchCommon;

#define HWBRCH COMMON_BLOCK(HWBRCH, hwbrch)
  COMMON_BLOCK_DEF(HwbrchCommon, HWBRCH);

typedef struct {
  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;
} HwevntCommon;

#define HWEVNT COMMON_BLOCK(HWEVNT, hwevnt)
  COMMON_BLOCK_DEF(HwevntCommon, HWEVNT);

typedef struct {
  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[6];
  int    MAXFL;
  int    BGSHAT;
  int    COLISR;
  int    FSTEVT;
  int    FSTWGT;
  int    GENEV;
  int    HVFCEN;
  int    TPOL;
  int     DURHAM;
} HwhardCommon;

#define HWHARD COMMON_BLOCK(HWHARD, hwhard)
  COMMON_BLOCK_DEF(HwhardCommon, HWHARD);

int const NMXRES = 500;

typedef struct {
  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];
} HwpropCommon;

#define HWPROP COMMON_BLOCK(HWPROP, hwprop)
  COMMON_BLOCK_DEF(HwpropCommon, HWPROP);

typedef struct {
  char RNAME[NMXRES+1][8];
  char TXNAME[NMXRES+1][2][37];
} HwunamCommon;

#define HWUNAM COMMON_BLOCK(HWUNAM, hwunam)
  COMMON_BLOCK_DEF(HwunamCommon, HWUNAM);

int const NMXDKS = 4000;
int const NMXMOD = 200;

typedef struct {
  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];
} HwupdtCommon;

#define HWUPDT COMMON_BLOCK(HWUPDT, hwupdt)
  COMMON_BLOCK_DEF(HwupdtCommon, HWUPDT);


typedef struct {
  double REPWT[5][5][4];
  double SNGWT;
  double DECWT;
  double QWT[3];
  double PWT[12];
  double SWTEF[NMXRES];
} HwuwtsCommon;

#define HWUWTS COMMON_BLOCK(HWUWTS, hwuwts)
  COMMON_BLOCK_DEF(HwuwtsCommon, HWUWTS);


int const NMXCDK = 4000;

typedef struct {
  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;
} HwucluCommon;

#define HWUCLU COMMON_BLOCK(HWUCLU, hwuclu)
  COMMON_BLOCK_DEF(HwucluCommon, HWUCLU);


typedef struct {
  double EXAG;
  double GEV2MM;
  double HBAR;
  double PLTCUT;
  double VMIN2;
  double VTXPIP[5];
  double XMIX[2];
  double XMRCT[2];
  double YMIX[2];
  double YMRCT[2];
  int    IOPDKL;
  int    MAXDKL;
  int    MIXING;
  int    PIPSMR;
} HwdistCommon;

#define HWDIST COMMON_BLOCK(HWDIST, hwdist)
  COMMON_BLOCK_DEF(HwdistCommon, HWDIST);

int const NMXQDK=20;

typedef struct {
  double VTXQDK[NMXQDK][4];
  int    IMQDK[NMXQDK];
  int    LOCQ[NMXQDK];
  int    NQDK;
} HwqdksCommon;

#define HWQDKS COMMON_BLOCK(HWQDKS, hwqdks)
  COMMON_BLOCK_DEF(HwqdksCommon, HWQDKS);

int const NMXSUD = 1024;

typedef struct {
  double ACCUR;
  double QEV[6][NMXSUD];
  double SUD[6][NMXSUD];
  int    INTER;
  int    NQEV;
  int    NSUD;
  int    SUDORD;
} HwusudCommon;

#define HWUSUD COMMON_BLOCK(HWUSUD, hwusud)
  COMMON_BLOCK_DEF(HwusudCommon, HWUSUD);

typedef struct {
  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 DMSSM;
  double SENHNC[24];
  double SSPARITY;
  int    SUSYIN;
} HwsusyCommon;

#define HWSUSY COMMON_BLOCK(HWSUSY, hwsusy)
  COMMON_BLOCK_DEF(HwsusyCommon, HWSUSY);

typedef struct {
  double LAMDA1[3][3][3];
  double LAMDA2[3][3][3];
  double LAMDA3[3][3][3];
  int    HRDCOL[5][2];
  int    RPARTY;
  int    COLUPD;
} HwrparCommon;

#define HWRPAR COMMON_BLOCK(HWRPAR, hwrpar)
  COMMON_BLOCK_DEF(HwrparCommon, HWRPAR);

typedef struct {
  double PMBN1;
  double PMBN2;
  double PMBN3;
  double PMBK1;
  double PMBK2;
  double PMBM1;
  double PMBM2;
  double PMBP1;
  double PMBP2;
  double PMBP3;
} HwminbCommon;

#define HWMINB COMMON_BLOCK(HWMINB, hwminb)
  COMMON_BLOCK_DEF(HwminbCommon, HWMINB);

int const NMXCL = 500;

typedef struct {
  double PPCL[NMXCL][5];
  int    IDCL[NMXCL];
  int    NCL;
} HwclusCommon;

#define HWCLUS COMMON_BLOCK(HWCLUS, hwclus)
  COMMON_BLOCK_DEF(HwclusCommon, HWCLUS);

// herwig 6.507

typedef struct Hwgrav_t {
  double GRVLAM;
  double EMGRV;
  double GAMGRV;
} HwgravCommon;

#define HWGRAV COMMON_BLOCK(HWGRAV, hwgrav)
  COMMON_BLOCK_DEF(HwgravCommon, HWGRAV);

typedef struct {
  double VIPWID[3];
  double DXRCYL;
  double DXZMAX;
  double DXRSPH;
  int    WZRFR;
  int    FIX4JT;
  int    IMSSM;
  int    IHIGGS;
  int    PARITY;
  int    LRSUSY;
} Hw6202Common;

#define HW6202 COMMON_BLOCK(HW6202, hw6202)
  COMMON_BLOCK_DEF(Hw6202Common, HW6202);

typedef struct {
  double ABWGT;
  double ABWSUM;
  double AVABW;
  int    NNEGWT;
  int    NNEGEV;
  int    NEGWTS;
} Hw6203Common;

#define HW6203 COMMON_BLOCK(HW6203, hw6203)
  COMMON_BLOCK_DEF(Hw6203Common, HW6203);

int const IMAXCH = 20;

typedef struct {
  double MJJMIN;
  double CHNPRB[IMAXCH];
  int    IOPSTP;
  int    IOPSH;
  int    OPTM;
  int    CHON[IMAXCH];
} Hw6300Common;

#define HW6300 COMMON_BLOCK(HW6300, hw6300)
  COMMON_BLOCK_DEF(Hw6300Common, HW6300);

int const NXMRS = 49;
int const NQMRS = 37;
int const NPMRS = 8;

typedef struct {
  double FMRS[NQMRS+1][NXMRS][NPMRS][3];
} HwpmrsCommon;

#define HWPMRS COMMON_BLOCK(HWPMRS, hwpmrs)
  COMMON_BLOCK_DEF(HwpmrsCommon, HWPMRS);

typedef struct {
  int    CIRCOP;
  int    CIRCAC;
  int    CIRCVR;
  int    CIRCRV;
  int    CIRCCH;
} HwcircCommon;

#define HWCIRC COMMON_BLOCK(HWCIRC, hwcirc)
  COMMON_BLOCK_DEF(HwcircCommon, HWCIRC);

int const NCFMAX = 3;
int const NMODE2 = 500;
int const NMODE3 = 500;
int const NDIAGR = 8;
int const NMODEB = 50;
int const NMODE4 = 4;

typedef struct {
  double ABMODE[NMODEB][2];
  double BBMODE[NMODEB][12][2];
  double PBMODE[NMODEB][12];
  double WTBMAX[NMODEB][12];
  int    IDBPRT[NMODEB];
  int    IBDRTP[NMODEB];
  int    IBMODE[NMODEB];
  int    NBMODE;
} HwdspbCommon;

#define HWDSPB COMMON_BLOCK(HWDSPB, hwdspb)
  COMMON_BLOCK_DEF(HwdspbCommon, HWDSPB);

typedef struct {
  double A2MODE[NMODE2][2];
  double P2MODE[NMODE2];
  double WT2MAX[NMODE2];
  int    ID2PRT[NMODE2];
  int    I2DRTP[NMODE2];
  int    N2MODE;
} Hwdsp2Common;

#define HWDSP2 COMMON_BLOCK(HWDSP2, hwdsp2)
  COMMON_BLOCK_DEF(Hwdsp2Common, HWDSP2);

typedef struct {
  double A3MODE[NMODE3][NDIAGR][2];
  double B3MODE[NMODE3][NDIAGR][2];
  double P3MODE[NMODE3];
  double WT3MAX[NMODE3];
  double SPN3CF[NMODE3][NCFMAX][NCFMAX];
  int    ID3PRT[NMODE3];
  int    I3MODE[NMODE3][NDIAGR];
  int    I3DRTP[NMODE3][NDIAGR];
  int    N3MODE;
  int    NDI3BY[NMODE3];
  int    N3NCFL[NMODE3];
  int    I3DRCF[NMODE3][NDIAGR];
} Hwdsp3Common;

#define HWDSP3 COMMON_BLOCK(HWDSP3, hwdsp3)
  COMMON_BLOCK_DEF(Hwdsp3Common, HWDSP3);

typedef struct {
  double A4MODE[NMODE4][12][2];
  double B4MODE[NMODE4][12][2];
  double P4MODE[NMODE4][12][12];
  double WT4MAX[NMODE4][12][12];
  int    ID4PRT[NMODE4];
  int    I4MODE[NMODE4][2];
  int    N4MODE;
} Hwdsp4Common;

#define HWDSP4 COMMON_BLOCK(HWDSP4, hwdsp4)
  COMMON_BLOCK_DEF(Hwdsp4Common, HWDSP4);

typedef struct {
  int    NDECSY;
  int    NSEARCH;
  int    LRDEC;
  int    LWDEC;
  int    SYSPIN;
  int    THREEB;
  int    FOURB;
  char   TAUDEC[6];
} HwdspnCommon;

#define HWDSPN COMMON_BLOCK(HWDSPN, hwdspn)
  COMMON_BLOCK_DEF(HwdspnCommon, HWDSPN);

int const NMXSPN = 50;

typedef struct {
  dcpx   MESPN[NMXSPN][NCFMAX][2][2][2][2];
  dcpx   RHOSPN[NMXSPN][2][2];
  double SPNCFC[NMXSPN][NCFMAX][NCFMAX];
  int    IDSPN[NMXSPN];
  int    JMOSPN[NMXSPN];
  int    JDASPN[NMXSPN][2];
  int    NSPN;
  int    ISNHEP[NMXHEP];
  int    NSNTRY;
  int    DECSPN[NMXSPN];
  int    NCFL[NMXSPN];
  int    SPCOPT;
} HwspinCommon;

#define HWSPIN COMMON_BLOCK(HWSPIN, hwspin)
  COMMON_BLOCK_DEF(HwspinCommon, HWSPIN);

typedef struct {
  int    JAK1;
  int    JAK2;
  int    ITDKRC;
  int    IFPHOT;
} HwstauCommon;

#define HWSTAU COMMON_BLOCK(HWSTAU, hwstau)
  COMMON_BLOCK_DEF(HwstauCommon, HWSTAU);

int const MAXHRP = 100;

typedef struct {
  double LHWGT[MAXHRP];
  double LHWGTS[MAXHRP];
  double LHXSCT[MAXHRP];
  double LHXERR[MAXHRP];
  double LHXMAX[MAXHRP];
  double LHMXSM;
  int    LHIWGT[MAXHRP];
  int    LHNEVT[MAXHRP];
  int    ITYPLH;
  int    LHSOFT;
  int    LHGLSF;    
} HwguprCommon;

#define HWGUPR COMMON_BLOCK(HWGUPR, hwgupr)
  COMMON_BLOCK_DEF(HwguprCommon, HWGUPR);

typedef struct {
  int    PRESPL;
} Hw6500Common;

#define HW6500 COMMON_BLOCK(HW6500, hw6500)
  COMMON_BLOCK_DEF(Hw6500Common, HW6500);

typedef struct {
  int    ITOPRD;
} Hw6504Common;

#define HW6504 COMMON_BLOCK(HW6504, hw6504)
  COMMON_BLOCK_DEF(Hw6504Common, HW6504);

typedef struct {
  double PDFX0;
  double PDFPOW;
} Hw6506Common;

#define HW6506 COMMON_BLOCK(HW6506, hw6506)
  COMMON_BLOCK_DEF(Hw6506Common, HW6506);

}

extern "C" {
    void  hwuepr_();
    void  hwigin_();
    void  hwuinc_();
    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  hwusta_(const char * name, int);
    void  hwiodk_(int);
}

// subroutines to be call by JIMMY

extern "C" {
  void  jminit_();
  void  jimmin_();
  void  jmefin_();
}

#endif
Commit	Line	Data
455f128d	1	#ifndef HerwigCommon
	2	#define HerwigCommon
	3
	4	#ifndef __CFORTRAN_LOADED
	5	#include <cfortran.h>
	6	#endif
	7
	8	extern "C" {
2d8d4543	9	// Translation of Fortran commons from the Herwig6
	10	// f77 program into c++ structures to be used in ROOT
	11	// and declaration of Fortran functions as extern
	12	// C functions to be called from the class Herwig6
	13	// author: j. g. contreras jgcn@moni.mda.cinvestav.mx
	14	// date: december 22, 2000
	15
e2054d85	16	struct dcpx {double dr,di;};
e2054d85	17
455f128d	18	int const NMXHEP = 4000;
2d8d4543	19
455f128d	20	typedef struct {
2d8d4543	21	int NEVHEP;
	22	int NHEP;
	23	int ISTHEP[NMXHEP];
	24	int IDHEP[NMXHEP];
	25	int JMOHEP[NMXHEP][2];
	26	int JDAHEP[NMXHEP][2];
	27	double PHEP[NMXHEP][5];
	28	double VHEP[NMXHEP][4];
455f128d	29	} HepevtCommon;
	30
	31	#define HEPEVT COMMON_BLOCK(HEPEVT, hepevt)
	32	COMMON_BLOCK_DEF(HepevtCommon, HEPEVT);
2d8d4543	33
455f128d	34
455f128d	35	typedef struct {
2d8d4543	36	int IPART1;
2d8d4543	37	int IPART2;
455f128d	38	} HwbeamCommon;
	39
	40	#define HWBEAM COMMON_BLOCK(HWBEAM, hwbeam)
	41	COMMON_BLOCK_DEF(HwbeamCommon, HWBEAM);
2d8d4543	42
455f128d	43	typedef struct {
2d8d4543	44	char PART1[8];
2d8d4543	45	char PART2[8];
455f128d	46	} HwbmchCommon;
	47
	48	#define HWBMCH COMMON_BLOCK(HWBMCH, hwbmch)
	49	COMMON_BLOCK_DEF(HwbmchCommon, HWBMCH);
2d8d4543	50
455f128d	51
455f128d	52	typedef struct {
2d8d4543	53	double EBEAM1;
	54	double EBEAM2;
	55	double PBEAM1;
	56	double PBEAM2;
	57	int IPROC;
	58	int MAXEV;
455f128d	59	} HwprocCommon;
	60
	61	#define HWPROC COMMON_BLOCK(HWPROC, hwproc)
	62	COMMON_BLOCK_DEF(HwprocCommon, HWPROC);
	63
2d8d4543	64
455f128d	65	typedef struct {
2d8d4543	66	double AFCH[2][16];
	67	double ALPHEM;
	68	double B1LIM;
	69	double BETAF;
	70	double BTCLM;
	71	double CAFAC;
	72	double CFFAC;
	73	double CLMAX;
	74	double CLPOW;
	75	double CLSMR[2];
	76	double CSPEED;
	77	double ENSOF;
	78	double ETAMIX;
	79	double F0MIX;
	80	double F1MIX;
	81	double F2MIX;
	82	double GAMH;
	83	double GAMW;
	84	double GAMZ;
	85	double GAMZP;
	86	double GEV2NB;
	87	double H1MIX;
	88	double PDIQK;
	89	double PGSMX;
	90	double PGSPL[4];
	91	double PHIMIX;
	92	double PIFAC;
	93	double PRSOF;
	94	double PSPLT[2];
	95	double PTRMS;
	96	double PXRMS;
	97	double QCDL3;
	98	double QCDL5;
	99	double QCDLAM;
	100	double QDIQK;
	101	double QFCH[16];
	102	double QG;
	103	double QSPAC;
	104	double QV;
	105	double SCABI;
	106	double SWEIN;
	107	double TMTOP;
	108	double VFCH[2][16];
	109	double VCKM[3][3];
	110	double VGCUT;
	111	double VQCUT;
	112	double VPCUT;
	113	double ZBINM;
	114	double EFFMIN;
	115	double OMHMIX;
	116	double ET2MIX;
	117	double PH3MIX;
	118	double GCUTME;
	119	int IOPREM;
	120	int IPRINT;
	121	int ISPAC;
	122	int LRSUD;
	123	int LWSUD;
	124	int MODPDF[2];
	125	int NBTRY;
	126	int NCOLO;
	127	int NCTRY;
	128	int NDTRY;
	129	int NETRY;
130	int NFLAV;
131	int NGSPL;
132	int NSTRU;
133	int NSTRY;
134	int NZBIN;
135	int IOP4JT[2];
136	int NPRFMT;
137	int AZSOFT;
138	int AZSPIN;
139	int CLDIR[2];
140	int HARDME;
141	int NOSPAC;
142	int PRNDEC;
143	int PRVTX;
144	int SOFTME;
145	int ZPRIME;
146	int PRNDEF;
147	int PRNTEX;
148	int PRNWEB;
455f128d	149	} HwpramCommon;
2d8d4543	150
455f128d	151	#define HWPRAM COMMON_BLOCK(HWPRAM, hwpram)
	152	COMMON_BLOCK_DEF(HwpramCommon, HWPRAM);
	153
	154	typedef struct {
2d8d4543	155	char AUTPDF[2][20];
2d8d4543	156	char BDECAY[4];
455f128d	157	} HwprchCommon;
	158
	159	#define HWPRCH COMMON_BLOCK(HWPRCH, hwprch)
	160	COMMON_BLOCK_DEF(HwprchCommon, HWPRCH);
2d8d4543	161
	162	int const NMXPAR = 500;
	163
455f128d	164	typedef struct {
2d8d4543	165	int NEVPAR;
	166	int NPAR;
	167	int ISTPAR[NMXPAR];
	168	int IDPAR[NMXPAR];
	169	int JMOPAR[NMXPAR][2];
	170	int JDAPAR[NMXPAR][2];
	171	double PPAR[NMXPAR][5];
	172	double VPAR[NMXPAR][4];
455f128d	173	} HwpartCommon;
	174
	175	#define HWPART COMMON_BLOCK(HWPART, hwpart)
	176	COMMON_BLOCK_DEF(HwpartCommon, HWPART);
2d8d4543	177
455f128d	178	typedef struct {
2d8d4543	179	double DECPAR[NMXPAR][2];
	180	double PHIPAR[NMXPAR][2];
	181	double RHOPAR[NMXPAR][2];
	182	int TMPAR[NMXPAR];
455f128d	183	} HwparpCommon;
	184
	185	#define HWPARP COMMON_BLOCK(HWPARP, hwparp)
	186	COMMON_BLOCK_DEF(HwparpCommon, HWPARP);
2d8d4543	187
2fc6fff1	188	int const MODMAX = 50;
2d8d4543	189
455f128d	190	typedef struct {
2d8d4543	191	double ALPFAC;
	192	double BRHIG[12];
	193	double ENHANC[12];
	194	double GAMMAX;
	195	double RHOHEP[NMXHEP][3];
	196	int IOPHIG;
	197	int MODBOS[MODMAX];
455f128d	198	} HwboscCommon;
	199
	200	#define HWBOSC COMMON_BLOCK(HWBOSC, hwbosc)
	201	COMMON_BLOCK_DEF(HwboscCommon, HWBOSC);
2d8d4543	202
455f128d	203	typedef struct {
2d8d4543	204	int JCOPAR[NMXPAR][4];
455f128d	205	} HwparcCommon;
2d8d4543	206
455f128d	207	#define HWPARC COMMON_BLOCK(HWPARC, hwparc)
	208	COMMON_BLOCK_DEF(HwparcCommon, HWPARC);
	209
	210	typedef struct {
2d8d4543	211	double ANOMSC[2][2];
	212	double HARDST;
	213	double PTINT[2][3];
	214	double XFACT;
	215	int INHAD;
	216	int JNHAD;
	217	int NSPAC[7];
	218	int ISLENT;
	219	int BREIT;
	220	int FROST;
	221	int USECMF;
455f128d	222	} HwbrchCommon;
	223
	224	#define HWBRCH COMMON_BLOCK(HWBRCH, hwbrch)
	225	COMMON_BLOCK_DEF(HwbrchCommon, HWBRCH);
2d8d4543	226
455f128d	227	typedef struct {
2d8d4543	228	double AVWGT;
	229	double EVWGT;
	230	double GAMWT;
	231	double TLOUT;
	232	double WBIGST;
	233	double WGTMAX;
	234	double WGTSUM;
	235	double WSQSUM;
	236	int IDHW[NMXHEP];
	237	int IERROR;
	238	int ISTAT;
	239	int LWEVT;
	240	int MAXER;
	241	int MAXPR;
	242	int NOWGT;
	243	int NRN[2];
	244	int NUMER;
	245	int NUMERU;
	246	int NWGTS;
	247	int GENSOF;
455f128d	248	} HwevntCommon;
2d8d4543	249
455f128d	250	#define HWEVNT COMMON_BLOCK(HWEVNT, hwevnt)
	251	COMMON_BLOCK_DEF(HwevntCommon, HWEVNT);
	252
	253	typedef struct {
2d8d4543	254	double ASFIXD;
	255	double CLQ[6][7];
	256	double COSS;
	257	double COSTH;
	258	double CTMAX;
	259	double DISF[2][13];
	260	double EMLST;
	261	double EMMAX;
	262	double EMMIN;
	263	double EMPOW;
	264	double EMSCA;
	265	double EPOLN[3];
	266	double GCOEF[7];
	267	double GPOLN;
	268	double OMEGA0;
	269	double PHOMAS;
	270	double PPOLN[3];
	271	double PTMAX;
	272	double PTMIN;
	273	double PTPOW;
	274	double Q2MAX;
	275	double Q2MIN;
	276	double Q2POW;
	277	double Q2WWMN;
	278	double Q2WWMX;
	279	double QLIM;
	280	double SINS;
	281	double THMAX;
	282	double Y4JT;
	283	double TMNISR;
	284	double TQWT;
	285	double XX[2];
	286	double XLMIN;
	287	double XXMIN;
	288	double YBMAX;
	289	double YBMIN;
	290	double YJMAX;
	291	double YJMIN;
	292	double YWWMAX;
	293	double YWWMIN;
	294	double WHMIN;
	295	double ZJMAX;
	296	double ZMXISR;
	297	int IAPHIG;
	298	int IBRN[2];
	299	int IBSH;
	300	int ICO[10];
	301	int IDCMF;
	302	int IDN[10];
	303	int IFLMAX;
	304	int IFLMIN;
	305	int IHPRO;
	306	int IPRO;
2fc6fff1	307	int MAPQ[6];
2d8d4543	308	int MAXFL;
	309	int BGSHAT;
	310	int COLISR;
	311	int FSTEVT;
	312	int FSTWGT;
	313	int GENEV;
	314	int HVFCEN;
	315	int TPOL;
	316	int DURHAM;
455f128d	317	} HwhardCommon;
	318
	319	#define HWHARD COMMON_BLOCK(HWHARD, hwhard)
	320	COMMON_BLOCK_DEF(HwhardCommon, HWHARD);
2d8d4543	321
	322	int const NMXRES = 500;
	323
455f128d	324	typedef struct {
2d8d4543	325	double RLTIM[NMXRES+1];
	326	double RMASS[NMXRES+1];
	327	double RSPIN[NMXRES+1];
	328	int ICHRG[NMXRES+1];
	329	int IDPDG[NMXRES+1];
	330	int IFLAV[NMXRES+1];
	331	int NRES;
	332	int VTOCDK[NMXRES+1];
	333	int VTORDK[NMXRES+1];
	334	int QORQQB[NMXRES+1];
	335	int QBORQQ[NMXRES+1];
455f128d	336	} HwpropCommon;
	337
	338	#define HWPROP COMMON_BLOCK(HWPROP, hwprop)
	339	COMMON_BLOCK_DEF(HwpropCommon, HWPROP);
2d8d4543	340
455f128d	341	typedef struct {
2d8d4543	342	char RNAME[NMXRES+1][8];
2d8d4543	343	char TXNAME[NMXRES+1][2][37];
455f128d	344	} HwunamCommon;
	345
	346	#define HWUNAM COMMON_BLOCK(HWUNAM, hwunam)
	347	COMMON_BLOCK_DEF(HwunamCommon, HWUNAM);
2d8d4543	348
	349	int const NMXDKS = 4000;
	350	int const NMXMOD = 200;
	351
455f128d	352	typedef struct {
2d8d4543	353	double BRFRAC[NMXDKS];
	354	double CMMOM[NMXDKS];
	355	double DKLTM[NMXRES];
	356	int IDK[NMXDKS];
	357	int IDKPRD[NMXDKS][5];
	358	int LNEXT[NMXDKS];
	359	int LSTRT[NMXRES];
	360	int NDKYS;
	361	int NME[NMXDKS];
	362	int NMODES[NMXRES];
	363	int NPRODS[NMXDKS];
	364	int DKPSET;
	365	int RSTAB[NMXRES+1];
455f128d	366	} HwupdtCommon;
	367
	368	#define HWUPDT COMMON_BLOCK(HWUPDT, hwupdt)
	369	COMMON_BLOCK_DEF(HwupdtCommon, HWUPDT);
	370
2d8d4543	371
455f128d	372	typedef struct {
2fc6fff1	373	double REPWT[5][5][4];
2d8d4543	374	double SNGWT;
	375	double DECWT;
	376	double QWT[3];
	377	double PWT[12];
	378	double SWTEF[NMXRES];
455f128d	379	} HwuwtsCommon;
	380
	381	#define HWUWTS COMMON_BLOCK(HWUWTS, hwuwts)
	382	COMMON_BLOCK_DEF(HwuwtsCommon, HWUWTS);
	383
2d8d4543	384
	385	int const NMXCDK = 4000;
	386
455f128d	387	typedef struct {
2d8d4543	388	double CLDKWT[NMXCDK];
	389	double CTHRPW[12][12];
	390	double PRECO;
	391	double RESN[12][12];
	392	double RMIN[12][12];
	393	int LOCN[12][12];
	394	int NCLDK[NMXCDK];
	395	int NRECO;
	396	int CLRECO;
455f128d	397	} HwucluCommon;
	398
	399	#define HWUCLU COMMON_BLOCK(HWUCLU, hwuclu)
	400	COMMON_BLOCK_DEF(HwucluCommon, HWUCLU);
2d8d4543	401
455f128d	402
455f128d	403	typedef struct {
2d8d4543	404	double EXAG;
	405	double GEV2MM;
	406	double HBAR;
	407	double PLTCUT;
	408	double VMIN2;
2fc6fff1	409	double VTXPIP[5];
2d8d4543	410	double XMIX[2];
	411	double XMRCT[2];
	412	double YMIX[2];
	413	double YMRCT[2];
	414	int IOPDKL;
	415	int MAXDKL;
	416	int MIXING;
	417	int PIPSMR;
455f128d	418	} HwdistCommon;
	419
	420	#define HWDIST COMMON_BLOCK(HWDIST, hwdist)
	421	COMMON_BLOCK_DEF(HwdistCommon, HWDIST);
2d8d4543	422
	423	int const NMXQDK=20;
	424
455f128d	425	typedef struct {
2d8d4543	426	double VTXQDK[NMXQDK][4];
	427	int IMQDK[NMXQDK];
	428	int LOCQ[NMXQDK];
	429	int NQDK;
455f128d	430	} HwqdksCommon;
	431
	432	#define HWQDKS COMMON_BLOCK(HWQDKS, hwqdks)
	433	COMMON_BLOCK_DEF(HwqdksCommon, HWQDKS);
2d8d4543	434
	435	int const NMXSUD = 1024;
	436
455f128d	437	typedef struct {
2d8d4543	438	double ACCUR;
	439	double QEV[6][NMXSUD];
	440	double SUD[6][NMXSUD];
	441	int INTER;
	442	int NQEV;
	443	int NSUD;
	444	int SUDORD;
455f128d	445	} HwusudCommon;
	446
	447	#define HWUSUD COMMON_BLOCK(HWUSUD, hwusud)
	448	COMMON_BLOCK_DEF(HwusudCommon, HWUSUD);
2d8d4543	449
455f128d	450	typedef struct {
2d8d4543	451	double TANB;
	452	double ALPHAH;
	453	double COSBPA;
	454	double SINBPA;
	455	double COSBMA;
	456	double SINBMA;
	457	double COSA;
	458	double SINA;
	459	double COSB;
	460	double SINB;
	461	double COTB;
	462	double ZMIXSS[4][4];
	463	double ZMXNSS[4][4];
	464	double ZSGNSS[4];
	465	double LFCH[16];
	466	double RFCH[16];
	467	double SLFCH[4][16];
	468	double SRFCH[4][16];
	469	double WMXUSS[2][2];
	470	double WMXVSS[2][2];
	471	double WSGNSS[2];
	472	double QMIXSS[2][2][6];
	473	double LMIXSS[2][2][6];
	474	double THETAT;
	475	double THETAB;
	476	double THETAL;
	477	double ATSS;
	478	double ABSS;
	479	double ALSS;
	480	double MUSS;
	481	double FACTSS;
	482	double GHWWSS[3];
	483	double GHZZSS[3];
	484	double GHDDSS[4];
	485	double GHUUSS[4];
	486	double GHWHSS[3];
	487	double GHSQSS[2][2][6][4];
	488	double XLMNSS;
	489	double RMMNSS;
2fc6fff1	490	double DMSSM;
2d8d4543	491	double SENHNC[24];
	492	double SSPARITY;
	493	int SUSYIN;
455f128d	494	} HwsusyCommon;
2d8d4543	495
455f128d	496	#define HWSUSY COMMON_BLOCK(HWSUSY, hwsusy)
	497	COMMON_BLOCK_DEF(HwsusyCommon, HWSUSY);
	498
	499	typedef struct {
2d8d4543	500	double LAMDA1[3][3][3];
	501	double LAMDA2[3][3][3];
	502	double LAMDA3[3][3][3];
	503	int HRDCOL[5][2];
	504	int RPARTY;
	505	int COLUPD;
455f128d	506	} HwrparCommon;
	507
	508	#define HWRPAR COMMON_BLOCK(HWRPAR, hwrpar)
	509	COMMON_BLOCK_DEF(HwrparCommon, HWRPAR);
2d8d4543	510
455f128d	511	typedef struct {
2d8d4543	512	double PMBN1;
	513	double PMBN2;
	514	double PMBN3;
	515	double PMBK1;
	516	double PMBK2;
	517	double PMBM1;
	518	double PMBM2;
	519	double PMBP1;
	520	double PMBP2;
	521	double PMBP3;
455f128d	522	} HwminbCommon;
	523
	524	#define HWMINB COMMON_BLOCK(HWMINB, hwminb)
	525	COMMON_BLOCK_DEF(HwminbCommon, HWMINB);
2d8d4543	526
	527	int const NMXCL = 500;
	528
455f128d	529	typedef struct {
2d8d4543	530	double PPCL[NMXCL][5];
	531	int IDCL[NMXCL];
	532	int NCL;
455f128d	533	} HwclusCommon;
	534
	535	#define HWCLUS COMMON_BLOCK(HWCLUS, hwclus)
	536	COMMON_BLOCK_DEF(HwclusCommon, HWCLUS);
2d8d4543	537
e2054d85	538	// herwig 6.507
e2054d85	539
455f128d	540	typedef struct Hwgrav_t {
e2054d85	541	double GRVLAM;
	542	double EMGRV;
	543	double GAMGRV;
455f128d	544	} HwgravCommon;
	545
	546	#define HWGRAV COMMON_BLOCK(HWGRAV, hwgrav)
	547	COMMON_BLOCK_DEF(HwgravCommon, HWGRAV);
e2054d85	548
455f128d	549	typedef struct {
e2054d85	550	double VIPWID[3];
	551	double DXRCYL;
	552	double DXZMAX;
	553	double DXRSPH;
	554	int WZRFR;
	555	int FIX4JT;
	556	int IMSSM;
	557	int IHIGGS;
	558	int PARITY;
	559	int LRSUSY;
455f128d	560	} Hw6202Common;
	561
	562	#define HW6202 COMMON_BLOCK(HW6202, hw6202)
	563	COMMON_BLOCK_DEF(Hw6202Common, HW6202);
e2054d85	564
455f128d	565	typedef struct {
e2054d85	566	double ABWGT;
	567	double ABWSUM;
	568	double AVABW;
	569	int NNEGWT;
	570	int NNEGEV;
	571	int NEGWTS;
455f128d	572	} Hw6203Common;
	573
	574	#define HW6203 COMMON_BLOCK(HW6203, hw6203)
	575	COMMON_BLOCK_DEF(Hw6203Common, HW6203);
e2054d85	576
	577	int const IMAXCH = 20;
	578
455f128d	579	typedef struct {
e2054d85	580	double MJJMIN;
	581	double CHNPRB[IMAXCH];
	582	int IOPSTP;
	583	int IOPSH;
	584	int OPTM;
	585	int CHON[IMAXCH];
455f128d	586	} Hw6300Common;
e2054d85	587
455f128d	588	#define HW6300 COMMON_BLOCK(HW6300, hw6300)
455f128d	589	COMMON_BLOCK_DEF(Hw6300Common, HW6300);
e2054d85	590
	591	int const NXMRS = 49;
	592	int const NQMRS = 37;
	593	int const NPMRS = 8;
	594
455f128d	595	typedef struct {
e2054d85	596	double FMRS[NQMRS+1][NXMRS][NPMRS][3];
455f128d	597	} HwpmrsCommon;
	598
	599	#define HWPMRS COMMON_BLOCK(HWPMRS, hwpmrs)
	600	COMMON_BLOCK_DEF(HwpmrsCommon, HWPMRS);
e2054d85	601
455f128d	602	typedef struct {
e2054d85	603	int CIRCOP;
	604	int CIRCAC;
	605	int CIRCVR;
	606	int CIRCRV;
	607	int CIRCCH;
455f128d	608	} HwcircCommon;
	609
	610	#define HWCIRC COMMON_BLOCK(HWCIRC, hwcirc)
	611	COMMON_BLOCK_DEF(HwcircCommon, HWCIRC);
e2054d85	612
	613	int const NCFMAX = 3;
	614	int const NMODE2 = 500;
	615	int const NMODE3 = 500;
	616	int const NDIAGR = 8;
	617	int const NMODEB = 50;
	618	int const NMODE4 = 4;
	619
455f128d	620	typedef struct {
e2054d85	621	double ABMODE[NMODEB][2];
	622	double BBMODE[NMODEB][12][2];
	623	double PBMODE[NMODEB][12];
	624	double WTBMAX[NMODEB][12];
	625	int IDBPRT[NMODEB];
	626	int IBDRTP[NMODEB];
	627	int IBMODE[NMODEB];
	628	int NBMODE;
455f128d	629	} HwdspbCommon;
e2054d85	630
455f128d	631	#define HWDSPB COMMON_BLOCK(HWDSPB, hwdspb)
	632	COMMON_BLOCK_DEF(HwdspbCommon, HWDSPB);
	633
	634	typedef struct {
e2054d85	635	double A2MODE[NMODE2][2];
	636	double P2MODE[NMODE2];
	637	double WT2MAX[NMODE2];
	638	int ID2PRT[NMODE2];
	639	int I2DRTP[NMODE2];
	640	int N2MODE;
455f128d	641	} Hwdsp2Common;
	642
	643	#define HWDSP2 COMMON_BLOCK(HWDSP2, hwdsp2)
	644	COMMON_BLOCK_DEF(Hwdsp2Common, HWDSP2);
e2054d85	645
455f128d	646	typedef struct {
e2054d85	647	double A3MODE[NMODE3][NDIAGR][2];
	648	double B3MODE[NMODE3][NDIAGR][2];
	649	double P3MODE[NMODE3];
	650	double WT3MAX[NMODE3];
	651	double SPN3CF[NMODE3][NCFMAX][NCFMAX];
	652	int ID3PRT[NMODE3];
	653	int I3MODE[NMODE3][NDIAGR];
	654	int I3DRTP[NMODE3][NDIAGR];
	655	int N3MODE;
	656	int NDI3BY[NMODE3];
	657	int N3NCFL[NMODE3];
	658	int I3DRCF[NMODE3][NDIAGR];
455f128d	659	} Hwdsp3Common;
	660
	661	#define HWDSP3 COMMON_BLOCK(HWDSP3, hwdsp3)
	662	COMMON_BLOCK_DEF(Hwdsp3Common, HWDSP3);
e2054d85	663
455f128d	664	typedef struct {
e2054d85	665	double A4MODE[NMODE4][12][2];
	666	double B4MODE[NMODE4][12][2];
	667	double P4MODE[NMODE4][12][12];
	668	double WT4MAX[NMODE4][12][12];
	669	int ID4PRT[NMODE4];
	670	int I4MODE[NMODE4][2];
	671	int N4MODE;
455f128d	672	} Hwdsp4Common;
e2054d85	673
455f128d	674	#define HWDSP4 COMMON_BLOCK(HWDSP4, hwdsp4)
	675	COMMON_BLOCK_DEF(Hwdsp4Common, HWDSP4);
	676
	677	typedef struct {
e2054d85	678	int NDECSY;
	679	int NSEARCH;
	680	int LRDEC;
	681	int LWDEC;
	682	int SYSPIN;
	683	int THREEB;
	684	int FOURB;
	685	char TAUDEC[6];
455f128d	686	} HwdspnCommon;
	687
	688	#define HWDSPN COMMON_BLOCK(HWDSPN, hwdspn)
	689	COMMON_BLOCK_DEF(HwdspnCommon, HWDSPN);
e2054d85	690
	691	int const NMXSPN = 50;
	692
455f128d	693	typedef struct {
e2054d85	694	dcpx MESPN[NMXSPN][NCFMAX][2][2][2][2];
	695	dcpx RHOSPN[NMXSPN][2][2];
	696	double SPNCFC[NMXSPN][NCFMAX][NCFMAX];
	697	int IDSPN[NMXSPN];
	698	int JMOSPN[NMXSPN];
	699	int JDASPN[NMXSPN][2];
	700	int NSPN;
	701	int ISNHEP[NMXHEP];
	702	int NSNTRY;
	703	int DECSPN[NMXSPN];
	704	int NCFL[NMXSPN];
	705	int SPCOPT;
455f128d	706	} HwspinCommon;
	707
	708	#define HWSPIN COMMON_BLOCK(HWSPIN, hwspin)
	709	COMMON_BLOCK_DEF(HwspinCommon, HWSPIN);
e2054d85	710
455f128d	711	typedef struct {
e2054d85	712	int JAK1;
	713	int JAK2;
	714	int ITDKRC;
	715	int IFPHOT;
455f128d	716	} HwstauCommon;
	717
	718	#define HWSTAU COMMON_BLOCK(HWSTAU, hwstau)
	719	COMMON_BLOCK_DEF(HwstauCommon, HWSTAU);
e2054d85	720
	721	int const MAXHRP = 100;
	722
455f128d	723	typedef struct {
e2054d85	724	double LHWGT[MAXHRP];
	725	double LHWGTS[MAXHRP];
	726	double LHXSCT[MAXHRP];
	727	double LHXERR[MAXHRP];
	728	double LHXMAX[MAXHRP];
	729	double LHMXSM;
	730	int LHIWGT[MAXHRP];
	731	int LHNEVT[MAXHRP];
	732	int ITYPLH;
	733	int LHSOFT;
	734	int LHGLSF;
455f128d	735	} HwguprCommon;
	736
	737	#define HWGUPR COMMON_BLOCK(HWGUPR, hwgupr)
	738	COMMON_BLOCK_DEF(HwguprCommon, HWGUPR);
e2054d85	739
455f128d	740	typedef struct {
e2054d85	741	int PRESPL;
455f128d	742	} Hw6500Common;
	743
	744	#define HW6500 COMMON_BLOCK(HW6500, hw6500)
	745	COMMON_BLOCK_DEF(Hw6500Common, HW6500);
e2054d85	746
455f128d	747	typedef struct {
e2054d85	748	int ITOPRD;
455f128d	749	} Hw6504Common;
e2054d85	750
455f128d	751	#define HW6504 COMMON_BLOCK(HW6504, hw6504)
	752	COMMON_BLOCK_DEF(Hw6504Common, HW6504);
	753
	754	typedef struct {
e2054d85	755	double PDFX0;
e2054d85	756	double PDFPOW;
455f128d	757	} Hw6506Common;
e2054d85	758
455f128d	759	#define HW6506 COMMON_BLOCK(HW6506, hw6506)
455f128d	760	COMMON_BLOCK_DEF(Hw6506Common, HW6506);
e2054d85	761
455f128d	762	}
2d8d4543	763
2d8d4543	764	extern "C" {
455f128d	765	void hwuepr_();
	766	void hwigin_();
	767	void hwuinc_();
	768	void hweini_();
	769	void hwuine_();
	770	void hwepro_();
	771	void hwbgen_();
	772	void hwdhob_();
	773	void hwcfor_();
	774	void hwcdec_();
	775	void hwdhad_();
	776	void hwdhvy_();
	777	void hwmevt_();
	778	void hwufne_();
	779	void hwefin_();
	780	void hwusta_(const char * name, int);
	781	void hwiodk_(int);
2d8d4543	782	}
2d8d4543	783
7677b281	784	// subroutines to be call by JIMMY
	785
	786	extern "C" {
	787	void jminit_();
	788	void jimmin_();
	789	void jmefin_();
	790	}
	791
455f128d	792	#endif
2d8d4543	793
	794
	795
	796