GenEvent.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
/* Author: Andrii Verbytskyi andrii.verbytskyi@mpp.mpg.de */
 
#ifndef ATLASHEPMC_GENEVENT_H
#define ATLASHEPMC_GENEVENT_H
#include "HepMC3/GenEvent.h"
#include "HepMC3/GenHeavyIon.h"
#include "HepMC3/GenPdfInfo.h"
#include "HepMC3/PrintStreams.h"
#include "AtlasHepMC/Barcode.h"
#include "AtlasHepMC/GenVertex.h"
#include "AtlasHepMC/GenParticle.h"
#include "AtlasHepMC/SimpleVector.h"
#include "AtlasHepMC/AttributeNames.h"
 
#include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
#include <unordered_map>
 
namespace HepMC3 {
inline std::vector<HepMC3::GenParticlePtr>::const_iterator  begin(HepMC3::GenEvent& e) { return e.particles().begin(); }
inline std::vector<HepMC3::GenParticlePtr>::const_iterator  end(HepMC3::GenEvent& e) { return e.particles().end(); }
inline std::vector<HepMC3::ConstGenParticlePtr>::const_iterator  begin(const HepMC3::GenEvent& e) { return e.particles().begin(); }
inline std::vector<HepMC3::ConstGenParticlePtr>::const_iterator  end(const HepMC3::GenEvent& e) { return e.particles().end(); }
}
 
namespace HepMC {
using Print = HepMC3::Print;
using GenHeavyIon = HepMC3::GenHeavyIon;
using GenEvent = HepMC3::GenEvent;
 
class ShortEventAttribute : public HepMC3::Attribute {
public:
    ShortEventAttribute(): HepMC3::Attribute(){}
    ShortEventAttribute(const HepMC3::GenEvent* e): HepMC3::Attribute(){ from_event(e); }
 
    bool from_event(const HepMC3::GenEvent* e){
      NUP=e->particles().size();
      resize();
      XWGTUP = e->weights().size() ? e->weights()[0] : 1.0;
      auto A_signal_process_id = e->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_id);
      IDPRUP = A_signal_process_id ? A_signal_process_id->value() : 0;
      auto A_event_scale = e->attribute<HepMC3::DoubleAttribute>(HepMCStr::event_scale);
      SCALUP = A_event_scale ? A_event_scale->value() : 0;
      auto A_alphaQCD = e->attribute<HepMC3::DoubleAttribute>(HepMCStr::alphaQCD);
      AQCDUP = A_alphaQCD ? A_alphaQCD->value() : 0;
      auto A_alphaQED = e->attribute<HepMC3::DoubleAttribute>(HepMCStr::alphaQED);
      AQEDUP = A_alphaQED ? A_alphaQED->value() : 0;
      for ( int i = 0; i < NUP; ++i ){
        const auto & thisParticle = e->particles().at(i);
        PUP[i][0] = thisParticle->momentum().px();
        PUP[i][1] = thisParticle->momentum().py();
        PUP[i][2] = thisParticle->momentum().pz();
        PUP[i][3] = thisParticle->momentum().e();
        PUP[i][4] = thisParticle->momentum().m();
        IDUP[i] = thisParticle->pdg_id();
        const auto pv = thisParticle->production_vertex();
        const auto ev = thisParticle->end_vertex();
        if (pv && ev ) ISTUP[i] = 2;
        if (pv && !ev ) ISTUP[i] = 1;
        if (thisParticle->status() == 4 || !pv ) ISTUP[i] = -1;
        const auto flow1 = thisParticle->attribute<HepMC3::IntAttribute>(HepMCStr::flow1);
        const auto flow2 = thisParticle->attribute<HepMC3::IntAttribute>(HepMCStr::flow2);
        ICOLUP[i].first = flow1 ? flow1->value() : 0;
        ICOLUP[i].second = flow2 ? flow2->value() : 0;
        int l = 0;
        int h = 0;
        if (pv && !pv->particles_in().empty()) {
          l = pv->particles_in().front()->id();
          h = l;
          for (const auto& p : pv->particles_in()) {
            const int id = p->id();
            l = std::min(l, id);
            h = std::max(h, id);
          }
        }
        MOTHUP[i].first = h;
        MOTHUP[i].second = l;
      }
      return true;
   }
 
