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