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