    bool from_string(const std::string &att) override {
      std::istringstream iss(att);
      iss >> NUP;
      iss >> IDPRUP; 
      iss >> XWGTUP;
      iss >> SCALUP;
      iss >> AQEDUP;
      iss >> AQCDUP;
      //assume input is a trusted source
      //coverity[tainted_data] 
      resize();
      for ( int i = 0; i < NUP; ++i ){
        iss >>  IDUP[i];
        iss >>  ISTUP[i];
        iss >>  MOTHUP[i].first;
        iss >>  MOTHUP[i].second;
        iss >>  ICOLUP[i].first;
        iss >>  ICOLUP[i].second;
        iss >>  PUP[i][0];
        iss >>  PUP[i][1];
        iss >>  PUP[i][2];
        iss >>  PUP[i][3];
        iss >> PUP[i][4];
        iss >>  VTIMUP[i];
        iss >>  SPINUP[i];
      }
        set_is_parsed(true);
        return true;
    }
 
    bool to_string(std::string &fl) const  override {
      std::ostringstream file;
      file << " " << std::setw(4) << NUP
           << " " << std::setw(6) << IDPRUP
           << " " << std::setw(14) << XWGTUP
           << " " << std::setw(14) << SCALUP
           << " " << std::setw(14) << AQEDUP
           << " " << std::setw(14) << AQCDUP << "\n";
      for ( int i = 0; i < NUP; ++i )
        file << " " << std::setw(8) << IDUP[i]
             << " " << std::setw(2) << ISTUP[i]
             << " " << std::setw(4) << MOTHUP[i].first
             << " " << std::setw(4) << MOTHUP[i].second
             << " " << std::setw(4) << ICOLUP[i].first
             << " " << std::setw(4) << ICOLUP[i].second
             << " " << std::setw(14) << PUP[i][0]
             << " " << std::setw(14) << PUP[i][1]
             << " " << std::setw(14) << PUP[i][2]
             << " " << std::setw(14) << PUP[i][3]
             << " " << std::setw(14) << PUP[i][4]
             << " " << std::setw(1) << VTIMUP[i]
             << " " << std::setw(1) << SPINUP[i] << std::endl;
       fl += file.str();
       return true;
    }
 
  void resize() {
    IDUP.resize(NUP);
    ISTUP.resize(NUP);
    MOTHUP.resize(NUP);
    ICOLUP.resize(NUP);
    PUP.resize(NUP, std::vector<double>(5));
    VTIMUP.resize(NUP);
    SPINUP.resize(NUP);
  }
 
  int NUP = 0;
  int IDPRUP = 0;
  double XWGTUP = 0;
  double SCALUP = 0;
  double AQEDUP = 0;
  double AQCDUP = 0;
  std::vector<long> IDUP{};
  std::vector<int> ISTUP{};
  std::vector< std::pair<int,int> > MOTHUP{};
  std::vector< std::pair<int,int> > ICOLUP{};
  std::vector< std::vector<double> > PUP{};
  std::vector<double> VTIMUP{};
  std::vector<double> SPINUP{};
};
 
 
class GenEventBarcodes : public HepMC3::Attribute
{
public:
  virtual bool from_string(const std::string & /*att*/) override { return false; }
  virtual bool to_string(std::string &att) const override
  {
    att =  "GenEventBarcodes";
    return true;
  }
  ConstGenVertexPtr barcode_to_vertex (int id) const {
    const auto it = m_vertexBC.find (id);
    if (it != m_vertexBC.end()) return it->second;
    return nullptr;
  }
  GenVertexPtr barcode_to_vertex (int id) {
    const auto it = m_vertexBC.find (id);
    if (it != m_vertexBC.end()) return it->second;
    return nullptr;
  }
  ConstGenParticlePtr barcode_to_particle (int id) const {
    const auto it = m_particleBC.find (id);
    if (it != m_particleBC.end()) return it->second;
    return nullptr;
  }
  GenParticlePtr barcode_to_particle (int id) {
    const auto it = m_particleBC.find (id);
    if (it != m_particleBC.end()) return it->second;
    return nullptr;
  }
 
  void add (GenVertexPtr p) {
    if (!p) return;
    auto barcode = p->attribute<HepMC3::IntAttribute>(HepMCStr::barcode);
    if (barcode) {
      m_vertexBC[barcode->value()] = std::move(p);
    }
  }
 
  void remove (GenVertexPtr p) {
    if (!p) return;
    auto barcode = p->attribute<HepMC3::IntAttribute>(HepMCStr::barcode);
    if (barcode) {
      const auto it = m_vertexBC.find (barcode->value());
      if (it != m_vertexBC.end()) {
        m_vertexBC.erase (it);
      }
    }
  }
 
