BTaggingEfficiencyTool Class Reference

#include <BTaggingEfficiencyTool.h>

Inheritance diagram for BTaggingEfficiencyTool:

Classes
struct	SystInfo

Public Member Functions
	BTaggingEfficiencyTool (const std::string &name)
	Create a proper constructor for Athena.
virtual	~BTaggingEfficiencyTool ()
	Create a constructor for standalone usage.
CP::CorrectionCode	getEigenRecompositionCoefficientMap (const std::string &label, std::map< std::string, std::map< std::string, float > > &coefficientMap)
	Run EigenvectorRecomposition method and get the coefficient map.
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Methods implementing the main jet-by-jet access in the xAOD context
CP::CorrectionCode	getScaleFactor (const xAOD::Jet &jet, float &sf)
	Computes the data/MC efficiency scale factor for the given jet.
CP::CorrectionCode	getEfficiency (const xAOD::Jet &jet, float &eff)
	Computes the data efficiency for the given jet.
CP::CorrectionCode	getInefficiency (const xAOD::Jet &jet, float &eff)
	Computes the data inefficiency for the given jet.
CP::CorrectionCode	getInefficiencyScaleFactor (const xAOD::Jet &jet, float &sf)
	Computes the data/MC inefficiency scale factor for the given jet.
CP::CorrectionCode	getMCEfficiency (const xAOD::Jet &jet, float &eff)
	Computes the MC efficiency for the given jet.
Methods equivalent to those above but not relying on the xAOD format
CP::CorrectionCode	getScaleFactor (int flavour, const Analysis::CalibrationDataVariables &v, float &sf)
	Computes the data/MC efficiency scale factor for the jet, given its kinematics, (possibly) tagger weight and truth flavour.
CP::CorrectionCode	getEfficiency (int flavour, const Analysis::CalibrationDataVariables &v, float &eff)
	Computes the data efficiency for the jet, given its kinematics, (possibly) tagger weight and truth flavour.
CP::CorrectionCode	getInefficiency (int flavour, const Analysis::CalibrationDataVariables &v, float &eff)
	Computes the data inefficiency for the jet, given its kinematics, (possibly) tagger weight and truth flavour.
CP::CorrectionCode	getInefficiencyScaleFactor (int flavour, const Analysis::CalibrationDataVariables &v, float &sf)
	Computes the data/MC inefficiency scale factor for the jet, given its kinematics, (possibly) tagger weight and truth flavour.
CP::CorrectionCode	getMCEfficiency (int flavour, const Analysis::CalibrationDataVariables &v, float &eff)
	Computes the MC efficiency for the jet, given its kinematics, (possibly) tagger weight and truth flavour.
CP::CorrectionCode	getMCEfficiencyONNX (const std::vector< std::vector< float > > &node_feat, std::vector< float > &effAllJet)
	Computes the MC efficiency of the jets in a given event.
CP::CorrectionCode	getMCEfficiencyONNX (const std::vector< std::vector< float > > &node_feat, std::vector< std::vector< float > > &effAllJetAllWp)
	Computes the MC efficiency of the jets in a given event.
Other methods implementing the IBTagEfficiencyTool interface
StatusCode	initialize ()
	Initialise the tool.
StatusCode	applySystematicVariation (const CP::SystematicSet &set)
	Set the tool to return "shifted" values.
CP::SystematicSet	affectingSystematics () const
	Return a list of all systematic variations supported by this tool.
CP::SystematicSet	recommendedSystematics () const
	Return a list of "recommended" systematic variations supported by this tool.
bool	isAffectedBySystematic (const CP::SystematicVariation &systematic) const
	Returns whether or not the given systematic variation is supported by this tool.
bool	setMapIndex (const std::string &flavour, unsigned int index)
	Specify the "map index" to be used for the given jet flavour (at initialisation time it will be set to 0).
bool	setMapIndex (unsigned int dsid)
query methods
Utility method returning a detailed list of systematics (including the flavours to which they apply)
const std::map< CP::SystematicVariation, std::vector< std::string > >	listSystematics () const
const std::string &	getTaggerName () const
	Retrieve the name of the tagger (as specified in the calibration file)
const std::string &	getOperatingPoint () const
	Retrieve the operating point (as specified in the calibration file)
const std::string &	getJetAuthor () const
	Retrieve the jet collection name (as specified in the calibration file) for which this tool was setup.
bool	applySystematics () const
	Specify whether any systematic variation is being used at present.
std::map< std::string, std::vector< std::string > >	listScaleFactorSystematics (bool named=false) const
	This merely passes on the request to the underlying CDI object (listSystematics() cannot be used here, as corresponding CP::SystematicVariation objects may not exist).
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	addSystematics (const std::vector< std::string > &systematicNames, unsigned int flavourID, Analysis::Uncertainty uncType)
	add entries to the systematics registry
std::vector< std::string >	makeEigenSyst (const std::string &flav, int number, const std::string &suffix)
	generate names for the eigenvector variations for the given jet flavour
bool	getIndices (unsigned int flavour, unsigned int &sf, unsigned int &ef) const
	helper function for retrieving object indices
std::string	getLabel (int flavourID) const
	convert integer flavour index to its string equivalent
unsigned int	getFlavourID (const std::string &label, bool conventional=true) const
	convert string flavour to its integer index equivalent
bool	fillVariables (const xAOD::Jet &jet, Analysis::CalibrationDataVariables &x) const
	Fill the Analysis::CalibrationDataVariables struct with relevant information pertaining to the jet considered.
bool	fillVariables (const double jetPt, const double jetEta, const double jetTagWeight, Analysis::CalibrationDataVariables &x) const
	Fill the Analysis::CalibrationDataVariables struct with relevant information pertaining to the jet considered.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::shared_ptr< Analysis::CalibrationDataInterfaceROOT >	m_CDI
	pointer to the object doing the actual work
std::unique_ptr< SaltModel >	m_saltModel
	pointer to the onnx tool
Gaudi::Property< bool >	m_useFlex {this, "useFlexibleConfig", false, "Setup the flexible configuration of the xAODBTaggingEfficiencyTool with alternate labeling"}
std::vector< std::string >	m_flex_labels
std::vector< unsigned int >	m_flex_label_integers
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
core configuration properties (set at initalization time and not modified afterwards)
asg::AnaToolHandle< IBTaggingSelectionTool >	m_selectionTool
	we need access to a BTaggingSelectionTool, at least for DL1 weight computation
Gaudi::Property< std::string >	m_SFFile {this, "ScaleFactorFileName", ftag::defaults::cdi_path, "name of the official scale factor calibration CDI file (uses PathResolver)"}
	name of the data/MC efficiency scale factor calibration file (may be changed by the PathResolver)
std::string	m_SFFileFull
Gaudi::Property< std::string >	m_SelectionCDIFile {this, "SelectionCDIFileName", "", "name of the CDI file to be used to configure the selection tool if needed, will use the SF CDI file by default"}
Gaudi::Property< std::string >	m_EffFile {this, "EfficiencyFileName", "", "name of optional user-provided MC efficiency CDI file"}
	name of the optional MC efficiency file (may be changed by the PathResolver)
Gaudi::Property< std::string >	m_EffConfigFile {this, "EfficiencyConfig", "", "name of config file specifying which efficiency map to use with a given samples DSID"}
Gaudi::Property< std::string >	m_SFNamesB {this, "ScaleFactorBCalibration", "default", "name of b-jet scale factor calibration object"}
	names of the data/MC scale factor calibrations
Gaudi::Property< std::string >	m_SFNamesC {this, "ScaleFactorCCalibration", "default", "name of c-jet scale factor calibration object"}
Gaudi::Property< std::string >	m_SFNamesT {this, "ScaleFactorTCalibration", "default", "name of tau-jet scale factor calibration object"}
Gaudi::Property< std::string >	m_SFNamesLight {this, "ScaleFactorLightCalibration", "default", "name of light-flavour jet scale factor calibration object"}
std::map< std::string, std::string >	m_SFNames
Gaudi::Property< std::string >	m_EVReductionB {this, "EigenvectorReductionB", "Loose", "b-jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"}
	specification of the eigenvector reduction strategy (if eigenvectors are used)
Gaudi::Property< std::string >	m_EVReductionC {this, "EigenvectorReductionC", "Loose", "c-jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"}
Gaudi::Property< std::string >	m_EVReductionLight {this, "EigenvectorReductionLight", "Loose", "light-flavour jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"}
std::map< std::string, std::string >	m_EVReduction
Gaudi::Property< std::string >	m_EffNamesB {this, "EfficiencyBCalibrations", "", "(semicolon-separated) name(s) of b-jet efficiency object(s)"}
	semicolon-separated lists of MC efficiency parametrisation names
Gaudi::Property< std::string >	m_EffNamesC {this, "EfficiencyCCalibrations", "", "(semicolon-separated) name(s) of c-jet efficiency object(s)"}
Gaudi::Property< std::string >	m_EffNamesT {this, "EfficiencyTCalibrations", "", "(semicolon-separated) name(s) of tau-jet efficiency object(s)"}
Gaudi::Property< std::string >	m_EffNamesLight {this, "EfficiencyLightCalibrations", "", "(semicolon-separated) name(s) of light-flavour-jet efficiency object(s)"}
std::map< std::string, std::string >	m_EffNames
Gaudi::Property< std::string >	m_effName {this, "EfficiencyCalibrations", "default", "default for all flavors"}
Gaudi::Property< std::string >	m_excludeFromEV {this, "ExcludeFromEigenVectorTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from all eigenvector decompositions (if used)"}
	semicolon-separated list of uncertainties to be excluded from the eigenvector variation procedure for all flavours
Gaudi::Property< std::string >	m_excludeFlvFromEVB {this, "ExcludeFromEigenVectorBTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from b-jet eigenvector decompositions (if used)"}
	semicolon-separated list of uncertainties to be excluded from the eigenvector variation procedure for b, c, and light-flavour jets
Gaudi::Property< std::string >	m_excludeFlvFromEVC {this, "ExcludeFromEigenVectorCTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from c-jet eigenvector decompositions (if used)"}
Gaudi::Property< std::string >	m_excludeFlvFromEVLight {this, "ExcludeFromEigenVectorLightTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from light-flavour-jet eigenvector decompositions (if used)"}
std::map< std::string, std::string >	m_excludeFlvFromEV
Gaudi::Property< std::string >	m_uncertaintySuffixesB {this, "UncertaintyBSuffix", "", "optional suffix for b-jet uncertainty naming"}
	optional (per-flavour) suffix that can be used to decorrelate uncertainties (between flavours, or -in case of a result from different runs- between periods)
Gaudi::Property< std::string >	m_uncertaintySuffixesC {this, "UncertaintyCSuffix", "", "optional suffix for c-jet uncertainty naming"}
Gaudi::Property< std::string >	m_uncertaintySuffixesT {this, "UncertaintyTSuffix", "", "optional suffix for tau-jet uncertainty naming"}
Gaudi::Property< std::string >	m_uncertaintySuffixesLight {this, "UncertaintyLightSuffix", "", "optional suffix for light-flavour-jet uncertainty naming"}
std::map< std::string, std::string >	m_uncertaintySuffixes
bool	m_using_conventional_labels
Gaudi::Property< std::string >	m_SFName_flex {this, "FlexibleScaleFactorCalibrations", "", "(semicolon-separated) name of scale factor calibration object for (0,1,2..) indexed flavour labels, e.g. '0:default;1:default;2:default;3:default'"}
Gaudi::Property< std::string >	m_EVReduction_flex {this, "FlexibleEigenvectorReduction", "", "(semicolon-separated) list of eigenvector reduction strategy for (0,1,2..) indexed flavour labels; choose between 'Loose', 'Medium', 'Tight' for different labels, e.g. '0:Loose;1:Loose;2:Loose'"}
Gaudi::Property< std::string >	m_EffNames_flex {this, "FlexibleEfficiencyCalibrations", "", "(semicolon-separated) name(s) of efficiency object(s) names for (0,1,2..) indexed flavour labels, e.g. '0:default;1:default;2:default;3:default'"}
Gaudi::Property< std::string >	m_uncertaintySuffixes_flex {this, "FlexibleUncertaintySuffix", "", "optional (semicolon-separated) list of suffixes for (0,1,2..) indexed flavour label uncertainty naming, e.g. '0:;1:;2:;3:'"}
Gaudi::Property< std::string >	m_excludeFlvFromEV_flex {this, "FlexibleExcludeFromEVTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from (0,1,2..) indexed flavour eigenvector decompositions (if used), e.g. '0:;1:;2:;3:'"}
Gaudi::Property< std::string >	m_taggerName {this, "TaggerName", ftag::defaults::tagger, "tagging algorithm name as specified in CDI file"}
	tagger name
Gaudi::Property< std::string >	m_selectionTaggerName {this, "SelectionTaggerName", "", "tagging algorithm name as specified in selection CDI file, will use TaggerName by default"}
Gaudi::Property< std::string >	m_OP {this, "OperatingPoint", ftag::defaults::pcbt_op, "operating point as specified in CDI file"}
	operating point
Gaudi::Property< std::string >	m_jetAuthor {this, "JetAuthor", ftag::defaults::jet_collection, "jet collection & JVF/JVT specification in CDI file"}
	jet collection name
Gaudi::Property< float >	m_minPt {this, "MinPt", 0., "minimum jet pT cut"}
	minimum jet pT
Gaudi::Property< std::string >	m_systStrategy {this, "SystematicsStrategy", ftag::defaults::strategy, "name of systematics model; presently choose between 'SFEigen' and 'Envelope'"}
	systematics model to be used (current choices are "SFEigen", "SFEigenRefined", and "Envelope") // <-----— Addoing "SFGlobalEigen" to the list
Gaudi::Property< bool >	m_useDevFile
	if true, attempt to retrieve the data/MC efficiency scale factor calibration files from the @PathResolver development area
