Event.hh

// -*- C++ -*-
#ifndef RIVET_Event_HH
#define RIVET_Event_HH
 
#include "Rivet/Particle.hh"
#include "Rivet/Projection.hh"
#include "Rivet/Config/RivetCommon.hh"
 
namespace Rivet {
 

  class Event {
  public:


    Event(GenEvent* ge, const vector<size_t>& weightindices = {}) //, bool strip=false)
        : _weightIndices(weightindices), _genevent(*ge) {
      if (!ge) throw UserError("User provided a null GenEvent pointer for analysis");
      // if (strip) _strip(_genevent);
      _fixGenEvent();
    }

    Event(GenEvent& ge, const vector<size_t>& weightindices = {}) //, bool strip=false)
        : _weightIndices(weightindices), _genevent(ge) {
      // if (strip) _strip(_genevent);
      _fixGenEvent();
    }

    Event(const Event& e)
        : _weightIndices(e._weightIndices), _genevent(e._genevent) { }

 


    const GenEvent& hepmcEvent() const {
      return _genevent;
    }
    // /// @brief The generated HepMC event obtained from an external event generator
    // ///
    // /// Convenience alias for hepmcEventPtr()
    // const GenEvent& hepmc() const { return _genevent; }

    const GenEvent* hepmcEventPtr() const {
      return &_genevent;
    }

    const GenEvent* genEvent() const {
      return &_genevent;
    }

    ParticlePair beams() const;

    double sqrtS() const;

    double asqrtS() const;

 


    const Particles& allParticles() const;

    inline Particles allParticles(const Cut& c) const {
      return select(allParticles(), c);
    }

    template <typename FN>
    inline Particles allParticles(const FN& f) const {
      return select(allParticles(), f);
    }

    std::valarray<double> weights() const;

    std::vector<std::pair<double, double>> crossSections() const;



    template <typename PROJ>
    const PROJ& applyProjection(PROJ& p) const {
      static bool docaching = getEnvParam("RIVET_CACHE_PROJECTIONS", true);
      if (docaching) {
        MSG_TRACE("Applying projection " << &p << " (" << p.name() << ") -> comparing to projections "
                                         << _projections);
        // First search for this projection *or an equivalent* in the already-executed list
        const Projection* cpp(&p);
        // std::set<const Projection*>::const_iterator old = _projections.find(cpp);
        std::set<const Projection*>::const_iterator old = std::begin(_projections);
        std::uintptr_t recpp = reinterpret_cast<std::uintptr_t>(cpp);
        for (; old != _projections.end(); ++old)
          if (reinterpret_cast<std::uintptr_t>(*old) == recpp) break;
        if (old != _projections.end()) {
          MSG_TRACE("Equivalent projection found -> returning already-run projection " << *old);
          const Projection& pRef = **old;
          return pcast<PROJ>(pRef);
        }
        MSG_TRACE("No equivalent projection in the already-run list -> projecting now");
      }
      else {
        MSG_TRACE("Applying projection " << &p << " (" << p.name()
                                         << ") WITHOUT projection caching & comparison");
      }
      // If this one hasn't been run yet on this event, run it and add to the list
      Projection* pp = const_cast<Projection*>(&p);
      pp->_isValid = true;
      pp->project(*this);
      if (docaching) _projections.insert(pp);
      return p;
    }
 

    template <typename PROJ>
    const PROJ& applyProjection(PROJ* pp) const {
      if (!pp) throw Error("Event::applyProjection(PROJ*): Projection pointer is null.");
      return applyProjection(*pp);
    }

 
 
  private:

    void _fixGenEvent();

    Log& getLog() const;
 
 
    // /// @brief Remove uninteresting or unphysical particles in the
    // /// GenEvent to speed up searches
    // ///
    // /// @todo Remove!
    // void _strip(GenEvent& ge);
 
    // /// @brief Convert the GenEvent to use conventional alignment
    // ///
    // /// For example, FHerwig only produces DIS events in the unconventional
    // /// hadron-lepton orientation and has to be corrected for DIS analysis
    // /// portability.
    // void _geNormAlignment();

    const std::vector<size_t> _weightIndices;

    const GenEvent& _genevent;

    mutable Particles _particles;

    mutable std::set<ConstProjectionPtr> _projections;

    mutable std::valarray<double> _weights;

    mutable std::vector<std::pair<double, double>> _xsecs;
  };
 
 
}
 
#endif