ATLAS Offline Software
Loading...
Searching...
No Matches
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  TagBin
 Create a proper constructor for Athena. More...
struct  jetVariable
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, const 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 376 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ NjetsTagStrategy

will be set according to m_taggingStrategy

Enumerator
AllJets 
Leading2SignalJets 
Leading3SignalJets 

Definition at line 262 of file BTaggingTruthTaggingTool.h.

Constructor & Destructor Documentation

◆ BTaggingTruthTaggingTool()

BTaggingTruthTaggingTool::BTaggingTruthTaggingTool ( const std::string & name)

Create a constructor for standalone usage.

Definition at line 39 of file BTaggingTruthTaggingTool.cxx.

40 : asg::AsgTool( name ),
41 m_effTool ("BTaggingEfficiencyTool/effTool", this),
42 m_selTool ("BTaggingSelectionTool/selTool", this)
43 {
44
45 m_initialised = false;
46}
asg::AnaToolHandle< IBTaggingSelectionTool > m_selTool
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_effTool

◆ ~BTaggingTruthTaggingTool()

BTaggingTruthTaggingTool::~BTaggingTruthTaggingTool ( )
virtual

Definition at line 1058 of file BTaggingTruthTaggingTool.cxx.

1058 {
1059
1060 // delete trfinf.jets;
1061
1062}

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.

59 {
60 return m_effTool->affectingSystematics();
61}

◆ 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.

64{
65 for (auto syst : systConfig) {
66 CP::SystematicSet myset;
67 ATH_MSG_WARNING("applySystematicVariation was called for " << syst.name() << " but BTaggingTruthTaggingTool does not apply Systematic Variations");
68 //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.
69 }
70 return StatusCode::SUCCESS;
71}
#define ATH_MSG_WARNING(x,...)

◆ CalculateResults() [1/3]

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

Implements IBTaggingTruthTaggingTool.

Definition at line 526 of file BTaggingTruthTaggingTool.cxx.

526 {
527
528 ANA_CHECK_SET_TYPE (StatusCode);
529
530 TRFinfo trfinf;
531
532 ANA_CHECK(setJets(trfinf,jets));
533
534 return CalculateResults(trfinf,results,rand_seed);
535}
#define ANA_CHECK(EXP)
check whether the given expression was successful
#define ANA_CHECK_SET_TYPE(TYPE)
set the type for ANA_CHECK to report failures
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)

◆ 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 515 of file BTaggingTruthTaggingTool.cxx.

515 {
516
517 ANA_CHECK_SET_TYPE (StatusCode);
518
519 TRFinfo trfinf;
520
521 ANA_CHECK(setJets(trfinf,pt, eta, flav, tagw));
522
523 return CalculateResults(trfinf,results,rand_seed);
524}
Scalar eta() const
pseudorapidity method

◆ CalculateResults() [3/3]

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

Definition at line 434 of file BTaggingTruthTaggingTool.cxx.

434 {
435 ANA_CHECK_SET_TYPE (StatusCode);
436 results.clear();
437
438 if(rand_seed!=-1){
439 trfinf.rand.SetSeed(rand_seed);
440 }
441
442 std::vector<float> trf_weight_ex, trf_weight_in;
443
444 trf_weight_ex.clear();
445 trf_weight_in.clear();
446
447 ANA_CHECK(GetTruthTagWeights(trfinf, trf_weight_ex, trf_weight_in));
448
449 ANA_CHECK(getTagPermutation(trfinf,results.trf_chosen_perm_ex,results.trf_chosen_perm_in));
450
451 //modify quantiles according to the different conventions
452 ANA_CHECK(getQuantiles(trfinf,results.trf_bin_ex, results.trf_bin_in));
453
454 //new tagger scores
455 ANA_CHECK(generateRandomTaggerScores(results.trf_bin_ex, results.trf_bin_score_ex, results.trf_ctag_bin_score_ex));
456 ANA_CHECK(generateRandomTaggerScores(results.trf_bin_in, results.trf_bin_score_in, results.trf_ctag_bin_score_in));
457
458 //direct tag
459 if(m_doDirectTag)
460 ANA_CHECK( getDirectTaggedJets(trfinf, results.is_tagged) );
461
462 //handle systematics
463 unsigned int n_systs = (m_useSys) ? m_eff_syst.size() : 1;
464 results.syst_names.clear();
465
466 for(unsigned int sys = 0; sys < n_systs; ++sys){
467 if(sys!=0 && m_useSys) {
468 ANA_CHECK_THROW( m_effTool->applySystematicVariation(m_eff_syst[sys]) );
469 }
470
471 results.syst_names.push_back(m_sys_name.at(sys));
472
473 results.map_trf_weight_ex[m_sys_name.at(sys)].resize(trfinf.trfw_ex.size());
474 results.map_trf_weight_in[m_sys_name.at(sys)].resize(trfinf.trfw_in.size());
475
476 results.map_SF_ex[m_sys_name.at(sys)].resize(trfinf.trfw_ex.size());
477 results.map_SF_in[m_sys_name.at(sys)].resize(trfinf.trfw_in.size());
478
479 //direct tagging
480 if(m_doDirectTag){
481 std::vector<int> is_tagged;
482 for(auto t : results.is_tagged){
483 is_tagged.push_back(static_cast<int>(t));
484 }
485 results.map_SF[m_sys_name.at(sys)]=getEvtSF(trfinf,is_tagged);
486 }
487
488 //go over the ntag combinations.
489 //ntj = number of tagged jets
490 for(unsigned int ntj=0; ntj< trfinf.trfw_ex.size(); ntj++){
491 if(ntj > trfinf.njets) {
492 results.map_SF_ex[m_sys_name.at(sys)].at(ntj) = 1.;
493 results.map_SF_in[m_sys_name.at(sys)].at(ntj) = 1.;
494 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.");
495 }
496 else{
497 results.map_SF_ex[m_sys_name.at(sys)].at(ntj) = getEvtSF(trfinf,results.trf_bin_ex.at(ntj));
498 results.map_SF_in[m_sys_name.at(sys)].at(ntj) = getEvtSF(trfinf,results.trf_bin_in.at(ntj));
499 }
500
501 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);
502 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);
503 }
504 }
505
506 if(m_useSys) { // reset syst to nominal
507 CP::SystematicSet defaultSet;
508 ANA_CHECK_THROW( m_effTool->applySystematicVariation(defaultSet) );
509 }
510
511 return StatusCode::SUCCESS;
512
513}
#define ATH_MSG_DEBUG(x,...)
#define ANA_CHECK_THROW(EXP)
check whether the given expression was successful, throwing an exception on failure
std::vector< std::string > m_sys_name
float getEvtSF(TRFinfo &trfinf, std::vector< int > &quantiles)
StatusCode getQuantiles(TRFinfo &trfinf, std::vector< std::vector< int > > &trf_bin_ex, std::vector< std::vector< int > > &trf_bin_in)
std::vector< CP::SystematicSet > m_eff_syst
Gaudi::Property< bool > m_doDirectTag
possibility to compute the direct tagging SFs map directly from the TruthTaggingTool
StatusCode getDirectTaggedJets(TRFinfo &trfinf, std::vector< bool > &is_tagged)
Gaudi::Property< bool > m_useSys
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 generateRandomTaggerScores(std::vector< std::vector< int > > &quantiles, std::vector< std::vector< float > > &btag_scores, std::vector< std::vector< float > > &ctag_scores)

◆ 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 538 of file BTaggingTruthTaggingTool.cxx.

538 {
539
540 ANA_CHECK_SET_TYPE (StatusCode);
541
542 TRFinfo trfinf;
543
544 ANA_CHECK(setJets(trfinf, node_feat, tagw));
545
546 return CalculateResults(trfinf, results, rand_seed);
547}

