Root::TElectronEfficiencyCorrectionTool Class Reference

#include <TElectronEfficiencyCorrectionTool.h>

Inheritance diagram for Root::TElectronEfficiencyCorrectionTool:

Collaboration diagram for Root::TElectronEfficiencyCorrectionTool:

Classes
struct	Result
struct	HistEdge

Public Types
using	HistArray = std::vector<std::unique_ptr<TH1>>

Public Member Functions
	TElectronEfficiencyCorrectionTool (const char *name="TElectronEfficiencyCorrectionTool")
	Standard constructor.
	~TElectronEfficiencyCorrectionTool ()=default
	Standard destructor.
void	addFileName (const std::string &val)
	This is more of an utility so the initialize is different wrt to an athena component.
void	bookToyMCScaleFactors (const int nToyMC)
	Running these before the initialize will setup the booking of toys.
void	bookCombToyMCScaleFactors (const int nToyMC)
int	initialize ()
	Initialize this class.
int	calculate (const PATCore::ParticleDataType::DataType dataType, const unsigned int runnumber, const double cluster_eta, const double et, Result &result, const bool onlyTotal=false) const
	The main calculate method: dataType PATCore::ParticleDataType::DataType (e.g DATA,FULL etc) @ runnumber the run number.
int	getNbins (std::map< float, std::vector< float > > &ptEta) const
	Helpers to get the binning of the uncertainties in a std::map (pt, eta).
int	getNSyst () const
	get number of systematics
void	setSeed (const unsigned long int seed)
	Set the Random Seed.
bool	uncorrEmpty (const PATCore::ParticleDataType::DataType dataType)
	Check if stat+uncorr has input.
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Member Functions
int	getHistograms ()
	Load all histograms from the input file(s).
int	setupHistogramsInFolder (const TObjArray &dirNameArray, int lastIdx)
bool	setupUncorrToySyst (std::vector< std::vector< TH1 * > > &objs, std::vector< std::vector< TH1 * > > &sysObjs, std::vector< std::vector< HistArray > > &uncorrToyMCSyst)
std::vector< HistArray >	buildToyMCTable (const std::vector< TH1 * > &sf, const std::vector< TH1 * > &eig, const std::vector< TH1 * > &stat, const std::vector< TH1 * > &uncorr, const std::vector< std::vector< TH1 * > > &corr)
std::vector< TH2 * >	buildSingleToyMC (const TH1 *sf, const TH1 *stat, const TH1 *uncorr, const std::vector< TH1 * > &corr, int &randomCounter)
TH2 *	buildSingleCombToyMC (const TH1 *sf, const TH1 *stat, const TH1 *uncorr, const std::vector< TH1 * > &corr, const int nSys, int &randomCounter)
void	setupTempMapsHelper (TH1 *obj, std::vector< std::vector< TH1 * > > &objs, std::vector< std::vector< TH1 * > > &sysObjs, int &seenSystematics)
int	setup (const std::vector< TH1 * > &hists, std::vector< HistArray > &histList, std::vector< unsigned int > &beginRunNumberList, std::vector< unsigned int > &endRunNumberList, const int runNumBegin, const int runNumEnd) const
	Fill and interpret the setup, depending on which histograms are found in the input file(s).
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static void	fillHistEdges (const std::vector< HistArray > &sfPerPeriodHist, std::vector< std::vector< HistEdge > > &sfPerPeriodEdges)

Private Attributes
bool	m_doToyMC
	Flag to control Toys.
bool	m_doCombToyMC
int	m_nToyMC
	The number of toys.
unsigned long int	m_seed
	The Random seed.
int	m_nSysMax
	Maximum number of systematics.
std::vector< std::vector< HistArray > >	m_uncorrToyMCSystFull
std::vector< std::vector< HistArray > >	m_uncorrToyMCSystFast
std::vector< std::string >	m_corrFileNameList
	The list of file name(s).
std::vector< unsigned int >	m_begRunNumberList
	List of run numbers where histograms become valid for full simulation.
std::vector< unsigned int >	m_endRunNumberList
	List of run numbers where histograms stop being valid for full simulation.
std::vector< unsigned int >	m_begRunNumberListFastSim
	List of run numbers where histograms become valid for fast simulation.
std::vector< unsigned int >	m_endRunNumberListFastSim
	List of run numbers where histograms stop being valid for fast simulation.
std::vector< std::vector< HistArray > >	m_histList
	List of histograms for full Geant4 simulation.
std::vector< std::vector< HistEdge > >	m_histEdges
std::vector< std::vector< HistArray > >	m_sysList
std::vector< std::vector< HistArray > >	m_fastHistList
	List of histograms for fast simulation.
std::vector< std::vector< HistEdge > >	m_fastHistEdges
std::vector< std::vector< HistArray > >	m_fastSysList
TRandom3	m_Rndm
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 35 of file TElectronEfficiencyCorrectionTool.h.

Member Typedef Documentation

HistArray

using Root::TElectronEfficiencyCorrectionTool::HistArray = std::vector<std::unique_ptr<TH1>>

Definition at line 39 of file TElectronEfficiencyCorrectionTool.h.

Constructor & Destructor Documentation

TElectronEfficiencyCorrectionTool()

TElectronEfficiencyCorrectionTool::TElectronEfficiencyCorrectionTool

(

const char *

name = "TElectronEfficiencyCorrectionTool"

)

Standard constructor.

Definition at line 72 of file TElectronEfficiencyCorrectionTool.cxx.

  : asg::AsgMessaging(std::string(name))
  , m_doToyMC(false)
  , m_doCombToyMC(false)
  , m_nToyMC(0)
  , m_seed(0)
  , m_nSysMax(0)
  , m_histList{ mapkey::end }
  , m_fastHistList{ mapkey::end }
  , m_Rndm()
{
}

~TElectronEfficiencyCorrectionTool()

