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 {
 
 
  class JetFinder : public Projection {
  public:
 
    enum class Muons { NONE, DECAY, ALL };
 
    enum class Invisibles { NONE, DECAY, ALL };
 
 
 
    JetFinder(const FinalState& fs,
           Muons usemuons = Muons::ALL,
           Invisibles useinvis = Invisibles::NONE);
 
    JetFinder() = default;
 
    virtual unique_ptr<Projection> clone() const = 0;
 
    virtual ~JetFinder() = default;
 
 
 
 
    void useMuons(Muons usemuons = Muons::ALL) {
      _useMuons = usemuons;
    }
 
    void useInvisibles(Invisibles useinvis = Invisibles::DECAY) {
      _useInvisibles = useinvis;
    }
 
    DEPRECATED("make an explicit choice from Invisibles::{NONE,DECAY,ALL}. This boolean call does not allow for ALL")
    void useInvisibles(bool useinvis) {
      _useInvisibles = useinvis ? Invisibles::DECAY : Invisibles::NONE;
    }
 
 
 
 
 
    virtual Jets jets(const Cut& c=Cuts::open()) const {
      return filter_select(_jets(), c);
    }
 
    virtual Jets jets(const JetSelector& selector) const {
      return filter_select(_jets(), selector);
    }
 
 
    Jets jets(const Cut& c, const JetSorter& sorter) const {
      return sortBy(jets(c), sorter);
    }
 
    Jets jets(const JetSorter& sorter, const Cut& c=Cuts::open()) const {
      return jets(c, sorter);
    }
 
    Jets jets(const JetSelector& selector, const JetSorter& sorter) const {
      return sortBy(jets(selector), sorter);
    }
 
    Jets jets(const JetSorter& sorter, const JetSelector selector) const {
      return jets(selector, sorter);
    }
 
 
    Jets jetsByPt(const Cut& c=Cuts::open()) const {
      return jets(c, cmpMomByPt);
    }
 
    Jets jetsByPt(const JetSelector& selector) const {
      return jets(selector, cmpMomByPt);
    }
 
    Jets jetsByPt(double ptmin) const {
      return jets(Cuts::pT >= ptmin, cmpMomByPt);
    }
 
 
 
  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:
 
    Muons _useMuons;
 
    Invisibles _useInvisibles;
 
 
  };
 
 
}
 
#endif