adding herwig translation from HepMC 1.24

HepMC/HepMC/CBhepevt.h

-// $Id: CBhepevt.h,v 1.2 2003/10/08 19:36:47 garren Exp $
+// $Id: CBhepevt.h,v 1.3 2003/10/10 15:56:34 garren Exp $
 // ----------------------------------------------------------------------
 // CBhepevt.h
 // ----------------------------------------------------------------------
@@ -65,9 +65,9 @@ public:
   bool       addtoHEPEVT( const GenEvent * );     // not yet implemented
   
   void       print( std::ostream & os = std::cout ) const;
-  void       print_hepevt( std::ostream & os = std::cout );
+  void       printHEPEVT( std::ostream & os = std::cout );
   void       print_legend( std::ostream & os = std::cout );
-  void       print_hepevt_particle( int index, std::ostream & os = std::cout );
+  void       printHEPEVTparticle( int index, std::ostream & os = std::cout );
   
   // decide how to deal with HEPEVT
   bool  trustMothers() const { return itsTrustMothers; }

HepMC/HepMC/CBhepevt.icc

-// $Id: CBhepevt.icc,v 1.2 2003/10/08 19:36:47 garren Exp $
+// $Id: CBhepevt.icc,v 1.3 2003/10/10 15:56:34 garren Exp $
 // ----------------------------------------------------------------------
 // CBhepevt.icc
 // ----------------------------------------------------------------------
@@ -77,7 +77,7 @@ void CBhepevt::print( std::ostream & os ) const
     os << "  trustMothersAndDaughters: " << itsTrustMothersAndDaughters << std::endl;
 }
 
-void CBhepevt::print_hepevt( std::ostream & os )
+void CBhepevt::printHEPEVT( std::ostream & os )
 {
     // dumps the content of this HEPEVT event to os  (Width is 80)
     os << "________________________________________"
@@ -91,7 +91,7 @@ void CBhepevt::print_hepevt( std::ostream & os )
     os << "________________________________________"
        << "________________________________________" << std::endl;
     for ( int i=1; i <= number_entries(); ++i ) {
-	print_hepevt_particle( i, os );
+	printHEPEVTparticle( i, os );
     }
     os << "________________________________________"
        << "________________________________________" << std::endl;
@@ -99,13 +99,18 @@ void CBhepevt::print_hepevt( std::ostream & os )
 
 void CBhepevt::print_legend( std::ostream & os )
 {
-    os << "Indx Stat Par- chil-   " 
-       << "(  P_x,      P_y,      P_z,   Energy   M ) [GeV]" << std::endl;
-    os << "    ID ents  dren      "
-       << "Prod (   X,    Y,    Z,    cT ) [mm]" << std::endl;
+    char outline[81];
+    sprintf( outline,"%4s %4s %4s %5s   %10s, %9s, %9s, %9s, %10s",
+	     "Indx","Stat","Par-","chil-",
+	     "(  P_x","P_y","P_z","Energy","M ) [GeV]");
+    os << outline << std::endl;
+    sprintf( outline,"%9s %4s %4s    %10s, %9s, %9s, %9s) %9s",
+	     "ID ","ents","dren",
+	     "Prod (   X","Y","Z","cT", "[mm]");
+    os << outline << std::endl;
 }	
 
-void CBhepevt::print_hepevt_particle( int i, std::ostream & os )
+void CBhepevt::printHEPEVTparticle( int i, std::ostream & os )
 {
     // dumps the content HEPEVT particle entry i   (Width is 120)
     // here i is the C array index (i.e. it starts at 0 ... whereas the
@@ -148,7 +153,7 @@ bool CBhepevt::check_hepevt_consistency( std::ostream & os )
 	    }
 	    os << "Inconsistent entry " << i 
 	       << " first parent > last parent " << std::endl;
-	    CBhepevt::print_hepevt_particle( i, os );
+	    CBhepevt::printHEPEVTparticle( i, os );
 	}
 	for ( int m = moth1; m<=moth2 && m!=0; ++m ) {
 	    if ( m>CBhepevt::number_entries() || m < 0 ) {
@@ -159,7 +164,7 @@ bool CBhepevt::check_hepevt_consistency( std::ostream & os )
 		}
 		os << "Inconsistent entry " << i 
 		   << " mother points out of range " << std::endl;
-		CBhepevt::print_hepevt_particle( i, os );
+		CBhepevt::printHEPEVTparticle( i, os );
 	    }
 	    int mChild1 = CBhepevt::first_child(m);
 	    int mChild2 = CBhepevt::last_child(m);