◆ 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 550 of file BTaggingTruthTaggingTool.cxx.

550 {
551
552 ANA_CHECK_SET_TYPE (StatusCode);
553
554 TRFinfo trfinf;
555
556 ANA_CHECK(setJets(trfinf, jets, node_feat));
557
558 return CalculateResults(trfinf, results, rand_seed);
559}

◆ check_syst_range()

StatusCode BTaggingTruthTaggingTool::check_syst_range ( unsigned int sys)
private

Definition at line 1050 of file BTaggingTruthTaggingTool.cxx.

1050 {
1051 if(sys < m_eff_syst.size()) return StatusCode::SUCCESS;
1052 ATH_MSG_ERROR(sys << " Out of range of available systematics");
1053 return StatusCode::FAILURE;
1054}
#define ATH_MSG_ERROR(x,...)

◆ chooseAllTagBins()

StatusCode BTaggingTruthTaggingTool::chooseAllTagBins ( TRFinfo & trfinf)
private

Definition at line 877 of file BTaggingTruthTaggingTool.cxx.

877 {
878 ANA_CHECK_SET_TYPE (StatusCode);
879 trfinf.tbins_ex.clear();
880 trfinf.tbins_in.clear();
881 trfinf.tbins_ex.resize( trfinf.trfw_ex.size());
882 trfinf.tbins_in.resize( trfinf.trfw_in.size());
883
884 trfinf.binsprob_ex.clear();
885 trfinf.binsprob_in.clear();
886 trfinf.binsprob_ex.resize( trfinf.trfw_ex.size());
887 trfinf.binsprob_in.resize( trfinf.trfw_in.size());
888
889 if(trfinf.perm_ex.size() != trfinf.perm_in.size()) ATH_MSG_WARNING("Different sizes in exclusive and inclusive permutation choices");
890
891 for(unsigned int nb=0; nb<trfinf.perm_ex.size(); nb++) {
892 ANA_CHECK(chooseTagBins_cum(trfinf,trfinf.perm_ex.at(nb), false, nb));
893 ANA_CHECK(chooseTagBins_cum(trfinf,trfinf.perm_in.at(nb), true, nb));
894 }
895 return StatusCode::SUCCESS;
896}
StatusCode chooseTagBins_cum(TRFinfo &trfinf, std::vector< bool > &tagconf, bool isIncl, unsigned int nbtag)

◆ chooseAllTagPermutation()

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

Definition at line 782 of file BTaggingTruthTaggingTool.cxx.

782 {
783
784 ANA_CHECK_SET_TYPE (StatusCode);
785
786 if(!m_usePerm){
787 return StatusCode::FAILURE;
788 }
789
790 unsigned int njets = trfinf.njets;
791 unsigned int limit = (njets > 7) ? 8 : njets+1;
792 unsigned int max = (njets < nbtag+1) ? limit : nbtag+1;
793
794 trfinf.perm_ex.clear(), trfinf.perm_ex.resize(nbtag+1);
795 trfinf.perm_in.clear(), trfinf.perm_in.resize(nbtag+1);
796
797 trfinf.permprob_ex.clear(), trfinf.permprob_ex.resize(nbtag+1);
798 trfinf.permprob_in.clear(), trfinf.permprob_in.resize(nbtag+1);
799
800 for(unsigned int i=0; i<max; i++) { // need +1 as 0 is included
801 ANA_CHECK(chooseTagPermutation(trfinf,i,false));
802 ANA_CHECK(chooseTagPermutation(trfinf,i,true));
803 }
804
805 return StatusCode::SUCCESS;
806}
#define max(a, b)
Definition cfImp.cxx:41
Gaudi::Property< bool > m_usePerm
StatusCode chooseTagPermutation(TRFinfo &trfinf, unsigned int nbtag, bool isIncl)

◆ chooseTagBins_cum()

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

Definition at line 899 of file BTaggingTruthTaggingTool.cxx.

899 {
900 std::vector<int> btagops;
901
902 ATH_MSG_DEBUG("chooseTagBins_cum ntag: " <<nbtag);
903
904 std::vector<float> incl;
905 std::vector<float> untagged_bins;
906 float prob = 1.;
907
908 //define the untagged bins
909 for (int bin=0; bin<m_nbins; bin++) {
910 if (std::count(m_OperatingBins.begin(), m_OperatingBins.end(), bin)) continue;
911 untagged_bins.push_back(bin);
912 }
913
914 //How to calculate Probabilities:
915 //sum: [---- P(bin 0) -----][-- P(bin 1) ---][- P(bin 2) -]
916 //random X up to sum of the bins. pick one prob based on the efficiency
917 for(unsigned int j=0; j<tagconf.size(); j++) {
918
919 ATH_MSG_DEBUG("tagconf.at(tc) " <<tagconf.at(j));
920
921 if(tagconf.at(j)) { // tagged jet
922 float sum=0.;
923 incl.clear();
924 for (int tagged_bin : m_OperatingBins){
925 sum += trfinf.effMC_allBins[tagged_bin][j];
926 incl.push_back(sum);
927 }
928
929 float theX = trfinf.rand.Uniform(sum);
930 auto tag_index = std::lower_bound(incl.begin(), incl.end(), theX) - incl.begin();
931 float tbin_choice = m_OperatingBins[tag_index];
932 btagops.push_back(tbin_choice);
933 prob *= (trfinf.effMC_allBins[tbin_choice][j]);
934 ATH_MSG_DEBUG("it " <<tag_index <<" theX " <<theX <<" effMC " <<trfinf.effMC_allBins[tbin_choice][j] <<" prob* " <<prob);
935 } //tagged
936 else { // untagged jet
937 float untag_sum = 0. ;
938 incl.clear();
939 //sum over untagged bins
940 for(auto bin : untagged_bins){
941 untag_sum += trfinf.effMC_allBins[bin][j];
942 incl.push_back(untag_sum);
943 }
944
945 float theX = trfinf.rand.Uniform(untag_sum);
946 auto untag_index = std::lower_bound(incl.begin(), incl.end(), theX) - incl.begin();
947 float utbin_choice = untagged_bins[untag_index];
948 btagops.push_back(utbin_choice);
949 prob *= 1 - trfinf.effMC_allBins[utbin_choice][j];
950 ATH_MSG_DEBUG(" unt_bin " <<untag_index <<" theX " <<theX<<" 1-effMC " <<1-trfinf.effMC_allBins[utbin_choice][j] <<" prob* " <<prob);
951 }
952 }
953
954 if(btagops.size() != tagconf.size()) {
955 ATH_MSG_ERROR("You should not be here -> wrong size of tag bins vector. btagops: " <<btagops.size() <<" tagconf: " <<tagconf.size());
956 return StatusCode::FAILURE;
957 }
958 if(isIncl) {
959 trfinf.tbins_in.at(nbtag) = btagops;
960 trfinf.binsprob_in.at(nbtag) = prob;
961 ATH_MSG_DEBUG("incl, nbtag " << nbtag << " prob " << prob);
962 }
963 else {
964 trfinf.tbins_ex.at(nbtag) = btagops;
965 trfinf.binsprob_ex.at(nbtag) = prob;
966 ATH_MSG_DEBUG("excl, nbtag " << nbtag << " prob " << prob);
967 }
968 return StatusCode::SUCCESS;
969}
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)

◆ chooseTagPermutation()

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

Definition at line 808 of file BTaggingTruthTaggingTool.cxx.