Gaudi::Property< bool >	m_coneFlavourLabel {this, "ConeFlavourLabel", true, "specify whether or not to use the cone-based flavour labelling instead of the default ghost association based labelling"}
	if true, use cone-based labelling (as opposed to ghost association)
Gaudi::Property< bool >	m_extFlavourLabel {this, "ExtendedFlavourLabel", false, "specify whether or not to use an 'extended' flavour labelling (allowing for multiple HF hadrons or perhaps partons)"}
	if true, use an 'extended' labelling (allowing for multiple HF hadrons -or perhaps partons- in the jet)
Gaudi::Property< bool >	m_useRecommendedEVExclusions {this, "ExcludeRecommendedFromEigenVectorTreatment", false, "specify whether or not to add recommended lists to the user specified eigenvector decomposition exclusion lists"}
	if true, extract pre-set lists of uncertainties to be recommended from the EV decomposition (in addition to user specified ones)
Gaudi::Property< bool >	m_ignoreOutOfValidityRange {this, "IgnoreOutOfValidityRange", false, "ignore out-of-extrapolation-range errors as returned by the underlying tool"}
	if true, ignore out-of-extrapolation range errors (i.e., return CorrectionCode::Ok if these are encountered)
Gaudi::Property< bool >	m_useCTag {this, "useCTagging", false, "Enabled only for FixedCut or Continuous WPs: define wether the cuts refer to b-tagging or c-tagging"}
	if false, suppress any non-error/warning printout from the underlying tool 1D tagging only: define wether the cuts refer to b-tagging or c-tagging
Gaudi::Property< bool >	m_readFromBTaggingObject {this, "readFromBTaggingObject", false, "Enabled to access btagging scores from xAOD::BTagging object; Can be disabled for GN2v01 to access the scores from the jet itself."}
Gaudi::Property< std::string >	m_pathToONNX {this, "pathToONNX", "", "path to the onnx file that will be used for inference"}
	if this string is empty, the onnx tool won't be created
Cached variables
bool	m_initialised
	flag to indicate tool is initialized correctly when set
bool	m_applySyst
SystInfo	m_applyThisSyst
std::map< CP::SystematicVariation, SystInfo >	m_systematicsInfo
CP::SystematicSet	m_systematics
bool	m_isContinuous
bool	m_isContinuous2D
std::map< std::string, unsigned int >	m_mapIndices
std::map< unsigned int, unsigned int >	m_SFIndices
	actual information identifying scale factor calibration objects
std::map< unsigned int, unsigned int >	m_EffIndices
	actual information identifying efficiency calibration objects
std::map< unsigned int, unsigned int >	m_DSID_to_MapIndex

Detailed Description

Definition at line 31 of file BTaggingEfficiencyTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

BTaggingEfficiencyTool()

BTaggingEfficiencyTool::BTaggingEfficiencyTool

(

const std::string &

name

)

Create a proper constructor for Athena.

Create a constructor for standalone usage

Definition at line 126 of file BTaggingEfficiencyTool.cxx.

                                                                      : asg::AsgTool( name ), m_selectionTool("") {
  // initialise some variables needed for caching
  // TODO : add configuration of the mapIndices - rather than just using the default of 0
  //m_mapIndices["Light"] = m_mapIndices["T"] = m_mapIndices["C"] = m_mapIndices["B"] = 0;
  m_initialised = false;
  m_applySyst      = false;
  m_isContinuous   = false;
  m_isContinuous2D = false;
  m_using_conventional_labels = false;
 
  // declare the selection tool to be private (not absolutely sure this is needed?)
  m_selectionTool.declarePropertyFor(this, "BTaggingSelectionTool", "selection tool to be used internally");
}

~BTaggingEfficiencyTool()

BTaggingEfficiencyTool::~BTaggingEfficiencyTool ( )

virtual

Create a constructor for standalone usage.

Definition at line 140 of file BTaggingEfficiencyTool.cxx.

                                                {
  //delete m_CDI;
}

Member Function Documentation

addSystematics()

bool BTaggingEfficiencyTool::addSystematics ( const std::vector< std::string > & systematicNames, unsigned int flavourID, Analysis::Uncertainty uncType )

private

add entries to the systematics registry

Definition at line 1403 of file BTaggingEfficiencyTool.cxx.

                                                                                                                                     {
  for (int i=0, n=systematicNames.size(); i<n; ++i) {
    const std::string systName = systematicNames[i];
    SystematicVariation up(systName,1);
    SystematicVariation down(systName,-1);
    std::map<SystematicVariation,SystInfo>::iterator iter = m_systematicsInfo.find(up);
    if (iter == m_systematicsInfo.end()) {
      // First case: new variation
      SystInfo info;
      info.isUp = true;
      info.uncType = uncType;
      info.indexMap[flavourID] = i;
      m_systematicsInfo[up] = info;
      ATH_MSG_VERBOSE("addSystematics: adding " << systName << " for flavour " << getLabel(flavourID));
      info.isUp = false;
      m_systematicsInfo[down]=info;
    } else {
      // Second case: already known variation. This can happen if a variation applies to more than one
      // jet flavour. Check that indeed it's not registered yet for the requested flavour.
      SystInfo info = iter->second; // make a copy
      std::map<unsigned int, unsigned int>::const_iterator indIter = info.indexMap.find(flavourID);
      if (indIter != info.indexMap.end()) {
        ATH_MSG_ERROR("addSystematics : flavourID " << flavourID << " is already in the map for uncertainty '" << systName << "', ignoring");
        continue;
      } else {
        info.indexMap[flavourID] = i;
        m_systematicsInfo[up] = info;
        ATH_MSG_VERBOSE("addSystematics: adding " << systName << " for flavour " << getLabel(flavourID));
        info.isUp = false;
        m_systematicsInfo[down] = info;
      }
    }
  }
  return true;
}

affectingSystematics()

SystematicSet BTaggingEfficiencyTool::affectingSystematics ( ) const

virtual

Return a list of all systematic variations supported by this tool.

Note that this list depends on the uncertainty model used, and on the (dynamic) configuration of the eigenvector variations (if this uncertainty model is used).

Implements CP::IReentrantSystematicsTool.

Definition at line 1101 of file BTaggingEfficiencyTool.cxx.

                                                                 {
  return m_systematics;
}

applySystematics()

bool BTaggingEfficiencyTool::applySystematics ( ) const

inline

Specify whether any systematic variation is being used at present.

Definition at line 197 of file BTaggingEfficiencyTool.h.

{ return m_applySyst;}

applySystematicVariation()

StatusCode BTaggingEfficiencyTool::applySystematicVariation ( const CP::SystematicSet & set )

virtual

Set the tool to return "shifted" values.

Note that only single-parameter variations or empty sets (the latter are to revert to nominal results) are supported at present; StatusCode::FAILURE will be returned for variations of multiple parameters or variations that aren't recognised.

Implements CP::ISystematicsTool.

Definition at line 1211 of file BTaggingEfficiencyTool.cxx.

                                                                                             {
  // If the user is doing the right thing, no need to use the costly filterForAffectingSystematics
  // i.e if only 1 variation passed and this variation is in the map. Else, resort to full logic.
  if (systConfig.size() == 1 ) {
    auto mapIter = m_systematicsInfo.find(*(systConfig.begin()));
    if (mapIter != m_systematicsInfo.end()) {
      m_applySyst = true;
      m_applyThisSyst = mapIter->second;
      ATH_MSG_VERBOSE("variation '" << systConfig.begin()->name() << "' applied successfully");
      return StatusCode::SUCCESS;
    }
  }
 
  // First filter out any systematics that do not apply to us
  SystematicSet filteredSysts;
  if (SystematicSet::filterForAffectingSystematics(systConfig, affectingSystematics(), filteredSysts) != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("received unsupported systematics: " << systConfig.name());
    return StatusCode::FAILURE;
  }
  // check the size of the remaining (filtered) SystematicSet
  if (filteredSysts.size() == 0) {
    // If it is 0 then turn off systematics
    ATH_MSG_VERBOSE("empty systematics set; nothing to be done");
    m_applySyst = false;
    return StatusCode::SUCCESS;
  } else if (filteredSysts.size() > 1) {
    // Restriction: we allow only a single systematic variation affecting b-tagging
    ATH_MSG_WARNING("more than a single b-tagging systematic variation requested but not (yet) supported");
    return StatusCode::FAILURE;
  } else {
    // Interpret the (single) remaining variation
    SystematicVariation var = *(filteredSysts.begin());
    auto mapIter = m_systematicsInfo.find(var);
    if (mapIter == m_systematicsInfo.end()) {
      ATH_MSG_WARNING("variation '" << var.name() << "' not found! Cannot apply");
      return StatusCode::FAILURE;
    }
    m_applySyst = true;
    m_applyThisSyst = mapIter->second;
    ATH_MSG_VERBOSE("variation '" << var.name() << "' applied successfully");
  }
  return StatusCode::SUCCESS;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

fillVariables() [1/2]

bool BTaggingEfficiencyTool::fillVariables ( const double jetPt, const double jetEta, const double jetTagWeight, Analysis::CalibrationDataVariables & x ) const

private

Fill the Analysis::CalibrationDataVariables struct with relevant information pertaining to the jet considered.

Definition at line 1288 of file BTaggingEfficiencyTool.cxx.

{
  x.jetPt = jetPt;
  x.jetEta = jetEta;
  x.jetTagWeight = jetTagWeight;
  x.jetAuthor = m_jetAuthor;
 
  return true;
}

fillVariables() [2/2]

bool BTaggingEfficiencyTool::fillVariables ( const xAOD::Jet & jet, Analysis::CalibrationDataVariables & x ) const

private

Fill the Analysis::CalibrationDataVariables struct with relevant information pertaining to the jet considered.

Returns

false if the requested information cannot be retrieved (this should never happen except if "continuous tagging" is used and the no b-tagging was applied to the jet)

Definition at line 1257 of file BTaggingEfficiencyTool.cxx.

{
  x.jetPt = jet.pt();
  x.jetEta = jet.eta();
  x.jetTagWeight = 0.;
  x.jetAuthor = m_jetAuthor;
  //bool weightOK = true;
 
  if (m_isContinuous2D){
    x.jetTagWeight = m_selectionTool->getQuantile(jet)+0.5;
  }
  else if (m_isContinuous) {
    if(m_readFromBTaggingObject){
        const xAOD::BTagging* tagInfo = xAOD::BTaggingUtilities::getBTagging( jet );
        if (!tagInfo) return false;
    }
    // For now, we defer the tag weight computation to the selection tool only in the case of DL1* (this is likely to be revisited)
    if (m_taggerName.value().find("DL1") != std::string::npos ||
    m_taggerName.value().find("GN1") != std::string::npos ||
    m_taggerName.value().find("GN2") != std::string::npos) {
      return (m_selectionTool->getTaggerWeight(jet, x.jetTagWeight, m_useCTag) == CP::CorrectionCode::Ok);
    } else {
      ATH_MSG_ERROR("BTaggingEfficiencyTool doesn't support tagger: "+m_taggerName);
      return CorrectionCode::Error;
    }
  }
 
  return true;
}

getEfficiency() [1/2]

CorrectionCode BTaggingEfficiencyTool::getEfficiency ( const xAOD::Jet & jet, float & eff )

virtual

Computes the data efficiency for the given jet.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Implements IBTaggingEfficiencyTool.

Definition at line 789 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) return CorrectionCode::Error;
 
  // get the btag label
  int flavour = jetFlavourLabel(jet, m_coneFlavourLabel, m_extFlavourLabel);
 
  Analysis::CalibrationDataVariables vars;
 
  if (! fillVariables(jet, vars)) {
    ATH_MSG_ERROR("unable to fill variables required for efficiency evaluation");
    return CorrectionCode::Error;
  }
 
  return getEfficiency(flavour, vars, eff);
}

getEfficiency() [2/2]

CorrectionCode BTaggingEfficiencyTool::getEfficiency	(	int	flavour,
		const Analysis::CalibrationDataVariables &	v,
		float &	eff )

Computes the data efficiency for the jet, given its kinematics, (possibly) tagger weight and truth flavour.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Definition at line 807 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) return CorrectionCode::Error;
 
  CalibResult result;
 
  unsigned int sfindex = 0;
  unsigned int efindex = 0;
 
  if( !getIndices(flavour,sfindex,efindex)) {
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getEfficiency call to getIndices failed " << flavour << " " << sfindex << " " << efindex);
    return CorrectionCode::Error;
  }
  Uncertainty unc = None;
  unsigned int unc_ind = 0;
 
  if( m_applySyst) {
    
    unc = m_applyThisSyst.uncType;
    // if( m_applyThisSyst.isNamed) {
    //   unc = SFNamed;
    // } else {
    //   unc = SFEigen;
    // }
    
    if(!m_applyThisSyst.getIndex(flavour,unc_ind)) {
      ATH_MSG_VERBOSE("getEfficiency: requested variation cannot be applied to flavour " << getLabel(flavour) << ", returning nominal result");
      unc = None;
    }
  }
 
  CalibrationStatus status = m_CDI->getEfficiency(v,sfindex,efindex, unc,unc_ind,result, getLabel(flavour));
  // Interpret what has been retrieved;
  // this depends both on the uncertainty type and on the up/down setting.
  eff = result.first; // central value or up variation
  if (m_applySyst && unc != None) {
    if (! (unc == SFEigen || unc == SFNamed)){
      eff += m_applyThisSyst.isUp ? result.second : -result.second ;
    } else if (!m_applyThisSyst.isUp) {
      eff = result.second; // down variation
    }
  }
  
  switch (status) {
  case Analysis::kError:
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getEfficiency call to underlying code returned a kError!");
    return CorrectionCode::Error;
  case Analysis::kRange:
  case Analysis::kExtrapolatedRange:
    return m_ignoreOutOfValidityRange ? CorrectionCode::Ok : CorrectionCode::OutOfValidityRange;
  case Analysis::kSuccess:
  default:
    return CorrectionCode::Ok;
  }
}