@@ -174,8 +179,8 @@ bool CBhepevt::check_hepevt_consistency( std::ostream & os )
 		os << "Inconsistent mother-daughter relationship between "
 		   << i << " & " << m 
 		   << " (try !trustMother)" << std::endl;
-		CBhepevt::print_hepevt_particle( i, os );
-		CBhepevt::print_hepevt_particle( m, os );
+		CBhepevt::printHEPEVTparticle( i, os );
+		CBhepevt::printHEPEVTparticle( m, os );
 	    }
 	}
 	// 2. check its daughters
@@ -189,7 +194,7 @@ bool CBhepevt::check_hepevt_consistency( std::ostream & os )
 	    }
 	    os << "Inconsistent entry " << i 
 	       << " first child > last child " << std::endl;
-	    CBhepevt::print_hepevt_particle( i, os );
+	    CBhepevt::printHEPEVTparticle( i, os );
 	}
 	for ( int d = dau1; d<=dau2 && d!=0; ++d ) {
 	    if ( d>CBhepevt::number_entries() || d < 0 ) {
@@ -200,7 +205,7 @@ bool CBhepevt::check_hepevt_consistency( std::ostream & os )
 		}
 		os << "Inconsistent entry " << i 
 		   << " child points out of range " << std::endl;
-		CBhepevt::print_hepevt_particle( i, os );
+		CBhepevt::printHEPEVTparticle( i, os );
 	    }
 	    int d_moth1 = CBhepevt::first_parent(d);
 	    int d_moth2 = CBhepevt::last_parent(d);
@@ -215,8 +220,8 @@ bool CBhepevt::check_hepevt_consistency( std::ostream & os )
 		os << "Inconsistent mother-daughter relationship between "
 		   << i << " & " << d 
 		   << " (try trustMothers)"<< std::endl;
-		CBhepevt::print_hepevt_particle( i, os );
-		CBhepevt::print_hepevt_particle( d, os );
+		CBhepevt::printHEPEVTparticle( i, os );
+		CBhepevt::printHEPEVTparticle( d, os );
 	    }
 	}
     }
@@ -240,7 +245,7 @@ bool CBhepevt::check_hepevt_consistency( std::ostream & os )
 	os << "To obtain a file summarizing the inconsistency, you should:"
 	   << "\n\t ofstream myFile(\"myInconsistentEvent.txt\"); "
 	   << "\n\t CBhepevt::check_hepevt_consistency(myFile); "
-	   << "\n\t CBhepevt::print_hepevt(myFile); "
+	   << "\n\t CBhepevt::printHEPEVT(myFile); "
 	   << "\n[now write the event to HepMC using something like"
 	   << "\n\t\t myIO_HEPEVT->write_event(myEvent); ]"
 	   << "\n\t myEvent->print( myFile ); "

HepMC/HepMC/CBherwig.h

