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';}