Root::TElectronEfficiencyCorrectionTool::~TElectronEfficiencyCorrectionTool ( )

default

Standard destructor.

Member Function Documentation

addFileName()

void Root::TElectronEfficiencyCorrectionTool::addFileName ( const std::string & val )

inline

This is more of an utility so the initialize is different wrt to an athena component.

Add an input file with the auxiliary measurement needed before we call initialize

Definition at line 66 of file TElectronEfficiencyCorrectionTool.h.

                                                {
    m_corrFileNameList.push_back(val);
  }

bookCombToyMCScaleFactors()

void Root::TElectronEfficiencyCorrectionTool::bookCombToyMCScaleFactors ( const int nToyMC )

inline

Definition at line 75 of file TElectronEfficiencyCorrectionTool.h.

                                                          {
    m_doCombToyMC = true;
    m_nToyMC = nToyMC;
  }

bookToyMCScaleFactors()

void Root::TElectronEfficiencyCorrectionTool::bookToyMCScaleFactors ( const int nToyMC )

inline

Running these before the initialize will setup the booking of toys.

Definition at line 71 of file TElectronEfficiencyCorrectionTool.h.

                                                      {
    m_doToyMC = true;
    m_nToyMC = nToyMC;
  }

buildSingleCombToyMC()

TH2 * TElectronEfficiencyCorrectionTool::buildSingleCombToyMC ( const TH1 * sf, const TH1 * stat, const TH1 * uncorr, const std::vector< TH1 * > & corr, const int nSys, int & randomCounter )

private

Definition at line 438 of file TElectronEfficiencyCorrectionTool.cxx.

{
 
  ATH_MSG_DEBUG(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                           << "Entering function buildSingleCombToyMC");
 
  TH2* tmpHist;
  const int nBins = (stat->GetNbinsX() + 2) * (stat->GetNbinsY() + 2);
  tmpHist = (TH2*)corr.at(0)->Clone();
  // Create random numbers for the corr. uncertainties
  std::vector<double> rnd(nSys, 0);
  for (int s = 0; s < nSys; ++s) {
    rnd[s] = m_Rndm.Gaus(0, 1);
    randomCounter++;
  }
  // Loop over all bins
  for (int bin = 0; bin < nBins; ++bin) {
    double val = stat->GetBinContent(bin);
 
    // Add uncorrelated systematics
    if (uncorr != nullptr) {
      double valAdd = uncorr->GetBinContent(bin);
      val = sqrt(val * val + valAdd * valAdd);
    }
    val = val * m_Rndm.Gaus(0, 1);
    randomCounter++;
    // Add larger correlated systematics
    for (int s = 0; s < nSys; ++s) {
      if (corr.at(s) != nullptr) {
        val += static_cast<TH2*>(corr.at(s))->GetBinContent(bin) * rnd[s];
      }
    }
    tmpHist->SetBinContent(bin, val + sf->GetBinContent(bin));
  }
  tmpHist->SetDirectory(nullptr);
  return tmpHist;
}

buildSingleToyMC()

std::vector< TH2 * > TElectronEfficiencyCorrectionTool::buildSingleToyMC ( const TH1 * sf, const TH1 * stat, const TH1 * uncorr, const std::vector< TH1 * > & corr, int & randomCounter )

private

Definition at line 398 of file TElectronEfficiencyCorrectionTool.cxx.

{
  ATH_MSG_DEBUG(" (file: " << __FILE__ << ", line: " << __LINE__ << ")! "
                           << "Entering function buildSingleToyMC");
  std::vector<TH2*> tmpHists;
  int nBins = (stat->GetNbinsX() + 2) * (stat->GetNbinsY() + 2);
  tmpHists.reserve(m_nToyMC);
  for (int toy = 0; toy < m_nToyMC; toy++) {
    tmpHists.push_back((TH2*)corr.at(0)->Clone());
  }
  // Loop over all bins
  for (int bin = 0; bin < nBins; bin++) {
    double val = stat->GetBinContent(bin);
 
    // Add uncorrelated systematics
    if (uncorr != nullptr) {
      double valAdd = uncorr->GetBinContent(bin);
      val = sqrt(val * val + valAdd * valAdd);
    }
    for (int toy = 0; toy < m_nToyMC; toy++) {
      tmpHists.at(toy)->SetBinContent(
        bin, (val * m_Rndm.Gaus(0, 1)) + sf->GetBinContent(bin));
      randomCounter++;
      tmpHists.at(toy)->SetDirectory(nullptr);
    }
  }
  return tmpHists;
}

buildToyMCTable()

std::vector< Root::TElectronEfficiencyCorrectionTool::HistArray > TElectronEfficiencyCorrectionTool::buildToyMCTable ( const std::vector< TH1 * > & sf, const std::vector< TH1 * > & eig, const std::vector< TH1 * > & stat, const std::vector< TH1 * > & uncorr, const std::vector< std::vector< TH1 * > > & corr )

private

Definition at line 485 of file TElectronEfficiencyCorrectionTool.cxx.