getEigenRecompositionCoefficientMap()

CorrectionCode BTaggingEfficiencyTool::getEigenRecompositionCoefficientMap ( const std::string & label, std::map< std::string, std::map< std::string, float > > & coefficientMap )

virtual

Run EigenvectorRecomposition method and get the coefficient map.

Calling EigenVectorRecomposition method in CDI and retrieve recomposition map. If success, coefficientMap would be filled and return ok. If failed, return error. label : flavour label coefficientMap: store returned coefficient map. This map could help expressing eigenvector NPs by linear combination of original uncertainty NPs in workspace level of physics analysis. The coefficient value is stored in the map in the format of: map<"Eigen_B_0", map<"[original uncertainty name]", [corresponding coefficient value]>>

Implements IBTaggingEfficiencyTool.

Definition at line 1183 of file BTaggingEfficiencyTool.cxx.

                                                                                                                                               {
  // Calling EigenVectorRecomposition method in CDI and retrieve recomposition map.
  // If success, coefficientMap would be filled and return ok.
  // If failed, return error.
  // label  :  flavour label
  // coefficientMap: store returned coefficient map.
  if (! m_initialised) {
    ATH_MSG_ERROR("BTaggingEfficiencyTool has not been initialised");
    return CorrectionCode::Error;
  }
  if(label.compare("B") != 0 &&
     label.compare("C") != 0 &&
     label.compare("T") != 0 &&
     label.compare("Light") != 0){
    ATH_MSG_ERROR("Flavour label is illegal! Label need to be B,C,T or Light.");
    return CorrectionCode::Error;
  }
  CalibrationStatus status = m_CDI->runEigenVectorRecomposition(m_jetAuthor, label, m_OP);
  if (status != Analysis::kSuccess){
    ATH_MSG_ERROR("Failure running EigenVectorRecomposition Method.");
    return CorrectionCode::Error;
  }
  coefficientMap = m_CDI->getEigenVectorRecompositionCoefficientMap();
  return CorrectionCode::Ok;
}

getFlavourID()

unsigned int BTaggingEfficiencyTool::getFlavourID ( const std::string & label, bool conventional = true ) const

inlineprivate

convert string flavour to its integer index equivalent

Definition at line 262 of file BTaggingEfficiencyTool.h.

                                                                                    {
    // always default to "light" = 0
    if( label.size() <1)
      return 0;
    if (conventional){
      switch (label[0]) {
      case 'B':
        return 5; break;
      case 'C':
        return 4; break;
      case 'T':
        return 15; break;
      default:
        return 0;
      }
    } else {
        ATH_MSG_WARNING("Non-conventional label, return flavour ID = 0!");
        return 0;
    }
  }

getIndices()

bool BTaggingEfficiencyTool::getIndices ( unsigned int flavour, unsigned int & sf, unsigned int & ef ) const

private

helper function for retrieving object indices

Definition at line 1371 of file BTaggingEfficiencyTool.cxx.

                                                                                                   {
  auto mapIter = m_SFIndices.find(flavour);
  if(mapIter != m_SFIndices.end()) {
    sf = mapIter->second;
  } else {
    return false;
  }
    
  mapIter = m_EffIndices.find(flavour);
  if(mapIter != m_EffIndices.end()) {
    ef = mapIter->second;
  } else {
    return false;
  }
  return true;
}

getInefficiency() [1/2]

CorrectionCode BTaggingEfficiencyTool::getInefficiency ( const xAOD::Jet & jet, float & eff )

virtual

Computes the data inefficiency for the given jet.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Implements IBTaggingEfficiencyTool.

Definition at line 865 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) return CorrectionCode::Error;
 
  // get the btag label
  int flavour = jetFlavourLabel(jet, m_coneFlavourLabel, m_extFlavourLabel);
 
  Analysis::CalibrationDataVariables vars;
  if (! fillVariables(jet, vars)) {
    ATH_MSG_ERROR("unable to fill variables required for scale factor evaluation");
    return CorrectionCode::Error;
  }
 
  return getInefficiency (flavour, vars, eff);
}

getInefficiency() [2/2]

CorrectionCode BTaggingEfficiencyTool::getInefficiency	(	int	flavour,
		const Analysis::CalibrationDataVariables &	v,
		float &	eff )

Computes the data inefficiency for the jet, given its kinematics, (possibly) tagger weight and truth flavour.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Definition at line 882 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) return CorrectionCode::Error;
 
  CalibResult result;
 
  unsigned int sfindex = 0;
  unsigned int efindex = 0;
 
  if( !getIndices(flavour,sfindex,efindex)) {
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getInefficiency call to getIndices failed " << flavour << " " << sfindex << " " << efindex);
    return CorrectionCode::Error;
  }
  Uncertainty unc = None;
  unsigned int unc_ind = 0;
  if( m_applySyst) {
    
    unc = m_applyThisSyst.uncType;
    // if( m_applyThisSyst.isNamed) {
    //   unc = SFNamed;
    // } else {
    //   unc = SFEigen;
    // }
    
    if(!m_applyThisSyst.getIndex(flavour,unc_ind)) {
      ATH_MSG_VERBOSE("getInefficiency: requested variation cannot be applied to flavour " << getLabel(flavour)
              << ", returning nominal result");
      unc = None;
    }
  }
 
  CalibrationStatus status = m_CDI->getInefficiency(v, sfindex, efindex, unc, unc_ind, result, getLabel(flavour));
  // Interpret what has been retrieved;
  // this depends both on the uncertainty type and on the up/down setting.
  // For the Total uncertainty, note also the sign change compared to e.g. getEfficiency().
  eff = result.first; // central value or up variation
  if (m_applySyst && unc != None) {
    if (! (unc == SFEigen || unc == SFNamed))
      eff += m_applyThisSyst.isUp ? -result.second : result.second ;
    else if (!m_applyThisSyst.isUp) {
      eff = result.second; // down variation
    }
  }
 
  switch (status) {
  case Analysis::kError:
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getInefficiency call to underlying code returned a kError!");
    return CorrectionCode::Error;
  case Analysis::kRange:
  case Analysis::kExtrapolatedRange:
    return m_ignoreOutOfValidityRange ? CorrectionCode::Ok : CorrectionCode::OutOfValidityRange;
  case Analysis::kSuccess:
  default:
    return CorrectionCode::Ok;
  }
}

getInefficiencyScaleFactor() [1/2]

CorrectionCode BTaggingEfficiencyTool::getInefficiencyScaleFactor ( const xAOD::Jet & jet, float & sf )

virtual

Computes the data/MC inefficiency scale factor for the given jet.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Implements IBTaggingEfficiencyTool.

Definition at line 941 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) return CorrectionCode::Error;
  if (m_isContinuous || m_isContinuous2D){
      ATH_MSG_ERROR("Inefficiency SF should NOT be included for the Continous operation point");
      return CorrectionCode::Error;
  }
 
  // get the btag label
  int flavour = jetFlavourLabel(jet, m_coneFlavourLabel, m_extFlavourLabel);
 
  Analysis::CalibrationDataVariables vars;
  if (! fillVariables(jet, vars)) {
    ATH_MSG_ERROR("unable to fill variables required for scale factor evaluation");
    return CorrectionCode::Error;
  }
  
  return getInefficiencyScaleFactor( flavour, vars, sf);
}

getInefficiencyScaleFactor() [2/2]

CorrectionCode BTaggingEfficiencyTool::getInefficiencyScaleFactor ( int flavour, const Analysis::CalibrationDataVariables & v, float & sf )

virtual

Computes the data/MC inefficiency scale factor for the jet, given its kinematics, (possibly) tagger weight and truth flavour.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Implements IBTaggingEfficiencyTool.

Definition at line 962 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) return CorrectionCode::Error;
  if (m_isContinuous || m_isContinuous2D){
      ATH_MSG_ERROR("Inefficiency SF should NOT be included for the Continous operation point");
      return CorrectionCode::Error;
  }
 
  CalibResult result;
 
  unsigned int sfindex = 0;
  unsigned int efindex = 0;
  
  if( !getIndices(flavour,sfindex,efindex)) {
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getInefficiencyScaleFactor call to getIndices failed " << flavour << " " << sfindex << " " << efindex);
    return CorrectionCode::Error;
  }
  Uncertainty unc=None;
  unsigned int unc_ind=0;
  if( m_applySyst) {
    
    unc = m_applyThisSyst.uncType;
    // if( m_applyThisSyst.isNamed) {
    //   unc = SFNamed;
    // } else {
    //   unc = SFEigen;
    // }
    
    if(!m_applyThisSyst.getIndex(flavour,unc_ind)) {
      ATH_MSG_VERBOSE("getInefficiencyScaleFactor: requested variation cannot be applied to flavour " << getLabel(flavour)
              << ", returning nominal result");
      unc = None;
    }
  }
 
  CalibrationStatus status = m_CDI->getInefficiencyScaleFactor(v,sfindex,efindex, unc, unc_ind, result, getLabel(flavour));
  // Interpret what has been retrieved;
  // this depends both on the uncertainty type and on the up/down setting.
  // For the Total uncertainty, note also the sign change compared to e.g. getScaleFactor().
  sf = result.first; // central value or up variation
  if (m_applySyst && unc != None) {
    if (! (unc == SFEigen || unc == SFNamed))
      sf += m_applyThisSyst.isUp ? -result.second : result.second ;
    else if (!m_applyThisSyst.isUp) {
      sf = result.second; // down variation
    }
  }
 
  switch (status) {
  case Analysis::kError:
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getInefficiencyScaleFactor call to underlying code returned a kError!");
    return CorrectionCode::Error;
  case Analysis::kRange:
  case Analysis::kExtrapolatedRange:
    return m_ignoreOutOfValidityRange ? CorrectionCode::Ok : CorrectionCode::OutOfValidityRange;
  case Analysis::kSuccess:
  default:
    return CorrectionCode::Ok;
  }
}

getJetAuthor()

const std::string & BTaggingEfficiencyTool::getJetAuthor ( ) const

inlinevirtual

Retrieve the jet collection name (as specified in the calibration file) for which this tool was setup.

Implements IBTaggingEfficiencyTool.

Definition at line 191 of file BTaggingEfficiencyTool.h.

{ return m_jetAuthor;}

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getLabel()

std::string BTaggingEfficiencyTool::getLabel ( int flavourID ) const

inlineprivate

convert integer flavour index to its string equivalent

Definition at line 242 of file BTaggingEfficiencyTool.h.

                                          {
    switch(flavourID) {
    case 5:
      return "B";
      break;
    case 4:
      return "C";
      break;
    case 15:
      return "T";
      break;
    case 0:
      return "Light";
      break;
    default:
      return "Light";
    }
  }

getMCEfficiency() [1/2]

CorrectionCode BTaggingEfficiencyTool::getMCEfficiency ( const xAOD::Jet & jet, float & eff )

virtual

Computes the MC efficiency for the given jet.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Implements IBTaggingEfficiencyTool.

Definition at line 1025 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) return CorrectionCode::Error;
 
  // get the btag label
  int flavour = jetFlavourLabel(jet, m_coneFlavourLabel, m_extFlavourLabel);
 
  Analysis::CalibrationDataVariables vars;
  if (! fillVariables(jet, vars)) {
    ATH_MSG_ERROR("unable to fill variables required for scale factor evaluation");
    return CorrectionCode::Error;
  }
  
  return getMCEfficiency( flavour, vars, eff);
}

getMCEfficiency() [2/2]

CorrectionCode BTaggingEfficiencyTool::getMCEfficiency ( int flavour, const Analysis::CalibrationDataVariables & v, float & eff )

virtual

Computes the MC efficiency for the jet, given its kinematics, (possibly) tagger weight and truth flavour.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Implements IBTaggingEfficiencyTool.

Definition at line 1042 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) return CorrectionCode::Error;
  CalibResult result;
 
  unsigned int sfindex = 0;
  unsigned int efindex = 0;
  
  if( !getIndices(flavour,sfindex,efindex)) {
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getMCEfficiency call to getIndices failed " << flavour << " " << sfindex << " " << efindex);
    return CorrectionCode::Error;
  }
  Uncertainty unc = None;
  // no uncertainty index here as there aren't any uncertainties associated with the MC efficiencies
  CalibrationStatus status = m_CDI->getMCEfficiency(v,efindex, unc,result);
  eff = result.first;
  if( m_applySyst && !m_applyThisSyst.isUp) {
    eff = result.second; // down variation
  }
  
  switch (status) {
  case Analysis::kError:
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getMCEfficiency call to underlying code returned a kError!");
    return CorrectionCode::Error;
  case Analysis::kRange:
  case Analysis::kExtrapolatedRange:
    return m_ignoreOutOfValidityRange ? CorrectionCode::Ok : CorrectionCode::OutOfValidityRange;
  case Analysis::kSuccess:
  default:
    return CorrectionCode::Ok;
  }
}

getMCEfficiencyONNX() [1/2]

CorrectionCode BTaggingEfficiencyTool::getMCEfficiencyONNX ( const std::vector< std::vector< float > > & node_feat, std::vector< float > & effAllJet )

virtual

Computes the MC efficiency of the jets in a given event.

(Uses the onnx tool) For fixed cut wp

Implements IBTaggingEfficiencyTool.

Definition at line 1078 of file BTaggingEfficiencyTool.cxx.

{
  m_saltModel->runInference(node_feat, effAllJet);
  return CorrectionCode::Ok;
}

getMCEfficiencyONNX() [2/2]

CorrectionCode BTaggingEfficiencyTool::getMCEfficiencyONNX ( const std::vector< std::vector< float > > & node_feat, std::vector< std::vector< float > > & effAllJetAllWp )

virtual

Computes the MC efficiency of the jets in a given event.