  void add (GenParticlePtr p) {
    if (!p) return;
    auto barcode = p->attribute<HepMC3::IntAttribute>(HepMCStr::barcode);
    if (barcode) {
      m_particleBC[barcode->value()] = std::move(p);
    }
  }
 
  void remove (GenParticlePtr p) {
    if (!p) return;
    auto barcode = p->attribute<HepMC3::IntAttribute>(HepMCStr::barcode);
    if (barcode) {
      const auto it = m_particleBC.find (barcode->value());
      if (it != m_particleBC.end()) {
        m_particleBC.erase (it);
      }
    }
  }
  
  std::map<int, ConstGenVertexPtr> barcode_to_vertex_map() const {
    std::map<int, ConstGenVertexPtr> ret;
    for (const auto &bcvertpair: m_vertexBC)
      ret.insert({bcvertpair.first, std::const_pointer_cast<const HepMC3::GenVertex>(bcvertpair.second)});
    return ret;
   }
  std::map<int, ConstGenParticlePtr> barcode_to_particle_map() const {
    std::map<int, ConstGenParticlePtr> ret;
    for (const auto &bcpartpair: m_particleBC)
      ret.insert({bcpartpair.first, std::const_pointer_cast<const HepMC3::GenParticle>(bcpartpair.second)});
    return ret;
   }
  std::map<int,int> id_to_barcode_map() const {
    std::map<int, int> ret;
    for (const auto &bcvertpair: m_vertexBC) ret.insert({bcvertpair.second->id(), bcvertpair.first});
    for (const auto &bcpartpair: m_particleBC) ret.insert({bcpartpair.second->id(), bcpartpair.first});
    return ret;
   }
 
 
  void fillAttribute(GenEvent* e) {
    const auto eventAttributes = e->attributes(); // this makes a copy
    const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
    const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
    const auto &particles = e->particles();
    for (size_t i = 1; i <= particles.size(); i++) {
      if (hasBarcodeAttribute && barcodeAttributeIt->second.count(i) > 0) {
        const auto &ptr = barcodeAttributeIt->second.at(i);
        if (ptr->is_parsed()) {
          m_particleBC[static_cast<HepMC3::IntAttribute*>(ptr.get())->value()] = ptr->particle();
        }
        else {
          m_particleBC[std::atoi(ptr->unparsed_string().c_str())] = ptr->particle();
        }
      } else {
        m_particleBC[i] = particles[i-1];
      }
    }
    const auto &vertices = e->vertices();
    for (size_t i = 1; i <= vertices.size(); i++) {
      if (hasBarcodeAttribute && barcodeAttributeIt->second.count(-i) > 0) {
        const auto &ptr = barcodeAttributeIt->second.at(-i);
        if (ptr->is_parsed()) {
          m_vertexBC[static_cast<HepMC3::IntAttribute*>(ptr.get())->value()] = ptr->vertex();
        }
        else {
          m_vertexBC[std::atoi(ptr->unparsed_string().c_str())] = ptr->vertex();
        }
      } else {
        m_vertexBC[-i] = vertices[i-1];
      }
    }
    set_is_parsed(true);
  }
 
private:
  std::unordered_map<int, GenVertexPtr> m_vertexBC;
  std::unordered_map<int, GenParticlePtr> m_particleBC;
};

class ShadowParticle : public HepMC3::Attribute {
public:

  ShadowParticle() {}

  ShadowParticle(ConstGenParticlePtr p)
    : Attribute(), m_shadow(p) {}

  virtual bool from_string(const std::string &) override { return false; }

  virtual bool to_string(std::string &att) const override
  {
    att =  "ShadowParticle";
    return true;
  }

  ConstGenParticlePtr value() const {
    return m_shadow;
  }
 
private:
  
  ConstGenParticlePtr m_shadow; 
};
 
inline bool set_ll_event_number(HepMC3::GenEvent* e, long long int num){
  e->add_attribute(HepMCStr::long_long_event_number, std::make_shared<HepMC3::LongLongAttribute>(num));
  return true;
}
inline long long int get_ll_event_number(const HepMC3::GenEvent* e){
  auto at = e->attribute<HepMC3::LongLongAttribute>(HepMCStr::long_long_event_number);
  return at ? at->value() : e->event_number();
}
 
inline std::map<std::string, std::size_t> weights_map(const HepMC3::GenEvent* e) {
  std::map<std::string, std::size_t>  ret;
  auto run = e->run_info();
  if (!run) return ret;
  const std::vector<std::string> names = run->weight_names();
  for (const auto& name: names) ret[name] = run->weight_index(name);
  return ret;
}
 
