BTagEntry

Description

BTagEntry

Represents one pt- or discriminator-dependent calibration function.

measurement_type: e.g. comb, ttbar, di-mu, boosted, ... sys_type: e.g. central, plus, minus, plus_JEC, plus_JER, ...

Everything is converted into a function, as it is easiest to store it in a txt or json file.

#include <BTagCalibration.h>

Collaboration diagram for BTagEntry:

Classes
struct	Parameters

Public Types
enum	OperatingPoint { OP_LOOSE =0, OP_MEDIUM =1, OP_TIGHT =2, OP_RESHAPING =3 }
enum	JetFlavor { FLAV_B =5, FLAV_C =4, FLAV_UDSG =0 }

Public Member Functions
	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 ()
std::string	makeCSVLine () const

Static Public Member Functions
static std::string	makeCSVHeader ()
static std::string	trimStr (std::string str)

Public Attributes
std::string	formula
Parameters	params

Member Enumeration Documentation

JetFlavor

enum JetFlavor

Enumerator
FLAV_B
FLAV_C
FLAV_UDSG

                 { // modified from original code to match UL convention
    FLAV_B=5, // previously 0
    FLAV_C=4, // previsouly 1
    FLAV_UDSG=0, // previsouly 2
  };

OperatingPoint

enum OperatingPoint

Enumerator
OP_LOOSE
OP_MEDIUM
OP_TIGHT
OP_RESHAPING

                      {
    OP_LOOSE=0,
    OP_MEDIUM=1,
    OP_TIGHT=2,
    OP_RESHAPING=3,
  };

Constructor & Destructor Documentation

BTagEntry() [1/5]

BTagEntry ( )

inline

{}

BTagEntry() [2/5]

BTagEntry

(

const std::string &

csvLine

)

{
  // make tokens
  std::stringstream buff(csvLine);
  std::vector<std::string> vec;
  std::string token;
  while (std::getline(buff, token, ","[0])) {
    token = BTagEntry::trimStr(token);
    if (token.empty()) {
      continue;
    }
    vec.push_back(token);
  }
  if (vec.size() != 11) {
std::cerr << "ERROR in BTagCalibration: "
          << "Invalid csv line; num tokens != 11: "
          << csvLine;
throw std::exception();
  }
 
  // clean string values
  char chars[] = " \"\n";
  for (unsigned int i = 0; i < strlen(chars); ++i) {
    vec[1].erase(remove(vec[1].begin(),vec[1].end(),chars[i]),vec[1].end());
    vec[2].erase(remove(vec[2].begin(),vec[2].end(),chars[i]),vec[2].end());
    vec[10].erase(remove(vec[10].begin(),vec[10].end(),chars[i]),vec[10].end());
  }
 
  // make formula
  formula = vec[10];
  TF1 f1("", formula.c_str());  // compile formula to check validity
  if (f1.IsZombie()) {
std::cerr << "ERROR in BTagCalibration: "
          << "Invalid csv line; formula does not compile: "
          << csvLine;
throw std::exception();
  }
 
  // make parameters
  unsigned op = stoi(vec[0]);
  if (op > 3) {
std::cerr << "ERROR in BTagCalibration: "
          << "Invalid csv line; OperatingPoint > 3: "
          << csvLine;
throw std::exception();
  }
  unsigned jf = stoi(vec[3]);
  if (jf != FLAV_B && jf != FLAV_C && jf != FLAV_UDSG) { // modified from original code to match UL convention
std::cerr << "ERROR in BTagCalibration: "
          << "Invalid csv line; JetFlavor has none of the known values: "
          << csvLine;
throw std::exception();
  }
  params = BTagEntry::Parameters(
    BTagEntry::OperatingPoint(op),
    vec[1],
    vec[2],
    BTagEntry::JetFlavor(jf),
    stof(vec[4]),
    stof(vec[5]),
    stof(vec[6]),
    stof(vec[7]),
    stof(vec[8]),
    stof(vec[9])
  );
}

BTagEntry() [3/5]

BTagEntry	(	const std::string &	func,
		BTagEntry::Parameters	p
	)

                                                                :
  formula(func),
  params(p)
{
  TF1 f1("", formula.c_str());  // compile formula to check validity
  if (f1.IsZombie()) {
std::cerr << "ERROR in BTagCalibration: "
          << "Invalid func string; formula does not compile: "
          << func;
throw std::exception();
  }
}

BTagEntry() [4/5]

BTagEntry	(	const TF1 *	func,
		BTagEntry::Parameters	p
	)

                                                          :
  formula(std::string(func->GetExpFormula("p").Data())),
  params(p)
{
  if (func->IsZombie()) {
std::cerr << "ERROR in BTagCalibration: "
          << "Invalid TF1 function; function is zombie: "
          << func->GetName();
throw std::exception();
  }
}

BTagEntry() [5/5]

BTagEntry	(	const TH1 *	histo,
		BTagEntry::Parameters	p
	)

                                                          :
  params(p)
{
  int nbins = hist->GetNbinsX();
  TAxis const* axis = hist->GetXaxis();
 
  // overwrite bounds with histo values
  if (params.operatingPoint == BTagEntry::OP_RESHAPING) {
    params.discrMin = axis->GetBinLowEdge(1);
    params.discrMax = axis->GetBinUpEdge(nbins);
  } else {
    params.ptMin = axis->GetBinLowEdge(1);
    params.ptMax = axis->GetBinUpEdge(nbins);
  }
 
  // balanced full binary tree height = ceil(log(2*n_leaves)/log(2))
  // breakes even around 10, but lower values are more propable in pt-spectrum
  if (nbins < 15) {
    formula = th1ToFormulaLin(hist);
  } else {
    formula = th1ToFormulaBinTree(hist);
  }
 
  // compile formula to check validity
  TF1 f1("", formula.c_str());
  if (f1.IsZombie()) {
std::cerr << "ERROR in BTagCalibration: "
          << "Invalid histogram; formula does not compile (>150 bins?): "
          << hist->GetName();
throw std::exception();
  }
}

~BTagEntry()

~BTagEntry ( )

inline

{}

Member Function Documentation

makeCSVHeader()

std::string makeCSVHeader ( )

static

{
  return "OperatingPoint, "
         "measurementType, "
         "sysType, "
         "jetFlavor, "
         "etaMin, "
         "etaMax, "
         "ptMin, "
         "ptMax, "
         "discrMin, "
         "discrMax, "
         "formula \n";
}

makeCSVLine()

std::string makeCSVLine

(

)

const

{
  std::stringstream buff;
  buff << params.operatingPoint
       << ", " << params.measurementType
       << ", " << params.sysType
       << ", " << params.jetFlavor
       << ", " << params.etaMin
       << ", " << params.etaMax
       << ", " << params.ptMin
       << ", " << params.ptMax
       << ", " << params.discrMin
       << ", " << params.discrMax
       << ", \"" << formula
       << "\" \n";
  return buff.str();
}

trimStr()

std::string trimStr ( std::string  str )

static

                                          {
  size_t s = str.find_first_not_of(" \n\r\t");
  size_t e = str.find_last_not_of (" \n\r\t");
 
  if((std::string::npos == s) || (std::string::npos == e))
    return "";
  else
    return str.substr(s, e-s+1);
}

Member Data Documentation

formula

std::string formula

params

Parameters params

---

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

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