808 {
809 std::vector<float> incl;
810 std::vector<std::pair<unsigned int, unsigned int> > trackPerm;
811 float sum = 0;
812 if(isIncl) {
813 for(unsigned int itag=nbtag; itag < trfinf.permsWeight.size(); itag++) {
814 for(unsigned int ip = 0; ip < trfinf.permsWeight.at(itag).size(); ip++) {
815 sum += trfinf.permsWeight.at(itag).at(ip);
816 incl.push_back(sum);
817 trackPerm.push_back(std::make_pair(itag,ip));
818 }
819 }
820 }
821 else { // in exclusive case
822 sum = trfinf.permsSumWeight.at(nbtag).back();
823 incl = trfinf.permsSumWeight.at(nbtag);
824 for(unsigned int ip = 0; ip < trfinf.permsSumWeight.at(nbtag).size(); ip++) trackPerm.push_back(std::make_pair(nbtag,ip));
825 }
826 float theX = trfinf.rand.Uniform(sum);
827 for(unsigned int ip=0; ip < incl.size(); ip++) {
828 ATH_MSG_DEBUG("incl.at(ip): " << incl.at(ip) << " theX: " << theX);
829 if(incl.at(ip) >= theX) {
830 if(isIncl) {
831 trfinf.perm_in.at(nbtag) = trfinf.perms[trfinf.njets].at(trackPerm.at(ip).first).at(trackPerm.at(ip).second);
832 trfinf.permprob_in.at(nbtag) = trfinf.permsWeight.at(trackPerm.at(ip).first).at(trackPerm.at(ip).second) / trfinf.trfw_in.at(nbtag);
833 }
834 else {
835 trfinf.perm_ex.at(nbtag) = trfinf.perms[trfinf.njets].at(trackPerm.at(ip).first).at(trackPerm.at(ip).second);
836 trfinf.permprob_ex.at(nbtag) = trfinf.permsWeight.at(trackPerm.at(ip).first).at(trackPerm.at(ip).second) / trfinf.trfw_ex.at(nbtag);
837 }
838 return StatusCode::SUCCESS;
839 }
840 }
841 return StatusCode::SUCCESS;
842}
size_t size() const
Number of registered mappings.

◆ 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.

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ 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.

◆ 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.

◆ ExclusiveConeHadronFlavourLabel()

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

Definition at line 1089 of file BTaggingTruthTaggingTool.cxx.

1089 {
1090 // default label means "invalid"
1091 int label = -1;
1092 // We don't check the return value, as we would not be able to handle it gracefully anyway
1093 jet.getAttribute("HadronConeExclTruthLabelID",label);
1094 return label;
1095}
std::string label(const std::string &format, int i)
Definition label.h:19

◆ 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 407 of file BTaggingTruthTaggingTool.cxx.

407 {
408 x.jetPt = jetPt;
409 x.jetEta = jetEta;
410 x.jetTagWeight = jetTagWeight;
411 x.jetAuthor = m_jetAuthor;
412 return StatusCode::SUCCESS;
413}
#define x
Gaudi::Property< std::string > m_jetAuthor
jet collection name

◆ fillVariables() [2/2]

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

Definition at line 390 of file BTaggingTruthTaggingTool.cxx.

390 {
391 x.jetPt = jet.pt();
392 x.jetEta = jet.eta();
393 x.jetAuthor = m_jetAuthor;
394
396 if (!tagInfo) return StatusCode::FAILURE;
397
398 CorrectionCode code = m_selTool->getTaggerWeight(jet, x.jetTagWeight);
400 ATH_MSG_ERROR("BTaggingSelectionTool::getTaggerWeight returned CorrectionCode::Error");
401 return StatusCode::FAILURE;
402 }
403
404 return StatusCode::SUCCESS;
405}
@ OutOfValidityRange
Input object is out of validity range.
@ Ok
The correction was done successfully.
const BTagging * getBTagging(const SG::AuxElement &part)
Access the default xAOD::BTagging object associated to an object.
BTagging_v1 BTagging
Definition of the current "BTagging version".
Definition BTagging.h:17

◆ GAFinalHadronFlavourLabel()

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

Definition at line 1072 of file BTaggingTruthTaggingTool.cxx.

1072 {
1073
1074 const std::string labelB = "GhostBHadronsFinal";
1075 const std::string labelC = "GhostCHadronsFinal";
1076 const std::string labelTau = "GhostTausFinal";
1077
1078 std::vector<const IParticle*> ghostB;
1079 if (jet.getAssociatedObjects<IParticle>(labelB, ghostB) && ghostB.size() > 0) return 5;
1080 std::vector<const IParticle*> ghostC;
1081 if (jet.getAssociatedObjects<IParticle>(labelC, ghostC) && ghostC.size() > 0) return 4;
1082 std::vector<const IParticle*> ghostTau;
1083 if (jet.getAssociatedObjects<IParticle>(labelTau, ghostTau) && ghostTau.size() > 0) return 15;
1084
1085
1086 return 0;
1087}

◆ generatePermutations()

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

Definition at line 637 of file BTaggingTruthTaggingTool.cxx.

637 {
638 std::vector<std::vector<bool> > perm;
639 std::vector<std::vector<bool> > temp_perm;
640 if(tags==0){
641 std::vector<bool> tags(njets,false);
642 perm.push_back(tags);
643 }
644 else if(tags == njets) {
645 std::vector<bool> tags(njets,true);
646 perm.push_back(tags);
647 }
648 else {
649 for(int i=start; i<njets;i++){
650 temp_perm = generatePermutations(njets,tags-1,i+1);
651 for(unsigned int j=0; j<temp_perm.size(); j++){
652 temp_perm.at(j).at(i)=true;
653 perm.push_back(temp_perm.at(j));
654 }
655 }
656 }
657 return perm;
658}
std::vector< std::vector< bool > > generatePermutations(int njets, int tags, int start=0)
std::vector< std::string > tags
Definition hcg.cxx:107

◆ 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 1126 of file BTaggingTruthTaggingTool.cxx.

1126 {
1127
1128 TRandom3 random;
1129
1130 btag_scores.clear();
1131 btag_scores.resize(quantiles.size());
1132
1133 if(m_continuous2D){
1134 ctag_scores.clear();
1135 ctag_scores.resize(quantiles.size());
1136 }
1137
1138 for(unsigned int i=0; i <quantiles.size(); i++ ){
1139
1140 btag_scores.at(i).resize(quantiles.at(i).size());
1141 if(m_continuous2D)
1142 ctag_scores.at(i).resize(quantiles.at(i).size());
1143
1144 unsigned int njets = quantiles.at(i).size();
1145 for(unsigned int j=0; j < njets; j++ ){
1146
1147 int temp_quantile = (m_continuous2D) ? quantiles.at(i).at(j) : quantiles.at(i).at(j) -1;
1148
1149 float btag_low = m_cuts[temp_quantile].bcut_low;
1150 float btag_hig = m_cuts[temp_quantile].bcut_hig;
1151
1152 float ctag_low = m_cuts[temp_quantile].ccut_low;
1153 float ctag_hig = m_cuts[temp_quantile].ccut_hig;
1154
1155 btag_scores.at(i).at(j) = btag_low + random.Uniform()*(btag_hig - btag_low );
1156 if(m_continuous2D)
1157 ctag_scores.at(i).at(j) = ctag_low + random.Uniform()*(ctag_hig - ctag_low );
1158 }
1159 }
1160 return StatusCode::SUCCESS;
1161
1162}

◆ getAllEffMC()

StatusCode BTaggingTruthTaggingTool::getAllEffMC ( TRFinfo & trfinf)
private

Definition at line 561 of file BTaggingTruthTaggingTool.cxx.

561 {
562 if (trfinf.node_feat.size() == 0){
563 return getAllEffMCCDI(trfinf);
564 } else {
565 return getAllEffMCGNN(trfinf);
566 }
567}
StatusCode getAllEffMCGNN(TRFinfo &trfinf)
StatusCode getAllEffMCCDI(TRFinfo &trfinf)

◆ getAllEffMCCDI()