{
 
  ATH_MSG_DEBUG(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                           << "Entering function buildToyMCTable");
 
  int nSys{};
  int randomCounter(0);
  std::vector<HistArray> tmpVec;
  const int stat_entries = stat.size();
  if (m_doCombToyMC) {
    for (int toyMC = 0; toyMC < m_nToyMC; toyMC++) {
      HistArray tmpArray;
      for (int i = 0; i < stat_entries; ++i) {
        if (!eig.empty() && !uncorr.empty()) {
          nSys = (eig.at(i))->GetNbinsX() - 1;
          tmpArray.emplace_back(buildSingleCombToyMC(sf.at(i),
                                                     stat.at(i),
                                                     uncorr.at(i),
                                                     corr.at(i),
                                                     nSys,
                                                     randomCounter));
        } else {
          tmpArray.emplace_back(buildSingleCombToyMC(sf.at(i),
                                                     stat.at(i),
                                                     nullptr,
                                                     corr.at(i),
                                                     nSys,
                                                     randomCounter));
        }
      }
      tmpVec.emplace_back(std::move(tmpArray));
    }
  } else {
    std::vector<std::vector<TH2*>> tmpVec2;
    for (int i = 0; i < stat_entries; ++i) {
      nSys = (eig.at(i))->GetNbinsX() - 1;
      tmpVec2.push_back(buildSingleToyMC(sf.at(i),
                                         stat.at(i),
                                         uncorr.at(i),
                                         corr.at(i),
                                         randomCounter));
    }
    for (int toy = 0; toy < m_nToyMC; toy++) {
      HistArray tmpArray;
      for (auto& i : tmpVec2) {
        tmpArray.emplace_back(i.at(toy));
      }
      tmpVec.emplace_back(std::move(tmpArray));
    }
  }
  return tmpVec;
}

calculate()

int TElectronEfficiencyCorrectionTool::calculate	(	const PATCore::ParticleDataType::DataType	dataType,
		const unsigned int	runnumber,
		const double	cluster_eta,
		const double	et,
		Result &	result,
		const bool	onlyTotal = false ) const

The main calculate method: dataType PATCore::ParticleDataType::DataType (e.g DATA,FULL etc) @ runnumber the run number.

1st dimension of the stored measurements @ cluster_eta the cluster eta. 2nd dimension of the stored measurements @ electron et. third dimension of the stored measurments @ result struct filled with SF, Total uncertainty, Stat uncertainty, Uncorr uncertainty @ onlyTotal do only the "total" systematic returns 0 in failure

Toy production is controlled by internal flags set by the Asg Tool. As toys are special.

Definition at line 160 of file TElectronEfficiencyCorrectionTool.cxx.

{
  // Set up the non-0 defaults
  result.SF = -999;
  result.Total = 1;
  /*
   * Determine Simulation flavour and find the run period
   */
  const bool isFastSim = dataType == PATCore::ParticleDataType::Fast;
  int runnumberIndex = -1;
  if (isFastSim) {
    for (unsigned int i = 0; i < m_begRunNumberListFastSim.size(); ++i) {
      if (m_begRunNumberListFastSim[i] <= runnumber &&
          runnumber <= m_endRunNumberListFastSim[i]) {
        runnumberIndex = i;
        break;
      }
    }
  } else {
    for (unsigned int i = 0; i < m_begRunNumberList.size(); ++i) {
      if (m_begRunNumberList[i] <= runnumber &&
          runnumber <= m_endRunNumberList[i]) {
        runnumberIndex = i;
        break;
      }
    }
  }
  if (runnumberIndex < 0) {
    return 0;
  }
  /* What we have is a vector<vector<HistArray>> acting as a map:
   * Key/Index is SF,Stat,Eigen,UnCorr
   * The Entry in this index is a vector<HistArray>
   * Each vector<HistArray>  has as many entries as supported Run periods.
   * Each HistArray has 2D histos (could be standard, low-et, or forward
   * electrons) The 2D Histo then has the number we want. What follows is the
   * logic to get to this number.
   */
  const auto& currentmap = (isFastSim) ? m_fastHistList : m_histList;
  const std::vector<HistArray>& sfVector = currentmap.at(mapkey::sf);
  /*
   * See if we can find a  vector for key SF in the map
   * and then if we can get the  corresponding HisArray
   * for the run period.
   */
  if (sfVector.empty() || runnumberIndex >= static_cast<int>(sfVector.size())) {
    return 0;
  }
  /*
   * At this stage we have found the relevant period
   * So we need to locate the right histogram.
   */
  const HistArray& sfObjectArray = sfVector[runnumberIndex];
  const auto& edges = (isFastSim) ? m_fastHistEdges[runnumberIndex]
                                  : m_histEdges[runnumberIndex];
  const int entries = edges.size();
  /*
   * Now the logic of finding the histogram
   * Some parts of the code can be perhaps improved ...
   */
  double xValue(et);
  double yValue(cluster_eta);
  int smallEt(0);
  int etaCov(0);
  int nSF(0);
  bool invalid = false;
  bool changedEt = false;
  int index = -1;
 
  for (int i = 0; i < entries; ++i) {
    invalid = false;
    const HistEdge& histEdge = edges[i];
    // invalid if we are below minimum et
    if (et < histEdge.etMin) {
      smallEt++;
      invalid = true;
    }
 
    // invalid if we are above max eta
    if (std::abs(yValue) >= histEdge.etaMax) {
      etaCov++;
      invalid = true;
    }
    // invalid if we are less than minimum eta (forward electrons)
    if (std::abs(yValue) < histEdge.etaMin) {
      etaCov++;
      invalid = true;
    }
    /*
     * Invalid if above max et and is a low Et histogram.
     * If not low Et histogram then change the xValue to the maximum
     * availabe Et of ths histogram. As we assume that the  SF stays the same
     * for very high Et
     */
    if (et > histEdge.etMax) {
      if (histEdge.isLowPt) {
        invalid = true;
      } else {
        xValue = histEdge.etMax - 1000 ; //1000 is 1 GeV
        changedEt = true;
      }
    }
    /*
     * Get the histogram index in the TObjArray
     * Also mark how many times we found something
     * as SF should be unique
     */
    if (!invalid) {
      index = i;
      if (!changedEt) {
        nSF++;
      }
    }
  }
  if (smallEt == entries) {
    return 0;
  }
  if (etaCov == entries) {
    return 0;
  }
  if (nSF > 1) {
    ATH_MSG_WARNING("More than 1 SF found for eta="
                    << yValue << " , et = " << et << " , run number = "
                    << runnumber << ". Please check your input files!");
  }
  if (index < 0) {
    return 0;
  }
 
  /*
   * Now we have the index of the histogram
   */
  const HistEdge& currentEdge = edges[index];
  /*
   * If SF is only given in Abs(eta) convert eta input to std::abs()
   */
  constexpr double epsilon = 1e-6;
  if (currentEdge.etaMin >= (0 - epsilon)) {
    yValue = std::abs(yValue);
  }
 
  const TH2* currentHist = static_cast<TH2*>(sfObjectArray[index].get()) ;
  const int globalBinNumber = currentHist->FindFixBin(xValue, yValue);
  const double scaleFactor = currentHist->GetBinContent(globalBinNumber);
  const double scaleFactorErr = currentHist->GetBinError(globalBinNumber);
  /*
   * Write the retrieved values to the output
   */
  result.SF= scaleFactor;
  result.Total = scaleFactorErr;
  result.histIndex = index;
  result.histBinNum = globalBinNumber;
  /*
   * if we only wanted the Total we can exit here
   */
  if (onlyTotal) {
    return 1;
  }
  /*
   * Do the stat error using the available info from the above (SF)
   */
  double statErr = -999;
  const std::vector<HistArray>& statVector = currentmap.at(mapkey::stat);
  if (runnumberIndex < static_cast<int> (statVector.size())) {
    if (!statVector[runnumberIndex].empty()) {
      statErr = static_cast<TH1*>(statVector[runnumberIndex][index].get())
                  ->GetBinContent(globalBinNumber);
      result.Stat = statErr;
    }
  }
  /*
   * Do the Uncorr  uncertainty
   */
  double val = statErr;
  const std::vector<HistArray>& uncorrVector = currentmap.at(mapkey::uncorr);
  if (runnumberIndex < static_cast<int>(uncorrVector.size())) {
    if (!uncorrVector.at(runnumberIndex).empty()) {
      const double valAdd =
        static_cast<TH1*>(uncorrVector[runnumberIndex][index].get())
          ->GetBinContent(globalBinNumber);
      val = sqrt(val * val + valAdd * valAdd);
    }
  }
  result.UnCorr = val;
  /*
   * Do the correlated part
   * For the N~16 systematic variations
   * we keep them in a vector of vector of HistArray
   * The first vector index being the runnumber
   * The second the systematic
   * And them the HistArray for high low etc.
   */
  result.Corr.resize(m_nSysMax);
  const std::vector<std::vector<HistArray>>& sysList =
      (isFastSim) ? m_fastSysList : m_sysList;
  if (sysList.size() > static_cast<unsigned int>(index)) {
    if (sysList.at(index).size() > static_cast<unsigned int>(runnumberIndex)) {
      const int sys_entries = sysList.at(index).at(runnumberIndex).size();
      for (int sys = 0; sys < sys_entries; ++sys) {
        double sysVal =
            static_cast<TH2*>(sysList[index][runnumberIndex][sys].get())
                ->GetBinContent(globalBinNumber);
        result.Corr[sys] = sysVal;
      }
    }
  }
  /*
   * Do the toys if requested
   */
  if (m_doToyMC || m_doCombToyMC) {
    result.toys.resize(static_cast<size_t>(m_nToyMC));
    const std::vector<std::vector<HistArray>>& toyMCList =
        ((isFastSim) ? m_uncorrToyMCSystFast : m_uncorrToyMCSystFull);
    if (toyMCList.size() > (unsigned int)runnumberIndex) {
      for (int toy = 0; toy < m_nToyMC; ++toy) {
        if (toyMCList[runnumberIndex][toy].size() >
            static_cast<unsigned int>(index)) {
          result.toys[toy] =
              static_cast<TH2*>(toyMCList[runnumberIndex][toy][index].get())
                  ->GetBinContent(globalBinNumber);
        }
      }
    }
  }
  return 1;
}

