New TPC parameters
[u/mrichter/AliRoot.git] / 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