StatusCode BTaggingTruthTaggingTool::getAllEffMCCDI ( TRFinfo & trfinf)
private

Definition at line 605 of file BTaggingTruthTaggingTool.cxx.

605 {
606
607 float eff_all =1.;
608 for(int bin = 0; bin < m_nbins; bin++)
609 trfinf.effMC_allBins[bin].clear();
610
611 for(size_t jet=0; jet < trfinf.jets.size(); jet++){
612 for(int bin = 0; bin < m_nbins; bin++){ // loop on bins
613 eff_all=1.;
614
615 //set a dumb value of the truth tag weight to get the different efficiency maps for each bin. to be improved..
616 if (m_continuous2D)
617 trfinf.jets.at(jet).vars.jetTagWeight = bin+0.5;
618 else
619 trfinf.jets.at(jet).vars.jetTagWeight = (m_cuts[bin].bcut_low + m_cuts[bin].bcut_hig)/2.;
620
621 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);
622 //get the efficiency
623 CorrectionCode code = m_effTool->getMCEfficiency(trfinf.jets.at(jet).flav, trfinf.jets.at(jet).vars, eff_all);
625 ATH_MSG_ERROR("BTaggingEfficiencyTool::getMCEfficiency returned CorrectionCode::Error");
626 return StatusCode::FAILURE;
627 }
628
629 trfinf.effMC_allBins[bin].push_back(eff_all);
630 ATH_MSG_DEBUG("effMC_allBins: tag bin: " <<bin <<" tagw: " << trfinf.jets.at(jet).vars.jetTagWeight <<" eff: " <<eff_all);
631 } // end loop on bins
632 } // end loop on jets
633
634 return StatusCode::SUCCESS;
635}

◆ getAllEffMCGNN()

StatusCode BTaggingTruthTaggingTool::getAllEffMCGNN ( TRFinfo & trfinf)
private

Definition at line 570 of file BTaggingTruthTaggingTool.cxx.

570 {
571
572 for(int bin = 0; bin < m_nbins; bin++)
573 trfinf.effMC_allBins[bin].clear();
574
575 //extract efficiency
576 std::vector<std::vector<float>> tmp_effMC_allBins; // shape:{num_jets, num_wp}
577 CorrectionCode code = m_effTool->getMCEfficiencyONNX(trfinf.node_feat, tmp_effMC_allBins);
578
580 ATH_MSG_ERROR("BTaggingEfficiencyTool::getMCEfficiencyONNX returned CorrectionCode::Error");
581 return StatusCode::FAILURE;
582 }
583
584 if(m_continuous) {
585 for(int bin = 0; bin < m_nbins; bin++){
586 // need to transpose
587 std::vector<float> tmp_effMC_oneBin; // shape: {num_jet} = trfinf.njets
588 for (unsigned int jet_index=0; jet_index<trfinf.njets; jet_index++){
589 tmp_effMC_oneBin.push_back(tmp_effMC_allBins[jet_index][bin]);
590 }
591 trfinf.effMC_allBins[bin] = tmp_effMC_oneBin;
592 }
593 } // m_continuous
594 else{
595 for (unsigned int jet_index=0; jet_index<trfinf.njets; jet_index++){
596 float tmp_effMC = std::accumulate(tmp_effMC_allBins[jet_index].begin()+m_OP_index_for_GNN, tmp_effMC_allBins[jet_index].end(), 0.0);
597 trfinf.effMC_allBins[0].push_back(1-tmp_effMC);
598 trfinf.effMC_allBins[1].push_back(tmp_effMC);
599 }
600 } // !m_continuous
601
602 return StatusCode::SUCCESS;
603}

◆ getAllEffSF()

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

◆ getDirectTaggedJets()

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

Definition at line 992 of file BTaggingTruthTaggingTool.cxx.

992 {
993 is_tagged.clear();
994 std::vector<int> appo;
995 auto is_jettag = false;
996 for(const auto &jet : trfinf.jets) {
997 ATH_MSG_DEBUG("pt " << jet.vars.jetPt << " eta " << jet.vars.jetEta << " wei " << jet.vars.jetTagWeight);
998 is_jettag = static_cast<bool>(m_selTool->accept(jet.vars.jetPt, jet.vars.jetEta, jet.vars.jetTagWeight));
999
1000 ATH_MSG_DEBUG("is tagged? " << is_jettag);
1001 if(is_jettag) is_tagged.push_back(1);
1002 else is_tagged.push_back(0);
1003 }
1004
1005 return StatusCode::SUCCESS;
1006}

◆ getEvtSF()

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

Definition at line 1009 of file BTaggingTruthTaggingTool.cxx.

1009 {
1010
1011 float SF = 1.;
1012
1013 if (m_ignoreSF)
1014 return SF;
1015
1016 for(unsigned int i =0; i< trfinf.njets; i++) {
1017 float jetSF = 1;
1018
1019 if(!m_continuous){ //FixedCut
1020
1021 bool is_btagged = quantiles.at(i);
1022 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);
1023
1025 ATH_MSG_ERROR("BTaggingEfficiencyTool::getScaleFactor returned CorrectionCode::Error");
1026 return -99.;
1027 }
1028 }
1029 else{ //continuous & continuous2D
1030 int bin = quantiles.at(i);
1031 //set new tagweight bin according to the final decision
1032 //the quantile convention for continuous is: bin+1!
1033 trfinf.jets.at(i).vars.jetTagWeight = (m_continuous2D) ? bin+0.5 : (m_cuts[bin-1].bcut_low + m_cuts[bin-1].bcut_hig)/2.;
1034
1035 auto code = m_effTool->getScaleFactor(trfinf.jets.at(i).flav, trfinf.jets.at(i).vars, jetSF);
1037 ATH_MSG_ERROR("BTaggingEfficiencyTool::getScaleFactor returned CorrectionCode::Error");
1038 return -99;
1039 }
1040 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);
1041 }
1042 SF*=jetSF;
1043 } //loop over jets
1044
1045 ATH_MSG_DEBUG(" FINAL SF : " <<SF);
1046 return SF;
1047}
Gaudi::Property< bool > m_ignoreSF
const float SF[NF]
Cross sections for Fluor.

◆ 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::Event 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
ptrThe 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.

119 {
120
121#ifdef XAOD_STANDALONE
122 // In case we use @c xAOD::Event, we have a direct function call
123 // for this.
124 return evtStore()->event()->getKey( ptr );
125#else
126 const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127 return ( proxy == nullptr ? 0 : proxy->sgkey() );
128#endif // XAOD_STANDALONE
129 }
ServiceHandle< StoreGateSvc > & evtStore()

◆ 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::Event 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
ptrThe 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.

106 {
107
108#ifdef XAOD_STANDALONE
109 // In case we use @c xAOD::Event, we have a direct function call
110 // for this.
111 return evtStore()->event()->getName( ptr );
112#else
113 const SG::DataProxy* proxy = evtStore()->proxy( ptr );
114 static const std::string dummy = "";
115 return ( proxy == nullptr ? dummy : proxy->name() );
116#endif // XAOD_STANDALONE
117 }

◆ 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 857 of file BTaggingTruthTaggingTool.cxx.

857 {
858 trf_bin_ex.resize(trfinf.tbins_ex.size());
859 for(unsigned int i =0; i<trfinf.tbins_ex.size(); i++)
860 trf_bin_ex.at(i).resize(trfinf.tbins_ex.at(i).size());
861
862 trf_bin_in.resize(trfinf.tbins_in.size());
863 for(unsigned int i =0; i<trfinf.tbins_in.size(); i++)
864 trf_bin_in.at(i).resize(trfinf.tbins_in.at(i).size());
865 // increasing the value by 1 to match conventions in selectionTool (not continuous2D)
866 for(unsigned int i =0; i<trfinf.tbins_ex.size(); i++)
867 for(unsigned int j=0; j<trfinf.tbins_ex.at(i).size(); j++)
868 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;
869
870 for(unsigned int i =0; i<trfinf.tbins_in.size(); i++)
871 for(unsigned int j=0; j<trfinf.tbins_in.at(i).size(); j++)
872 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;
873
874 return StatusCode::SUCCESS;
875}

