ATLAS Offline Software
Public Member Functions | Public Attributes | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
TauAnalysisTools::CommonDiTauEfficiencyTool Class Referenceabstract

#include <CommonDiTauEfficiencyTool.h>

Inheritance diagram for TauAnalysisTools::CommonDiTauEfficiencyTool:
Collaboration diagram for TauAnalysisTools::CommonDiTauEfficiencyTool:

Public Member Functions

 CommonDiTauEfficiencyTool (const std::string &sName)
 Create a proper constructor for Athena. More...
 
 ~CommonDiTauEfficiencyTool ()
 
virtual StatusCode initialize () override
 Dummy implementation of the initialisation function. More...
 
virtual CP::CorrectionCode getEfficiencyScaleFactor (const xAOD::DiTauJet &xDiTau, double &dEfficiencyScaleFactor) override
 Get the Efficiency Scale Factor of ditau jet. More...
 
virtual CP::CorrectionCode applyEfficiencyScaleFactor (const xAOD::DiTauJet &xDiTau) override
 Get the Efficiency Scale Factor of ditau jet. More...
 
void ReadInputs (std::unique_ptr< TFile > &fFile)
 
CP::CorrectionCode getValue (const std::string &sHistName, const xAOD::DiTauJet &xDiTau, double &dEfficiencyScaleFactor) const
 Get the scale factor from a particular recommendations histogram. More...
 
void generateSystematicSets ()
 generate a set of relevant systematic variations to be applied More...
 
virtual CP::CorrectionCode getEfficiencyScaleFactor (const xAOD::TauJet &tau, double &dEfficiencyScaleFactor, unsigned int iRunNumber=0)
 
virtual CP::CorrectionCode applyEfficiencyScaleFactor (const xAOD::TauJet &xTau, unsigned int iRunNumber=0)
 
virtual CP::CorrectionCode getValue (const std::string &sHistName, const xAOD::TauJet &xTau, double &dEfficiencyScaleFactor) const
 
virtual CP::CorrectionCode getEfficiencyScaleFactor (const xAOD::TauJet &tau, double &dEfficiencyScaleFactor, unsigned int iRunNumber=0)
 Declare the interface that the class provides. More...
 
virtual CP::CorrectionCode applyEfficiencyScaleFactor (const xAOD::TauJet &xTau, unsigned int iRunNumber=0)
 Decorate the tau with its efficiency. More...
 
virtual bool isAffectedBySystematic (const CP::SystematicVariation &systematic) const
 returns: whether this tool is affected by the given systematics More...
 
virtual CP::SystematicSet affectingSystematics () const
 returns: the list of all systematics this tool can be affected by More...
 
virtual CP::SystematicSet recommendedSystematics () const
 returns: the list of all systematics this tool recommends to use More...
 
virtual StatusCode applySystematicVariation (const CP::SystematicSet &sSystematicSet)
 configure this tool for the given list of systematic variations. More...
 
virtual bool isSupportedRunNumber (int) const
 check if run number is supported in recommendations More...
 
virtual void print () const =0
 Print the state of the tool. More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Public Attributes