+// $Id: CBherwig.h,v 1.1 2003/10/10 15:56:34 garren Exp $
+// ----------------------------------------------------------------------
+// CBherwig.h
+// ----------------------------------------------------------------------
+// Author:  Lynn Garren, Marc Paterno
+// 
+// This is part of the Fortran interface to the herwig common blocks
+// Do not attempt to use the common blocks directly.
+//
+// user code:
+//   CBherwig * hep = CBherwig::instance();
+//   hep->hepevt()->nhep;
+// ----------------------------------------------------------------------
+#ifndef CBHERWIG_H
+#define CBHERWIG_H
+//////////////////////////////////////////////////////////////////////////
+// Matt.Dobbs@Cern.CH, October 2002, refer to:
+// M. Dobbs and J.B. Hansen, "The HepMC C++ Monte Carlo Event Record for
+// High Energy Physics", Computer Physics Communications (to be published).
+//
+// IO class for reading the (non-standard) HEPEVT common block from 
+//  the Herwig monte carlo program.
+// Notes:
+//   - The HERWIG HEPEVT common block is non-standard, primarily because it 
+//     contains some color flow information. When you call CBherwig, the 
+//     HEPEVT common block is transformed to the standard. THIS CHANGES THE
+//     CONTENT of HEPEVT!.
+//   - The HERWIG HEPEVT common block has some EXTRA non-physical ENTRIES 
+//     (such as CMS frame, HARD subprocess, and CONE).
+//     These are removed by CBherwig. Thus the HepMC event will APPEAR
+//     to have fewer particles in it that herwig did.
+//     There is a switch itsNoBarcodeGaps. For
+//       true  - then the extra particles are removed from HEPEVT, with 
+//               the result that the HepMC barcodes will be sequential, with 
+//               no gaps.
+//       false - the barcodes will correspond directly to the HEPEVT index, but
+//               there will be gaps ... ie some barcodes will be unassigned.
+//       this switch requested by I Hinchliffe, October 31, 2002
+//   - some of the Herwig GLUON SPLITTING products are not properly documented
+//     in hepevt. I was unable to repair this in a simple and robust way. 
+//     Therefore some of the gluon splitting products will be orphans 
+//     in the HepMC output. 
+//////////////////////////////////////////////////////////////////////////
+
+#include "CLHEP/HepMC/GenEvent.h"
+#include "CLHEP/HepMC/HepMCConfig.h"
+
+#include "CLHEP/HepMC/include/stdhep.h"
+
+namespace HepMC {
+
+/**
+ * @author
+ * @ingroup hepmc
+ */
+class CBherwig {
+
+public:
+
+  CBherwig();
+
+  hepevt_t * hepevt() { return hptr; }
+  static int max_number_entries() { return NMXHEP; }
+  static int max_multiple_interactions() { return NMXMLT; }
+  int        event_number() { return hptr->nevhep; }
+  int        number_entries() { return hptr->nhep; }
+  int        first_parent( int index );  // index of 1st mother
+  int        last_parent( int index );   // index of last mother
+  int        first_child( int index );   // index of 1st daughter
+  int        last_child( int index );    // index of last daughter
+  int        number_children( int index );
+  int        number_parents( int index ); 
+
+  void       clean( );
+  void       zero_everything() { clean(); }
+  bool       check_hepevt_consistency( std::ostream & os = std::cout );
+  bool       toGenEvent( GenEvent *, bool printErrors );
+  bool       addtoHEPEVT( const GenEvent * );     // not yet implemented
+
+  bool       no_gaps_in_barcodes() const  { return itsNoBarcodeGaps; }
+  void       set_no_gaps_in_barcodes( bool a ) { itsNoBarcodeGaps=a; }
+  
+  void       print( std::ostream & os = std::cout ) const;
+  void       printHEPEVT( std::ostream & os = std::cout );
+  void       print_legend( std::ostream & os = std::cout );
+  void       printHEPEVTparticle( int index, std::ostream & os = std::cout );
+
+protected: // for internal use only
+  
+  // decide how to deal with HEPEVT
+  bool  trustMothers() const { return itsTrustMothers; }
+  bool  trustMothersAndDaughters() const { return itsTrustMothersAndDaughters; }
+  void  setTrustMothers( bool b ) { itsTrustMothers = b; }
+  void  setTrustMothersAndDaughters( bool b ) { itsTrustMothersAndDaughters = b; }
+  int   translate_herwig_to_pdg_id( int i, bool printInconsistencyErrors ) const;
+
+private:
+
+  hepevt_t * hptr;
+  bool       itsTrustMothers;
+  bool       itsTrustMothersAndDaughters;
+  bool       itsNoBarcodeGaps;
+  // we need to use HepPDT translation instead
+  std::vector<int>  m_herwig_to_pdg_id;
+  std::set<int>     m_no_antiparticles;
+
+  // internal functions
+  GenParticle* createParticle( int index );
+  void buildProductionVertex( int i, 
+                              std::vector<GenParticle*>& hepevt_particle, 
+  		              GenEvent* evt,
+			      bool printInconsistencyErrors );
+  void buildEndVertex( int i, std::vector<GenParticle*>& hepevt_particle, 
+                       GenEvent* evt,
+		       bool printInconsistencyErrors );
+  int  find( const std::map<GenParticle*,int>& m, GenParticle* p);
+
+  void  repair_hepevt( bool printInconsistencyErrors );
+  void  remove_gaps_in_hepevt();
+  void  zero_hepevt_entry( int i );
+
+};	// CBherwig
+
+}	// HepMC
+
+#include "CLHEP/HepMC/CBherwig.icc"
+
+#endif // CBHERWIG_H

