CalibrationDataInterfaceROOT.cxx File Reference

#include "CalibrationDataInterface/CalibrationDataInterfaceROOT.h"
#include "CalibrationDataInterface/CalibrationDataContainer.h"
#include "CalibrationDataInterface/CalibrationDataEigenVariations.h"
#include "CalibrationDataInterface/CalibrationDataInternals.h"
#include <boost/algorithm/string.hpp>
#include "TMath.h"
#include "TEnv.h"
#include "TFile.h"
#include "TObjString.h"
#include <iostream>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <cstring>

Go to the source code of this file.

Typedefs
typedef std::pair< double, double >	UncertaintyResult
	The following typedef is for convenience: most uncertainties can be asymmetric.

Functions
	ClassImp (Analysis::CalibrationDataInterfaceROOT) Analysis
std::vector< std::string >	split (const std::string &str, const char token=';')
	local utility function: split string into a vector of substrings separated by a specified separator, and with whitespace in the results trimmed

Typedef Documentation

UncertaintyResult

typedef std::pair<double, double> Analysis::UncertaintyResult

The following typedef is for convenience: most uncertainties can be asymmetric.

The pair holds the positive (first) and negative (second) uncertainties. Note that in the context of systematic uncertainties, "positive" and "negative" may reflect what happens if the uncertainty parameter is varied. This means that the "positive" uncertainty result may be negative etc.

Definition at line 33 of file CalibrationDataContainer.h.

Function Documentation

ClassImp()

ClassImp

(

Analysis::CalibrationDataInterfaceROOT

)

