Cuts.hh

#ifndef RIVET_Cuts_HH
#define RIVET_Cuts_HH
 
#include "Rivet/Tools/Cuts.fhh"
#include <string>
 
namespace Rivet {
 
 
  class CutBase {
  public:
 
    template <typename ClassToCheck>
    bool accept(const ClassToCheck&) const;
 
    template <typename ClassToCheck>
    bool operator () (const ClassToCheck& x) const { return accept(x); }
 
    virtual bool operator == (const Cut&) const = 0;
 
    virtual std::string toString() const = 0;
 
    virtual ~CutBase() {}
 
 
  protected:
 
    virtual bool _accept(const CuttableBase&) const = 0;
 
  };
 
 
  inline bool operator == (const Cut& a, const Cut& b) { return *a == b; }
 
  Cut operator , (const Cut&, const Cut&) = delete;
  Cut& operator , (Cut&, Cut&) = delete;
  Cut operator , (Cut, Cut) = delete;
 
 
  namespace Cuts {
 
    enum Quantity { pT=0, pt=0, Et=1, et=1, E=2, energy=2,
                    mass, rap, absrap, eta, abseta, phi,
                    pid, abspid, charge, abscharge, charge3, abscharge3, pz };
 
    const Cut& open(); //< access by factory function
 
    extern const Cut& OPEN; //= open(); //< access by constant
    extern const Cut& NOCUT; //= open(); //< access by constant
 
    Cut range(Quantity, double m, double n);
    inline Cut ptIn(double m, double n) { return range(pT, m,n); }
    inline Cut etIn(double m, double n) { return range(Et, m,n); }
    inline Cut energyIn(double m, double n) { return range(energy, m,n); }
    inline Cut massIn(double m, double n) { return range(mass, m,n); }
    inline Cut rapIn(double m, double n) { return range(rap, m,n); }
    inline Cut absrapIn(double m, double n) { return range(absrap, m,n); }
    inline Cut etaIn(double m, double n) { return range(eta, m,n); }
    inline Cut absetaIn(double m, double n) { return range(abseta, m,n); }
 
  }
 
 
  Cut operator == (Cuts::Quantity, double);
  Cut operator != (Cuts::Quantity, double);
  Cut operator <  (Cuts::Quantity, double);
  Cut operator >  (Cuts::Quantity, double);
  Cut operator <= (Cuts::Quantity, double);
  Cut operator >= (Cuts::Quantity, double);
 
  inline Cut operator == (Cuts::Quantity qty, int i) { return qty ==  double(i); }
  inline Cut operator != (Cuts::Quantity qty, int i) { return qty !=  double(i); }
  // Cut operator == (Cuts::Quantity qty, int i);
  // Cut operator != (Cuts::Quantity qty, int i);
  inline Cut operator <  (Cuts::Quantity qty, int i) { return qty <  double(i); }
  inline Cut operator >  (Cuts::Quantity qty, int i) { return qty >  double(i); }
  inline Cut operator <= (Cuts::Quantity qty, int i) { return qty <= double(i); }
  inline Cut operator >= (Cuts::Quantity qty, int i) { return qty >= double(i); }
 
 
 
 
  Cut operator && (const Cut & aptr, const Cut & bptr);
  Cut operator || (const Cut & aptr, const Cut & bptr);
  Cut operator ! (const Cut & cptr);
 
  Cut operator & (const Cut & aptr, const Cut & bptr);
  Cut operator | (const Cut & aptr, const Cut & bptr);
  Cut operator ~ (const Cut & cptr);
  Cut operator ^ (const Cut & aptr, const Cut & bptr);
 
 
 
  inline std::ostream& operator << (std::ostream& os, const Cut& cptr) {
    os << cptr->toString();
    return os;
  }
 
 
}
 
#endif