BTaggingTruthTaggingTool Class Reference

Tool to apply flavour-tagging requirements on jets @modified by Ilaria Luise, Nilotpal Kakati in March 2022. More...

#include <BTaggingTruthTaggingTool.h>

Inheritance diagram for BTaggingTruthTaggingTool:

Collaboration diagram for BTaggingTruthTaggingTool:

Classes
struct	jetVariable
struct	TagBin
	Create a proper constructor for Athena. More...
struct	TRFinfo

Public Member Functions
	BTaggingTruthTaggingTool (const std::string &name)
	Create a constructor for standalone usage.
StatusCode	CalculateResults (std::vector< float > &pt, std::vector< float > &eta, std::vector< int > &flav, std::vector< float > &tagw, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	CalculateResults (const xAOD::JetContainer &jets, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	CalculateResultsONNX (const std::vector< std::vector< float > > &node_feat, std::vector< float > &tagw, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	CalculateResultsONNX (const xAOD::JetContainer &jets, const std::vector< std::vector< float > > &node_feat, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	setEffMapIndex (const std::string &flavour, unsigned int index)
	Declare the interface that the class provides.
void	setUseSystematics (bool useSystematics)
virtual	~BTaggingTruthTaggingTool ()
StatusCode	initialize ()
	Dummy implementation of the initialisation function.
CP::SystematicSet	affectingSystematics () const
	the list of all systematics this tool can be affected by
StatusCode	applySystematicVariation (const CP::SystematicSet &systConfig)
	effects: configure this tool for the given list of systematic variations.
CP::SystematicSet	recommendedSystematics () const
	the list of all systematics this tool recommends to use
bool	isAffectedBySystematic (const CP::SystematicVariation &systematic) const
	Declare the interface that this class provides.
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
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
enum	NjetsTagStrategy { AllJets =-1 , Leading2SignalJets =2 , Leading3SignalJets =3 }
	will be set according to m_taggingStrategy More...
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	CalculateResults (TRFinfo &trfinf, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	setJets (TRFinfo &trfinf, std::vector< float > &pt, std::vector< float > &eta, std::vector< int > &flav, std::vector< float > &tagw)
StatusCode	setJets (TRFinfo &trfinf, const xAOD::JetContainer &jets)
StatusCode	setJets (TRFinfo &trfinf, std::vector< int > &flav, std::vector< Analysis::CalibrationDataVariables > *vars)
StatusCode	setJets (TRFinfo &trfinf, const std::vector< std::vector< float > > &node_feat, std::vector< float > &tagw)
StatusCode	setJets (TRFinfo &trfinf, const xAOD::JetContainer &jets, const std::vector< std::vector< float > > &node_feat)
StatusCode	setJets (TRFinfo &trfinf, std::vector< int > &flav, const std::vector< Analysis::CalibrationDataVariables > *vars, const std::vector< std::vector< float > > &node_feat)
StatusCode	GetTruthTagWeights (TRFinfo &trfinf, std::vector< float > &trf_weight_ex, std::vector< float > &trf_weight_in)
StatusCode	getTagPermutation (TRFinfo &trfinf, std::vector< std::vector< bool > > &trf_chosen_perm_ex, std::vector< std::vector< bool > > &trf_chosen_perm_in)
StatusCode	getQuantiles (TRFinfo &trfinf, std::vector< std::vector< int > > &trf_bin_ex, std::vector< std::vector< int > > &trf_bin_in)
float	getEvtSF (TRFinfo &trfinf, std::vector< int > &quantiles)
StatusCode	getDirectTaggedJets (TRFinfo &trfinf, std::vector< bool > &is_tagged)
StatusCode	getTRFweight (TRFinfo &trfinf, unsigned int nbtag, bool isInclusive)
StatusCode	getAllEffMC (TRFinfo &trfinf)
StatusCode	getAllEffMCCDI (TRFinfo &trfinf)
StatusCode	getAllEffMCGNN (TRFinfo &trfinf)
StatusCode	getAllEffSF (TRFinfo &trfinf, int=0)
int	jetFlavourLabel (const xAOD::Jet &jet)
int	GAFinalHadronFlavourLabel (const xAOD::Jet &jet)
int	ExclusiveConeHadronFlavourLabel (const xAOD::Jet &jet)
std::vector< std::string >	split (const std::string &str, char token)
StatusCode	check_syst_range (unsigned int sys)
std::vector< std::vector< bool > >	generatePermutations (int njets, int tags, int start=0)
float	trfWeight (TRFinfo &trfinf, const std::vector< bool > &tags)
StatusCode	chooseAllTagPermutation (TRFinfo &trfinf, unsigned int nbtag)
StatusCode	chooseTagPermutation (TRFinfo &trfinf, unsigned int nbtag, bool isIncl)
StatusCode	chooseAllTagBins (TRFinfo &trfinf)
StatusCode	chooseTagBins_cum (TRFinfo &trfinf, std::vector< bool > &tagconf, bool isIncl, unsigned int nbtag)
StatusCode	generateRandomTaggerScores (std::vector< std::vector< int > > &quantiles, std::vector< std::vector< float > > &btag_scores, std::vector< std::vector< float > > &ctag_scores)
float	getTagBinsConfProb (TRFinfo &trfinf, std::vector< int > &tagws)
StatusCode	fillVariables (const xAOD::Jet &jet, Analysis::CalibrationDataVariables &x)
StatusCode	fillVariables (const float jetPt, const float jetEta, const float jetTagWeight, Analysis::CalibrationDataVariables &x)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::vector< std::string >	m_availableOP_fixCut = {"FixedCutBEff_85", "FixedCutBEff_77","FixedCutBEff_70","FixedCutBEff_60"}
TFile *	m_inf {}
std::vector< TagBin >	m_cuts
bool	m_initialised {}
std::vector< CP::SystematicSet >	m_eff_syst
std::vector< std::string >	m_sys_name
Gaudi::Property< std::string >	m_SFFile {this, "ScaleFactorFileName", "xAODBTaggingEfficiency/13TeV/2016-20_7-13TeV-MC15-CDI-July12_v1.root", "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)
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_SFBName {this, "ScaleFactorBCalibration", "default", "name of b-jet scale factor calibration object"}
	name of the data/MC scale factor calibration for b jets
Gaudi::Property< std::string >	m_SFCName {this, "ScaleFactorCCalibration", "default", "name of c-jet scale factor calibration object"}
	name of the data/MC scale factor calibration for charm jets
Gaudi::Property< std::string >	m_SFTName {this, "ScaleFactorTCalibration", "default", "name of tau-jet scale factor calibration object"}
	name of the data/MC scale factor calibration for tau jets
Gaudi::Property< std::string >	m_SFLightName {this, "ScaleFactorLightCalibration", "default", "name of light-flavour jet scale factor calibration object"}
	name of the data/MC scale factor calibration for light-flavour jets
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 for b jets (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'"}
	specification of the eigenvector reduction strategy for c jets (if eigenvectors are used)
Gaudi::Property< std::string >	m_EVReductionLight {this, "EigenvectorReductionLight", "Loose","light-flavour jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'"}
	specification of the eigenvector reduction strategy for light-flavour jets (if eigenvectors are used)
Gaudi::Property< std::string >	m_EffBName {this, "EfficiencyBCalibrations", "default", "(semicolon-separated) name(s) of b-jet efficiency object(s)"}
	semicolon-separated list of MC efficiency parametrisation names for b jets
Gaudi::Property< std::string >	m_EffCName {this, "EfficiencyCCalibrations", "default", "(semicolon-separated) name(s) of c-jet efficiency object(s)"}
	semicolon-separated list of MC efficiency parametrisation names for charm jets
Gaudi::Property< std::string >	m_EffTName {this, "EfficiencyTCalibrations", "default", "(semicolon-separated) name(s) of tau-jet efficiency object(s)"}
	semicolon-separated list of MC efficiency parametrisation names for tau jets
Gaudi::Property< std::string >	m_EffLightName {this, "EfficiencyLightCalibrations", "default", "(semicolon-separated) name(s) of light-flavour-jet efficiency object(s)"}
	semicolon-separated list of MC efficiency parametrisation names for light-flavour jets
Gaudi::Property< std::string >	m_excludeFromEV {this, "ExcludeFromEigenVectorTreatment", "", "(semicolon-separated) names of uncertainties to be excluded from eigenvector decomposition (if used)"}
	semicolon-separated list of uncertainties to be excluded from the eigenvector variation procedure
Gaudi::Property< std::string >	m_taggerName {this, "TaggerName", "MV2c10", "tagging algorithm name as specified in CDI file"}
	tagger name
Gaudi::Property< std::string >	m_OP {this, "OperatingPoint", "FixedCutBEff_77", "operating point as specified in CDI file"}
	operating point
Gaudi::Property< std::string >	m_cutBenchmark {this, "CutBenchmark", "1,2", "if you want to run in continuous you need to fix a benchmark - it does something only if running in Continuous OP"}
	operating point when running in Continuous
Gaudi::Property< std::string >	m_jetAuthor {this, "JetAuthor", "AntiKt4EMTopoJets", "jet collection & JVF/JVT specification in CDI file"}
	jet collection name
Gaudi::Property< std::string >	m_systStrategy {this, "SystematicsStrategy", "SFEigen", "name of systematics model; presently choose between 'SFEigen' and 'Envelope'"}
	systematics model to be used (current choices are "SFEigen" and "Envelope")
Gaudi::Property< bool >	m_useDevFile {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
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< std::string >	m_excludeEV {this, "ExcludeSpecificEigens", "" , "(semicolon-separated) names of Eigens you want to exclude. in case of continuous some eigenvectors can be ignored to make the computation faster"}
	in case of continuous WP you can choose to ignore some of the eigenvectors
Gaudi::Property< bool >	m_doDirectTag {this, "doDirectTagging", false , "If set to true it also computes and stores the direct tagging choice and the related SFs for each jet"}
	possibility to compute the direct tagging SFs map directly from the TruthTaggingTool
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 used
Gaudi::Property< std::string >	m_taggingStrategy {this, "TaggingStrategy", "AllJets", "tagging strategy in the Analysis (eg. 'leading2SignalJets' in boosted VHbb). Required to do TT with GNN"}
	tagging strategy is required to do TT with GNN, when we don't want to truth tag all the jets (eg. 'leading2SignalJets')
NjetsTagStrategy	m_njetsTagStrategy {AllJets}
Gaudi::Property< float >	m_minPt {this, "MinPt", 20000 , "Minimum jet pT cut (in MeV)"}
Gaudi::Property< float >	m_maxEta {this, "MaxEta", 2.5, "Maximum jet eta cut"}
Gaudi::Property< float >	m_maxRangePt {this, "MaxRangePt", 1000000 , "Max pT range (in MeV)"}
Gaudi::Property< bool >	m_doOnlyUpVariations {this, "StoreOnlyUpVariations", false , "If set to true it processes only the __1up b-tagging variations. It speeds up the computation in case of symmetric variations."}
bool	m_continuous {}
bool	m_continuous2D {}
Gaudi::Property< bool >	m_ignoreSF {this, "IgnoreScaleFactors", true, "ignore scale factors in computation of TRF weight"}
Gaudi::Property< bool >	m_usePerm {this, "UsePermutations", true, "if the chosen permutation is used, a reweighting is applied to the TRF weight for systematics"}
Gaudi::Property< bool >	m_useQuantile {this, "UseQuantile", true, "if the chosen quantile is used, a reweighting is applied to the TRF weight for systematics"}
Gaudi::Property< bool >	m_useSys {this, "UseSystematics", false, "will the results contain all systematic variations, or just the nominal"}
Gaudi::Property< int >	m_nbtag {this, "MaxNtagged", 2, "what is the maximal possible number of tagged jets"}
int	m_nbins {}
std::vector< int >	m_OperatingBins
unsigned int	m_OP_index_for_GNN {}
std::map< int, asg::AnaToolHandle< IBTaggingEfficiencyTool > >	m_effTool_allBins
asg::AnaToolHandle< IBTaggingEfficiencyTool >	m_effTool
asg::AnaToolHandle< IBTaggingSelectionTool >	m_selTool
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

Detailed Description

Tool to apply flavour-tagging requirements on jets @modified by Ilaria Luise, Nilotpal Kakati in March 2022.

Author

C. Rizzi, M. Ughetto @contact chiar.nosp@m.a.ri.nosp@m.zzi@c.nosp@m.ern..nosp@m.ch, mughe.nosp@m.tto@.nosp@m.cern..nosp@m.ch @contact ilari.nosp@m.a.lu.nosp@m.ise@c.nosp@m.ern..nosp@m.ch, nkaka.nosp@m.ti@c.nosp@m.ern.c.nosp@m.h

Definition at line 48 of file BTaggingTruthTaggingTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

NjetsTagStrategy

enum BTaggingTruthTaggingTool::NjetsTagStrategy

private

will be set according to m_taggingStrategy

Enumerator
AllJets
Leading2SignalJets
Leading3SignalJets

Definition at line 262 of file BTaggingTruthTaggingTool.h.

{AllJets=-1, Leading2SignalJets=2, Leading3SignalJets=3};

Constructor & Destructor Documentation

BTaggingTruthTaggingTool()

BTaggingTruthTaggingTool::BTaggingTruthTaggingTool

(

const std::string &

name

)

Create a constructor for standalone usage.

Definition at line 39 of file BTaggingTruthTaggingTool.cxx.

  : asg::AsgTool( name ),
    m_effTool ("BTaggingEfficiencyTool/effTool", this),
    m_selTool ("BTaggingSelectionTool/selTool", this)
  {
 
  m_initialised = false;
}

~BTaggingTruthTaggingTool()

BTaggingTruthTaggingTool::~BTaggingTruthTaggingTool ( )

virtual

Definition at line 1060 of file BTaggingTruthTaggingTool.cxx.

                                                   {
 
  // delete trfinf.jets;
 
}

Member Function Documentation

affectingSystematics()

SystematicSet BTaggingTruthTaggingTool::affectingSystematics ( ) const

virtual

the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 59 of file BTaggingTruthTaggingTool.cxx.

                                                                   {
  return m_effTool->affectingSystematics();
}

applySystematicVariation()

StatusCode BTaggingTruthTaggingTool::applySystematicVariation ( const CP::SystematicSet & systConfig )

virtual

effects: configure this tool for the given list of systematic variations.

any requested systematics that are not affecting this tool will be silently ignored (unless they cause other errors). failures: systematic unknown failures: requesting multiple variations on the same systematic (e.g. up & down) failures: requesting an unsupported variation on an otherwise supported systematic (e.g. a 2 sigma variation and the tool only supports 1 sigma variations) failures: unsupported combination of supported systematic failures: other tool specific errors

Implements CP::ISystematicsTool.

Definition at line 63 of file BTaggingTruthTaggingTool.cxx.

{
    for (auto syst : systConfig) {
        CP::SystematicSet myset;
        ATH_MSG_WARNING("applySystematicVariation was called for " << syst.name() << " but BTaggingTruthTaggingTool does not apply Systematic Variations");
        //the truth tagging tool provides results for all possible systematic variations in its results objects, the user does not need to call each one seperatly.
    }
   return StatusCode::SUCCESS;
}

CalculateResults() [1/3]

StatusCode BTaggingTruthTaggingTool::CalculateResults ( const xAOD::JetContainer & jets, Analysis::TruthTagResults & results, int rand_seed = -1 )

virtual

Implements IBTaggingTruthTaggingTool.

Definition at line 528 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                 {
 
  ANA_CHECK_SET_TYPE (StatusCode);
 
  TRFinfo trfinf;
 
  ANA_CHECK(setJets(trfinf,jets));
 
  return CalculateResults(trfinf,results,rand_seed);
}

CalculateResults() [2/3]

StatusCode BTaggingTruthTaggingTool::CalculateResults ( std::vector< float > & pt, std::vector< float > & eta, std::vector< int > & flav, std::vector< float > & tagw, Analysis::TruthTagResults & results, int rand_seed = -1 )

virtual

Implements IBTaggingTruthTaggingTool.

Definition at line 517 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                                                                              {
 
  ANA_CHECK_SET_TYPE (StatusCode);
 
  TRFinfo trfinf;
 
  ANA_CHECK(setJets(trfinf,pt, eta, flav, tagw));
 
  return CalculateResults(trfinf,results,rand_seed);
}

CalculateResults() [3/3]

StatusCode BTaggingTruthTaggingTool::CalculateResults ( TRFinfo & trfinf, Analysis::TruthTagResults & results, int rand_seed = -1 )

private

Definition at line 436 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                   {
  ANA_CHECK_SET_TYPE (StatusCode);
  results.clear();
 
  if(rand_seed!=-1){
    trfinf.rand.SetSeed(rand_seed);
  }
 
  std::vector<float> trf_weight_ex,  trf_weight_in;
 
  trf_weight_ex.clear();
  trf_weight_in.clear();
 
  ANA_CHECK(GetTruthTagWeights(trfinf, trf_weight_ex, trf_weight_in));
 
  ANA_CHECK(getTagPermutation(trfinf,results.trf_chosen_perm_ex,results.trf_chosen_perm_in));
 
  //modify quantiles according to the different conventions
  ANA_CHECK(getQuantiles(trfinf,results.trf_bin_ex, results.trf_bin_in));
    
  //new tagger scores
  ANA_CHECK(generateRandomTaggerScores(results.trf_bin_ex, results.trf_bin_score_ex, results.trf_ctag_bin_score_ex));
  ANA_CHECK(generateRandomTaggerScores(results.trf_bin_in, results.trf_bin_score_in, results.trf_ctag_bin_score_in));
 
  //direct tag
  if(m_doDirectTag)
    ANA_CHECK( getDirectTaggedJets(trfinf, results.is_tagged) );
 
  //handle systematics
  unsigned int n_systs = (m_useSys) ? m_eff_syst.size() : 1;
  results.syst_names.clear();
 
  for(unsigned int sys = 0; sys < n_systs; ++sys){
    if(sys!=0 && m_useSys) {
      ANA_CHECK_THROW( m_effTool->applySystematicVariation(m_eff_syst[sys]) );
    }
    
    results.syst_names.push_back(m_sys_name.at(sys));
    
    results.map_trf_weight_ex[m_sys_name.at(sys)].resize(trfinf.trfw_ex.size());
    results.map_trf_weight_in[m_sys_name.at(sys)].resize(trfinf.trfw_in.size());
 
    results.map_SF_ex[m_sys_name.at(sys)].resize(trfinf.trfw_ex.size());
    results.map_SF_in[m_sys_name.at(sys)].resize(trfinf.trfw_in.size());
 
    //direct tagging
    if(m_doDirectTag){
      std::vector<int> is_tagged;
      for(auto t : results.is_tagged){
    is_tagged.push_back(static_cast<int>(t));
      }
      results.map_SF[m_sys_name.at(sys)]=getEvtSF(trfinf,is_tagged);
    }
 
    //go over the ntag combinations.
    //ntj = number of tagged jets
    for(unsigned int ntj=0; ntj< trfinf.trfw_ex.size(); ntj++){
      if(ntj > trfinf.njets) {
    results.map_SF_ex[m_sys_name.at(sys)].at(ntj) = 1.;
    results.map_SF_in[m_sys_name.at(sys)].at(ntj) = 1.;
    ATH_MSG_DEBUG("number of jets: " <<trfinf.njets <<" less than max btag: " <<m_nbtag <<". Return BTag SF = 1. Consider applying an event pre-selection if this happens too often.");
      }
      else{
    results.map_SF_ex[m_sys_name.at(sys)].at(ntj) = getEvtSF(trfinf,results.trf_bin_ex.at(ntj));
    results.map_SF_in[m_sys_name.at(sys)].at(ntj) = getEvtSF(trfinf,results.trf_bin_in.at(ntj));
      }
      
      results.map_trf_weight_ex[m_sys_name.at(sys)].at(ntj) = trfinf.trfw_ex.at(ntj) * results.map_SF_ex[m_sys_name.at(sys)].at(ntj);
      results.map_trf_weight_in[m_sys_name.at(sys)].at(ntj) = trfinf.trfw_in.at(ntj) * results.map_SF_in[m_sys_name.at(sys)].at(ntj);
    }
  }
 
  if(m_useSys) {  // reset syst to nominal
    CP::SystematicSet defaultSet;
    ANA_CHECK_THROW( m_effTool->applySystematicVariation(defaultSet) );
  }
 
  return StatusCode::SUCCESS;
 
}

CalculateResultsONNX() [1/2]

StatusCode BTaggingTruthTaggingTool::CalculateResultsONNX ( const std::vector< std::vector< float > > & node_feat, std::vector< float > & tagw, Analysis::TruthTagResults & results, int rand_seed = -1 )

virtual

Implements IBTaggingTruthTaggingTool.

Definition at line 540 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                                                              {
 
  ANA_CHECK_SET_TYPE (StatusCode);
 
  TRFinfo trfinf;
    
  ANA_CHECK(setJets(trfinf, node_feat, tagw));
 
  return CalculateResults(trfinf, results, rand_seed);
}

CalculateResultsONNX() [2/2]

StatusCode BTaggingTruthTaggingTool::CalculateResultsONNX ( const xAOD::JetContainer & jets, const std::vector< std::vector< float > > & node_feat, Analysis::TruthTagResults & results, int rand_seed = -1 )

virtual

Implements IBTaggingTruthTaggingTool.

Definition at line 552 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                                                                    {
 
  ANA_CHECK_SET_TYPE (StatusCode);
 
  TRFinfo trfinf;
 
  ANA_CHECK(setJets(trfinf, jets, node_feat));
 
  return CalculateResults(trfinf, results, rand_seed);
}

check_syst_range()

StatusCode BTaggingTruthTaggingTool::check_syst_range ( unsigned int sys )

private

Definition at line 1052 of file BTaggingTruthTaggingTool.cxx.

                                                                     {
  if(sys < m_eff_syst.size()) return StatusCode::SUCCESS;
  ATH_MSG_ERROR(sys << " Out of range of available systematics");
  return StatusCode::FAILURE;
}

chooseAllTagBins()

StatusCode BTaggingTruthTaggingTool::chooseAllTagBins ( TRFinfo & trfinf )

private

Definition at line 879 of file BTaggingTruthTaggingTool.cxx.

                                                                    {
  ANA_CHECK_SET_TYPE (StatusCode);
  trfinf.tbins_ex.clear();
  trfinf.tbins_in.clear();
  trfinf.tbins_ex.resize( trfinf.trfw_ex.size());
  trfinf.tbins_in.resize( trfinf.trfw_in.size());
 
  trfinf.binsprob_ex.clear();
  trfinf.binsprob_in.clear();
  trfinf.binsprob_ex.resize( trfinf.trfw_ex.size());
  trfinf.binsprob_in.resize( trfinf.trfw_in.size());
 
  if(trfinf.perm_ex.size() != trfinf.perm_in.size()) ATH_MSG_WARNING("Different sizes in exclusive and inclusive permutation choices");
 
  for(unsigned int nb=0; nb<trfinf.perm_ex.size(); nb++) {
    ANA_CHECK(chooseTagBins_cum(trfinf,trfinf.perm_ex.at(nb), false, nb));
    ANA_CHECK(chooseTagBins_cum(trfinf,trfinf.perm_in.at(nb), true, nb));
  }
  return StatusCode::SUCCESS;
}

chooseAllTagPermutation()

StatusCode BTaggingTruthTaggingTool::chooseAllTagPermutation ( TRFinfo & trfinf, unsigned int nbtag )

private

Definition at line 784 of file BTaggingTruthTaggingTool.cxx.

                                                                                              {
 
  ANA_CHECK_SET_TYPE (StatusCode);
 
  if(!m_usePerm){
    return StatusCode::FAILURE;
  }
 
  unsigned int njets = trfinf.njets;
  unsigned int limit = (njets > 7) ? 8 : njets+1;
  unsigned int max = (njets < nbtag+1) ? limit : nbtag+1;
 
  trfinf.perm_ex.clear(), trfinf.perm_ex.resize(nbtag+1);
  trfinf.perm_in.clear(), trfinf.perm_in.resize(nbtag+1);
 
  trfinf.permprob_ex.clear(), trfinf.permprob_ex.resize(nbtag+1);
  trfinf.permprob_in.clear(), trfinf.permprob_in.resize(nbtag+1);
 
  for(unsigned int i=0; i<max; i++) { // need +1 as 0 is included
    ANA_CHECK(chooseTagPermutation(trfinf,i,false));
    ANA_CHECK(chooseTagPermutation(trfinf,i,true));
  }
 
  return StatusCode::SUCCESS;
}

chooseTagBins_cum()

StatusCode BTaggingTruthTaggingTool::chooseTagBins_cum ( TRFinfo & trfinf, std::vector< bool > & tagconf, bool isIncl, unsigned int nbtag )

private

Definition at line 901 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                               {
  std::vector<int> btagops;
 
  ATH_MSG_DEBUG("chooseTagBins_cum ntag: " <<nbtag);
 
  std::vector<float> incl;
  std::vector<float> untagged_bins;
  float prob = 1.;
 
  //define the untagged bins
  for (int bin=0; bin<m_nbins; bin++) {
    if (std::count(m_OperatingBins.begin(), m_OperatingBins.end(), bin)) continue;
    untagged_bins.push_back(bin); 
  }
 
  //How to calculate Probabilities:
  //sum: [---- P(bin 0) -----][-- P(bin 1) ---][- P(bin 2) -]
  //random X up to sum of the bins. pick one prob based on the efficiency
  for(unsigned int j=0; j<tagconf.size(); j++) {
 
    ATH_MSG_DEBUG("tagconf.at(tc) " <<tagconf.at(j));
 
    if(tagconf.at(j)) { // tagged jet
      float sum=0.;
      incl.clear();
      for (int tagged_bin : m_OperatingBins){
    sum += trfinf.effMC_allBins[tagged_bin][j];
    incl.push_back(sum);
      }
 
      float theX = trfinf.rand.Uniform(sum);
      auto tag_index = std::lower_bound(incl.begin(), incl.end(), theX) - incl.begin();
      float tbin_choice = m_OperatingBins[tag_index];
      btagops.push_back(tbin_choice);
      prob *= (trfinf.effMC_allBins[tbin_choice][j]);
      ATH_MSG_DEBUG("it " <<tag_index <<" theX " <<theX <<" effMC " <<trfinf.effMC_allBins[tbin_choice][j] <<" prob* "  <<prob);
    } //tagged
    else { // untagged jet
      float untag_sum  = 0. ;
      incl.clear();
      //sum over untagged bins
      for(auto bin : untagged_bins){
    untag_sum += trfinf.effMC_allBins[bin][j];
        incl.push_back(untag_sum);
      }
      
      float theX = trfinf.rand.Uniform(untag_sum);
      auto untag_index = std::lower_bound(incl.begin(), incl.end(), theX) - incl.begin();
      float utbin_choice = untagged_bins[untag_index]; 
        btagops.push_back(utbin_choice);
    prob *= 1 - trfinf.effMC_allBins[utbin_choice][j];
    ATH_MSG_DEBUG(" unt_bin " <<untag_index <<" theX " <<theX<<" 1-effMC " <<1-trfinf.effMC_allBins[utbin_choice][j] <<" prob* " <<prob);
    }
  }
 
  if(btagops.size() != tagconf.size()) {
    ATH_MSG_ERROR("You should not be here -> wrong size of tag bins vector. btagops: " <<btagops.size() <<" tagconf: " <<tagconf.size());
    return StatusCode::FAILURE;
  }
  if(isIncl) {
    trfinf.tbins_in.at(nbtag) = btagops;
    trfinf.binsprob_in.at(nbtag) = prob;
    ATH_MSG_DEBUG("incl, nbtag " << nbtag << "   prob " << prob);
  }
  else {
    trfinf.tbins_ex.at(nbtag) = btagops;
    trfinf.binsprob_ex.at(nbtag) = prob;
    ATH_MSG_DEBUG("excl, nbtag " << nbtag << "   prob " << prob);
  }
  return StatusCode::SUCCESS;
}

chooseTagPermutation()

StatusCode BTaggingTruthTaggingTool::chooseTagPermutation ( TRFinfo & trfinf, unsigned int nbtag, bool isIncl )

private

Definition at line 810 of file BTaggingTruthTaggingTool.cxx.

                                                                                                        {
  std::vector<float> incl;
  std::vector<std::pair<unsigned int, unsigned int> > trackPerm;
  float sum = 0;
  if(isIncl) {
    for(unsigned int itag=nbtag; itag < trfinf.permsWeight.size(); itag++) {
      for(unsigned int ip = 0; ip < trfinf.permsWeight.at(itag).size(); ip++) {
        sum += trfinf.permsWeight.at(itag).at(ip);
        incl.push_back(sum);
        trackPerm.push_back(std::make_pair(itag,ip));
      }
    }
  }
  else { // in exclusive case
    sum = trfinf.permsSumWeight.at(nbtag).back();
    incl = trfinf.permsSumWeight.at(nbtag);
    for(unsigned int ip = 0; ip < trfinf.permsSumWeight.at(nbtag).size(); ip++) trackPerm.push_back(std::make_pair(nbtag,ip));
  }
  float theX = trfinf.rand.Uniform(sum);
  for(unsigned int ip=0; ip < incl.size(); ip++) {
    ATH_MSG_DEBUG("incl.at(ip): " << incl.at(ip) << "  theX: " << theX);
    if(incl.at(ip) >= theX) {
      if(isIncl) {
        trfinf.perm_in.at(nbtag) = trfinf.perms[trfinf.njets].at(trackPerm.at(ip).first).at(trackPerm.at(ip).second);
        trfinf.permprob_in.at(nbtag) = trfinf.permsWeight.at(trackPerm.at(ip).first).at(trackPerm.at(ip).second) / trfinf.trfw_in.at(nbtag);
      }
      else {
        trfinf.perm_ex.at(nbtag) = trfinf.perms[trfinf.njets].at(trackPerm.at(ip).first).at(trackPerm.at(ip).second);
        trfinf.permprob_ex.at(nbtag) = trfinf.permsWeight.at(trackPerm.at(ip).first).at(trackPerm.at(ip).second) / trfinf.trfw_ex.at(nbtag);
      }
      return StatusCode::SUCCESS;
    }
  }
  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; }

ExclusiveConeHadronFlavourLabel()

int BTaggingTruthTaggingTool::ExclusiveConeHadronFlavourLabel ( const xAOD::Jet & jet )

private

Definition at line 1091 of file BTaggingTruthTaggingTool.cxx.

                                                                                {
  // default label means "invalid"
  int label = -1;
  // We don't check the return value, as we would not be able to handle it gracefully anyway
  jet.getAttribute("HadronConeExclTruthLabelID",label);
  return label;
}

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]

StatusCode BTaggingTruthTaggingTool::fillVariables ( const float jetPt, const float jetEta, const float jetTagWeight, Analysis::CalibrationDataVariables & x )

private

Definition at line 409 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                               {
  x.jetPt = jetPt;
  x.jetEta = jetEta;
  x.jetTagWeight = jetTagWeight;
  x.jetAuthor = m_jetAuthor;
  return StatusCode::SUCCESS;
}

fillVariables() [2/2]

StatusCode BTaggingTruthTaggingTool::fillVariables ( const xAOD::Jet & jet, Analysis::CalibrationDataVariables & x )

private

Definition at line 392 of file BTaggingTruthTaggingTool.cxx.

                                                                                                  {
  x.jetPt = jet.pt();
  x.jetEta = jet.eta();
  x.jetAuthor = m_jetAuthor;
 
  const xAOD::BTagging* tagInfo = xAOD::BTaggingUtilities::getBTagging( jet );
  if (!tagInfo) return StatusCode::FAILURE;
 
  CorrectionCode code = m_selTool->getTaggerWeight(jet, x.jetTagWeight);
  if(!(code==CorrectionCode::Ok || code==CorrectionCode::OutOfValidityRange)){
    ATH_MSG_ERROR("BTaggingSelectionTool::getTaggerWeight returned CorrectionCode::Error");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

GAFinalHadronFlavourLabel()

int BTaggingTruthTaggingTool::GAFinalHadronFlavourLabel ( const xAOD::Jet & jet )

private

Definition at line 1074 of file BTaggingTruthTaggingTool.cxx.

                                                                           {
 
  const std::string labelB = "GhostBHadronsFinal";
  const std::string labelC = "GhostCHadronsFinal";
  const std::string labelTau = "GhostTausFinal";
 
  std::vector<const IParticle*> ghostB;
  if (jet.getAssociatedObjects<IParticle>(labelB, ghostB) && ghostB.size() > 0) return 5;
  std::vector<const IParticle*> ghostC;
  if (jet.getAssociatedObjects<IParticle>(labelC, ghostC) && ghostC.size() > 0) return 4;
  std::vector<const IParticle*> ghostTau;
  if (jet.getAssociatedObjects<IParticle>(labelTau, ghostTau) && ghostTau.size() > 0) return 15;
 
 
  return 0;
}

generatePermutations()

std::vector< std::vector< bool > > BTaggingTruthTaggingTool::generatePermutations ( int njets, int tags, int start = 0 )

private

Definition at line 639 of file BTaggingTruthTaggingTool.cxx.

                                                                                                        {
  std::vector<std::vector<bool> > perm;
  std::vector<std::vector<bool> > temp_perm;
  if(tags==0){
    std::vector<bool> tags(njets,false);
    perm.push_back(tags);
  }
  else if(tags == njets) {
    std::vector<bool> tags(njets,true);
    perm.push_back(tags);
  }
  else {
    for(int i=start; i<njets;i++){
      temp_perm = generatePermutations(njets,tags-1,i+1);
      for(unsigned int j=0; j<temp_perm.size(); j++){
        temp_perm.at(j).at(i)=true;
        perm.push_back(temp_perm.at(j));
      }
    }
  }
  return perm;
}

generateRandomTaggerScores()

StatusCode BTaggingTruthTaggingTool::generateRandomTaggerScores ( std::vector< std::vector< int > > & quantiles, std::vector< std::vector< float > > & btag_scores, std::vector< std::vector< float > > & ctag_scores )

private

Definition at line 1128 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                                                                             {
 
  TRandom3 random;
  
  btag_scores.clear();
  btag_scores.resize(quantiles.size());
  
  if(m_continuous2D){
    ctag_scores.clear();
    ctag_scores.resize(quantiles.size());
  }
  
  for(unsigned int i=0; i <quantiles.size(); i++ ){
 
    btag_scores.at(i).resize(quantiles.at(i).size());
    if(m_continuous2D)
      ctag_scores.at(i).resize(quantiles.at(i).size());
 
    unsigned int njets = quantiles.at(i).size();
    for(unsigned int j=0; j < njets; j++ ){
 
      int temp_quantile = (m_continuous2D) ? quantiles.at(i).at(j) : quantiles.at(i).at(j) -1;
 
      float btag_low =  m_cuts[temp_quantile].bcut_low;
      float btag_hig =  m_cuts[temp_quantile].bcut_hig;
                  
      float ctag_low =  m_cuts[temp_quantile].ccut_low;
      float ctag_hig =  m_cuts[temp_quantile].ccut_hig;
 
      btag_scores.at(i).at(j) = btag_low + random.Uniform()*(btag_hig - btag_low );
      if(m_continuous2D)
    ctag_scores.at(i).at(j) = ctag_low + random.Uniform()*(ctag_hig - ctag_low );
    }
  }
  return StatusCode::SUCCESS;
 
}

getAllEffMC()

StatusCode BTaggingTruthTaggingTool::getAllEffMC ( TRFinfo & trfinf )

private

Definition at line 563 of file BTaggingTruthTaggingTool.cxx.

                                                               {
  if (trfinf.node_feat.size() == 0){
    return getAllEffMCCDI(trfinf);
  } else {
    return getAllEffMCGNN(trfinf);
  }
}

getAllEffMCCDI()

StatusCode BTaggingTruthTaggingTool::getAllEffMCCDI ( TRFinfo & trfinf )

private

Definition at line 607 of file BTaggingTruthTaggingTool.cxx.

                                                                  {
 
  float eff_all =1.;
  for(int bin = 0; bin < m_nbins; bin++)
    trfinf.effMC_allBins[bin].clear();
  
  for(size_t jet=0; jet < trfinf.jets.size(); jet++){
      for(int bin = 0; bin < m_nbins; bin++){   // loop on bins    
        eff_all=1.;
 
        //set a dumb value of the truth tag weight to get the different efficiency maps for each bin. to be improved..
    if (m_continuous2D)
      trfinf.jets.at(jet).vars.jetTagWeight = bin+0.5;
    else
      trfinf.jets.at(jet).vars.jetTagWeight = (m_cuts[bin].bcut_low + m_cuts[bin].bcut_hig)/2.;
 
    ATH_MSG_DEBUG("effMC_allBins: tag bin: " <<bin <<" tagw: "  << trfinf.jets.at(jet).vars.jetTagWeight <<" "  <<m_cuts[bin].bcut_low <<" "  << m_cuts[bin].bcut_hig <<" " <<trfinf.jets.at(jet).vars.jetPt <<" " <<trfinf.jets.at(jet).vars.jetEta <<" " <<trfinf.jets.at(jet).flav);
    //get the efficiency    
        CorrectionCode code = m_effTool->getMCEfficiency(trfinf.jets.at(jet).flav, trfinf.jets.at(jet).vars, eff_all);
    if(!(code==CorrectionCode::Ok || code==CorrectionCode::OutOfValidityRange)){
      ATH_MSG_ERROR("BTaggingEfficiencyTool::getMCEfficiency returned CorrectionCode::Error");
      return StatusCode::FAILURE;
    }
 
        trfinf.effMC_allBins[bin].push_back(eff_all);
    ATH_MSG_DEBUG("effMC_allBins: tag bin: " <<bin <<" tagw: "  << trfinf.jets.at(jet).vars.jetTagWeight  <<" eff: " <<eff_all);
      } // end loop on bins
  } // end loop on jets
 
  return StatusCode::SUCCESS;
}

getAllEffMCGNN()

StatusCode BTaggingTruthTaggingTool::getAllEffMCGNN ( TRFinfo & trfinf )

private

Definition at line 572 of file BTaggingTruthTaggingTool.cxx.

                                                                  {
 
  for(int bin = 0; bin < m_nbins; bin++)
    trfinf.effMC_allBins[bin].clear();
    
  //extract efficiency
  std::vector<std::vector<float>> tmp_effMC_allBins; // shape:{num_jets, num_wp}
  CorrectionCode code = m_effTool->getMCEfficiencyONNX(trfinf.node_feat, tmp_effMC_allBins);
  
  if(!(code==CorrectionCode::Ok || code==CorrectionCode::OutOfValidityRange)){
    ATH_MSG_ERROR("BTaggingEfficiencyTool::getMCEfficiencyONNX returned CorrectionCode::Error");
    return StatusCode::FAILURE;
  }
 
  if(m_continuous) {
    for(int bin = 0; bin < m_nbins; bin++){
      // need to transpose
      std::vector<float> tmp_effMC_oneBin; // shape: {num_jet} = trfinf.njets
      for (unsigned int jet_index=0; jet_index<trfinf.njets; jet_index++){
        tmp_effMC_oneBin.push_back(tmp_effMC_allBins[jet_index][bin]);
      }
      trfinf.effMC_allBins[bin] = tmp_effMC_oneBin;
    }
  } // m_continuous
  else{
    for (unsigned int jet_index=0; jet_index<trfinf.njets; jet_index++){
     float tmp_effMC = std::accumulate(tmp_effMC_allBins[jet_index].begin()+m_OP_index_for_GNN, tmp_effMC_allBins[jet_index].end(), 0.0);
     trfinf.effMC_allBins[0].push_back(1-tmp_effMC);
     trfinf.effMC_allBins[1].push_back(tmp_effMC);
    }
 } // !m_continuous
         
  return StatusCode::SUCCESS;
}

getAllEffSF()

StatusCode BTaggingTruthTaggingTool::getAllEffSF ( TRFinfo & trfinf, int = 0 )

private

getDirectTaggedJets()

StatusCode BTaggingTruthTaggingTool::getDirectTaggedJets ( TRFinfo & trfinf, std::vector< bool > & is_tagged )

private

Definition at line 994 of file BTaggingTruthTaggingTool.cxx.

                                                                                                  {
  is_tagged.clear();
  std::vector<int> appo;
  auto is_jettag = false;
  for(const auto &jet : trfinf.jets) {
    ATH_MSG_DEBUG("pt " << jet.vars.jetPt << "   eta " << jet.vars.jetEta << "   wei " << jet.vars.jetTagWeight);
    is_jettag = static_cast<bool>(m_selTool->accept(jet.vars.jetPt, jet.vars.jetEta, jet.vars.jetTagWeight));
  
    ATH_MSG_DEBUG("is tagged? " << is_jettag);
    if(is_jettag) is_tagged.push_back(1);
    else is_tagged.push_back(0);
  }
 
  return StatusCode::SUCCESS;
}

getEvtSF()

float BTaggingTruthTaggingTool::getEvtSF ( TRFinfo & trfinf, std::vector< int > & quantiles )

private

Definition at line 1011 of file BTaggingTruthTaggingTool.cxx.

                                                                                  {
 
  float SF = 1.;
 
  if (m_ignoreSF) 
    return SF;
 
  for(unsigned int i =0; i< trfinf.njets; i++) {
    float jetSF = 1;
 
    if(!m_continuous){ //FixedCut
 
      bool is_btagged = quantiles.at(i);
      auto code = (is_btagged) ? m_effTool->getScaleFactor(trfinf.jets.at(i).flav, trfinf.jets.at(i).vars, jetSF) : m_effTool->getInefficiencyScaleFactor(trfinf.jets.at(i).flav, trfinf.jets.at(i).vars, jetSF);
     
      if(!(code==CorrectionCode::Ok || code==CorrectionCode::OutOfValidityRange)){
        ATH_MSG_ERROR("BTaggingEfficiencyTool::getScaleFactor returned CorrectionCode::Error");
        return -99.;
      }
    }
    else{ //continuous & continuous2D      
      int bin = quantiles.at(i);
      //set new tagweight bin according to the final decision
      //the quantile convention for continuous is: bin+1!  
      trfinf.jets.at(i).vars.jetTagWeight = (m_continuous2D) ? bin+0.5 : (m_cuts[bin-1].bcut_low + m_cuts[bin-1].bcut_hig)/2.;
      
      auto code = m_effTool->getScaleFactor(trfinf.jets.at(i).flav, trfinf.jets.at(i).vars, jetSF);
      if(!(code==CorrectionCode::Ok || code==CorrectionCode::OutOfValidityRange)){
        ATH_MSG_ERROR("BTaggingEfficiencyTool::getScaleFactor returned CorrectionCode::Error");
        return -99;
      }
      ATH_MSG_DEBUG("BIN " <<bin <<"SF: pt " <<trfinf.jets.at(i).vars.jetPt <<" " <<trfinf.jets.at(i).vars.jetEta <<" " <<trfinf.jets.at(i).vars.jetTagWeight <<" jetSF " <<jetSF);
    }
    SF*=jetSF;
  } //loop over jets
  
  ATH_MSG_DEBUG(" FINAL SF : " <<SF);
  return SF;
}

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
   }

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
   }

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

getQuantiles()

StatusCode BTaggingTruthTaggingTool::getQuantiles ( TRFinfo & trfinf, std::vector< std::vector< int > > & trf_bin_ex, std::vector< std::vector< int > > & trf_bin_in )

private

Definition at line 859 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                               {
  trf_bin_ex.resize(trfinf.tbins_ex.size());
  for(unsigned int i =0; i<trfinf.tbins_ex.size(); i++)
    trf_bin_ex.at(i).resize(trfinf.tbins_ex.at(i).size());
 
  trf_bin_in.resize(trfinf.tbins_in.size());
  for(unsigned int i =0; i<trfinf.tbins_in.size(); i++)
    trf_bin_in.at(i).resize(trfinf.tbins_in.at(i).size());
  // increasing the value by 1 to match conventions in selectionTool (not continuous2D)
  for(unsigned int i =0; i<trfinf.tbins_ex.size(); i++)
    for(unsigned int j=0; j<trfinf.tbins_ex.at(i).size(); j++)
      trf_bin_ex.at(i).at(j)= (m_continuous2D || !m_continuous) ? trfinf.tbins_ex.at(i).at(j) : trfinf.tbins_ex.at(i).at(j) +1;
 
  for(unsigned int i =0; i<trfinf.tbins_in.size(); i++)
    for(unsigned int j=0; j<trfinf.tbins_in.at(i).size(); j++)
      trf_bin_in.at(i).at(j) = (m_continuous2D || !m_continuous) ? trfinf.tbins_in.at(i).at(j) : trfinf.tbins_in.at(i).at(j) +1;
 
  return StatusCode::SUCCESS;
}

getTagBinsConfProb()

float BTaggingTruthTaggingTool::getTagBinsConfProb ( TRFinfo & trfinf, std::vector< int > & tagws )

private

Definition at line 973 of file BTaggingTruthTaggingTool.cxx.

                                                                                       {
  float prob = 1.;
  for(unsigned int j=0; j<tagws.size(); j++) {
    
    float sum_tag = 0.;
    //calculate sum of all tagged bins
    for (auto bin : m_OperatingBins)
      sum_tag += trfinf.effMC_allBins[bin][j]; 
      
    if(std::count(m_OperatingBins.begin(), m_OperatingBins.end(), tagws.at(j) ) ) { // tagged
      prob *= (trfinf.effMC_allBins[tagws.at(j)][j]) / sum_tag;
      ATH_MSG_DEBUG("prob " << prob);
    }
    else { // untagged
      prob *= (1 - trfinf.effMC_allBins[tagws.at(j)][j]) / (1 - sum_tag);
      ATH_MSG_DEBUG("prob " << prob);
    }
  }
  return prob;
}

getTagPermutation()

StatusCode BTaggingTruthTaggingTool::getTagPermutation ( TRFinfo & trfinf, std::vector< std::vector< bool > > & trf_chosen_perm_ex, std::vector< std::vector< bool > > & trf_chosen_perm_in )

private

Definition at line 767 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                                                       {
  trf_chosen_perm_ex.resize(m_nbtag+1);
  trf_chosen_perm_in.resize(m_nbtag+1);
  trf_chosen_perm_ex = trfinf.perm_ex;
  trf_chosen_perm_in = trfinf.perm_in;
  std::string print_perm = "Permutation: ";
  for(const auto& perm: trfinf.perm_ex){
    for(auto is: perm) {
      if(is) print_perm+=std::to_string(1);
      else print_perm+=std::to_string(0);
      print_perm+="  ";
    }
  }
  ATH_MSG_DEBUG(print_perm);
  return StatusCode::SUCCESS;
}

getTRFweight()

StatusCode BTaggingTruthTaggingTool::getTRFweight ( TRFinfo & trfinf, unsigned int nbtag, bool isInclusive )

private

Definition at line 687 of file BTaggingTruthTaggingTool.cxx.

                                                                                                     {
 
  unsigned int njets = trfinf.njets;
  // Consider permutations of njet jets with up to limit b-tags
  unsigned int limit = (njets > 7) ? 8 : njets+1;
 
  // Permutations: njets, ntags, permutations
  auto& perm = trfinf.perms[njets];
  if (perm.empty()) {   // if I don't have already saved the possible permutations for njet
    perm.resize (limit);
    for(unsigned int i=0;i<limit;i++)
      trfinf.perms[njets].at(i) = generatePermutations(njets,i);
  }
  trfinf.permsWeight.clear(), trfinf.permsWeight.resize(limit); // trfinf.permsWeight.at(i).at(j): TRF weight of the j-th perm with i b-tags
  trfinf.permsSumWeight.clear(), trfinf.permsSumWeight.resize(limit); // trfinf.permsSumWeight.at(i).at(j): partial sum of  TRF weight of the permutations with i b-tags up to j (0,1,..,j-th) perm. Used in the choice of the selected permutation
 
  // compute TRF weight
  unsigned int max = nbtag+1; // from 0 to nbtag b-tags --> nbtag+1 positions
  trfinf.trfw_ex.clear(), trfinf.trfw_in.clear();
  trfinf.trfw_ex.resize(max), trfinf.trfw_in.resize(max);
 
  //clear and resize elements of trfinf
  trfinf.perm_ex.clear(), trfinf.perm_in.clear(); // vector<vector<bool>> --> for each number of tags the chosen permutation
  trfinf.perm_ex.resize(max),  trfinf.perm_in.resize(max);
  trfinf.permprob_ex.clear(), trfinf.permprob_in.clear(); // probability of the perm in trfinf.perm_ex/in
  trfinf.permprob_ex.resize(max),  trfinf.permprob_in.resize(max);
 
  if(isInclusive) {
    for(unsigned int i=0; i<limit; i++) { // note: I consider maximum limit tags. It's an approximation
      std::vector<float> weights;
      float sum = 0.;
      float w   = 0.; //weight
      trfinf.permsWeight.at(i).clear();
      trfinf.permsSumWeight.at(i).clear();
      trfinf.permsWeight.at(i).resize(trfinf.perms[njets].at(i).size());
      trfinf.permsSumWeight.at(i).resize(trfinf.perms[njets].at(i).size());
 
      // loop on all the permutations with i tags
      for(unsigned int p=0; p<trfinf.perms[njets].at(i).size(); p++) {
 
        w = trfWeight(trfinf,trfinf.perms[njets].at(i).at(p));
        sum+=w;
        trfinf.permsWeight.at(i).at(p) = w;
        trfinf.permsSumWeight.at(i).at(p) = sum;
 
          ATH_MSG_DEBUG("nbtag = " << i << "  wei = " << w << "  sum = " << sum);
      }
      if(i<limit && i<max) {
      // note: I need to already have the exclusive weights filled to compite the inclusive
        trfinf.trfw_ex.at(i) = sum; // sum of TRF weights for all perm with i b-tags
        if(i == 0) trfinf.trfw_in.at(0) = 1.;
        else trfinf.trfw_in.at(i) = trfinf.trfw_in.at(i-1) - trfinf.trfw_ex.at(i-1); // P(>=4) = P(>=3) - P(==3)
        ATH_MSG_DEBUG("i = " << i << "  sum = " << sum << "  TRF in " << trfinf.trfw_in.at(i) << "  ex = " << trfinf.trfw_ex.at(i));
      }
    }
    ATH_MSG_DEBUG("before return, nbtag = " << nbtag << "  size de trfinf.trfw_in = " << trfinf.trfw_in.size());
    return StatusCode::SUCCESS;
  }
  else { // exclusive case, only one calculation needed
    std::vector<float> weights;
    float sum = 0., w = 0.;
    size_t size = trfinf.perms[njets].at(nbtag).size();
    trfinf.permsWeight.at(nbtag).clear();
    trfinf.permsSumWeight.at(nbtag).clear();
    trfinf.permsWeight.at(nbtag).resize(size);
    trfinf.permsSumWeight.at(nbtag).resize(size);
    // loop on all the permutations with i tags
    for(unsigned int p=0; p<trfinf.perms[njets].at(nbtag).size(); p++) {
      w = trfWeight(trfinf,trfinf.perms[njets].at(nbtag).at(p));
      sum+=w;
      trfinf.permsWeight.at(nbtag).at(p) = w;
      trfinf.permsSumWeight.at(nbtag).at(p) = sum;
    }
    trfinf.trfw_ex.at(nbtag) = sum;
    return StatusCode::SUCCESS;
  }
  return StatusCode::SUCCESS;
}

GetTruthTagWeights()

StatusCode BTaggingTruthTaggingTool::GetTruthTagWeights ( TRFinfo & trfinf, std::vector< float > & trf_weight_ex, std::vector< float > & trf_weight_in )

private

Definition at line 417 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                        {
 
  ANA_CHECK_SET_TYPE (StatusCode);
  //get MC efficiencies
  ANA_CHECK(getAllEffMC(trfinf));
  //compute truth tag weights
  ANA_CHECK(getTRFweight(trfinf,m_nbtag, true));
  // choice of the selected permutation
  ANA_CHECK(chooseAllTagPermutation(trfinf,m_nbtag));
 
  // choice of the tagged bins
  ANA_CHECK(chooseAllTagBins(trfinf));
 
  trf_weight_ex = trfinf.trfw_ex;
  trf_weight_in = trfinf.trfw_in;
  return StatusCode::SUCCESS;
}

initialize()

StatusCode BTaggingTruthTaggingTool::initialize ( void )

virtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 83 of file BTaggingTruthTaggingTool.cxx.

                                                {
 
  ANA_CHECK_SET_TYPE (StatusCode);
  m_initialised = true;
 
  ANA_CHECK(m_selTool.setProperty("MaxEta",  m_maxEta));
  ANA_CHECK(m_selTool.setProperty("MaxRangePt",  m_maxRangePt));
  ANA_CHECK(m_selTool.setProperty("MinPt",  m_minPt));
  ANA_CHECK(m_selTool.setProperty("TaggerName",  m_taggerName));
  ANA_CHECK(m_selTool.setProperty("OperatingPoint", m_OP));
  ANA_CHECK(m_selTool.setProperty("JetAuthor", m_jetAuthor));
  ANA_CHECK(m_selTool.setProperty("FlvTagCutDefinitionsFileName", m_SFFile));
  ANA_CHECK(m_selTool.initialize());
 
  ANA_CHECK(m_effTool.setProperty("MinPt",                           m_minPt));
  ANA_CHECK(m_effTool.setProperty("TaggerName",                      m_taggerName));
  ANA_CHECK(m_effTool.setProperty("OperatingPoint",                  m_OP));
  ANA_CHECK(m_effTool.setProperty("JetAuthor",                       m_jetAuthor));
  ANA_CHECK(m_effTool.setProperty("ScaleFactorFileName",             m_SFFile ));
  ANA_CHECK(m_effTool.setProperty("UseDevelopmentFile",              m_useDevFile ));
  ANA_CHECK(m_effTool.setProperty("EfficiencyFileName",              m_EffFile ));
  ANA_CHECK(m_effTool.setProperty("ScaleFactorBCalibration",         m_SFBName ));
  ANA_CHECK(m_effTool.setProperty("ScaleFactorCCalibration",         m_SFCName ));
  ANA_CHECK(m_effTool.setProperty("ScaleFactorTCalibration",         m_SFTName ));
  ANA_CHECK(m_effTool.setProperty("ScaleFactorLightCalibration",     m_SFLightName ));
  ANA_CHECK(m_effTool.setProperty("EigenvectorReductionB",           m_EVReductionB ));
  ANA_CHECK(m_effTool.setProperty("EigenvectorReductionC",           m_EVReductionC ));
  ANA_CHECK(m_effTool.setProperty("EigenvectorReductionLight",       m_EVReductionLight ));
  ANA_CHECK(m_effTool.setProperty("EfficiencyBCalibrations",         m_EffBName ));
  ANA_CHECK(m_effTool.setProperty("EfficiencyCCalibrations",         m_EffCName ));
  ANA_CHECK(m_effTool.setProperty("EfficiencyTCalibrations",         m_EffTName ));
  ANA_CHECK(m_effTool.setProperty("EfficiencyLightCalibrations",     m_EffLightName ));
  ANA_CHECK(m_effTool.setProperty("ExcludeFromEigenVectorTreatment", m_excludeFromEV ));
  ANA_CHECK(m_effTool.setProperty("SystematicsStrategy",             m_systStrategy ));
  ANA_CHECK(m_effTool.setProperty("ConeFlavourLabel",                m_coneFlavourLabel ));
  ANA_CHECK(m_effTool.setProperty("pathToONNX",                      m_pathToONNX ));
 
  ANA_CHECK(m_effTool.initialize());
 
  m_continuous = false;
  m_continuous2D = false;
  if(m_OP.value().find("Continuous") != std::string::npos){
    ATH_MSG_INFO("You are running in Continuous and you chose " << m_cutBenchmark <<" as benchmarks" );
    m_continuous = true;
    if(m_OP.value().find("Continuous2D") != std::string::npos)
      m_continuous2D = true;
    
    //tokenize the quantiles that will be used as tagged bin indices.
    std::vector<std::string> tag_benchmarks = split(m_cutBenchmark, ',');
    for (const auto & tag_bin : tag_benchmarks ){
      if(m_continuous2D)
    m_OperatingBins.push_back(std::atoi(tag_bin.c_str()));
      else //continuous
    m_OperatingBins.push_back(std::atoi(tag_bin.c_str())-1); //different convention
    }
  }
  else{ //FixedCut working points
    m_OperatingBins.clear();
    m_OperatingBins.push_back(1); //first bin: untagged, second bin: tagged.
}
  
  if(m_useQuantile && !m_continuous){
    ATH_MSG_ERROR("UseQuantile is available only in Continuous WP. Please consider switching the Operating Point.");
    return StatusCode::FAILURE;
  }
  
  if (m_pathToONNX != ""){
    // 60% = 4, 70% = 3, 77% = 2, 85% = 1, 100% = 0
    m_OP_index_for_GNN = find(m_availableOP_fixCut.begin(), m_availableOP_fixCut.end(), m_OP) - m_availableOP_fixCut.begin() + 1; // GNN predicts 5 bins    
  }
  
  m_eff_syst.clear();
  m_sys_name.clear();
  CP::SystematicSet def_set;
  m_eff_syst.push_back(def_set);
  m_sys_name.push_back("Nominal");
  
  if(m_useSys){
    std::vector<std::string> excludeEV_vector;
    if(m_excludeEV != "")
      excludeEV_vector = split(m_excludeEV, ';');
    CP::SystematicSet systs = m_effTool->affectingSystematics();
    for (const auto & syst : systs) {
      CP::SystematicSet myset;
      string s = syst.name();
      if(m_doOnlyUpVariations && s.find("__1down") !=string::npos) continue;
      if(std::any_of(excludeEV_vector.begin(), excludeEV_vector.end(), [&s](const std::string& str) { return str.find(s) != std::string::npos; })) continue;
      myset.insert(syst);
      if(m_excludeEV != "")
        ATH_MSG_INFO("Adding systematic " << syst.name() << "to the list ");
      else
        ATH_MSG_DEBUG("Adding systematic " << syst.name() << "to the list ");
      m_eff_syst.push_back(myset);
      m_sys_name.push_back(syst.name());
    }
  }
  
  ATH_MSG_INFO("end of systematics ");
 
  //set the cuts
  TString pathtofile =  PathResolverFindCalibFile(m_SFFile);
  m_inf = TFile::Open(pathtofile, "read");
 
  float min_cut_low = (m_taggerName == "MV2c10") ? -1 : -20;
  float max_cut_hig = (m_taggerName == "MV2c10") ? +1 : +20;
  
  if(m_OP == "Continuous"){
    std::vector<float> bin_edges;
    bin_edges.push_back(min_cut_low);
    for (const std::string& bin_name : m_availableOP_fixCut){
      TString cutname = m_taggerName+"/"+m_jetAuthor+"/"+bin_name+"/cutvalue";
      float cutval = ((TVector*) m_inf->Get(cutname))[0](0);
      bin_edges.push_back(cutval);
    }
    bin_edges.push_back(max_cut_hig); 
    for (unsigned int be = 0 ; be < bin_edges.size()-1 ; be++){
      //check if the bin is one of the bins used for btagging
      //NB. i+1 is to follow the convention 1-5!
      bool is_tagbin = std::count(m_OperatingBins.begin(), m_OperatingBins.end(), be);
      TagBin one_cut = TagBin(is_tagbin, bin_edges.at(be), bin_edges.at(be+1));
      m_cuts.push_back(one_cut);
    }
  } //== continuous
  else if (m_OP.value().find("Continuous2D")  != std::string::npos){
    ATH_MSG_INFO("TruthTagging initialization: Working with Continuous2D WP.");
    TString cutname = m_taggerName+"/"+m_jetAuthor+"/Continuous2D/cutvalue";
    TMatrixD* cuts2D = (TMatrixD*) m_inf->Get(cutname);
    ATH_MSG_DEBUG("Counting "  <<cuts2D->GetNrows() <<" bins ");
 
    for (int bin = 0; bin < cuts2D->GetNrows(); bin++){
      ATH_MSG_DEBUG("INITIALIZATION c-cuts : " <<(*cuts2D)(bin,0) <<" "
            <<(*cuts2D)(bin,1) <<" b-cuts : "
            <<(*cuts2D)(bin,2) <<" "
            <<(*cuts2D)(bin,3));
      
      //check if the bin is one of the bins used for btagging
      //NB. i follows the convention 0-4 of the continuous2D tagging
      bool is_tagbin = std::count(m_OperatingBins.begin(), m_OperatingBins.end(), bin);
 
      //set protection limits, so the final generated tagweight values have a meaning
      float c_tagcut_low = ((*cuts2D)(bin,0) < min_cut_low) ? min_cut_low : (*cuts2D)(bin,0);
      float c_tagcut_hig = ((*cuts2D)(bin,1) > max_cut_hig) ? max_cut_hig : (*cuts2D)(bin,1);
      float b_tagcut_low = ((*cuts2D)(bin,2) < min_cut_low) ? min_cut_low : (*cuts2D)(bin,2);
      float b_tagcut_hig = ((*cuts2D)(bin,3) > max_cut_hig) ? max_cut_hig : (*cuts2D)(bin,3);
 
      TagBin one_cut = TagBin(is_tagbin, b_tagcut_low, b_tagcut_hig, c_tagcut_low, c_tagcut_hig);
      m_cuts.push_back(one_cut);
    }
  }//continuous2D
  else{ //fixed-cut
    TString cutname = m_taggerName+"/"+m_jetAuthor+"/"+m_OP+"/cutvalue";
    float cutval = ((TVector*) m_inf->Get(cutname))[0](0);
 
    TagBin untag_bin = TagBin(false, min_cut_low, cutval); //bin 0
    TagBin tag_bin   = TagBin(true, cutval, max_cut_hig); //bin 1
 
    m_cuts.push_back(untag_bin);
    m_cuts.push_back(tag_bin);
  } //FixedCut
 
  if(m_continuous)
    for (const auto& c :  m_cuts){
      ATH_MSG_INFO("b-tag low: " <<c.bcut_low <<" b-tag hig: " <<c.bcut_hig  <<" c-tag low: " <<c.ccut_low <<" c-tag hig: " <<c.ccut_hig <<" Added to tag bins: " <<c.is_tagbin);
    }
  
  //total number of bins. helpful in loops
  m_nbins = m_cuts.size(); //FixedCut
  ATH_MSG_INFO("Total number of bins: " <<m_nbins);
 
 
  // "AllJets" is the default strategy
  if (m_taggingStrategy == "AllJets"){
    m_njetsTagStrategy = AllJets;
  } else if (m_taggingStrategy == "Leading2SignalJets"){
    m_njetsTagStrategy = Leading2SignalJets;
  } else if (m_taggingStrategy == "Leading3SignalJets"){
    m_njetsTagStrategy = Leading3SignalJets;
  } else {
    ATH_MSG_ERROR("BTaggingTruthTaggingTool::tagging strategy " << m_taggingStrategy << " is not implemented in the TruthTagging Tool");
    return StatusCode::FAILURE;    
  }
 
  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 BTaggingTruthTaggingTool::isAffectedBySystematic ( const CP::SystematicVariation & systematic ) const

virtual

Declare the interface that this class provides.

returns: whether this tool is affected by the given systematics

Implements CP::ISystematicsTool.

Definition at line 73 of file BTaggingTruthTaggingTool.cxx.

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

jetFlavourLabel()

int BTaggingTruthTaggingTool::jetFlavourLabel ( const xAOD::Jet & jet )

private

Definition at line 1067 of file BTaggingTruthTaggingTool.cxx.

                                                                {
  if (m_coneFlavourLabel)
    return ExclusiveConeHadronFlavourLabel(jet);
  else
    return GAFinalHadronFlavourLabel(jet);
}

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 BTaggingTruthTaggingTool::recommendedSystematics ( ) const

virtual

the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 79 of file BTaggingTruthTaggingTool.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();
  }

setEffMapIndex()

StatusCode BTaggingTruthTaggingTool::setEffMapIndex ( const std::string & flavour, unsigned int index )

virtual

Declare the interface that the class provides.

Implements IBTaggingTruthTaggingTool.

Definition at line 48 of file BTaggingTruthTaggingTool.cxx.

                                                                                               {
    ANA_CHECK(m_effTool->setMapIndex(flavour, index));
    return  StatusCode::SUCCESS;
}

setJets() [1/6]

StatusCode BTaggingTruthTaggingTool::setJets ( TRFinfo & trfinf, const std::vector< std::vector< float > > & node_feat, std::vector< float > & tagw )

private

Definition at line 323 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                 {
  ANA_CHECK_SET_TYPE (StatusCode);
  if(node_feat.size()!=tagw.size()){
    ATH_MSG_ERROR( "Vectors of node_feat (outer axis) and tagw should have same size" );
    return StatusCode::FAILURE;
  }
 
  std::vector<int> flav;
  std::vector<Analysis::CalibrationDataVariables>* vars = new std::vector<Analysis::CalibrationDataVariables>(0);
  for(unsigned int i =0; i<tagw.size(); i++){
    Analysis::CalibrationDataVariables vars_appo;
      
    // node_feat[i] is always {flav, pt, eta, ...}
    float pt  = node_feat.at(i)[1];
    float eta = node_feat.at(i)[2];
 
    ANA_CHECK(fillVariables(pt, eta, tagw.at(i), vars_appo));
    vars->push_back(vars_appo);    
    flav.push_back(node_feat.at(i)[0]);
  }
 
  ANA_CHECK(setJets(trfinf, flav, vars, node_feat));
  return StatusCode::SUCCESS;
}

setJets() [2/6]

StatusCode BTaggingTruthTaggingTool::setJets ( TRFinfo & trfinf, const xAOD::JetContainer & jets )

private

Definition at line 288 of file BTaggingTruthTaggingTool.cxx.

                                                                                        {
  ANA_CHECK_SET_TYPE (StatusCode);
  std::vector<int> flav;
  std::vector<Analysis::CalibrationDataVariables>* vars = new std::vector<Analysis::CalibrationDataVariables>(0);
  for(const auto jet : jets) {
    Analysis::CalibrationDataVariables vars_appo;
    ANA_CHECK(fillVariables(*jet, vars_appo));
    vars->push_back(vars_appo);
    flav.push_back(jetFlavourLabel(*jet));
  }
 
  ANA_CHECK(setJets(trfinf,flav, vars));
  delete vars;
  flav.clear();
  return StatusCode::SUCCESS;
}

setJets() [3/6]

StatusCode BTaggingTruthTaggingTool::setJets ( TRFinfo & trfinf, const xAOD::JetContainer & jets, const std::vector< std::vector< float > > & node_feat )

private

Definition at line 349 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                       {
  ANA_CHECK_SET_TYPE (StatusCode);
  std::vector<int> flav;
  std::vector<Analysis::CalibrationDataVariables>* vars = new std::vector<Analysis::CalibrationDataVariables>(0);
  for(const auto jet : jets) {
    Analysis::CalibrationDataVariables vars_appo;
    ANA_CHECK(fillVariables(*jet, vars_appo));
    vars->push_back(vars_appo);
    flav.push_back(jetFlavourLabel(*jet));
  }
 
  ANA_CHECK(setJets(trfinf, flav, vars, node_feat));
  flav.clear();
  return StatusCode::SUCCESS;
}

setJets() [4/6]

StatusCode BTaggingTruthTaggingTool::setJets ( TRFinfo & trfinf, std::vector< float > & pt, std::vector< float > & eta, std::vector< int > & flav, std::vector< float > & tagw )

private

Definition at line 269 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                                     {
  ANA_CHECK_SET_TYPE (StatusCode);
  if(pt.size()!=eta.size() || pt.size()!=flav.size() || pt.size()!=tagw.size()){
    ATH_MSG_ERROR( "Vectors of pt, eta, flav and tagw should have same size" );
    return StatusCode::FAILURE;
  }
 
  std::vector<Analysis::CalibrationDataVariables>* vars = new std::vector<Analysis::CalibrationDataVariables>(0);
  for(unsigned int i =0; i<pt.size(); i++){
    Analysis::CalibrationDataVariables vars_appo;
    ANA_CHECK(fillVariables(pt.at(i), eta.at(i), tagw.at(i), vars_appo));
    vars->push_back(vars_appo);
  }
 
  ANA_CHECK(setJets(trfinf,flav, vars));
  delete vars;
  return StatusCode::SUCCESS;
}

setJets() [5/6]

StatusCode BTaggingTruthTaggingTool::setJets ( TRFinfo & trfinf, std::vector< int > & flav, const std::vector< Analysis::CalibrationDataVariables > * vars, const std::vector< std::vector< float > > & node_feat )

private

Definition at line 368 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                                                                       {
  if(flav.size()!=vars->size()){
    ATH_MSG_ERROR( "Vector of CalibrationDataVariables and flavour should have same size" );
    return StatusCode::FAILURE;
  }
  trfinf.jets.clear();
 
  if (m_njetsTagStrategy == -1){
    trfinf.njets = vars->size();
  } else {
    trfinf.njets = std::min(static_cast<unsigned int>(m_njetsTagStrategy), static_cast<unsigned int>(vars->size()));
  }
 
  for(unsigned int i =0; i<trfinf.njets; i++){
    jetVariable jetVar_appo;
    jetVar_appo.flav=flav.at(i);
    jetVar_appo.vars=vars->at(i);
    trfinf.jets.push_back(jetVar_appo);
  }
  trfinf.node_feat = node_feat;
  return StatusCode::SUCCESS;
}

setJets() [6/6]

StatusCode BTaggingTruthTaggingTool::setJets ( TRFinfo & trfinf, std::vector< int > & flav, std::vector< Analysis::CalibrationDataVariables > * vars )

private

Definition at line 305 of file BTaggingTruthTaggingTool.cxx.

                                                                                                                                   {
  if(flav.size()!=vars->size()){
    ATH_MSG_ERROR( "Vector of CalibrationDataVariables and flavour should have same size" );
    return StatusCode::FAILURE;
  }
  trfinf.jets.clear();
  for(unsigned int i =0; i<vars->size(); i++){
    jetVariable jetVar_appo;
    jetVar_appo.flav=flav.at(i);
    jetVar_appo.vars=vars->at(i);
    trfinf.jets.push_back(jetVar_appo);
 
  }
  trfinf.njets=trfinf.jets.size();
  return StatusCode::SUCCESS;
}

setUseSystematics()

void BTaggingTruthTaggingTool::setUseSystematics

(

bool

useSystematics

)

Definition at line 53 of file BTaggingTruthTaggingTool.cxx.

                                                                   {
  ATH_MSG_DEBUG("setting the use of systematics to: " <<useSystematics);
  m_useSys = useSystematics;
  ATH_MSG_DEBUG(" m_useSys = " << m_useSys);
}

split()

std::vector< std::string > BTaggingTruthTaggingTool::split ( const std::string & str, char token )

private

Definition at line 1113 of file BTaggingTruthTaggingTool.cxx.

                                                                                     {
  std::vector<std::string> result;
  if (str.size() > 0) {
    std::string::size_type end;
    std::string tmp(str);
    do {
      end = tmp.find(token);
      std::string entry = trim(tmp.substr(0,end));
      if (entry.size() > 0) result.push_back(entry);
      if (end != std::string::npos) tmp = tmp.substr(end+1);
    } while (end != std::string::npos);
  }
  return result;
}

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.

trfWeight()

float BTaggingTruthTaggingTool::trfWeight ( TRFinfo & trfinf, const std::vector< bool > & tags )

private

Definition at line 663 of file BTaggingTruthTaggingTool.cxx.

                                                                                    {
 
  float weight = 1;
  for (unsigned int t=0; t<tags.size();t++) {
    float trf = 0.;
    
    //sum of the efficiencies in the tagged bins
    for (int bin : m_OperatingBins){
 
      trf += trfinf.effMC_allBins[bin][t];
      
    }
    if(trf>1.) {
      ATH_MSG_WARNING("Truth Tagging weight > 1. --> setting it to 1. check maps!");
      trf = 1.;
    }
    if(tags.at(t)) weight *= trf;
    else weight *= (1.-trf);
    ATH_MSG_DEBUG("weight " <<weight);
  } // end loop over jets
  return weight;
}

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_availableOP_fixCut

std::vector<std::string> BTaggingTruthTaggingTool::m_availableOP_fixCut = {"FixedCutBEff_85", "FixedCutBEff_77","FixedCutBEff_70","FixedCutBEff_60"}

private

Definition at line 181 of file BTaggingTruthTaggingTool.h.

{"FixedCutBEff_85", "FixedCutBEff_77","FixedCutBEff_70","FixedCutBEff_60"};

m_coneFlavourLabel

Gaudi::Property<bool> BTaggingTruthTaggingTool::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 251 of file BTaggingTruthTaggingTool.h.

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

m_continuous

bool BTaggingTruthTaggingTool::m_continuous {}

private

Definition at line 275 of file BTaggingTruthTaggingTool.h.

{};

m_continuous2D

bool BTaggingTruthTaggingTool::m_continuous2D {}

private

Definition at line 276 of file BTaggingTruthTaggingTool.h.

{};

m_cutBenchmark

Gaudi::Property<std::string> BTaggingTruthTaggingTool::m_cutBenchmark {this, "CutBenchmark", "1,2", "if you want to run in continuous you need to fix a benchmark - it does something only if running in Continuous OP"}

private

operating point when running in Continuous

Definition at line 243 of file BTaggingTruthTaggingTool.h.

{this, "CutBenchmark", "1,2", "if you want to run in continuous you need to fix a benchmark - it does something only if running in Continuous OP"};

m_cuts

std::vector<TagBin> BTaggingTruthTaggingTool::m_cuts

private

Definition at line 186 of file BTaggingTruthTaggingTool.h.

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_doDirectTag

Gaudi::Property<bool> BTaggingTruthTaggingTool::m_doDirectTag {this, "doDirectTagging", false , "If set to true it also computes and stores the direct tagging choice and the related SFs for each jet"}

private

possibility to compute the direct tagging SFs map directly from the TruthTaggingTool

Definition at line 256 of file BTaggingTruthTaggingTool.h.

{this, "doDirectTagging", false , "If set to true it also computes and stores the direct tagging choice and the related SFs for each jet"};

m_doOnlyUpVariations

Gaudi::Property<bool> BTaggingTruthTaggingTool::m_doOnlyUpVariations {this, "StoreOnlyUpVariations", false , "If set to true it processes only the __1up b-tagging variations. It speeds up the computation in case of symmetric variations."}

private

Definition at line 273 of file BTaggingTruthTaggingTool.h.

{this, "StoreOnlyUpVariations", false , "If set to true it processes only the __1up b-tagging variations. It speeds up the computation in case of symmetric variations."};

m_eff_syst

std::vector<CP::SystematicSet> BTaggingTruthTaggingTool::m_eff_syst

private

Definition at line 197 of file BTaggingTruthTaggingTool.h.

m_EffBName

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

private

semicolon-separated list of MC efficiency parametrisation names for b jets

Definition at line 229 of file BTaggingTruthTaggingTool.h.

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

m_EffCName

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

private

semicolon-separated list of MC efficiency parametrisation names for charm jets

Definition at line 231 of file BTaggingTruthTaggingTool.h.

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

m_EffFile

Gaudi::Property<std::string> BTaggingTruthTaggingTool::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 213 of file BTaggingTruthTaggingTool.h.

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

m_EffLightName

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

private

semicolon-separated list of MC efficiency parametrisation names for light-flavour jets

Definition at line 235 of file BTaggingTruthTaggingTool.h.

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

m_EffTName

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

private

semicolon-separated list of MC efficiency parametrisation names for tau jets

Definition at line 233 of file BTaggingTruthTaggingTool.h.

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

m_effTool

asg::AnaToolHandle<IBTaggingEfficiencyTool> BTaggingTruthTaggingTool::m_effTool

private

Definition at line 294 of file BTaggingTruthTaggingTool.h.

m_effTool_allBins

std::map<int, asg::AnaToolHandle<IBTaggingEfficiencyTool> > BTaggingTruthTaggingTool::m_effTool_allBins

private

Definition at line 291 of file BTaggingTruthTaggingTool.h.

m_EVReductionB

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

private

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

Definition at line 223 of file BTaggingTruthTaggingTool.h.

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

m_EVReductionC

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

private

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

Definition at line 225 of file BTaggingTruthTaggingTool.h.

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

m_EVReductionLight

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

private

specification of the eigenvector reduction strategy for light-flavour jets (if eigenvectors are used)

Definition at line 227 of file BTaggingTruthTaggingTool.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_excludeEV

Gaudi::Property<std::string> BTaggingTruthTaggingTool::m_excludeEV {this, "ExcludeSpecificEigens", "" , "(semicolon-separated) names of Eigens you want to exclude. in case of continuous some eigenvectors can be ignored to make the computation faster"}

private

in case of continuous WP you can choose to ignore some of the eigenvectors

Definition at line 254 of file BTaggingTruthTaggingTool.h.

{this, "ExcludeSpecificEigens", "" , "(semicolon-separated) names of Eigens you want to exclude. in case of continuous some eigenvectors can be ignored to make the computation faster"};

m_excludeFromEV

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

private

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

Definition at line 237 of file BTaggingTruthTaggingTool.h.

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

m_ignoreSF

Gaudi::Property<bool> BTaggingTruthTaggingTool::m_ignoreSF {this, "IgnoreScaleFactors", true, "ignore scale factors in computation of TRF weight"}

private

Definition at line 279 of file BTaggingTruthTaggingTool.h.

{this, "IgnoreScaleFactors", true, "ignore scale factors in computation of TRF weight"};

m_inf

TFile* BTaggingTruthTaggingTool::m_inf {}

private

Definition at line 183 of file BTaggingTruthTaggingTool.h.

{}; //file for reading the cut values from the CDI.

m_initialised

bool BTaggingTruthTaggingTool::m_initialised {}

private

Definition at line 188 of file BTaggingTruthTaggingTool.h.

{};

m_jetAuthor

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

private

jet collection name

Definition at line 245 of file BTaggingTruthTaggingTool.h.

{this, "JetAuthor", "AntiKt4EMTopoJets", "jet collection & JVF/JVT specification in CDI file"};

m_maxEta

Gaudi::Property<float> BTaggingTruthTaggingTool::m_maxEta {this, "MaxEta", 2.5, "Maximum jet eta cut"}

private

Definition at line 269 of file BTaggingTruthTaggingTool.h.

{this, "MaxEta", 2.5, "Maximum jet eta cut"};

m_maxRangePt

Gaudi::Property<float> BTaggingTruthTaggingTool::m_maxRangePt {this, "MaxRangePt", 1000000 , "Max pT range (in MeV)"}

private

Definition at line 270 of file BTaggingTruthTaggingTool.h.

{this, "MaxRangePt", 1000000 /*MeV*/, "Max pT range (in MeV)"};

m_minPt

Gaudi::Property<float> BTaggingTruthTaggingTool::m_minPt {this, "MinPt", 20000 , "Minimum jet pT cut (in MeV)"}

private

Definition at line 268 of file BTaggingTruthTaggingTool.h.

{this, "MinPt", 20000 /*MeV*/, "Minimum jet pT cut (in MeV)"};

m_nbins

int BTaggingTruthTaggingTool::m_nbins {}

private

Definition at line 287 of file BTaggingTruthTaggingTool.h.

{};

m_nbtag

Gaudi::Property<int> BTaggingTruthTaggingTool::m_nbtag {this, "MaxNtagged", 2, "what is the maximal possible number of tagged jets"}

private

Definition at line 285 of file BTaggingTruthTaggingTool.h.

{this, "MaxNtagged", 2, "what is the maximal possible number of tagged jets"};

m_njetsTagStrategy

NjetsTagStrategy BTaggingTruthTaggingTool::m_njetsTagStrategy {AllJets}

private

Definition at line 263 of file BTaggingTruthTaggingTool.h.

{AllJets};

m_OP

Gaudi::Property<std::string> BTaggingTruthTaggingTool::m_OP {this, "OperatingPoint", "FixedCutBEff_77", "operating point as specified in CDI file"}

private

operating point

Definition at line 241 of file BTaggingTruthTaggingTool.h.

{this, "OperatingPoint", "FixedCutBEff_77", "operating point as specified in CDI file"};

m_OP_index_for_GNN

unsigned int BTaggingTruthTaggingTool::m_OP_index_for_GNN {}

private

Definition at line 289 of file BTaggingTruthTaggingTool.h.

{};

m_OperatingBins

std::vector<int> BTaggingTruthTaggingTool::m_OperatingBins

private

Definition at line 288 of file BTaggingTruthTaggingTool.h.

m_pathToONNX

Gaudi::Property<std::string> BTaggingTruthTaggingTool::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 used

Definition at line 258 of file BTaggingTruthTaggingTool.h.

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

m_selTool

asg::AnaToolHandle<IBTaggingSelectionTool> BTaggingTruthTaggingTool::m_selTool

private

Definition at line 295 of file BTaggingTruthTaggingTool.h.

m_SFBName

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

private

name of the data/MC scale factor calibration for b jets

Definition at line 215 of file BTaggingTruthTaggingTool.h.

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

m_SFCName

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

private

name of the data/MC scale factor calibration for charm jets

Definition at line 217 of file BTaggingTruthTaggingTool.h.

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

m_SFFile

Gaudi::Property<std::string> BTaggingTruthTaggingTool::m_SFFile {this, "ScaleFactorFileName", "xAODBTaggingEfficiency/13TeV/2016-20_7-13TeV-MC15-CDI-July12_v1.root", "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 211 of file BTaggingTruthTaggingTool.h.

{this, "ScaleFactorFileName", "xAODBTaggingEfficiency/13TeV/2016-20_7-13TeV-MC15-CDI-July12_v1.root", "name of the official scale factor calibration CDI file (uses PathResolver)"};

m_SFLightName

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

private

name of the data/MC scale factor calibration for light-flavour jets

Definition at line 221 of file BTaggingTruthTaggingTool.h.

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

m_SFTName

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

private

name of the data/MC scale factor calibration for tau jets

Definition at line 219 of file BTaggingTruthTaggingTool.h.

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

m_sys_name

std::vector<std::string> BTaggingTruthTaggingTool::m_sys_name

private

Definition at line 198 of file BTaggingTruthTaggingTool.h.

m_systStrategy

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

private

systematics model to be used (current choices are "SFEigen" and "Envelope")

Definition at line 247 of file BTaggingTruthTaggingTool.h.

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

m_taggerName

Gaudi::Property<std::string> BTaggingTruthTaggingTool::m_taggerName {this, "TaggerName", "MV2c10", "tagging algorithm name as specified in CDI file"}

private

tagger name

Definition at line 239 of file BTaggingTruthTaggingTool.h.

{this, "TaggerName", "MV2c10", "tagging algorithm name as specified in CDI file"};

m_taggingStrategy

Gaudi::Property<std::string> BTaggingTruthTaggingTool::m_taggingStrategy {this, "TaggingStrategy", "AllJets", "tagging strategy in the Analysis (eg. 'leading2SignalJets' in boosted VHbb). Required to do TT with GNN"}

private

tagging strategy is required to do TT with GNN, when we don't want to truth tag all the jets (eg. 'leading2SignalJets')

Definition at line 260 of file BTaggingTruthTaggingTool.h.

{this, "TaggingStrategy", "AllJets", "tagging strategy in the Analysis (eg. 'leading2SignalJets' in boosted VHbb). Required to do TT with GNN"};

m_useDevFile

Gaudi::Property<bool> BTaggingTruthTaggingTool::m_useDevFile {this, "UseDevelopmentFile", false, "specify whether or not to use the (PathResolver) area for temporary scale factor calibration CDI files"}

private

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

Definition at line 249 of file BTaggingTruthTaggingTool.h.

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

m_usePerm

Gaudi::Property<bool> BTaggingTruthTaggingTool::m_usePerm {this, "UsePermutations", true, "if the chosen permutation is used, a reweighting is applied to the TRF weight for systematics"}

private

Definition at line 280 of file BTaggingTruthTaggingTool.h.

{this, "UsePermutations", true, "if the chosen permutation is used, a reweighting is applied to the TRF weight for systematics"};

m_useQuantile

Gaudi::Property<bool> BTaggingTruthTaggingTool::m_useQuantile {this, "UseQuantile", true, "if the chosen quantile is used, a reweighting is applied to the TRF weight for systematics"}

private

Definition at line 281 of file BTaggingTruthTaggingTool.h.

{this, "UseQuantile", true, "if the chosen quantile is used, a reweighting is applied to the TRF weight for systematics"};

m_useSys

Gaudi::Property<bool> BTaggingTruthTaggingTool::m_useSys {this, "UseSystematics", false, "will the results contain all systematic variations, or just the nominal"}

private

Definition at line 282 of file BTaggingTruthTaggingTool.h.

{this, "UseSystematics", false, "will the results contain all systematic variations, or just the nominal"};

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:

• BTaggingTruthTaggingTool.h
• BTaggingTruthTaggingTool.cxx