ParticleFinder.hh

// -*- C++ -*-
#ifndef RIVET_ParticleFinder_HH
#define RIVET_ParticleFinder_HH
 
#include "Rivet/Projection.hh"
 
namespace Rivet {
 

  class ParticleFinder : public Projection {
  public:
 
    //using Projection::operator=;


    ParticleFinder(const Cut& c = Cuts::OPEN)
        : _cuts(c), _theParticles() { }
 
    // /// @brief Construction using a wrapped other ParticleFinder plus cuts
    // ///
    // /// Useful to apply extra cuts to a generic PF's returned particles.
    // ParticleFinder(const ParticleFinder& pf, const Cut& c) //=Cuts::OPEN)
    //   : _cuts(c), _theParticles()
    // {
    //   setName("ParticleFinder[" + pf.name() + "]");
    //   declare(pf, "PF");
    // }

    virtual ~ParticleFinder() { }

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


    using Projection::operator=;
 


    size_t size() const {
      return particles().size();
    }

    size_t size(const Cut& c) const {
      return particles(c).size();
    }

    size_t size(const ParticleSelector& s) const {
      return particles(s).size();
    }

    bool empty() const {
      return size() == 0;
    }

    bool empty(const Cut& c) const {
      return size(c) == 0;
    }

    bool empty(const ParticleSelector& s) const {
      return size(s) == 0;
    }

    virtual const Particles& particles() const {
      return _theParticles;
    }

    Particles rawParticles() const {
      Particles rtn;
      for (const Particle& p : particles()) rtn += p.rawConstituents();
      return rtn;
    }

    Particles particles(const Cut& c) const {
      return select(particles(), c);
    }

    Particles particles(const ParticleSelector& selector) const {
      return select(particles(), selector);
    }

    Particles particles(const ParticleSorter& sorter, const Cut& c = Cuts::open()) const {
      return sortBy(particles(c), sorter);
    }

    Particles particles(const Cut& c, const ParticleSorter& sorter) const {
      return sortBy(particles(c), sorter);
    }

    Particles particles(const ParticleSelector& selector, const ParticleSorter& sorter) const {
      return sortBy(particles(selector), sorter);
    }

    Particles particles(const ParticleSorter& sorter, const ParticleSelector& selector) const {
      return sortBy(particles(selector), sorter);
    }

    Particles particlesByPt(const Cut& c = Cuts::open()) const {
      return particles(c, cmpMomByPt);
    }

    Particles particlesByPt(const ParticleSelector& selector) const {
      return particles(selector, cmpMomByPt);
    }

    Particles particlesByPt(double ptmin) const {
      return particles(Cuts::pT >= ptmin, cmpMomByPt);
    }

 

 

 
    typedef Particle entity_type;
    typedef Particles collection_type;

    const collection_type& entities() const {
      return particles();
    }


    virtual void project(const Event& e) = 0;

    virtual CmpState compare(const Projection& p) const;
 
 
  protected:

    Cut _cuts;

    Particles _theParticles;
  };
 
 
}
 
#endif