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
  61 typedef enum
  62 {
  63    kHwCharm         =  1704,
  64    kHwBeauty        =  1705,
  65    kHwCharmMCATNLO  = -1704,
  66    kHwBeautyMCATNLO = -1705
  67 } Process_t;
  68
  69 class TObjArray;
  70
  71 // Translation of Fortran commons from the Herwig6
  72 // f77 program into c++ structures to be used in ROOT
  73 // and declaration of Fortran functions as extern
  74 // C functions to be called from the class Herwig6
  75 // author: j. g. contreras jgcn@moni.mda.cinvestav.mx
  76 // date: december 22, 2000
  77
  78 typedef struct {double dr,di;} dcpx;
  79
  80 int const NMXHEP = 4000;
  81
  82 typedef struct {
  83   int NEVHEP;
  84   int NHEP;
  85   int ISTHEP[NMXHEP];
  86   int IDHEP[NMXHEP];
  87   int JMOHEP[NMXHEP][2];
  88   int JDAHEP[NMXHEP][2];
  89   double PHEP[NMXHEP][5];
  90   double VHEP[NMXHEP][4];
  91 } Hepevt_t;
  92
  93 typedef struct {
  94   int IPART1;
  95   int IPART2;
  96 } Hwbeam_t;
  97
  98 typedef struct {
  99   char PART1[8];
 100   char PART2[8];
 101 } Hwbmch_t;
 102
 103 typedef struct {
 104   double EBEAM1;
 105   double EBEAM2;
 106   double PBEAM1;
 107   double PBEAM2;
 108   int    IPROC;
 109   int    MAXEV;
 110 } Hwproc_t;
 111
 112 typedef struct {
 113   double AFCH[2][16];
 114   double ALPHEM;
 115   double B1LIM;
 116   double BETAF;
 117   double BTCLM;
 118   double CAFAC;
 119   double CFFAC;
 120   double CLMAX;
 121   double CLPOW;
 122   double CLSMR[2];
 123   double CSPEED;
 124   double ENSOF;
 125   double ETAMIX;
 126   double F0MIX;
 127   double F1MIX;
 128   double F2MIX;
 129   double GAMH;
 130   double GAMW;
 131   double GAMZ;
 132   double GAMZP;
 133   double GEV2NB;
 134   double H1MIX;
 135   double PDIQK;
 136   double PGSMX;
 137   double PGSPL[4];
 138   double PHIMIX;
 139   double PIFAC;
 140   double PRSOF;
 141   double PSPLT[2];
 142   double PTRMS;
 143   double PXRMS;
 144   double QCDL3;
 145   double QCDL5;
 146   double QCDLAM;
 147   double QDIQK;
 148   double QFCH[16];
 149   double QG;
 150   double QSPAC;
 151   double QV;
 152   double SCABI;
 153   double SWEIN;
 154   double TMTOP;
 155   double VFCH[2][16];
 156   double VCKM[3][3];
 157   double VGCUT;
 158   double VQCUT;
 159   double VPCUT;
 160   double ZBINM;
 161   double EFFMIN;
 162   double OMHMIX;
 163   double ET2MIX;
 164   double PH3MIX;
 165   double GCUTME;
 166   int    IOPREM;
 167   int    IPRINT;
 168   int    ISPAC;
 169   int    LRSUD;
 170   int    LWSUD;
 171   int    MODPDF[2];
 172   int    NBTRY;
 173   int    NCOLO;
 174   int    NCTRY;
 175   int    NDTRY;
 176   int    NETRY;
 177   int    NFLAV;
 178   int    NGSPL;
 179   int    NSTRU;
 180   int    NSTRY;
 181   int    NZBIN;
 182   int    IOP4JT[2];
 183   int    NPRFMT;
 184   int AZSOFT;
 185   int AZSPIN;
 186   int CLDIR[2];
 187   int HARDME;
 188   int NOSPAC;
 189   int PRNDEC;
 190   int PRVTX;
 191   int SOFTME;
 192   int ZPRIME;
 193   int PRNDEF;
 194   int PRNTEX;
 195   int PRNWEB;
 196 } Hwpram_t;
 197
 198 typedef struct {
 199   char AUTPDF[2][20];
 200   char BDECAY[4];
 201 } Hwprch_t;
 202
 203 int const NMXPAR = 500;
 204
 205 typedef struct {
 206   int  NEVPAR;
 207   int  NPAR;
 208   int  ISTPAR[NMXPAR];
 209   int  IDPAR[NMXPAR];
 210   int  JMOPAR[NMXPAR][2];
 211   int  JDAPAR[NMXPAR][2];
 212   double  PPAR[NMXPAR][5];
 213   double  VPAR[NMXPAR][4];
 214 } Hwpart_t;
 215
 216 typedef struct {
 217   double DECPAR[NMXPAR][2];
 218   double PHIPAR[NMXPAR][2];
 219   double RHOPAR[NMXPAR][2];
 220   int TMPAR[NMXPAR];
 221 } Hwparp_t;
 222
 223 int const MODMAX = 50;
 224
 225 typedef struct {
 226   double  ALPFAC;
 227   double  BRHIG[12];
 228   double  ENHANC[12];
 229   double  GAMMAX;
 230   double  RHOHEP[NMXHEP][3];
 231   int     IOPHIG;
 232   int     MODBOS[MODMAX];
 233 } Hwbosc_t;
 234
 235 typedef struct {
 236   int     JCOPAR[NMXPAR][4];
 237 } Hwparc_t;
 238
 239 typedef struct {
 240   double ANOMSC[2][2];
 241   double HARDST;
 242   double PTINT[2][3];
 243   double XFACT;
 244   int    INHAD;
 245   int    JNHAD;
 246   int    NSPAC[7];
 247   int    ISLENT;
 248   int    BREIT;
 249   int    FROST;
 250   int    USECMF;
 251 } Hwbrch_t;
 252
 253 typedef struct {
 254   double AVWGT;
 255   double EVWGT;
 256   double GAMWT;
 257   double TLOUT;
 258   double WBIGST;
 259   double WGTMAX;
 260   double WGTSUM;
 261   double WSQSUM;
 262   int    IDHW[NMXHEP];
 263   int    IERROR;
 264   int    ISTAT;
 265   int    LWEVT;
 266   int    MAXER;
 267   int    MAXPR;
 268   int    NOWGT;
 269   int    NRN[2];
 270   int    NUMER;
 271   int    NUMERU;
 272   int    NWGTS;
 273   int    GENSOF;
 274   int    EV1PR;
 275   int    EV2PR;
 276 } Hwevnt_t;
 277
 278 typedef struct {
 279   double ASFIXD;
 280   double CLQ[6][7];
 281   double COSS;
 282   double COSTH;
 283   double CTMAX;
 284   double DISF[2][13];
 285   double EMLST;
 286   double EMMAX;
 287   double EMMIN;
 288   double EMPOW;
 289   double EMSCA;
 290   double EPOLN[3];
 291   double GCOEF[7];
 292   double GPOLN;
 293   double OMEGA0;
 294   double PHOMAS;
 295   double PPOLN[3];
 296   double PTMAX;
 297   double PTMIN;
 298   double PTPOW;
 299   double Q2MAX;
 300   double Q2MIN;
 301   double Q2POW;
 302   double Q2WWMN;
 303   double Q2WWMX;
 304   double QLIM;
 305   double SINS;
 306   double THMAX;
 307   double Y4JT;
 308   double TMNISR;
 309   double TQWT;
 310   double XX[2];
 311   double XLMIN;
 312   double XXMIN;
 313   double YBMAX;
 314   double YBMIN;
 315   double YJMAX;
 316   double YJMIN;
 317   double YWWMAX;
 318   double YWWMIN;
 319   double WHMIN;
 320   double ZJMAX;
 321   double ZMXISR;
 322   int    IAPHIG;
 323   int    IBRN[2];
 324   int    IBSH;
 325   int    ICO[10];
 326   int    IDCMF;
 327   int    IDN[10];
 328   int    IFLMAX;
 329   int    IFLMIN;
 330   int    IHPRO;
 331   int    IPRO;
 332   int    MAPQ[10];
 333   int    MAXFL;
 334   int    BGSHAT;
 335   int    COLISR;
 336   int    FSTEVT;
 337   int    FSTWGT;
 338   int    GENEV;
 339   int    HVFCEN;
 340   int    TPOL;
 341   int     DURHAM;
 342 } Hwhard_t;
 343
 344 int const NMXRES = 500;
 345
 346 typedef struct {
 347   double RLTIM[NMXRES+1];
 348   double RMASS[NMXRES+1];
 349   double RSPIN[NMXRES+1];
 350   int    ICHRG[NMXRES+1];
 351   int    IDPDG[NMXRES+1];
 352   int    IFLAV[NMXRES+1];
 353   int    NRES;
 354   int    VTOCDK[NMXRES+1];
 355   int    VTORDK[NMXRES+1];
 356   int    QORQQB[NMXRES+1];
 357   int    QBORQQ[NMXRES+1];
 358 } Hwprop_t;
 359
 360 typedef struct {
 361   char RNAME[NMXRES+1][8];
 362   char TXNAME[NMXRES+1][2][37];
 363 } Hwunam_t;
 364
 365 int const NMXDKS = 4000;
 366 int const NMXMOD = 200;
 367
 368 typedef struct {
 369   double BRFRAC[NMXDKS];
 370   double CMMOM[NMXDKS];
 371   double DKLTM[NMXRES];
 372   int    IDK[NMXDKS];
 373   int    IDKPRD[NMXDKS][5];
 374   int    LNEXT[NMXDKS];
 375   int    LSTRT[NMXRES];
 376   int    NDKYS;
 377   int    NME[NMXDKS];
 378   int    NMODES[NMXRES];
 379   int    NPRODS[NMXDKS];
 380   int    DKPSET;
 381   int    RSTAB[NMXRES+1];
 382 } Hwupdt_t;
 383
 384 typedef struct {
 385   double REPWT[5][4][4];
 386   double SNGWT;
 387   double DECWT;
 388   double QWT[3];
 389   double PWT[12];
 390   double SWTEF[NMXRES];
 391 } Hwuwts_t;
 392
 393 int const NMXCDK = 4000;
 394
 395 typedef struct {
 396   double CLDKWT[NMXCDK];
 397   double CTHRPW[12][12];
 398   double PRECO;
 399   double RESN[12][12];
 400   double RMIN[12][12];
 401   int    LOCN[12][12];
 402   int    NCLDK[NMXCDK];
 403   int    NRECO;
 404   int    CLRECO;
 405 } Hwuclu_t;
 406
 407 typedef struct {
 408   double EXAG;
 409   double GEV2MM;
 410   double HBAR;
 411   double PLTCUT;
 412   double VMIN2;
 413   double VTXPIP[5];
 414   double XMIX[2];
 415   double XMRCT[2];
 416   double YMIX[2];
 417   double YMRCT[2];
 418   int    IOPDKL;
 419   int    MAXDKL;
 420   int    MIXING;
 421   int    PIPSMR;
 422 } Hwdist_t;
 423
 424 int const NMXQDK=20;
 425
 426 typedef struct {
 427   double VTXQDK[NMXQDK][4];
 428   int    IMQDK[NMXQDK];
 429   int    LOCQ[NMXQDK];
 430   int    NQDK;
 431 } Hwqdks_t;
 432
 433 int const NMXSUD = 1024;
 434
 435 typedef struct {
 436   double ACCUR;
 437   double QEV[6][NMXSUD];
 438   double SUD[6][NMXSUD];
 439   int    INTER;
 440   int    NQEV;
 441   int    NSUD;
 442   int    SUDORD;
 443 } Hwusud_t;
 444
 445 typedef struct {
 446   double TANB;
 447   double ALPHAH;
 448   double COSBPA;
 449   double SINBPA;
 450   double COSBMA;
 451   double SINBMA;
 452   double COSA;
 453   double SINA;
 454   double COSB;
 455   double SINB;
 456   double COTB;
 457   double ZMIXSS[4][4];
 458   double ZMXNSS[4][4];
 459   double ZSGNSS[4];
 460   double LFCH[16];
 461   double RFCH[16];
 462   double SLFCH[4][16];
 463   double SRFCH[4][16];
 464   double WMXUSS[2][2];
 465   double WMXVSS[2][2];
 466   double WSGNSS[2];
 467   double QMIXSS[2][2][6];
 468   double LMIXSS[2][2][6];
 469   double THETAT;
 470   double THETAB;
 471   double THETAL;
 472   double ATSS;
 473   double ABSS;
 474   double ALSS;
 475   double MUSS;
 476   double FACTSS;
 477   double GHWWSS[3];
 478   double GHZZSS[3];
 479   double GHDDSS[4];
 480   double GHUUSS[4];
 481   double GHWHSS[3];
 482   double GHSQSS[2][2][6][4];
 483   double XLMNSS;
 484   double RMMNSS;
 485   double DMSSM;
 486   double SENHNC[24];
 487   double SSPARITY;
 488   int    SUSYIN;
 489 } Hwsusy_t;
 490
 491 typedef struct {
 492   double LAMDA1[3][3][3];
 493   double LAMDA2[3][3][3];
 494   double LAMDA3[3][3][3];
 495   int    HRDCOL[5][2];
 496   int    RPARTY;
 497   int    COLUPD;
 498 } Hwrpar_t;
 499
 500 typedef struct {
 501   double PMBN1;
 502   double PMBN2;
 503   double PMBN3;
 504   double PMBK1;
 505   double PMBK2;
 506   double PMBM1;
 507   double PMBM2;
 508   double PMBP1;
 509   double PMBP2;
 510   double PMBP3;
 511 } Hwminb_t;
 512
 513 int const NMXCL = 500;
 514
 515 typedef struct {
 516   double PPCL[NMXCL][5];
 517   int    IDCL[NMXCL];
 518   int    NCL;
 519 } Hwclus_t;
 520
 521 // herwig 6.507
 522
 523 typedef struct {
 524   double GRVLAM;
 525   double EMGRV;
 526   double GAMGRV;
 527 } Hwgrav_t;
 528
 529 typedef struct {
 530   double VIPWID[3];
 531   double DXRCYL;
 532   double DXZMAX;
 533   double DXRSPH;
 534   int      WZRFR;
 535   int      FIX4JT;
 536   int      IMSSM;
 537   int      IHIGGS;
 538   int      PARITY;
 539   int      LRSUSY;
 540 } Hw6202_t;
 541
 542 typedef struct {
 543   double ABWGT;
 544   double ABWSUM;
 545   double AVABW;
 546   int      NNEGWT;
 547   int      NNEGEV;
 548   int      NEGWTS;
 549 } Hw6203_t;
 550
 551 int const IMAXCH = 20;
 552
 553 typedef struct {
 554   double MJJMIN;
 555   double CHNPRB[IMAXCH];
 556   int      IOPSTP;
 557   int      IOPSH;
 558   int      OPTM;
 559   int      CHON[IMAXCH];
 560 } Hw6300_t;
 561
 562
 563 int const NXMRS = 49;
 564 int const NQMRS = 37;
 565 int const NPMRS = 8;
 566
 567 typedef struct {
 568   double FMRS[NQMRS+1][NXMRS][NPMRS][3];
 569 } Hwpmrs_t;
 570
 571 typedef struct {
 572   int      CIRCOP;
 573   int      CIRCAC;
 574   int      CIRCVR;
 575   int      CIRCRV;
 576   int      CIRCCH;
 577 } Hwcirc_t;
 578
 579 int const NCFMAX = 3;
 580 int const NMODE2 = 500;
 581 int const NMODE3 = 500;
 582 int const NDIAGR = 8;
 583 int const NMODEB = 50;
 584 int const NMODE4 = 4;
 585
 586 typedef struct {
 587   double ABMODE[NMODEB][2];
 588   double BBMODE[NMODEB][12][2];
 589   double PBMODE[NMODEB][12];
 590   double WTBMAX[NMODEB][12];
 591   int      IDBPRT[NMODEB];
 592   int      IBDRTP[NMODEB];
 593   int      IBMODE[NMODEB];
 594   int      NBMODE;
 595 } Hwdspb_t;
 596
 597 typedef struct {
 598   double A2MODE[NMODE2][2];
 599   double P2MODE[NMODE2];
 600   double WT2MAX[NMODE2];
 601   int      ID2PRT[NMODE2];
 602   int      I2DRTP[NMODE2];
 603   int      N2MODE;
 604 } Hwdsp2_t;
 605
 606 typedef struct {
 607   double A3MODE[NMODE3][NDIAGR][2];
 608   double B3MODE[NMODE3][NDIAGR][2];
 609   double P3MODE[NMODE3];
 610   double WT3MAX[NMODE3];
 611   double SPN3CF[NMODE3][NCFMAX][NCFMAX];
 612   int      ID3PRT[NMODE3];
 613   int      I3MODE[NMODE3][NDIAGR];
 614   int      I3DRTP[NMODE3][NDIAGR];
 615   int      N3MODE;
 616   int      NDI3BY[NMODE3];
 617   int      N3NCFL[NMODE3];
 618   int      I3DRCF[NMODE3][NDIAGR];
 619 } Hwdsp3_t;
 620
 621 typedef struct {
 622   double A4MODE[NMODE4][12][2];
 623   double B4MODE[NMODE4][12][2];
 624   double P4MODE[NMODE4][12][12];
 625   double WT4MAX[NMODE4][12][12];
 626   int      ID4PRT[NMODE4];
 627   int      I4MODE[NMODE4][2];
 628   int      N4MODE;
 629 } Hwdsp4_t;
 630
 631 typedef struct {
 632   int      NDECSY;
 633   int      NSEARCH;
 634   int      LRDEC;
 635   int      LWDEC;
 636   int      SYSPIN;
 637   int      THREEB;
 638   int      FOURB;
 639   char   TAUDEC[6];
 640 } Hwdspn_t;
 641
 642 int const NMXSPN = 50;
 643
 644 typedef struct {
 645   dcpx   MESPN[NMXSPN][NCFMAX][2][2][2][2];
 646   dcpx   RHOSPN[NMXSPN][2][2];
 647   double SPNCFC[NMXSPN][NCFMAX][NCFMAX];
 648   int      IDSPN[NMXSPN];
 649   int      JMOSPN[NMXSPN];
 650   int      JDASPN[NMXSPN][2];
 651   int      NSPN;
 652   int      ISNHEP[NMXHEP];
 653   int      NSNTRY;
 654   int      DECSPN[NMXSPN];
 655   int      NCFL[NMXSPN];
 656   int      SPCOPT;
 657 } Hwspin_t;
 658
 659 typedef struct {
 660   int      JAK1;
 661   int      JAK2;
 662   int      ITDKRC;
 663   int      IFPHOT;
 664 } Hwstau_t;
 665
 666 int const MAXHRP = 100;
 667
 668 typedef struct {
 669   double LHWGT[MAXHRP];
 670   double LHWGTS[MAXHRP];
 671   double LHXSCT[MAXHRP];
 672   double LHXERR[MAXHRP];
 673   double LHXMAX[MAXHRP];
 674   double LHMXSM;
 675   int      LHIWGT[MAXHRP];
 676   int      LHNEVT[MAXHRP];
 677   int      ITYPLH;
 678   int      LHSOFT;
 679   int      LHGLSF;
 680 } Hwgupr_t;
 681
 682 typedef struct {
 683   int    PRESPL;
 684 } Hw6500_t;
 685
 686 typedef struct {
 687   int    ITOPRD;
 688 } Hw6504_t;
 689
 690 typedef struct {
 691   double PDFX0;
 692   double PDFPOW;
 693 } Hw6506_t;
 694
 695
 696
 697
 698 extern "C" {
 699   void  hwigin_();
 700   void  hwuinc_();
 701   void  hwusta_(char * name, int);
 702   void  hweini_();
 703   void  hwuine_();
 704   void  hwepro_();
 705   void  hwbgen_();
 706   void  hwdhob_();
 707   void  hwcfor_();
 708   void  hwcdec_();
 709   void  hwdhad_();
 710   void  hwdhvy_();
 711   void  hwmevt_();
 712   void  hwufne_();
 713   void  hwefin_();
 714   void  hwiodk_(int);
 715 }
 716
 717
 718
 719
 720
 721
 722 /* THerwig6 class declaration */
 723 class THerwig6 : public TGenerator {
 724 //----------------------------------------------------------------------------
 725 //  functions:
 726 //----------------------------------------------------------------------------
 727 public:
 728                                 // ****** constructors and destructor
 729   THerwig6();
 730   THerwig6(const THerwig6 & source): TGenerator(source) {
 731     Fatal("THerwig6","Copy constructor not implemented yet");
 732   }
 733   THerwig6 & operator=(const THerwig6 & /*source*/) {
 734     Fatal("THerwig6","Assignment operator not implemented yet");
 735     return *this;
 736   }
 737   virtual ~THerwig6();
 738
 739   // acces to hep common block
 740   Hepevt_t*   GetHepevt        () const     { return fHepevt; }
 741   int         GetNEVHEP        () const     { return fHepevt->NEVHEP; }
 742   int         GetNhep          () const     { return fHepevt->NHEP; }
 743   int         GetISTHEP    (int i)const     { return fHepevt->ISTHEP[i-1]; }
 744   int         GetIDHEP     (int i)const     { return fHepevt->IDHEP[i-1]; }
 745   int         GetJMOHEP (int i, int j) const
 746     { return fHepevt->JMOHEP[i-1][j-1]; }
 747   int         GetJDAHEP (int i, int j) const
 748     { return fHepevt->JDAHEP[i-1][j-1]; }
 749   double      GetPHEP   (int i, int j) const
 750     { return fHepevt->PHEP[i-1][j-1]; }
 751   double      GetVHEP   (int i, int j) const
 752     { return fHepevt->VHEP[i-1][j-1]; }
 753
 754   // access to Herwig6 common-blocks
 755   // WARNING: Some arrays start in 1, others in 0. Look up the manual!
 756
 757   // /HWBEAM/
 758
 759   Hwbeam_t*   GetHwbeam        ()           { return fHwbeam; }
 760   int         GetIPART1        () const     { return fHwbeam->IPART1; }
 761   int         GetIPART2        () const     { return fHwbeam->IPART2; }
 762
 763   // /HWBMCH/
 764   Hwbmch_t*   GetHwbmch        ()           { return fHwbmch; }
 765   char*       GetPART1         () const     { return fHwbmch->PART1; }
 766   char*       GetPART2         () const     { return fHwbmch->PART2; }
 767
 768
 769   // /HWPROC/
 770   Hwproc_t*   GetHwproc        ()           { return fHwproc; }
 771   double      GetEBEAM1        () const     { return fHwproc->EBEAM1; }
 772   double      GetEBEAM2        () const     { return fHwproc->EBEAM2; }
 773   double      GetPBEAM1        () const     { return fHwproc->PBEAM1; }
 774   double      GetPBEAM2        () const     { return fHwproc->PBEAM2; }
 775   int         GetIPROC         () const     { return fHwproc->IPROC; }
 776   int         GetMAXEV         () const     { return fHwproc->MAXEV; }
 777
 778   // /HWPRAM/
 779   Hwpram_t*   GetHwpram        ()           { return fHwpram; }
 780   double      GetQCDLAM        () const     { return fHwpram->QCDLAM; }
 781   void        SetQCDLAM   (double q)        { fHwpram->QCDLAM = q; }
 782   double      GetVQCUT         () const     { return fHwpram->VQCUT; }
 783   void        SetVQCUT    (double v)        { fHwpram->VQCUT = v; }
 784   double      GetVGCUT         () const     { return fHwpram->VGCUT; }
 785   void        SetVGCUT    (double v)        { fHwpram->VGCUT = v; }
 786   double      GetVPCUT         () const     { return fHwpram->VPCUT; }
 787   void        SetVPCUT    (double v)        { fHwpram->VPCUT = v; }
 788   double      GetCLMAX         () const     { return fHwpram->CLMAX; }
 789   void        SetCLMAX    (double c)        { fHwpram->CLMAX = c; }
 790   double      GetCLPOW         () const     { return fHwpram->CLPOW; }
 791   void        SetCLPOW    (double c)        { fHwpram->CLPOW = c; }
 792   double      GetPSPLT    (int i) const     { return fHwpram->PSPLT[i-1];}
 793   void        SetPSPLT    (int i, double p) { fHwpram->PSPLT[i-1] = p;}
 794   double      GetQDIQK         () const     { return fHwpram->QDIQK; }
 795   void        SetQDIQK    (double q)        { fHwpram->QDIQK = q; }
 796   double      GetPDIQK         () const     { return fHwpram->PDIQK; }
 797   void        SetPDIQK    (double p)        { fHwpram->PDIQK = p; }
 798   double      GetQSPAC         () const     { return fHwpram->QSPAC; }
 799   void        SetQSPAC    (double q)        { fHwpram->QSPAC = q; }
 800   double      GetPTRMS         () const     { return fHwpram->PTRMS; }
 801   void        SetPTRMS    (double p)        { fHwpram->PTRMS = p; }
 802   double      GetENSOF         () const     { return fHwpram->ENSOF; }
 803   void        SetENSOF    (double e)        { fHwpram->ENSOF = e; }
 804   int         GetIPRINT        () const     { return fHwpram->IPRINT; }
 805   void        SetIPRINT   (int i)           { fHwpram->IPRINT = i; }
 806   int         GetMODPDF   (int i) const     { return fHwpram->MODPDF[i-1];}
 807   void        SetMODPDF   (int i, int j)  { fHwpram->MODPDF[i-1] = j; }
 808   int         GetNSTRU         () const     { return fHwpram->NSTRU; }
 809   void        SetNSTRU    (int i)          { fHwpram->NSTRU = i; }
 810
 811   // /HWPRCH/
 812   Hwprch_t*   GetHwprch        ()           { return fHwprch; }
 813   char*       GetAUTPDF     (int i)         { return fHwprch->AUTPDF[i-1]; }
 814   void        SetAUTPDF(int i,const char* s){ strncpy(fHwprch->AUTPDF[i-1],s,20);}
 815   char*       GetBDECAY        ()           { return fHwprch->BDECAY; }
 816
 817   // /HWPART/
 818   Hwpart_t*   GetHwpart        ()           { return fHwpart; }
 819
 820   // /HWPARP/
 821   Hwparp_t*   GetHwparp        ()           { return fHwparp; }
 822
 823   // /HWBOSC/
 824   Hwbosc_t*   GetHwbosc        ()           { return fHwbosc; }
 825
 826   // /HWPARC/
 827   Hwparc_t*   GetHwparc        ()           { return fHwparc; }
 828
 829   // /HWBRCH/
 830   Hwbrch_t*   GetHwbrch        ()           { return fHwbrch; }
 831
 832   // /HWEVNT/
 833   Hwevnt_t*   GetHwevnt        ()           { return fHwevnt; }
 834   double      GetAVWGT         () const     { return fHwevnt->AVWGT; }
 835   int         GetMAXPR         () const     { return fHwevnt->MAXPR; }
 836   void        SetMAXPR    (int i)           { fHwevnt->MAXPR = i; }
 837
 838   void        SetEV1PR    (int i)           { fHwevnt->EV1PR = i; }
 839   void        SetEV2PR    (int i)           { fHwevnt->EV2PR = i; }
 840
 841   int         GetMAXER         () const     { return fHwevnt->MAXER; }
 842   void        SetMAXER    (int i)           { fHwevnt->MAXER = i; }
 843   int         GetNRN      (int i) const     { return fHwevnt->NRN[i-1]; }
 844   void        SetNRN    (int i, int j)      { fHwevnt->NRN[i-1] = j; }
 845   double      GetEVWGT         () const     { return fHwevnt->EVWGT; }
 846
 847   int         GetIDHW     (int i) const     { return fHwevnt->IDHW[i]; }
 848
 849   int         GetIERROR        () const     { return fHwevnt->IERROR; }
 850
 851   // /HWHARD/
 852   Hwhard_t*   GetHwhard        ()           { return fHwhard; }
 853   double      GetPTMIN         () const     { return fHwhard->PTMIN; }
 854   void        SetPTMIN    (double d)        { fHwhard->PTMIN = d; }
 855   double      GetPTPOW         () const     { return fHwhard->PTPOW; }
 856   void        SetPTPOW    (double d)        { fHwhard->PTPOW = d; }
 857   double      GetYJMIN         () const     { return fHwhard->YJMIN; }
 858   void        SetYJMIN    (double d)        { fHwhard->YJMIN = d; }
 859   double      GetYJMAX         () const     { return fHwhard->YJMAX; }
 860   void        SetYJMAX    (double d)        { fHwhard->YJMAX = d; }
 861   double      GetQ2MIN         () const     { return fHwhard->Q2MIN; }
 862   void        SetQ2MIN    (double d)        { fHwhard->Q2MIN = d; }
 863   double      GetQ2MAX         () const     { return fHwhard->Q2MAX; }
 864   void        SetQ2MAX    (double d)        { fHwhard->Q2MAX = d; }
 865   double      GetYBMIN         () const     { return fHwhard->YBMIN; }
 866   void        SetYBMIN    (double d)        { fHwhard->YBMIN = d; }
 867   double      GetYBMAX         () const     { return fHwhard->YBMAX; }
 868   void        SetYBMAX    (double d)        { fHwhard->YBMAX = d; }
 869   double      GetZJMAX        ()  const     { return fHwhard->ZJMAX; }
 870   void        SetZJMAX    (double d)        { fHwhard->ZJMAX = d; }
 871
 872   // /HWPROP/
 873   Hwprop_t*   GetHwprop        ()           { return fHwprop; }
 874   double      GetRMASS      (int i) const   { return fHwprop->RMASS[i]; }
 875   void        SetRMASS    (int i, double r) { fHwprop->RMASS[i] = r; }
 876
 877   // /HWUNAM/
 878   Hwunam_t*   GetHwunam        ()           { return fHwunam; }
 879
 880   void        GetRNAME (int i, char a[9])   { for (int j=0;j<8;j++) a[j] = fHwunam->RNAME[i][j]; a[8] = '\0';}
 881 /*  char*       GetRNAME(int i) { return fHwunam->RNAME[i]; }*/
 882
 883   // /HWUPDT/
 884   Hwupdt_t*   GetHwupdt        ()           { return fHwupdt; }
 885
 886   // /HWUWTS/
 887   Hwuwts_t*   GetHwuwts        ()           { return fHwuwts; }
 888
 889   // /HWUCLU/
 890   Hwuclu_t*   GetHwuclu        ()           { return fHwuclu; }
 891
 892   // /HWDIST/
 893   Hwdist_t*   GetHwdist        ()           { return fHwdist; }
 894
 895   // /HWQDKT/
 896   Hwqdks_t*   GetHwqdkt        ()           { return fHwqdks; }
 897
 898   // /HWUSUD/
 899   Hwusud_t*   GetHwusud        ()           { return fHwusud; }
 900
 901   // /HWSUSY/
 902   Hwsusy_t*   GetHwsusy        ()           { return fHwsusy; }
 903
 904   // /HWRPAR/
 905   Hwrpar_t*   GetHwrpar        ()           { return fHwrpar; }
 906
 907   // /HWMINB/
 908   Hwminb_t*   GetHwminb        ()           { return fHwminb; }
 909
 910   // /HWCLUS/
 911   Hwclus_t*   GetHwclus        ()           { return fHwclus; }
 912
 913   // Herwig6 routines
 914   // the user would call
 915   //   Initialize
 916   //   change by himself the parameters s/he wants
 917   //   Hwusta to make stable the particles s/he wants
 918   //   PrepareRun
 919   //   GenerateEvent as many times as wished
 920   // An example is given in SetupTest
 921
 922   void             GenerateEvent();
 923   void             Initialize(const char *beam, const char *target, double pbeam1, double pbeam2, int iproc);
 924   void             PrepareRun();
 925   void             OpenFortranFile(int lun, char* name);
 926   void             CloseFortranFile(int lun);
 927   Int_t            ImportParticles(TClonesArray *particles, Option_t *option="");
 928   TObjArray       *ImportParticles(Option_t *option="");
 929   TObjArray       *Particles() { return fParticles; }
 930   void             Hwigin();
 931   void             Hwuinc();
 932   void             Hwusta(char * name);
 933   void             Hweini();
 934   void             Hwuine();
 935   void             Hwepro();
 936   void             Hwbgen();
 937   void             Hwdhob();
 938   void             Hwcfor();
 939   void             Hwcdec();
 940   void             Hwdhad();
 941   void             Hwdhvy();
 942   void             Hwmevt();
 943   void             Hwufne();
 944   void             Hwefin();
 945   void             Hwiodk(int iopt);
 946   void             SetupTest();
 947 protected:
 948
 949   Hepevt_t* fHepevt; // Standard hep common block
 950   // Herwig6 common-blocks
 951   Hwbeam_t* fHwbeam; // Beams, process and number of events
 952   Hwbmch_t* fHwbmch; // Beams, process and number of events
 953   Hwproc_t* fHwproc; // Beams, process and number of events
 954   Hwpram_t* fHwpram; // Basic parameters (and quantities derived from them)
 955   Hwprch_t* fHwprch; // Basic parameters (and quantities derived from them)
 956   Hwpart_t* fHwpart; // Parton shower common
 957   Hwparp_t* fHwparp; // Parton polarization common
 958   Hwbosc_t* fHwbosc; // Electroweak boson common
 959   Hwparc_t* fHwparc; // Parton colour common
 960   Hwbrch_t* fHwbrch; // Branching common
 961   Hwevnt_t* fHwevnt; // Event common
 962   Hwhard_t* fHwhard; // Hard subprocess common
 963   Hwprop_t* fHwprop; // Particle properties
 964   Hwunam_t* fHwunam; // Particle properties
 965   Hwupdt_t* fHwupdt; // Particle decays
 966   Hwuwts_t* fHwuwts; // Weights used in cluster decays
 967   Hwuclu_t* fHwuclu; // Parameters for cluster decays
 968   Hwdist_t* fHwdist; // Variables controling mixing and vertex information
 969   Hwqdks_t* fHwqdks; // Arrays for temporarily storing heavy-b,c-hadrons decaying partonicaly
 970   Hwusud_t* fHwusud; // Parameters for Sudakov form factors
 971   Hwsusy_t* fHwsusy; // SUSY parameters
 972   Hwrpar_t* fHwrpar; // R-Parity violating parameters and colours
 973   Hwminb_t* fHwminb; // Parameters for minimum bias/soft underlying event
 974   Hwclus_t* fHwclus; // Cluster common used by soft event routines
 975   Hwgrav_t* fHwgrav;
 976   Hw6202_t* fHw6202;
 977   Hw6203_t* fHw6203;
 978   Hw6300_t* fHw6300;
 979   Hwpmrs_t* fHwpmrs;
 980   Hwcirc_t* fHwcirc;
 981   Hwdspb_t* fHwdspb;
 982   Hwdsp2_t* fHwdsp2;
 983   Hwdsp3_t* fHwdsp3;
 984   Hwdsp4_t* fHwdsp4;
 985   Hwdspn_t* fHwdspn;
 986   Hwspin_t* fHwspin;
 987   Hwstau_t* fHwstau;
 988   Hwgupr_t* fHwgupr;
 989   Hw6500_t* fHw6500;
 990   Hw6504_t* fHw6504;
 991   Hw6506_t* fHw6506;
 992
 993   ClassDef(THerwig6,0)  //Interface to Herwig6.1 Event Generator
 994 };
 995
 996 #endif