THerwig/THerwig6.h

   1 #ifndef ROOT_THerwig
   2 #define ROOT_THerwig
   3
   4 // declaration of c++ Class THerwig6 to be used in ROOT
   5 // this is a c++ interface to the F77 Herwig6 program
   6 // author: j. g. contreras jgcn@moni.mda.cinvestav.mx
   7 // date: december 22, 2000
   8
   9 /*
  10
  11  Class THerwig6 is an interface to the Herwig program
  12
  13 C-----------------------------------------------------------------------
  14 C                           H E R W I G
  15 C
  16 C            a Monte Carlo event generator for simulating
  17 C        +---------------------------------------------------+
  18 C        | Hadron Emission Reactions With Interfering Gluons |
  19 C        +---------------------------------------------------+
  20 C I.G. Knowles(*), G. Marchesini(+), M.H. Seymour($) and B.R. Webber(#)
  21 C-----------------------------------------------------------------------
  22 C with Minimal Supersymmetric Standard Model Matrix Elements by
  23 C                  S. Moretti($) and K. Odagiri($)
  24 C-----------------------------------------------------------------------
  25 C R parity violating Supersymmetric Decays and Matrix Elements by
  26 C                          P. Richardson(&)
  27 C-----------------------------------------------------------------------
  28 C matrix element corrections to top decay and Drell-Yan type processes
  29 C                         by G. Corcella(+)
  30 C-----------------------------------------------------------------------
  31 C Deep Inelastic Scattering and Heavy Flavour Electroproduction by
  32 C                  G. Abbiendi(@) and L. Stanco(%)
  33 C-----------------------------------------------------------------------
  34 C and Jet Photoproduction in Lepton-Hadron Collisions by J. Chyla(~)
  35 C-----------------------------------------------------------------------
  36 C(*)  Department of Physics & Astronomy, University of Edinburgh
  37 C(+)  Dipartimento di Fisica, Universita di Milano
  38 C($)  Rutherford Appleton Laboratory
  39 C(#)  Cavendish Laboratory, Cambridge
  40 C(&)  Department of Physics, University of Oxford
  41 C(@)  Dipartimento di Fisica, Universita di Bologna
  42 C(%)  Dipartimento di Fisica, Universita di Padova
  43 C(~)  Institute of Physics, Prague
  44 C-----------------------------------------------------------------------
  45 C                  Version 6.100 - 16th December 1999
  46 C-----------------------------------------------------------------------
  47 C Main reference:
  48 C    G.Marchesini,  B.R.Webber,  G.Abbiendi,  I.G.Knowles,  M.H.Seymour,
  49 C    and L.Stanco, Computer Physics Communications 67 (1992) 465.
  50 C-----------------------------------------------------------------------
  51 C Please send e-mail about  this program  to one of the  authors at the
  52 C following Internet addresses:
  53 C    I.Knowles@ed.ac.uk        Giuseppe.Marchesini@mi.infn.it
  54 C    M.Seymour@rl.ac.uk        webber@hep.phy.cam.ac.uk
  55 C-----------------------------------------------------------------------
  56 */
  57
  58 /* declarations from ROOT */
  59 #include "TGenerator.h"
  60 #include "TObjArray.h"
  61
  62 // Translation of Fortran commons from the Herwig6
  63 // f77 program into c++ structures to be used in ROOT
  64 // and declaration of Fortran functions as extern
  65 // C functions to be called from the class Herwig6
  66 // author: j. g. contreras jgcn@moni.mda.cinvestav.mx
  67 // date: december 22, 2000
  68
  69 int const NMXHEP = 2000;
  70
  71 struct Hepevt_t {
  72   int NEVHEP;
  73   int NHEP;
  74   int ISTHEP[NMXHEP];
  75   int IDHEP[NMXHEP];
  76   int JMOHEP[NMXHEP][2];
  77   int JDAHEP[NMXHEP][2];
  78   double PHEP[NMXHEP][5];
  79   double VHEP[NMXHEP][4];
  80 };
  81
  82 struct Hwbeam_t {
  83   int IPART1;
  84   int IPART2;
  85 };
  86
  87 struct Hwbmch_t {
  88   char PART1[8];
  89   char PART2[8];
  90 };
  91
  92 struct Hwproc_t {
  93   double EBEAM1;
  94   double EBEAM2;
  95   double PBEAM1;
  96   double PBEAM2;
  97   int    IPROC;
  98   int    MAXEV;
  99 };
 100
 101 struct Hwpram_t {
 102   double AFCH[2][16];
 103   double ALPHEM;
 104   double B1LIM;
 105   double BETAF;
 106   double BTCLM;
 107   double CAFAC;
 108   double CFFAC;
 109   double CLMAX;
 110   double CLPOW;
 111   double CLSMR[2];
 112   double CSPEED;
 113   double ENSOF;
 114   double ETAMIX;
 115   double F0MIX;
 116   double F1MIX;
 117   double F2MIX;
 118   double GAMH;
 119   double GAMW;
 120   double GAMZ;
 121   double GAMZP;
 122   double GEV2NB;
 123   double H1MIX;
 124   double PDIQK;
 125   double PGSMX;
 126   double PGSPL[4];
 127   double PHIMIX;
 128   double PIFAC;
 129   double PRSOF;
 130   double PSPLT[2];
 131   double PTRMS;
 132   double PXRMS;
 133   double QCDL3;
 134   double QCDL5;
 135   double QCDLAM;
 136   double QDIQK;
 137   double QFCH[16];
 138   double QG;
 139   double QSPAC;
 140   double QV;
 141   double SCABI;
 142   double SWEIN;
 143   double TMTOP;
 144   double VFCH[2][16];
 145   double VCKM[3][3];
 146   double VGCUT;
 147   double VQCUT;
 148   double VPCUT;
 149   double ZBINM;
 150   double EFFMIN;
 151   double OMHMIX;
 152   double ET2MIX;
 153   double PH3MIX;
 154   double GCUTME;
 155   int    IOPREM;
 156   int    IPRINT;
 157   int    ISPAC;
 158   int    LRSUD;
 159   int    LWSUD;
 160   int    MODPDF[2];
 161   int    NBTRY;
 162   int    NCOLO;
 163   int    NCTRY;
 164   int    NDTRY;
 165   int    NETRY;
 166   int    NFLAV;
 167   int    NGSPL;
 168   int    NSTRU;
 169   int    NSTRY;
 170   int    NZBIN;
 171   int    IOP4JT[2];
 172   int    NPRFMT;
 173   int AZSOFT;
 174   int AZSPIN;
 175   int CLDIR[2];
 176   int HARDME;
 177   int NOSPAC;
 178   int PRNDEC;
 179   int PRVTX;
 180   int SOFTME;
 181   int ZPRIME;
 182   int PRNDEF;
 183   int PRNTEX;
 184   int PRNWEB;
 185 };
 186
 187 struct Hwprch_t {
 188   char AUTPDF[2][20];
 189   char BDECAY[4];
 190 };
 191
 192 int const NMXPAR = 500;
 193
 194 struct Hwpart_t {
 195   int  NEVPAR;
 196   int  NPAR;
 197   int  ISTPAR[NMXPAR];
 198   int  IDPAR[NMXPAR];
 199   int  JMOPAR[NMXPAR][2];
 200   int  JDAPAR[NMXPAR][2];
 201   double  PPAR[NMXPAR][5];
 202   double  VPAR[NMXPAR][4];
 203 };
 204
 205 struct Hwparp_t {
 206   double DECPAR[NMXPAR][2];
 207   double PHIPAR[NMXPAR][2];
 208   double RHOPAR[NMXPAR][2];
 209   int TMPAR[NMXPAR];
 210 };
 211
 212 int const MODMAX = 5;
 213
 214 struct Hwbosc_t {
 215   double  ALPFAC;
 216   double  BRHIG[12];
 217   double  ENHANC[12];
 218   double  GAMMAX;
 219   double  RHOHEP[NMXHEP][3];
 220   int     IOPHIG;
 221   int     MODBOS[MODMAX];
 222 };
 223
 224 struct Hwparc_t {
 225   int     JCOPAR[NMXPAR][4];
 226 };
 227
 228 struct Hwbrch_t {
 229   double ANOMSC[2][2];
 230   double HARDST;
 231   double PTINT[2][3];
 232   double XFACT;
 233   int    INHAD;
 234   int    JNHAD;
 235   int    NSPAC[7];
 236   int    ISLENT;
 237   int    BREIT;
 238   int    FROST;
 239   int    USECMF;
 240 };
 241
 242 struct Hwevnt_t {
 243   double AVWGT;
 244   double EVWGT;
 245   double GAMWT;
 246   double TLOUT;
 247   double WBIGST;
 248   double WGTMAX;
 249   double WGTSUM;
 250   double WSQSUM;
 251   int    IDHW[NMXHEP];
 252   int    IERROR;
 253   int    ISTAT;
 254   int    LWEVT;
 255   int    MAXER;
 256   int    MAXPR;
 257   int    NOWGT;
 258   int    NRN[2];
 259   int    NUMER;
 260   int    NUMERU;
 261   int    NWGTS;
 262   int    GENSOF;
 263 };
 264
 265 struct Hwhard_t {
 266   double ASFIXD;
 267   double CLQ[6][7];
 268   double COSS;
 269   double COSTH;
 270   double CTMAX;
 271   double DISF[2][13];
 272   double EMLST;
 273   double EMMAX;
 274   double EMMIN;
 275   double EMPOW;
 276   double EMSCA;
 277   double EPOLN[3];
 278   double GCOEF[7];
 279   double GPOLN;
 280   double OMEGA0;
 281   double PHOMAS;
 282   double PPOLN[3];
 283   double PTMAX;
 284   double PTMIN;
 285   double PTPOW;
 286   double Q2MAX;
 287   double Q2MIN;
 288   double Q2POW;
 289   double Q2WWMN;
 290   double Q2WWMX;
 291   double QLIM;
 292   double SINS;
 293   double THMAX;
 294   double Y4JT;
 295   double TMNISR;
 296   double TQWT;
 297   double XX[2];
 298   double XLMIN;
 299   double XXMIN;
 300   double YBMAX;
 301   double YBMIN;
 302   double YJMAX;
 303   double YJMIN;
 304   double YWWMAX;
 305   double YWWMIN;
 306   double WHMIN;
 307   double ZJMAX;
 308   double ZMXISR;
 309   int    IAPHIG;
 310   int    IBRN[2];
 311   int    IBSH;
 312   int    ICO[10];
 313   int    IDCMF;
 314   int    IDN[10];
 315   int    IFLMAX;
 316   int    IFLMIN;
 317   int    IHPRO;
 318   int    IPRO;
 319   int    MAPQ[10];
 320   int    MAXFL;
 321   int    BGSHAT;
 322   int    COLISR;
 323   int    FSTEVT;
 324   int    FSTWGT;
 325   int    GENEV;
 326   int    HVFCEN;
 327   int    TPOL;
 328   int     DURHAM;
 329 };
 330
 331 int const NMXRES = 500;
 332
 333 struct Hwprop_t {
 334   double RLTIM[NMXRES+1];
 335   double RMASS[NMXRES+1];
 336   double RSPIN[NMXRES+1];
 337   int    ICHRG[NMXRES+1];
 338   int    IDPDG[NMXRES+1];
 339   int    IFLAV[NMXRES+1];
 340   int    NRES;
 341   int    VTOCDK[NMXRES+1];
 342   int    VTORDK[NMXRES+1];
 343   int    QORQQB[NMXRES+1];
 344   int    QBORQQ[NMXRES+1];
 345 };
 346
 347 struct Hwunam_t {
 348   char RNAME[NMXRES+1][8];
 349   char TXNAME[NMXRES+1][2][37];
 350 };
 351
 352 int const NMXDKS = 4000;
 353 int const NMXMOD = 200;
 354
 355 struct Hwupdt_t {
 356   double BRFRAC[NMXDKS];
 357   double CMMOM[NMXDKS];
 358   double DKLTM[NMXRES];
 359   int    IDK[NMXDKS];
 360   int    IDKPRD[NMXDKS][5];
 361   int    LNEXT[NMXDKS];
 362   int    LSTRT[NMXRES];
 363   int    NDKYS;
 364   int    NME[NMXDKS];
 365   int    NMODES[NMXRES];
 366   int    NPRODS[NMXDKS];
 367   int    DKPSET;
 368   int    RSTAB[NMXRES+1];
 369 };
 370
 371 struct Hwuwts_t {
 372   double REPWT[5][4][4];
 373   double SNGWT;
 374   double DECWT;
 375   double QWT[3];
 376   double PWT[12];
 377   double SWTEF[NMXRES];
 378 };
 379
 380 int const NMXCDK = 4000;
 381
 382 struct Hwuclu_t {
 383   double CLDKWT[NMXCDK];
 384   double CTHRPW[12][12];
 385   double PRECO;
 386   double RESN[12][12];
 387   double RMIN[12][12];
 388   int    LOCN[12][12];
 389   int    NCLDK[NMXCDK];
 390   int    NRECO;
 391   int    CLRECO;
 392 };
 393
 394 struct Hwdist_t {
 395   double EXAG;
 396   double GEV2MM;
 397   double HBAR;
 398   double PLTCUT;
 399   double VMIN2;
 400   double VTXPIP[4];
 401   double XMIX[2];
 402   double XMRCT[2];
 403   double YMIX[2];
 404   double YMRCT[2];
 405   int    IOPDKL;
 406   int    MAXDKL;
 407   int    MIXING;
 408   int    PIPSMR;
 409 };
 410
 411 int const NMXQDK=20;
 412
 413 struct Hwqdks_t {
 414   double VTXQDK[NMXQDK][4];
 415   int    IMQDK[NMXQDK];
 416   int    LOCQ[NMXQDK];
 417   int    NQDK;
 418 };
 419
 420 int const NMXSUD = 1024;
 421
 422 struct Hwusud_t {
 423   double ACCUR;
 424   double QEV[6][NMXSUD];
 425   double SUD[6][NMXSUD];
 426   int    INTER;
 427   int    NQEV;
 428   int    NSUD;
 429   int    SUDORD;
 430 };
 431
 432 struct Hwsusy_t {
 433   double TANB;
 434   double ALPHAH;
 435   double COSBPA;
 436   double SINBPA;
 437   double COSBMA;
 438   double SINBMA;
 439   double COSA;
 440   double SINA;
 441   double COSB;
 442   double SINB;
 443   double COTB;
 444   double ZMIXSS[4][4];
 445   double ZMXNSS[4][4];
 446   double ZSGNSS[4];
 447   double LFCH[16];
 448   double RFCH[16];
 449   double SLFCH[4][16];
 450   double SRFCH[4][16];
 451   double WMXUSS[2][2];
 452   double WMXVSS[2][2];
 453   double WSGNSS[2];
 454   double QMIXSS[2][2][6];
 455   double LMIXSS[2][2][6];
 456   double THETAT;
 457   double THETAB;
 458   double THETAL;
 459   double ATSS;
 460   double ABSS;
 461   double ALSS;
 462   double MUSS;
 463   double FACTSS;
 464   double GHWWSS[3];
 465   double GHZZSS[3];
 466   double GHDDSS[4];
 467   double GHUUSS[4];
 468   double GHWHSS[3];
 469   double GHSQSS[2][2][6][4];
 470   double XLMNSS;
 471   double RMMNSS;
 472   double IMSSM;
 473   double SENHNC[24];
 474   double SSPARITY;
 475   int    SUSYIN;
 476 };
 477
 478 struct Hwrpar_t {
 479   double LAMDA1[3][3][3];
 480   double LAMDA2[3][3][3];
 481   double LAMDA3[3][3][3];
 482   int    HRDCOL[5][2];
 483   int    RPARTY;
 484   int    COLUPD;
 485 };
 486
 487 struct Hwminb_t {
 488   double PMBN1;
 489   double PMBN2;
 490   double PMBN3;
 491   double PMBK1;
 492   double PMBK2;
 493   double PMBM1;
 494   double PMBM2;
 495   double PMBP1;
 496   double PMBP2;
 497   double PMBP3;
 498 };
 499
 500 int const NMXCL = 500;
 501
 502 struct Hwclus_t {
 503   double PPCL[NMXCL][5];
 504   int    IDCL[NMXCL];
 505   int    NCL;
 506 };
 507
 508
 509 extern "C" {
 510   void  hwigin_();
 511   void  hwuinc_();
 512   void  hwusta_(char * name, int);
 513   void  hweini_();
 514   void  hwuine_();
 515   void  hwepro_();
 516   void  hwbgen_();
 517   void  hwdhob_();
 518   void  hwcfor_();
 519   void  hwcdec_();
 520   void  hwdhad_();
 521   void  hwdhvy_();
 522   void  hwmevt_();
 523   void  hwufne_();
 524   void  hwefin_();
 525 }
 526
 527
 528
 529
 530
 531
 532 /* THerwig6 class declaration */
 533 class THerwig6 : public TGenerator {
 534 protected:
 535   // Standard hep common block
 536   Hepevt_t* fHepevt;
 537   // Herwig6 common-blocks
 538   Hwbeam_t* fHwbeam;
 539   Hwbmch_t* fHwbmch;
 540   Hwproc_t* fHwproc;
 541   Hwpram_t* fHwpram;
 542   Hwprch_t* fHwprch;
 543   Hwpart_t* fHwpart;
 544   Hwparp_t* fHwparp;
 545   Hwbosc_t* fHwbosc;
 546   Hwparc_t* fHwparc;
 547   Hwbrch_t* fHwbrch;
 548   Hwevnt_t* fHwevnt;
 549   Hwhard_t* fHwhard;
 550   Hwprop_t* fHwprop;
 551   Hwunam_t* fHwunam;
 552   Hwupdt_t* fHwupdt;
 553   Hwuwts_t* fHwuwts;
 554   Hwuclu_t* fHwuclu;
 555   Hwdist_t* fHwdist;
 556   Hwqdks_t* fHwqdks;
 557   Hwusud_t* fHwusud;
 558   Hwsusy_t* fHwsusy;
 559   Hwrpar_t* fHwrpar;
 560   Hwminb_t* fHwminb;
 561   Hwclus_t* fHwclus;
 562 //----------------------------------------------------------------------------
 563 //  functions:
 564 //----------------------------------------------------------------------------
 565 public:
 566                                 // ****** constructors and destructor
 567   THerwig6();
 568   virtual ~THerwig6();
 569
 570   // acces to hep common block
 571   Hepevt_t*   GetHepevt        ()           { return fHepevt; }
 572   int         GetNevhep        ()           { return fHepevt->NEVHEP; }
 573   int         GetNhep          ()           { return fHepevt->NHEP; }
 574   int         GetISTHEP    (int i)          { return fHepevt->ISTHEP[i-1]; }
 575   int         GetIDHEP     (int i)          { return fHepevt->IDHEP[i-1]; }
 576   int         GetJMOHEP (int i, int j) { return fHepevt->JMOHEP[i-1][j-1]; }
 577   int         GetJDAHEP (int i, int j) { return fHepevt->JDAHEP[i-1][j-1]; }
 578   double      GetPHEP   (int i, int j) { return fHepevt->PHEP[i-1][j-1]; }
 579   double      GetVHEP   (int i, int j) { return fHepevt->VHEP[i-1][j-1]; }
 580
 581   // access to Herwig6 common-blocks
 582   // WARNING: Some arrays start in 1, others in 0. Look up the manual!
 583
 584   // /HWBEAM/
 585
 586   Hwbeam_t*   GetHwbeam        ()           { return fHwbeam; }
 587   int         GetIPART1        ()           { return fHwbeam->IPART1; }
 588   int         GetIPART2        ()           { return fHwbeam->IPART2; }
 589
 590   // /HWBMCH/
 591   Hwbmch_t*   GetHwbmch        ()           { return fHwbmch; }
 592   char*       GetPART1         ()           { return fHwbmch->PART1; }
 593   char*       GetPART2         ()           { return fHwbmch->PART2; }
 594
 595
 596   // /HWPROC/
 597   Hwproc_t*   GetHwproc        ()           { return fHwproc; }
 598   double      GetEBEAM1        ()           { return fHwproc->EBEAM1; }
 599   double      GetEBEAM2        ()           { return fHwproc->EBEAM2; }
 600   double      GetPBEAM1        ()           { return fHwproc->PBEAM1; }
 601   double      GetPBEAM2        ()           { return fHwproc->PBEAM2; }
 602   int         GetIPROC         ()           { return fHwproc->IPROC; }
 603   int         GetMAXEV         ()           { return fHwproc->MAXEV; }
 604
 605   // /HWPRAM/
 606   Hwpram_t*   GetHwpram        ()           { return fHwpram; }
 607   double      GetQCDLAM        ()           { return fHwpram->QCDLAM; }
 608   void        SetQCDLAM   (double q)        { fHwpram->QCDLAM = q; }
 609   double      GetVQCUT         ()           { return fHwpram->VQCUT; }
 610   void        SetVQCUT    (double v)        { fHwpram->VQCUT = v; }
 611   double      GetVGCUT         ()           { return fHwpram->VGCUT; }
 612   void        SetVGCUT    (double v)        { fHwpram->VGCUT = v; }
 613   double      GetVPCUT         ()           { return fHwpram->VPCUT; }
 614   void        SetVPCUT    (double v)        { fHwpram->VPCUT = v; }
 615   double      GetCLMAX         ()           { return fHwpram->CLMAX; }
 616   void        SetCLMAX    (double c)        { fHwpram->CLMAX = c; }
 617   double      GetCLPOW         ()           { return fHwpram->CLPOW; }
 618   void        SetCLPOW    (double c)        { fHwpram->CLPOW = c; }
 619   double      GetPSPLT    (int i)           { return fHwpram->PSPLT[i-1];}
 620   void        SetPSPLT    (int i, double p) { fHwpram->PSPLT[i-1] = p;}
 621   double      GetQDIQK         ()           { return fHwpram->QDIQK; }
 622   void        SetQDIQK    (double q)        { fHwpram->QDIQK = q; }
 623   double      GetPDIQK         ()           { return fHwpram->PDIQK; }
 624   void        SetPDIQK    (double p)        { fHwpram->PDIQK = p; }
 625   double      GetQSPAC         ()           { return fHwpram->QSPAC; }
 626   void        SetQSPAC    (double q)        { fHwpram->QSPAC = q; }
 627   double      GetPTRMS         ()           { return fHwpram->PTRMS; }
 628   void        SetPTRMS    (double p)        { fHwpram->PTRMS = p; }
 629   double      GetENSOF         ()           { return fHwpram->ENSOF; }
 630   void        SetENSOF    (double e)        { fHwpram->ENSOF = e; }
 631   int         GetIPRINT         ()          { return fHwpram->IPRINT; }
 632   void        SetIPRINT    (int i)          { fHwpram->IPRINT = i; }
 633   int         GetMODPDF     (int i)         { return fHwpram->MODPDF[i-1];}
 634   void        SetMODPDF     (int i, int j)  { fHwpram->MODPDF[i-1] = j; }
 635   int         GetNSTRU         ()           { return fHwpram->NSTRU; }
 636   void        SetNSTRU     (int i)          { fHwpram->NSTRU = i; }
 637
 638   // /HWPRCH/
 639   Hwprch_t*   GetHwprch        ()           { return fHwprch; }
 640   char*       GetAUTPDF     (int i)         { return fHwprch->AUTPDF[i-1]; }
 641   void        SetAUTPDF(int i,const char* s){ strncpy(fHwprch->AUTPDF[i-1],s,20);}
 642   char*       GetBDECAY        ()           { return fHwprch->BDECAY; }
 643
 644   // /HWPART/
 645   Hwpart_t*   GetHwpart        ()           { return fHwpart; }
 646
 647   // /HWPARP/
 648   Hwparp_t*   GetHwparp        ()           { return fHwparp; }
 649
 650   // /HWBOSC/
 651   Hwbosc_t*   GetHwbosc        ()           { return fHwbosc; }
 652
 653   // /HWPARC/
 654   Hwparc_t*   GetHwparc        ()           { return fHwparc; }
 655
 656   // /HWBRCH/
 657   Hwbrch_t*   GetHwbrch        ()           { return fHwbrch; }
 658
 659   // /HWEVNT/
 660   Hwevnt_t*   GetHwevnt        ()           { return fHwevnt; }
 661   double      GetAVWGT         ()           { return fHwevnt->AVWGT; }
 662   int         GetMAXPR         ()           { return fHwevnt->MAXPR; }
 663   void        SetMAXPR    (int i)           { fHwevnt->MAXPR = i; }
 664   int         GetMAXER         ()           { return fHwevnt->MAXER; }
 665   void        SetMAXER    (int i)           { fHwevnt->MAXER = i; }
 666   int         GetNRN      (int i)           { return fHwevnt->NRN[i-1]; }
 667   void        SetNRN    (int i, int j)      { fHwevnt->NRN[i-1] = j; }
 668
 669   // /HWHARD/
 670   Hwhard_t*   GetHwhard        ()           { return fHwhard; }
 671   double      GetPTMIN         ()           { return fHwhard->PTMIN; }
 672   void        SetPTMIN    (double d)        { fHwhard->PTMIN = d; }
 673   double      GetPTPOW         ()           { return fHwhard->PTPOW; }
 674   void        SetPTPOW    (double d)        { fHwhard->PTPOW = d; }
 675   double      GetYJMIN         ()           { return fHwhard->YJMIN; }
 676   void        SetYJMIN    (double d)        { fHwhard->YJMIN = d; }
 677   double      GetYJMAX         ()           { return fHwhard->YJMAX; }
 678   void        SetYJMAX    (double d)        { fHwhard->YJMAX = d; }
 679   double      GetQ2MIN         ()           { return fHwhard->Q2MIN; }
 680   void        SetQ2MIN    (double d)        { fHwhard->Q2MIN = d; }
 681   double      GetQ2MAX         ()           { return fHwhard->Q2MAX; }
 682   void        SetQ2MAX    (double d)        { fHwhard->Q2MAX = d; }
 683   double      GetYBMIN         ()           { return fHwhard->YBMIN; }
 684   void        SetYBMIN    (double d)        { fHwhard->YBMIN = d; }
 685   double      GetYBMAX         ()           { return fHwhard->YBMAX; }
 686   void        SetYBMAX    (double d)        { fHwhard->YBMAX = d; }
 687   double      GetZJMAX        ()            { return fHwhard->ZJMAX; }
 688   void        SetZJMAX    (double d)        { fHwhard->ZJMAX = d; }
 689
 690   // /HWPROP/
 691   Hwprop_t*   GetHwprop        ()           { return fHwprop; }
 692   double      GetRMASS      (int i)         { return fHwprop->RMASS[i]; }
 693   void        SetRMASS    (int i, double r) { fHwprop->RMASS[i] = r; }
 694
 695   // /HWUNAM/
 696   Hwunam_t*   GetHwunam        ()           { return fHwunam; }
 697
 698   // /HWUPDT/
 699   Hwupdt_t*   GetHwupdt        ()           { return fHwupdt; }
 700
 701   // /HWUWTS/
 702   Hwuwts_t*   GetHwuwts        ()           { return fHwuwts; }
 703
 704   // /HWUCLU/
 705   Hwuclu_t*   GetHwuclu        ()           { return fHwuclu; }
 706
 707   // /HWDIST/
 708   Hwdist_t*   GetHwdist        ()           { return fHwdist; }
 709
 710   // /HWQDKT/
 711   Hwqdks_t*   GetHwqdkt        ()           { return fHwqdks; }
 712
 713   // /HWUSUD/
 714   Hwusud_t*   GetHwusud        ()           { return fHwusud; }
 715
 716   // /HWSUSY/
 717   Hwsusy_t*   GetHwsusy        ()           { return fHwsusy; }
 718
 719   // /HWRPAR/
 720   Hwrpar_t*   GetHwrpar        ()           { return fHwrpar; }
 721
 722   // /HWMINB/
 723   Hwminb_t*   GetHwminb        ()           { return fHwminb; }
 724
 725   // /HWCLUS/
 726   Hwclus_t*   GetHwclus        ()           { return fHwclus; }
 727
 728   // Herwig6 routines
 729   // the user would call
 730   //   Initialize
 731   //   change by himself the parameters s/he wants
 732   //   Hwusta to make stable the particles s/he wants
 733   //   PrepareRun
 734   //   GenerateEvent as many times as wished
 735   // An example is given in SetupTest
 736
 737   void             GenerateEvent();
 738   void             Initialize(const char *beam, const char *target, double pbeam1, double pbeam2, int iproc);
 739   void             PrepareRun();
 740   void             OpenFortranFile(int lun, char* name);
 741   void             CloseFortranFile(int lun);
 742   Int_t            ImportParticles(TClonesArray *particles, Option_t *option="");
 743   TObjArray       *ImportParticles(Option_t *option="");
 744   TObjArray       *Particles() { return fParticles; }
 745   void             Hwigin();
 746   void             Hwuinc();
 747   void             Hwusta(char * name);
 748   void             Hweini();
 749   void             Hwuine();
 750   void             Hwepro();
 751   void             Hwbgen();
 752   void             Hwdhob();
 753   void             Hwcfor();
 754   void             Hwcdec();
 755   void             Hwdhad();
 756   void             Hwdhvy();
 757   void             Hwmevt();
 758   void             Hwufne();
 759   void             Hwefin();
 760   void             SetupTest();
 761
 762   ClassDef(THerwig6,0)  //Interface to Herwig6.1 Event Generator
 763 };
 764
 765 #endif