diff --git a/CepGen/IO/HepMCEventInterface.cpp b/CepGen/IO/HepMCEventInterface.cpp
index 6b8d52a..3c21899 100644
--- a/CepGen/IO/HepMCEventInterface.cpp
+++ b/CepGen/IO/HepMCEventInterface.cpp
@@ -1,128 +1,130 @@
 #include "CepGen/IO/HepMCEventInterface.h"
 
 #include "CepGen/Parameters.h"
 #include "CepGen/Core/Exception.h"
 
 #include "CepGen/Event/Event.h"
 #include "CepGen/Physics/Constants.h"
+#include "CepGen/Physics/PDG.h"
 
 #ifdef HEPMC3
 #  include "HepMC3/Version.h"
 #  include "HepMC3/FourVector.h"
 #  include "HepMC3/GenEvent.h"
 #  include "HepMC3/GenRunInfo.h"
 #  include "HepMC3/GenVertex.h"
 #  include "HepMC3/GenParticle.h"
 #else
 #  include "HepMC/Version.h"
 #  if !defined( HEPMC_VERSION_CODE ) // HepMC v2
 #    include "HepMC/SimpleVector.h"
 #    include "HepMC/GenEvent.h"
 #    include "HepMC/GenVertex.h"
 #    include "HepMC/GenParticle.h"
 #  else
 #    include "HepMC/FourVector.h"
 #    include "HepMC/GenEvent.h"
 #    include "HepMC/GenRunInfo.h"
 #    include "HepMC/GenVertex.h"
 #    include "HepMC/GenParticle.h"
 #    define HEPMC3
 #  endif
 #endif
 
 namespace HepMC
 {
   CepGenEvent::CepGenEvent() :
     GenEvent( Units::GEV, Units::MM )
   {
 #ifdef HEPMC3
     GenEvent::add_attribute( "AlphaQCD", make_shared<DoubleAttribute>( cepgen::constants::ALPHA_QCD ) );
     GenEvent::add_attribute( "AlphaEM", make_shared<DoubleAttribute>( cepgen::constants::ALPHA_EM ) );
 #else
     GenEvent::set_alphaQCD( cepgen::constants::ALPHA_QCD );
     GenEvent::set_alphaQED( cepgen::constants::ALPHA_EM );
 #endif
   }
 
   void
   CepGenEvent::feedEvent( const cepgen::Event& evt )
   {
     GenEvent::clear();
     GenEvent::weights().push_back( 1. ); // unweighted events
 
     // filling the particles content
     const FourVector origin( 0., 0., 0., 0. );
     auto& part_vec = evt.particles();
 
     int cm_id = 0, idx = 1;
 
 #ifdef HEPMC3
     GenVertexPtr v1 = make_shared<GenVertex>( origin ), v2 = make_shared<GenVertex>( origin );
     GenVertexPtr vcm = make_shared<GenVertex>( origin );
 #else
     GenVertex* v1 = new GenVertex( origin ), *v2 = new GenVertex( origin );
     GenVertex* vcm = new GenVertex( origin );
 #endif
     for ( unsigned int i = 0; i < part_vec.size(); ++i ) {
       const auto& part_orig = part_vec.at( i );
       const auto& mom_orig = part_orig.momentum();
       FourVector pmom( mom_orig.px(), mom_orig.py(), mom_orig.pz(), part_orig.energy() );
 #ifdef HEPMC3
       auto part = make_shared<GenParticle>( pmom, part_orig.integerPdgId(), (int)part_orig.status() );
 #else
       auto part = new GenParticle( pmom, part_orig.integerPdgId(), (int)part_orig.status() );
       part->suggest_barcode( idx++ );
 #endif
+      part->set_generated_mass( cepgen::PDG::get().mass( part_orig.pdgId() ) );
 
       switch ( part_orig.role() ) {
         case cepgen::Particle::IncomingBeam1:
           v1->add_particle_in( part );
           break;
         case cepgen::Particle::IncomingBeam2:
           v2->add_particle_in( part );
           break;
         case cepgen::Particle::OutgoingBeam1:
           v1->add_particle_out( part );
           break;
         case cepgen::Particle::OutgoingBeam2:
           v2->add_particle_out( part );
           break;
         case cepgen::Particle::Parton1:
           v1->add_particle_out( part );
           vcm->add_particle_in( part );
           break;
         case cepgen::Particle::Parton2:
           v2->add_particle_out( part );
           vcm->add_particle_in( part );
           break;
         case cepgen::Particle::Intermediate:
           // skip the two-parton system and propagate the parentage
           cm_id = i;
           continue;
         case cepgen::Particle::CentralSystem: default: {
           const auto& moth = part_orig.mothers();
           if ( moth.empty() )
             // skip disconnected lines
             continue;
           const short m1 = *moth.begin(), m2 = moth.size() > 1 ? *moth.rbegin() : -1;
           if ( cm_id == m1 || ( m2 >= 0 && ( m1 < cm_id && cm_id <= m2 ) ) ) // also supports range
             // if connected to the central system
             vcm->add_particle_out( part );
           else
             throw CG_FATAL( "HepMCHandler:fillEvent" )
               << "Other particle requested! Not yet implemented!";
         } break;
       }
       idx++;
     }
     GenEvent::add_vertex( v1 );
     GenEvent::add_vertex( v2 );
     GenEvent::add_vertex( vcm );
 
 #ifndef HEPMC3
     GenEvent::set_beam_particles( *v1->particles_in_const_begin(), *v2->particles_in_const_begin() );
     GenEvent::set_signal_process_vertex( vcm );
 #endif
   }
 }
 