(Uses the onnx tool) For continuous wp

Implements IBTaggingEfficiencyTool.

Definition at line 1086 of file BTaggingEfficiencyTool.cxx.

{
  m_saltModel->runInference(node_feat, effAllJetAllWp);
  return CorrectionCode::Ok;
}

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getOperatingPoint()

const std::string & BTaggingEfficiencyTool::getOperatingPoint ( ) const

inlinevirtual

Retrieve the operating point (as specified in the calibration file)

Implements IBTaggingEfficiencyTool.

Definition at line 188 of file BTaggingEfficiencyTool.h.

{ return m_OP;}

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

getScaleFactor() [1/2]

CorrectionCode BTaggingEfficiencyTool::getScaleFactor ( const xAOD::Jet & jet, float & sf )

virtual

Computes the data/MC efficiency scale factor for the given jet.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Implements IBTaggingEfficiencyTool.

Definition at line 701 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) {
    ATH_MSG_ERROR("BTaggingEfficiencyTool has not been initialised");
    return CorrectionCode::Error;
  }
  
  // get the btag label
  int flavour{0};
  if (m_using_conventional_labels){ // if not using conventional labels, so flavour label will have to be set by some other means...
    flavour = jetFlavourLabel(jet, m_coneFlavourLabel, m_extFlavourLabel);
  } 
 
  Analysis::CalibrationDataVariables vars;
  //const double pt = jet.pt();
  //const double eta = jet.eta();
  //const double tagwe = 0.7; // temporary testing
  if (! fillVariables(jet, vars)) {
  //if (! fillVariables(pt, eta, tagwe, vars)){
    ATH_MSG_ERROR("unable to fill variables required for scale factor evaluation");
    return CorrectionCode::Error;
  }
 
  return getScaleFactor(flavour, vars, sf);
}

getScaleFactor() [2/2]

CorrectionCode BTaggingEfficiencyTool::getScaleFactor ( int flavour, const Analysis::CalibrationDataVariables & v, float & sf )

virtual

Computes the data/MC efficiency scale factor for the jet, given its kinematics, (possibly) tagger weight and truth flavour.

The tagger and operating point under consideration are part of the configuration and hence aren't function arguments.

Implements IBTaggingEfficiencyTool.

Definition at line 728 of file BTaggingEfficiencyTool.cxx.

{
  if (! m_initialised) {
    ATH_MSG_ERROR("BTaggingEfficiencyTool has not been initialised");
    return CorrectionCode::Error;
  }
  
  CalibResult result;
  
  unsigned int sfindex = 0;
  unsigned int efindex = 0;
  
  if( !getIndices(flavour,sfindex,efindex)) { //<-------- This method returns true if it can find the sfindex and efindex corresponding to the flavour
    // These indices are used internally in the CalibrationDataInterfaceROOT. They represent the index where
    // the CalibrationDataContainer storing the calibration scalefactors/efficiencies are at in the CDIROOT (in m_objects in both cases, but needs a call to getMCScaleFactor in latter case)
    // Once the container is retrieved by index, the CalibrationDataEigenVariations object is retrieved by container,
    // which actually returns Up/Down variations, else return SF+SFError
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getScaleFactor call to getIndices failed " << flavour << " " << sfindex << " " << efindex);
    return CorrectionCode::Error;
  }
  CalibrationStatus status;
  Uncertainty unc = None;
  unsigned int unc_ind=0; // <----- This is the index of the variation internal to the CDIROOT object
  
  if( m_applySyst) { // indicate that we want to apply a systematic variation, i.e. return an up/down variation pair
    unc = m_applyThisSyst.uncType; // type of systematic strategy...
    if(!m_applyThisSyst.getIndex(flavour,unc_ind)) {
      ATH_MSG_VERBOSE("getScaleFactor: requested variation cannot be applied to flavour " << getLabel(flavour) << ", returning nominal result");
      unc = None;
    }
  }
 
  // In all likelihood, the "sfindex" and "efindex" need more work in the CDIROOT (or in the CDGEV)
  status = (m_isContinuous || m_isContinuous2D) ? m_CDI->getWeightScaleFactor(v,sfindex,efindex, unc,unc_ind,result) : m_CDI->getScaleFactor(v,sfindex,efindex, unc,unc_ind,result, getLabel(flavour));
 
  // Interpret what has been retrieved;
  // this depends both on the uncertainty type and on the up/down setting.
  sf = result.first;
  if (m_applySyst && unc != None) {
    if (! (unc == SFEigen || unc == SFNamed || unc == SFGlobalEigen)){ 
      sf += m_applyThisSyst.isUp ? result.second : -result.second ;
    } else if (!m_applyThisSyst.isUp) {
      sf = result.second; // otherwise, set the sf to the down variation (if down is requested)
    } // otherwise, doing nothing will return the result.first value, which SHOULD represent the up variation
  }
 
  switch (status) {
  case Analysis::kError:
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getScaleFactor call to underlying code returned a kError!");
    return CorrectionCode::Error;
  case Analysis::kRange:
  case Analysis::kExtrapolatedRange:
    return m_ignoreOutOfValidityRange ? CorrectionCode::Ok : CorrectionCode::OutOfValidityRange;
  case Analysis::kSuccess:
  default:
    return CorrectionCode::Ok;
  }
}

getTaggerName()

const std::string & BTaggingEfficiencyTool::getTaggerName ( ) const

inlinevirtual

Retrieve the name of the tagger (as specified in the calibration file)

Implements IBTaggingEfficiencyTool.

Definition at line 185 of file BTaggingEfficiencyTool.h.

{ return m_taggerName;}

initialize()

StatusCode BTaggingEfficiencyTool::initialize ( void )

virtual

Initialise the tool.

This is the stage at which all of the configuration is done and the underlying CalibrationDataInferfaceROOT object is instantiated. The properties that can be set are documented in the xAOD interface section of the CalibrationDataInterface Twiki page.

Reimplemented from asg::AsgTool.

