BTagCalibration.h

Go to the documentation of this file.

#ifndef BTagEntry_H
#define BTagEntry_H
 
#include <string>
#include <TF1.h>
#include <TH1.h>
 
 
class BTagEntry
{
public:
  enum OperatingPoint {
    OP_LOOSE=0,
    OP_MEDIUM=1,
    OP_TIGHT=2,
    OP_RESHAPING=3,
  };
  enum JetFlavor { // modified from original code to match UL convention
    FLAV_B=5, // previously 0
    FLAV_C=4, // previsouly 1
    FLAV_UDSG=0, // previsouly 2
  };
  struct Parameters {
    OperatingPoint operatingPoint;
    std::string measurementType;
    std::string sysType;
    JetFlavor jetFlavor;
    float etaMin;
    float etaMax;
    float ptMin;
    float ptMax;
    float discrMin;
    float discrMax;
 
    // default constructor
    Parameters(
      OperatingPoint op=OP_TIGHT,
      std::string measurement_type="comb",
      std::string sys_type="central",
      JetFlavor jf=FLAV_B,
      float eta_min=-99999.,
      float eta_max=99999.,
      float pt_min=0.,
      float pt_max=99999.,
      float discr_min=0.,
      float discr_max=99999.
    );
 
  };
 
  BTagEntry() {}
  BTagEntry(const std::string &csvLine);
  BTagEntry(const std::string &func, Parameters p);
  BTagEntry(const TF1* func, Parameters p);
  BTagEntry(const TH1* histo, Parameters p);
  ~BTagEntry() {}
  static std::string makeCSVHeader();
  std::string makeCSVLine() const;
  static std::string trimStr(std::string str);
 
  // public, no getters needed
  std::string formula;
  Parameters params;
 
};
 
#endif  // BTagEntry_H
 
 
#ifndef BTagCalibration_H
#define BTagCalibration_H
 
#include <map>
#include <vector>
#include <string>
#include <istream>
#include <ostream>
 
 
class BTagCalibration
{
public:
  BTagCalibration() {}
  BTagCalibration(const std::string &tagger);
  BTagCalibration(const std::string &tagger, const std::string &filename);
  ~BTagCalibration() {}
 
  std::string tagger() const {return tagger_;}
 
  void addEntry(const BTagEntry &entry);
  const std::vector<BTagEntry>& getEntries(const BTagEntry::Parameters &par) const;
 
  void readCSV(std::istream &s);
  void readCSV(const std::string &s);
  void makeCSV(std::ostream &s) const;
  std::string makeCSV() const;
 
protected:
  static std::string token(const BTagEntry::Parameters &par);
 
  std::string tagger_;
  std::map<std::string, std::vector<BTagEntry> > data_;
 
};
 
#endif  // BTagCalibration_H
 
 
#ifndef BTagCalibrationReader_H
#define BTagCalibrationReader_H
 
#include <memory>
#include <string>
 
 
 
class BTagCalibrationReader
{
public:
  class BTagCalibrationReaderImpl;
 
  BTagCalibrationReader() {}
  BTagCalibrationReader(BTagEntry::OperatingPoint op,
                        const std::string & sysType="central",
                        const std::vector<std::string> & otherSysTypes={});
 
  void load(const BTagCalibration & c,
            BTagEntry::JetFlavor jf,
            const std::string & measurementType="comb");
 
  double eval(BTagEntry::JetFlavor jf,
              float eta,
              float pt,
              float discr=0.) const;
 
  double eval_auto_bounds(const std::string & sys,
                          BTagEntry::JetFlavor jf,
                          float eta,
                          float pt,
                          float discr=0.) const;
 
  std::pair<float, float> min_max_pt(BTagEntry::JetFlavor jf,
                                     float eta,
                                     float discr=0.) const;
protected:
  std::shared_ptr<BTagCalibrationReaderImpl> pimpl;
};
 
 
#endif  // BTagCalibrationReader_H