diff --git a/CepGen/IO/HepMCHandler.cpp b/CepGen/IO/HepMCHandler.cpp
index 1be1592..f6e89a1 100644
--- a/CepGen/IO/HepMCHandler.cpp
+++ b/CepGen/IO/HepMCHandler.cpp
@@ -1,137 +1,141 @@
 #include "CepGen/IO/ExportHandler.h"
 #include "CepGen/IO/HepMCEventInterface.h"
 
 #include "CepGen/Parameters.h"
 #include "CepGen/Core/Exception.h"
 #include "CepGen/Core/ParametersList.h"
 
 #include "CepGen/Event/Event.h"
 #include "CepGen/Physics/Constants.h"
 
 #ifdef HEPMC3
 #  include "HepMC3/Version.h"
 #  define HEPMC_VERSION HEPMC3_VERSION
 #  define HEPMC_VERSION_CODE HEPMC3_VERSION_CODE
 #  include "HepMC3/WriterAscii.h"
 #  include "HepMC3/WriterAsciiHepMC2.h"
 #  include "HepMC3/WriterHEPEVT.h"
 #  ifdef HEPMC3_ROOTIO
 #    include "HepMC3/WriterRoot.h"
 #    include "HepMC3/WriterRootTree.h"
 #  endif
 #else
 #  include "HepMC/Version.h"
 #  if !defined( HEPMC_VERSION_CODE ) // HepMC v2
 #    include "HepMC/IO_GenEvent.h"
+#    include "HepMC/IO_AsciiParticles.h"
 #  else
 #    include "HepMC/WriterAscii.h"
 #    include "HepMC/WriterHEPEVT.h"
 #    define HEPMC3
 #  endif
 #endif
 
 #include <memory>
 
 using namespace HepMC;
 
 namespace cepgen
 {
   namespace io
   {
     /// Handler for the HepMC file output
     /// \tparam T HepMC writer handler (format-dependent)
     /// \author Laurent Forthomme <laurent.forthomme@cern.ch>
     /// \date Sep 2016
     template<typename T>
     class HepMCHandler : public GenericExportHandler
     {
       public:
         /// Class constructor
         explicit HepMCHandler( const ParametersList& );
         ~HepMCHandler();
 
         void initialise( const Parameters& /*params*/ ) override {}
         /// Writer operator
         void operator<<( const Event& ) override;
         void setCrossSection( double, double ) override;
 
       private:
         /// Writer object
         std::unique_ptr<T> output_;
         /// Generator cross section and error
         std::shared_ptr<GenCrossSection> xs_;
 #ifdef HEPMC3
         /// Auxiliary information on run
         std::shared_ptr<GenRunInfo> runinfo_;
 #endif
         /// Associated HepMC event
         std::shared_ptr<CepGenEvent> event_;
     };
 
     template<typename T>
     HepMCHandler<T>::HepMCHandler( const ParametersList& params ) :
       GenericExportHandler( "hepmc" ),
-      output_( new T( params.get<std::string>( "filename", "output.hepmc" ) ) ),
+      output_( new T( params.get<std::string>( "filename", "output.hepmc" ).c_str() ) ),
       xs_( new GenCrossSection ),
 #ifdef HEPMC3
       runinfo_( new GenRunInfo ),
 #endif
       event_( new CepGenEvent )
     {
 #ifdef HEPMC3
       output_->set_run_info( runinfo_ );
       runinfo_->set_weight_names( { "Default" } );
 #endif
       CG_INFO( "HepMC" )
         << "Interfacing module initialised "
         << "for HepMC version " << HEPMC_VERSION << ".";
     }
 
     template<typename T>
     HepMCHandler<T>::~HepMCHandler()
     {
+#ifdef HEPMC3
       output_->close();
+#endif
     }
 
     template<typename T> void
     HepMCHandler<T>::operator<<( const Event& evt )
     {
       event_->feedEvent( evt );
       // general information
 #ifdef HEPMC3
       event_->set_cross_section( xs_ );
       event_->set_run_info( runinfo_ );
 #else
       event_->set_cross_section( *xs_ );
 #endif
       event_->set_event_number( event_num_++ );
 #ifdef HEPMC3
       output_->write_event( *event_ );
 #else
       output_->write_event( event_.get() );
 #endif
     }
 
     template<typename T> void
     HepMCHandler<T>::setCrossSection( double xsect, double xsect_err )
     {
       xs_->set_cross_section( xsect, xsect_err );
     }
   }
 }
 
 #ifdef HEPMC3
 REGISTER_IO_MODULE( hepmc, HepMCHandler<WriterAscii> )
 REGISTER_IO_MODULE( hepmc3, HepMCHandler<WriterAscii> )
 REGISTER_IO_MODULE( hepevt, HepMCHandler<WriterHEPEVT> )
 #  if HEPMC_VERSION_CODE >= 3001000
 REGISTER_IO_MODULE( hepmc2, HepMCHandler<WriterAsciiHepMC2> )
 #  endif
 #  ifdef HEPMC3_ROOTIO
 REGISTER_IO_MODULE( hepmc_root, HepMCHandler<WriterRoot> )
 REGISTER_IO_MODULE( hepmc_root_tree, HepMCHandler<WriterRootTree> )
 #  endif
-#else
+#else // HepMC version 2 and below
 REGISTER_IO_MODULE( hepmc, HepMCHandler<IO_GenEvent> )
+REGISTER_IO_MODULE( hepmc_ascii, HepMCHandler<IO_AsciiParticles> )
 #endif