JetAlg.hh

// -*- C++ -*-
#ifndef RIVET_JetAlg_HH
#define RIVET_JetAlg_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 JetAlg : public Projection {
  public:

    enum MuonsStrategy { NO_MUONS, DECAY_MUONS, ALL_MUONS };

    enum InvisiblesStrategy { NO_INVISIBLES, DECAY_INVISIBLES, ALL_INVISIBLES };



    JetAlg(const FinalState& fs, MuonsStrategy usemuons=JetAlg::ALL_MUONS, InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES);

    JetAlg() {};

    virtual unique_ptr<Projection> clone() const = 0;

    virtual ~JetAlg() { }




    void useMuons(MuonsStrategy usemuons=ALL_MUONS) {
      _useMuons = usemuons;
    }

    void useInvisibles(InvisiblesStrategy useinvis=DECAY_INVISIBLES) {
      _useInvisibles = useinvis;
    }

    void useInvisibles(bool useinvis) {
      _useInvisibles = useinvis ? DECAY_INVISIBLES : NO_INVISIBLES;
    }





    virtual Jets jets(const Cut& c=Cuts::open()) const {
      return filter_select(_jets(), c);
      // const Jets rawjets = _jets();
      // // Just return a copy of rawjets if the cut is open
      // if (c == Cuts::open()) return rawjets;
      // // If there is a non-trivial cut...
      // /// @todo Use an STL erase(remove_if) and lambda function for this
      // Jets rtn;
      // rtn.reserve(size());
      // foreach (const Jet& j, rawjets)
      //   if (c->accept(j)) rtn.push_back(j);
      // return rtn;
    }

    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 int compare(const Projection& p) const = 0;


  protected:

    MuonsStrategy _useMuons;

    InvisiblesStrategy _useInvisibles;


  };


  using JetFinder = JetAlg;


}

#endif