ATLAS Offline Software
CalibrationDataInterfaceROOT.h
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // CalibrationDataInterfaceROOT.h, (c) ATLAS Detector software
8 
9 #ifndef ANALYSISCALIBRATIONDATAINTERFACEROOT_H
10 #define ANALYSISCALIBRATIONDATAINTERFACEROOT_H
11 
12 
15 
16 //#include "Rtypes.h"
17 #include "TMatrixDSym.h"
18 #include "TH1.h"
19 #include <vector>
20 #include <string>
21 #include <map>
22 
23 class TFile;
24 class TMap;
25 
26 namespace Analysis
27 {
28  class CalibrationDataContainer;
29 
30  class CalibrationDataEigenVariations;
31 
71 
73  enum EVReductionStrategy { Tight = 0, Medium = 1, Loose = 2};
74 
83 
86 
88  {
89  public:
91  CalibrationDataInterfaceROOT(const std::string& taggerName, const std::string& configname = "BTagCalibration.env", const std::string& pathname = "");
92 
94  CalibrationDataInterfaceROOT(const std::string& taggerName,
95  const char* fileSF, const char* fileEff,
96  const std::vector<std::string>& jetAliases,
97  const std::map<std::string, std::string>& SFNames,
98  const std::map<std::string, std::vector<std::string> >& EffNames,
99  const std::map<std::string, std::vector<std::string> >& excludeFromEV,
100  const std::map<std::string, Analysis::EVReductionStrategy>& EVReductions,
101  bool useEV = true, Uncertainty strat = SFEigen, bool useMCMCSF = true,
102  bool useTopologyRescaling = false, bool useRecommendedEVExclusions = false,
103  bool verbose = true, std::vector<std::string> flavours = {"B", "C", "Light", "T"}
104  );
105 
108 
111 
114 
115  // ------------------------------------------------------------------------------------------
116 
117  // Main jet-by-jet interface methods accessing the flavour tagging performance information.
118  // Note that for both of the following, the label is assumed to adhere to the
119  // TruthInfo conventions (see package PhysicsAnalysis/JetTagging/JetTagInfo).
120 
121  // THe following methods are one of three
124  const std::string& label, const std::string& OP,
125  Uncertainty unc, unsigned int numVariation = 0,
126  unsigned int mapIndex = 0);
127 
130  const std::string& label, const std::string& OP,
131  Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0,
132  unsigned int mapIndex = 0);
133 
136  const std::string& label, const std::string& OP,
137  Uncertainty unc, unsigned int numVariation = 0,
138  unsigned int mapIndex = 0);
139 
142  const std::string& label, const std::string& OP,
143  Uncertainty unc, unsigned int numVariation = 0,
144  unsigned int mapIndex = 0);
145 
148  const std::string& OP, Uncertainty unc = None, unsigned int mapIndex = 0);
149 
152  const std::string& OP, Uncertainty unc = None, unsigned int mapIndex = 0);
153 
154 
164  std::vector<std::string> listScaleFactorUncertainties(const std::string& author, //<-------- One of two
165  const std::string& label,
166  const std::string& OP,
167  bool named = false);
168 
172  unsigned int getNumVariations(const std::string& author, const std::string& label,
173  const std::string& OP, Uncertainty unc);
174 
175  // ------------------------------------------------------------------------------------------
176 
177  // Main jet-by-jet interface methods accessing the flavour tagging performance information.
178  // The difference with the previous set of methods is that no label and operating point are
179  // passed; instead, it is assumed that the user has retrieved the (unsigned) integer index
180  // corresponding to the label/OP/jet collection using the retrieveCalibrationIndex() method
181  // below. The methods below are not protected against wrong usage of this index!
182 
185  bool retrieveCalibrationIndex (const std::string& label, const std::string& OP,
186  const std::string& author, bool isSF, unsigned int& index,
187  unsigned int mapIndex = 0);
188 
190  std::string nameFromIndex (unsigned int index) const;
191 
194  unsigned int indexSF, unsigned int indexEff,
195  Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0);
196 
199  unsigned int indexSF, unsigned int indexEff,
200  Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0);
201 
204  unsigned int indexSF, unsigned int indexEff,
205  Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0);
206 
209  unsigned int indexSF, unsigned int indexEff,
210  Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0);
211 
214  Uncertainty unc = None);
215 
218  Uncertainty unc = None);
219 
223  unsigned indexSF, unsigned int indexEff) const;
224 
234  std::vector<std::string> listScaleFactorUncertainties(unsigned int index,
235  const std::string& flavour, bool named = false);
236 
240  unsigned int getNumVariations(unsigned int index, Uncertainty unc, const std::string& flavour);
241 
243  std::string fullName(const std::string& author, const std::string& OP,
244  const std::string& label, bool isSF, unsigned mapIndex = 0) const;
245 
246  // ------------------------------------------------------------------------------------------
247 
248  // Main jet-by-jet interface methods accessing the flavour tagging performance information.
249  // The difference with the previous set of methods is in the signatures of the methods, where
250  // the return value is a status code while the actual calibration result is to be passed as
251  // one of the arguments. Other than this, the same comments hold as for the previous set of
252  // methods.
253 
256  unsigned int indexSF, unsigned int indexEff,
257  Uncertainty unc, unsigned int numVariation,
258  CalibResult& result, const std::string& flavour);
259 
262  unsigned int indexSF, unsigned int indexEff,
263  Uncertainty unc, unsigned int numVariation,
264  CalibResult& result, const std::string& flavour);
265 
268  unsigned int indexSF, unsigned int indexEff,
269  Uncertainty unc, unsigned int numVariation,
270  CalibResult& result, const std::string& flavour);
271 
274  unsigned int indexSF, unsigned int indexEff,
275  Uncertainty unc, unsigned int numVariation,
276  CalibResult& result, const std::string& flavour);
277 
280  unsigned int index, Uncertainty unc,
282 
283  // ------------------------------------------------------------------------------------------
284 
285  // Main jet-by-jet interface methods accessing "pseudo-continuous" flavour tagging performance
286  // information. This refers to data/MC scale factors in tag weight bins rather than scale factors
287  // for jets to pass a fixed tag weight cut.
288  // Both versions (one using names, one using integer indices) are available. As for the latter: like
289  // for the regular (non-continuous) case, the method is not protected against wrong usage of this index!
290 
292  CalibResult getWeightScaleFactor (const CalibrationDataVariables& variables, const std::string& label, //<--------- One of three
293  Uncertainty unc, unsigned int numVariation = 0, unsigned int mapIndex = 0);
294 
297  unsigned int indexSF, unsigned int indexEff,
298  Uncertainty unc, unsigned int numVariation = 0);
299 
302  unsigned int indexSF, unsigned int indexEff,
303  Uncertainty unc, unsigned int numVariation,
305 
306  // ------------------------------------------------------------------------------------------
307 
310  const std::string& label,
311  const std::string& OP,
312  unsigned int mapindex = 0);
313 
315  unsigned int mapindex = 0);
316 
318  std::map<std::string, std::map<std::string, float>> getEigenVectorRecompositionCoefficientMap();
319 
320  // ------------------------------------------------------------------------------------------
321 
322  // Utilities
323 
329  const TObject* getMCEfficiencyObject (const std::string& author, const std::string& label,
330  const std::string& OP, unsigned int mapIndex = 0);
331 
336  const TH1* getBinnedScaleFactors (const std::string& author, const std::string& label,
337  const std::string& OP);
338 
346  const TH1* getShiftedScaleFactors (const std::string& author, const std::string& label,
347  const std::string& OP, const std::string& unc,
348  double sigmas);
349 
355  TMatrixDSym getScaleFactorCovarianceMatrix (const std::string& author, const std::string& label,
356  const std::string& OP, const std::string& unc = "all");
357 
358  // ------------------------------------------------------------------------------------------
359 
360  // Helper class dealing with the hadronisation reference information.
361  // Rootcint requires this to be public.
362 
364  public:
365  HadronisationReferenceHelper(TMap* mapSF, TMap* mapEff);
366  // default constructor (for PROOF purposes)
372  bool getReference(const std::string& spec, std::string& ref) const;
373 
374  private:
376  std::map<std::string, std::string> m_refs;
377  };
378 
379  // ------------------------------------------------------------------------------------------
380 
382  void initialize(const std::string& jetauthor, const std::string& OP, Uncertainty unc);
383 
385  // CalibrationDataContainer* retrieveContainer(const std::string& name, bool isSF);
386  CalibrationDataContainer* retrieveContainer(const std::string& label, const std::string& OP, const std::string& author, const std::string& cntname, bool isSF, bool doPrint = true);
387 
388  // The above two methods need to be modified to handle the various EV techniques
389  //
390 
391 
392 
393 
394 
395  /* Private data members and methods */
396 
397  private:
398 
400  TFile* m_fileEff{};
401  TFile* m_fileSF{};
402 
405  std::map<std::string, std::string> m_aliases;
406 
410  std::vector<CalibrationDataContainer*> m_objects;
411  std::map<std::string, unsigned int> m_objectIndices;
412 
414  std::string getAlias(const std::string& author) const;
415 
417  std::string m_filenameSF;
418  std::string m_filenameEff;
419  std::vector<std::string> m_flavours;
420 
421  // ------------------------------------------------------------------------------------------
422 
423  // Eigenvector variations functionality
424 
426  std::map<const CalibrationDataContainer*, std::shared_ptr<CalibrationDataEigenVariations> > m_eigenVariationsMap;
427 
430  Uncertainty m_EVStrategy{}; // <--- In addition, specify whether to use the global eigenvariations method
431 
433  std::map<std::string, Analysis::EVReductionStrategy> m_EVReductions;
434 
436  std::map<std::string, std::vector<std::string> > m_excludeFromCovMatrix;
437  // <--------- The above maps the flavour of the jet to the string of uncertainties to exclude from EV on that jet flavour
438 
439 
442 
444  bool m_verbose{};
445 
446  // ------------------------------------------------------------------------------------------
447 
448  // MC/MC scale factors functionality
449 
452  bool m_useMCMCSF{};
456 
459  std::map<std::string, HadronisationReferenceHelper*> m_refMap;
461  std::vector<int> m_hadronisationReference;
462 
463  // ------------------------------------------------------------------------------------------
464 
465  // map storing coefficient calculated by EigenRecomposition.
466  std::map<std::string, std::map<std::string, float>> m_coefficientMap;
467 
468  // ------------------------------------------------------------------------------------------
469 
470  // Bounds checking functionality
471 
473  double m_maxAbsEta{};
476 
477  [[nodiscard]] bool checkAbsEta(const CalibrationDataVariables& variables, unsigned int index);
478 
480  std::vector<unsigned int> m_etaCounters;
481  std::vector<unsigned int> m_mainCounters;
482  std::vector<unsigned int> m_extrapolatedCounters;
483  // std::vector<unsigned int> m_tagWeightCounters;
484  void increaseCounter(unsigned int index, OutOfBoundsType oob = Main);
485 
486  // for (one-time) checks of scale factors
487  void checkWeightScaleFactors(unsigned int indexSF, unsigned int indexEff);
488  std::vector<std::pair<unsigned int, unsigned int> > m_checkedWeightScaleFactors;
489  double m_maxTagWeight{};
490 
491  // make it possible to persistify this class (for PROOF purposes)
492  ClassDef(CalibrationDataInterfaceROOT,1) // platform-independent (main) interface for access to b-tagging information
493  };
494 
495 } // end of namespace
496 
497 #endif // ANALYSISCALIBRATIONDATAINTERFACEROOT_H
Analysis::CalibResult
std::pair< double, double > CalibResult
Definition: CalibrationDataInterfaceBase.h:34
Analysis::GiveUp
@ GiveUp
Definition: CalibrationDataInterfaceROOT.h:82
Analysis::CalibrationDataInterfaceROOT::m_maxAbsEta
double m_maxAbsEta
|eta| bounds and strategy for dealing with out-of-bounds conditions
Definition: CalibrationDataInterfaceROOT.h:473
Analysis::CalibrationDataInterfaceROOT::m_EVReductions
std::map< std::string, Analysis::EVReductionStrategy > m_EVReductions
Eigenvector reduction strategy (per flavour)
Definition: CalibrationDataInterfaceROOT.h:433
Analysis::CalibrationDataInterfaceROOT::nameFromIndex
std::string nameFromIndex(unsigned int index) const
Retrieve the name of the calibration object (container) given its index.
Definition: CalibrationDataInterfaceROOT.cxx:1945
Analysis::CalibrationDataInterfaceROOT::m_EVStrategy
Uncertainty m_EVStrategy
Definition: CalibrationDataInterfaceROOT.h:430
get_generator_info.result
result
Definition: get_generator_info.py:21
Analysis::CalibrationDataContainer
Definition: CalibrationDataContainer.h:51
Analysis::CalibrationDataInterfaceROOT::m_useRecommendedEVExclusions
bool m_useRecommendedEVExclusions
if true, exclude pre-recommended lists of uncertainties from the covariance matrix building,...
Definition: CalibrationDataInterfaceROOT.h:441
checkCoolLatestUpdate.variables
variables
Definition: checkCoolLatestUpdate.py:13
Analysis::CalibrationDataInterfaceROOT::CalibrationDataInterfaceROOT
CalibrationDataInterfaceROOT()
default constructor for PROOF object retrieval
Definition: CalibrationDataInterfaceROOT.cxx:603
Analysis::CalibrationDataInterfaceROOT::fullName
std::string fullName(const std::string &author, const std::string &OP, const std::string &label, bool isSF, unsigned mapIndex=0) const
@ brief construct the full object pathname from its individual components
Definition: CalibrationDataInterfaceROOT.cxx:2721
Analysis::CalibrationDataInterfaceROOT::m_etaCounters
std::vector< unsigned int > m_etaCounters
counters for flagging out-of-bound cases
Definition: CalibrationDataInterfaceROOT.h:480
Analysis::CalibrationDataInterfaceROOT::m_hadronisationReference
std::vector< int > m_hadronisationReference
store the 'hadronisation' reference for each object (-1 means no reference found)
Definition: CalibrationDataInterfaceROOT.h:461
Analysis::CalibrationDataInterfaceBase
Definition: CalibrationDataInterfaceBase.h:47
CaloCondBlobAlgs_fillNoiseFromASCII.spec
spec
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:47
index
Definition: index.py:1
Analysis::SFNamed
@ SFNamed
Definition: CalibrationDataInterfaceROOT.h:70
PlotCalibFromCool.label
label
Definition: PlotCalibFromCool.py:78
Analysis::CalibrationDataInterfaceROOT::runEigenVectorRecomposition
CalibrationStatus runEigenVectorRecomposition(const std::string &author, const std::string &label, const std::string &OP, unsigned int mapindex=0)
run EigenVector Recomposition method
Definition: CalibrationDataInterfaceROOT.cxx:2207
Analysis::CalibrationDataInterfaceROOT::getWeightScaleFactor
CalibResult getWeightScaleFactor(const CalibrationDataVariables &variables, const std::string &label, Uncertainty unc, unsigned int numVariation=0, unsigned int mapIndex=0)
efficiency scale factor retrieval by name
Definition: CalibrationDataInterfaceROOT.cxx:1485
Analysis::Statistical
@ Statistical
Definition: CalibrationDataInterfaceROOT.h:70
Analysis::TagWeight
@ TagWeight
Definition: CalibrationDataInterfaceROOT.h:85
Analysis::CalibrationDataInterfaceROOT::getShiftedScaleFactors
const TH1 * getShiftedScaleFactors(const std::string &author, const std::string &label, const std::string &OP, const std::string &unc, double sigmas)
retrieve the binned calibration object for the given flavour label and operating point,...
Definition: CalibrationDataInterfaceROOT.cxx:2158
Analysis::CalibrationDataInterfaceROOT::initialize
void initialize(const std::string &jetauthor, const std::string &OP, Uncertainty unc)
initialization for PROOF usage
Definition: CalibrationDataInterfaceROOT.cxx:2484
Analysis::OutOfBoundsStrategy
OutOfBoundsStrategy
strategies for dealing with specified kinematic variables being outside their range of validity: igno...
Definition: CalibrationDataInterfaceROOT.h:82
CalibrationDataVariables.h
Analysis::CalibrationDataInterfaceROOT::HadronisationReferenceHelper::HadronisationReferenceHelper
HadronisationReferenceHelper()
Definition: CalibrationDataInterfaceROOT.h:367
Analysis::CalibrationDataInterfaceROOT::m_checkedWeightScaleFactors
std::vector< std::pair< unsigned int, unsigned int > > m_checkedWeightScaleFactors
Definition: CalibrationDataInterfaceROOT.h:488
Analysis::TauExtrapolation
@ TauExtrapolation
Definition: CalibrationDataInterfaceROOT.h:70
Analysis::CalibrationDataInterfaceROOT::getNumVariations
unsigned int getNumVariations(const std::string &author, const std::string &label, const std::string &OP, Uncertainty unc)
retrieve the number of variations relevant to the calibration object.
Definition: CalibrationDataInterfaceROOT.cxx:2063
Analysis::EVReductionStrategy
EVReductionStrategy
specification of Eigenvector variations reduction strategy.
Definition: CalibrationDataInterfaceROOT.h:73
Analysis::CalibrationDataInterfaceROOT::m_eigenVariationsMap
std::map< const CalibrationDataContainer *, std::shared_ptr< CalibrationDataEigenVariations > > m_eigenVariationsMap
store the eigenvector class and associate to its CalibrationDataContainer
Definition: CalibrationDataInterfaceROOT.h:426
Analysis::Main
@ Main
Definition: CalibrationDataInterfaceROOT.h:85
Analysis::CalibrationDataInterfaceROOT::HadronisationReferenceHelper
Definition: CalibrationDataInterfaceROOT.h:363
Analysis::Total
@ Total
Definition: CalibrationDataInterfaceROOT.h:70
Analysis::CalibrationDataInterfaceROOT::m_excludeFromCovMatrix
std::map< std::string, std::vector< std::string > > m_excludeFromCovMatrix
store the uncertainties which should be excluded from building the full covariance matrix
Definition: CalibrationDataInterfaceROOT.h:436
Analysis::CalibrationDataInterfaceROOT::m_absEtaStrategy
OutOfBoundsStrategy m_absEtaStrategy
Definition: CalibrationDataInterfaceROOT.h:474
Analysis::CalibrationDataInterfaceROOT::retrieveContainer
CalibrationDataContainer * retrieveContainer(const std::string &label, const std::string &OP, const std::string &author, const std::string &cntname, bool isSF, bool doPrint=true)
utility function taking care of object retrieval
Definition: CalibrationDataInterfaceROOT.cxx:2523
Analysis::GiveUpExtrapolated
@ GiveUpExtrapolated
Definition: CalibrationDataInterfaceROOT.h:82
Analysis::CalibrationDataInterfaceROOT::getEfficiency
CalibResult getEfficiency(const CalibrationDataVariables &variables, const std::string &label, const std::string &OP, Uncertainty unc, const std::string &flavour, unsigned int numVariation=0, unsigned int mapIndex=0)
efficiency retrieval by name
Definition: CalibrationDataInterfaceROOT.cxx:1071
Analysis::CalibrationDataInterfaceROOT::m_verbose
bool m_verbose
if true, allow also for some informational (and not only error/warning) messages
Definition: CalibrationDataInterfaceROOT.h:444
Analysis::CalibrationDataInterfaceROOT::m_otherStrategy
OutOfBoundsStrategy m_otherStrategy
Definition: CalibrationDataInterfaceROOT.h:475
Analysis::Uncertainty
Uncertainty
specification of type information requested by the user
Definition: CalibrationDataInterfaceROOT.h:70
Analysis::Medium
@ Medium
Definition: CalibrationDataInterfaceROOT.h:73
Analysis::CalibrationDataInterfaceROOT::m_filenameSF
std::string m_filenameSF
in addition, store also the filenames themselves (needed for the copy constructor)
Definition: CalibrationDataInterfaceROOT.h:417
Analysis::CalibrationDataInterfaceROOT::~CalibrationDataInterfaceROOT
virtual ~CalibrationDataInterfaceROOT()
default destructor
Definition: CalibrationDataInterfaceROOT.cxx:633
Analysis::CalibrationDataInterfaceROOT::m_refMap
std::map< std::string, HadronisationReferenceHelper * > m_refMap
the following maps (one for each directory) specify the name of the container serving as the 'hadroni...
Definition: CalibrationDataInterfaceROOT.h:459
Analysis::CalibrationDataInterfaceROOT::m_flavours
std::vector< std::string > m_flavours
Definition: CalibrationDataInterfaceROOT.h:419
Analysis::CalibrationDataInterfaceROOT::m_useTopologyRescaling
bool m_useTopologyRescaling
specify whether or not to use MC/MC (topology) scale factors (also this steering option may be remove...
Definition: CalibrationDataInterfaceROOT.h:455
Analysis::CalibrationDataInterfaceROOT::CalibrationDataInterfaceROOT
CalibrationDataInterfaceROOT(const std::string &taggerName, const std::string &configname="BTagCalibration.env", const std::string &pathname="")
main constructor for "stand-alone" use (with information fed in from a .env configuration file read b...
Analysis::Loose
@ Loose
Definition: CalibrationDataInterfaceROOT.h:73
Analysis::CalibrationDataInterfaceROOT::getMCMCScaleFactor
double getMCMCScaleFactor(const CalibrationDataVariables &variables, unsigned indexSF, unsigned int indexEff) const
MC/MC scale factor retrieval.
Definition: CalibrationDataInterfaceROOT.cxx:1465
Analysis::SFEigen
@ SFEigen
Definition: CalibrationDataInterfaceROOT.h:70
Analysis::CalibrationDataInterfaceROOT::listScaleFactorUncertainties
std::vector< std::string > listScaleFactorUncertainties(const std::string &author, const std::string &label, const std::string &OP, bool named=false)
retrieve the list of "uncertainties" relevant to the calibration object.
Definition: CalibrationDataInterfaceROOT.cxx:1987
Analysis::CalibrationDataInterfaceROOT::getMCEfficiency
CalibResult getMCEfficiency(const CalibrationDataVariables &variables, const std::string &label, const std::string &OP, Uncertainty unc=None, unsigned int mapIndex=0)
"MC" efficiency retrieval by name
Definition: CalibrationDataInterfaceROOT.cxx:963
Analysis::CalibrationDataInterfaceROOT::m_aliases
std::map< std::string, std::string > m_aliases
Do not attempt to persistify (PROOF)
Definition: CalibrationDataInterfaceROOT.h:405
Analysis::CalibrationDataInterfaceROOT::retrieveCalibrationIndex
bool retrieveCalibrationIndex(const std::string &label, const std::string &OP, const std::string &author, bool isSF, unsigned int &index, unsigned int mapIndex=0)
Retrieve the index of the calibration object (container) starting from the label and operating point.
Definition: CalibrationDataInterfaceROOT.cxx:688
Analysis::CalibrationDataInterfaceROOT::HadronisationReferenceHelper::m_refs
std::map< std::string, std::string > m_refs
map from hadronisation specification to container name
Definition: CalibrationDataInterfaceROOT.h:376
Analysis::CalibrationDataInterfaceROOT::getMCInefficiency
CalibResult getMCInefficiency(const CalibrationDataVariables &variables, const std::string &label, const std::string &OP, Uncertainty unc=None, unsigned int mapIndex=0)
"MC" inefficiency retrieval by name
Definition: CalibrationDataInterfaceROOT.cxx:1422
Analysis::CalibrationDataInterfaceROOT::m_filenameEff
std::string m_filenameEff
Definition: CalibrationDataInterfaceROOT.h:418
Analysis::CalibrationDataInterfaceROOT::m_coefficientMap
std::map< std::string, std::map< std::string, float > > m_coefficientMap
Definition: CalibrationDataInterfaceROOT.h:466
Analysis::CalibrationDataInterfaceROOT::increaseCounter
void increaseCounter(unsigned int index, OutOfBoundsType oob=Main)
Definition: CalibrationDataInterfaceROOT.cxx:1959
Analysis::Extrapolated
@ Extrapolated
Definition: CalibrationDataInterfaceROOT.h:85
Analysis
The namespace of all packages in PhysicsAnalysis/JetTagging.
Definition: BTaggingCnvAlg.h:20
Analysis::CalibrationStatus
CalibrationStatus
Definition: CalibrationDataVariables.h:56
Analysis::OutOfBoundsType
OutOfBoundsType
counter types (to be used when flagging out-of-bounds cases)
Definition: CalibrationDataInterfaceROOT.h:85
Analysis::Eta
@ Eta
Definition: CalibrationDataInterfaceROOT.h:85
Analysis::CalibrationDataInterfaceROOT::m_useMCMCSF
bool m_useMCMCSF
specify whether or not to use MC/MC (hadronisation) scale factors (the fact that this is steerable is...
Definition: CalibrationDataInterfaceROOT.h:452
Analysis::CalibrationDataInterfaceROOT::HadronisationReferenceHelper::getReference
bool getReference(const std::string &spec, std::string &ref) const
Retrieve the (full) name of the reference histogram, given the hadronisation specification.
Definition: CalibrationDataInterfaceROOT.cxx:2776
Analysis::CalibrationDataInterfaceROOT::checkAbsEta
bool checkAbsEta(const CalibrationDataVariables &variables, unsigned int index)
Definition: CalibrationDataInterfaceROOT.cxx:1919
Analysis::CalibrationDataInterfaceROOT::getInefficiency
CalibResult getInefficiency(const CalibrationDataVariables &variables, const std::string &label, const std::string &OP, Uncertainty unc, unsigned int numVariation=0, unsigned int mapIndex=0)
inefficiency retrieval by name
Definition: CalibrationDataInterfaceROOT.cxx:1307
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
Analysis::CalibrationDataInterfaceROOT::m_maxTagWeight
double m_maxTagWeight
Definition: CalibrationDataInterfaceROOT.h:489
ref
const boost::regex ref(r_ef)
Analysis::CalibrationDataInterfaceROOT
Definition: CalibrationDataInterfaceROOT.h:88
Analysis::SFGlobalEigen
@ SFGlobalEigen
Definition: CalibrationDataInterfaceROOT.h:70
Analysis::CalibrationDataInterfaceROOT::m_objectIndices
std::map< std::string, unsigned int > m_objectIndices
Definition: CalibrationDataInterfaceROOT.h:411
Analysis::CalibrationDataInterfaceROOT::m_runEigenVectorMethod
bool m_runEigenVectorMethod
decide whether to run the eigenvector method or not
Definition: CalibrationDataInterfaceROOT.h:429
python.TriggerHandler.verbose
verbose
Definition: TriggerHandler.py:297
Analysis::CalibrationDataInterfaceROOT::getScaleFactor
CalibResult getScaleFactor(const CalibrationDataVariables &variables, const std::string &label, const std::string &OP, Uncertainty unc, unsigned int numVariation=0, unsigned int mapIndex=0)
efficiency scale factor retrieval by name.
Definition: CalibrationDataInterfaceROOT.cxx:736
CaloCondBlobAlgs_fillNoiseFromASCII.author
string author
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:26
Analysis::CalibrationDataInterfaceROOT::checkWeightScaleFactors
void checkWeightScaleFactors(unsigned int indexSF, unsigned int indexEff)
Definition: CalibrationDataInterfaceROOT.cxx:1763
Analysis::CalibrationDataVariables
Definition: CalibrationDataVariables.h:42
Analysis::Ignore
@ Ignore
Definition: CalibrationDataInterfaceROOT.h:82
Analysis::None
@ None
Definition: CalibrationDataInterfaceROOT.h:70
Analysis::CalibrationDataInterfaceROOT::getInefficiencyScaleFactor
CalibResult getInefficiencyScaleFactor(const CalibrationDataVariables &variables, const std::string &label, const std::string &OP, Uncertainty unc, unsigned int numVariation=0, unsigned int mapIndex=0)
"MC" inefficiency scale factor retrieval by name
Definition: CalibrationDataInterfaceROOT.cxx:1186
Analysis::CalibrationDataInterfaceROOT::m_fileSF
TFile * m_fileSF
Do not attempt to persistify (PROOF)
Definition: CalibrationDataInterfaceROOT.h:401
Analysis::Tight
@ Tight
Definition: CalibrationDataInterfaceROOT.h:73
Analysis::Systematic
@ Systematic
Definition: CalibrationDataInterfaceROOT.h:70
CalibrationDataInterfaceBase.h
Analysis::Flag
@ Flag
Definition: CalibrationDataInterfaceROOT.h:82
Analysis::Extrapolation
@ Extrapolation
Definition: CalibrationDataInterfaceROOT.h:70
Analysis::CalibrationDataInterfaceROOT::getAlias
std::string getAlias(const std::string &author) const
associated alias retrieval method
Definition: CalibrationDataInterfaceROOT.cxx:2710
Analysis::CalibrationDataInterfaceROOT::getMCEfficiencyObject
const TObject * getMCEfficiencyObject(const std::string &author, const std::string &label, const std::string &OP, unsigned int mapIndex=0)
retrieve the MC efficiency (central values) object for the given flavour label and operating point.
Definition: CalibrationDataInterfaceROOT.cxx:2130
Analysis::CalibrationDataInterfaceROOT::m_objects
std::vector< CalibrationDataContainer * > m_objects
cache the objects themselves (so that the user will not have to delete them after each call etc....
Definition: CalibrationDataInterfaceROOT.h:410
Analysis::CalibrationDataInterfaceROOT::m_extrapolatedCounters
std::vector< unsigned int > m_extrapolatedCounters
Definition: CalibrationDataInterfaceROOT.h:482
Analysis::CalibrationDataInterfaceROOT::getScaleFactorCovarianceMatrix
TMatrixDSym getScaleFactorCovarianceMatrix(const std::string &author, const std::string &label, const std::string &OP, const std::string &unc="all")
retrieve the named covariance matrix element corresponding to the binned calibration object.
Definition: CalibrationDataInterfaceROOT.cxx:2415
Analysis::CalibrationDataInterfaceROOT::m_mainCounters
std::vector< unsigned int > m_mainCounters
Definition: CalibrationDataInterfaceROOT.h:481
Analysis::CalibrationDataInterfaceROOT::m_fileEff
TFile * m_fileEff
pointer to the TFile object providing access to the calibrations
Definition: CalibrationDataInterfaceROOT.h:400
Analysis::CalibrationDataInterfaceROOT::getBinnedScaleFactors
const TH1 * getBinnedScaleFactors(const std::string &author, const std::string &label, const std::string &OP)
retrieve the binned calibration object for the given flavour label and operating point.
Definition: CalibrationDataInterfaceROOT.cxx:2108
Analysis::CalibrationDataInterfaceROOT::getEigenVectorRecompositionCoefficientMap
std::map< std::string, std::map< std::string, float > > getEigenVectorRecompositionCoefficientMap()
Get Eigenvector recomposition map after running runEigenVectorRecomposition()
Definition: CalibrationDataInterfaceROOT.cxx:2267