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.

Functions
	ClassImp (Analysis::CalibrationDataInterfaceROOT) Analysis

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;
}