inline std::vector<HepMC3::GenParticlePtr>::const_iterator  begin(HepMC3::GenEvent& e) { return e.particles().begin(); }
inline std::vector<HepMC3::GenParticlePtr>::const_iterator  end(HepMC3::GenEvent& e) { return e.particles().end(); }
inline std::vector<HepMC3::ConstGenParticlePtr>::const_iterator  begin(const HepMC3::GenEvent& e) { return e.particles().begin(); }
inline std::vector<HepMC3::ConstGenParticlePtr>::const_iterator  end(const HepMC3::GenEvent& e) { return e.particles().end(); }
 
inline GenEvent* newGenEvent(const int signal_process_id, const int event_number) { // TODO Update event_number to long long int?
    GenEvent* e = new GenEvent();
    std::shared_ptr<HepMC3::IntAttribute> signal_process_id_A = std::make_shared<HepMC3::IntAttribute>(signal_process_id);
    e->add_attribute(HepMCStr::signal_process_id, signal_process_id_A);
    e->add_attribute(HepMCStr::barcodes, std::make_shared<GenEventBarcodes>());
    e->set_event_number(event_number);
    return e;
}
 
inline GenEvent* copyemptyGenEvent(const GenEvent* inEvt) {
  GenEvent* e = new GenEvent();
  e->set_event_number(inEvt->event_number());
  e->weights() = inEvt->weights();
  auto a_mpi = inEvt->attribute<HepMC3::IntAttribute>(HepMCStr::mpi); 
  if (a_mpi) e->add_attribute(HepMCStr::mpi, std::make_shared<HepMC3::IntAttribute>(*a_mpi));
  auto a_signal_process_id = inEvt->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_id);
  if (a_signal_process_id) e->add_attribute(HepMCStr::signal_process_id, std::make_shared<HepMC3::IntAttribute>(*a_signal_process_id));
  auto a_event_scale = inEvt->attribute<HepMC3::DoubleAttribute>(HepMCStr::event_scale);
  if (a_event_scale) e->add_attribute(HepMCStr::event_scale, std::make_shared<HepMC3::DoubleAttribute>(*a_event_scale));
  auto a_alphaQCD = inEvt->attribute<HepMC3::DoubleAttribute>(HepMCStr::alphaQCD);
  if (a_alphaQCD) e->add_attribute(HepMCStr::alphaQCD, std::make_shared<HepMC3::DoubleAttribute>(*a_alphaQCD));
  auto a_alphaQED = inEvt->attribute<HepMC3::DoubleAttribute>(HepMCStr::alphaQED);
  if (a_alphaQED) e->add_attribute(HepMCStr::alphaQED, std::make_shared<HepMC3::DoubleAttribute>(*a_alphaQED));
  auto a_pi = inEvt->pdf_info(); 
  if (a_pi) e->set_pdf_info(std::make_shared<HepMC3::GenPdfInfo>(*a_pi));
  auto a_hi = inEvt->heavy_ion(); 
  if (a_hi) e->set_heavy_ion(std::make_shared<HepMC3::GenHeavyIon>(*a_hi));
  auto a_random_states = inEvt->attribute<HepMC3::VectorLongIntAttribute>(HepMCStr::random_states);
  if (a_random_states) e->add_attribute(HepMCStr::random_states, std::make_shared<HepMC3::VectorLongIntAttribute>(*a_random_states));
  e->add_attribute(HepMCStr::barcodes, std::make_shared<GenEventBarcodes>());
  return e;
}
 
inline void fillBarcodesAttribute(GenEvent* e) {
  auto barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (!barcodes) {
    barcodes = std::make_shared<GenEventBarcodes>();
    e->add_attribute(HepMCStr::barcodes, barcodes);
  }
  // force re-parsing as calling barcodes->is_parsed() returns true here
  barcodes->fillAttribute(e);
}
 
