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:

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

Public Member Functions
	BTaggingTruthTaggingTool (const std::string &name)
	Create a constructor for standalone usage.
StatusCode	CalculateResults (std::vector< float > &pt, std::vector< float > &eta, std::vector< int > &flav, std::vector< float > &tagw, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	CalculateResults (const xAOD::JetContainer &jets, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	CalculateResultsONNX (const std::vector< std::vector< float > > &node_feat, std::vector< float > &tagw, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	CalculateResultsONNX (const xAOD::JetContainer &jets, const std::vector< std::vector< float > > &node_feat, Analysis::TruthTagResults &results, int rand_seed=-1)
StatusCode	setEffMapIndex (const std::string &flavour, unsigned int index)
	Declare the interface that the class provides.
void	setUseSystematics (bool useSystematics)
virtual	~BTaggingTruthTaggingTool ()
StatusCode	initialize ()
	Dummy implementation of the initialisation function.
CP::SystematicSet	affectingSystematics () const
	the list of all systematics this tool can be affected by
StatusCode	applySystematicVariation (const CP::SystematicSet &systConfig)
	effects: configure this tool for the given list of systematic variations.
CP::SystematicSet	recommendedSystematics () const
	the list of all systematics this tool recommends to use
bool	isAffectedBySystematic (const CP::SystematicVariation &systematic) const
	Declare the interface that this class provides.
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

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

Private Types
enum	NjetsTagStrategy { AllJets =-1 , Leading2SignalJets =2 , Leading3SignalJets =3 }
	will be set according to m_taggingStrategy More...
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Private Attributes
std::vector< std::string >	m_availableOP_fixCut = {"FixedCutBEff_85", "FixedCutBEff_77","FixedCutBEff_70","FixedCutBEff_60"}
TFile *	m_inf {}
std::vector< TagBin >	m_cuts
bool	m_initialised {}
std::vector< CP::SystematicSet >	m_eff_syst
std::vector< std::string >	m_sys_name
std::string	m_SFFile
	name of the data/MC efficiency scale factor calibration file (may be changed by the PathResolver)
std::string	m_EffFile
	name of the optional MC efficiency file (may be changed by the PathResolver)
std::string	m_SFBName
	name of the data/MC scale factor calibration for b jets
std::string	m_SFCName
	name of the data/MC scale factor calibration for charm jets
std::string	m_SFTName
	name of the data/MC scale factor calibration for tau jets
std::string	m_SFLightName
	name of the data/MC scale factor calibration for light-flavour jets
std::string	m_EVReductionB
	specification of the eigenvector reduction strategy for b jets (if eigenvectors are used)
std::string	m_EVReductionC
	specification of the eigenvector reduction strategy for c jets (if eigenvectors are used)
std::string	m_EVReductionLight
	specification of the eigenvector reduction strategy for light-flavour jets (if eigenvectors are used)
std::string	m_EffBName
	semicolon-separated list of MC efficiency parametrisation names for b jets
std::string	m_EffCName
	semicolon-separated list of MC efficiency parametrisation names for charm jets
std::string	m_EffTName
	semicolon-separated list of MC efficiency parametrisation names for tau jets
std::string	m_EffLightName
	semicolon-separated list of MC efficiency parametrisation names for light-flavour jets
std::string	m_excludeFromEV
	semicolon-separated list of uncertainties to be excluded from the eigenvector variation procedure
std::string	m_taggerName
	tagger name
std::string	m_OP
	operating point
std::string	m_cutBenchmark
	operating point when running in Continuous
std::string	m_jetAuthor
	jet collection name
std::string	m_systStrategy
	systematics model to be used (current choices are "SFEigen" and "Envelope")
bool	m_useDevFile {}
	if true, attempt to retrieve the data/MC efficiency scale factor calibration files from the @PathResolver development area
bool	m_coneFlavourLabel {true}
	if true, use cone-based labelling (as opposed to ghost association)
std::string	m_excludeEV
	in case of continuous WP you can choose to ignore some of the eigenvectors
bool	m_doDirectTag {}
	possibility to compute the direct tagging SFs map directly from the TruthTaggingTool
std::string	m_pathToONNX
	if this string is empty, the onnx tool won't be used
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. 'leading2SignalJets')
NjetsTagStrategy	m_njetsTagStrategy {AllJets}
float	m_maxEta {2.5f}
float	m_minPt {20000.f}
float	m_maxRangePt {1000000.f}
bool	m_doOnlyUpVariations {}
bool	m_ignoreSF {true}
bool	m_usePerm {true}
bool	m_useQuantile {true}
bool	m_continuous {}
bool	m_continuous2D {}
bool	m_useSys {}
int	m_nbtag {2}
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 46 of file BTaggingTruthTaggingTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

NjetsTagStrategy

enum BTaggingTruthTaggingTool::NjetsTagStrategy

private

will be set according to m_taggingStrategy

Enumerator
AllJets
Leading2SignalJets
Leading3SignalJets

Definition at line 259 of file BTaggingTruthTaggingTool.h.

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

Constructor & Destructor Documentation

BTaggingTruthTaggingTool()

BTaggingTruthTaggingTool::BTaggingTruthTaggingTool

(

const std::string &

name

)

Create a constructor for standalone usage.

Definition at line 39 of file BTaggingTruthTaggingTool.cxx.

  : asg::AsgTool( name ),
    m_effTool ("BTaggingEfficiencyTool/effTool", this),
    m_selTool ("BTaggingSelectionTool/selTool", this)
  {
 
  m_initialised = false;
 
  // properties of BTaggingTruthTaggingTool
  declareProperty( "IgnoreScaleFactors", m_ignoreSF=true, "ignore scale factors in computation of TRF weight");
  declareProperty( "UsePermutations", m_usePerm=true, "if the chosen permutation is used, a reweighting is applied to the TRF weight for systematics");
  declareProperty( "UseQuantile", m_useQuantile=true, "if the chosen quantile is used, a reweighting is applied to the TRF weight for systematics");
  declareProperty( "UseSystematics", m_useSys=false, "will the results contain all systematic variations, or just the nominal");
  declareProperty( "MaxNtagged", m_nbtag=2, "what is the maximal possible number of tagged jets");
 
  // properties of BtaggingSelectionTool
  declareProperty( "MaxEta", m_maxEta = 2.5 );
  declareProperty( "MinPt", m_minPt = 20000 /*MeV*/);
  declareProperty( "MaxRangePt", m_maxRangePt = 1000000 /*MeV*/);
 
  // properties of BTaggingEfficiencyTool
  declareProperty("TaggerName",                      m_taggerName="MV2c10",            "tagging algorithm name as specified in CDI file");
  declareProperty("OperatingPoint",                  m_OP="FixedCutBEff_77",                    "operating point as specified in CDI file");
  declareProperty("JetAuthor",                       m_jetAuthor="AntiKt4EMTopoJets",             "jet collection & JVF/JVT specification in CDI file");
  declareProperty("ScaleFactorFileName",             m_SFFile = "xAODBTaggingEfficiency/13TeV/2016-20_7-13TeV-MC15-CDI-July12_v1.root",              "name of the official scale factor calibration CDI file (uses PathResolver)");
  declareProperty("UseDevelopmentFile",              m_useDevFile = false,       "specify whether or not to use the (PathResolver) area for temporary scale factor calibration CDI files");
  declareProperty("EfficiencyFileName",              m_EffFile = "",             "name of optional user-provided MC efficiency CDI file");
  declareProperty("ScaleFactorBCalibration",         m_SFBName = "default",      "name of b-jet scale factor calibration object");
  declareProperty("ScaleFactorCCalibration",         m_SFCName = "default",      "name of c-jet scale factor calibration object");
  declareProperty("ScaleFactorTCalibration",         m_SFTName = "default",      "name of tau-jet scale factor calibration object");
  declareProperty("ScaleFactorLightCalibration",     m_SFLightName = "default",  "name of light-flavour jet scale factor calibration object");
  declareProperty("EigenvectorReductionB",           m_EVReductionB = "Loose",   "b-jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'");
  declareProperty("EigenvectorReductionC",           m_EVReductionC = "Loose",   "c-jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'");
  declareProperty("EigenvectorReductionLight",       m_EVReductionLight = "Loose","light-flavour jet scale factor Eigenvector reduction strategy; choose between 'Loose', 'Medium', 'Tight'");
  declareProperty("EfficiencyBCalibrations",         m_EffBName = "default",     "(semicolon-separated) name(s) of b-jet efficiency object(s)");
  declareProperty("EfficiencyCCalibrations",         m_EffCName = "default",     "(semicolon-separated) name(s) of c-jet efficiency object(s)");
  declareProperty("EfficiencyTCalibrations",         m_EffTName = "default",     "(semicolon-separated) name(s) of tau-jet efficiency object(s)");
  declareProperty("EfficiencyLightCalibrations",     m_EffLightName = "default", "(semicolon-separated) name(s) of light-flavour-jet efficiency object(s)");
  declareProperty("ExcludeFromEigenVectorTreatment", m_excludeFromEV = "",       "(semicolon-separated) names of uncertainties to be excluded from eigenvector decomposition (if used)");
  declareProperty("SystematicsStrategy",             m_systStrategy = "SFEigen", "name of systematics model; presently choose between 'SFEigen' and 'Envelope'");
  declareProperty("ConeFlavourLabel",                m_coneFlavourLabel = true, "specify whether or not to use the cone-based flavour labelling instead of the default ghost association based labelling");
  declareProperty("CutBenchmark",                    m_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");
  declareProperty("ExcludeSpecificEigens",           m_excludeEV = "" ,    "(semicolon-separated) names of Eigens you want to exclude. in case of continuous some eigenvectors can be ignored to make the computation faster");
  declareProperty("StoreOnlyUpVariations",           m_doOnlyUpVariations = false ,    "If set to true it processes only the __1up b-tagging variations. It speeds up the computation in case of symmetric variations.");
  declareProperty("doDirectTagging",                 m_doDirectTag = false ,    "If set to true it also computes and stores the direct tagging choice and the related SFs for each jet");
  // if it is empty, the onnx tool won't be initialised
  declareProperty( "pathToONNX",                     m_pathToONNX = "",          "path to the onnx file that will be used for inference");
  declareProperty( "TaggingStrategy",                m_taggingStrategy = "AllJets",     "tagging strategy in the Analysis (eg. 'leading2SignalJets' in boosted VHbb). Required to do TT with GNN");
}

~BTaggingTruthTaggingTool()

BTaggingTruthTaggingTool::~BTaggingTruthTaggingTool ( )

virtual

Definition at line 1101 of file BTaggingTruthTaggingTool.cxx.

                                                   {
 
  // delete trfinf.jets;
 
}

Member Function Documentation

affectingSystematics()

SystematicSet BTaggingTruthTaggingTool::affectingSystematics ( ) const

virtual

the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 100 of file BTaggingTruthTaggingTool.cxx.

                                                                   {
  return m_effTool->affectingSystematics();
}

applySystematicVariation()

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

virtual

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

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

Implements CP::ISystematicsTool.

Definition at line 104 of file BTaggingTruthTaggingTool.cxx.

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

CalculateResults() [1/3]

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

virtual

Implements IBTaggingTruthTaggingTool.

Definition at line 569 of file BTaggingTruthTaggingTool.cxx.

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

CalculateResults() [2/3]

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

virtual

Implements IBTaggingTruthTaggingTool.

Definition at line 558 of file BTaggingTruthTaggingTool.cxx.

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

CalculateResults() [3/3]

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

private

Definition at line 477 of file BTaggingTruthTaggingTool.cxx.

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

CalculateResultsONNX() [1/2]

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

virtual

Implements IBTaggingTruthTaggingTool.

Definition at line 581 of file BTaggingTruthTaggingTool.cxx.

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

CalculateResultsONNX() [2/2]

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

virtual

Implements IBTaggingTruthTaggingTool.

Definition at line 593 of file BTaggingTruthTaggingTool.cxx.

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

check_syst_range()

StatusCode BTaggingTruthTaggingTool::check_syst_range ( unsigned int sys )

private

Definition at line 1093 of file BTaggingTruthTaggingTool.cxx.

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

chooseAllTagBins()

StatusCode BTaggingTruthTaggingTool::chooseAllTagBins ( TRFinfo & trfinf )

private

Definition at line 920 of file BTaggingTruthTaggingTool.cxx.

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

chooseAllTagPermutation()

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

private

Definition at line 825 of file BTaggingTruthTaggingTool.cxx.

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

chooseTagBins_cum()

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

private

Definition at line 942 of file BTaggingTruthTaggingTool.cxx.

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

chooseTagPermutation()

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

private

Definition at line 851 of file BTaggingTruthTaggingTool.cxx.

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

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

ExclusiveConeHadronFlavourLabel()

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

private

Definition at line 1132 of file BTaggingTruthTaggingTool.cxx.

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

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

fillVariables() [1/2]

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

private

Definition at line 450 of file BTaggingTruthTaggingTool.cxx.

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

fillVariables() [2/2]

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

private

Definition at line 433 of file BTaggingTruthTaggingTool.cxx.

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

GAFinalHadronFlavourLabel()

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

private

Definition at line 1115 of file BTaggingTruthTaggingTool.cxx.

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

generatePermutations()

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

private

Definition at line 680 of file BTaggingTruthTaggingTool.cxx.

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

generateRandomTaggerScores()

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

private

Definition at line 1169 of file BTaggingTruthTaggingTool.cxx.

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

getAllEffMC()

StatusCode BTaggingTruthTaggingTool::getAllEffMC ( TRFinfo & trfinf )

private

Definition at line 604 of file BTaggingTruthTaggingTool.cxx.

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

getAllEffMCCDI()

StatusCode BTaggingTruthTaggingTool::getAllEffMCCDI ( TRFinfo & trfinf )

private

Definition at line 648 of file BTaggingTruthTaggingTool.cxx.

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

getAllEffMCGNN()

StatusCode BTaggingTruthTaggingTool::getAllEffMCGNN ( TRFinfo & trfinf )

private

Definition at line 613 of file BTaggingTruthTaggingTool.cxx.

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

getAllEffSF()

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

private

getDirectTaggedJets()

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

private

Definition at line 1035 of file BTaggingTruthTaggingTool.cxx.

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

getEvtSF()

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

private

Definition at line 1052 of file BTaggingTruthTaggingTool.cxx.

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

getKey()

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

inherited

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

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

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

See also

asg::AsgTool::getName

Parameters

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

Returns

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

Definition at line 119 of file AsgTool.cxx.

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

getName()

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

inherited

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

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

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

See also

asg::AsgTool::getKey

Parameters

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

Returns

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

Definition at line 106 of file AsgTool.cxx.

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

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

getQuantiles()

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

private

Definition at line 900 of file BTaggingTruthTaggingTool.cxx.

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

getTagBinsConfProb()

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

private

Definition at line 1014 of file BTaggingTruthTaggingTool.cxx.

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

getTagPermutation()

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

private

Definition at line 808 of file BTaggingTruthTaggingTool.cxx.

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

getTRFweight()

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

private

Definition at line 728 of file BTaggingTruthTaggingTool.cxx.

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

GetTruthTagWeights()

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

private

Definition at line 458 of file BTaggingTruthTaggingTool.cxx.

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

initialize()

StatusCode BTaggingTruthTaggingTool::initialize ( void )

virtual

Dummy implementation of the initialisation function.

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

Reimplemented from asg::AsgTool.

Definition at line 124 of file BTaggingTruthTaggingTool.cxx.

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

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

isAffectedBySystematic()

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

virtual

Declare the interface that this class provides.

returns: whether this tool is affected by the given systematics

Implements CP::ISystematicsTool.

Definition at line 114 of file BTaggingTruthTaggingTool.cxx.

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

jetFlavourLabel()

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

private

Definition at line 1108 of file BTaggingTruthTaggingTool.cxx.

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

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

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

inherited

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

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

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

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

Returns

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

Definition at line 101 of file AsgTool.cxx.

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

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

recommendedSystematics()

SystematicSet BTaggingTruthTaggingTool::recommendedSystematics ( ) const

virtual

the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 120 of file BTaggingTruthTaggingTool.cxx.

                                                                     {
  return affectingSystematics();
}

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setEffMapIndex()

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

virtual

Declare the interface that the class provides.

Implements IBTaggingTruthTaggingTool.

Definition at line 89 of file BTaggingTruthTaggingTool.cxx.

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

setJets() [1/6]

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

private

Definition at line 364 of file BTaggingTruthTaggingTool.cxx.

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

setJets() [2/6]

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

private

Definition at line 329 of file BTaggingTruthTaggingTool.cxx.

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

setJets() [3/6]

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

private

Definition at line 390 of file BTaggingTruthTaggingTool.cxx.

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

setJets() [4/6]

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

private

Definition at line 310 of file BTaggingTruthTaggingTool.cxx.

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

setJets() [5/6]

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

private

Definition at line 409 of file BTaggingTruthTaggingTool.cxx.

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

setJets() [6/6]

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

private

Definition at line 346 of file BTaggingTruthTaggingTool.cxx.

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

setUseSystematics()

void BTaggingTruthTaggingTool::setUseSystematics

(

bool

useSystematics

)

Definition at line 94 of file BTaggingTruthTaggingTool.cxx.

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

split()

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

private

Definition at line 1154 of file BTaggingTruthTaggingTool.cxx.

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

sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

trfWeight()

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

private

Definition at line 704 of file BTaggingTruthTaggingTool.cxx.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_availableOP_fixCut

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

private

Definition at line 179 of file BTaggingTruthTaggingTool.h.

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

m_coneFlavourLabel

bool BTaggingTruthTaggingTool::m_coneFlavourLabel {true}

private

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

Definition at line 249 of file BTaggingTruthTaggingTool.h.

{true};

m_continuous

bool BTaggingTruthTaggingTool::m_continuous {}

private

Definition at line 275 of file BTaggingTruthTaggingTool.h.

{};

m_continuous2D

bool BTaggingTruthTaggingTool::m_continuous2D {}

private

Definition at line 276 of file BTaggingTruthTaggingTool.h.

{};

m_cutBenchmark

std::string BTaggingTruthTaggingTool::m_cutBenchmark

private

operating point when running in Continuous

Definition at line 241 of file BTaggingTruthTaggingTool.h.

m_cuts

std::vector<TagBin> BTaggingTruthTaggingTool::m_cuts

private

Definition at line 184 of file BTaggingTruthTaggingTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doDirectTag

bool BTaggingTruthTaggingTool::m_doDirectTag {}

private

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

Definition at line 253 of file BTaggingTruthTaggingTool.h.

{};

m_doOnlyUpVariations

bool BTaggingTruthTaggingTool::m_doOnlyUpVariations {}

private

Definition at line 271 of file BTaggingTruthTaggingTool.h.

{};

m_eff_syst

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

private

Definition at line 195 of file BTaggingTruthTaggingTool.h.

m_EffBName

std::string BTaggingTruthTaggingTool::m_EffBName

private

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

Definition at line 227 of file BTaggingTruthTaggingTool.h.

m_EffCName

std::string BTaggingTruthTaggingTool::m_EffCName

private

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

Definition at line 229 of file BTaggingTruthTaggingTool.h.

m_EffFile

std::string BTaggingTruthTaggingTool::m_EffFile

private

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

Definition at line 211 of file BTaggingTruthTaggingTool.h.

m_EffLightName

std::string BTaggingTruthTaggingTool::m_EffLightName

private

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

Definition at line 233 of file BTaggingTruthTaggingTool.h.

m_EffTName

std::string BTaggingTruthTaggingTool::m_EffTName

private

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

Definition at line 231 of file BTaggingTruthTaggingTool.h.

m_effTool

asg::AnaToolHandle<IBTaggingEfficiencyTool> BTaggingTruthTaggingTool::m_effTool

private

Definition at line 286 of file BTaggingTruthTaggingTool.h.

m_effTool_allBins

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

private

Definition at line 283 of file BTaggingTruthTaggingTool.h.

m_EVReductionB

std::string BTaggingTruthTaggingTool::m_EVReductionB

private

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

Definition at line 221 of file BTaggingTruthTaggingTool.h.

m_EVReductionC

std::string BTaggingTruthTaggingTool::m_EVReductionC

private

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

Definition at line 223 of file BTaggingTruthTaggingTool.h.

m_EVReductionLight

std::string BTaggingTruthTaggingTool::m_EVReductionLight

private

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

Definition at line 225 of file BTaggingTruthTaggingTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_excludeEV

std::string BTaggingTruthTaggingTool::m_excludeEV

private

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

Definition at line 251 of file BTaggingTruthTaggingTool.h.

m_excludeFromEV

std::string BTaggingTruthTaggingTool::m_excludeFromEV

private

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

Definition at line 235 of file BTaggingTruthTaggingTool.h.

m_ignoreSF

bool BTaggingTruthTaggingTool::m_ignoreSF {true}

private

Definition at line 272 of file BTaggingTruthTaggingTool.h.

{true};

m_inf

TFile* BTaggingTruthTaggingTool::m_inf {}

private

Definition at line 181 of file BTaggingTruthTaggingTool.h.

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

m_initialised

bool BTaggingTruthTaggingTool::m_initialised {}

private

Definition at line 186 of file BTaggingTruthTaggingTool.h.

{};

m_jetAuthor

std::string BTaggingTruthTaggingTool::m_jetAuthor

private

jet collection name

Definition at line 243 of file BTaggingTruthTaggingTool.h.

m_maxEta

float BTaggingTruthTaggingTool::m_maxEta {2.5f}

private

Definition at line 266 of file BTaggingTruthTaggingTool.h.

{2.5f};

m_maxRangePt

float BTaggingTruthTaggingTool::m_maxRangePt {1000000.f}

private

Definition at line 268 of file BTaggingTruthTaggingTool.h.

{1000000.f};

m_minPt

float BTaggingTruthTaggingTool::m_minPt {20000.f}

private

Definition at line 267 of file BTaggingTruthTaggingTool.h.

{20000.f};

m_nbins

int BTaggingTruthTaggingTool::m_nbins {}

private

Definition at line 279 of file BTaggingTruthTaggingTool.h.

{};

m_nbtag

int BTaggingTruthTaggingTool::m_nbtag {2}

private

Definition at line 278 of file BTaggingTruthTaggingTool.h.

{2};

m_njetsTagStrategy

NjetsTagStrategy BTaggingTruthTaggingTool::m_njetsTagStrategy {AllJets}

private

Definition at line 260 of file BTaggingTruthTaggingTool.h.

{AllJets};

m_OP

std::string BTaggingTruthTaggingTool::m_OP

private

operating point

Definition at line 239 of file BTaggingTruthTaggingTool.h.

m_OP_index_for_GNN

unsigned int BTaggingTruthTaggingTool::m_OP_index_for_GNN {}

private

Definition at line 281 of file BTaggingTruthTaggingTool.h.

{};

m_OperatingBins

std::vector<int> BTaggingTruthTaggingTool::m_OperatingBins

private

Definition at line 280 of file BTaggingTruthTaggingTool.h.

m_pathToONNX

std::string BTaggingTruthTaggingTool::m_pathToONNX

private

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

Definition at line 255 of file BTaggingTruthTaggingTool.h.

m_selTool

asg::AnaToolHandle<IBTaggingSelectionTool> BTaggingTruthTaggingTool::m_selTool

private

Definition at line 287 of file BTaggingTruthTaggingTool.h.

m_SFBName

std::string BTaggingTruthTaggingTool::m_SFBName

private

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

Definition at line 213 of file BTaggingTruthTaggingTool.h.

m_SFCName

std::string BTaggingTruthTaggingTool::m_SFCName

private

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

Definition at line 215 of file BTaggingTruthTaggingTool.h.

m_SFFile

std::string BTaggingTruthTaggingTool::m_SFFile

private

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

Definition at line 209 of file BTaggingTruthTaggingTool.h.

m_SFLightName

std::string BTaggingTruthTaggingTool::m_SFLightName

private

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

Definition at line 219 of file BTaggingTruthTaggingTool.h.

m_SFTName

std::string BTaggingTruthTaggingTool::m_SFTName

private

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

Definition at line 217 of file BTaggingTruthTaggingTool.h.

m_sys_name

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

private

Definition at line 196 of file BTaggingTruthTaggingTool.h.

m_systStrategy

std::string BTaggingTruthTaggingTool::m_systStrategy

private

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

Definition at line 245 of file BTaggingTruthTaggingTool.h.

m_taggerName

std::string BTaggingTruthTaggingTool::m_taggerName

private

tagger name

Definition at line 237 of file BTaggingTruthTaggingTool.h.

m_taggingStrategy

std::string BTaggingTruthTaggingTool::m_taggingStrategy

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 257 of file BTaggingTruthTaggingTool.h.

m_useDevFile

bool BTaggingTruthTaggingTool::m_useDevFile {}

private

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

Definition at line 247 of file BTaggingTruthTaggingTool.h.

{};

m_usePerm

bool BTaggingTruthTaggingTool::m_usePerm {true}

private

Definition at line 273 of file BTaggingTruthTaggingTool.h.

{true};

m_useQuantile

bool BTaggingTruthTaggingTool::m_useQuantile {true}

private

Definition at line 274 of file BTaggingTruthTaggingTool.h.

{true};

m_useSys

bool BTaggingTruthTaggingTool::m_useSys {}

private

Definition at line 277 of file BTaggingTruthTaggingTool.h.

{};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• BTaggingTruthTaggingTool.h
• BTaggingTruthTaggingTool.cxx