Rivet/Tools/JetSmearingFunctions.hh

0001 // -*- C++ -*-
0002 #ifndef RIVET_JetSmearingFunctions_HH
0003 #define RIVET_JetSmearingFunctions_HH
0004
0005 #include "Rivet/Jet.hh"
0006 #include "Rivet/Tools/MomentumSmearingFunctions.hh"
0007 #include "Rivet/Tools/ParticleSmearingFunctions.hh"
0008 #include "Rivet/Tools/Random.hh"
0009
0010 namespace Rivet {
0011
0012
0013   /// @ingroup smearing
0014   /// @{
0015
0016   /// @defgroup smearing_particle Generic jet filtering, efficiency and smearing utils
0017   /// @{
0018
0019   /// Typedef for Jet smearing functions/functors
0020   typedef function<Jet(const Jet&)> JetSmearFn;
0021
0022   /// Typedef for Jet efficiency functions/functors
0023   typedef function<double(const Jet&)> JetEffFn;
0024
0025
0026
0027   /// Take a jet and return a constant 0
0028   inline double JET_EFF_ZERO(const Jet&) { return 0; }
0029   /// Alias for JET_EFF_ZERO
0030   inline double JET_EFF_0(const Jet&) { return 0; }
0031   /// Alias for JET_EFF_ZERO
0032   inline double JET_FN0(const Jet&) { return 0; }
0033
0034   /// Take a jet and return a constant 1
0035   inline double JET_EFF_ONE(const Jet&) { return 1; }
0036   /// Alias for JET_EFF_ONE
0037   inline double JET_EFF_1(const Jet&) { return 1; }
0038   /// Alias for JET_EFF_ONE
0039   inline double JET_EFF_PERFECT(const Jet&) { return 1; }
0040   /// Alias for JET_EFF_ONE
0041   inline double JET_EFF_IDENTITY(const Jet&) { return 1; }
0042   /// Alias for JET_EFF_ONE
0043   inline double JET_FN1(const Jet&) { return 1; }
0044
0045   /// Take a Jet and return a constant efficiency
0046   struct JET_EFF_CONST {
0047     JET_EFF_CONST(double eff) : _eff(eff) {}
0048     double operator () (const Jet& )  const { return _eff; }
0049     double _eff;
0050   };
0051
0052
0053   /// @brief Return 1 if the given Jet contains a b, otherwise 0
0054   ///
0055   /// @todo Need to be able to pass a tag pT threshold? -> functor struct
0056   inline double JET_BTAG_PERFECT(const Jet& j) { return j.bTagged() ? 1 : 0; }
0057   /// Alias for JET_BTAG_PERFECT
0058   inline double JET_BTAG_IDENTITY(const Jet& j) { return JET_BTAG_PERFECT(j); }
0059
0060   /// @brief Return 1 if the given Jet contains a c, otherwise 0
0061   ///
0062   /// @todo Need to be able to pass a tag pT threshold? -> functor struct
0063   inline double JET_CTAG_PERFECT(const Jet& j) { return j.cTagged() ? 1 : 0; }
0064   /// Alias for JET_CTAG_PERFECT
0065   inline double JET_CTAG_IDENTITY(const Jet& j) { return JET_CTAG_PERFECT(j); }
0066
0067   /// @brief Return 1 if the given Jet contains a c, otherwise 0
0068   ///
0069   /// @todo Need to be able to pass a tag pT threshold? -> functor struct
0070   inline double JET_TAUTAG_PERFECT(const Jet& j) { return j.tauTagged() ? 1 : 0; }
0071   /// Alias for JET_TAUTAG_PERFECT
0072   inline double JET_TAUTAG_IDENTITY(const Jet& j) { return JET_TAUTAG_PERFECT(j); }
0073
0074
0075   /// @brief b-tagging efficiency functor, for more readable b-tag effs and mistag rates
0076   ///
0077   /// @note Note the several constructors, allowing for optional specification of charm, tau, and light jet mistag rates.
0078   struct JET_BTAG_EFFS {
0079     JET_BTAG_EFFS(double eff_b, double eff_light=0) : _eff_b(eff_b), _eff_c(-1), _eff_t(-1), _eff_l(eff_light) { }
0080     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) { }
0081     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) { }
0082     inline double operator () (const Jet& j) {
0083       if (j.bTagged()) return _eff_b;
0084       if (_eff_c >= 0 && j.cTagged()) return _eff_c;
0085       if (_eff_t >= 0 && j.tauTagged()) return _eff_t;
0086       return _eff_l;
0087     }
0088     double _eff_b, _eff_c, _eff_t, _eff_l;
0089   };
0090
0091
0092   /// Take a jet and return an unmodified copy
0093   /// @todo Modify constituent particle vectors for consistency
0094   /// @todo Set a null PseudoJet if the Jet is smeared?
0095   inline Jet JET_SMEAR_IDENTITY(const Jet& j) { return j; }
0096   /// Alias for JET_SMEAR_IDENTITY
0097   inline Jet JET_SMEAR_PERFECT(const Jet& j) { return j; }
0098
0099
0100   /// @brief Functor for simultaneous efficiency-filtering and smearing of Jets
0101   ///
0102   /// A central element of the SmearedJets system
0103   ///
0104   /// @todo Include tagging efficiency functions?
0105   struct JetEffSmearFn {
0106     JetEffSmearFn(const JetSmearFn& s, const JetEffFn& e)
0107       : sfn(s), efn(e) {    }
0108
0109     JetEffSmearFn(const JetEffFn& e, const JetSmearFn& s)
0110       : sfn(s), efn(e) {    }
0111
0112     JetEffSmearFn(const JetSmearFn& s)
0113       : sfn(s), efn(JET_EFF_ONE) {    }
0114
0115     JetEffSmearFn(const JetEffFn& e)
0116       : sfn(JET_SMEAR_IDENTITY), efn(e) {    }
0117
0118     JetEffSmearFn(double eff)
0119       : JetEffSmearFn(JET_EFF_CONST(eff)) {    }
0120
0121     /// Smear and calculate an efficiency for the given jet
0122     pair<Jet,double> operator() (const Jet& j) const {
0123       return make_pair(sfn(j), efn(j));
0124     }
0125
0126     /// Compare to another, for use in the projection system
0127     CmpState cmp(const JetEffSmearFn& other) const {
0128       // cout << "Eff hashes = " << get_address(efn) << "," << get_address(other.efn) << "; "
0129       //      << "smear hashes = " << get_address(sfn) << "," << get_address(other.sfn) << '\n';
0130       if (get_address(sfn) == 0 || get_address(other.sfn) == 0) return CmpState::NEQ;
0131       if (get_address(efn) == 0 || get_address(other.efn) == 0) return CmpState::NEQ;
0132       return Rivet::cmp(get_address(sfn), get_address(other.sfn)) || Rivet::cmp(get_address(efn), get_address(other.efn));
0133     }
0134
0135     /// Automatic conversion to a smearing function
0136     operator JetSmearFn () { return sfn; }
0137     /// Automatic conversion to an efficiency function
0138     /// @todo Ambiguity re. whether reco eff or a tagging efficiency...
0139     // operator JetEffFn () { return efn; }
0140
0141     // Stored functions/functors
0142     JetSmearFn sfn;
0143     JetEffFn efn;
0144   };
0145
0146
0147   /// Return true if Jet @a j is chosen to survive a random efficiency selection
0148   template <typename FN>
0149   inline bool efffilt(const Jet& j, FN& feff) {
0150     return rand01() < feff(j);
0151   }
0152
0153   /// A functor to return true if Jet @a j survives a random efficiency selection
0154   struct JetEffFilter {
0155     template <typename FN>
0156     JetEffFilter(const FN& feff) : _feff(feff) {}
0157     JetEffFilter(double eff) : JetEffFilter( [&](const Jet&){return eff;} ) {}
0158     bool operator () (const Jet& j) const { return efffilt(j, _feff); }
0159   private:
0160     const JetEffFn _feff;
0161   };
0162   using jetEffFilter = JetEffFilter;
0163
0164   /// @}
0165
0166   /// @}
0167
0168 }
0169
0170 #endif