inline ConstGenVertexPtr  barcode_to_vertex(const GenEvent* e, int id) {
  // Prefer to use optimized GenEvent barcodes attribute
  const auto &barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (barcodes) {
    ConstGenVertexPtr ptr = barcodes->barcode_to_vertex (id);
    if (ptr) return ptr;
  }
  // Fallback to unoptimized GenVertex barcode attribute
  const auto eventAttributes = e->attributes(); // this makes a copy
  const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
  const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
  const auto &vertices = e->vertices();
  if (hasBarcodeAttribute) {
    for (size_t i = 1; i <= vertices.size(); i++) {
      const auto &ptrIt = barcodeAttributeIt->second.find(-i);
      if (ptrIt != barcodeAttributeIt->second.end()) {
        const auto &ptr = ptrIt->second;
        if (ptr->is_parsed()) {
          if (id == static_cast<HepMC3::IntAttribute*>(ptr.get())->value()) {
            return ptr->vertex();
          }
        }
        else {
          if (id == std::atoi(ptr->unparsed_string().c_str())) {
            return ptr->vertex();
          }
        }
      }
    }
  }
  // No barcodes attribute, so assume that we are passing the id member variable instead of a barcode
  if (-id > 0 && -id <= static_cast<int>(vertices.size())) {
    if (!vertices[-id-1]->attribute<HepMC3::IntAttribute>(HepMCStr::barcode)) {
      return vertices[-id-1];
    }
  }
  return  HepMC3::ConstGenVertexPtr();
}
 
inline ConstGenParticlePtr  barcode_to_particle(const GenEvent* e, int id) {
  // Prefer to use optimized GenEvent barcodes attribute
  const auto &barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (barcodes) {
    ConstGenParticlePtr ptr = barcodes->barcode_to_particle (id);
    if (ptr) return ptr;
  }
  // Fallback to unoptimized GenParticle barcode attribute
  const auto eventAttributes = e->attributes(); // this makes a copy
  const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
  const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
  const auto &particles = e->particles();
  if (hasBarcodeAttribute) {
    for (size_t i = 1; i <= particles.size(); i++) {
      const auto &ptrIt = barcodeAttributeIt->second.find(i);
      if (ptrIt != barcodeAttributeIt->second.end()) {
        const auto &ptr = ptrIt->second;
        if (ptr->is_parsed()) {
          if (id == static_cast<HepMC3::IntAttribute*>(ptr.get())->value()) {
            return ptr->particle();
          }
        }
        else {
          if (id == std::atoi(ptr->unparsed_string().c_str())) {
            return ptr->particle();
          }
        }
      }
    }
  }
  // No barcodes attribute, so assume that we are passing the id member variable instead of a barcode
  if (id > 0 && id <= static_cast<int>(particles.size())) {
    if (!particles[id-1]->attribute<HepMC3::IntAttribute>(HepMCStr::barcode)) {
      return particles[id-1];
    }
  }
  return  HepMC3::ConstGenParticlePtr();
}
 
inline GenVertexPtr  barcode_to_vertex(GenEvent* e, int id) {
  // Prefer to use optimized GenEvent barcodes attribute
  const auto &barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (barcodes) {
    GenVertexPtr ptr = barcodes->barcode_to_vertex (id);
    if (ptr) return ptr;
  }
  // Fallback to unoptimized GenVertex barcode attribute
  const auto eventAttributes = e->attributes(); // this makes a copy
  const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
  const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
  const auto &vertices = e->vertices();
  if (hasBarcodeAttribute) {
    for (size_t i = 1; i <= vertices.size(); i++) {
      const auto &ptrIt = barcodeAttributeIt->second.find(-i);
      if (ptrIt != barcodeAttributeIt->second.end()) {
        const auto &ptr = ptrIt->second;
        if (ptr->is_parsed()) {
          if (id == static_cast<HepMC3::IntAttribute*>(ptr.get())->value()) {
            return ptr->vertex();
          }
        }
        else {
          if (id == std::atoi(ptr->unparsed_string().c_str())) {
            return ptr->vertex();
          }
        }
      }
    }
  }
  // No barcodes attribute, so assume that we are passing the id member variable instead of a barcode
  if (-id > 0 && -id <= static_cast<int>(vertices.size())) {
    if (!vertices[-id-1]->attribute<HepMC3::IntAttribute>(HepMCStr::barcode)) {
      return vertices[-id-1];
    }
  }
  return  HepMC3::GenVertexPtr();
}
 
