BTagCalibrationReader::BTagCalibrationReaderImpl

Collaboration diagram for BTagCalibrationReader::BTagCalibrationReaderImpl:

Classes
struct	TmpEntry

Private Member Functions
	BTagCalibrationReaderImpl (BTagEntry::OperatingPoint op, const std::string &sysType, const std::vector< std::string > &otherSysTypes={})
void	load (const BTagCalibration &c, BTagEntry::JetFlavor jf, std::string measurementType)
double	eval (BTagEntry::JetFlavor jf, float eta, float pt, float discr) const
double	eval_auto_bounds (const std::string &sys, BTagEntry::JetFlavor jf, float eta, float pt, float discr) const
std::pair< float, float >	min_max_pt (BTagEntry::JetFlavor jf, float eta, float discr) const
std::pair< float, float >	min_max_eta (BTagEntry::JetFlavor jf, float discr) const

Private Attributes
BTagEntry::OperatingPoint	op_
std::string	sysType_
std::map< BTagEntry::JetFlavor, std::vector< TmpEntry > >	tmpData_
std::map< std::string, std::shared_ptr< BTagCalibrationReaderImpl > >	otherSysTypeReaders_

Friends
class	BTagCalibrationReader

Constructor & Destructor Documentation

BTagCalibrationReaderImpl()

BTagCalibrationReaderImpl ( BTagEntry::OperatingPoint  op, const std::string &  sysType, const std::vector< std::string > &  otherSysTypes = {}  )

private

                                                                                        :
  op_(op),
  sysType_(sysType)
{
  for (const std::string & ost : otherSysTypes) {
    if (otherSysTypeReaders_.count(ost)) {
std::cerr << "ERROR in BTagCalibration: "
            << "Every otherSysType should only be given once. Duplicate: "
            << ost;
throw std::exception();
    }
    otherSysTypeReaders_[ost] = std::auto_ptr<BTagCalibrationReaderImpl>(
        new BTagCalibrationReaderImpl(op, ost)
    );
  }
}

Member Function Documentation

eval()

double eval ( BTagEntry::JetFlavor  jf, float  eta, float  pt, float  discr  ) const

private

{
  bool use_discr = (op_ == BTagEntry::OP_RESHAPING);
 
  // search linearly through eta, pt and discr ranges and eval
  // future: find some clever data structure based on intervals
  const auto &entries = tmpData_.at(jf);
  for (unsigned i=0; i<entries.size(); ++i) {
    const auto &e = entries.at(i);
    if (
      e.etaMin <= eta && eta <= e.etaMax                   // find eta
      && e.ptMin < pt && pt <= e.ptMax                    // check pt
    ){
      if (use_discr) {                                    // discr. reshaping?
        if (e.discrMin <= discr && discr < e.discrMax) {  // check discr
          return e.func.Eval(discr);
        }
      } else {
        return e.func.Eval(pt);
      }
    }
  }
 
  return 0.;  // default value
}

eval_auto_bounds()

double eval_auto_bounds ( const std::string &  sys, BTagEntry::JetFlavor  jf, float  eta, float  pt, float  discr  ) const

private

{
  auto sf_bounds_eta = min_max_eta(jf, discr);
  bool eta_is_out_of_bounds = false;
 
  if (sf_bounds_eta.first < 0) sf_bounds_eta.first = -sf_bounds_eta.second;   
  if (eta <= sf_bounds_eta.first || eta > sf_bounds_eta.second ) {
    eta_is_out_of_bounds = true;
  }
   
  if (eta_is_out_of_bounds) {
    return 1.;
  }
 
 
   auto sf_bounds = min_max_pt(jf, eta, discr);
   float pt_for_eval = pt;
   bool is_out_of_bounds = false;
 
   if (pt <= sf_bounds.first) {
    pt_for_eval = sf_bounds.first + .0001;
    is_out_of_bounds = true;
  } else if (pt > sf_bounds.second) {
    pt_for_eval = sf_bounds.second - .0001;
    is_out_of_bounds = true;
  }
 
  // get central SF (and maybe return)
  double sf = eval(jf, eta, pt_for_eval, discr);
  if (sys == sysType_) {
    return sf;
  }
 
  // get sys SF (and maybe return)
  if (!otherSysTypeReaders_.count(sys)) {
std::cerr << "ERROR in BTagCalibration: "
        << "sysType not available (maybe not loaded?): "
        << sys;
throw std::exception();
  }
  double sf_err = otherSysTypeReaders_.at(sys)->eval(jf, eta, pt_for_eval, discr);
  if (!is_out_of_bounds) {
    return sf_err;
  }
 
  // double uncertainty on out-of-bounds and return
  sf_err = sf + 2*(sf_err - sf);
  return sf_err;
}