Definition at line 289 of file CalibrationDataInterfaceROOT.cxx.

                                                                                                                                                   :
  m_runEigenVectorMethod(false), m_EVStrategy(SFEigen), m_useRecommendedEVExclusions(false), m_verbose(true),
  m_absEtaStrategy(GiveUp), m_otherStrategy(Flag)
{
  // Normal constructor.
  //
  //     taggerName:  this should correspond to the tagger name as used in the calibration ROOT file
  //     configname:  full name of the configuration file
  //     pathname:    directory specification for separate scale factor or efficiency ROOT file
 
  m_taggerName = taggerName;
 
  TEnv env;
  env.ReadFile(configname.c_str(),kEnvGlobal);
 
 
  // ROOT file containing the calibrations
  TString filename = env.GetValue("File", "BTaggingPerformanceCalibrations.root");
  m_filenameEff = string(env.GetValue("FileEff", "")); trim(m_filenameEff);
  m_filenameSF =  string(env.GetValue("FileSF", ""));  trim(m_filenameSF);
  if (m_filenameEff == "") {
    m_filenameEff = pathname + filename.Data();
  }
  if (m_filenameSF == "") {
    m_filenameSF = pathname + filename.Data();
  }
 
  if (m_verbose) {
    cout << "=== CalibrationDataInterfaceROOT::CalibrationDataInterfaceROOT ===" << endl;
    cout << " Config name          : " << configname << endl;
    cout << " taggerName           : " << taggerName << endl;
    cout << " Efficiency file name : " << m_filenameEff << endl 
     << " SF         file name : " << m_filenameSF << endl;
  }
 
  m_fileEff = TFile::Open(m_filenameEff.c_str(), "READ");
  if (m_filenameEff == m_filenameSF)
    m_fileSF = m_fileEff;
  else
    m_fileSF = TFile::Open(m_filenameSF.c_str(), "READ");
 
  if (m_verbose) {
    TObjString* s;
    m_fileSF->GetObject("VersionInfo/BuildNumber", s);
    if (s) cout << " CDI file build number: " << s->GetName() << endl;
    cout << endl;
  }
 
  m_flavours = { "B", "C", "T", "Light" };
  string testPrefix(taggerName); testPrefix += ".";
 
  // Since TEnv doesn't allow for straight retrieval of vectors of strings, expect
  // semicolon-separated entries (semicolon because ROOT considers this as a "special"
  // token anyway in object names).
  string::size_type end;
 
  // Calibration names for the efficiencies
  std::map<string, std::vector<string> > effNames;
  for (auto const& flavour : m_flavours) {
    string test(testPrefix); test += "EfficiencyCalibration"; test += flavour; test += "Name";
    effNames[flavour] = split(string(env.GetValue(test.c_str(), "default")));
  }
  setEffCalibrationNames(effNames);
 
  // Calibration names for the efficiency scale factors
  std::map<string, string> SFNames;
  for (auto const& flavour : m_flavours) {
    string test(testPrefix); test += "ScaleFactorCalibration"; test += flavour; test += "Name";
    SFNames[flavour] = string(env.GetValue(test.c_str(), "default")); trim(SFNames[flavour]);
  }
  setSFCalibrationNames(SFNames);
 
  // Since TEnv doesn't allow for straight retrieval of vectors of strings, expect
  // semicolon-separated entries (semicolon because ROOT considers this as a "special"
  // token anyway in object names).
  // Don't prefix this since the aliases are common to all taggers (even if they are read again for each tagger).
  string AL(env.GetValue("aliases", ""));
  if (AL.size() > 0) {
    do {
      end = AL.find(";");
      string alias = AL.substr(0, end);
      // Each alias specification uses an arrow ("->"). Forget about entries
      // not properly following this specification.
      // NB: TEnv imposes a maximum string length of 1024 characters -- is this a problem?
      string::size_type arrow = alias.find("->");
      if (arrow == string::npos) continue;
      string target = alias.substr(0,arrow); trim(target);
      m_aliases[target] = alias.substr(arrow+2); trim(m_aliases[target]);
      if (end != string::npos) AL = AL.substr(end+1);
    } while (end != string::npos);
  }
 
  //run egenvector method or not?
  string test="runEigenVectorMethod";
  m_runEigenVectorMethod=(bool)env.GetValue(test.c_str(),0);
 
  if (m_runEigenVectorMethod) {
    // Retrieve the list of systematic uncertainties not to be considered when building up 
    // the full covariance matrix used for the eigenvector method.
    // We do this in two steps: first, for backward compatibility reasons, a flavour-independent list is scanned.
    // Second, flavour-specific lists are scanned.
    test = "excludeFromCovMatrix";
    std::vector<std::string> to_exclude = split(env.GetValue(test.c_str(), ""));
    // Copy the resulting list to all flavours
    for (auto const& flavour : m_flavours) {
      m_excludeFromCovMatrix[flavour] = to_exclude;
    }
    for (auto const& flavour : m_flavours) {
      test = "excludeFrom"; test += flavour; test += "CovMatrix";
      to_exclude = split(env.GetValue(test.c_str(), ""));
      // Append to the existing list
      m_excludeFromCovMatrix[flavour].insert(m_excludeFromCovMatrix[flavour].end(), to_exclude.begin(), to_exclude.end());
    }
    
    unsigned int n_excluded = 0;
    for (auto const& flavour : m_flavours) {
      n_excluded += m_excludeFromCovMatrix[flavour].size();
    }
    if (m_verbose) {
      cout << " List of uncertainties to exclude:";
      if (n_excluded == 0) cout << " none";
      for (auto const& flavour : m_flavours) {
    if (m_excludeFromCovMatrix[flavour].size() > 0) {
      cout << "\n\t" << flavour << ":\t";
      for (unsigned int i = 0; i < m_excludeFromCovMatrix[flavour].size(); ++i) {
        cout << m_excludeFromCovMatrix[flavour].at(i);
        if (i+1 == m_excludeFromCovMatrix[flavour].size()) cout << ";  ";
      }
      cout << endl;
    }
      }
      cout << endl;
    }
 
    // The following determines whether also pre-determined (recommended) lists of uncertainties are to be excluded from EV decomposition.
    // These lists are stored with the CalibrationDataContainers, which have not been instantiated yet (so we cannot show them at this point).
    m_useRecommendedEVExclusions = (bool) env.GetValue("ExcludeRecommendedFromEigenVectorTreatment", false);
    
    // determine also the eigenvector reduction strategies
    std::map<string, EVReductionStrategy> mappings;
    mappings["Loose"] = Loose;
    mappings["Medium"] = Medium;
    mappings["Tight"] = Tight;
    for (auto const& flavour : m_flavours) {
      test = testPrefix; test += "EigenvectorReduction"; test += flavour;
      std::string reduction = string(env.GetValue(test.c_str(), "Loose")); trim(reduction);
      m_EVReductions[flavour] = mappings.find(reduction) == mappings.end() ? mappings["Loose"] : mappings.find(reduction)->second;
    }
  }
 
  // determine |eta| validity range
  m_maxAbsEta = env.GetValue("MaxAbsEta", 2.5);
  if (m_maxAbsEta < 0) m_maxAbsEta = 2.5;
 
  // set validation / protection strategy in case an out-of-bounds eta value is specified
  string strategy = string(env.GetValue("OutOfBoundsEta", "GiveUp")); trim(strategy);
  if (strategy == "GiveUp") m_absEtaStrategy = GiveUp;
  else if (strategy == "Flag") m_absEtaStrategy = Flag;
  else if (strategy == "Ignore") m_absEtaStrategy = Ignore;
  else {
    cerr << "unknown |eta| extrapolation strategy: " << strategy << ", setting to GiveUp" << endl;
    m_absEtaStrategy = GiveUp;
  }
 
  // set validation / protection strategy in case out-of-bounds variables are specified
  strategy = string(env.GetValue("OutOfBoundsOther", "Flag")); trim(strategy);
  if (strategy == "GiveUp") m_otherStrategy = GiveUp;
  else if (strategy == "GiveUpExtrapolated") m_otherStrategy = GiveUpExtrapolated;
  else if (strategy == "Flag") m_otherStrategy = Flag;
  else if (strategy == "Ignore") m_otherStrategy = Ignore;
  else {
    cerr << "unknown general extrapolation strategy: " << strategy << ", setting to Flag" << endl;
    m_otherStrategy = Flag;
  }
 
  // maximum tag weight to accept
  m_maxTagWeight = env.GetValue("MaxTagWeight", 10.0);
 
  // MC/MC (hadronisation) scale factors: making this user-steerable is intended to be *temporary* only
  m_useMCMCSF = (bool) env.GetValue("useMCMCSF", 1);
  // MC/MC (topology) scale factors: making this user-steerable is intended to be *temporary* only
  m_useTopologyRescaling = (bool) env.GetValue("useTopologySF", 0);
 
  if (m_verbose) cout << "======= end of CalibrationDataInterfaceROOT instantiation ========" << endl;
}

split()

std::vector< std::string > Analysis::CalibrationDataInterface::split	(	const std::string &	str,
		const char	token = ';' )

local utility function: split string into a vector of substrings separated by a specified separator, and with whitespace in the results trimmed

Definition at line 9 of file CalibrationDataInternals.cxx.

                                                                       {
      std::vector<std::string> result;
      boost::split(result, str, [&token] (char c) { return c == token ;});
      for (std::string& element : result) {
    boost::trim(element);
      }
      return result;
    }