Definition at line 144 of file BTaggingEfficiencyTool.cxx.

                                              {
 
  ATH_MSG_INFO( " Hello BTaggingEfficiencyTool user... initializing");
  ATH_MSG_INFO( " TaggerName = " << m_taggerName);
  ATH_MSG_INFO( " OP = " << m_OP);
  ATH_MSG_INFO( " m_systStrategy is " << m_systStrategy);
 
  m_SFNames["B"] = m_SFNamesB;
  m_SFNames["C"] = m_SFNamesC;
  m_SFNames["T"] = m_SFNamesT;
  m_SFNames["Light"] = m_SFNamesLight;
 
  m_EVReduction["B"] = m_EVReductionB;
  m_EVReduction["C"] = m_EVReductionC;
  m_EVReduction["Light"] = m_EVReductionLight;
 
  m_EffNames["B"] = m_EffNamesB;
  m_EffNames["C"] = m_EffNamesC;
  m_EffNames["T"] = m_EffNamesT;
  m_EffNames["Light"] = m_EffNamesLight;
 
  m_uncertaintySuffixes["B"] = m_uncertaintySuffixesB;
  m_uncertaintySuffixes["C"] = m_uncertaintySuffixesC;
  m_uncertaintySuffixes["T"] = m_uncertaintySuffixesT;
  m_uncertaintySuffixes["Light"] = m_uncertaintySuffixesLight;
 
  m_excludeFlvFromEV["B"] = m_excludeFlvFromEVB;
  m_excludeFlvFromEV["C"] = m_excludeFlvFromEVC;
  m_excludeFlvFromEV["Light"] = m_excludeFlvFromEVLight;
 
  if(m_SelectionCDIFile.empty()) m_SelectionCDIFile = m_SFFile;
  if(m_selectionTaggerName.empty()) m_selectionTaggerName = m_taggerName;
 
  // set default MCMC map if they haven't been specified
  for (auto& [k, v]: m_EffNames) {
    if (v.size() == 0) v = m_effName;
  }
 
  // Use the PathResolver to find the full pathname (behind the scenes this can also be used to download the file),
  // if the file cannot be found directly.
  // For consistency with the PathResolver code, use the Boost library to check on this first possibility.
  m_SFFile = trim(m_SFFile);
  std::string location = PathResolverFindCalibFile(m_SFFile);
  if (location == "") {
    std::string prepend = "";
    if (m_useDevFile) {
      ATH_MSG_WARNING(" Attempting to retrieve b-tagging scale factor calibration file from development area");
      prepend = "dev/";
    }
    prepend += "xAODBTaggingEfficiency/";
    m_SFFile = prepend + m_SFFile;
    m_SFFileFull = PathResolverFindCalibFile(m_SFFile);
    if (m_SFFileFull == "")
      ATH_MSG_WARNING(" Unable to retrieve b-tagging scale factor calibration file!");
    else
      ATH_MSG_DEBUG(" Retrieving b-tagging scale factor calibration file as " << m_SFFile);
  } else {
    m_SFFileFull = location;
  }
 
  // The situation for the efficiency file is a bit simpler since it need not reside under "xAODBTaggingEfficiency"
  m_EffFile = trim(m_EffFile);
  if (m_EffFile != "") m_EffFile = PathResolverFindCalibFile(m_EffFile);
 
 
  // Strategies for eigenvector reductions (only relevant if eigenvector variations are used, of course).
  // For now, we will assume that the strategy for tau "jets" is identical to that for c jets.
  std::map<std::string, Analysis::EVReductionStrategy> EVRedStrategies, mappings;
  mappings["Loose"] = Analysis::Loose;
  mappings["Medium"] = Analysis::Medium;
  mappings["Tight"] = Analysis::Tight;
 
 
  // Now that we know the CDI file location, let's check if the configuration provided is correct
  Analysis::CDIReader Reader(m_SFFileFull);
  if(!Reader.checkConfig(m_taggerName, m_jetAuthor, m_OP, msgLvl(MSG::DEBUG))){
    ATH_MSG_ERROR( "BTaggingEfficiencyTool configuration is invalid - follow the above suggestions to correct your config!");
    return StatusCode::FAILURE;
  };
 
  std::vector<std::string> config_labels = Reader.getLabels(); // the labels compatible with this configuration
  std::vector<std::string> flavours;
  // "pack" the efficiency map names for each flavour. Note that multiple, semicolon separated, entries may exist; so this needs to be decoded first
  std::map<std::string, std::vector<std::string> > EffNames;
  std::vector<std::string> EVflavours = { "B", "C", "Light" }; // ideally this would also come from the metadata of the CDI file as well...
  // specify which systematic variations are to be excluded from the eigenvector decomposition
  std::map<std::string, std::vector<std::string> > excludeFromEVCov;
  std::vector<std::string> to_exclude = split(m_excludeFromEV); // uncertainties to exclude from all flavours
 
  if(!m_useFlex){
 
    //if a configuration file was provided for efficiency maps, overwrite the efficiency map selection with the one provided in the first line of the config
    if(not m_EffConfigFile.empty()){
      m_EffConfigFile = PathResolverFindCalibFile(m_EffConfigFile);
      std::ifstream eff_config_file(m_EffConfigFile);
 
      std::string str;
      std::getline(eff_config_file, str);
 
      m_EffNames["B"] = str;
      m_EffNames["C"] = str;
      m_EffNames["T"] = str;
      m_EffNames["Light"] = str;
 
      while (std::getline(eff_config_file, str)) {
          std::vector<std::string> dsid_and_effmap = split(str,':');
          unsigned int dsid = std::stoul( dsid_and_effmap[0] );
          unsigned int map_index = std::stoul( dsid_and_effmap[1] );
          m_DSID_to_MapIndex[dsid] = map_index;
      }
    }
 
 
 
    flavours = { "B", "C", "Light", "T"};
 
    for (auto const& flavour : flavours) {
      EffNames[flavour] = split(m_EffNames[flavour]);
    }
 
    ATH_MSG_INFO( " b-jet     SF/eff calibration = " << m_SFNames["B"] <<     " / " << m_EffNames["B"]);
    ATH_MSG_INFO( " c-jet     SF/eff calibration = " << m_SFNames["C"] <<     " / " << m_EffNames["C"]);
    ATH_MSG_INFO( " tau-jet   SF/eff calibration = " << m_SFNames["T"] <<     " / " << m_EffNames["T"]);
    ATH_MSG_INFO( " light-jet SF/eff calibration = " << m_SFNames["Light"] << " / " << m_EffNames["Light"]);
    ATH_MSG_INFO( " JetAuthor = " << m_jetAuthor);
 
 
  } else {
 
    // Set defaults for the following, based on flavour label
    // metadata if any of the following properties are not set:
    //  - FlexibleScaleFactorCalibrations
    //  - FlexibleEfficiencyCalibrations
    //  - FlexibleEigenvectorReduction
    //  - FlexibleUncertaintySuffix
    //  - FlexibleExcludeFromEVTreatment
    
    flavours = config_labels; // set the flavours vector from CDI metadata
    m_flex_labels = flavours; // set the label scheme, for use elsewhere
    for(const std::string& label : m_flex_labels){
      m_flex_label_integers.push_back(getFlavourID(label, false)); // populate the ordered flavour ID vector
    }
    int size_of_labels = flavours.size();
    if (m_SFName_flex.empty()){
      m_SFName_flex = default_flexible(flavours.size(), ":default");
    } else {ATH_MSG_INFO(" Setting m_SFName_flex : " << m_SFName_flex);}
    if (m_EffNames_flex.empty()){
      m_EffNames_flex = default_flexible(flavours.size(), ":default");
    } else {ATH_MSG_INFO(" Setting m_EffNames_flex : " << m_EffNames_flex);}
    if (m_EVReduction_flex.empty()){
      m_EVReduction_flex = default_flexible(flavours.size(), ":Loose");
    } else {ATH_MSG_INFO(" Setting m_EVReduction_flex : " << m_EVReduction_flex);}
    if (m_uncertaintySuffixes_flex.empty()){
      m_uncertaintySuffixes_flex = default_flexible(flavours.size(), ":");
    } else {ATH_MSG_INFO(" Setting m_uncertaintySuffixes_flex : " << m_uncertaintySuffixes_flex);}
    if (m_excludeFlvFromEV_flex.empty()){
      m_excludeFlvFromEV_flex = default_flexible(flavours.size(), ":");
    } else {ATH_MSG_INFO(" Setting m_excludeFlvFromEV_flex : " << m_excludeFlvFromEV_flex);}
 
    // empty m_SFNames (filled by the 'default' setting), in the flexible method we want to use the labels found in the CDI file meta-data
    m_SFNames.clear();
    std::vector<std::string> efficiencies_map = split(m_EffNames_flex); // split to {"0:default", "1:47100,47200,default", "2:default", "3:default"}
    for (auto const& effconfig : efficiencies_map) {
      std::vector<std::string> effmap = split(effconfig, ':'); // split to {"0", "default"}
      if(effmap.size() != 2){ // check if first flavour label config is written properly // || std::stoi(effmap.at(0)) > (int)flavours.size()
        ATH_MSG_ERROR( "BTaggingEfficiencyTool configuration is invalid - efficiency files not included properly in the (experimental) flexible configuration!");
        return StatusCode::FAILURE;
      }
      int index = std::stoi(effmap.at(0)); // index of flavour label in 'flavours' vector
      std::vector<std::string> effcalibs; // vector of efficiency calibrations
      if(effmap.at(1) != "default"){
        effcalibs = split(effmap.at(1), ',');
      } else {
        effcalibs.push_back(effmap.at(1));
      }
      std::string flavour_name = flavours.at(index);
      m_EffNames[flavour_name] = effmap.at(1); // set this for posterity
      EffNames[flavour_name] = effcalibs;
    }
 
    std::vector<std::string> scalefactor_map = split(m_SFName_flex); // split to {"0:default", "1:47100,47200,default", "2:default", "3:default"}
    for (auto const& sfconfig : scalefactor_map) {
      std::vector<std::string> sfmap = split(sfconfig, ':'); // split to {"0", "default"}
      if(sfmap.size() != 2){ // check if first flavour label config is written properly // || std::stoi(sfmap.at(0)) > (int)flavours.size()
        ATH_MSG_ERROR( "BTaggingEfficiencyTool configuration is invalid - efficiency files not included properly in the (experimental) flexible configuration!");
        return StatusCode::FAILURE;
      }
      int index = std::stoi(sfmap.at(0)); // index of flavour label in 'flavours' vector
      std::string flavour_name = flavours.at(index);
      m_SFNames[flavour_name] = sfmap.at(1);
    }
    for(const std::string& flav : flavours){
      ATH_MSG_INFO( flav + " label     SF/eff calibration = " + m_SFNames[flav] +  " / " + m_EffNames[flav] ) ;
    }
 
    // Now deal with the flexible configurations
    EVflavours.clear(); // ideally this vector would also come from CDI file metadata
    EVflavours = flavours; // for now, just set the vector of EV flavours to the flavours vector
    // construct the flavour m_EVReduction map from m_EVReduction_flex index based configuration
    std::vector<std::string> evreduction_map = split(m_EVReduction_flex);
    for (auto const& evred : evreduction_map) {
      std::vector<std::string> evredmap = split(evred, ':'); // split to {"0", "Loose"} 
      if(evredmap.size() != 2){
        if(std::stoi(evredmap.at(0)) < size_of_labels){
          evredmap.push_back("");
        } else {
          ATH_MSG_ERROR( "BTaggingEfficiencyTool configuration is invalid - reduction strategies not set properly in the (experimental) flexible configuration!");
          return StatusCode::FAILURE;
        }
      }
      int index = std::stoi(evredmap.at(0)); // index of flavour label in 'flavours' vector
      const std::string& flavour_name = flavours.at(index);
      m_EVReduction[flavour_name] = evredmap.at(1);
    }
    
    // construct the flavour m_excludeFlvFromEV map from m_excludeFlvFromEV_flex index based configuration
    std::vector<std::string> exclusion_map = split(m_excludeFlvFromEV_flex);
    for (auto const& excl : exclusion_map) {
      std::vector<std::string> exclmap = split(excl, ':'); // split to {"0", "uncertainty1,uncertainty2,..,uncertaintyN"}
      if(exclmap.size() != 2){
        if(std::stoi(exclmap.at(0)) < size_of_labels){
          exclmap.push_back("");
        } else {
          ATH_MSG_ERROR( "BTaggingEfficiencyTool configuration is invalid - uncertainty exclusion not set properly in the (experimental) flexible configuration!");
          return StatusCode::FAILURE;
        }
      }
      int index = std::stoi(exclmap.at(0)); // index of flavour label in 'flavours' vector
      std::vector<std::string> uncertainties_to_exclude = split(exclmap.at(1), ',');; // vector of uncertainties to exclude for this flavour
      const std::string& flavour_name = flavours.at(index);
      m_excludeFlvFromEV[flavour_name] = exclmap.at(1);
    }
  }
 
  // set the reduction per EV flavour/label, and exclude uncertainties from EV reduction
  for (auto const& flavour : EVflavours) {
    EVRedStrategies[flavour] = mappings.find(trim(m_EVReduction[flavour])) == mappings.end() ? mappings["Loose"] : mappings[trim(m_EVReduction[flavour])];
    excludeFromEVCov[flavour] = to_exclude; // look for uncertainties to be excluded for all flavours
    std::vector<std::string> further_exclude = split(m_excludeFlvFromEV[flavour]); // now grab the flavour/label specific uncertainties to exclude
    excludeFromEVCov[flavour].insert(excludeFromEVCov[flavour].end(), further_exclude.begin(), further_exclude.end()); // Append to the existing list
  }
 
  // now, handle the edge-cases of EV reduction and extra uncertainties
  // e.g. C - T calibration duplication in "conventional" flavour labeling
  // check if the labels are "conventional"
  std::vector<std::string> conventional_labels = {"B", "C", "Light", "T"};
  if (flavours == conventional_labels) {
    m_using_conventional_labels = true;
  }
  if (m_using_conventional_labels) {
    // if using conventional label, we can use the same logic as always
    EVRedStrategies["T"] = EVRedStrategies["C"];
 
    // For the SFEigen strategy, tau "jets" are treated differently from other flavours. 
    // First, copy the charm-jet calibration settings
    excludeFromEVCov["T"] = excludeFromEVCov["C"];
 
    //high pt extrapolation uncertainties
    if(m_OP.value().find("Continuous") != std::string::npos){
      excludeFromEVCov["B"].push_back("extrapolation_pt_b_Eigen*");
      excludeFromEVCov["C"].push_back("extrapolation_pt_c_Eigen*");
      excludeFromEVCov["Light"].push_back("extrapolation_pt_l_Eigen*");
      excludeFromEVCov["T"].push_back("extrapolation_pt_c_Eigen*");
    }
  } 
 
  if (m_OP == "Continuous") {
    // continuous tagging is special in two respects:
    // 1  the tag weight needs to be retrieved
    // 2  the generator dependent scale factor rescaling is done differently, and therefore
    //    CalibrationDataInterfaceROOT::getWeightScaleFactor() instead of
    //    CalibrationDataInterfaceROOT::getScaleFactor() must be used
    m_isContinuous = true;
  }
  else if (m_OP.value().find("Continuous2D")  != std::string::npos) {
    m_isContinuous2D = true;
  }
  // Note that the instantiation below does not leave a choice: the Eigenvector variations and generator-specific scale factors are always used
  std::vector<std::string> jetAliases;
  m_CDI = std::shared_ptr<Analysis::CalibrationDataInterfaceROOT>( new Analysis::CalibrationDataInterfaceROOT(
                 m_taggerName,                              // tagger name: always needed
                             m_SFFileFull.c_str(),                          // full pathname of the SF calibration file: always needed
                                             (m_EffFile == "") ? 0 : m_EffFile.value().c_str(), // full pathname of optional efficiency file
                             jetAliases,                                // since we configure the jet "collection name" by hand, we don't need this
                             m_SFNames,                                 // names of the scale factor calibrations to be used
                             EffNames,                                  // names of the efficiency calibrations to be used (can be multiple per flavour)
                             excludeFromEVCov,                          // names of systematic uncertainties to be excluded from the EV decomposition
                             EVRedStrategies,                           // strategies for eigenvector reductions
                             m_systStrategy != "Envelope",              // assume that eigenvector variations will be used unless the "Envelope" model is used
                 (m_systStrategy=="SFEigen") ? Analysis::SFEigen : Analysis::Uncertainty::SFGlobalEigen,
                             true,                                      // use MC/MC scale factors
                             false,                                     // do not use topology rescaling (only relevant for pseudo-continuous tagging)
                             m_useRecommendedEVExclusions,              // if true, add pre-set lists of uncertainties to be excluded from EV decomposition
                 msgLvl(MSG::DEBUG),                         // if false, suppress any non-error/warning messages
                 flavours                                   // vector of flavour labels, conventional or not
                ));                         
 
  if(m_using_conventional_labels){
    ATH_MSG_INFO("BTEffTool->initialize : setMapIndex(Light)");
    setMapIndex("Light",0);
    ATH_MSG_INFO("BTEffTool->initialize : setMapIndex(C)");
    setMapIndex("C",0);
    ATH_MSG_INFO("BTEffTool->initialize : setMapIndex(B)");
    setMapIndex("B",0);
    ATH_MSG_INFO("BTEffTool->initialize : setMapIndex(T)");
    setMapIndex("T",0);
  } else {
    for(const auto& flavour : flavours){
      // set map index for each flavour (label) index
      ATH_MSG_INFO(" - - -BTEffTool->initialize : setMapIndex(" << flavour << ")");
      setMapIndex(flavour, 0); 
    }
  }
 
  ATH_MSG_INFO( "Using systematics model " << m_systStrategy);
  if (m_systStrategy != "Envelope" && m_useRecommendedEVExclusions) ATH_MSG_INFO( "excluding pre-set uncertainties from eigenvector decomposition");
 
  // We have a double loop over flavours here.. not nice but this is to ensure that the suffixes are always well determined before using them.
  // Note that (in the SFEigen model) suffixes are attached to eigenvector variations only (the idea being that named uncertainties, if used, are likely to be correlated).
  std::vector<std::string> suffixes;
  if (m_using_conventional_labels){
    for (int i = 0; i < 4; ++i) { // four flavours in conventional label scheme
      std::string flav = flavours[i]; if (flav == "T") flav = "C";
      // add an underscore to any specified suffix (if specified and if not already starting with a suffix)
      std::string test = trim(m_uncertaintySuffixes[flav]);
      if (test.length() > 0 && test[0] != '_') test.insert(0,"_");
      suffixes.push_back(test);
    }
  } else {
    // Need to handle the suffixes for the generic labels
    std::vector<std::string> suffixvec = split(m_uncertaintySuffixes_flex);
    int size_of_labels = flavours.size();
    for (auto const& suff : suffixvec) {
      std::vector<std::string> suffmap = split(suff, ':'); // split to {"0", "uncertainty1,uncertainty2,..,uncertaintyN"}
      if(suffmap.size() != 2){
        if(std::stoi(suffmap.at(0)) < size_of_labels){
          suffmap.push_back("");
        } else {
          ATH_MSG_ERROR( "BTaggingEfficiencyTool configuration is invalid - suffix configuration not set properly in the (experimental) flexible configuration!");
          return StatusCode::FAILURE;
        }
      }
      int index = std::stoi(suffmap.at(0)); // index of flavour label in 'flavours' vector
      std::string flavour_name = flavours.at(index);
      // add an underscore to any specified suffix (if specified and if not already starting with a suffix)
      std::string suffix = trim(suffmap.at(1));
      if (suffix.length() > 0 && suffix[0] != '_') suffix.insert(0,"_");
      suffixes.push_back(suffix);
    }
  }
 
  // If the tool has not already been initialised and m_OP and m_jetAuthor have been set - ie via the properties "OperatingPoint" and "JetAuthor"
  // then autmatically set things up to use these by default
  // All this must happen before registerSystematics otherwise that won't work
  for (long unsigned int i = 0; i < flavours.size(); ++i) {
    // For each flavour, we check the validity of the initialization of the CalibrationInterfaceROOT object (m_CDI)
    unsigned int flavourID;
    if (m_using_conventional_labels){
      flavourID = getFlavourID(flavours[i]);
    } else {
      flavourID = getFlavourID(flavours[i], false); // in flexible scheme, need to specify the new labels in getFlavourID
    }
    // std::map<unsigned int, unsigned int>::const_iterator
    auto mapIter = m_SFIndices.find(flavourID);
    if( mapIter==m_SFIndices.end()) { // if the flavour doesn't have an entry need to fail the initialization
      ATH_MSG_ERROR( "No entry for flavour " << flavourID << " which is " << flavours[i] << " in SFIndices map, invalid initialization");
      return StatusCode::FAILURE;
    }
    int id = mapIter->second;
    // Implement the different strategies for dealing with uncertainties here.
    if (m_systStrategy == "SFEigen" || m_systStrategy == "SFGlobalEigen") {
      //
      // Generally recommended model: use eigenvector variations. Notes:
      // -   The list of systematics to be excluded from the eigenvector variation approach is dynamic.
      // -   The tau SF are identical to the c-jet ones, with merely one additional uncertainty assigned due to the extrapolation.
      //
      unsigned int flavourIDRef;
      if (m_using_conventional_labels){
        flavourIDRef = (flavourID == 15) ? 4 : flavourID;
      } else {
        flavourIDRef = flavourID;
      }
      int idRef = m_SFIndices.find(flavourIDRef)->second;
      // First, handle any named variations
      std::vector<std::string> systematics = m_CDI->listScaleFactorUncertainties(idRef, flavours.at(i), true); // flavours[i] should be "B", "C", "Light", or "T"
      // Replace any spaces with underscores (this is to make ROOT browsing happy).
      // Also, remove the "extrapolation" uncertainty from the list (it will be added later under Extrapolation rather than SFNamed).
 
      auto it = std::remove (systematics.begin(), systematics.end(),
                             "extrapolation");
      bool hasExtrapolation = (it != systematics.end());
      systematics.erase (it, systematics.end());
      // C++20 alternative:
      //bool hasExtrapolation = std::erase (systematics, "extrapolation") > 0;
      
      for (auto& systematic : systematics) {
        std::replace_if(systematic.begin(), systematic.end(), [] (char c) { return c == ' '; }, '_'); // <--- This just replaces spaces with underscores
        // We don't add suffixes here but only for EV variations (see JIRA: AFT-343)
      }
      
      if (!addSystematics(systematics, flavourID, SFNamed)) { // Add the SFNamed to m_systematicsInfo
        ATH_MSG_ERROR("SFEigen model: error adding named systematics for flavour " << getLabel(flavourIDRef) << ", invalid initialization"); // For each uncertainty type, have to add ALL uncertainties pertaining to that type
        return StatusCode::FAILURE;
      }
 
      // Add here the extrapolation uncertainty (if it exists -- which ought to be the case).
      // "Cosmetic" fix: the outside world wants to see "FT_EFF_" prefixes. On the other hand, like for the above named uncertainties, we don't add suffixes here
      if (hasExtrapolation) {
        std::vector<std::string> extrapSyst; extrapSyst.push_back(std::string("FT_EFF_extrapolation")); // Add the EXTRAPOLATION to m_systematicsInfo
        if (! addSystematics(extrapSyst, flavourID, Extrapolation)) {
          ATH_MSG_ERROR("SFEigen model: error adding extrapolation uncertainty for flavour " << getLabel(flavourIDRef) << ", invalid initialization");
          return StatusCode::FAILURE;
        }
      }
 
      // And then the eigenvector variations
      std::vector<std::string> eigenSysts;
      if (m_systStrategy == "SFEigen"){
        if (m_using_conventional_labels){
          eigenSysts = makeEigenSyst(getLabel(flavourIDRef),m_CDI->getNumVariations(idRef, SFEigen, getLabel(flavourID)), suffixes[i]); // Add the eigenvariations to m_systematicsInfo
        } else {
          eigenSysts = makeEigenSyst(getLabel(flavourIDRef),m_CDI->getNumVariations(idRef, SFEigen, flavours[i]), suffixes[i]); // Add the eigenvariations to m_systematicsInfo
        }
        if (!addSystematics(eigenSysts, flavourID, SFEigen)) {
          ATH_MSG_ERROR("SFEigen model: error adding eigenvector systematics for flavour " << getLabel(flavourIDRef) << ", invalid initialization");
          return StatusCode::FAILURE;
        }
      } else if (m_systStrategy == "SFGlobalEigen") {
 
        // we have to add the SFGlobalEigen systematics like this...
        if (m_using_conventional_labels){
          eigenSysts = makeEigenSyst(getLabel(flavourIDRef),m_CDI->getNumVariations(idRef, SFGlobalEigen, getLabel(flavourID)), suffixes[i]); // Add the eigenvariations to m_systematicsInfo
        } else {
          std::vector<std::string> eigenSysts = makeEigenSyst(getLabel(flavourIDRef),m_CDI->getNumVariations(idRef, SFGlobalEigen, flavours[i]), suffixes[i]); // Add the eigenvariations to m_systematicsInfo
        }
        if (!addSystematics(eigenSysts, flavourID, SFGlobalEigen)) {
          ATH_MSG_ERROR("SFGlobalEigen model: error adding eigenvector systematics for flavour " << getLabel(flavourIDRef) << " ie " << getLabel(flavourID) << ", invalid initialization");
          return StatusCode::FAILURE;
        }

      }
      // The above should cover all uncertainties except the charm -> tau extrapolation; so we take care of that here.
      if (flavourID == 15) {
        // First extract the complete list of uncertainties for taus
        std::vector<std::string> all_systematics = m_CDI->listScaleFactorUncertainties(id, getLabel(flavourID));
        // And from this list extract only this particular uncertainty (if it exists)
        const std::string s_tau_extrap = "extrapolation from charm";
        if (std::find(all_systematics.begin(), all_systematics.end(), s_tau_extrap) != all_systematics.end()) {
          // Again, we don't add the suffix here (per JIRA: AFT-343)
          std::string entry = "FT_EFF_extrapolation_from_charm"; // entry.append(suffixes[i]);
          std::vector<std::string> extrapSyst; extrapSyst.push_back(entry);
          if (! addSystematics(extrapSyst, flavourID, TauExtrapolation)) {     // <--- Add the TauExtrapolation to m_systematicsInfo
            ATH_MSG_ERROR("SFEigen model: error adding charm->tau systematics for flavour " << getLabel(flavourID) << ", invalid initialization");
            return StatusCode::FAILURE;
          }
        }
      }
    } else if (m_systStrategy == "Envelope") {
      //
      // Simplified model: use uncertainty envelopes supplemented by a (common) extrapolation uncertainty
      // (since the extrapolation uncertainties aren't included in the Total uncertainty). Notes:
      // -   The tau SF are identical to the c-jet ones, with merely one additional uncertainty assigned due to the extrapolation.
      // -   The "total" uncertainty is always expected to be available; the code will bomb if this is not the case.
      //     Also, the "total" uncertainties for different flavours are assumed to be uncorrelated.
      //
      unsigned int flavourIDRef = (flavourID == 15) ? 4 : flavourID;
      int idRef = m_SFIndices.find(flavourIDRef)->second;
      // First, handle the Total variations; these need different prefixes to reflect them being uncorrelated
      std::vector<std::string> all_ref_systematics = m_CDI->listScaleFactorUncertainties(idRef,getLabel(flavourID),false);
      const std::string s_total = "systematics";
      if (std::find(all_ref_systematics.begin(), all_ref_systematics.end(), s_total) == all_ref_systematics.end()) {
        ATH_MSG_ERROR("Envelope model: required uncertainty " << s_total << " not found for flavour " << getLabel(flavourIDRef)
                << ", invalid initialization");
        return StatusCode::FAILURE;
      }
      std::vector<std::string> totalSyst; totalSyst.push_back("FT_EFF_" + getLabel(flavourIDRef) + "_" + s_total + suffixes[i]);
      if (! addSystematics(totalSyst, flavourID, Total)) {
        ATH_MSG_ERROR("Envelope model: error adding systematics uncertainty for flavour " << getLabel(flavourIDRef)
              << ", invalid initialization");
        return StatusCode::FAILURE;
      }
      // Second, handle the extrapolation variations; these are shared between flavours (unless different suffixes are specified)
      const std::string s_extrap = "extrapolation";
      if (std::find(all_ref_systematics.begin(), all_ref_systematics.end(), s_extrap) != all_ref_systematics.end()) {
        std::vector<std::string> extrapSyst; extrapSyst.push_back("FT_EFF_" + s_extrap + suffixes[i]);
        if (! addSystematics(extrapSyst, flavourID, Extrapolation)) {
          ATH_MSG_ERROR("Envelope model: error adding extrapolation uncertainty for flavour " << getLabel(flavourIDRef)
                << ", invalid initialization");
          return StatusCode::FAILURE;
        }
      }
      // Finally, handle the charm -> tau extrapolation (as in the above)
      if (flavourID == 15) {
        // First extract the complete list of uncertainties for taus
        std::vector<std::string> all_systematics = m_CDI->listScaleFactorUncertainties(id, getLabel(flavourID));
        // And from this list extract only this particular uncertainty (if it exists)
        const std::string s_tau_extrap = "extrapolation from charm";
        if (std::find(all_systematics.begin(), all_systematics.end(), s_tau_extrap) != all_systematics.end()) {
          std::vector<std::string> extrapSyst; extrapSyst.push_back("FT_EFF_extrapolation_from_charm" + suffixes[i]);
          if (! addSystematics(extrapSyst, flavourID, TauExtrapolation)) {
            ATH_MSG_ERROR("Envelope model: error adding charm->tau systematics for flavour " << getLabel(flavourID) << ", invalid initialization");
            return StatusCode::FAILURE;
          }
        }
      }
    }
  } // end flavour loop
 
  // now fill the SystematicSet
  for( std::map<SystematicVariation,SystInfo>::const_iterator mapIter = m_systematicsInfo.begin(); mapIter != m_systematicsInfo.end();++mapIter) {
    const SystematicVariation & variation = mapIter->first;
    m_systematics.insert(variation);
  }
  // systematics framework
  SystematicRegistry & registry = SystematicRegistry::getInstance();
  if( registry.registerSystematics(*this) != StatusCode::SUCCESS) 
    return StatusCode::FAILURE;
 
  // Finally, also initialise the selection tool, if needed (for now this is the case only for DL1 tag weight computations,
  // so we do this only when DL1 is specified)
  if (m_taggerName.value().find("DL1") != std::string::npos ||
      m_taggerName.value().find("GN1") != std::string::npos ||
      m_taggerName.value().find("GN2") != std::string::npos) {
    m_selectionTool.setTypeAndName("BTaggingSelectionTool/" + name() + "_selection");
    ATH_CHECK( m_selectionTool.setProperty("FlvTagCutDefinitionsFileName", m_SelectionCDIFile) );
    ATH_CHECK( m_selectionTool.setProperty("TaggerName",                   m_selectionTaggerName) );
    ATH_CHECK( m_selectionTool.setProperty("OperatingPoint",               m_OP) );
    ATH_CHECK( m_selectionTool.setProperty("JetAuthor",                    m_jetAuthor) );
    ATH_CHECK( m_selectionTool.setProperty("MinPt",                        m_minPt) );
    ATH_CHECK( m_selectionTool.setProperty("useCTagging",                  m_useCTag) );
    ATH_CHECK( m_selectionTool.setProperty("readFromBTaggingObject",                  m_readFromBTaggingObject) );
    ATH_CHECK( m_selectionTool.retrieve() );
 }
 
  // if the user decides to ignore these errors, at least make her/him aware of this
  if (m_ignoreOutOfValidityRange) {
    ATH_MSG_INFO("!!!!! You have chosen to disable out-of-validity return codes -- contact the Flavour Tagging group if such jets comprise a substantial part of the phase space in your analysis !!!!!");
  }
  
  // create and initialise the onnx tool
  if (m_pathToONNX != ""){
    std::string pathtoonnxfile = PathResolverFindCalibFile(m_pathToONNX);
    if (pathtoonnxfile == ""){
      ATH_MSG_ERROR("ONNX error: Model file doesn't exist! Please set the property 'pathToONNX' to a valid ONNX file");
      return StatusCode::FAILURE;
    }
    m_saltModel = std::make_unique<SaltModel> (m_pathToONNX);
    m_saltModel->initialize();
  }
 
  m_initialised = true;
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isAffectedBySystematic()

bool BTaggingEfficiencyTool::isAffectedBySystematic ( const CP::SystematicVariation & systematic ) const

virtual

Returns whether or not the given systematic variation is supported by this tool.

Implements CP::ISystematicsTool.

Definition at line 1094 of file BTaggingEfficiencyTool.cxx.

{
  SystematicSet sys = affectingSystematics();
  return sys.find( systematic) != sys.end();
}

listScaleFactorSystematics()

std::map< std::string, std::vector< std::string > > BTaggingEfficiencyTool::listScaleFactorSystematics ( bool named = false ) const

virtual

This merely passes on the request to the underlying CDI object (listSystematics() cannot be used here, as corresponding CP::SystematicVariation objects may not exist).

This method retrieves all systematic uncertainties known to the relevant calibration objects.

Note that the uncertainty naming does not follow the rewriting conventions leading to the names one will see as CP::SystematicVariations, but rather follows the "raw" names used on input (which are appropriate e.g. when excluding uncertainties from the eigenvalue decomposition).

Since the expected use of this method is in the context of the SFEigen model, we will assume (and not check) that this model is being used. Note: the uncertainties returned are in the format of the underlying CDI, and do not have the rewriting applied to them that one would use in analysis.

Implements IBTaggingEfficiencyTool.

Definition at line 1148 of file BTaggingEfficiencyTool.cxx.

                                                                   {
  std::map<std::string, std::vector<std::string> > uncertainties;
 
  std::vector<unsigned int> all_flavours;
  if(m_using_conventional_labels){
    all_flavours = { 5, 4, 15, 0 };
  } else {
    all_flavours = m_flex_label_integers;
  }
 
  for (const unsigned int flavourID : all_flavours){
    // Assumed model: use eigenvector variations. In this model, the tau SF are identical to the c-jet ones,
    // with merely one additional uncertainty assigned due to the extrapolation.
    unsigned int flavourIDRef = flavourID;
    if (m_using_conventional_labels and flavourID == 15){
      flavourIDRef = 4; // make C - T relationship
    }
    auto mapIter = m_SFIndices.find(flavourIDRef);
    if( mapIter==m_SFIndices.end()) { // if the flavour doesn't have an entry need to fail the initialization
      ATH_MSG_ERROR( "No entry for flavour " << flavourIDRef << " in SFIndices map, invalid initialization");
      continue;
    }
    int idRef = mapIter->second;
    // Retrieve the actual list
    std::vector<std::string> systematics = m_CDI->listScaleFactorUncertainties(idRef, getLabel(flavourID), named);
    // For the special case of tau SF, add the extrapolation from charm.
    // Since this comes on top of the charm uncertainties, it would always be a "named" uncertainty,
    // so there is no need to check for the "named" argument.
    if (m_using_conventional_labels and flavourID == 15) systematics.push_back("extrapolation from charm");
    uncertainties[getLabel(int(flavourID))] = systematics;
  }
  return uncertainties;
}

listSystematics()

const std::map< SystematicVariation, std::vector< std::string > > BTaggingEfficiencyTool::listSystematics ( ) const

virtual

Implements IBTaggingEfficiencyTool.

Definition at line 1111 of file BTaggingEfficiencyTool.cxx.

                                              {
  std::map<SystematicVariation, std::vector<std::string> > results;
 
  if (! m_initialised) {
    ATH_MSG_ERROR("listSystematics() cannot be called before initialisation is finished");
    return results;
  }
 
 
  std::vector<unsigned int> all_flavours{5, 4, 15, 0};
  if(!m_using_conventional_labels){
    all_flavours = m_flex_label_integers;
  }
 
  for (const auto& info : m_systematicsInfo) {
    // The map key is easy...
    const SystematicVariation& variation = info.first;
    // Then see for which flavours this particular key is relevant
    std::vector<std::string> flavours;
    for(const unsigned int flavour : all_flavours){ // Grab the number 5,4,15,0 for B,C,T,Light respectively (or other custom labelings)
      unsigned int idx;
      if (info.second.getIndex(flavour, idx)){ // If the flavour is mapped to an index internally in the SystInfo.indexMap, then return true
        flavours.push_back(getLabel(int(flavour)));
      }
    }
    results[variation] = flavours; // <------ Map the list of flavours that a systematic applies to, to the SystematicVariation object that was retrieved from m_systematicsInfo
  }
  return results;
}

makeEigenSyst()

std::vector< std::string > BTaggingEfficiencyTool::makeEigenSyst ( const std::string & flav, int number, const std::string & suffix )

private

generate names for the eigenvector variations for the given jet flavour

Definition at line 1359 of file BTaggingEfficiencyTool.cxx.

                                                                                                                      {
  std::vector<std::string> systStrings;
  for(int i=0;i<number;++i) {
    std::ostringstream ost;
    ost << flav << "_" << i << suffix;
    std::string basename="FT_EFF_Eigen_"+ost.str();
    systStrings.push_back(basename);
  }
  return systStrings;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

recommendedSystematics()

SystematicSet BTaggingEfficiencyTool::recommendedSystematics ( ) const

virtual

Return a list of "recommended" systematic variations supported by this tool.

At present, multiple views of the same uncertainties (beyond the uncertainty model etc., see above) are not implemented, so this method simply calls affectingSystematics() .

Implements CP::IReentrantSystematicsTool.

Definition at line 1106 of file BTaggingEfficiencyTool.cxx.

                                                                   {
  return affectingSystematics();
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setMapIndex() [1/2]

bool BTaggingEfficiencyTool::setMapIndex ( const std::string & flavour, unsigned int index )

virtual

Specify the "map index" to be used for the given jet flavour (at initialisation time it will be set to 0).

Returns

false if the requested index is invalid (in which case no setting will be changed)

See the CalibrationDataInterface documentation for more detail on the meaning of the map index

Implements IBTaggingEfficiencyTool.

Definition at line 1302 of file BTaggingEfficiencyTool.cxx.

{
  // do nothing unless it's needed!
  if (m_initialised && index == m_mapIndices[label]) return true;
  // convert to integer index
  unsigned int flavourID = -1; // set default, error if ever seen
  if (m_using_conventional_labels){
    flavourID = getFlavourID(label);
  } else {
    auto iter = std::find(m_flex_labels.begin(), m_flex_labels.end(), label);
    if (iter != m_flex_labels.end()){
      flavourID = getFlavourID(label, false);
    }
  }
  // retrieve the new calibration index
  unsigned int effIndex;
  if (m_CDI->retrieveCalibrationIndex(label, m_OP, m_jetAuthor, false, effIndex, index)) {
    // replace cached information
    m_mapIndices[label] = index; 
    m_EffIndices[flavourID] = effIndex; // This shortcuts you from flavourID to Eff container
    unsigned int sfIndex;
    if( m_CDI->retrieveCalibrationIndex(label, m_OP, m_jetAuthor, true, sfIndex, index)) {
      m_SFIndices[flavourID] = sfIndex; // This shortcuts you from flavourID to SF container
      return true;
    } else {
      ATH_MSG_ERROR("setMapIndex failed to find a SF calibration object" << label << " " << index);
    }
  } else {
    // flag non-existent calibration object & do nothing
    ATH_MSG_ERROR("setMapIndex failed to find an Eff calibration object" << label << " " << index);
  }
  return false;
}

setMapIndex() [2/2]

bool BTaggingEfficiencyTool::setMapIndex ( unsigned int dsid )

virtual

Implements IBTaggingEfficiencyTool.

Definition at line 1335 of file BTaggingEfficiencyTool.cxx.

                                                         {
 
  if(m_DSID_to_MapIndex.find(dsid) == m_DSID_to_MapIndex.end() ){
    ATH_MSG_WARNING("setMapIndex DSID "  << dsid << "not found in config file");
 
  }else{
      unsigned int map_index = m_DSID_to_MapIndex[dsid];
 
      bool set_b = setMapIndex("B",map_index);
      bool set_c = setMapIndex("C",map_index);
      bool set_light = setMapIndex("Light",map_index);
      bool set_t = setMapIndex("T",map_index);
 
      return set_b && set_c && set_light && set_t;
  }
 
 
  return false;
 
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_applySyst

bool BTaggingEfficiencyTool::m_applySyst

private

Definition at line 404 of file BTaggingEfficiencyTool.h.

m_applyThisSyst

SystInfo BTaggingEfficiencyTool::m_applyThisSyst

private

Definition at line 405 of file BTaggingEfficiencyTool.h.

m_CDI

std::shared_ptr<Analysis::CalibrationDataInterfaceROOT> BTaggingEfficiencyTool::m_CDI

private

pointer to the object doing the actual work

Definition at line 296 of file BTaggingEfficiencyTool.h.

m_coneFlavourLabel

Gaudi::Property<bool> BTaggingEfficiencyTool::m_coneFlavourLabel {this, "ConeFlavourLabel", true, "specify whether or not to use the cone-based flavour labelling instead of the default ghost association based labelling"}

private

if true, use cone-based labelling (as opposed to ghost association)

Definition at line 377 of file BTaggingEfficiencyTool.h.

{this, "ConeFlavourLabel", true, "specify whether or not to use the cone-based flavour labelling instead of the default ghost association based labelling"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_DSID_to_MapIndex

std::map<unsigned int, unsigned int> BTaggingEfficiencyTool::m_DSID_to_MapIndex

private

Definition at line 426 of file BTaggingEfficiencyTool.h.

m_EffConfigFile

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EffConfigFile {this, "EfficiencyConfig", "", "name of config file specifying which efficiency map to use with a given samples DSID"}

private

Definition at line 312 of file BTaggingEfficiencyTool.h.

{this, "EfficiencyConfig", "", "name of config file specifying which efficiency map to use with a given samples DSID"};

m_EffFile

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EffFile {this, "EfficiencyFileName", "", "name of optional user-provided MC efficiency CDI file"}

private

name of the optional MC efficiency file (may be changed by the PathResolver)

Definition at line 311 of file BTaggingEfficiencyTool.h.

{this, "EfficiencyFileName", "", "name of optional user-provided MC efficiency CDI file"};

m_EffIndices

std::map<unsigned int, unsigned int> BTaggingEfficiencyTool::m_EffIndices

private

actual information identifying efficiency calibration objects

Definition at line 423 of file BTaggingEfficiencyTool.h.

m_effName

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_effName {this, "EfficiencyCalibrations", "default", "default for all flavors"}

private

Definition at line 334 of file BTaggingEfficiencyTool.h.

{this, "EfficiencyCalibrations", "default", "default for all flavors"};

m_EffNames

std::map<std::string, std::string> BTaggingEfficiencyTool::m_EffNames

private

Definition at line 331 of file BTaggingEfficiencyTool.h.

m_EffNames_flex

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EffNames_flex {this, "FlexibleEfficiencyCalibrations", "", "(semicolon-separated) name(s) of efficiency object(s) names for (0,1,2..) indexed flavour labels, e.g. '0:default;1:default;2:default;3:default'"}

private

Definition at line 356 of file BTaggingEfficiencyTool.h.

{this, "FlexibleEfficiencyCalibrations", "", "(semicolon-separated) name(s) of efficiency object(s) names for (0,1,2..) indexed flavour labels, e.g. '0:default;1:default;2:default;3:default'"};

m_EffNamesB

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EffNamesB {this, "EfficiencyBCalibrations", "", "(semicolon-separated) name(s) of b-jet efficiency object(s)"}

private

semicolon-separated lists of MC efficiency parametrisation names

Definition at line 327 of file BTaggingEfficiencyTool.h.

{this, "EfficiencyBCalibrations", "", "(semicolon-separated) name(s) of b-jet efficiency object(s)"};

m_EffNamesC

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EffNamesC {this, "EfficiencyCCalibrations", "", "(semicolon-separated) name(s) of c-jet efficiency object(s)"}

private

Definition at line 328 of file BTaggingEfficiencyTool.h.

{this, "EfficiencyCCalibrations", "", "(semicolon-separated) name(s) of c-jet efficiency object(s)"};

m_EffNamesLight

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EffNamesLight {this, "EfficiencyLightCalibrations", "", "(semicolon-separated) name(s) of light-flavour-jet efficiency object(s)"}

private

Definition at line 330 of file BTaggingEfficiencyTool.h.

{this, "EfficiencyLightCalibrations", "", "(semicolon-separated) name(s) of light-flavour-jet efficiency object(s)"};

m_EffNamesT

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EffNamesT {this, "EfficiencyTCalibrations", "", "(semicolon-separated) name(s) of tau-jet efficiency object(s)"}

private

Definition at line 329 of file BTaggingEfficiencyTool.h.

{this, "EfficiencyTCalibrations", "", "(semicolon-separated) name(s) of tau-jet efficiency object(s)"};

m_EVReduction

std::map<std::string, std::string> BTaggingEfficiencyTool::m_EVReduction

private

Definition at line 324 of file BTaggingEfficiencyTool.h.

m_EVReduction_flex

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EVReduction_flex {this, "FlexibleEigenvectorReduction", "", "(semicolon-separated) list of eigenvector reduction strategy for (0,1,2..) indexed flavour labels; choose between 'Loose', 'Medium', 'Tight' for different labels, e.g. '0:Loose;1:Loose;2:Loose'"}

private

Definition at line 354 of file BTaggingEfficiencyTool.h.

{this, "FlexibleEigenvectorReduction", "", "(semicolon-separated) list of eigenvector reduction strategy for (0,1,2..) indexed flavour labels; choose between 'Loose', 'Medium', 'Tight' for different labels, e.g. '0:Loose;1:Loose;2:Loose'"};

m_EVReductionB

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EVReductionB {this, "EigenvectorReductionB", "Loose", "b-jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"}

private

specification of the eigenvector reduction strategy (if eigenvectors are used)

Definition at line 321 of file BTaggingEfficiencyTool.h.

{this, "EigenvectorReductionB", "Loose", "b-jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"};

m_EVReductionC

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EVReductionC {this, "EigenvectorReductionC", "Loose", "c-jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"}

private

Definition at line 322 of file BTaggingEfficiencyTool.h.

{this, "EigenvectorReductionC", "Loose", "c-jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"};

m_EVReductionLight

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_EVReductionLight {this, "EigenvectorReductionLight", "Loose", "light-flavour jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"}

private

Definition at line 323 of file BTaggingEfficiencyTool.h.

{this, "EigenvectorReductionLight", "Loose", "light-flavour jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_excludeFlvFromEV

std::map<std::string, std::string> BTaggingEfficiencyTool::m_excludeFlvFromEV

private

Definition at line 341 of file BTaggingEfficiencyTool.h.

m_excludeFlvFromEV_flex

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_excludeFlvFromEV_flex {this, "FlexibleExcludeFromEVTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from (0,1,2..) indexed flavour eigenvector decompositions (if used), e.g. '0:;1:;2:;3:'"}

private

Definition at line 360 of file BTaggingEfficiencyTool.h.

{this, "FlexibleExcludeFromEVTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from (0,1,2..) indexed flavour eigenvector decompositions (if used), e.g. '0:;1:;2:;3:'"};

m_excludeFlvFromEVB

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_excludeFlvFromEVB {this, "ExcludeFromEigenVectorBTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from b-jet eigenvector decompositions (if used)"}

private

semicolon-separated list of uncertainties to be excluded from the eigenvector variation procedure for b, c, and light-flavour jets

Definition at line 338 of file BTaggingEfficiencyTool.h.

{this, "ExcludeFromEigenVectorBTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from b-jet eigenvector decompositions (if used)"};

m_excludeFlvFromEVC

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_excludeFlvFromEVC {this, "ExcludeFromEigenVectorCTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from c-jet eigenvector decompositions (if used)"}

private

Definition at line 339 of file BTaggingEfficiencyTool.h.

{this, "ExcludeFromEigenVectorCTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from c-jet eigenvector decompositions (if used)"};

m_excludeFlvFromEVLight

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_excludeFlvFromEVLight {this, "ExcludeFromEigenVectorLightTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from light-flavour-jet eigenvector decompositions (if used)"}

private

Definition at line 340 of file BTaggingEfficiencyTool.h.

{this, "ExcludeFromEigenVectorLightTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from light-flavour-jet eigenvector decompositions (if used)"};

m_excludeFromEV

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_excludeFromEV {this, "ExcludeFromEigenVectorTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from all eigenvector decompositions (if used)"}

private

semicolon-separated list of uncertainties to be excluded from the eigenvector variation procedure for all flavours

Definition at line 336 of file BTaggingEfficiencyTool.h.

{this, "ExcludeFromEigenVectorTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from all eigenvector decompositions (if used)"};

m_extFlavourLabel

Gaudi::Property<bool> BTaggingEfficiencyTool::m_extFlavourLabel {this, "ExtendedFlavourLabel", false, "specify whether or not to use an 'extended' flavour labelling (allowing for multiple HF hadrons or perhaps partons)"}

private

if true, use an 'extended' labelling (allowing for multiple HF hadrons -or perhaps partons- in the jet)

Definition at line 379 of file BTaggingEfficiencyTool.h.

{this, "ExtendedFlavourLabel", false, "specify whether or not to use an 'extended' flavour labelling (allowing for multiple HF hadrons or perhaps partons)"};

m_flex_label_integers

std::vector<unsigned int> BTaggingEfficiencyTool::m_flex_label_integers

private

Definition at line 395 of file BTaggingEfficiencyTool.h.

m_flex_labels

std::vector<std::string> BTaggingEfficiencyTool::m_flex_labels

private

Definition at line 394 of file BTaggingEfficiencyTool.h.

m_ignoreOutOfValidityRange

Gaudi::Property<bool> BTaggingEfficiencyTool::m_ignoreOutOfValidityRange {this, "IgnoreOutOfValidityRange", false, "ignore out-of-extrapolation-range errors as returned by the underlying tool"}

private

if true, ignore out-of-extrapolation range errors (i.e., return CorrectionCode::Ok if these are encountered)

Definition at line 383 of file BTaggingEfficiencyTool.h.

{this, "IgnoreOutOfValidityRange", false, "ignore out-of-extrapolation-range errors as returned by the underlying tool"};

m_initialised

bool BTaggingEfficiencyTool::m_initialised

private

flag to indicate tool is initialized correctly when set

Definition at line 401 of file BTaggingEfficiencyTool.h.

m_isContinuous

bool BTaggingEfficiencyTool::m_isContinuous

private

Definition at line 411 of file BTaggingEfficiencyTool.h.

m_isContinuous2D

bool BTaggingEfficiencyTool::m_isContinuous2D

private

Definition at line 413 of file BTaggingEfficiencyTool.h.

m_jetAuthor

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_jetAuthor {this, "JetAuthor", ftag::defaults::jet_collection, "jet collection & JVF/JVT specification in CDI file"}

private

jet collection name

Definition at line 368 of file BTaggingEfficiencyTool.h.

{this, "JetAuthor", ftag::defaults::jet_collection, "jet collection & JVF/JVT specification in CDI file"};

m_mapIndices

std::map<std::string, unsigned int> BTaggingEfficiencyTool::m_mapIndices

private

Definition at line 418 of file BTaggingEfficiencyTool.h.

m_minPt

Gaudi::Property<float> BTaggingEfficiencyTool::m_minPt {this, "MinPt", 0., "minimum jet pT cut"}

private

minimum jet pT

Definition at line 370 of file BTaggingEfficiencyTool.h.

{this, "MinPt", 0., "minimum jet pT cut"};

m_OP

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_OP {this, "OperatingPoint", ftag::defaults::pcbt_op, "operating point as specified in CDI file"}

private

operating point

Definition at line 366 of file BTaggingEfficiencyTool.h.

{this, "OperatingPoint", ftag::defaults::pcbt_op, "operating point as specified in CDI file"};

m_pathToONNX

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_pathToONNX {this, "pathToONNX", "", "path to the onnx file that will be used for inference"}

private

if this string is empty, the onnx tool won't be created

Definition at line 389 of file BTaggingEfficiencyTool.h.

{this, "pathToONNX", "", "path to the onnx file that will be used for inference"};

m_readFromBTaggingObject

Gaudi::Property<bool> BTaggingEfficiencyTool::m_readFromBTaggingObject {this, "readFromBTaggingObject", false, "Enabled to access btagging scores from xAOD::BTagging object; Can be disabled for GN2v01 to access the scores from the jet itself."}

private

Definition at line 387 of file BTaggingEfficiencyTool.h.

{this, "readFromBTaggingObject", false, "Enabled to access btagging scores from xAOD::BTagging object; Can be disabled for GN2v01 to access the scores from the jet itself."};

m_saltModel

std::unique_ptr<SaltModel> BTaggingEfficiencyTool::m_saltModel

private

pointer to the onnx tool

Definition at line 298 of file BTaggingEfficiencyTool.h.

m_SelectionCDIFile

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_SelectionCDIFile {this, "SelectionCDIFileName", "", "name of the CDI file to be used to configure the selection tool if needed, will use the SF CDI file by default"}

private

Definition at line 309 of file BTaggingEfficiencyTool.h.

{this, "SelectionCDIFileName", "", "name of the CDI file to be used to configure the selection tool if needed, will use the SF CDI file by default"};

m_selectionTaggerName

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_selectionTaggerName {this, "SelectionTaggerName", "", "tagging algorithm name as specified in selection CDI file, will use TaggerName by default"}

private

Definition at line 364 of file BTaggingEfficiencyTool.h.

{this, "SelectionTaggerName", "", "tagging algorithm name as specified in selection CDI file, will use TaggerName by default"};

m_selectionTool

asg::AnaToolHandle<IBTaggingSelectionTool> BTaggingEfficiencyTool::m_selectionTool

private

we need access to a BTaggingSelectionTool, at least for DL1 weight computation

Definition at line 304 of file BTaggingEfficiencyTool.h.

m_SFFile

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_SFFile {this, "ScaleFactorFileName", ftag::defaults::cdi_path, "name of the official scale factor calibration CDI file (uses PathResolver)"}

private

name of the data/MC efficiency scale factor calibration file (may be changed by the PathResolver)

Definition at line 307 of file BTaggingEfficiencyTool.h.

{this, "ScaleFactorFileName", ftag::defaults::cdi_path, "name of the official scale factor calibration CDI file (uses PathResolver)"};

m_SFFileFull

std::string BTaggingEfficiencyTool::m_SFFileFull

private

Definition at line 308 of file BTaggingEfficiencyTool.h.

m_SFIndices

std::map<unsigned int, unsigned int> BTaggingEfficiencyTool::m_SFIndices

private

actual information identifying scale factor calibration objects

Definition at line 421 of file BTaggingEfficiencyTool.h.

m_SFName_flex

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_SFName_flex {this, "FlexibleScaleFactorCalibrations", "", "(semicolon-separated) name of scale factor calibration object for (0,1,2..) indexed flavour labels, e.g. '0:default;1:default;2:default;3:default'"}

private

Definition at line 352 of file BTaggingEfficiencyTool.h.

{this, "FlexibleScaleFactorCalibrations", "", "(semicolon-separated) name of scale factor calibration object for (0,1,2..) indexed flavour labels, e.g. '0:default;1:default;2:default;3:default'"};

m_SFNames

std::map<std::string, std::string> BTaggingEfficiencyTool::m_SFNames

private

Definition at line 318 of file BTaggingEfficiencyTool.h.

m_SFNamesB

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_SFNamesB {this, "ScaleFactorBCalibration", "default", "name of b-jet scale factor calibration object"}

private

names of the data/MC scale factor calibrations

Definition at line 314 of file BTaggingEfficiencyTool.h.

{this, "ScaleFactorBCalibration", "default", "name of b-jet scale factor calibration object"};

m_SFNamesC

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_SFNamesC {this, "ScaleFactorCCalibration", "default", "name of c-jet scale factor calibration object"}

private

Definition at line 315 of file BTaggingEfficiencyTool.h.

{this, "ScaleFactorCCalibration", "default", "name of c-jet scale factor calibration object"};

m_SFNamesLight

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_SFNamesLight {this, "ScaleFactorLightCalibration", "default", "name of light-flavour jet scale factor calibration object"}

private

Definition at line 317 of file BTaggingEfficiencyTool.h.

{this, "ScaleFactorLightCalibration", "default", "name of light-flavour jet scale factor calibration object"};

m_SFNamesT

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_SFNamesT {this, "ScaleFactorTCalibration", "default", "name of tau-jet scale factor calibration object"}

private

Definition at line 316 of file BTaggingEfficiencyTool.h.

{this, "ScaleFactorTCalibration", "default", "name of tau-jet scale factor calibration object"};

m_systematics

CP::SystematicSet BTaggingEfficiencyTool::m_systematics

private

Definition at line 409 of file BTaggingEfficiencyTool.h.

m_systematicsInfo

std::map<CP::SystematicVariation,SystInfo> BTaggingEfficiencyTool::m_systematicsInfo

private

Definition at line 407 of file BTaggingEfficiencyTool.h.

m_systStrategy

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_systStrategy {this, "SystematicsStrategy", ftag::defaults::strategy, "name of systematics model; presently choose between 'SFEigen' and 'Envelope'"}

private

systematics model to be used (current choices are "SFEigen", "SFEigenRefined", and "Envelope") // <-----— Addoing "SFGlobalEigen" to the list

Definition at line 372 of file BTaggingEfficiencyTool.h.

{this, "SystematicsStrategy", ftag::defaults::strategy, "name of systematics model; presently choose between 'SFEigen' and 'Envelope'"};

m_taggerName

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_taggerName {this, "TaggerName", ftag::defaults::tagger, "tagging algorithm name as specified in CDI file"}

private

tagger name

Definition at line 363 of file BTaggingEfficiencyTool.h.

{this, "TaggerName", ftag::defaults::tagger, "tagging algorithm name as specified in CDI file"};

m_uncertaintySuffixes

std::map<std::string, std::string> BTaggingEfficiencyTool::m_uncertaintySuffixes

private

Definition at line 348 of file BTaggingEfficiencyTool.h.

m_uncertaintySuffixes_flex

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_uncertaintySuffixes_flex {this, "FlexibleUncertaintySuffix", "", "optional (semicolon-separated) list of suffixes for (0,1,2..) indexed flavour label uncertainty naming, e.g. '0:;1:;2:;3:'"}

private

Definition at line 358 of file BTaggingEfficiencyTool.h.

{this, "FlexibleUncertaintySuffix", "", "optional (semicolon-separated) list of suffixes for (0,1,2..) indexed flavour label uncertainty naming, e.g. '0:;1:;2:;3:'"};

m_uncertaintySuffixesB

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_uncertaintySuffixesB {this, "UncertaintyBSuffix", "", "optional suffix for b-jet uncertainty naming"}

private

optional (per-flavour) suffix that can be used to decorrelate uncertainties (between flavours, or -in case of a result from different runs- between periods)

Definition at line 344 of file BTaggingEfficiencyTool.h.

{this, "UncertaintyBSuffix", "", "optional suffix for b-jet uncertainty naming"};

m_uncertaintySuffixesC

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_uncertaintySuffixesC {this, "UncertaintyCSuffix", "", "optional suffix for c-jet uncertainty naming"}

private

Definition at line 345 of file BTaggingEfficiencyTool.h.

{this, "UncertaintyCSuffix", "", "optional suffix for c-jet uncertainty naming"};

m_uncertaintySuffixesLight

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_uncertaintySuffixesLight {this, "UncertaintyLightSuffix", "", "optional suffix for light-flavour-jet uncertainty naming"}

private

Definition at line 347 of file BTaggingEfficiencyTool.h.

{this, "UncertaintyLightSuffix", "", "optional suffix for light-flavour-jet uncertainty naming"};

m_uncertaintySuffixesT

Gaudi::Property<std::string> BTaggingEfficiencyTool::m_uncertaintySuffixesT {this, "UncertaintyTSuffix", "", "optional suffix for tau-jet uncertainty naming"}

private

Definition at line 346 of file BTaggingEfficiencyTool.h.

{this, "UncertaintyTSuffix", "", "optional suffix for tau-jet uncertainty naming"};

m_useCTag

Gaudi::Property<bool> BTaggingEfficiencyTool::m_useCTag {this, "useCTagging", false, "Enabled only for FixedCut or Continuous WPs: define wether the cuts refer to b-tagging or c-tagging"}

private

if false, suppress any non-error/warning printout from the underlying tool 1D tagging only: define wether the cuts refer to b-tagging or c-tagging

Definition at line 386 of file BTaggingEfficiencyTool.h.

{this, "useCTagging", false, "Enabled only for FixedCut or Continuous WPs: define wether the cuts refer to b-tagging or c-tagging"};

m_useDevFile

Gaudi::Property<bool> BTaggingEfficiencyTool::m_useDevFile

private

Initial value:

{this, "UseDevelopmentFile", false,
    "specify whether or not to use the (PathResolver) area for temporary scale factor calibration CDI files"}

if true, attempt to retrieve the data/MC efficiency scale factor calibration files from the @PathResolver development area

Definition at line 374 of file BTaggingEfficiencyTool.h.

                                  {this, "UseDevelopmentFile", false,
    "specify whether or not to use the (PathResolver) area for temporary scale factor calibration CDI files"};

m_useFlex

Gaudi::Property<bool> BTaggingEfficiencyTool::m_useFlex {this, "useFlexibleConfig", false, "Setup the flexible configuration of the xAODBTaggingEfficiencyTool with alternate labeling"}

private

Definition at line 393 of file BTaggingEfficiencyTool.h.

{this, "useFlexibleConfig", false, "Setup the flexible configuration of the xAODBTaggingEfficiencyTool with alternate labeling"};

m_useRecommendedEVExclusions

Gaudi::Property<bool> BTaggingEfficiencyTool::m_useRecommendedEVExclusions {this, "ExcludeRecommendedFromEigenVectorTreatment", false, "specify whether or not to add recommended lists to the user specified eigenvector decomposition exclusion lists"}

private

if true, extract pre-set lists of uncertainties to be recommended from the EV decomposition (in addition to user specified ones)

Definition at line 381 of file BTaggingEfficiencyTool.h.

{this, "ExcludeRecommendedFromEigenVectorTreatment", false, "specify whether or not to add recommended lists to the user specified eigenvector decomposition exclusion lists"};

m_using_conventional_labels

bool BTaggingEfficiencyTool::m_using_conventional_labels

private

Definition at line 350 of file BTaggingEfficiencyTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• BTaggingEfficiencyTool.h
• BTaggingEfficiencyTool.cxx