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


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

    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