Flushing the buffer for debug purposes (R. Preghenella)
[u/mrichter/AliRoot.git] / THerwig / THerwig6.cxx
1 // definition of c++ Class THerwig6 to be used in ROOT
2 // this is a c++ interface to the F77 Herwig6 program
3 // author: j. g. contreras jgcn@moni.mda.cinvestav.mx
4 // date: december 22, 2000
5 //  Class THerwig6 is an interface to the Herwig program
6 //
7 // C-----------------------------------------------------------------------
8 // C                           H E R W I G
9 // C
10 // C            a Monte Carlo event generator for simulating
11 // C        +---------------------------------------------------+
12 // C        | Hadron Emission Reactions With Interfering Gluons |
13 // C        +---------------------------------------------------+
14 // C I.G. Knowles(*), G. Marchesini(+), M.H. Seymour($) and B.R. Webber(#)
15 // C-----------------------------------------------------------------------
16 // C with Minimal Supersymmetric Standard Model Matrix Elements by
17 // C                  S. Moretti($) and K. Odagiri($)
18 // C-----------------------------------------------------------------------
19 // C R parity violating Supersymmetric Decays and Matrix Elements by
20 // C                          P. Richardson(&)
21 // C-----------------------------------------------------------------------
22 // C matrix element corrections to top decay and Drell-Yan type processes
23 // C                         by G. Corcella(+)
24 // C-----------------------------------------------------------------------
25 // C Deep Inelastic Scattering and Heavy Flavour Electroproduction by
26 // C                  G. Abbiendi(@) and L. Stanco(%)
27 // C-----------------------------------------------------------------------
28 // C and Jet Photoproduction in Lepton-Hadron Collisions by J. Chyla(~)
29 // C-----------------------------------------------------------------------
30 // C(*)  Department of Physics & Astronomy, University of Edinburgh
31 // C(+)  Dipartimento di Fisica, Universita di Milano
32 // C($)  Rutherford Appleton Laboratory
33 // C(#)  Cavendish Laboratory, Cambridge
34 // C(&)  Department of Physics, University of Oxford
35 // C(@)  Dipartimento di Fisica, Universita di Bologna
36 // C(%)  Dipartimento di Fisica, Universita di Padova
37 // C(~)  Institute of Physics, Prague
38 // C-----------------------------------------------------------------------
39 // C                  Version 6.100 - 16th December 1999
40 // C-----------------------------------------------------------------------
41 // C Main reference:
42 // C    G.Marchesini,  B.R.Webber,  G.Abbiendi,  I.G.Knowles,  M.H.Seymour,
43 // C    and L.Stanco, Computer Physics Communications 67 (1992) 465.
44 // C-----------------------------------------------------------------------
45 // C Please send e-mail about  this program  to one of the  authors at the
46 // C following Internet addresses:
47 // C    I.Knowles@ed.ac.uk        Giuseppe.Marchesini@mi.infn.it
48 // C    M.Seymour@rl.ac.uk        webber@hep.phy.cam.ac.uk
49 // C-----------------------------------------------------------------------
50
51
52 #include "THerwig6.h"
53 #include "HCommon.h"
54 #include "TClonesArray.h"
55 #include "TParticle.h"
56 #include "TObjArray.h"
57 #include "Riostream.h"
58
59
60 using std::cout;
61 using std::endl;
62
63 ClassImp(THerwig6)
64
65 extern "C" {
66   void   herwig6_open_fortran_file_ (int* lun, char* name, int);
67   void   herwig6_close_fortran_file_(int* lun);
68 }
69
70 THerwig6 *THerwig6::fgInstance = 0;
71
72 THerwig6::THerwig6() : TGenerator("Herwig6","Herwig6")
73 {
74
75 // THerwig6 constructor: creates a TClonesArray in which it will store all
76 // particles. Note that there may be only one functional THerwig6 object
77 // at a time, so it's not use to create more than one instance of it.
78
79   delete fParticles; // was allocated as TObjArray in TGenerator
80   fParticles = new TClonesArray("TParticle",50);
81
82   // initialize common-blocks
83   
84   if (fgInstance) 
85     cout << "WARNING: creating second instance of THerwig6" << endl;
86   fgInstance = this;
87  }
88
89 THerwig6::THerwig6(const THerwig6 & source): TGenerator(source)
90 {
91     Fatal("THerwig6","Copy constructor not implemented yet");
92 }
93 //------------------------------------------------------------------------------
94  THerwig6::~THerwig6()
95  {
96    // Destructor. The data members of TGenerator are delete by itself
97    fgInstance = 0;
98  }
99
100 //------------------------------------------------------------------------------
101 THerwig6 *THerwig6::Instance()
102  {
103    return fgInstance ? fgInstance : new THerwig6;
104  }
105 //______________________________________________________________________________
106 void THerwig6::GenerateEvent()
107 {
108
109   //initialize event
110   hwuine_();
111   // generate hard subprocess
112   hwepro_();
113   // generate parton cascades
114   hwbgen_();
115   // do heavy objects decay
116   hwdhob_();
117   // do cluster formation
118   hwcfor_();
119   // do cluster decays
120   hwcdec_();
121   // do unstable particle decays
122   hwdhad_();
123   // do heavy flavor hadrons decay
124   hwdhvy_();
125   // add soft underlying event
126   hwmevt_();
127   // finish event
128   hwufne_();
129 }
130 //______________________________________________________________________________
131 void THerwig6::OpenFortranFile(int lun, char* name) {
132   herwig6_open_fortran_file_(&lun, name, strlen(name));
133 }
134
135 //______________________________________________________________________________
136 void THerwig6::CloseFortranFile(int lun) {
137   herwig6_close_fortran_file_(&lun);
138 }
139
140 void THerwig6::Initialize(const char *beam, const char *target, double pbeam1, double pbeam2, int iproc)
141
142 {
143   // perform the initialization for Herwig6
144   // sets correct title.
145   // after calling this method all parameters are set to their default
146   // values. If you want to modify any parameter you have to set the new
147   // value after calling Initialize and before PrepareRun.
148
149    char  cbeam[9];
150     strncpy(cbeam,beam, 8);
151    char  ctarget[9];
152    strncpy(ctarget,target, 8);
153    printf("\n Initializing Herwig !! \n");
154    if ( (!strncmp(beam, "E+"    ,2)) &&
155         (!strncmp(beam, "E-"    ,2)) &&
156         (!strncmp(beam, "MU+"   ,3)) &&
157         (!strncmp(beam, "MU-"   ,3)) &&
158         (!strncmp(beam, "NUE"   ,3)) &&
159         (!strncmp(beam, "NUEB"  ,4)) &&
160         (!strncmp(beam, "NUMU"  ,4)) &&
161         (!strncmp(beam, "NMUB"  ,4)) &&
162         (!strncmp(beam, "NTAU"  ,4)) &&
163         (!strncmp(beam, "NTAB"  ,4)) &&
164         (!strncmp(beam, "GAMA"  ,4)) &&
165         (!strncmp(beam, "P       ",8)) &&
166         (!strncmp(beam, "PBAR    ",8)) &&
167         (!strncmp(beam, "N"     ,1)) &&
168         (!strncmp(beam, "NBAR"  ,4)) &&
169         (!strncmp(beam, "PI+"   ,3)) &&
170         (!strncmp(beam, "PI-"   ,3)) ) {
171       printf("WARNING! In THerwig6:Initialize():\n");
172       printf(" specified beam=%s is unrecognized .\n",beam);
173       printf(" resetting to \"P\" .");
174       snprintf(cbeam, 8, "P");
175    }
176
177    if ( (!strncmp(target, "E+"    ,2)) &&
178         (!strncmp(target, "E-"    ,2)) &&
179         (!strncmp(target, "MU+"   ,3)) &&
180         (!strncmp(target, "MU-"   ,3)) &&
181         (!strncmp(target, "NUE"   ,3)) &&
182         (!strncmp(target, "NUEB"  ,4)) &&
183         (!strncmp(target, "NUMU"  ,4)) &&
184         (!strncmp(target, "NMUB"  ,4)) &&
185         (!strncmp(target, "NTAU"  ,4)) &&
186         (!strncmp(target, "NTAB"  ,4)) &&
187         (!strncmp(target, "GAMA"  ,4)) &&
188         (!strncmp(target, "P       ",8)) &&
189         (!strncmp(target, "PBAR    ",8)) &&
190         (!strncmp(target, "N"     ,1)) &&
191         (!strncmp(target, "NBAR"  ,4)) &&
192         (!strncmp(target, "PI+"   ,3)) &&
193         (!strncmp(target, "PI-"   ,3)) ) {
194       printf("WARNING! In THerwig6:Initialize():\n");
195       printf(" specified target=%s is unrecognized .\n",target);
196       printf(" resetting to \"P\" .");
197       snprintf(ctarget,8, "P");
198    }
199
200    // initialization:
201    // type of beams
202    memcpy(HWBMCH.PART1,beam, 8);
203    memcpy(HWBMCH.PART2,target, 8);
204    // momentum of beams
205    HWPROC.PBEAM1=pbeam1;
206    HWPROC.PBEAM2=pbeam2;
207    // process to generate
208    HWPROC.IPROC=iproc;
209    // not used in the class definition
210    HWPROC.MAXEV=1;
211    
212    // reset all parameters
213    hwigin_();
214
215    // set correct title
216    //char atitle[132];
217    double win=pbeam1+pbeam2;
218    printf("\n %s - %s at %g GeV \n",beam,target,win);
219    //sprintf(atitle,"%s-%s at %g GeV",cbeam,ctarget,win);
220    //SetTitle(atitle);
221 }
222
223 void THerwig6::InitializeJimmy(const char *beam, const char *target, double pbeam1, double pbeam2, int iproc)
224
225 {
226   // perform the initialization for Herwig6
227   // sets correct title.
228   // after calling this method all parameters are set to their default
229   // values. If you want to modify any parameter you have to set the new
230   // value after calling Initialize and before PrepareRun.
231
232    char  cbeam[9];
233    strncpy(cbeam,beam,8);
234    char  ctarget[9];
235    strncpy(ctarget,target,8);
236    printf("\n Initializing Herwig !! \n");
237    if ( (!strncmp(beam, "E+"    ,2)) &&
238         (!strncmp(beam, "E-"    ,2)) &&
239         (!strncmp(beam, "MU+"   ,3)) &&
240         (!strncmp(beam, "MU-"   ,3)) &&
241         (!strncmp(beam, "NUE"   ,3)) &&
242         (!strncmp(beam, "NUEB"  ,4)) &&
243         (!strncmp(beam, "NUMU"  ,4)) &&
244         (!strncmp(beam, "NMUB"  ,4)) &&
245         (!strncmp(beam, "NTAU"  ,4)) &&
246         (!strncmp(beam, "NTAB"  ,4)) &&
247         (!strncmp(beam, "GAMA"  ,4)) &&
248         (!strncmp(beam, "P       ",8)) &&
249         (!strncmp(beam, "PBAR    ",8)) &&
250         (!strncmp(beam, "N"     ,1)) &&
251         (!strncmp(beam, "NBAR"  ,4)) &&
252         (!strncmp(beam, "PI+"   ,3)) &&
253         (!strncmp(beam, "PI-"   ,3)) ) {
254       printf("WARNING! In THerwig6:Initialize():\n");
255       printf(" specified beam=%s is unrecognized .\n",beam);
256       printf(" resetting to \"P\" .");
257       snprintf(cbeam, 8, "P");
258    }
259
260    if ( (!strncmp(target, "E+"    ,2)) &&
261         (!strncmp(target, "E-"    ,2)) &&
262         (!strncmp(target, "MU+"   ,3)) &&
263         (!strncmp(target, "MU-"   ,3)) &&
264         (!strncmp(target, "NUE"   ,3)) &&
265         (!strncmp(target, "NUEB"  ,4)) &&
266         (!strncmp(target, "NUMU"  ,4)) &&
267         (!strncmp(target, "NMUB"  ,4)) &&
268         (!strncmp(target, "NTAU"  ,4)) &&
269         (!strncmp(target, "NTAB"  ,4)) &&
270         (!strncmp(target, "GAMA"  ,4)) &&
271         (!strncmp(target, "P       ",8)) &&
272         (!strncmp(target, "PBAR    ",8)) &&
273         (!strncmp(target, "N"     ,1)) &&
274         (!strncmp(target, "NBAR"  ,4)) &&
275         (!strncmp(target, "PI+"   ,3)) &&
276         (!strncmp(target, "PI-"   ,3)) ) {
277       printf("WARNING! In THerwig6:Initialize():\n");
278       printf(" specified target=%s is unrecognized .\n",target);
279       printf(" resetting to \"P\" .");
280       snprintf(ctarget, 8, "P");
281    }
282
283    // initialization:
284    // type of beams
285    memcpy(HWBMCH.PART1,beam,8);
286    memcpy(HWBMCH.PART2,target,8);
287    // momentum of beams
288    HWPROC.PBEAM1=pbeam1;
289    HWPROC.PBEAM2=pbeam2;
290    // process to generate
291    HWPROC.IPROC=iproc;
292    // not used in the class definition
293    HWPROC.MAXEV=1;
294
295    // reset all parameters
296    hwigin_();
297    // JIMMY initialization
298    jimmin_();
299
300    // set correct title
301 //   char atitle[132];
302    double win=pbeam1+pbeam2;
303    printf("\n %s - %s at %g GeV",beam,target,win);
304 //   sprintf(atitle,"%s-%s at %g GeV",cbeam,ctarget,win);
305 //   SetTitle(atitle);
306 }
307
308 void THerwig6::PrepareRun()
309 {
310   // compute parameter dependent constants
311   hwuinc_();
312   // initialize elementary processes
313   hweini_();
314 }
315
316 void THerwig6::PrepareRunJimmy()
317 {
318   // compute parameter dependent constants
319   hwuinc_();
320   // initialize elementary processes
321   hweini_();
322   // more initializations for JIMMY
323   jminit_();
324 }
325 //______________________________________________________________________________
326 TObjArray* THerwig6::ImportParticles(Option_t *option)
327 {
328 //
329 //  Default primary creation method. It reads the /HEPEVT/ common block which
330 //  has been filled by the GenerateEvent method. If the event generator does
331 //  not use the HEPEVT common block, This routine has to be overloaded by
332 //  the subclasses.
333 //  The default action is to store only the stable particles (ISTHEP = 1)
334 //  This can be demanded explicitly by setting the option = "Final"
335 //  If the option = "All", all the particles are stored.
336 //
337   fParticles->Clear();
338   Int_t numpart = HEPEVT.NHEP;
339   TClonesArray &a = *((TClonesArray*)fParticles);
340   if (!strcmp(option,"") || !strcmp(option,"Final")) {
341     for (Int_t i = 0; i < numpart; i++) {
342       if (HEPEVT.ISTHEP[i] == 1) {
343 //
344 //  Use the common block values for the TParticle constructor
345 //
346         new(a[i]) TParticle(
347                                    HEPEVT.IDHEP[i],
348                                    HEPEVT.ISTHEP[i],
349                                    HEPEVT.JMOHEP[i][0]-1,
350                                    HEPEVT.JMOHEP[i][1]-1,
351                                    HEPEVT.JDAHEP[i][0]-1,
352                                    HEPEVT.JDAHEP[i][1]-1,
353
354                                    HEPEVT.PHEP[i][0],
355                                    HEPEVT.PHEP[i][1],
356                                    HEPEVT.PHEP[i][2],
357                                    HEPEVT.PHEP[i][3],
358                                    HEPEVT.VHEP[i][0],
359                                    HEPEVT.VHEP[i][1],
360                                    HEPEVT.VHEP[i][2],
361                                    HEPEVT.VHEP[i][3]);
362         }
363      }
364   }
365   else if (!strcmp(option,"All")) {
366     for (Int_t i = 0; i < numpart; i++) {
367       new(a[i]) TParticle(
368                                    HEPEVT.IDHEP[i],
369                                    HEPEVT.ISTHEP[i],
370                                    HEPEVT.JMOHEP[i][0]-1,
371                                    HEPEVT.JMOHEP[i][1]-1,
372                                    HEPEVT.JDAHEP[i][0]-1,
373                                    HEPEVT.JDAHEP[i][1]-1,
374
375                                    HEPEVT.PHEP[i][0],
376                                    HEPEVT.PHEP[i][1],
377                                    HEPEVT.PHEP[i][2],
378                                    HEPEVT.PHEP[i][3],
379                                    HEPEVT.VHEP[i][0],
380                                    HEPEVT.VHEP[i][1],
381                                    HEPEVT.VHEP[i][2],
382                                    HEPEVT.VHEP[i][3]);
383     }
384   }
385   return fParticles;
386 }
387
388 //______________________________________________________________________________
389 Int_t THerwig6::ImportParticles(TClonesArray *particles, Option_t *option)
390 {
391 //
392 //  Default primary creation method. It reads the /HEPEVT/ common block which
393 //  has been filled by the GenerateEvent method. If the event generator does
394 //  not use the HEPEVT common block, This routine has to be overloaded by
395 //  the subclasses.
396 //  The function loops on the generated particles and store them in
397 //  the TClonesArray pointed by the argument particles.
398 //  The default action is to store only the stable particles (ISTHEP = 1)
399 //  This can be demanded explicitly by setting the option = "Final"
400 //  If the option = "All", all the particles are stored.
401 //
402   if (particles == 0) return 0;
403   TClonesArray &refParticles = *particles;
404   refParticles.Clear();
405   Int_t numpart = HEPEVT.NHEP;
406   if (!strcmp(option,"") || !strcmp(option,"Final")) {
407     for (Int_t i = 0; i < numpart; i++) {
408       if (HEPEVT.ISTHEP[i] == 1) {
409 //
410 //  Use the common block values for the TParticle constructor
411 //
412         new(refParticles[i]) TParticle(
413                                    HEPEVT.IDHEP[i],
414                                    HEPEVT.ISTHEP[i],
415                                    HEPEVT.JMOHEP[i][0]-1,
416                                    HEPEVT.JMOHEP[i][1]-1,
417                                    HEPEVT.JDAHEP[i][0]-1,
418                                    HEPEVT.JDAHEP[i][1]-1,
419
420                                    HEPEVT.PHEP[i][0],
421                                    HEPEVT.PHEP[i][1],
422                                    HEPEVT.PHEP[i][2],
423                                    HEPEVT.PHEP[i][3],
424                                    HEPEVT.VHEP[i][0],
425                                    HEPEVT.VHEP[i][1],
426                                    HEPEVT.VHEP[i][2],
427                                    HEPEVT.VHEP[i][3]);
428         }
429      }
430   }
431   else if (!strcmp(option,"All")) {
432     for (Int_t i = 0; i< numpart; i++) {
433       new(refParticles[i]) TParticle(
434                                    HEPEVT.IDHEP[i],
435                                    HEPEVT.ISTHEP[i],
436                                    HEPEVT.JMOHEP[i][0]-1,
437                                    HEPEVT.JMOHEP[i][1]-1,
438                                    HEPEVT.JDAHEP[i][0]-1,
439                                    HEPEVT.JDAHEP[i][1]-1,
440
441                                    HEPEVT.PHEP[i][0],
442                                    HEPEVT.PHEP[i][1],
443                                    HEPEVT.PHEP[i][2],
444                                    HEPEVT.PHEP[i][3],
445                                    HEPEVT.VHEP[i][0],
446                                    HEPEVT.VHEP[i][1],
447                                    HEPEVT.VHEP[i][2],
448                                    HEPEVT.VHEP[i][3]); // 
449     }
450   }
451   return numpart;
452 }
453
454 void THerwig6::Hwigin()
455 {
456   hwigin_();
457 }
458
459 void THerwig6::Hwuinc()
460 {
461   hwuinc_();
462 }
463
464 void THerwig6::Hwusta(const char* name)
465
466 {
467   hwusta_(name,8);
468 }
469
470 void THerwig6::Hweini()
471
472 {
473   hweini_();
474 }
475
476 void THerwig6::Hwuine()
477
478 {
479   hwuine_();
480 }
481
482 void THerwig6::Hwepro()
483
484 {
485   hwepro_();
486 }
487
488 void THerwig6::Hwbgen()
489
490 {
491   hwbgen_();
492 }
493
494 void THerwig6::Hwdhob()
495
496 {
497   hwdhob_();
498 }
499
500 void THerwig6::Hwcfor()
501
502 {
503   hwcfor_();
504 }
505
506 void THerwig6::Hwcdec()
507
508 {
509   hwcdec_();
510 }
511
512 void THerwig6::Hwdhad()
513
514 {
515   hwdhad_();
516 }
517
518 void THerwig6::Hwdhvy()
519
520 {
521   hwdhvy_();
522 }
523
524 void THerwig6::Hwmevt()
525
526 {
527   hwmevt_();
528 }
529
530 void THerwig6::Hwufne()
531
532 {
533   hwufne_();
534 }
535
536 void THerwig6::Hwefin()
537
538 {
539   hwefin_();
540 }
541
542 void THerwig6::Hwiodk(int iopt)
543
544 {
545   hwiodk_(iopt);
546 }
547
548 void THerwig6::SetupTest()
549 {
550   // exampe of running herwig and generating one event
551   // after changing some options
552   Initialize("P","PBAR",900.,900.,1500);
553   // here you can set some parameters
554   SetPTMIN(15.); // Min pt in hadronic jet production
555   SetYJMIN(-4.); // Min jet rapidity
556   SetYJMAX(4.);  // Max jet rapidity
557   // after you set your wished parameters
558   // herwig can do its work
559   PrepareRun();
560   int nEvToGenerate=1;
561   for (int i=0;i<nEvToGenerate;i++)
562     {
563       GenerateEvent();
564       // do your stuff. For ex:
565       int nOfPar=GetNumberOfParticles(); // from TGenerator
566       for (int j=0; j<nOfPar; j++)
567         {
568           TParticle* p=GetParticle(j);
569           // here you do whatever you want with the particle
570           p->Print();
571         };
572     };
573 }
574
575 // Jimmy subroutines
576
577 void THerwig6::Jminit()
578 {
579   jminit_();
580 }
581
582 void THerwig6::Jimmin()
583 {
584   jimmin_();
585 }
586
587 void THerwig6::Jmefin()
588 {
589   jmefin_();
590 }
591
592 void THerwig6::PrintEvt()
593 {
594     hwuepr_();
595     
596 }
597
598   // acces to hep common block
599 int         THerwig6::GetNEVHEP        () const     { return HEPEVT.NEVHEP; }
600 int         THerwig6::GetNhep          () const     { return HEPEVT.NHEP; }
601 int         THerwig6::GetISTHEP    (int i)const     { return HEPEVT.ISTHEP[i-1]; }
602 int         THerwig6::GetIDHEP     (int i)const     { return HEPEVT.IDHEP[i-1]; }
603 int         THerwig6::GetJMOHEP (int i, int j) const
604 { return HEPEVT.JMOHEP[i-1][j-1]; }
605 int         THerwig6::GetJDAHEP (int i, int j) const
606 { return HEPEVT.JDAHEP[i-1][j-1]; }
607 double      THerwig6::GetPHEP   (int i, int j) const
608 { return HEPEVT.PHEP[i-1][j-1]; }
609 double      THerwig6::GetVHEP   (int i, int j) const
610 { return HEPEVT.VHEP[i-1][j-1]; }
611
612 // access to Herwig6 common-blocks
613 // WARNING: Some arrays start in 1, others in 0. Look up the manual!
614
615 // /HWBEAM/
616
617 int         THerwig6::GetIPART1        () const     { return HWBEAM.IPART1; }
618 int         THerwig6::GetIPART2        () const     { return HWBEAM.IPART2; }
619
620 // /HWBMCH/
621 char*       THerwig6::GetPART1         () const     { return HWBMCH.PART1; }
622 char*       THerwig6::GetPART2         () const     { return HWBMCH.PART2; }
623
624
625 // /HWPROC/
626 double      THerwig6::GetEBEAM1        () const     { return HWPROC.EBEAM1; }
627 double      THerwig6::GetEBEAM2        () const     { return HWPROC.EBEAM2; }
628 double      THerwig6::GetPBEAM1        () const     { return HWPROC.PBEAM1; }
629 double      THerwig6::GetPBEAM2        () const     { return HWPROC.PBEAM2; }
630 int         THerwig6::GetIPROC         () const     { return HWPROC.IPROC; }
631 int         THerwig6::GetMAXEV         () const     { return HWPROC.MAXEV; }
632
633 // /HWPRAM/
634 double      THerwig6::GetQCDLAM        ()           const     { return HWPRAM.QCDLAM; }
635 void        THerwig6::SetQCDLAM   (double q)        const     { HWPRAM.QCDLAM = q; }
636 double      THerwig6::GetVQCUT         ()           const     { return HWPRAM.VQCUT; }
637 void        THerwig6::SetVQCUT    (double v)        const     { HWPRAM.VQCUT = v; }
638 double      THerwig6::GetVGCUT         ()           const     { return HWPRAM.VGCUT; }
639 void        THerwig6::SetVGCUT    (double v)        const     { HWPRAM.VGCUT = v; }
640 double      THerwig6::GetVPCUT         ()           const     { return HWPRAM.VPCUT; }
641 void        THerwig6::SetVPCUT    (double v)        const     { HWPRAM.VPCUT = v; }
642 double      THerwig6::GetCLMAX         ()           const     { return HWPRAM.CLMAX; }
643 void        THerwig6::SetCLMAX    (double c)        const     { HWPRAM.CLMAX = c; }
644 double      THerwig6::GetCLPOW         ()           const     { return HWPRAM.CLPOW; }
645 void        THerwig6::SetCLPOW    (double c)        const     { HWPRAM.CLPOW = c; }
646 double      THerwig6::GetPSPLT    (int i)           const     { return HWPRAM.PSPLT[i-1];}
647 void        THerwig6::SetPSPLT    (int i, double p) const     { HWPRAM.PSPLT[i-1] = p;}
648 double      THerwig6::GetQDIQK         ()           const     { return HWPRAM.QDIQK; }
649 void        THerwig6::SetQDIQK    (double q)        const     { HWPRAM.QDIQK = q; }
650 double      THerwig6::GetPDIQK         ()           const     { return HWPRAM.PDIQK; }
651 void        THerwig6::SetPDIQK    (double p)        const     { HWPRAM.PDIQK = p; }
652 double      THerwig6::GetQSPAC         ()           const     { return HWPRAM.QSPAC; }
653 void        THerwig6::SetQSPAC    (double q)        const     { HWPRAM.QSPAC = q; }
654 double      THerwig6::GetPTRMS         ()           const     { return HWPRAM.PTRMS; }
655 void        THerwig6::SetPTRMS    (double p)        const     { HWPRAM.PTRMS = p; }
656 double      THerwig6::GetENSOF         ()           const     { return HWPRAM.ENSOF; }
657 void        THerwig6::SetENSOF    (double e)        const     { HWPRAM.ENSOF = e; }
658 int         THerwig6::GetIPRINT        ()           const     { return HWPRAM.IPRINT; }
659 void        THerwig6::SetIPRINT   (int i)           const     { HWPRAM.IPRINT = i; }
660 int         THerwig6::GetMODPDF   (int i)           const     { return HWPRAM.MODPDF[i-1];}
661 void        THerwig6::SetMODPDF   (int i, int j)    const     { HWPRAM.MODPDF[i-1] = j; }
662 int         THerwig6::GetNSTRU         ()           const     { return HWPRAM.NSTRU; }
663 void        THerwig6::SetNSTRU    (int i)           const     { HWPRAM.NSTRU = i; }
664
665 // /HWPRCH/
666 char*       THerwig6::GetAUTPDF     (int i)         const     { return HWPRCH.AUTPDF[i-1]; }
667 void        THerwig6::SetAUTPDF(int i,const char* s)const     { strncpy(HWPRCH.AUTPDF[i-1], s, 19);}
668 char*       THerwig6::GetBDECAY        ()           const     { return HWPRCH.BDECAY; }
669
670 // /HWEVNT/
671 double      THerwig6::GetAVWGT         ()           const     { return HWEVNT.AVWGT; }
672 int         THerwig6::GetMAXPR         ()           const     { return HWEVNT.MAXPR; }
673 void        THerwig6::SetMAXPR    (int i)           const     { HWEVNT.MAXPR = i; }
674 int         THerwig6::GetMAXER         ()           const     { return HWEVNT.MAXER; }
675 void        THerwig6::SetMAXER    (int i)           const     { HWEVNT.MAXER = i; }
676 int         THerwig6::GetNRN      (int i)           const     { return HWEVNT.NRN[i-1]; }
677 void        THerwig6::SetNRN    (int i, int j)      const     { HWEVNT.NRN[i-1] = j; }
678 double      THerwig6::GetEVWGT         ()           const     { return HWEVNT.EVWGT; }
679
680 int         THerwig6::GetIDHW     (int i)           const     { return HWEVNT.IDHW[i]; }
681
682 int         THerwig6::GetIERROR        ()           const     { return HWEVNT.IERROR; }
683
684 // /HWHARD/
685 double      THerwig6::GetPTMIN         ()           const     { return HWHARD.PTMIN; }
686 void        THerwig6::SetPTMIN    (double d)        const     { HWHARD.PTMIN = d; }
687 double      THerwig6::GetPTMAX         ()           const     { return HWHARD.PTMAX; }
688 void        THerwig6::SetPTMAX    (double d)        const     { HWHARD.PTMAX = d; }
689 double      THerwig6::GetPTPOW         ()           const     { return HWHARD.PTPOW; }
690 void        THerwig6::SetPTPOW    (double d)        const     { HWHARD.PTPOW = d; }
691 double      THerwig6::GetYJMIN         ()           const     { return HWHARD.YJMIN; }
692 void        THerwig6::SetYJMIN    (double d)        const     { HWHARD.YJMIN = d; }
693 double      THerwig6::GetYJMAX         ()           const     { return HWHARD.YJMAX; }
694 void        THerwig6::SetYJMAX    (double d)        const     { HWHARD.YJMAX = d; }
695 double      THerwig6::GetQ2MIN         ()           const     { return HWHARD.Q2MIN; }
696 void        THerwig6::SetQ2MIN    (double d)        const     { HWHARD.Q2MIN = d; }
697 double      THerwig6::GetQ2MAX         ()           const     { return HWHARD.Q2MAX; }
698 void        THerwig6::SetQ2MAX    (double d)        const     { HWHARD.Q2MAX = d; }
699 double      THerwig6::GetYBMIN         ()           const     { return HWHARD.YBMIN; }
700 void        THerwig6::SetYBMIN    (double d)        const     { HWHARD.YBMIN = d; }
701 double      THerwig6::GetYBMAX         ()           const     { return HWHARD.YBMAX; }
702 void        THerwig6::SetYBMAX    (double d)        const     { HWHARD.YBMAX = d; }
703 double      THerwig6::GetZJMAX        ()            const     { return HWHARD.ZJMAX; }
704 void        THerwig6::SetZJMAX    (double d)        const     { HWHARD.ZJMAX = d; }
705 int         THerwig6::GetIHPRO        ()            const     { return HWHARD.IHPRO; }
706 // /HWPROP/
707 double      THerwig6::GetRMASS      (int i)         const     { return HWPROP.RMASS[i]; }
708 void        THerwig6::SetRMASS    (int i, double r) const     { HWPROP.RMASS[i] = r; }
709
710
711 void        THerwig6::GetRNAME (int i, char a[9])   const     { for (int j=0;j<8;j++) a[j] = HWUNAM.RNAME[i][j]; a[8] = '\0';}