Projection.hh

// -*- C++ -*-
#ifndef RIVET_Projection_HH
#define RIVET_Projection_HH
 
#include "Rivet/Projection.fhh"
#include "Rivet/ProjectionApplier.hh"
#include "Rivet/ProjectionHandler.hh"
#include "Rivet/Config/RivetCommon.hh"
#include "Rivet/Tools/Cuts.hh"
// NOTE: Cmp.hh, Event.hh and Particle.hh included at the bottom
 
namespace Rivet {
 
 
  // Forward declaration
  class Event;
 
 
  class Projection : public ProjectionApplier {
  public:
 
    friend class Event;
 
    friend class Cmp<Projection>;
 
 
 
 
    Projection();
 
    virtual unique_ptr<Projection> clone() const = 0;
 
    virtual ~Projection() = default;
 
    virtual Projection& operator = (const Projection&) = delete;
 
    Projection(const Projection&) = default;
 
 
 
    virtual std::string name() const {
      return _name;
    }
 
    bool valid() const {
      return _isValid;
    }
 
    bool failed() const {
      return !valid();
    }
 
 
    virtual void project(const Event& e) = 0;
 
    virtual CmpState compare(const Projection& p) const = 0;
 
    bool before(const Projection& p) const;
 
 
 
 
    // /// @name Beam configuration
    // /// @todo Does it really make sense to restrict Projections to particular beam configs? Do we use this in practice?
    // /// @{
 
    // /// Return the allowed beam pairs on which this projection can operate, not
    // /// including recursion. Derived classes should ensure that all contained
    // /// projections are registered in the @a _projections set for the beam
    // /// constraint chaining to work.
    // /// @todo Remove the beam constraints system from projections.
    // virtual const std::set<PdgIdPair> beamPairs() const;
 
 
    // /// Add a colliding beam pair.
    // /// @todo This deserves a better name!
    // Projection& addPdgIdPair(PdgId beam1, PdgId beam2) {
    //   _beamPairs.insert(PdgIdPair(beam1, beam2));
    //   return *this;
    // }
 
    // /// @}
 
 
  protected:
 
    Log& getLog() const {
      string logname = "Rivet.Projection." + name();
      return Log::getLog(logname);
    }
 
    void setName(const std::string& name) {
      _name = name;
    }
    
    void fail() {
      _isValid = false;
    }
 
    Cmp<Projection> mkNamedPCmp(const Projection& otherparent, const std::string& pname) const;
 
    Cmp<Projection> mkPCmp(const Projection& otherparent, const std::string& pname) const;
 
 
  private:
 
    string _name;
 
    bool _isValid;
 
  };
 
 
}
 
 
inline bool std::less<const Rivet::Projection *>::operator()(const Rivet::Projection* x,
                                                             const Rivet::Projection* y) const {
  return x->before(*y);
}
 
 
#endif
 
 
#include "Rivet/Event.hh"
#include "Rivet/Particle.hh"
#include "Rivet/Tools/Cmp.hh"
 
 
#define RIVET_DEFAULT_PROJ_CLONE(clsname) \
  virtual unique_ptr<Projection> clone() const { return unique_ptr<Projection>(new clsname(*this)); }