◆ getTagBinsConfProb()

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

Definition at line 971 of file BTaggingTruthTaggingTool.cxx.

971 {
972 float prob = 1.;
973 for(unsigned int j=0; j<tagws.size(); j++) {
974
975 float sum_tag = 0.;
976 //calculate sum of all tagged bins
977 for (auto bin : m_OperatingBins)
978 sum_tag += trfinf.effMC_allBins[bin][j];
979
980 if(std::count(m_OperatingBins.begin(), m_OperatingBins.end(), tagws.at(j) ) ) { // tagged
981 prob *= (trfinf.effMC_allBins[tagws.at(j)][j]) / sum_tag;
982 ATH_MSG_DEBUG("prob " << prob);
983 }
984 else { // untagged
985 prob *= (1 - trfinf.effMC_allBins[tagws.at(j)][j]) / (1 - sum_tag);
986 ATH_MSG_DEBUG("prob " << prob);
987 }
988 }
989 return prob;
990}

◆ 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 765 of file BTaggingTruthTaggingTool.cxx.

765 {
766 trf_chosen_perm_ex.resize(m_nbtag+1);
767 trf_chosen_perm_in.resize(m_nbtag+1);
768 trf_chosen_perm_ex = trfinf.perm_ex;
769 trf_chosen_perm_in = trfinf.perm_in;
770 std::string print_perm = "Permutation: ";
771 for(const auto& perm: trfinf.perm_ex){
772 for(auto is: perm) {
773 if(is) print_perm+=std::to_string(1);
774 else print_perm+=std::to_string(0);
775 print_perm+=" ";
776 }
777 }
778 ATH_MSG_DEBUG(print_perm);
779 return StatusCode::SUCCESS;
780}

◆ getTRFweight()

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

Definition at line 685 of file BTaggingTruthTaggingTool.cxx.

685 {
686
687 unsigned int njets = trfinf.njets;
688 // Consider permutations of njet jets with up to limit b-tags
689 unsigned int limit = (njets > 7) ? 8 : njets+1;
690
691 // Permutations: njets, ntags, permutations
692 auto& perm = trfinf.perms[njets];
693 if (perm.empty()) { // if I don't have already saved the possible permutations for njet
694 perm.resize (limit);
695 for(unsigned int i=0;i<limit;i++)
696 trfinf.perms[njets].at(i) = generatePermutations(njets,i);
697 }
698 trfinf.permsWeight.clear(), trfinf.permsWeight.resize(limit); // trfinf.permsWeight.at(i).at(j): TRF weight of the j-th perm with i b-tags
699 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
700
701 // compute TRF weight
702 unsigned int max = nbtag+1; // from 0 to nbtag b-tags --> nbtag+1 positions
703 trfinf.trfw_ex.clear(), trfinf.trfw_in.clear();
704 trfinf.trfw_ex.resize(max), trfinf.trfw_in.resize(max);
705
706 //clear and resize elements of trfinf
707 trfinf.perm_ex.clear(), trfinf.perm_in.clear(); // vector<vector<bool>> --> for each number of tags the chosen permutation
708 trfinf.perm_ex.resize(max), trfinf.perm_in.resize(max);
709 trfinf.permprob_ex.clear(), trfinf.permprob_in.clear(); // probability of the perm in trfinf.perm_ex/in
710 trfinf.permprob_ex.resize(max), trfinf.permprob_in.resize(max);
711
712 if(isInclusive) {
713 for(unsigned int i=0; i<limit; i++) { // note: I consider maximum limit tags. It's an approximation
714 std::vector<float> weights;
715 float sum = 0.;
716 float w = 0.; //weight
717 trfinf.permsWeight.at(i).clear();
718 trfinf.permsSumWeight.at(i).clear();
719 trfinf.permsWeight.at(i).resize(trfinf.perms[njets].at(i).size());
720 trfinf.permsSumWeight.at(i).resize(trfinf.perms[njets].at(i).size());
721
722 // loop on all the permutations with i tags
723 for(unsigned int p=0; p<trfinf.perms[njets].at(i).size(); p++) {
724
725 w = trfWeight(trfinf,trfinf.perms[njets].at(i).at(p));
726 sum+=w;
727 trfinf.permsWeight.at(i).at(p) = w;
728 trfinf.permsSumWeight.at(i).at(p) = sum;
729
730 ATH_MSG_DEBUG("nbtag = " << i << " wei = " << w << " sum = " << sum);
731 }
732 if(i<limit && i<max) {
733 // note: I need to already have the exclusive weights filled to compite the inclusive
734 trfinf.trfw_ex.at(i) = sum; // sum of TRF weights for all perm with i b-tags
735 if(i == 0) trfinf.trfw_in.at(0) = 1.;
736 else trfinf.trfw_in.at(i) = trfinf.trfw_in.at(i-1) - trfinf.trfw_ex.at(i-1); // P(>=4) = P(>=3) - P(==3)
737 ATH_MSG_DEBUG("i = " << i << " sum = " << sum << " TRF in " << trfinf.trfw_in.at(i) << " ex = " << trfinf.trfw_ex.at(i));
738 }
739 }
740 ATH_MSG_DEBUG("before return, nbtag = " << nbtag << " size de trfinf.trfw_in = " << trfinf.trfw_in.size());
741 return StatusCode::SUCCESS;
742 }
743 else { // exclusive case, only one calculation needed
744 std::vector<float> weights;
745 float sum = 0., w = 0.;
746 size_t size = trfinf.perms[njets].at(nbtag).size();
747 trfinf.permsWeight.at(nbtag).clear();
748 trfinf.permsSumWeight.at(nbtag).clear();
749 trfinf.permsWeight.at(nbtag).resize(size);
750 trfinf.permsSumWeight.at(nbtag).resize(size);
751 // loop on all the permutations with i tags
752 for(unsigned int p=0; p<trfinf.perms[njets].at(nbtag).size(); p++) {
753 w = trfWeight(trfinf,trfinf.perms[njets].at(nbtag).at(p));
754 sum+=w;
755 trfinf.permsWeight.at(nbtag).at(p) = w;
756 trfinf.permsSumWeight.at(nbtag).at(p) = sum;
757 }
758 trfinf.trfw_ex.at(nbtag) = sum;
759 return StatusCode::SUCCESS;
760 }
761 return StatusCode::SUCCESS;
762}
float trfWeight(TRFinfo &trfinf, const std::vector< bool > &tags)

◆ GetTruthTagWeights()

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

Definition at line 415 of file BTaggingTruthTaggingTool.cxx.

415 {
416
417 ANA_CHECK_SET_TYPE (StatusCode);
418 //get MC efficiencies
419 ANA_CHECK(getAllEffMC(trfinf));
420 //compute truth tag weights
421 ANA_CHECK(getTRFweight(trfinf,m_nbtag, true));
422 // choice of the selected permutation
424
425 // choice of the tagged bins
427
428 trf_weight_ex = trfinf.trfw_ex;
429 trf_weight_in = trfinf.trfw_in;
430 return StatusCode::SUCCESS;
431}
StatusCode getAllEffMC(TRFinfo &trfinf)
StatusCode chooseAllTagPermutation(TRFinfo &trfinf, unsigned int nbtag)
StatusCode getTRFweight(TRFinfo &trfinf, unsigned int nbtag, bool isInclusive)
StatusCode chooseAllTagBins(TRFinfo &trfinf)

