JetSmearingFunctions.hh

// -*- C++ -*-
#ifndef RIVET_JetSmearingFunctions_HH
#define RIVET_JetSmearingFunctions_HH
 
#include "Rivet/Jet.hh"
#include "Rivet/Tools/MomentumSmearingFunctions.hh"
#include "Rivet/Tools/ParticleSmearingFunctions.hh"
#include "Rivet/Tools/Random.hh"
 
namespace Rivet {
 
 
 
 
  typedef function<Jet(const Jet&)> JetSmearFn;
 
  typedef function<double(const Jet&)> JetEffFn;
 
 
 
  inline double JET_EFF_ZERO(const Jet&) { return 0; }
  inline double JET_EFF_0(const Jet&) { return 0; }
  inline double JET_FN0(const Jet&) { return 0; }
 
  inline double JET_EFF_ONE(const Jet&) { return 1; }
  inline double JET_EFF_1(const Jet&) { return 1; }
  inline double JET_EFF_PERFECT(const Jet&) { return 1; }
  inline double JET_EFF_IDENTITY(const Jet&) { return 1; }
  inline double JET_FN1(const Jet&) { return 1; }
 
  struct JET_EFF_CONST {
    JET_EFF_CONST(double eff) : _eff(eff) {}
    double operator () (const Jet& )  const { return _eff; }
    double _eff;
  };
  struct JET_EFF_CONST {…};
 
 
  inline double JET_BTAG_PERFECT(const Jet& j) { return j.bTagged() ? 1 : 0; }
  inline double JET_BTAG_IDENTITY(const Jet& j) { return JET_BTAG_PERFECT(j); }
 
  inline double JET_CTAG_PERFECT(const Jet& j) { return j.cTagged() ? 1 : 0; }
  inline double JET_CTAG_IDENTITY(const Jet& j) { return JET_CTAG_PERFECT(j); }
 
  inline double JET_TAUTAG_PERFECT(const Jet& j) { return j.tauTagged() ? 1 : 0; }
  inline double JET_TAUTAG_IDENTITY(const Jet& j) { return JET_TAUTAG_PERFECT(j); }
 
 
  struct JET_BTAG_EFFS {
    JET_BTAG_EFFS(double eff_b, double eff_light=0) : _eff_b(eff_b), _eff_c(-1), _eff_t(-1), _eff_l(eff_light) { }
    JET_BTAG_EFFS(double eff_b, double eff_c, double eff_light) : _eff_b(eff_b), _eff_c(eff_c), _eff_t(-1), _eff_l(eff_light) { }
    JET_BTAG_EFFS(double eff_b, double eff_c, double eff_tau, double eff_light) : _eff_b(eff_b), _eff_c(eff_c), _eff_t(eff_tau), _eff_l(eff_light) { }
    inline double operator () (const Jet& j) {
      if (j.bTagged()) return _eff_b;
      if (_eff_c >= 0 && j.cTagged()) return _eff_c;
      if (_eff_t >= 0 && j.tauTagged()) return _eff_t;
      return _eff_l;
    }
    double _eff_b, _eff_c, _eff_t, _eff_l;
  };
  struct JET_BTAG_EFFS {…};
 
 
  inline Jet JET_SMEAR_IDENTITY(const Jet& j) { return j; }
  inline Jet JET_SMEAR_PERFECT(const Jet& j) { return j; }
 
 
  struct JetEffSmearFn {
    JetEffSmearFn(const JetSmearFn& s, const JetEffFn& e)
      : sfn(s), efn(e) {    }
 
    JetEffSmearFn(const JetEffFn& e, const JetSmearFn& s)
      : sfn(s), efn(e) {    }
 
    JetEffSmearFn(const JetSmearFn& s)
      : sfn(s), efn(JET_EFF_ONE) {    }
 
    JetEffSmearFn(const JetEffFn& e)
      : sfn(JET_SMEAR_IDENTITY), efn(e) {    }
 
    JetEffSmearFn(double eff)
      : JetEffSmearFn(JET_EFF_CONST(eff)) {    }
 
    pair<Jet,double> operator() (const Jet& j) const {
      return make_pair(sfn(j), efn(j));
    }
    pair<Jet,double> operator() (const Jet& j) const  {…}
 
    CmpState cmp(const JetEffSmearFn& other) const {
      // cout << "Eff hashes = " << get_address(efn) << "," << get_address(other.efn) << "; "
      //      << "smear hashes = " << get_address(sfn) << "," << get_address(other.sfn) << '\n';
      if (get_address(sfn) == 0 || get_address(other.sfn) == 0) return CmpState::NEQ;
      if (get_address(efn) == 0 || get_address(other.efn) == 0) return CmpState::NEQ;
      return Rivet::cmp(get_address(sfn), get_address(other.sfn)) || Rivet::cmp(get_address(efn), get_address(other.efn));
    }
    CmpState cmp(const JetEffSmearFn& other) const  {…}
 
    operator JetSmearFn () { return sfn; }
    // operator JetEffFn () { return efn; }
 
    // Stored functions/functors
    JetSmearFn sfn;
    JetEffFn efn;
  };
  struct JetEffSmearFn {…};
 
 
  template <typename FN>
  inline bool efffilt(const Jet& j, FN& feff) {
    return rand01() < feff(j);
  }
  inline bool efffilt(const Jet& j, FN& feff) {…}
 
  struct JetEffFilter {
    template <typename FN>
    JetEffFilter(const FN& feff) : _feff(feff) {}
    JetEffFilter(double eff) : JetEffFilter( [&](const Jet&){return eff;} ) {}
    bool operator () (const Jet& j) const { return efffilt(j, _feff); }
  private:
    const JetEffFn _feff;
  };
  struct JetEffFilter {…};
  using jetEffFilter = JetEffFilter;
 
 
 
}
 
#endif