THerwig/THerwig6.h

   1 #ifndef THERWIG6_H
   2 #define THERWIG6_H
   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 class TObjArray;
  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 typedef struct {
  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 } Hepevt_t;
  81
  82 typedef struct {
  83   int IPART1;
  84   int IPART2;
  85 } Hwbeam_t;
  86
  87 typedef struct {
  88   char PART1[8];
  89   char PART2[8];
  90 } Hwbmch_t;
  91
  92 typedef struct {
  93   double EBEAM1;
  94   double EBEAM2;
  95   double PBEAM1;
  96   double PBEAM2;
  97   int    IPROC;
  98   int    MAXEV;
  99 } Hwproc_t;
 100
 101 typedef struct {
 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 } Hwpram_t;
 186
 187 typedef struct {
 188   char AUTPDF[2][20];
 189   char BDECAY[4];
 190 } Hwprch_t;
 191
 192 int const NMXPAR = 500;
 193
 194 typedef struct {
 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 } Hwpart_t;
 204
 205 typedef struct {
 206   double DECPAR[NMXPAR][2];
 207   double PHIPAR[NMXPAR][2];
 208   double RHOPAR[NMXPAR][2];
 209   int TMPAR[NMXPAR];
 210 } Hwparp_t;
 211
 212 int const MODMAX = 5;
 213
 214 typedef struct {
 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 } Hwbosc_t;
 223
 224 typedef struct {
 225   int     JCOPAR[NMXPAR][4];
 226 } Hwparc_t;
 227
 228 typedef struct {
 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 } Hwbrch_t;
 241
 242 typedef struct {
 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 } Hwevnt_t;
 264
 265 typedef struct {
 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 } Hwhard_t;
 330
 331 int const NMXRES = 500;
 332
 333 typedef struct {
 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 } Hwprop_t;
 346
 347 typedef struct {
 348   char RNAME[NMXRES+1][8];
 349   char TXNAME[NMXRES+1][2][37];
 350 } Hwunam_t;
 351
 352 int const NMXDKS = 4000;
 353 int const NMXMOD = 200;
 354
 355 typedef struct {
 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 } Hwupdt_t;
 370
 371 typedef struct {
 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 } Hwuwts_t;
 379
 380 int const NMXCDK = 4000;
 381
 382 typedef struct {
 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 } Hwuclu_t;
 393
 394 typedef struct {
 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 } Hwdist_t;
 410
 411 int const NMXQDK=20;
 412
 413 typedef struct {
 414   double VTXQDK[NMXQDK][4];
 415   int    IMQDK[NMXQDK];
 416   int    LOCQ[NMXQDK];
 417   int    NQDK;
 418 } Hwqdks_t;
 419
 420 int const NMXSUD = 1024;
 421
 422 typedef struct {
 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 } Hwusud_t;
 431
 432 typedef struct {
 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 } Hwsusy_t;
 477
 478 typedef struct {
 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 } Hwrpar_t;
 486
 487 typedef struct {
 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 } Hwminb_t;
 499
 500 int const NMXCL = 500;
 501
 502 typedef struct {
 503   double PPCL[NMXCL][5];
 504   int    IDCL[NMXCL];
 505   int    NCL;
 506 } Hwclus_t;
 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 //----------------------------------------------------------------------------
 535 //  functions:
 536 //----------------------------------------------------------------------------
 537 public:
 538                                 // ****** constructors and destructor
 539   THerwig6();
 540   THerwig6(const THerwig6 & source): TGenerator(source) {
 541     Fatal("THerwig6","Copy constructor not implemented yet");
 542   }
 543   THerwig6 & operator=(const THerwig6 & /*source*/) {
 544     Fatal("THerwig6","Assignment operator not implemented yet");
 545     return *this;
 546   }
 547   virtual ~THerwig6();
 548
 549   // acces to hep common block
 550   Hepevt_t*   GetHepevt        () const     { return fHepevt; }
 551   int         GetNevhep        () const     { return fHepevt->NEVHEP; }
 552   int         GetNhep          () const     { return fHepevt->NHEP; }
 553   int         GetISTHEP    (int i)const     { return fHepevt->ISTHEP[i-1]; }
 554   int         GetIDHEP     (int i)const     { return fHepevt->IDHEP[i-1]; }
 555   int         GetJMOHEP (int i, int j) const
 556     { return fHepevt->JMOHEP[i-1][j-1]; }
 557   int         GetJDAHEP (int i, int j) const
 558     { return fHepevt->JDAHEP[i-1][j-1]; }
 559   double      GetPHEP   (int i, int j) const
 560     { return fHepevt->PHEP[i-1][j-1]; }
 561   double      GetVHEP   (int i, int j) const
 562     { return fHepevt->VHEP[i-1][j-1]; }
 563
 564   // access to Herwig6 common-blocks
 565   // WARNING: Some arrays start in 1, others in 0. Look up the manual!
 566
 567   // /HWBEAM/
 568
 569   Hwbeam_t*   GetHwbeam        ()           { return fHwbeam; }
 570   int         GetIPART1        () const     { return fHwbeam->IPART1; }
 571   int         GetIPART2        () const     { return fHwbeam->IPART2; }
 572
 573   // /HWBMCH/
 574   Hwbmch_t*   GetHwbmch        ()           { return fHwbmch; }
 575   char*       GetPART1         () const     { return fHwbmch->PART1; }
 576   char*       GetPART2         () const     { return fHwbmch->PART2; }
 577
 578
 579   // /HWPROC/
 580   Hwproc_t*   GetHwproc        ()           { return fHwproc; }
 581   double      GetEBEAM1        () const     { return fHwproc->EBEAM1; }
 582   double      GetEBEAM2        () const     { return fHwproc->EBEAM2; }
 583   double      GetPBEAM1        () const     { return fHwproc->PBEAM1; }
 584   double      GetPBEAM2        () const     { return fHwproc->PBEAM2; }
 585   int         GetIPROC         () const     { return fHwproc->IPROC; }
 586   int         GetMAXEV         () const     { return fHwproc->MAXEV; }
 587
 588   // /HWPRAM/
 589   Hwpram_t*   GetHwpram        ()           { return fHwpram; }
 590   double      GetQCDLAM        () const     { return fHwpram->QCDLAM; }
 591   void        SetQCDLAM   (double q)        { fHwpram->QCDLAM = q; }
 592   double      GetVQCUT         () const     { return fHwpram->VQCUT; }
 593   void        SetVQCUT    (double v)        { fHwpram->VQCUT = v; }
 594   double      GetVGCUT         () const     { return fHwpram->VGCUT; }
 595   void        SetVGCUT    (double v)        { fHwpram->VGCUT = v; }
 596   double      GetVPCUT         () const     { return fHwpram->VPCUT; }
 597   void        SetVPCUT    (double v)        { fHwpram->VPCUT = v; }
 598   double      GetCLMAX         () const     { return fHwpram->CLMAX; }
 599   void        SetCLMAX    (double c)        { fHwpram->CLMAX = c; }
 600   double      GetCLPOW         () const     { return fHwpram->CLPOW; }
 601   void        SetCLPOW    (double c)        { fHwpram->CLPOW = c; }
 602   double      GetPSPLT    (int i) const     { return fHwpram->PSPLT[i-1];}
 603   void        SetPSPLT    (int i, double p) { fHwpram->PSPLT[i-1] = p;}
 604   double      GetQDIQK         () const     { return fHwpram->QDIQK; }
 605   void        SetQDIQK    (double q)        { fHwpram->QDIQK = q; }
 606   double      GetPDIQK         () const     { return fHwpram->PDIQK; }
 607   void        SetPDIQK    (double p)        { fHwpram->PDIQK = p; }
 608   double      GetQSPAC         () const     { return fHwpram->QSPAC; }
 609   void        SetQSPAC    (double q)        { fHwpram->QSPAC = q; }
 610   double      GetPTRMS         () const     { return fHwpram->PTRMS; }
 611   void        SetPTRMS    (double p)        { fHwpram->PTRMS = p; }
 612   double      GetENSOF         () const     { return fHwpram->ENSOF; }
 613   void        SetENSOF    (double e)        { fHwpram->ENSOF = e; }
 614   int         GetIPRINT        () const     { return fHwpram->IPRINT; }
 615   void        SetIPRINT   (int i)           { fHwpram->IPRINT = i; }
 616   int         GetMODPDF   (int i) const     { return fHwpram->MODPDF[i-1];}
 617   void        SetMODPDF   (int i, int j)  { fHwpram->MODPDF[i-1] = j; }
 618   int         GetNSTRU         () const     { return fHwpram->NSTRU; }
 619   void        SetNSTRU    (int i)          { fHwpram->NSTRU = i; }
 620
 621   // /HWPRCH/
 622   Hwprch_t*   GetHwprch        ()           { return fHwprch; }
 623   char*       GetAUTPDF     (int i)         { return fHwprch->AUTPDF[i-1]; }
 624   void        SetAUTPDF(int i,const char* s){ strncpy(fHwprch->AUTPDF[i-1],s,20);}
 625   char*       GetBDECAY        ()           { return fHwprch->BDECAY; }
 626
 627   // /HWPART/
 628   Hwpart_t*   GetHwpart        ()           { return fHwpart; }
 629
 630   // /HWPARP/
 631   Hwparp_t*   GetHwparp        ()           { return fHwparp; }
 632
 633   // /HWBOSC/
 634   Hwbosc_t*   GetHwbosc        ()           { return fHwbosc; }
 635
 636   // /HWPARC/
 637   Hwparc_t*   GetHwparc        ()           { return fHwparc; }
 638
 639   // /HWBRCH/
 640   Hwbrch_t*   GetHwbrch        ()           { return fHwbrch; }
 641
 642   // /HWEVNT/
 643   Hwevnt_t*   GetHwevnt        ()           { return fHwevnt; }
 644   double      GetAVWGT         () const     { return fHwevnt->AVWGT; }
 645   int         GetMAXPR         () const     { return fHwevnt->MAXPR; }
 646   void        SetMAXPR    (int i)           { fHwevnt->MAXPR = i; }
 647   int         GetMAXER         () const     { return fHwevnt->MAXER; }
 648   void        SetMAXER    (int i)           { fHwevnt->MAXER = i; }
 649   int         GetNRN      (int i) const     { return fHwevnt->NRN[i-1]; }
 650   void        SetNRN    (int i, int j)      { fHwevnt->NRN[i-1] = j; }
 651
 652   // /HWHARD/
 653   Hwhard_t*   GetHwhard        ()           { return fHwhard; }
 654   double      GetPTMIN         () const     { return fHwhard->PTMIN; }
 655   void        SetPTMIN    (double d)        { fHwhard->PTMIN = d; }
 656   double      GetPTPOW         () const     { return fHwhard->PTPOW; }
 657   void        SetPTPOW    (double d)        { fHwhard->PTPOW = d; }
 658   double      GetYJMIN         () const     { return fHwhard->YJMIN; }
 659   void        SetYJMIN    (double d)        { fHwhard->YJMIN = d; }
 660   double      GetYJMAX         () const     { return fHwhard->YJMAX; }
 661   void        SetYJMAX    (double d)        { fHwhard->YJMAX = d; }
 662   double      GetQ2MIN         () const     { return fHwhard->Q2MIN; }
 663   void        SetQ2MIN    (double d)        { fHwhard->Q2MIN = d; }
 664   double      GetQ2MAX         () const     { return fHwhard->Q2MAX; }
 665   void        SetQ2MAX    (double d)        { fHwhard->Q2MAX = d; }
 666   double      GetYBMIN         () const     { return fHwhard->YBMIN; }
 667   void        SetYBMIN    (double d)        { fHwhard->YBMIN = d; }
 668   double      GetYBMAX         () const     { return fHwhard->YBMAX; }
 669   void        SetYBMAX    (double d)        { fHwhard->YBMAX = d; }
 670   double      GetZJMAX        ()  const     { return fHwhard->ZJMAX; }
 671   void        SetZJMAX    (double d)        { fHwhard->ZJMAX = d; }
 672
 673   // /HWPROP/
 674   Hwprop_t*   GetHwprop        ()           { return fHwprop; }
 675   double      GetRMASS      (int i) const   { return fHwprop->RMASS[i]; }
 676   void        SetRMASS    (int i, double r) { fHwprop->RMASS[i] = r; }
 677
 678   // /HWUNAM/
 679   Hwunam_t*   GetHwunam        ()           { return fHwunam; }
 680
 681   // /HWUPDT/
 682   Hwupdt_t*   GetHwupdt        ()           { return fHwupdt; }
 683
 684   // /HWUWTS/
 685   Hwuwts_t*   GetHwuwts        ()           { return fHwuwts; }
 686
 687   // /HWUCLU/
 688   Hwuclu_t*   GetHwuclu        ()           { return fHwuclu; }
 689
 690   // /HWDIST/
 691   Hwdist_t*   GetHwdist        ()           { return fHwdist; }
 692
 693   // /HWQDKT/
 694   Hwqdks_t*   GetHwqdkt        ()           { return fHwqdks; }
 695
 696   // /HWUSUD/
 697   Hwusud_t*   GetHwusud        ()           { return fHwusud; }
 698
 699   // /HWSUSY/
 700   Hwsusy_t*   GetHwsusy        ()           { return fHwsusy; }
 701
 702   // /HWRPAR/
 703   Hwrpar_t*   GetHwrpar        ()           { return fHwrpar; }
 704
 705   // /HWMINB/
 706   Hwminb_t*   GetHwminb        ()           { return fHwminb; }
 707
 708   // /HWCLUS/
 709   Hwclus_t*   GetHwclus        ()           { return fHwclus; }
 710
 711   // Herwig6 routines
 712   // the user would call
 713   //   Initialize
 714   //   change by himself the parameters s/he wants
 715   //   Hwusta to make stable the particles s/he wants
 716   //   PrepareRun
 717   //   GenerateEvent as many times as wished
 718   // An example is given in SetupTest
 719
 720   void             GenerateEvent();
 721   void             Initialize(const char *beam, const char *target, double pbeam1, double pbeam2, int iproc);
 722   void             PrepareRun();
 723   void             OpenFortranFile(int lun, char* name);
 724   void             CloseFortranFile(int lun);
 725   Int_t            ImportParticles(TClonesArray *particles, Option_t *option="");
 726   TObjArray       *ImportParticles(Option_t *option="");
 727   TObjArray       *Particles() { return fParticles; }
 728   void             Hwigin();
 729   void             Hwuinc();
 730   void             Hwusta(char * name);
 731   void             Hweini();
 732   void             Hwuine();
 733   void             Hwepro();
 734   void             Hwbgen();
 735   void             Hwdhob();
 736   void             Hwcfor();
 737   void             Hwcdec();
 738   void             Hwdhad();
 739   void             Hwdhvy();
 740   void             Hwmevt();
 741   void             Hwufne();
 742   void             Hwefin();
 743   void             SetupTest();
 744 protected:
 745
 746   Hepevt_t* fHepevt; // Standard hep common block
 747   // Herwig6 common-blocks
 748   Hwbeam_t* fHwbeam; // Beams, process and number of events
 749   Hwbmch_t* fHwbmch; // Beams, process and number of events
 750   Hwproc_t* fHwproc; // Beams, process and number of events
 751   Hwpram_t* fHwpram; // Basic parameters (and quantities derived from them)
 752   Hwprch_t* fHwprch; // Basic parameters (and quantities derived from them)
 753   Hwpart_t* fHwpart; // Parton shower common
 754   Hwparp_t* fHwparp; // Parton polarization common
 755   Hwbosc_t* fHwbosc; // Electroweak boson common
 756   Hwparc_t* fHwparc; // Parton colour common
 757   Hwbrch_t* fHwbrch; // Branching common
 758   Hwevnt_t* fHwevnt; // Event common
 759   Hwhard_t* fHwhard; // Hard subprocess common
 760   Hwprop_t* fHwprop; // Particle properties
 761   Hwunam_t* fHwunam; // Particle properties
 762   Hwupdt_t* fHwupdt; // Particle decays
 763   Hwuwts_t* fHwuwts; // Weights used in cluster decays
 764   Hwuclu_t* fHwuclu; // Parameters for cluster decays
 765   Hwdist_t* fHwdist; // Variables controling mixing and vertex information
 766   Hwqdks_t* fHwqdks; // Arrays for temporarily storing heavy-b,c-hadrons decaying partonicaly
 767   Hwusud_t* fHwusud; // Parameters for Sudakov form factors
 768   Hwsusy_t* fHwsusy; // SUSY parameters
 769   Hwrpar_t* fHwrpar; // R-Parity violating parameters and colours
 770   Hwminb_t* fHwminb; // Parameters for minimum bias/soft underlying event
 771   Hwclus_t* fHwclus; // Cluster common used by soft event routines
 772
 773   ClassDef(THerwig6,0)  //Interface to Herwig6.1 Event Generator
 774 };
 775
 776 #endif