Event.hh

// -*- C++ -*-
#ifndef RIVET_Event_HH
#define RIVET_Event_HH

#include "Rivet/Config/RivetCommon.hh"
#include "Rivet/Particle.hh"
#include "Rivet/Projection.hh"

namespace Rivet {


  class Event {
  public:



    Event(const GenEvent* ge)
      : _genevent_original(ge), _genevent(*ge)
    { assert(ge); _init(*ge); }

    Event(const GenEvent& ge)
      : _genevent_original(&ge), _genevent(ge)
    { _init(ge); }

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





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

    double weight() const;

    ParticlePair beams() const;

    double sqrtS() const;

    double asqrtS() const;

    double centrality() const;

    // /// Get the boost to the beam centre-of-mass
    // Vector3 beamCMSBoost() const;

    // /// Get the boost to the beam centre-of-mass
    // LorentzTransform beamCMSTransform();





    const Particles& allParticles() const;

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

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





    template <typename PROJ>
    const PROJ& applyProjection(PROJ& p) const {
      Log& log = Log::getLog("Rivet.Event");
      log << Log::TRACE << "Applying projection " << &p << " (" << p.name() << ") -> comparing to projections " << _projections << endl;
      // 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);
      if (old != _projections.end()) {
        log << Log::TRACE << "Equivalent projection found -> returning already-run projection " << *old << endl;
        const Projection& pRef = **old;
        return pcast<PROJ>(pRef);
      }
      // If this one hasn't been run yet on this event, run it and add to the list
      log << Log::TRACE << "No equivalent projection in the already-run list -> projecting now" << endl;
      Projection* pp = const_cast<Projection*>(cpp);
      pp->project(*this);
      _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 _init(const 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 GenEvent* _genevent_original;

    mutable GenEvent _genevent;

    mutable Particles _particles;

    mutable std::set<ConstProjectionPtr> _projections;

  };


}

#endif