fillHistEdges()

void TElectronEfficiencyCorrectionTool::fillHistEdges ( const std::vector< HistArray > & sfPerPeriodHist, std::vector< std::vector< HistEdge > > & sfPerPeriodEdges )

staticprivate

Definition at line 964 of file TElectronEfficiencyCorrectionTool.cxx.

                                                      {
 
  for (const auto& vec : sfPerPeriodHist) {
    const size_t vecSize = vec.size();
    std::vector<HistEdge> periodVec;
    periodVec.reserve(vecSize);
    for (size_t i = 0; i < vecSize; ++i) {
      const auto* tmpHist = static_cast<TH2*>(vec[i].get());
      const auto* const xAxis = tmpHist->GetXaxis();
      const auto* yAxis = tmpHist->GetYaxis();
      HistEdge histEdge;
      histEdge.etaMax = yAxis->GetXmax();
      histEdge.etaMin = yAxis->GetXmin();
      histEdge.etMax = xAxis->GetXmax();
      histEdge.etMin = xAxis->GetXmin();
      histEdge.isLowPt =
          (std::strstr(tmpHist->GetName(), LowPt_string) != nullptr);
 
      periodVec.emplace_back(histEdge);
    }
    sfPerPeriodEdges.emplace_back(std::move(periodVec));
  }
}

getHistograms()

int TElectronEfficiencyCorrectionTool::getHistograms ( )

private

Load all histograms from the input file(s).

Definition at line 588 of file TElectronEfficiencyCorrectionTool.cxx.