load()

void load ( const BTagCalibration &  c, BTagEntry::JetFlavor  jf, std::string  measurementType  )

private

{
  if (tmpData_[jf].size()) {
std::cerr << "ERROR in BTagCalibration: "
          << "Data for this jet-flavor is already loaded: "
          << jf;
throw std::exception();
  }
 
  BTagEntry::Parameters params(op_, measurementType, sysType_);
  const std::vector<BTagEntry> &entries = c.getEntries(params);
 
  for (const auto &be : entries) {
    if (be.params.jetFlavor != jf) {
      continue;
    }
 
    TmpEntry te;
    te.etaMin = be.params.etaMin;
    te.etaMax = be.params.etaMax;
    te.ptMin = be.params.ptMin;
    te.ptMax = be.params.ptMax;
    te.discrMin = be.params.discrMin;
    te.discrMax = be.params.discrMax;
 
    if (op_ == BTagEntry::OP_RESHAPING) {
      te.func = TF1("", be.formula.c_str(),
                    be.params.discrMin, be.params.discrMax);
    } else {
      te.func = TF1("", be.formula.c_str(),
                    be.params.ptMin, be.params.ptMax);
    }
 
    tmpData_[be.params.jetFlavor].push_back(te);
  }
 
  for (auto & p : otherSysTypeReaders_) {
    p.second->load(c, jf, measurementType);
  }
}

min_max_eta()

std::pair< float, float > min_max_eta ( BTagEntry::JetFlavor  jf, float  discr  ) const

private

{
  bool use_discr = (op_ == BTagEntry::OP_RESHAPING);
 
  const auto &entries = tmpData_.at(jf);
  float min_eta = 0., max_eta = 0.;
  for (const auto & e: entries) {
 
      if (use_discr) {                                    // discr. reshaping?
        if (e.discrMin <= discr && discr < e.discrMax) {  // check discr
          min_eta = min_eta < e.etaMin ? min_eta : e.etaMin;
          max_eta = max_eta > e.etaMax ? max_eta : e.etaMax;
        }
      } else {
        min_eta = min_eta < e.etaMin ? min_eta : e.etaMin;
        max_eta = max_eta > e.etaMax ? max_eta : e.etaMax;
      }
    }
 
 
  return std::make_pair(min_eta, max_eta);
}

min_max_pt()

std::pair< float, float > min_max_pt ( BTagEntry::JetFlavor  jf, float  eta, float  discr  ) const

private

{
  bool use_discr = (op_ == BTagEntry::OP_RESHAPING);
 
  const auto &entries = tmpData_.at(jf);
  float min_pt = -1., max_pt = -1.;
  for (const auto & e: entries) {
    if (
      e.etaMin <= eta && eta <=e.etaMax                   // find eta
    ){
      if (min_pt < 0.) {                                  // init
        min_pt = e.ptMin;
        max_pt = e.ptMax;
        continue;
      }
 
      if (use_discr) {                                    // discr. reshaping?
        if (e.discrMin <= discr && discr < e.discrMax) {  // check discr
          min_pt = min_pt < e.ptMin ? min_pt : e.ptMin;
          max_pt = max_pt > e.ptMax ? max_pt : e.ptMax;
        }
      } else {
        min_pt = min_pt < e.ptMin ? min_pt : e.ptMin;
        max_pt = max_pt > e.ptMax ? max_pt : e.ptMax;
      }
    }
  }
 
  return std::make_pair(min_pt, max_pt);
}

Friends And Related Function Documentation

BTagCalibrationReader

friend class BTagCalibrationReader

friend

Member Data Documentation

op_

BTagEntry::OperatingPoint op_

private

otherSysTypeReaders_

std::map<std::string, std::shared_ptr<BTagCalibrationReaderImpl> > otherSysTypeReaders_

private

sysType_

std::string sysType_

private

tmpData_

std::map<BTagEntry::JetFlavor,std::vector<TmpEntry> > tmpData_

private

---

The documentation for this class was generated from the following file:

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/BTagging/src/BTagCalibration.cc