◆ 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.

83 {
84
85 ANA_CHECK_SET_TYPE (StatusCode);
86 m_initialised = true;
87
88 ANA_CHECK(m_selTool.setProperty("MaxEta", m_maxEta));
89 ANA_CHECK(m_selTool.setProperty("MaxRangePt", m_maxRangePt));
90 ANA_CHECK(m_selTool.setProperty("MinPt", m_minPt));
91 ANA_CHECK(m_selTool.setProperty("TaggerName", m_taggerName));
92 ANA_CHECK(m_selTool.setProperty("OperatingPoint", m_OP));
93 ANA_CHECK(m_selTool.setProperty("JetAuthor", m_jetAuthor));
94 ANA_CHECK(m_selTool.setProperty("FlvTagCutDefinitionsFileName", m_SFFile));
95 ANA_CHECK(m_selTool.initialize());
96
97 ANA_CHECK(m_effTool.setProperty("MinPt", m_minPt));
98 ANA_CHECK(m_effTool.setProperty("TaggerName", m_taggerName));
99 ANA_CHECK(m_effTool.setProperty("OperatingPoint", m_OP));
100 ANA_CHECK(m_effTool.setProperty("JetAuthor", m_jetAuthor));
101 ANA_CHECK(m_effTool.setProperty("ScaleFactorFileName", m_SFFile ));
102 ANA_CHECK(m_effTool.setProperty("UseDevelopmentFile", m_useDevFile ));
103 ANA_CHECK(m_effTool.setProperty("EfficiencyFileName", m_EffFile ));
104 ANA_CHECK(m_effTool.setProperty("ScaleFactorBCalibration", m_SFBName ));
105 ANA_CHECK(m_effTool.setProperty("ScaleFactorCCalibration", m_SFCName ));
106 ANA_CHECK(m_effTool.setProperty("ScaleFactorTCalibration", m_SFTName ));
107 ANA_CHECK(m_effTool.setProperty("ScaleFactorLightCalibration", m_SFLightName ));
108 ANA_CHECK(m_effTool.setProperty("EigenvectorReductionB", m_EVReductionB ));
109 ANA_CHECK(m_effTool.setProperty("EigenvectorReductionC", m_EVReductionC ));
110 ANA_CHECK(m_effTool.setProperty("EigenvectorReductionLight", m_EVReductionLight ));
111 ANA_CHECK(m_effTool.setProperty("EfficiencyBCalibrations", m_EffBName ));
112 ANA_CHECK(m_effTool.setProperty("EfficiencyCCalibrations", m_EffCName ));
113 ANA_CHECK(m_effTool.setProperty("EfficiencyTCalibrations", m_EffTName ));
114 ANA_CHECK(m_effTool.setProperty("EfficiencyLightCalibrations", m_EffLightName ));
115 ANA_CHECK(m_effTool.setProperty("ExcludeFromEigenVectorTreatment", m_excludeFromEV ));
116 ANA_CHECK(m_effTool.setProperty("SystematicsStrategy", m_systStrategy ));
117 ANA_CHECK(m_effTool.setProperty("ConeFlavourLabel", m_coneFlavourLabel ));
118 ANA_CHECK(m_effTool.setProperty("pathToONNX", m_pathToONNX ));
119
120 ANA_CHECK(m_effTool.initialize());
121
122 m_continuous = false;
123 m_continuous2D = false;
124 if(m_OP.value().find("Continuous") != std::string::npos){
125 ATH_MSG_INFO("You are running in Continuous and you chose " << m_cutBenchmark <<" as benchmarks" );
126 m_continuous = true;
127 if(m_OP.value().find("Continuous2D") != std::string::npos)
128 m_continuous2D = true;
129
130 //tokenize the quantiles that will be used as tagged bin indices.
131 std::vector<std::string> tag_benchmarks = split(m_cutBenchmark, ',');
132 for (const auto & tag_bin : tag_benchmarks ){
134 m_OperatingBins.push_back(std::atoi(tag_bin.c_str()));
135 else //continuous
136 m_OperatingBins.push_back(std::atoi(tag_bin.c_str())-1); //different convention
137 }
138 }
139 else{ //FixedCut working points
140 m_OperatingBins.clear();
141 m_OperatingBins.push_back(1); //first bin: untagged, second bin: tagged.
142}
143
145 ATH_MSG_ERROR("UseQuantile is available only in Continuous WP. Please consider switching the Operating Point.");
146 return StatusCode::FAILURE;
147 }
148
149 if (m_pathToONNX != ""){
150 // 60% = 4, 70% = 3, 77% = 2, 85% = 1, 100% = 0
151 m_OP_index_for_GNN = find(m_availableOP_fixCut.begin(), m_availableOP_fixCut.end(), m_OP.value()) - m_availableOP_fixCut.begin() + 1; // GNN predicts 5 bins
152 }
153
154 m_eff_syst.clear();
155 m_sys_name.clear();
156 CP::SystematicSet def_set;
157 m_eff_syst.push_back(def_set);
158 m_sys_name.push_back("Nominal");
159
160 if(m_useSys){
161 std::vector<std::string> excludeEV_vector;
162 if(m_excludeEV != "")
163 excludeEV_vector = split(m_excludeEV, ';');
164 CP::SystematicSet systs = m_effTool->affectingSystematics();
165 for (const auto & syst : systs) {
166 CP::SystematicSet myset;
167 string s = syst.name();
168 if(m_doOnlyUpVariations && s.find("__1down") !=string::npos) continue;
169 if(std::any_of(excludeEV_vector.begin(), excludeEV_vector.end(), [&s](const std::string& str) { return str.find(s) != std::string::npos; })) continue;
170 myset.insert(syst);
171 if(m_excludeEV != "")
172 ATH_MSG_INFO("Adding systematic " << syst.name() << "to the list ");
173 else
174 ATH_MSG_DEBUG("Adding systematic " << syst.name() << "to the list ");
175 m_eff_syst.push_back(myset);
176 m_sys_name.push_back(syst.name());
177 }
178 }
179
180 ATH_MSG_INFO("end of systematics ");
181
182 //set the cuts
183 TString pathtofile = PathResolverFindCalibFile(m_SFFile);
184 m_inf = TFile::Open(pathtofile, "read");
185
186 float min_cut_low = (m_taggerName == "MV2c10") ? -1 : -20;
187 float max_cut_hig = (m_taggerName == "MV2c10") ? +1 : +20;
188
189 if(m_OP == "Continuous"){
190 std::vector<float> bin_edges;
191 bin_edges.push_back(min_cut_low);
192 for (const std::string& bin_name : m_availableOP_fixCut){
193 TString cutname = m_taggerName+"/"+m_jetAuthor+"/"+bin_name+"/cutvalue";
194 float cutval = ((TVector*) m_inf->Get(cutname))[0](0);
195 bin_edges.push_back(cutval);
196 }
197 bin_edges.push_back(max_cut_hig);
198 for (unsigned int be = 0 ; be < bin_edges.size()-1 ; be++){
199 //check if the bin is one of the bins used for btagging
200 //NB. i+1 is to follow the convention 1-5!
201 bool is_tagbin = std::count(m_OperatingBins.begin(), m_OperatingBins.end(), be);
202 TagBin one_cut = TagBin(is_tagbin, bin_edges.at(be), bin_edges.at(be+1));
203 m_cuts.push_back(one_cut);
204 }
205 } //== continuous
206 else if (m_OP.value().find("Continuous2D") != std::string::npos){
207 ATH_MSG_INFO("TruthTagging initialization: Working with Continuous2D WP.");
208 TString cutname = m_taggerName+"/"+m_jetAuthor+"/Continuous2D/cutvalue";
209 TMatrixD* cuts2D = (TMatrixD*) m_inf->Get(cutname);
210 ATH_MSG_DEBUG("Counting " <<cuts2D->GetNrows() <<" bins ");
211
212 for (int bin = 0; bin < cuts2D->GetNrows(); bin++){
213 ATH_MSG_DEBUG("INITIALIZATION c-cuts : " <<(*cuts2D)(bin,0) <<" "
214 <<(*cuts2D)(bin,1) <<" b-cuts : "
215 <<(*cuts2D)(bin,2) <<" "
216 <<(*cuts2D)(bin,3));
217
218 //check if the bin is one of the bins used for btagging
219 //NB. i follows the convention 0-4 of the continuous2D tagging
220 bool is_tagbin = std::count(m_OperatingBins.begin(), m_OperatingBins.end(), bin);
221
222 //set protection limits, so the final generated tagweight values have a meaning
223 float c_tagcut_low = ((*cuts2D)(bin,0) < min_cut_low) ? min_cut_low : (*cuts2D)(bin,0);
224 float c_tagcut_hig = ((*cuts2D)(bin,1) > max_cut_hig) ? max_cut_hig : (*cuts2D)(bin,1);
225 float b_tagcut_low = ((*cuts2D)(bin,2) < min_cut_low) ? min_cut_low : (*cuts2D)(bin,2);
226 float b_tagcut_hig = ((*cuts2D)(bin,3) > max_cut_hig) ? max_cut_hig : (*cuts2D)(bin,3);
227
228 TagBin one_cut = TagBin(is_tagbin, b_tagcut_low, b_tagcut_hig, c_tagcut_low, c_tagcut_hig);
229 m_cuts.push_back(one_cut);
230 }
231 }//continuous2D
232 else{ //fixed-cut
233 TString cutname = m_taggerName+"/"+m_jetAuthor+"/"+m_OP+"/cutvalue";
234 float cutval = ((TVector*) m_inf->Get(cutname))[0](0);
235
236 TagBin untag_bin = TagBin(false, min_cut_low, cutval); //bin 0
237 TagBin tag_bin = TagBin(true, cutval, max_cut_hig); //bin 1
238
239 m_cuts.push_back(untag_bin);
240 m_cuts.push_back(tag_bin);
241 } //FixedCut
242
243 if(m_continuous)
244 for (const auto& c : m_cuts){
245 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);
246 }
247
248 //total number of bins. helpful in loops
249 m_nbins = m_cuts.size(); //FixedCut
250 ATH_MSG_INFO("Total number of bins: " <<m_nbins);
251
252
253 // "AllJets" is the default strategy
254 if (m_taggingStrategy == "AllJets"){
256 } else if (m_taggingStrategy == "Leading2SignalJets"){
258 } else if (m_taggingStrategy == "Leading3SignalJets"){
260 } else {
261 ATH_MSG_ERROR("BTaggingTruthTaggingTool::tagging strategy " << m_taggingStrategy << " is not implemented in the TruthTagging Tool");
262 return StatusCode::FAILURE;
263 }
264
265 return StatusCode::SUCCESS;
266 }
#define ATH_MSG_INFO(x,...)
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Gaudi::Property< std::string > m_SFBName
name of the data/MC scale factor calibration for b jets
std::vector< std::string > split(const std::string &str, char token)
Gaudi::Property< float > m_maxRangePt
Gaudi::Property< bool > m_useQuantile
Gaudi::Property< std::string > m_taggerName
tagger name
Gaudi::Property< std::string > m_EffFile
name of the optional MC efficiency file (may be changed by the PathResolver)
Gaudi::Property< std::string > m_OP
operating point
Gaudi::Property< float > m_maxEta
Gaudi::Property< std::string > m_EVReductionB
specification of the eigenvector reduction strategy for b jets (if eigenvectors are used)
Gaudi::Property< std::string > m_EVReductionLight
specification of the eigenvector reduction strategy for light-flavour jets (if eigenvectors are used)
Gaudi::Property< bool > m_coneFlavourLabel
if true, use cone-based labelling (as opposed to ghost association)
Gaudi::Property< std::string > m_EVReductionC
specification of the eigenvector reduction strategy for c jets (if eigenvectors are used)
Gaudi::Property< bool > m_doOnlyUpVariations
Gaudi::Property< std::string > m_SFCName
name of the data/MC scale factor calibration for charm jets
Gaudi::Property< std::string > m_SFLightName
name of the data/MC scale factor calibration for light-flavour jets
Gaudi::Property< std::string > m_EffTName
semicolon-separated list of MC efficiency parametrisation names for tau jets
Gaudi::Property< bool > m_useDevFile
if true, attempt to retrieve the data/MC efficiency scale factor calibration files from the @PathReso...
Gaudi::Property< std::string > m_excludeEV
in case of continuous WP you can choose to ignore some of the eigenvectors
Gaudi::Property< std::string > m_SFTName
name of the data/MC scale factor calibration for tau jets
Gaudi::Property< std::string > m_EffCName
semicolon-separated list of MC efficiency parametrisation names for charm jets
Gaudi::Property< float > m_minPt
Gaudi::Property< std::string > m_systStrategy
systematics model to be used (current choices are "SFEigen" and "Envelope")
Gaudi::Property< std::string > m_taggingStrategy
tagging strategy is required to do TT with GNN, when we don't want to truth tag all the jets (eg....
Gaudi::Property< std::string > m_EffBName
semicolon-separated list of MC efficiency parametrisation names for b jets
std::vector< std::string > m_availableOP_fixCut
Gaudi::Property< std::string > m_SFFile
name of the data/MC efficiency scale factor calibration file (may be changed by the PathResolver)
Gaudi::Property< std::string > m_excludeFromEV
semicolon-separated list of uncertainties to be excluded from the eigenvector variation procedure
Gaudi::Property< std::string > m_cutBenchmark
operating point when running in Continuous
Gaudi::Property< std::string > m_EffLightName
semicolon-separated list of MC efficiency parametrisation names for light-flavour jets
Gaudi::Property< std::string > m_pathToONNX
if this string is empty, the onnx tool won't be used
void insert(const SystematicVariation &systematic)
description: insert a systematic into the set
std::string find(const std::string &s)
return a remapped string
Definition hcg.cxx:140
Create a proper constructor for Athena.