{
  ATH_MSG_DEBUG(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                           << "Entering function getHistograms");
  // Cache the current directory in the root file
  TDirectory* origDir = gDirectory;
  /*
   * Get the name of the first input ROOT file and
   * interpret from that what we have:
   * efficiency vs. efficiencySF; offline vs. trigger; medium, loose,...
   */
  if (!m_corrFileNameList.empty()) {
    TString firstFileNameAndPath = m_corrFileNameList[0].c_str();
    std::unique_ptr<TObjArray> myStringList(firstFileNameAndPath.Tokenize("/"));
    int lastIdx = myStringList->GetLast();
    TString fileName = ((TObjString*)myStringList->At(lastIdx))->GetString();
    std::unique_ptr<TObjArray> myFileNameTokensList(fileName.Tokenize("."));
 
    if (myFileNameTokensList->GetLast() < 3) {
      ATH_MSG_ERROR("input file name has wrong format!");
      return 0;
    }
  }
  /*
   * Get all ROOT files and histograms
   */
  for (auto& ifile : m_corrFileNameList) {
    // Load the ROOT file
    const std::unique_ptr<char[]> fname(gSystem->ExpandPathName(ifile.c_str()));
    std::unique_ptr<TFile> rootFile(TFile::Open(fname.get(), "READ"));
    if (!rootFile) {
      ATH_MSG_ERROR("No ROOT file found here: " << ifile);
      return 0;
    }
    // Loop over all directories inside the root file (correspond to the run
    // number ranges
    TIter nextdir(rootFile->GetListOfKeys());
    TKey* dir = nullptr;
    TObject* obj = nullptr;
    while ((dir = (TKey*)nextdir())) {
      obj = dir->ReadObj();
      if (obj->IsA()->InheritsFrom("TDirectory")) {
        // splits string by delimiter --> e.g RunNumber1_RunNumber2
        std::unique_ptr<TObjArray> dirNameArray(
          TString(obj->GetName()).Tokenize("_"));
        // returns index of last string --> if one, the directory name does not
        // contain any run numbers
        int lastIdx = dirNameArray->GetLast();
        if (lastIdx != 1) {
          ATH_MSG_ERROR(
            "The folder name seems to have the wrong format! Directory name:"
            << obj->GetName());
          return 0;
        }
        rootFile->cd(obj->GetName());
        if (0 == this->setupHistogramsInFolder(*dirNameArray, lastIdx)) {
          ATH_MSG_ERROR("Unable to setup the histograms in directory "
                        << dir->GetName() << "in file " << ifile);
          return 0;
        }
      } else {
        ATH_MSG_ERROR("Wrong file content! Expected only Directories "
                      << gDirectory->cd());
        return 0;
      }
      // Return to the original ROOT directory
      gDirectory = origDir;
    } // End: directory loop
  }   // End: file loop
 
  // SF Histogram edges caching
  fillHistEdges(m_histList.at(mapkey::sf), m_histEdges);
  size_t histListSize = m_histList.at(mapkey::sf).size();
  size_t edgeListSize = m_histEdges.size();
  if (histListSize != edgeListSize) {
    ATH_MSG_ERROR("Histo List and Edge List differ in Run period entries "
                  << histListSize << " vs " << edgeListSize);
    return 0;
  }
  for (size_t i = 0; i < histListSize; ++i) {
    if (m_histList.at(mapkey::sf).at(i).size() != m_histEdges.at(i).size()) {
      ATH_MSG_ERROR(
          "Histo List and Edge List differ for the Run period in entry" << i);
      return 0;
    }
  }
 
  // Caching of Bin edges for Fast simul SF
  fillHistEdges(m_fastHistList.at(mapkey::sf), m_fastHistEdges);
  histListSize = m_fastHistList.at(mapkey::sf).size();
  edgeListSize = m_fastHistEdges.size();
  if (histListSize != edgeListSize) {
    ATH_MSG_ERROR("Fast Histo List and Edge List differ in Run period entries "
                  << histListSize << " vs " << edgeListSize);
    return 0;
  }
  for (size_t i = 0; i < histListSize; ++i) {
    if (m_fastHistList.at(mapkey::sf).at(i).size() !=
        m_fastHistEdges.at(i).size()) {
      ATH_MSG_ERROR(
          "Fast Histo List and Edge List differ for the Run period in entry"
          << i);
      return 0;
    }
  }
 
  return 1;
}

getNbins()

int TElectronEfficiencyCorrectionTool::getNbins

(

std::map< float, std::vector< float > > &

ptEta

)

const

Helpers to get the binning of the uncertainties in a std::map (pt, eta).

Definition at line 547 of file TElectronEfficiencyCorrectionTool.cxx.

{
  // Get sf histograms
  const std::vector<HistArray>& tmpVec = (!m_histList[mapkey::sf].empty())
                                             ? m_histList[mapkey::sf]
                                             : m_fastHistList[mapkey::sf];
 
  int nbinsTotal = 0;
  pt_eta1.clear();
  std::vector<float> eta1;
  eta1.clear();
 
  // Loop over the different Run range (one TObjeArray for each)
  for (const auto& ikey : tmpVec) {
    // Loop over the histograms for a given run numbers
    for (const auto& entries : ikey) {
      eta1.clear();
      // Get number of bins
      TH2* h_tmp = ((TH2*)entries.get());
      int nbinsX = h_tmp->GetNbinsX();
      int nbinsY = h_tmp->GetNbinsY();
      // fill in the eta pushing back
      for (int biny = 1; biny <= nbinsY; ++biny) {
        eta1.push_back(h_tmp->GetYaxis()->GetBinLowEdge(biny));
      }
      // associate each pt (bin) with the corresponding/available eta ones
      for (int binx = 1; binx <= nbinsX; ++binx) {
        pt_eta1[h_tmp->GetXaxis()->GetBinLowEdge(binx)] = eta1;
      }
    }
  }
  for (auto& i : pt_eta1) {
    nbinsTotal += i.second.size();
  }
  return nbinsTotal;
}

getNSyst()

int Root::TElectronEfficiencyCorrectionTool::getNSyst ( ) const

inline

get number of systematics

Definition at line 107 of file TElectronEfficiencyCorrectionTool.h.

{ return m_nSysMax; }

initialize()

int TElectronEfficiencyCorrectionTool::initialize

(

)

Initialize this class.

Definition at line 87 of file TElectronEfficiencyCorrectionTool.cxx.