double(* m_fXDiTau )(const xAOD::DiTauJet &xDiTau)
 scale factor bin x (e.g. More...
 
double(* m_fYDiTau )(const xAOD::DiTauJet &xDiTau)
 scale factor bin y (e.g. More...
 
double(* m_fZDiTau )(const xAOD::DiTauJet &xDiTau)
 scale factor bin z (e.g. More...
 
bool m_bSFIsAvailableDiTau
 true if scale factor name is already decorated More...
 
bool m_bSFIsAvailableCheckedDiTau
 true if cale factor name is already decorated has already been checked More...
 

Protected Types

typedef std::tuple< TObject *, CP::CorrectionCode(*)(const TObject *oObject, double &dEfficiencyScaleFactor, double dVars[]) > tTupleObjectFunc
 
typedef std::map< std::string, tTupleObjectFunctSFMAP
 

Protected Member Functions

std::string ConvertProngToString (const int iProngness) const
 
std::string ConvertDecayModeToString (const int iDecayMode) const
 
void ReadInputs (const TFile &fFile)
 
void addHistogramToSFMap (TKey *kKey, const std::string &sKeyName)
 
virtual CP::CorrectionCode getValue (const std::string &sHistName, const xAOD::TauJet &xTau, double &dEfficiencyScaleFactor) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

Static Protected Member Functions

static CP::CorrectionCode getValueTH1 (const TObject *oObject, double &dEfficiencyScaleFactor, double dVars[])
 
static CP::CorrectionCode getValueTH2 (const TObject *oObject, double &dEfficiencyScaleFactor, double dVars[])
 
static CP::CorrectionCode getValueTF1 (const TObject *oObject, double &dEfficiencyScaleFactor, double dVars[])
 

Protected Attributes

std::unique_ptr< tSFMAPm_mSF
 
std::unordered_map< CP::SystematicSet, std::string > m_mSystematicSets
 
const CP::SystematicSetm_sSystematicSet
 
std::map< std::string, int > m_mSystematics
 
std::map< std::string, std::string > m_mSystematicsHistNames
 
std::function< double(const xAOD::TauJet &xTau)> m_fX
 
std::function< double(const xAOD::TauJet &xTau)> m_fY
 
CP::SystematicSet m_sAffectingSystematics
 
CP::SystematicSet m_sRecommendedSystematics
 
Gaudi::Property< std::string > m_sInputFilePath {this, "InputFilePath", ""}
 
Gaudi::Property< std::string > m_sVarName {this, "VarName", ""}
 
Gaudi::Property< std::string > m_sWP {this, "WP", ""}
 
Gaudi::Property< bool > m_bSkipTruthMatchCheck {this, "SkipTruthMatchCheck", false}
 
Gaudi::Property< int > m_iJetIDLevel {this, "JetIDLevel", static_cast<int>(JETIDNONE)}
 
Gaudi::Property< int > m_iEleIDLevel {this, "EleIDLevel", static_cast<int>(ELEIDNONE)}
 
Gaudi::Property< bool > m_bUseTauSubstructure {this, "UseTauSubstructure", false}
 
Gaudi::Property< bool > m_doTauTrig {this, "DoTauTrig", false}
 
std::string m_sInputFileName
 
std::string m_sSFHistName
 
bool m_bNoMultiprong
 
TruthMatchedParticleType m_eCheckTruth
 
bool m_bSFIsAvailable
 
bool m_bSFIsAvailableChecked
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 38 of file CommonDiTauEfficiencyTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ tSFMAP

typedef std::map<std::string, tTupleObjectFunc > TauAnalysisTools::CommonEfficiencyTool::tSFMAP
protectedinherited

Definition at line 88 of file CommonEfficiencyTool.h.

◆ tTupleObjectFunc

typedef std::tuple<TObject*, CP::CorrectionCode (*)(const TObject* oObject, double& dEfficiencyScaleFactor, double dVars[] ) > TauAnalysisTools::CommonEfficiencyTool::tTupleObjectFunc
protectedinherited

Definition at line 87 of file CommonEfficiencyTool.h.

Constructor & Destructor Documentation

◆ CommonDiTauEfficiencyTool()

CommonDiTauEfficiencyTool::CommonDiTauEfficiencyTool ( const std::string &  sName)

Create a proper constructor for Athena.

Definition at line 21 of file CommonDiTauEfficiencyTool.cxx.

22  : CommonEfficiencyTool( sName )
26  , m_bSFIsAvailableDiTau(false)
28 {
29 }

◆ ~CommonDiTauEfficiencyTool()

CommonDiTauEfficiencyTool::~CommonDiTauEfficiencyTool ( )

Definition at line 31 of file CommonDiTauEfficiencyTool.cxx.

32 {
33 }

Member Function Documentation

◆ addHistogramToSFMap()

void CommonEfficiencyTool::addHistogramToSFMap ( TKey *  kKey,
const std::string &  sKeyName 
)
protectedinherited

Definition at line 540 of file CommonEfficiencyTool.cxx.

541 {
542  // handling for the 3 different input types TH1F/TH1D/TF1, function pointer
543  // handle the access methods for the final scale factor retrieval
544  TClass *cClass = gROOT->GetClass(kKey->GetClassName());
545  if (cClass->InheritsFrom("TH2"))
546  {
547  TH1* oObject = (TH1*)kKey->ReadObj();
548  oObject->SetDirectory(0);
549  (*m_mSF)[sKeyName] = tTupleObjectFunc(oObject,&getValueTH2);
550  ATH_MSG_DEBUG("added histogram with name "<<sKeyName);
551  }
552  else if (cClass->InheritsFrom("TH1"))
553  {
554  TH1* oObject = (TH1*)kKey->ReadObj();
555  oObject->SetDirectory(0);
556  (*m_mSF)[sKeyName] = tTupleObjectFunc(oObject,&getValueTH1);
557  ATH_MSG_DEBUG("added histogram with name "<<sKeyName);
558  }
559  else if (cClass->InheritsFrom("TF1"))
560  {
561  TObject* oObject = kKey->ReadObj();
562  (*m_mSF)[sKeyName] = tTupleObjectFunc(oObject,&getValueTF1);
563  ATH_MSG_DEBUG("added function with name "<<sKeyName);
564  }
565  else
566  {
567  ATH_MSG_DEBUG("ignored object with name "<<sKeyName);
568  }
569 }

◆ affectingSystematics()

CP::SystematicSet CommonEfficiencyTool::affectingSystematics ( ) const
virtualinherited

returns: the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 315 of file CommonEfficiencyTool.cxx.

316 {
318 }

◆ applyEfficiencyScaleFactor() [1/3]

CP::CorrectionCode CommonDiTauEfficiencyTool::applyEfficiencyScaleFactor ( const xAOD::DiTauJet xDiTau)
overridevirtual

Get the Efficiency Scale Factor of ditau jet.

Parameters
xDiTau
Returns
CP::CorrectionCode

Implements TauAnalysisTools::IDiTauEfficiencyCorrectionsTool.

Definition at line 163 of file CommonDiTauEfficiencyTool.cxx.

164 {
165  double dSf = 0.;
166 
169  {
170  m_bSFIsAvailableDiTau = decor.isAvailable(xDiTau);
173  {
174  ATH_MSG_DEBUG(m_sVarName << " decoration is available on first ditau processed, switched of applyEfficiencyScaleFactor for further ditaus.");
175  ATH_MSG_DEBUG("If an application of efficiency scale factors needs to be redone, please pass a shallow copy of the original ditau.");
176  }
177  }
179  return CP::CorrectionCode::Ok;
180 
181  // retrieve scale factor
182  CP::CorrectionCode tmpCorrectionCode = getEfficiencyScaleFactor(xDiTau, dSf);
183  // adding scale factor to tau as decoration
184  decor(xDiTau) = dSf;
185 
186  return tmpCorrectionCode;
187 }

◆ applyEfficiencyScaleFactor() [2/3]

CP::CorrectionCode CommonEfficiencyTool::applyEfficiencyScaleFactor

Definition at line 58 of file CommonEfficiencyTool.cxx.

275 {
276  double dSf = 0.;
277 
280  {
281  m_bSFIsAvailable = decor.isAvailable(xTau);
283  if (m_bSFIsAvailable)
284  {
285  ATH_MSG_DEBUG(m_sVarName << " decoration is available on first tau processed, switched off applyEfficiencyScaleFactor for further taus.");
286  ATH_MSG_DEBUG("If an application of efficiency scale factors needs to be redone, please pass a shallow copy of the original tau.");
287  }
288  }
289  if (m_bSFIsAvailable)
290  return CP::CorrectionCode::Ok;
291 
292  // retrieve scale factor
293  CP::CorrectionCode tmpCorrectionCode = getEfficiencyScaleFactor(xTau, dSf, iRunNumber);
294  // adding scale factor to tau as decoration
295  decor(xTau) = dSf;
296 
297  return tmpCorrectionCode;
298 }

◆ applyEfficiencyScaleFactor() [3/3]

CP::CorrectionCode CommonEfficiencyTool::applyEfficiencyScaleFactor ( const xAOD::TauJet xTau,
unsigned int  iRunNumber = 0 
)
virtualinherited

Decorate the tau with its efficiency.

Implements TauAnalysisTools::ITauEfficiencyCorrectionsTool.

Definition at line 273 of file CommonEfficiencyTool.cxx.

275 {
276  double dSf = 0.;
277 
280  {
281  m_bSFIsAvailable = decor.isAvailable(xTau);
283  if (m_bSFIsAvailable)
284  {
285  ATH_MSG_DEBUG(m_sVarName << " decoration is available on first tau processed, switched off applyEfficiencyScaleFactor for further taus.");
286  ATH_MSG_DEBUG("If an application of efficiency scale factors needs to be redone, please pass a shallow copy of the original tau.");
287  }
288  }
289  if (m_bSFIsAvailable)
290  return CP::CorrectionCode::Ok;
291 
292  // retrieve scale factor
293  CP::CorrectionCode tmpCorrectionCode = getEfficiencyScaleFactor(xTau, dSf, iRunNumber);
294  // adding scale factor to tau as decoration
295  decor(xTau) = dSf;
296 
297  return tmpCorrectionCode;
298 }

◆ applySystematicVariation()

StatusCode CommonEfficiencyTool::applySystematicVariation ( const CP::SystematicSet sSystematicSet)
virtualinherited

configure this tool for the given list of systematic variations.

any requested systematics that are not affecting this tool will be silently ignored

Implements CP::ISystematicsTool.

Definition at line 340 of file CommonEfficiencyTool.cxx.

341 {
342 
343  // first check if we already know this systematic configuration
344  auto itSystematicSet = m_mSystematicSets.find(sSystematicSet);
345  if (itSystematicSet != m_mSystematicSets.end())
346  {
347  m_sSystematicSet = &itSystematicSet->first;
348  return StatusCode::SUCCESS;
349  }
350 
351  // sanity checks if systematic set is supported
352  double dDirection = 0.;
353  CP::SystematicSet sSystematicSetAvailable;
354  for (auto sSyst : sSystematicSet)
355  {
356  // check if systematic is available
357  auto it = m_mSystematicsHistNames.find(sSyst.basename());
358  if (it == m_mSystematicsHistNames.end())
359  {
360  ATH_MSG_VERBOSE("unsupported systematic variation: "<< sSyst.basename()<<"; skipping this one");
361  continue;
362  }
363 
364 
365  if (sSyst.parameter() * dDirection < 0)
366  {
367  ATH_MSG_ERROR("unsupported set of systematic variations, you should either use only \"UP\" or only \"DOWN\" systematics in one set!");
368  ATH_MSG_ERROR("systematic set will not be applied");
369  return StatusCode::FAILURE;
370  }
371  dDirection = sSyst.parameter();
372 
373  if ((m_sRecommendedSystematics.find(sSyst.basename()) != m_sRecommendedSystematics.end()) and sSystematicSet.size() > 1)
374  {
375  ATH_MSG_ERROR("unsupported set of systematic variations, you should not combine \"TAUS_{TRUE|FAKE}_EFF_*_TOTAL\" with other systematic variations!");
376  ATH_MSG_ERROR("systematic set will not be applied");
377  return StatusCode::FAILURE;
378  }
379 
380  // finally add the systematic to the set of systematics to process
381  sSystematicSetAvailable.insert(sSyst);
382  }
383 
384  // store this calibration for future use, and make it current
385  m_sSystematicSet = &m_mSystematicSets.insert(std::pair<CP::SystematicSet,std::string>(sSystematicSetAvailable, sSystematicSet.name())).first->first;
386 
387  return StatusCode::SUCCESS;
388 }

◆ ConvertDecayModeToString()

std::string CommonEfficiencyTool::ConvertDecayModeToString ( const int  iDecayMode) const
protectedinherited

Definition at line 400 of file CommonEfficiencyTool.cxx.

401 {
402  switch(iDecayMode)
403  {
405  return "_r1p0n";
407  return "_r1p1n";
409  return "_r1pXn";
411  return "_r3p0n";
413  return "_r3pXn";
414  default:
415  return "";
416  }
417 }

◆ ConvertProngToString()

std::string CommonEfficiencyTool::ConvertProngToString ( const int  iProngness) const
protectedinherited

Definition at line 391 of file CommonEfficiencyTool.cxx.

392 {
393  return fProngness == 1 ? "_1p" : "_3p";
394 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

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  }

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

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ generateSystematicSets()

void CommonDiTauEfficiencyTool::generateSystematicSets ( )

generate a set of relevant systematic variations to be applied

Definition at line 243 of file CommonDiTauEfficiencyTool.cxx.

244 {
245  // creation of basic string for all NPs, e.g. "TAUS_TRUEHADTAU_EFF_RECO_"
246  std::vector<std::string> vSplitInputFilePath = {};
247  split(m_sInputFileName,'_',vSplitInputFilePath);
248  std::string sEfficiencyType = vSplitInputFilePath.at(0);
249  std::string sTruthType = vSplitInputFilePath.at(1);
250  std::transform(sEfficiencyType.begin(), sEfficiencyType.end(), sEfficiencyType.begin(), toupper);
251  std::transform(sTruthType.begin(), sTruthType.end(), sTruthType.begin(), toupper);
252  std::string sSystematicBaseString = "TAUS_"+sTruthType+"_EFF_"+sEfficiencyType+"_";
253  // set truth type to check for in truth matching
254  if (sTruthType=="TRUEHADTAU") m_eCheckTruth = TauAnalysisTools::TruthHadronicTau;
255  if (sTruthType=="TRUEHADDITAU") m_eCheckTruth = TauAnalysisTools::TruthHadronicDiTau;
256 
257  for (auto mSF : *m_mSF)
258  {
259  // parse for nuisance parameter in histogram name
260  std::vector<std::string> vSplitNP = {};
261  split(mSF.first,'_',vSplitNP);
262  std::string sNP = vSplitNP.at(0);
263  std::string sNPUppercase = vSplitNP.at(0);
264  // skip nominal scale factors
265  if (sNP == "sf") continue;
266  // test if NP starts with a capital letter indicating that this should be recommended
267  bool bIsRecommended = false;
268  if (isupper(sNP.at(0)))
269  bIsRecommended = true;
270  // make sNP uppercase and build final NP entry name
271  std::transform(sNPUppercase.begin(), sNPUppercase.end(), sNPUppercase.begin(), toupper);
272  std::string sSystematicString = sSystematicBaseString+sNPUppercase;
273  // add all found systematics to the AffectingSystematics
275  m_sAffectingSystematics.insert(CP::SystematicVariation (sSystematicString, -1));
276  // only add found uppercase systematics to the RecommendedSystematics
277  if (bIsRecommended)
278  {
281  }
282  ATH_MSG_DEBUG("connected base name " << sNP << " with systematic " <<sSystematicString);
283  m_mSystematicsHistNames.insert({sSystematicString,sNP});
284  }
285 }

◆ getEfficiencyScaleFactor() [1/3]

CP::CorrectionCode CommonDiTauEfficiencyTool::getEfficiencyScaleFactor ( const xAOD::DiTauJet xDiTau,
double &  dEfficiencyScaleFactor 
)
overridevirtual

Get the Efficiency Scale Factor of ditau jet.

Parameters
xDiTau: reco DiTauJet
dEfficiencyScaleFactor: reference to output variable where efficiency is returned
Returns
CP::CorrectionCode

Implements TauAnalysisTools::IDiTauEfficiencyCorrectionsTool.

Definition at line 86 of file CommonDiTauEfficiencyTool.cxx.

88 {
89  // check which true state is requestet
90  if (getTruthParticleType(xDiTau) != m_eCheckTruth)
91  {
92  dEfficiencyScaleFactor = 1.;
94  }
95 
96  CP::CorrectionCode tmpCorrectionCode = getValue(m_sSFHistName,
97  xDiTau,
98  dEfficiencyScaleFactor);
99  // return correction code if histogram is not available
100  if (tmpCorrectionCode != CP::CorrectionCode::Ok)
101  return tmpCorrectionCode;
102 
103  // skip further process if systematic set is empty
104  if (m_sSystematicSet->size() == 0)
105  return CP::CorrectionCode::Ok;
106 
107  // get uncertainties summed in quadrature
108  double dTotalSystematic2 = 0.;
109  double dDirection = 0.;
110  for (auto syst : *m_sSystematicSet)
111  {
112 
113  // check if systematic is available
114  auto it = m_mSystematicsHistNames.find(syst.basename());
115 
116  // get uncertainty value
117  double dUncertaintySyst = 0.;
118 
119  // needed for up/down decision
120  dDirection = syst.parameter();
121 
122  // build up histogram name
123  std::string sHistName = it->second;
124  if (dDirection>0) sHistName+="_up";
125  else sHistName+="_down";
126  if (!m_sWP.empty()) sHistName+="_"+m_sWP;
127 
128  // get the uncertainty from the histogram
129  tmpCorrectionCode = getValue(sHistName,
130  xDiTau,
131  dUncertaintySyst);
132 
133  // return correction code if histogram is not available
134  if (tmpCorrectionCode != CP::CorrectionCode::Ok)
135  return tmpCorrectionCode;
136 
137  // scale uncertainty with direction, i.e. +/- n*sigma
138  dUncertaintySyst *= dDirection;
139 
140  // square uncertainty and add to total uncertainty
141  dTotalSystematic2 += dUncertaintySyst * dUncertaintySyst;
142  }
143 
144  // now use dDirection to use up/down uncertainty
145  dDirection = (dDirection > 0.) ? 1. : -1.;
146 
147  // finally apply uncertainty (eff * ( 1 +/- \sum )
148  dEfficiencyScaleFactor *= 1. + dDirection * std::sqrt(dTotalSystematic2);
149 
150  return CP::CorrectionCode::Ok;
151 }

◆ getEfficiencyScaleFactor() [2/3]

CP::CorrectionCode CommonEfficiencyTool::getEfficiencyScaleFactor

Definition at line 55 of file CommonEfficiencyTool.cxx.

146 {
147  // check which true state is requested
149  {
150  dEfficiencyScaleFactor = 1.;
151  return CP::CorrectionCode::Ok;
152  }
153 
154  // check if 1 prong
155  if (m_bNoMultiprong && xTau.nTracks() != 1)
156  {
157  dEfficiencyScaleFactor = 1.;
158  return CP::CorrectionCode::Ok;
159  }
160 
161  // get decay mode or prong extension for histogram name
162  std::string sMode;
164  {
165  int iDecayMode = -1;
166  xTau.panTauDetail(xAOD::TauJetParameters::PanTau_DecayMode, iDecayMode);
167  sMode = ConvertDecayModeToString(iDecayMode);
168  if (sMode.empty())
169  {
170  ATH_MSG_WARNING("Found tau with unknown decay mode. Skip efficiency correction.");
172  }
173  }
174  else
175  {
176  // skip taus which are not 1 or 3 prong
177  if( xTau.nTracks() != 1 && xTau.nTracks() != 3) {
178  dEfficiencyScaleFactor = 1.;
179  return CP::CorrectionCode::Ok;
180  }
181 
182  sMode = ConvertProngToString(xTau.nTracks());
183  }
184 
185  std::string sHistName;
186  if(m_doTauTrig){
187  sHistName = "sf_all_"+m_sWP+sMode;
188  } else {
189  sHistName = m_sSFHistName + sMode;
190  }
191 
192  // get standard scale factor
193  CP::CorrectionCode tmpCorrectionCode = getValue(sHistName,
194  xTau,
195  dEfficiencyScaleFactor);
196  // return correction code if histogram is not available
197  if (tmpCorrectionCode != CP::CorrectionCode::Ok)
198  return tmpCorrectionCode;
199 
200  // skip further process if systematic set is empty
201  if (m_sSystematicSet->empty())
202  return CP::CorrectionCode::Ok;
203 
204  // get uncertainties summed in quadrature
205  double dTotalSystematic2 = 0.;
206  double dDirection = 0.;
207  for (auto syst : *m_sSystematicSet)
208  {
209  // check if systematic is available
210  auto it = m_mSystematicsHistNames.find(syst.basename());
211 
212  // get uncertainty value
213  double dUncertaintySyst = 0.;
214 
215  // needed for up/down decision
216  dDirection = syst.parameter();
217 
218  // build up histogram name
219  sHistName = it->second;
220  if (dDirection>0.) sHistName+="_up";
221  else sHistName+="_down";
222 
223  if(m_doTauTrig){ sHistName+="_all"; }
224 
225  if (!m_sWP.empty()) sHistName+="_"+m_sWP;
226  sHistName += sMode;
227 
228 
229  // filter unwanted combinations
230  if( (sHistName.find("3P") != std::string::npos && sHistName.find("1p") != std::string::npos) ||
231  (sHistName.find("1P") != std::string::npos && sHistName.find("3p") != std::string::npos))
232  continue;
233 
234  if( (sHistName.find("1520") != std::string::npos && sHistName.find("loose") != std::string::npos) ){
235  continue;
236  }
237 
238  // get the uncertainty from the histogram
239  tmpCorrectionCode = getValue(sHistName,
240  xTau,
241  dUncertaintySyst);
242 
243  // return correction code if histogram is not available
244  if (tmpCorrectionCode != CP::CorrectionCode::Ok)
245  return tmpCorrectionCode;
246 
247  // scale uncertainty with direction, i.e. +/- n*sigma
248  dUncertaintySyst *= dDirection;
249 
250  // square uncertainty and add to total uncertainty
251  dTotalSystematic2 += dUncertaintySyst * dUncertaintySyst;
252  }
253 
254  // now use dDirection to use up/down uncertainty
255  dDirection = (dDirection > 0.) ? 1. : -1.;
256 
257  // finally apply uncertainty (eff * ( 1 +/- \sum )
258  dEfficiencyScaleFactor *= 1. + dDirection * std::sqrt(dTotalSystematic2);
259 
260  return CP::CorrectionCode::Ok;
261 }

◆ getEfficiencyScaleFactor() [3/3]

CP::CorrectionCode CommonEfficiencyTool::getEfficiencyScaleFactor ( const xAOD::TauJet xTau,
double &  eff,
unsigned int  iRunNumber = 0 
)
virtualinherited

Declare the interface that the class provides.

Get the tau efficiency scale factor

Implements TauAnalysisTools::ITauEfficiencyCorrectionsTool.

Definition at line 144 of file CommonEfficiencyTool.cxx.

146 {
147  // check which true state is requested
149  {
150  dEfficiencyScaleFactor = 1.;
151  return CP::CorrectionCode::Ok;
152  }
153 
154  // check if 1 prong
155  if (m_bNoMultiprong && xTau.nTracks() != 1)
156  {
157  dEfficiencyScaleFactor = 1.;
158  return CP::CorrectionCode::Ok;
159  }
160 
161  // get decay mode or prong extension for histogram name
162  std::string sMode;
164  {
165  int iDecayMode = -1;
167  sMode = ConvertDecayModeToString(iDecayMode);
168  if (sMode.empty())
169  {
170  ATH_MSG_WARNING("Found tau with unknown decay mode. Skip efficiency correction.");
172  }
173  }
174  else
175  {
176  // skip taus which are not 1 or 3 prong
177  if( xTau.nTracks() != 1 && xTau.nTracks() != 3) {
178  dEfficiencyScaleFactor = 1.;
179  return CP::CorrectionCode::Ok;
180  }
181 
182  sMode = ConvertProngToString(xTau.nTracks());
183  }
184 
185  std::string sHistName;
186  if(m_doTauTrig){
187  sHistName = "sf_all_"+m_sWP+sMode;
188  } else {
189  sHistName = m_sSFHistName + sMode;
190  }
191 
192  // get standard scale factor
193  CP::CorrectionCode tmpCorrectionCode = getValue(sHistName,
194  xTau,
195  dEfficiencyScaleFactor);
196  // return correction code if histogram is not available
197  if (tmpCorrectionCode != CP::CorrectionCode::Ok)
198  return tmpCorrectionCode;
199 
200  // skip further process if systematic set is empty
201  if (m_sSystematicSet->empty())
202  return CP::CorrectionCode::Ok;
203 
204  // get uncertainties summed in quadrature
205  double dTotalSystematic2 = 0.;
206  double dDirection = 0.;
207  for (auto syst : *m_sSystematicSet)
208  {
209  // check if systematic is available
210  auto it = m_mSystematicsHistNames.find(syst.basename());
211 
212  // get uncertainty value
213  double dUncertaintySyst = 0.;
214 
215  // needed for up/down decision
216  dDirection = syst.parameter();
217 
218  // build up histogram name
219  sHistName = it->second;
220  if (dDirection>0.) sHistName+="_up";
221  else sHistName+="_down";
222 
223  if(m_doTauTrig){ sHistName+="_all"; }
224 
225  if (!m_sWP.empty()) sHistName+="_"+m_sWP;
226  sHistName += sMode;
227 
228 
229  // filter unwanted combinations
230  if( (sHistName.find("3P") != std::string::npos && sHistName.find("1p") != std::string::npos) ||
231  (sHistName.find("1P") != std::string::npos && sHistName.find("3p") != std::string::npos))
232  continue;
233 
234  if( (sHistName.find("1520") != std::string::npos && sHistName.find("loose") != std::string::npos) ){
235  continue;
236  }
237 
238  // get the uncertainty from the histogram
239  tmpCorrectionCode = getValue(sHistName,
240  xTau,
241  dUncertaintySyst);
242 
243  // return correction code if histogram is not available
244  if (tmpCorrectionCode != CP::CorrectionCode::Ok)
245  return tmpCorrectionCode;
246 
247  // scale uncertainty with direction, i.e. +/- n*sigma
248  dUncertaintySyst *= dDirection;
249 
250  // square uncertainty and add to total uncertainty
251  dTotalSystematic2 += dUncertaintySyst * dUncertaintySyst;
252  }
253 
254  // now use dDirection to use up/down uncertainty
255  dDirection = (dDirection > 0.) ? 1. : -1.;
256 
257  // finally apply uncertainty (eff * ( 1 +/- \sum )
258  dEfficiencyScaleFactor *= 1. + dDirection * std::sqrt(dTotalSystematic2);
259 
260  return CP::CorrectionCode::Ok;
261 }

◆ 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
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::TEvent, 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  }

◆ 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
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::TEvent, 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.

◆ getValue() [1/3]

CP::CorrectionCode CommonDiTauEfficiencyTool::getValue ( const std::string &  sHistName,
const xAOD::DiTauJet xDiTau,
double &  dEfficiencyScaleFactor 
) const

Get the scale factor from a particular recommendations histogram.

Parameters
sHistName
xDiTau
dEfficiencyScaleFactor
Returns
CP::CorrectionCode

Definition at line 292 of file CommonDiTauEfficiencyTool.cxx.

295 {
296  const tSFMAP& mSF = *m_mSF;
297  auto it = mSF.find (sHistName);
298  if (it == mSF.end())
299  {
300  ATH_MSG_ERROR("Object with name "<<sHistName<<" was not found in input file.");
301  ATH_MSG_DEBUG("Content of input file");
302  for (auto eEntry : mSF)
303  ATH_MSG_DEBUG(" Entry: "<<eEntry.first);
305  }
306 
307  // get a tuple (TObject*,functionPointer) from the scale factor map
308  tTupleObjectFunc tTuple = it->second;
309 
310  // get pt and eta (for x and y axis respectively)
311  double dX = m_fXDiTau(xDiTau);
312  double dY = m_fYDiTau(xDiTau);
313  double dZ = m_fZDiTau(xDiTau);
314 
315  double dVars[3] = {dX, dY, dZ};
316  // finally obtain efficiency scale factor from TH1F/TH1D/TF1, by calling the
317  // function pointer stored in the tuple from the scale factor map
318  return (std::get<1>(tTuple))(std::get<0>(tTuple), dEfficiencyScaleFactor, dVars);
319 }

◆ getValue() [2/3]

CP::CorrectionCode CommonEfficiencyTool::getValue

Definition at line 109 of file CommonEfficiencyTool.cxx.

648 {
649  const tSFMAP& mSF = *m_mSF;
650  auto it = mSF.find (sHistName);
651  if (it == mSF.end())
652  {
653  ATH_MSG_ERROR("Object with name "<<sHistName<<" was not found in input file.");
654  ATH_MSG_DEBUG("Content of input file");
655  for (auto eEntry : mSF)
656  ATH_MSG_DEBUG(" Entry: "<<eEntry.first);
658  }
659 
660  // get a tuple (TObject*,functionPointer) from the scale factor map
661  tTupleObjectFunc tTuple = it->second;
662 
663  // get pt and eta (for x and y axis respectively)
664  double dPt = m_fX(xTau);
665  double dEta = m_fY(xTau);
666 
667  double dVars[2] = {dPt, dEta};
668 
669  // finally obtain efficiency scale factor from TH1F/TH1D/TF1, by calling the
670  // function pointer stored in the tuple from the scale factor map
671  return (std::get<1>(tTuple))(std::get<0>(tTuple), dEfficiencyScaleFactor, dVars);
672 }

◆ getValue() [3/3]

CP::CorrectionCode CommonEfficiencyTool::getValue ( const std::string &  sHistName,
const xAOD::TauJet xTau,
double &  dEfficiencyScaleFactor 
) const
protectedvirtualinherited

Definition at line 645 of file CommonEfficiencyTool.cxx.

648 {
649  const tSFMAP& mSF = *m_mSF;
650  auto it = mSF.find (sHistName);
651  if (it == mSF.end())
652  {
653  ATH_MSG_ERROR("Object with name "<<sHistName<<" was not found in input file.");
654  ATH_MSG_DEBUG("Content of input file");
655  for (auto eEntry : mSF)
656  ATH_MSG_DEBUG(" Entry: "<<eEntry.first);
658  }
659 
660  // get a tuple (TObject*,functionPointer) from the scale factor map
661  tTupleObjectFunc tTuple = it->second;
662 
663  // get pt and eta (for x and y axis respectively)
664  double dPt = m_fX(xTau);
665  double dEta = m_fY(xTau);
666 
667  double dVars[2] = {dPt, dEta};
668 
669  // finally obtain efficiency scale factor from TH1F/TH1D/TF1, by calling the
670  // function pointer stored in the tuple from the scale factor map
671  return (std::get<1>(tTuple))(std::get<0>(tTuple), dEfficiencyScaleFactor, dVars);
672 }

◆ getValueTF1()

CP::CorrectionCode CommonEfficiencyTool::getValueTF1 ( const TObject *  oObject,
double &  dEfficiencyScaleFactor,
double  dVars[] 
)
staticprotectedinherited

Definition at line 742 of file CommonEfficiencyTool.cxx.

744 {
745  double dPt = dVars[0];
746  double dEta = dVars[1];
747 
748  const TF1* fFunc = static_cast<const TF1*>(oObject);
749 
750  if (!fFunc)
751  {
752  // ATH_MSG_ERROR("Problem with casting TObject of type "<<oObject->ClassName()<<" to TF1");
754  }
755 
756  // evaluate TFunction and set scale factor
757  dEfficiencyScaleFactor = fFunc->Eval(dPt, dEta);
758  return CP::CorrectionCode::Ok;
759 }

◆ getValueTH1()

CP::CorrectionCode CommonEfficiencyTool::getValueTH1 ( const TObject *  oObject,
double &  dEfficiencyScaleFactor,
double  dVars[] 
)
staticprotectedinherited

Definition at line 680 of file CommonEfficiencyTool.cxx.

682 {
683  double dPt = dVars[0];
684 
685  const TH1* hHist = dynamic_cast<const TH1*>(oObject);
686 
687  if (!hHist)
688  {
689  // ATH_MSG_ERROR("Problem with casting TObject of type "<<oObject->ClassName()<<" to TH2F");
691  }
692 
693  // protect values from underflow bins
694  dPt = std::max(dPt,hHist->GetXaxis()->GetXmin());
695  // protect values from overflow bins (times .999 to keep it inside last bin)
696  dPt = std::min(dPt,hHist->GetXaxis()->GetXmax() * .999);
697 
698  // get bin from TH2 depending on x and y values; finally set the scale factor
699  int iBin = hHist->FindFixBin(dPt);
700  dEfficiencyScaleFactor = hHist->GetBinContent(iBin);
701  return CP::CorrectionCode::Ok;
702 }

◆ getValueTH2()

CP::CorrectionCode CommonEfficiencyTool::getValueTH2 ( const TObject *  oObject,
double &  dEfficiencyScaleFactor,
double  dVars[] 
)
staticprotectedinherited

Definition at line 710 of file CommonEfficiencyTool.cxx.

712 {
713  double dPt = dVars[0];
714  double dEta = dVars[1];
715 
716  const TH2* hHist = dynamic_cast<const TH2*>(oObject);
717 
718  if (!hHist)
719  {
720  // ATH_MSG_ERROR("Problem with casting TObject of type "<<oObject->ClassName()<<" to TH2F");
722  }
723 
724  // protect values from underflow bins
725  dPt = std::max(dPt,hHist->GetXaxis()->GetXmin());
726  dEta = std::max(dEta,hHist->GetYaxis()->GetXmin());
727  // protect values from overflow bins (times .999 to keep it inside last bin)
728  dPt = std::min(dPt,hHist->GetXaxis()->GetXmax() * .999);
729  dEta = std::min(dEta,hHist->GetYaxis()->GetXmax() * .999);
730 
731  // get bin from TH2 depending on x and y values; finally set the scale factor
732  int iBin = hHist->FindFixBin(dPt,dEta);
733  dEfficiencyScaleFactor = hHist->GetBinContent(iBin);
734  return CP::CorrectionCode::Ok;
735 }

◆ initialize()

StatusCode CommonDiTauEfficiencyTool::initialize ( )
overridevirtual

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 TauAnalysisTools::CommonEfficiencyTool.

Definition at line 43 of file CommonDiTauEfficiencyTool.cxx.

44 {
45  ATH_MSG_INFO( "Initializing CommonDiTauEfficiencyTool" );
46  // only read in histograms once
47  if (m_mSF==nullptr)
48  {
49  std::string sInputFilePath = PathResolverFindCalibFile(m_sInputFilePath);
50 
51  m_mSF = std::make_unique< tSFMAP >();
52  std::unique_ptr< TFile > fSF( TFile::Open( sInputFilePath.c_str(), "READ" ) );
53  if(!fSF)
54  {
55  ATH_MSG_FATAL("Could not open file " << sInputFilePath.c_str());
56  return StatusCode::FAILURE;
57  }
58  ReadInputs(fSF);
59  fSF->Close();
60  }
61 
62  // needed later on in generateSystematicSets(), maybe move it there
63  std::vector<std::string> vInputFilePath;
64  split(m_sInputFilePath,'/',vInputFilePath);
65  m_sInputFileName = vInputFilePath.back();
66 
68 
69  if (m_sWP.size()>0)
70  m_sSFHistName = "sf_"+m_sWP;
71 
72  // load empty systematic variation by default
73  if (applySystematicVariation(CP::SystematicSet()) != StatusCode::SUCCESS )
74  return StatusCode::FAILURE;
75 
76  return StatusCode::SUCCESS;
77 }

◆ 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 CommonEfficiencyTool::isAffectedBySystematic ( const CP::SystematicVariation systematic) const
virtualinherited

returns: whether this tool is affected by the given systematics

Implements CP::ISystematicsTool.

Definition at line 304 of file CommonEfficiencyTool.cxx.

305 {
307  return sys.find(systematic) != sys.end();
308 }

◆ isSupportedRunNumber()

virtual bool TauAnalysisTools::CommonEfficiencyTool::isSupportedRunNumber ( int  iRunNumber) const
inlinevirtualinherited

check if run number is supported in recommendations

Implements TauAnalysisTools::ITauEfficiencyCorrectionsTool.

Definition at line 74 of file CommonEfficiencyTool.h.

75  {
76  return true;
77  };

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

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

◆ 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() [1/2]

void asg::AsgTool::print ( ) const
virtualinherited

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const
pure virtualinherited

◆ ReadInputs() [1/2]

void CommonEfficiencyTool::ReadInputs ( const TFile &  fFile)
protectedinherited

Definition at line 429 of file CommonEfficiencyTool.cxx.

430 {
431  m_mSF->clear();
432 
433  // initialize function pointer
434  m_fX = &finalTauPt;
435  m_fY = &finalTauEta;
436 
437  TKey *kKey;
438  TIter itNext(fFile.GetListOfKeys());
439  while ((kKey = (TKey*)itNext()))
440  {
441  // parse file content for objects of type TNamed, check their title for
442  // known strings and reset funtion pointer
443  std::string sKeyName = kKey->GetName();
444  if (sKeyName == "Xaxis")
445  {
446  TNamed* tObj = (TNamed*)kKey->ReadObj();
447  std::string sTitle = tObj->GetTitle();
448  delete tObj;
449  if (sTitle == "P" || sTitle == "PFinalCalib")
450  {
451  m_fX = &finalTauP;
452  ATH_MSG_DEBUG("using full momentum for x-axis");
453  }
454  if (sTitle == "TruthDecayMode")
455  {
456  m_fX = &truthDecayMode;
457  ATH_MSG_DEBUG("using truth decay mode for x-axis");
458  }
459  if (sTitle == "truth pt")
460  {
461  m_fX = &truthTauPt;
462  ATH_MSG_DEBUG("using truth pT for x-axis");
463  }
464  if (sTitle == "|eta|")
465  {
466  m_fX = &finalTauAbsEta;
467  ATH_MSG_DEBUG("using absolute tau eta for x-axis");
468  }
469 
470  continue;
471  }
472  else if (sKeyName == "Yaxis")
473  {
474  TNamed* tObj = (TNamed*)kKey->ReadObj();
475  std::string sTitle = tObj->GetTitle();
476  delete tObj;
477  if (sTitle == "track-eta")
478  {
480  ATH_MSG_DEBUG("using leading track eta for y-axis");
481  }
482  else if (sTitle == "|eta|")
483  {
484  m_fY = &finalTauAbsEta;
485  ATH_MSG_DEBUG("using absolute tau eta for y-axis");
486  }
487  else if (sTitle == "mu")
488  {
489  m_fY = [this](const xAOD::TauJet&) -> double {
490  const xAOD::EventInfo* xEventInfo = nullptr;
491  if (evtStore()->retrieve(xEventInfo,"EventInfo").isFailure()) {
492  return 0;
493  }
494  if (xEventInfo->runNumber()==284500)
495  {
496  return xEventInfo->averageInteractionsPerCrossing();
497  }
498  else if (xEventInfo->runNumber()==300000 || xEventInfo->runNumber()==310000)
499  {
500  return xEventInfo->actualInteractionsPerCrossing();
501  }
502  return 0;
503  };
504  ATH_MSG_DEBUG("using average mu for y-axis");
505  }
506  else if (sTitle == "truth |eta|")
507  {
508  m_fY = &truthTauAbsEta;
509  ATH_MSG_DEBUG("using absolute truth tau eta for y-axis");
510  }
511  continue;
512  }
513 
514  std::vector<std::string> vSplitName = {};
515  split(sKeyName,'_',vSplitName);
516  if (vSplitName[0] == "sf")
517  {
518  addHistogramToSFMap(kKey, sKeyName);
519  }
520  else
521  {
522  // std::string sDirection = vSplitName[1];
523  if (sKeyName.find("_up_") != std::string::npos or sKeyName.find("_down_") != std::string::npos)
524  addHistogramToSFMap(kKey, sKeyName);
525  else
526  {
527  size_t iPos = sKeyName.find('_');
528  addHistogramToSFMap(kKey, sKeyName.substr(0,iPos)+"_up"+sKeyName.substr(iPos));
529  addHistogramToSFMap(kKey, sKeyName.substr(0,iPos)+"_down"+sKeyName.substr(iPos));
530  }
531  }
532  }
533  ATH_MSG_INFO("data loaded from " << fFile.GetName());
534 }

◆ ReadInputs() [2/2]

void CommonDiTauEfficiencyTool::ReadInputs ( std::unique_ptr< TFile > &  fFile)

Definition at line 191 of file CommonDiTauEfficiencyTool.cxx.

192 {
193  m_mSF->clear();
194 
195  // initialize function pointer
199 
200  TKey *kKey;
201  TIter itNext(fFile->GetListOfKeys());
202  while ((kKey = (TKey*)itNext()))
203  {
204  // parse file content for objects of type TNamed, check their title for
205  // known strings and reset funtion pointer
206  std::string sKeyName = kKey->GetName();
207 
208  std::vector<std::string> vSplitName = {};
209  split(sKeyName,'_',vSplitName);
210  if (vSplitName[0] == "sf")
211  {
212  addHistogramToSFMap(kKey, sKeyName);
213  }
214  else
215  {
216  if (sKeyName.find("_up_") != std::string::npos or sKeyName.find("_down_") != std::string::npos)
217  addHistogramToSFMap(kKey, sKeyName);
218  else
219  {
220  size_t iPos = sKeyName.find('_');
221  addHistogramToSFMap(kKey, sKeyName.substr(0,iPos)+"_up"+sKeyName.substr(iPos));
222  addHistogramToSFMap(kKey, sKeyName.substr(0,iPos)+"_down"+sKeyName.substr(iPos));
223  }
224  }
225  }
226  ATH_MSG_INFO("data loaded from " << fFile->GetName());
227 }

◆ recommendedSystematics()

CP::SystematicSet CommonEfficiencyTool::recommendedSystematics ( ) const
virtualinherited

returns: the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 324 of file CommonEfficiencyTool.cxx.

325 {
327 }

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_bNoMultiprong

bool TauAnalysisTools::CommonEfficiencyTool::m_bNoMultiprong
protectedinherited

Definition at line 144 of file CommonEfficiencyTool.h.

◆ m_bSFIsAvailable

bool TauAnalysisTools::CommonEfficiencyTool::m_bSFIsAvailable
protectedinherited

Definition at line 148 of file CommonEfficiencyTool.h.

◆ m_bSFIsAvailableChecked

bool TauAnalysisTools::CommonEfficiencyTool::m_bSFIsAvailableChecked
protectedinherited

Definition at line 149 of file CommonEfficiencyTool.h.

◆ m_bSFIsAvailableCheckedDiTau

bool TauAnalysisTools::CommonDiTauEfficiencyTool::m_bSFIsAvailableCheckedDiTau

true if cale factor name is already decorated has already been checked

Definition at line 101 of file CommonDiTauEfficiencyTool.h.

◆ m_bSFIsAvailableDiTau

bool TauAnalysisTools::CommonDiTauEfficiencyTool::m_bSFIsAvailableDiTau

true if scale factor name is already decorated

Definition at line 99 of file CommonDiTauEfficiencyTool.h.

◆ m_bSkipTruthMatchCheck

Gaudi::Property<bool> TauAnalysisTools::CommonEfficiencyTool::m_bSkipTruthMatchCheck {this, "SkipTruthMatchCheck", false}
protectedinherited

Definition at line 136 of file CommonEfficiencyTool.h.

◆ m_bUseTauSubstructure

Gaudi::Property<bool> TauAnalysisTools::CommonEfficiencyTool::m_bUseTauSubstructure {this, "UseTauSubstructure", false}
protectedinherited

Definition at line 139 of file CommonEfficiencyTool.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_doTauTrig

Gaudi::Property<bool> TauAnalysisTools::CommonEfficiencyTool::m_doTauTrig {this, "DoTauTrig", false}
protectedinherited

Definition at line 140 of file CommonEfficiencyTool.h.

◆ m_eCheckTruth

TruthMatchedParticleType TauAnalysisTools::CommonEfficiencyTool::m_eCheckTruth
protectedinherited

Definition at line 146 of file CommonEfficiencyTool.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_fX

std::function<double(const xAOD::TauJet& xTau)> TauAnalysisTools::CommonEfficiencyTool::m_fX
protectedinherited

Definition at line 103 of file CommonEfficiencyTool.h.

◆ m_fXDiTau

double(* TauAnalysisTools::CommonDiTauEfficiencyTool::m_fXDiTau) (const xAOD::DiTauJet &xDiTau)

scale factor bin x (e.g.

lead match pT)

Definition at line 75 of file CommonDiTauEfficiencyTool.h.

◆ m_fY

std::function<double(const xAOD::TauJet& xTau)> TauAnalysisTools::CommonEfficiencyTool::m_fY
protectedinherited

Definition at line 104 of file CommonEfficiencyTool.h.

◆ m_fYDiTau

double(* TauAnalysisTools::CommonDiTauEfficiencyTool::m_fYDiTau) (const xAOD::DiTauJet &xDiTau)

scale factor bin y (e.g.

sublead match pT)

Definition at line 77 of file CommonDiTauEfficiencyTool.h.

◆ m_fZDiTau

double(* TauAnalysisTools::CommonDiTauEfficiencyTool::m_fZDiTau) (const xAOD::DiTauJet &xDiTau)

scale factor bin z (e.g.

dR match particles)

Definition at line 79 of file CommonDiTauEfficiencyTool.h.

◆ m_iEleIDLevel

Gaudi::Property<int> TauAnalysisTools::CommonEfficiencyTool::m_iEleIDLevel {this, "EleIDLevel", static_cast<int>(ELEIDNONE)}
protectedinherited

Definition at line 138 of file CommonEfficiencyTool.h.

◆ m_iJetIDLevel

Gaudi::Property<int> TauAnalysisTools::CommonEfficiencyTool::m_iJetIDLevel {this, "JetIDLevel", static_cast<int>(JETIDNONE)}
protectedinherited

Definition at line 137 of file CommonEfficiencyTool.h.

◆ m_mSF

std::unique_ptr< tSFMAP > TauAnalysisTools::CommonEfficiencyTool::m_mSF
protectedinherited

Definition at line 95 of file CommonEfficiencyTool.h.

◆ m_mSystematics

std::map<std::string, int> TauAnalysisTools::CommonEfficiencyTool::m_mSystematics
protectedinherited

Definition at line 100 of file CommonEfficiencyTool.h.

◆ m_mSystematicSets

std::unordered_map< CP::SystematicSet, std::string > TauAnalysisTools::CommonEfficiencyTool::m_mSystematicSets
protectedinherited

Definition at line 98 of file CommonEfficiencyTool.h.

◆ m_mSystematicsHistNames

std::map<std::string, std::string> TauAnalysisTools::CommonEfficiencyTool::m_mSystematicsHistNames
protectedinherited

Definition at line 101 of file CommonEfficiencyTool.h.

◆ m_sAffectingSystematics

CP::SystematicSet TauAnalysisTools::CommonEfficiencyTool::m_sAffectingSystematics
protectedinherited

Definition at line 130 of file CommonEfficiencyTool.h.

◆ m_sInputFileName

std::string TauAnalysisTools::CommonEfficiencyTool::m_sInputFileName
protectedinherited

Definition at line 142 of file CommonEfficiencyTool.h.

◆ m_sInputFilePath

Gaudi::Property<std::string> TauAnalysisTools::CommonEfficiencyTool::m_sInputFilePath {this, "InputFilePath", ""}
protectedinherited

Definition at line 133 of file CommonEfficiencyTool.h.

◆ m_sRecommendedSystematics

CP::SystematicSet TauAnalysisTools::CommonEfficiencyTool::m_sRecommendedSystematics
protectedinherited

Definition at line 131 of file CommonEfficiencyTool.h.

◆ m_sSFHistName

std::string TauAnalysisTools::CommonEfficiencyTool::m_sSFHistName
protectedinherited

Definition at line 143 of file CommonEfficiencyTool.h.

◆ m_sSystematicSet

const CP::SystematicSet* TauAnalysisTools::CommonEfficiencyTool::m_sSystematicSet
protectedinherited

Definition at line 99 of file CommonEfficiencyTool.h.

◆ m_sVarName

Gaudi::Property<std::string> TauAnalysisTools::CommonEfficiencyTool::m_sVarName {this, "VarName", ""}
protectedinherited

Definition at line 134 of file CommonEfficiencyTool.h.

◆ m_sWP

Gaudi::Property<std::string> TauAnalysisTools::CommonEfficiencyTool::m_sWP {this, "WP", ""}
protectedinherited

Definition at line 135 of file CommonEfficiencyTool.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:
TauAnalysisTools::CommonEfficiencyTool::getEfficiencyScaleFactor
virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::TauJet &tau, double &dEfficiencyScaleFactor, unsigned int iRunNumber=0)
Declare the interface that the class provides.
Definition: CommonEfficiencyTool.cxx:144
xAOD::TauJetParameters::Mode_1p0n
@ Mode_1p0n
Definition: TauDefs.h:386
xAOD::TauJetParameters::PanTau_DecayMode
@ PanTau_DecayMode
Definition: TauDefs.h:360
TauAnalysisTools::CommonEfficiencyTool::m_eCheckTruth
TruthMatchedParticleType m_eCheckTruth
Definition: CommonEfficiencyTool.h:146
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::TauJetParameters::Mode_1p1n
@ Mode_1p1n
Definition: TauDefs.h:387
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
TauAnalysisTools::truthTauAbsEta
double truthTauAbsEta(const xAOD::TauJet &xTau)
return truth match tau eta (if hadronic truth tau match)
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:173
TauAnalysisTools::CommonEfficiencyTool::m_sInputFilePath
Gaudi::Property< std::string > m_sInputFilePath
Definition: CommonEfficiencyTool.h:133
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TauAnalysisTools::CommonDiTauEfficiencyTool::m_fXDiTau
double(* m_fXDiTau)(const xAOD::DiTauJet &xDiTau)
scale factor bin x (e.g.
Definition: CommonDiTauEfficiencyTool.h:75
TauAnalysisTools::TruthSubleadPt
double TruthSubleadPt(const xAOD::DiTauJet &xDiTau)
return the truth vis pT of the subleading pT matched particle.
Definition: CommonDiTauEfficiencyTool.cxx:330
TauAnalysisTools::CommonDiTauEfficiencyTool::generateSystematicSets
void generateSystematicSets()
generate a set of relevant systematic variations to be applied
Definition: CommonDiTauEfficiencyTool.cxx:243
TauAnalysisTools::TruthHadronicTau
@ TruthHadronicTau
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:99
CP::SystematicSet::size
size_t size() const
returns: size of the set
Definition: SystematicSet.h:71
TauAnalysisTools::truthTauPt
double truthTauPt(const xAOD::TauJet &xTau)
return truth match tau pt in GeV (if hadronic truth tau match)
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:159
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
TauAnalysisTools::CommonEfficiencyTool::m_sSystematicSet
const CP::SystematicSet * m_sSystematicSet
Definition: CommonEfficiencyTool.h:99
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
CP::SystematicSet::empty
bool empty() const
returns: whether the set is empty
Definition: SystematicSet.h:67
xAOD::TauJet_v3::nTracks
size_t nTracks(TauJetParameters::TauTrackFlag flag=TauJetParameters::TauTrackFlag::classifiedCharged) const
Definition: TauJet_v3.cxx:488
TauAnalysisTools::CommonDiTauEfficiencyTool::getEfficiencyScaleFactor
virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::DiTauJet &xDiTau, double &dEfficiencyScaleFactor) override
Get the Efficiency Scale Factor of ditau jet.
Definition: CommonDiTauEfficiencyTool.cxx:86
skel.it
it
Definition: skel.GENtoEVGEN.py:407
TauAnalysisTools::CommonEfficiencyTool::ConvertProngToString
std::string ConvertProngToString(const int iProngness) const
Definition: CommonEfficiencyTool.cxx:391
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
TauAnalysisTools::CommonEfficiencyTool::tSFMAP
std::map< std::string, tTupleObjectFunc > tSFMAP
Definition: CommonEfficiencyTool.h:88
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TauAnalysisTools::CommonEfficiencyTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const CP::SystematicSet &sSystematicSet)
configure this tool for the given list of systematic variations.
Definition: CommonEfficiencyTool.cxx:340
TauAnalysisTools::CommonDiTauEfficiencyTool::m_fYDiTau
double(* m_fYDiTau)(const xAOD::DiTauJet &xDiTau)
scale factor bin y (e.g.
Definition: CommonDiTauEfficiencyTool.h:77
xAOD::TauJet_v3::panTauDetail
bool panTauDetail(TauJetParameters::PanTauDetails panTauDetail, int &value) const
Get and set values of pantau details variables via enum.
Definition: TauJet_v3.cxx:339
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
TauAnalysisTools::finalTauPt
double finalTauPt(const xAOD::TauJet &xTau)
return MVA based tau pt in GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:114
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
CP::SystematicVariation
Definition: SystematicVariation.h:47
TauAnalysisTools::CommonEfficiencyTool::tTupleObjectFunc
std::tuple< TObject *, CP::CorrectionCode(*)(const TObject *oObject, double &dEfficiencyScaleFactor, double dVars[]) > tTupleObjectFunc
Definition: CommonEfficiencyTool.h:87
TauAnalysisTools::TruthLeadPt
double TruthLeadPt(const xAOD::DiTauJet &xDiTau)
return the truth vis pT of the leading pT matched particle.
Definition: CommonDiTauEfficiencyTool.cxx:322
mapkey::sys
@ sys
Definition: TElectronEfficiencyCorrectionTool.cxx:42
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
xAOD::TauJetParameters::Mode_1pXn
@ Mode_1pXn
Definition: TauDefs.h:388
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
TauAnalysisTools::CommonEfficiencyTool::m_mSystematicSets
std::unordered_map< CP::SystematicSet, std::string > m_mSystematicSets
Definition: CommonEfficiencyTool.h:98
TauAnalysisTools::finalTauP
double finalTauP(const xAOD::TauJet &xTau)
return MVA based tau P in GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:135
TauAnalysisTools::CommonEfficiencyTool::getValue
virtual CP::CorrectionCode getValue(const std::string &sHistName, const xAOD::TauJet &xTau, double &dEfficiencyScaleFactor) const
Definition: CommonEfficiencyTool.cxx:645
CP::CorrectionCode::OutOfValidityRange
@ OutOfValidityRange
Input object is out of validity range.
Definition: CorrectionCode.h:37
TauAnalysisTools::truthDecayMode
double truthDecayMode(const xAOD::TauJet &xTau)
return truth decay mode (if hadronic truth tau match)
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:187
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition: CorrectionCode.h:36
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:59
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
TauAnalysisTools::CommonEfficiencyTool::m_mSF
std::unique_ptr< tSFMAP > m_mSF
Definition: CommonEfficiencyTool.h:95
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
TauAnalysisTools::CommonDiTauEfficiencyTool::ReadInputs
void ReadInputs(std::unique_ptr< TFile > &fFile)
Definition: CommonDiTauEfficiencyTool.cxx:191
CP::SystematicSet::end
const_iterator end() const
description: const iterator to the end of the set
Definition: SystematicSet.h:59
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
TauAnalysisTools::CommonEfficiencyTool::m_sVarName
Gaudi::Property< std::string > m_sVarName
Definition: CommonEfficiencyTool.h:134
TauAnalysisTools::CommonEfficiencyTool::m_fX
std::function< double(const xAOD::TauJet &xTau)> m_fX
Definition: CommonEfficiencyTool.h:103
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TauAnalysisTools::CommonEfficiencyTool::m_bSFIsAvailable
bool m_bSFIsAvailable
Definition: CommonEfficiencyTool.h:148
TauAnalysisTools::CommonEfficiencyTool::getValueTH2
static CP::CorrectionCode getValueTH2(const TObject *oObject, double &dEfficiencyScaleFactor, double dVars[])
Definition: CommonEfficiencyTool.cxx:710
xAOD::TauJetParameters::Mode_3p0n
@ Mode_3p0n
Definition: TauDefs.h:389
TauAnalysisTools::CommonEfficiencyTool::m_sSFHistName
std::string m_sSFHistName
Definition: CommonEfficiencyTool.h:143
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::EventInfo_v1::averageInteractionsPerCrossing
float averageInteractionsPerCrossing() const
Average interactions per crossing for all BCIDs - for out-of-time pile-up.
Definition: EventInfo_v1.cxx:397
TauAnalysisTools::TruthDeltaR
double TruthDeltaR(const xAOD::DiTauJet &xDiTau)
return the dR of between the leading and subleading pT matched particle.
Definition: CommonDiTauEfficiencyTool.cxx:338
TauAnalysisTools::CommonEfficiencyTool::m_sAffectingSystematics
CP::SystematicSet m_sAffectingSystematics
Definition: CommonEfficiencyTool.h:130
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
CP::SystematicSet::insert
void insert(const SystematicVariation &systematic)
description: insert a systematic into the set
Definition: SystematicSet.cxx:88
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TauAnalysisTools::CommonEfficiencyTool::m_fY
std::function< double(const xAOD::TauJet &xTau)> m_fY
Definition: CommonEfficiencyTool.h:104
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TauAnalysisTools::CommonDiTauEfficiencyTool::m_bSFIsAvailableDiTau
bool m_bSFIsAvailableDiTau
true if scale factor name is already decorated
Definition: CommonDiTauEfficiencyTool.h:99
TauAnalysisTools::CommonEfficiencyTool::addHistogramToSFMap
void addHistogramToSFMap(TKey *kKey, const std::string &sKeyName)
Definition: CommonEfficiencyTool.cxx:540
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
CP::SystematicSet::find
iterator find(const SystematicVariation &sys) const
description: find an element in the set
Definition: SystematicSet.h:63
TauAnalysisTools::CommonDiTauEfficiencyTool::m_fZDiTau
double(* m_fZDiTau)(const xAOD::DiTauJet &xDiTau)
scale factor bin z (e.g.
Definition: CommonDiTauEfficiencyTool.h:79
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition: CorrectionCode.h:38
a
TList * a
Definition: liststreamerinfos.cxx:10
TauAnalysisTools::CommonEfficiencyTool::m_sWP
Gaudi::Property< std::string > m_sWP
Definition: CommonEfficiencyTool.h:135
h
TauAnalysisTools::finalTauAbsEta
double finalTauAbsEta(const xAOD::TauJet &xTau)
return MVA based absolute tau eta
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:128
TauAnalysisTools::CommonEfficiencyTool::m_bSFIsAvailableChecked
bool m_bSFIsAvailableChecked
Definition: CommonEfficiencyTool.h:149
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TauAnalysisTools::CommonEfficiencyTool::CommonEfficiencyTool
CommonEfficiencyTool(const std::string &sName)
Create a proper constructor for Athena.
Definition: CommonEfficiencyTool.cxx:71
TauAnalysisTools::CommonEfficiencyTool::m_bUseTauSubstructure
Gaudi::Property< bool > m_bUseTauSubstructure
Definition: CommonEfficiencyTool.h:139
TauAnalysisTools::tauLeadTrackEta
double tauLeadTrackEta(const xAOD::TauJet &xTau)
return leading charge tau track eta
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:142
TauAnalysisTools::CommonEfficiencyTool::ConvertDecayModeToString
std::string ConvertDecayModeToString(const int iDecayMode) const
Definition: CommonEfficiencyTool.cxx:400
TauAnalysisTools::getTruthParticleType
TruthMatchedParticleType getTruthParticleType(const xAOD::TauJet &xTau)
return TauJet match type
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:494
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CP::CorrectionCode
Return value from object correction CP tools.
Definition: CorrectionCode.h:31
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
xAOD::TauJetParameters::Mode_3pXn
@ Mode_3pXn
Definition: TauDefs.h:390
TauAnalysisTools::CommonEfficiencyTool::m_doTauTrig
Gaudi::Property< bool > m_doTauTrig
Definition: CommonEfficiencyTool.h:140
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
TauAnalysisTools::CommonDiTauEfficiencyTool::m_bSFIsAvailableCheckedDiTau
bool m_bSFIsAvailableCheckedDiTau
true if cale factor name is already decorated has already been checked
Definition: CommonDiTauEfficiencyTool.h:101
TauAnalysisTools::CommonEfficiencyTool::m_bNoMultiprong
bool m_bNoMultiprong
Definition: CommonEfficiencyTool.h:144
TauGNNUtils::Variables::Track::dEta
bool dEta(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:538
TauAnalysisTools::CommonEfficiencyTool::m_sInputFileName
std::string m_sInputFileName
Definition: CommonEfficiencyTool.h:142
SG::DataProxy
Definition: DataProxy.h:45
TauAnalysisTools::CommonEfficiencyTool::affectingSystematics
virtual CP::SystematicSet affectingSystematics() const
returns: the list of all systematics this tool can be affected by
Definition: CommonEfficiencyTool.cxx:315
TauAnalysisTools::CommonEfficiencyTool::m_mSystematicsHistNames
std::map< std::string, std::string > m_mSystematicsHistNames
Definition: CommonEfficiencyTool.h:101
TauAnalysisTools::CommonEfficiencyTool::getValueTH1
static CP::CorrectionCode getValueTH1(const TObject *oObject, double &dEfficiencyScaleFactor, double dVars[])
Definition: CommonEfficiencyTool.cxx:680
TauAnalysisTools::TruthHadronicDiTau
@ TruthHadronicDiTau
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:104
TauAnalysisTools::CommonEfficiencyTool::getValueTF1
static CP::CorrectionCode getValueTF1(const TObject *oObject, double &dEfficiencyScaleFactor, double dVars[])
Definition: CommonEfficiencyTool.cxx:742
TauAnalysisTools::CommonEfficiencyTool::m_sRecommendedSystematics
CP::SystematicSet m_sRecommendedSystematics
Definition: CommonEfficiencyTool.h:131
TauAnalysisTools::finalTauEta
double finalTauEta(const xAOD::TauJet &xTau)
return MVA based tau eta
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:121
fitman.k
k
Definition: fitman.py:528
xAOD::EventInfo_v1::actualInteractionsPerCrossing
float actualInteractionsPerCrossing() const
Average interactions per crossing for the current BCID - for in-time pile-up.
Definition: EventInfo_v1.cxx:380
TauAnalysisTools::CommonDiTauEfficiencyTool::getValue
CP::CorrectionCode getValue(const std::string &sHistName, const xAOD::DiTauJet &xDiTau, double &dEfficiencyScaleFactor) const
Get the scale factor from a particular recommendations histogram.
Definition: CommonDiTauEfficiencyTool.cxx:292
TauAnalysisTools::CommonEfficiencyTool::m_bSkipTruthMatchCheck
Gaudi::Property< bool > m_bSkipTruthMatchCheck
Definition: CommonEfficiencyTool.h:136
TauAnalysisTools::split
void split(const std::string &sInput, const char cDelim, std::vector< std::string > &vOut)
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:24