◆ 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.

74{
75 SystematicSet sys = affectingSystematics();
76 return sys.find( systematic) != sys.end();
77}
CP::SystematicSet affectingSystematics() const
the list of all systematics this tool can be affected by

◆ jetFlavourLabel()

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

Definition at line 1065 of file BTaggingTruthTaggingTool.cxx.

1065 {
1068 else
1069 return GAFinalHadronFlavourLabel(jet);
1070}
int ExclusiveConeHadronFlavourLabel(const xAOD::Jet &jet)
int GAFinalHadronFlavourLabel(const xAOD::Jet &jet)

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ 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.

101 {
102
103 return MSG::name( msg().level() );
104 }
MsgStream & msg() const
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition MsgLevel.cxx:19

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ 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, JetFromPseudojet, JetPileupLabelingTool, JetPseudojetRetriever, JetSubStructureMomentToolsBase, JetTruthLabelingTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

131 {
132
133 ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134 return;
135 }

◆ 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.

79 {
80 return affectingSystematics();
81}

◆ 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 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
372 }
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)

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
354 }

◆ 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.

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

◆ setJets() [1/6]

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

Definition at line 321 of file BTaggingTruthTaggingTool.cxx.

321 {
322 ANA_CHECK_SET_TYPE (StatusCode);
323 if(node_feat.size()!=tagw.size()){
324 ATH_MSG_ERROR( "Vectors of node_feat (outer axis) and tagw should have same size" );
325 return StatusCode::FAILURE;
326 }
327
328 std::vector<int> flav;
329 std::vector<Analysis::CalibrationDataVariables> vars;
330 for(unsigned int i =0; i<tagw.size(); i++){
331 Analysis::CalibrationDataVariables vars_appo;
332
333 // node_feat[i] is always {flav, pt, eta, ...}
334 float pt = node_feat.at(i)[1];
335 float eta = node_feat.at(i)[2];
336
337 ANA_CHECK(fillVariables(pt, eta, tagw.at(i), vars_appo));
338 vars.push_back(vars_appo);
339 flav.push_back(node_feat.at(i)[0]);
340 }
341
342 ANA_CHECK(setJets(trfinf, flav, vars, node_feat));
343 return StatusCode::SUCCESS;
344}
StatusCode fillVariables(const xAOD::Jet &jet, Analysis::CalibrationDataVariables &x)

