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