JetFinder.hh

// -*- C++ -*-
#ifndef RIVET_JetFinder_HH
#define RIVET_JetFinder_HH
 
#include "Rivet/Jet.hh"
#include "Rivet/Particle.hh"
#include "Rivet/Projection.hh"
#include "Rivet/Projections/FinalState.hh"
#include "Rivet/Projections/VisibleFinalState.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;
  };
 

  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 useInvisibles(JetInvisibles useinvis = JetInvisibles::DECAY) {
      _useInvisibles = useinvis;
    }

 


    virtual Jets jets(const Cut& c = Cuts::open()) const {
      return select(_jets(), c);
    }

    virtual Jets jets(const JetSelector& selector) const {
      return 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);
    }

 
 
  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;
  };
 
 
}
 
#endif