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