inline GenParticlePtr  barcode_to_particle(GenEvent* e, int id) {
  // Prefer to use optimized GenEvent barcodes attribute
  const auto &barcodes = e->attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (barcodes) {
    GenParticlePtr ptr = barcodes->barcode_to_particle (id);
    if (ptr) return ptr;
  }
  // Fallback to unoptimized GenParticle barcode attribute
  const auto eventAttributes = e->attributes(); // this makes a copy
  const auto barcodeAttributeIt = eventAttributes.find(HepMCStr::barcode);
  const bool hasBarcodeAttribute = barcodeAttributeIt != eventAttributes.end();
 
  const auto &particles = e->particles();
  if (hasBarcodeAttribute) {
    for (size_t i = 1; i <= particles.size(); i++) {
      const auto &ptrIt = barcodeAttributeIt->second.find(i);
      if (ptrIt != barcodeAttributeIt->second.end()) {
        const auto &ptr = ptrIt->second;
        if (ptr->is_parsed()) {
          if (id == static_cast<HepMC3::IntAttribute*>(ptr.get())->value()) {
            return ptr->particle();
          }
        }
        else {
          if (id == std::atoi(ptr->unparsed_string().c_str())) {
            return ptr->particle();
          }
        }
      }
    }
  }
  // No barcodes attribute, so assume that we are passing the id member variable instead of a barcode
  if (id > 0 && id <= static_cast<int>(particles.size())) {
    if (!particles[id-1]->attribute<HepMC3::IntAttribute>(HepMCStr::barcode)) {
      return particles[id-1];
    }
  }
  return  HepMC3::GenParticlePtr();
}
 
inline int mpi(const GenEvent& evt) {
    std::shared_ptr<HepMC3::IntAttribute> A_mpi = evt.attribute<HepMC3::IntAttribute>(HepMCStr::mpi);
    return A_mpi ? (A_mpi->value()) : 0;
}
inline int mpi(const GenEvent* evt) {
    std::shared_ptr<HepMC3::IntAttribute> A_mpi = evt->attribute<HepMC3::IntAttribute>(HepMCStr::mpi);
    return A_mpi ? (A_mpi->value()) : 0;
}
 
inline int signal_process_id(const GenEvent& evt) {
    std::shared_ptr<HepMC3::IntAttribute> A_signal_process_id = evt.attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_id);
    return A_signal_process_id ? (A_signal_process_id->value()) : 0;
}
inline int signal_process_id(const GenEvent* evt) {
    std::shared_ptr<HepMC3::IntAttribute> A_signal_process_id = evt->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_id);
    return A_signal_process_id ? (A_signal_process_id->value()) : 0;
}
inline void set_signal_process_id(GenEvent* e, const int i = 0) {
    std::shared_ptr<HepMC3::IntAttribute> signal_process_id = std::make_shared<HepMC3::IntAttribute>(i);
    e->add_attribute(HepMCStr::signal_process_id, std::move(signal_process_id));
}
inline void set_mpi(GenEvent* e, const int i = 0) {
    std::shared_ptr<HepMC3::IntAttribute> mpi = std::make_shared<HepMC3::IntAttribute>(i);
    e->add_attribute(HepMCStr::mpi, std::move(mpi));
}
inline void set_random_states(GenEvent* e, std::vector<long int>& a) {
    e->add_attribute(HepMCStr::random_states, std::make_shared<HepMC3::VectorLongIntAttribute>(a));
}
template <class T> void set_signal_process_vertex(GenEvent* e, T& v) {
    if (!v || !e) return;
/* AV: HepMC2 adds the vertex to event */
    e->add_vertex(v);
    v->add_attribute(HepMCStr::signal_process_vertex, std::make_shared<HepMC3::IntAttribute>(1));
}
inline ConstGenVertexPtr signal_process_vertex(const GenEvent* e) { for (auto& v: e->vertices()) if (v->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_vertex)) return v; return nullptr; }
inline      GenVertexPtr signal_process_vertex(GenEvent* e) { for (auto& v: e->vertices()) if (v->attribute<HepMC3::IntAttribute>(HepMCStr::signal_process_vertex)) return v; return nullptr; }
inline bool valid_beam_particles(const GenEvent* e) { 
  if (!e) return false; 
  size_t nBeams = 0;
  for (const auto& p : e->beams()) { if (p->status() == 4)  ++nBeams; }
  if  (nBeams != 2) return false; 
  return true;
}
 
template <class T> bool suggest_barcode(T& p, int i) {
  if (!p->parent_event()) return false;
  auto barcodes = p->parent_event()->template attribute<GenEventBarcodes> (HepMCStr::barcodes);
  if (!barcodes) {
    barcodes = std::make_shared<GenEventBarcodes>();
    p->parent_event()->add_attribute(HepMCStr::barcodes, barcodes);
  }
  barcodes->remove(p);
  const bool ret = p->add_attribute(HepMCStr::barcode, std::make_shared<HepMC3::IntAttribute>(i));
  if (ret) barcodes->add(p);
  return ret;
}
 
}
#endif