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