HepMC/HepMC/ConvertHEPEVT.h

-// $Id: ConvertHEPEVT.h,v 1.1.1.1 2003/07/15 20:15:05 garren Exp $
+// $Id: ConvertHEPEVT.h,v 1.2 2003/10/10 15:56:34 garren Exp $
 // ----------------------------------------------------------------------
 //
 // ConvertHEPEVT.h
@@ -14,8 +14,8 @@
 //    bool tf = conv.fromGenEvent( evt );
 //
 // ----------------------------------------------------------------------
-#ifndef CONVERTHEPEVT_H
-#define CONVERTHEPEVT_H
+#ifndef CONVERT_HEPEVT_H
+#define CONVERT_HEPEVT_H
 
 #include "CLHEP/HepMC/GenEventConvert.h"
 #include "CLHEP/HepMC/CBhepevt.h"
@@ -27,4 +27,4 @@ typedef  CBInterface<CBhepevt>      FIhepevt;
 
 }
 
-#endif // CONVERTHEPEVT_H
+#endif // CONVERT_HEPEVT_H

HepMC/HepMC/ConvertHerwig.h

+// $Id: ConvertHerwig.h,v 1.1 2003/10/10 15:56:34 garren Exp $
+// ----------------------------------------------------------------------
+//
+// ConvertHerwig.h
+//
+//  defines methods to build GenEvent from Herwig
+//
+// User Code:
+//#include "CLHEP/HepMC/ConvertHerwig.h"
+//#include "CLHEP/HepMC/GenEvent.h"
+//  ...
+//    HepMC::ConvertHerwig conv;
+//    HepMC::GenEvent* evt = conv.getGenEventfromHEPEVT();
+//    bool tf = conv.fromGenEvent( evt );
+//
+// ----------------------------------------------------------------------
+#ifndef CONVERT_HERWIG_H
+#define CONVERT_HERWIG_H
+
+#include "CLHEP/HepMC/GenEventConvert.h"
+#include "CLHEP/HepMC/CBherwig.h"
+
+namespace HepMC {
+
+typedef  GenEventConvert<CBherwig>  ConvertHerwig;
+typedef  CBInterface<CBherwig>      FIherwig;
+
+}
+
+#endif // CONVERT_HERWIG_H

HepMC/HepMC/GenEventConvert.h

-// $Id: GenEventConvert.h,v 1.2 2003/10/08 19:36:47 garren Exp $
+// $Id: GenEventConvert.h,v 1.3 2003/10/10 15:56:34 garren Exp $
 // ----------------------------------------------------------------------
 //
 // GenEventConvert.h
@@ -41,11 +41,15 @@ public:
   bool       toGenEvent( GenEvent * );
   bool       fromGenEvent( const GenEvent * );
   bool       addtoHEPEVT( const GenEvent * );
-  bool       fill_next_event( GenEvent * evt ) { toGenEvent(evt); }
+  GenEvent * read_next_event() { return getGenEventfromHEPEVT(); }
+  bool       fill_next_event( GenEvent * evt ) { return toGenEvent(evt); }
 
   // decide how to deal with HEPEVT
   bool  printInconsistencyErrors() const { return itsInconsitencyErrors; }
   void  setInconsitencyErrors( bool b ) { itsInconsitencyErrors = b; }
+  
+  // print 
+  void  print_hepevt( std::ostream & os = std::cout );
 
 private:
 

HepMC/HepMC/GenEventConvert.icc

-// $Id: GenEventConvert.icc,v 1.2 2003/10/08 19:36:47 garren Exp $
+// $Id: GenEventConvert.icc,v 1.3 2003/10/10 15:56:34 garren Exp $
 // ----------------------------------------------------------------------
 //
 // GenEventConvert.icc