◆ setJets() [2/6]

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

Definition at line 287 of file BTaggingTruthTaggingTool.cxx.

287 {
288 ANA_CHECK_SET_TYPE (StatusCode);
289 std::vector<int> flav;
290 std::vector<Analysis::CalibrationDataVariables> vars;
291 for(const auto jet : jets) {
292 Analysis::CalibrationDataVariables vars_appo;
293 ANA_CHECK(fillVariables(*jet, vars_appo));
294 vars.push_back(vars_appo);
295 flav.push_back(jetFlavourLabel(*jet));
296 }
297
298 ANA_CHECK(setJets(trfinf,flav, vars));
299 flav.clear();
300 return StatusCode::SUCCESS;
301}
int jetFlavourLabel(const xAOD::Jet &jet)

◆ setJets() [3/6]

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

Definition at line 347 of file BTaggingTruthTaggingTool.cxx.

347 {
348 ANA_CHECK_SET_TYPE (StatusCode);
349 std::vector<int> flav;
350 std::vector<Analysis::CalibrationDataVariables> vars;
351 for(const auto jet : jets) {
352 Analysis::CalibrationDataVariables vars_appo;
353 ANA_CHECK(fillVariables(*jet, vars_appo));
354 vars.push_back(vars_appo);
355 flav.push_back(jetFlavourLabel(*jet));
356 }
357
358 ANA_CHECK(setJets(trfinf, flav, vars, node_feat));
359 flav.clear();
360 return StatusCode::SUCCESS;
361}

◆ 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.

269 {
270 ANA_CHECK_SET_TYPE (StatusCode);
271 if(pt.size()!=eta.size() || pt.size()!=flav.size() || pt.size()!=tagw.size()){
272 ATH_MSG_ERROR( "Vectors of pt, eta, flav and tagw should have same size" );
273 return StatusCode::FAILURE;
274 }
275
276 std::vector<Analysis::CalibrationDataVariables> vars;
277 for(unsigned int i =0; i<pt.size(); i++){
278 Analysis::CalibrationDataVariables vars_appo;
279 ANA_CHECK(fillVariables(pt.at(i), eta.at(i), tagw.at(i), vars_appo));
280 vars.push_back(vars_appo);
281 }
282
283 ANA_CHECK(setJets(trfinf,flav, vars));
284 return StatusCode::SUCCESS;
285}

◆ setJets() [5/6]

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

Definition at line 303 of file BTaggingTruthTaggingTool.cxx.

303 {
304 if(flav.size()!=vars.size()){
305 ATH_MSG_ERROR( "Vector of CalibrationDataVariables and flavour should have same size" );
306 return StatusCode::FAILURE;
307 }
308 trfinf.jets.clear();
309 for(unsigned int i =0; i<vars.size(); i++){
310 jetVariable jetVar_appo;
311 jetVar_appo.flav=flav.at(i);
312 jetVar_appo.vars=vars.at(i);
313 trfinf.jets.push_back(jetVar_appo);
314
315 }
316 trfinf.njets=trfinf.jets.size();
317 return StatusCode::SUCCESS;
318}

◆ setJets() [6/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 366 of file BTaggingTruthTaggingTool.cxx.

366 {
367 if(flav.size()!=vars.size()){
368 ATH_MSG_ERROR( "Vector of CalibrationDataVariables and flavour should have same size" );
369 return StatusCode::FAILURE;
370 }
371 trfinf.jets.clear();
372
373 if (m_njetsTagStrategy == -1){
374 trfinf.njets = vars.size();
375 } else {
376 trfinf.njets = std::min(static_cast<unsigned int>(m_njetsTagStrategy), static_cast<unsigned int>(vars.size()));
377 }
378
379 for(unsigned int i =0; i<trfinf.njets; i++){
380 jetVariable jetVar_appo;
381 jetVar_appo.flav=flav.at(i);
382 jetVar_appo.vars=vars.at(i);
383 trfinf.jets.push_back(jetVar_appo);
384 }
385 trfinf.node_feat = node_feat;
386 return StatusCode::SUCCESS;
387}

◆ setUseSystematics()

void BTaggingTruthTaggingTool::setUseSystematics ( bool useSystematics)

Definition at line 53 of file BTaggingTruthTaggingTool.cxx.

53 {
54 ATH_MSG_DEBUG("setting the use of systematics to: " <<useSystematics);
55 m_useSys = useSystematics;
56 ATH_MSG_DEBUG(" m_useSys = " << m_useSys);
57}

◆ split()

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

Definition at line 1111 of file BTaggingTruthTaggingTool.cxx.

1111 {
1112 std::vector<std::string> result;
1113 if (str.size() > 0) {
1114 std::string::size_type end;
1115 std::string tmp(str);
1116 do {
1117 end = tmp.find(token);
1118 std::string entry = trim(tmp.substr(0,end));
1119 if (entry.size() > 0) result.push_back(entry);
1120 if (end != std::string::npos) tmp = tmp.substr(end+1);
1121 } while (end != std::string::npos);
1122 }
1123 return result;
1124}
string trim(string s)

◆ 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 >, and AthCheckedComponent<::AthAlgTool >.

◆ 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 661 of file BTaggingTruthTaggingTool.cxx.

661 {
662
663 float weight = 1;
664 for (unsigned int t=0; t<tags.size();t++) {
665 float trf = 0.;
666
667 //sum of the efficiencies in the tagged bins
668 for (int bin : m_OperatingBins){
669
670 trf += trfinf.effMC_allBins[bin][t];
671
672 }
673 if(trf>1.) {
674 ATH_MSG_WARNING("Truth Tagging weight > 1. --> setting it to 1. check maps!");
675 trf = 1.;
676 }
677 if(tags.at(t)) weight *= trf;
678 else weight *= (1.-trf);
679 ATH_MSG_DEBUG("weight " <<weight);
680 } // end loop over jets
681 return weight;
682}

◆ updateVHKA()

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

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }
std::vector< SG::VarHandleKeyArray * > m_vhka

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.

181{"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.

251{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.

275{};

◆ m_continuous2D

bool BTaggingTruthTaggingTool::m_continuous2D {}
private

Definition at line 276 of file BTaggingTruthTaggingTool.h.

276{};

◆ 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.

243{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 381 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.

256{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.

273{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.

229{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.

231{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.

213{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.

235{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.

233{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.

223{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.

225{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.

227{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 378 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.

254{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.

237{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.

279{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.

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

◆ m_initialised

bool BTaggingTruthTaggingTool::m_initialised {}
private

Definition at line 188 of file BTaggingTruthTaggingTool.h.

188{};

◆ 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.

245{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.

269{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.

270{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.

268{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.

287{};

◆ 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.

285{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.

263{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.

241{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.

289{};

◆ 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.

258{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.

215{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.

217{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.

211{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.

221{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.

219{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.

247{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.

239{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.

260{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.

249{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.

280{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.

281{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.

282{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 387 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 386 of file AthCommonDataStore.h.


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