{
  // use an int as a StatusCode
  int sc(1);
  // Check if files are present
  if (m_corrFileNameList.empty()) {
    ATH_MSG_ERROR(" No file added!");
    return 0;
  }
  ATH_MSG_DEBUG("Initializing tool with " << m_corrFileNameList.size()
                                          << " configuration file(s)");
 
  if (m_doToyMC && m_doCombToyMC) {
    ATH_MSG_ERROR(" Both regular and combined toy MCs booked!"
                  << " Only use one!");
    return 0;
  }
  /*
   * initialize the random number generator if toyMC propagation booked
   * Use the 1st 4 bytes of the CheckSum of the reccomendation file as seed
   */
  if (m_doToyMC || m_doCombToyMC) {
    if (m_seed == 0) {
      // Use the name of the correction  for auto-setting of the seed based on
      // the md5-sum of the file
      const std::unique_ptr<char[]> fname(
        gSystem->ExpandPathName(m_corrFileNameList[0].c_str()));
      std::unique_ptr<TMD5> tmd = std::make_unique<TMD5>();
      const char* tmd_as_string = TMD5::FileChecksum(fname.get())->AsString();
      m_seed = *(reinterpret_cast<const unsigned long int*>(tmd_as_string));
      ATH_MSG_DEBUG("Seed (automatically) set to " << m_seed);
    } else {
      ATH_MSG_DEBUG("Seed set to " << m_seed);
    }
    m_Rndm = TRandom3(m_seed);
  }
  /*
   * Load the needed histograms
   */
  if (0 == getHistograms()) {
    ATH_MSG_ERROR(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                             << "! Problem when calling getHistograms()");
    return 0;
  }
  const unsigned int nRunNumbersFull = m_begRunNumberList.size();
  const unsigned int nRunNumbersFast = m_begRunNumberListFastSim.size();
 
  ATH_MSG_DEBUG(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                           << "Found " << nRunNumbersFast
                           << " run number ranges for fast sim with a total of "
                           << m_fastHistList[mapkey::sf].size()
                           << " scale factor histograms.");
 
  ATH_MSG_DEBUG(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                           << "Found " << nRunNumbersFull
                           << " run number ranges for full sim with a total of "
                           << m_histList[mapkey::sf].size()
                           << " scale factor histograms.");
 
  ATH_MSG_DEBUG("Tool succesfully initialized!");
 
  return sc;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setSeed()

void Root::TElectronEfficiencyCorrectionTool::setSeed ( const unsigned long int seed )

inline

Set the Random Seed.

Definition at line 110 of file TElectronEfficiencyCorrectionTool.h.

{ m_seed = seed; }

setup()

int TElectronEfficiencyCorrectionTool::setup ( const std::vector< TH1 * > & hists, std::vector< HistArray > & histList, std::vector< unsigned int > & beginRunNumberList, std::vector< unsigned int > & endRunNumberList, const int runNumBegin, const int runNumEnd ) const

private

Fill and interpret the setup, depending on which histograms are found in the input file(s).

Definition at line 925 of file TElectronEfficiencyCorrectionTool.cxx.

{
  if (hists.empty()) {
    ATH_MSG_ERROR("! Could NOT find histogram with name *_sf in folder");
    return 0;
  }
  TH1* tmpHist(nullptr);
  HistArray tmpArray;
  for (const auto& hist : hists) {
    tmpHist = static_cast<TH1*>(hist);
    tmpHist->SetDirectory(nullptr);
    tmpArray.emplace_back(tmpHist);
  }
  histList.emplace_back(std::move(tmpArray));
  // Now, we have all the needed info. Fill the vectors accordingly
  if (!beginRunNumberList.empty()) {
    if (runNumBegin != (int)beginRunNumberList.back()) {
      beginRunNumberList.push_back(runNumBegin);
    }
  } else {
    beginRunNumberList.push_back(runNumBegin);
  }
  if (!endRunNumberList.empty()) {
    if (runNumEnd != (int)endRunNumberList.back()) {
      endRunNumberList.push_back(runNumEnd);
    }
  } else {
    endRunNumberList.push_back(runNumEnd);
  }
  return 1;
}

setupHistogramsInFolder()

int TElectronEfficiencyCorrectionTool::setupHistogramsInFolder ( const TObjArray & dirNameArray, int lastIdx )

private

setup obj arrays at specific indices

Definition at line 700 of file TElectronEfficiencyCorrectionTool.cxx.

{
 
  ATH_MSG_DEBUG(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                           << "Entering funtion setupHistogramsInFolder");
 
  int runNumBegin(-1);
  TString myBegRunNumString =
    ((TObjString*)dirNameArray.At(lastIdx - 1))->GetString();
  if (myBegRunNumString.IsDigit()) {
    runNumBegin = myBegRunNumString.Atoi();
  }
  int runNumEnd(-1);
  TString myEndRunNumString =
    ((TObjString*)dirNameArray.At(lastIdx))->GetString();
  if (myEndRunNumString.IsDigit()) {
    runNumEnd = myEndRunNumString.Atoi();
  }
  if (runNumBegin < 0 || runNumEnd < 0 || runNumEnd < runNumBegin) {
    ATH_MSG_ERROR(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                             << "Could NOT interpret the run number range: "
                             << runNumBegin << " - " << runNumEnd);
    return 0;
  }
  //--> e.g. "sf" index 0 ,
  std::vector<std::vector<TH1*>> objsFull(mapkey::end);
  std::vector<std::vector<TH1*>> objsFast(mapkey::end);
  // Vector to hold the N~16 systematic variations
  std::vector<std::vector<TH1*>> sysObjsFull;
  std::vector<std::vector<TH1*>> sysObjsFast;
  TIter nextkey(gDirectory->GetListOfKeys());
  TKey* key = nullptr;
  TObject* obj = nullptr;
  int seenSystematics = 0;
  // Loop of the keys
  while ((key = (TKey*)nextkey())) {
    obj = key->ReadObj();
    if (obj->IsA()->InheritsFrom("TH1")) {
      // The histogram containing the scale factors need to end with _sf and
      // need to contain either the string "FullSim" or "AtlFast"!
      if (std::strstr(obj->GetName(), "FullSim") != nullptr) {
        setupTempMapsHelper(
          static_cast<TH1*>(obj), objsFull, sysObjsFull, seenSystematics);
      } else if (std::strstr(obj->GetName(), "AtlFast") != nullptr) {
        setupTempMapsHelper(
          static_cast<TH1*>(obj), objsFast, sysObjsFast, seenSystematics);
      } else {
        ATH_MSG_ERROR("Could NOT interpret if the histogram: "
                      << obj->GetName() << " is full or fast simulation!");
        return 0;
      }
    }
  }
  ATH_MSG_DEBUG(" (file: " << __FILE__ << ", line: " << __LINE__ << ")\n"
                           << "Setting up histograms for Run range  "
                           << runNumEnd);
  // Copy from the temporaries to the actual member variables
  // via the setup function
  for (int key : s_keys) {
    if (!objsFull.at(key).empty()) {
      if (0 == setup(objsFull.at(key),
                     m_histList[key],
                     m_begRunNumberList,
                     m_endRunNumberList,
                     runNumBegin,
                     runNumEnd)) {
        ATH_MSG_ERROR("! Could NOT setup histogram " << key
                                                     << " for full sim!");
        return 0;
      }
    }
    if (!objsFast.at(key).empty()) {
      if (0 == setup(objsFast.at(key),
                     m_fastHistList[key],
                     m_begRunNumberListFastSim,
                     m_endRunNumberListFastSim,
                     runNumBegin,
                     runNumEnd)) {
        ATH_MSG_ERROR("! Could NOT setup histogram " << key << " for fast sim");
        return 0;
      }
    }
  }
  m_fastSysList.resize(sysObjsFast.size());
  for (unsigned int sys = 0; sys < sysObjsFast.size(); sys++) {
    if (0 == setup(sysObjsFast.at(sys),
                   m_fastSysList[sys],
                   m_begRunNumberListFastSim,
                   m_endRunNumberListFastSim,
                   runNumBegin,
                   runNumEnd)) {
      ATH_MSG_ERROR("! Could NOT setup systematic histograms for fast sim");
      return 0;
    }
  }
  m_sysList.resize(sysObjsFull.size());
  for (unsigned int sys = 0; sys < sysObjsFull.size(); sys++) {
    if (0 == setup(sysObjsFull.at(sys),
                   m_sysList[sys],
                   m_begRunNumberList,
                   m_endRunNumberList,
                   runNumBegin,
                   runNumEnd)) {
      ATH_MSG_ERROR("! Could NOT setup systematic histograms for fast sim");
      return 0;
    }
  }
 
  // Toys
  if (m_doToyMC || m_doCombToyMC) {
    bool fullToysBooked =
      setupUncorrToySyst(objsFull, sysObjsFull, m_uncorrToyMCSystFull);
    bool fastToysBooked =
      setupUncorrToySyst(objsFast, sysObjsFast, m_uncorrToyMCSystFast);
    if (fullToysBooked || fastToysBooked) {
      if (m_doToyMC) {
        ATH_MSG_DEBUG("Created tables for " << m_nToyMC
                                            << " ToyMC systematics ");
      }
      if (m_doCombToyMC) {
        ATH_MSG_DEBUG("Created tables for " << m_nToyMC
                                            << " combined ToyMC systematics ");
      }
    }
  }
  return 1;
}

setupTempMapsHelper()

void TElectronEfficiencyCorrectionTool::setupTempMapsHelper ( TH1 * obj, std::vector< std::vector< TH1 * > > & objs, std::vector< std::vector< TH1 * > > & sysObjs, int & seenSystematics )

private

Definition at line 835 of file TElectronEfficiencyCorrectionTool.cxx.

{
  // Add all except the correlated
  for (int key : s_keys) {
    if (TString(obj->GetName())
          .EndsWith("_" + TString(mapkey::keytostring(key)))) {
      objs.at(key).emplace_back(obj);
    }
  }
 
  const TString tmpName(obj->GetName());
  // Special treatment , this is only for photons
  if (tmpName.EndsWith("_sys")) {
    objs.at(mapkey::sys).emplace_back(obj);
    std::vector<TH1*> tmpArray;
    // clone
    tmpArray.emplace_back(static_cast<TH1*>(obj->Clone()));
    sysObjs.emplace_back(tmpArray);
    seenSystematics++;
  }
  // See if we are dealing with correlated
  if (tmpName.Contains("_corr")) {
    /*
     * corr0 in the name triggers a few things
     * We assume that 0 is the 1st
     * histogram in a series of corr(i) that
     * we see for each of the vector entries that
     * can be one for LowPt,Standard,Forward etc
     */
    if (tmpName.EndsWith("corr0")) {
      // 1st create a TObjectArray
      std::vector<TH1*> tmpArray;
      // Register it to the vector
      sysObjs.emplace_back(tmpArray);
      // Reset the counter here
      seenSystematics = 0;
    }
    /*
     * Now we can add to the TObjeArray
     * This can be Low Pt or high Pt
     */
    sysObjs.back().emplace_back(obj);
    //Increase the counter
    seenSystematics++;
  }
 
  if (seenSystematics > m_nSysMax) {
    m_nSysMax = seenSystematics;
  }
}

setupUncorrToySyst()

bool TElectronEfficiencyCorrectionTool::setupUncorrToySyst ( std::vector< std::vector< TH1 * > > & objs, std::vector< std::vector< TH1 * > > & sysObjs, std::vector< std::vector< HistArray > > & uncorrToyMCSyst )

private

Definition at line 893 of file TElectronEfficiencyCorrectionTool.cxx.

{
  bool toysBooked = false;
  if (!m_histList[mapkey::sf].empty()) {
    if (objs.at(mapkey::eig).empty() || objs.at(mapkey::stat).empty() ||
        objs.at(mapkey::uncorr).empty()) {
 
      if (objs.at(mapkey::stat).size() > 1 || objs.at(mapkey::sys).size() > 1) {
 
        uncorrToyMCSyst.push_back(buildToyMCTable(
          objs.at(mapkey::sf), {}, objs.at(mapkey::stat), {}, sysObjs));
        toysBooked = true;
      }
    } else {
      uncorrToyMCSyst.push_back(buildToyMCTable(objs.at(mapkey::sf),
                                                objs.at(mapkey::eig),
                                                objs.at(mapkey::stat),
                                                objs.at(mapkey::uncorr),
                                                sysObjs));
      toysBooked = true;
    }
  }
  return toysBooked;
}

uncorrEmpty()

bool TElectronEfficiencyCorrectionTool::uncorrEmpty

(

const PATCore::ParticleDataType::DataType

dataType

)

Check if stat+uncorr has input.

Definition at line 151 of file TElectronEfficiencyCorrectionTool.cxx.

{
  const bool isFastSim = dataType == PATCore::ParticleDataType::Fast;
  const auto& currentmap = (isFastSim) ? m_fastHistList : m_histList;
 
  return  currentmap.at(mapkey::stat).empty() && currentmap.at(mapkey::uncorr).empty();
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_begRunNumberList

std::vector<unsigned int> Root::TElectronEfficiencyCorrectionTool::m_begRunNumberList

private

List of run numbers where histograms become valid for full simulation.

Definition at line 186 of file TElectronEfficiencyCorrectionTool.h.

m_begRunNumberListFastSim

std::vector<unsigned int> Root::TElectronEfficiencyCorrectionTool::m_begRunNumberListFastSim

private

List of run numbers where histograms become valid for fast simulation.

Definition at line 191 of file TElectronEfficiencyCorrectionTool.h.

m_corrFileNameList

std::vector<std::string> Root::TElectronEfficiencyCorrectionTool::m_corrFileNameList

private

The list of file name(s).

Definition at line 184 of file TElectronEfficiencyCorrectionTool.h.

m_doCombToyMC

bool Root::TElectronEfficiencyCorrectionTool::m_doCombToyMC

private

Definition at line 173 of file TElectronEfficiencyCorrectionTool.h.

m_doToyMC

bool Root::TElectronEfficiencyCorrectionTool::m_doToyMC

private

Flag to control Toys.

Definition at line 172 of file TElectronEfficiencyCorrectionTool.h.

m_endRunNumberList

std::vector<unsigned int> Root::TElectronEfficiencyCorrectionTool::m_endRunNumberList

private

List of run numbers where histograms stop being valid for full simulation.

Definition at line 189 of file TElectronEfficiencyCorrectionTool.h.

m_endRunNumberListFastSim

std::vector<unsigned int> Root::TElectronEfficiencyCorrectionTool::m_endRunNumberListFastSim

private

List of run numbers where histograms stop being valid for fast simulation.

Definition at line 194 of file TElectronEfficiencyCorrectionTool.h.

m_fastHistEdges

std::vector<std::vector<HistEdge> > Root::TElectronEfficiencyCorrectionTool::m_fastHistEdges

private

Definition at line 201 of file TElectronEfficiencyCorrectionTool.h.

m_fastHistList

std::vector<std::vector<HistArray> > Root::TElectronEfficiencyCorrectionTool::m_fastHistList

private

List of histograms for fast simulation.

Definition at line 200 of file TElectronEfficiencyCorrectionTool.h.

m_fastSysList

std::vector<std::vector<HistArray> > Root::TElectronEfficiencyCorrectionTool::m_fastSysList

private

Definition at line 202 of file TElectronEfficiencyCorrectionTool.h.

m_histEdges

std::vector<std::vector<HistEdge> > Root::TElectronEfficiencyCorrectionTool::m_histEdges

private

Definition at line 197 of file TElectronEfficiencyCorrectionTool.h.

m_histList

std::vector<std::vector<HistArray> > Root::TElectronEfficiencyCorrectionTool::m_histList

private

List of histograms for full Geant4 simulation.

Definition at line 196 of file TElectronEfficiencyCorrectionTool.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_nSysMax

int Root::TElectronEfficiencyCorrectionTool::m_nSysMax

private

Maximum number of systematics.

Definition at line 179 of file TElectronEfficiencyCorrectionTool.h.

m_nToyMC

int Root::TElectronEfficiencyCorrectionTool::m_nToyMC

private

The number of toys.

Definition at line 175 of file TElectronEfficiencyCorrectionTool.h.

m_Rndm

TRandom3 Root::TElectronEfficiencyCorrectionTool::m_Rndm

private

Definition at line 204 of file TElectronEfficiencyCorrectionTool.h.

m_seed

unsigned long int Root::TElectronEfficiencyCorrectionTool::m_seed

private

The Random seed.

Definition at line 177 of file TElectronEfficiencyCorrectionTool.h.

m_sysList

std::vector<std::vector<HistArray> > Root::TElectronEfficiencyCorrectionTool::m_sysList

private

Definition at line 198 of file TElectronEfficiencyCorrectionTool.h.

m_uncorrToyMCSystFast

std::vector<std::vector<HistArray> > Root::TElectronEfficiencyCorrectionTool::m_uncorrToyMCSystFast

private

Definition at line 182 of file TElectronEfficiencyCorrectionTool.h.

m_uncorrToyMCSystFull

std::vector<std::vector<HistArray> > Root::TElectronEfficiencyCorrectionTool::m_uncorrToyMCSystFull

private

Definition at line 181 of file TElectronEfficiencyCorrectionTool.h.

---

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

• TElectronEfficiencyCorrectionTool.h
• TElectronEfficiencyCorrectionTool.cxx