@@ -15,6 +15,14 @@
 
 namespace HepMC {
 
+template<class S>
+void  GenEventConvert< S >::print_hepevt( std::ostream & os  ) 
+{
+    CBInterface< S > * hep = CBInterface< S >::instance();
+    (*hep)->printHEPEVT( os );
+    return;
+}
+
 template<class S>
 GenEvent * GenEventConvert< S >::getGenEventfromHEPEVT()
 {

HepMC/HepMC/Makefile.am

@@ -7,8 +7,11 @@ SUBDIRS = include
 pkginclude_HEADERS = \
 	CBhepevt.h	\
 	CBhepevt.icc	\
+	CBherwig.h	\
+	CBherwig.icc	\
 	CBInterface.h	\
 	ConvertHEPEVT.h	\
+	ConvertHerwig.h	\
 	DummyDecayModel.h	\
 	Flow.h		\
 	GenEventConvert.h	\

HepMC/HepMC/include/HerwigWrapper.h

+//--------------------------------------------------------------------------
+
+//////////////////////////////////////////////////////////////////////////
+// Matt.Dobbs@Cern.CH, November 200July 2002
+// Just a link to whichever herwig version is current.
+//////////////////////////////////////////////////////////////////////////
+
+// This pre-compiler directive is included (2002-01-16) to allow compatibility
+// with MS Visual C++, which interfaces to fortran in a different manner.
+// For it to work you need to define the _WIN32 variable when compiling.
+#ifdef _WIN32 // Platform: Windows MS Visual C++
+
+//  Sorry, there is NO version currently available for Vusual C++.
+//  If you need it, please complain to Matt.Dobbs@cern.ch
+
+#else // Generic version, tested on Linux ecgs/gcc
+#include "CLHEP/HepMC/include/HerwigWrapper6_4.h"
+
+#endif // Platform
+
+//--------------------------------------------------------------------------

HepMC/HepMC/include/HerwigWrapper6_4.h

+//--------------------------------------------------------------------------
+#ifndef HERWIG_WRAPPER_H
+#define HERWIG_WRAPPER_H
+
+//////////////////////////////////////////////////////////////////////////
+// Matt.Dobbs@Cern.CH, April 2002
+// Wrapper for FORTRAN version of Herwig
+//////////////////////////////////////////////////////////////////////////
+// 
+
+#include <ctype.h>
+
+//--------------------------------------------------------------------------
+// HERWIG Common Block Declarations
+
+//        COMMON/HWPROC/EBEAM1,EBEAM2,PBEAM1,PBEAM2,IPROC,MAXEV
+    extern struct {
+	double EBEAM1,EBEAM2,PBEAM1,PBEAM2;
+        int IPROC,MAXEV;
+    } hwproc_;
+#define hwproc hwproc_
+
+//        CHARACTER*8 PART1,PART2
+//        COMMON/HWBMCH/PART1,PART2
+    extern struct {
+	char PART1[8],PART2[8];
+    } hwbmch_;
+#define hwbmch hwbmch_
+
+//  COMMON/HWEVNT/AVWGT,EVWGT,GAMWT,TLOUT,WBIGST,WGTMAX,WGTSUM,WSQSUM,
+//       & IDHW(NMXHEP),IERROR,ISTAT,LWEVT,MAXER,MAXPR,NOWGT,NRN(2),NUMER,
+//       & NUMERU,NWGTS,GENSOF
+const int herwig_hepevt_size = 4000;
+    extern struct {
+	double AVWGT,EVWGT,GAMWT,TLOUT,WBIGST,WGTMAX,WGTSUM,WSQSUM;
+	int IDHW[herwig_hepevt_size],IERROR,ISTAT,LWEVT,MAXER,MAXPR;
+	int NOWGT,NRN[2],NUMER,NUMERU,NWGTS;
+	int GENSOF; //Beware! in F77 this is logical
+    } hwevnt_;
+#define hwevnt hwevnt_
+
+//  C Basic parameters (and quantities derived from them)
+//        COMMON/HWPRAM/AFCH(16,2),ALPHEM,B1LIM,BETAF,BTCLM,CAFAC,CFFAC,
+//       & CLMAX,CLPOW,CLSMR(2),CSPEED,ENSOF,ETAMIX,F0MIX,F1MIX,F2MIX,GAMH,
+//       & GAMW,GAMZ,GAMZP,GEV2NB,H1MIX,PDIQK,PGSMX,PGSPL(4),PHIMIX,PIFAC,
+//       & PRSOF,PSPLT(2),PTRMS,PXRMS,QCDL3,QCDL5,QCDLAM,QDIQK,QFCH(16),QG,
+//       & QSPAC,QV,SCABI,SWEIN,TMTOP,VFCH(16,2),VCKM(3,3),VGCUT,VQCUT,
+//       & VPCUT,ZBINM,EFFMIN,OMHMIX,ET2MIX,PH3MIX,GCUTME,
+//       & IOPREM,IPRINT,ISPAC,LRSUD,LWSUD,MODPDF(2),NBTRY,NCOLO,NCTRY,
+//       & NDTRY,NETRY,NFLAV,NGSPL,NSTRU,NSTRY,NZBIN,IOP4JT(2),NPRFMT,
+//       & AZSOFT,AZSPIN,CLDIR(2),HARDME,NOSPAC,PRNDEC,PRVTX,SOFTME,ZPRIME,
+//       & PRNDEF,PRNTEX,PRNWEB
+
+    extern struct {
+	double AFCH[2][16],ALPHEM,B1LIM,BETAF,BTCLM,CAFAC,CFFAC,
+	    CLMAX,CLPOW,CLSMR[2],CSPEED,ENSOF,ETAMIX,F0MIX,F1MIX,F2MIX,GAMH,
+	    GAMW,GAMZ,GAMZP,GEV2NB,H1MIX,PDIQK,PGSMX,PGSPL[4],PHIMIX,PIFAC,
+	    PRSOF,PSPLT[2],PTRMS,PXRMS,QCDL3,QCDL5,QCDLAM,QDIQK,QFCH[16],QG,
+	    QSPAC,QV,SCABI,SWEIN,TMTOP,VFCH[2][16],VCKM[3][3],VGCUT,VQCUT,
+	    VPCUT,ZBINM,EFFMIN,OMHMIX,ET2MIX,PH3MIX,GCUTME;
+	int IOPREM,IPRINT,ISPAC,LRSUD,LWSUD,MODPDF[2],NBTRY,NCOLO,NCTRY,
+	    NDTRY,NETRY,NFLAV,NGSPL,NSTRU,NSTRY,NZBIN,IOP4JT[2],NPRFMT;
+	int AZSOFT,AZSPIN,CLDIR[2],HARDME,NOSPAC,PRNDEC,PRVTX,SOFTME,
+	    ZPRIME,PRNDEF,PRNTEX,PRNWEB; //Beware! in F77 these are logical
+    } hwpram_;
+#define hwpram hwpram_
+
+//--------------------------------------------------------------------------
+// HERWIG routines declaration
+
+#define hwigin hwigin_  // initialise other common blocks
+#define hwigup hwigup_  // initialise HepUP run common block
+#define hwuinc hwuinc_  // compute parameter-dependent constants
+#define hwusta hwusta_  // call hwusta to make any particle stable
+#define hweini hweini_  // initialise elementary process
+#define hwuine hwuine_  // initialise event
+#define hwepro hwepro_  // generate HERWIG hard subprocess
+#define hwupro hwupro_  // read USER hard subprocess from HepUP event common
+#define hwbgen hwbgen_  // generate parton cascades
+#define hwdhob hwdhob_  // do heavy object decays
+#define hwcfor hwcfor_  // do cluster hadronization
+#define hwcdec hwcdec_  // do cluster decay
+#define hwdhad hwdhad_  // do unstable particle decays
+#define hwdhvy hwdhvy_  // do heavy flavour decays
+#define hwmevt hwmevt_  // add soft underlying event if needed 
+#define hwufne hwufne_  // event generation completed, wrap up event .... 
+#define hwefin hwefin_  // terminate elementary process
+
+#define hwudpr hwudpr_  // prints out particle/decay properties
+#define hwuepr hwuepr_  // prints out event data
+#define hwupup hwupup_  // prints out HepEUP user common block event data
+#define hwegup hwegup_  // terminal calculations to replace HWEFIN for HepUP
+    extern "C" {
+        void hwigin(void);
+        void hwigup(void);
+        void hwuinc(void);
+        void hwusta(const char*,int);
+        void hweini(void);
+        void hwuine(void);
+        void hwepro(void);
+        void hwupro(void);
+        void hwbgen(void);
+        void hwdhob(void);
+        void hwcfor(void);
+        void hwcdec(void);
+        void hwdhad(void);
+        void hwdhvy(void);
+        void hwmevt(void);
+        void hwufne(void);
+        void hwefin(void);
+        void hwudpr(void);
+        void hwuepr(void);
+	void hwupup(void);
+	void hwegup(void);
+    }
+
+//--------------------------------------------------------------------------
+// HERWIG block data
+// ( with gcc it works to initialize the block data by calling 
+//   "hwudat();" at beginning. )
+
+#define hwudat hwudat_
+extern "C" {
+    void hwudat(void);
+}
+
+#endif  // HERWIG_WRAPPER_H
+//--------------------------------------------------------------------------

HepMC/examples/example_MyHerwig.cc

+//////////////////////////////////////////////////////////////////////////
+// Matt.Dobbs@Cern.CH, October 2002
+// example of generating events with Herwig using HepMC/HerwigWrapper.h 
+// Events are read into the HepMC event record from the FORTRAN HEPEVT 
+// common block using the ConvertHerwig strategy.
+//////////////////////////////////////////////////////////////////////////
+// To Compile: go to the HepMC directory and type:
+// gmake examples/example_MyHerwig.exe
+//
+// In this example the precision and number of entries for the HEPEVT 
+// fortran common block are explicitly defined to correspond to those 
+// used in the Herwig version of the HEPEVT common block. 
+// If you get funny output from HEPEVT in your own code, probably you have
+// set these values incorrectly!
+//
+
+#include <iostream>
+#include "CLHEP/HepMC/defs.h"
+#include "CLHEP/HepMC/include/HerwigWrapper.h"
+#include "CLHEP/HepMC/ConvertHerwig.h"
+#include "CLHEP/HepMC/GenEvent.h"
+
+int main() { 
+    //
+    //.......................................INITIALIZATIONS
+
+    hwproc.PBEAM1 = 7000.; // energy of beam1
+    hwproc.PBEAM2 = 7000.; // energy of beam2
+    // 1610 = gg->H--> WW, 1706 = qq-->ttbar, 2510 = ttH -> ttWW
+    hwproc.IPROC = 1706; // qq -> ttbar production 
+    hwproc.MAXEV = 100; // number of events
+    // tell it what the beam particles are:
+    for ( unsigned int i = 0; i < 8; ++i ) {
+        hwbmch.PART1[i] = (i < 1) ? 'P' : ' ';
+        hwbmch.PART2[i] = (i < 1) ? 'P' : ' ';
+    }
+    hwigin();    // INITIALISE OTHER COMMON BLOCKS
+    hwevnt.MAXPR = 1; // number of events to print
+    hwuinc(); // compute parameter-dependent constants
+    hweini(); // initialise elementary process
+
+    //........................................HepMC INITIALIZATIONS
+    //
+    // Instantiate an IO strategy for reading from HEPEVT.
+    HepMC::ConvertHerwig hepevtio;
+    //
+    //........................................EVENT LOOP
+    for ( int i = 1; i <= hwproc.MAXEV; i++ ) {
+	if ( i%50==1 ) std::cout << "Processing Event Number " 
+				 << i << std::endl;
+	// initialise event
+	hwuine();
+	// generate hard subprocess
+	hwepro();
+	// generate parton cascades
+	hwbgen();
+	// do heavy object decays
+	hwdhob();
+	// do cluster formation
+	hwcfor();
+	// do cluster decays
+	hwcdec();
+	// do unstable particle decays
+	hwdhad();
+	// do heavy flavour hadron decays
+	hwdhvy();
+	// add soft underlying event if needed
+	hwmevt();
+	// finish event
+	hwufne();
+	HepMC::GenEvent* evt = hepevtio.read_next_event();
+	// add some information to the event
+	evt->set_event_number(i);
+	evt->set_signal_process_id(20);
+	if (i<=hwevnt.MAXPR) {
+	    std::cout << "\n\n This is the FIXED version of HEPEVT as "
+		      << "coded in ConvertHerwig " << std::endl;
+	    hepevtio.print_hepevt();
+	    evt->print();
+	}
+
+	// we also need to delete the created event from memory
+	delete evt;
+    }
+    //........................................TERMINATION
+    hwefin();
+
+    return 0;
+}