JetFinder.hh

// -*- C++ -*-
#ifndef RIVET_JetFinder_HH
#define RIVET_JetFinder_HH
 
#include "Rivet/Projection.hh"
#include "Rivet/Projections/FinalState.hh"
#include "Rivet/Projections/VisibleFinalState.hh"
#include "Rivet/Particle.hh"
#include "Rivet/Jet.hh"
 
namespace Rivet {
 
 
  enum class JetMuons { NONE, DECAY, ALL };
 
  enum class JetInvisibles { NONE, DECAY, ALL };
 
 
  struct JetScheme {
    JetScheme(JetAlg a, double rparam,
              JetMuons usemuons=JetMuons::ALL,
              JetInvisibles useinvis=JetInvisibles::NONE)
      : alg(a), R(rparam), muons(usemuons), invis(useinvis)
    {    }
 
    JetScheme() : JetScheme(JetAlg::ANTIKT, 0.4) { }
 
    JetAlg alg;
    double R;
    JetMuons muons = JetMuons::ALL;
    JetInvisibles invis = JetInvisibles::NONE;
  };
  struct JetScheme {…};
 
 
  class JetFinder : public Projection {
  public:
 
    JetFinder(const FinalState& fs,
          JetMuons usemuons = JetMuons::ALL,
          JetInvisibles useinvis = JetInvisibles::NONE);
 
    JetFinder() = default;
 
    virtual unique_ptr<Projection> clone() const = 0;
 
    virtual ~JetFinder() = default;
 
    using Projection::operator =;
 
 
 
    void useMuons(JetMuons usemuons = JetMuons::ALL) {
      _useMuons = usemuons;
    }
    void useMuons(JetMuons usemuons = JetMuons::ALL) {…}
 
    void useInvisibles(JetInvisibles useinvis = JetInvisibles::DECAY) {
      _useInvisibles = useinvis;
    }
    void useInvisibles(JetInvisibles useinvis = JetInvisibles::DECAY) {…}
 
 
 
 
    virtual Jets jets(const Cut& c=Cuts::open()) const {
      return select(_jets(), c);
    }
    virtual Jets jets(const Cut& c=Cuts::open()) const  {…}
 
    virtual Jets jets(const JetSelector& selector) const {
      return select(_jets(), selector);
    }
    virtual Jets jets(const JetSelector& selector) const  {…}
 
 
    Jets jets(const Cut& c, const JetSorter& sorter) const {
      return sortBy(jets(c), sorter);
    }
    Jets jets(const Cut& c, const JetSorter& sorter) const  {…}
 
    Jets jets(const JetSorter& sorter, const Cut& c=Cuts::open()) const {
      return jets(c, sorter);
    }
    Jets jets(const JetSorter& sorter, const Cut& c=Cuts::open()) const  {…}
 
    Jets jets(const JetSelector& selector, const JetSorter& sorter) const {
      return sortBy(jets(selector), sorter);
    }
    Jets jets(const JetSelector& selector, const JetSorter& sorter) const  {…}
 
    Jets jets(const JetSorter& sorter, const JetSelector selector) const {
      return jets(selector, sorter);
    }
    Jets jets(const JetSorter& sorter, const JetSelector selector) const  {…}
 
 
    Jets jetsByPt(const Cut& c=Cuts::open()) const {
      return jets(c, cmpMomByPt);
    }
    Jets jetsByPt(const Cut& c=Cuts::open()) const  {…}
 
    Jets jetsByPt(const JetSelector& selector) const {
      return jets(selector, cmpMomByPt);
    }
    Jets jetsByPt(const JetSelector& selector) const  {…}
 
 
 
  protected:
 
    virtual Jets _jets() const = 0;
 
 
  public:
 
    size_t size() const { return jets().size(); }
    size_t size(const Cut& c) const { return jets(c).size(); }
    size_t size(const JetSelector& s) const { return jets(s).size(); }
 
    bool empty() const { return size() == 0; }
    bool empty(const Cut& c) const { return size(c) == 0; }
    bool empty(const JetSelector& s) const { return size(s) == 0; }
 
    virtual void reset() = 0;
 
    typedef Jet entity_type;
    typedef Jets collection_type;
 
    collection_type entities() const { return jets(); }
 
    // /// Do the calculation locally (no caching).
    // virtual void calc(const Particles& constituents, const Particles& tagparticles=Particles()) = 0;
 
 
  protected:
 
    virtual void project(const Event& e) = 0;
 
    virtual CmpState compare(const Projection& p) const = 0;
 
 
  protected:
 
    JetMuons _useMuons;
 
    JetInvisibles _useInvisibles;
 
 
  };
  class JetFinder : public Projection {…};
 
 
}
 
#endif