ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
top::ElectronScaleFactorCalculator Class Referencefinal

#include <ElectronScaleFactorCalculator.h>

Inheritance diagram for top::ElectronScaleFactorCalculator:
Collaboration diagram for top::ElectronScaleFactorCalculator:

Public Member Functions

 ElectronScaleFactorCalculator (const std::string &name)
 
virtual ~ElectronScaleFactorCalculator ()
 
 ElectronScaleFactorCalculator (const ElectronScaleFactorCalculator &rhs)=delete
 
 ElectronScaleFactorCalculator (ElectronScaleFactorCalculator &&rhs)=delete
 
ElectronScaleFactorCalculator & operator= (const ElectronScaleFactorCalculator &rhs)=delete
 
StatusCode initialize ()
 Dummy implementation of the initialisation function. More...
 
StatusCode execute ()
 
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 > &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
 

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

Private Attributes

std::shared_ptr< top::TopConfig > m_config
 
CP::SystematicSet m_systNominal
 
CP::SystematicSet m_systTrigger_UP
 
CP::SystematicSet m_systTrigger_DOWN
 
CP::SystematicSet m_systReco_UP
 
CP::SystematicSet m_systReco_DOWN
 
CP::SystematicSet m_systID_UP
 
CP::SystematicSet m_systID_DOWN
 
CP::SystematicSet m_systIso_UP
 
CP::SystematicSet m_systIso_DOWN
 
CP::SystematicSet m_systChargeID_UP
 
CP::SystematicSet m_systChargeID_DOWN
 
CP::SystematicSet m_systChargeMisID_STAT_UP
 
CP::SystematicSet m_systChargeMisID_STAT_DOWN
 
CP::SystematicSet m_systChargeMisID_SYST_UP
 
CP::SystematicSet m_systChargeMisID_SYST_DOWN
 
std::vector< CP::SystematicSet > m_systTriggerCorrModel
 
std::vector< CP::SystematicSet > m_systRecoCorrModel
 
std::vector< CP::SystematicSet > m_systIDCorrModel
 
std::vector< CP::SystematicSet > m_systIsoCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFTrigger
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFTriggerLoose
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffTrigger
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffTriggerLoose
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFReco
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFID
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIDLoose
 
bool m_electronEffIso_exists
 
bool m_electronEffIsoLoose_exists
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIso
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIsoLoose
 
bool m_electronEffChargeID_exists
 
bool m_electronEffChargeIDLoose_exists
 
bool m_electronEffChargeMisID_exists
 
bool m_electronEffChargeMisIDLoose_exists
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFChargeID
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFChargeIDLoose
 
ToolHandle< CP::ElectronChargeEfficiencyCorrectionTool > m_electronEffSFChargeMisID
 
ToolHandle< CP::ElectronChargeEfficiencyCorrectionTool > m_electronEffSFChargeMisIDLoose
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFTriggerCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFTriggerLooseCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffTriggerCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffTriggerLooseCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFRecoCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIDCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIDLooseCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIsoCorrModel
 
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIsoLooseCorrModel
 
std::string m_decor_triggerEff
 
std::string m_decor_triggerEff_loose
 
std::string m_decor_triggerSF
 
std::string m_decor_triggerSF_loose
 
std::string m_decor_recoSF
 
std::string m_decor_idSF
 
std::string m_decor_idSF_loose
 
std::string m_decor_isoSF
 
std::string m_decor_isoSF_loose
 
std::string m_decor_chargeidSF
 
std::string m_decor_chargeidSF_loose
 
std::string m_decor_chargemisidSF
 
std::string m_decor_chargemisidSF_loose
 
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 42 of file ElectronScaleFactorCalculator.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ElectronScaleFactorCalculator() [1/3]

top::ElectronScaleFactorCalculator::ElectronScaleFactorCalculator ( const std::string &  name)
explicit

Definition at line 15 of file ElectronScaleFactorCalculator.cxx.

15  :
16  asg::AsgTool(name),
17  m_config(nullptr),
18 
19  m_systNominal(CP::SystematicSet()),
20  m_systTrigger_UP(CP::SystematicSet()),
21  m_systTrigger_DOWN(CP::SystematicSet()),
22  m_systReco_UP(CP::SystematicSet()),
23  m_systReco_DOWN(CP::SystematicSet()),
24  m_systID_UP(CP::SystematicSet()),
25  m_systID_DOWN(CP::SystematicSet()),
26  m_systIso_UP(CP::SystematicSet()),
27  m_systIso_DOWN(CP::SystematicSet()),
28  m_systChargeID_UP(CP::SystematicSet()),
29  m_systChargeID_DOWN(CP::SystematicSet()),
30  m_systChargeMisID_STAT_UP(CP::SystematicSet()),
31  m_systChargeMisID_STAT_DOWN(CP::SystematicSet()),
32  m_systChargeMisID_SYST_UP(CP::SystematicSet()),
33  m_systChargeMisID_SYST_DOWN(CP::SystematicSet()),
34 
35  m_electronEffSFTrigger("AsgElectronEfficiencyCorrectionTool_TriggerSF"),
36  m_electronEffSFTriggerLoose("AsgElectronEfficiencyCorrectionTool_TriggerSFLoose"),
37  m_electronEffTrigger("AsgElectronEfficiencyCorrectionTool_Trigger"),
38  m_electronEffTriggerLoose("AsgElectronEfficiencyCorrectionTool_TriggerLoose"),
39  m_electronEffSFReco("AsgElectronEfficiencyCorrectionTool_Reco"),
40  m_electronEffSFID("AsgElectronEfficiencyCorrectionTool_ID"),
41  m_electronEffSFIDLoose("AsgElectronEfficiencyCorrectionTool_IDLoose"),
42  m_electronEffIso_exists(false),
43  m_electronEffIsoLoose_exists(false),
44  m_electronEffSFIso("AsgElectronEfficiencyCorrectionTool_Iso"),
45  m_electronEffSFIsoLoose("AsgElectronEfficiencyCorrectionTool_IsoLoose"),
46  m_electronEffChargeID_exists(false),
47  m_electronEffChargeIDLoose_exists(false),
48  m_electronEffChargeMisID_exists(false),
49  m_electronEffChargeMisIDLoose_exists(false),
50  m_electronEffSFChargeID("AsgElectronEfficiencyCorrectionTool_ChargeID"),
51  m_electronEffSFChargeIDLoose("AsgElectronEfficiencyCorrectionTool_ChargeIDLoose"),
52  m_electronEffSFChargeMisID("ElectronChargeEfficiencyCorrection"),
53  m_electronEffSFChargeMisIDLoose("ElectronChargeEfficiencyCorrectionLoose"),
54 
55  m_electronEffSFTriggerCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_TriggerSF"),
56  m_electronEffSFTriggerLooseCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_TriggerSFLoose"),
57  m_electronEffTriggerCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_Trigger"),
58  m_electronEffTriggerLooseCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_TriggerLoose"),
59  m_electronEffSFRecoCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_Reco"),
60  m_electronEffSFIDCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_ID"),
61  m_electronEffSFIDLooseCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_IDLoose"),
62  m_electronEffSFIsoCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_Iso"),
63  m_electronEffSFIsoLooseCorrModel("AsgElectronEfficiencyCorrectionTool_CorrModel_IsoLoose"),
64 
65  m_decor_triggerEff("SetMe"),
66  m_decor_triggerEff_loose("SetMe"),
67  m_decor_triggerSF("SetMe"),
68  m_decor_triggerSF_loose("SetMe"),
69  m_decor_recoSF("SetMe"),
70  m_decor_idSF("SetMe"),
71  m_decor_idSF_loose("SetMe"),
72  m_decor_isoSF("SetMe"),
73  m_decor_isoSF_loose("SetMe"),
74  m_decor_chargeidSF("SetMe"),
75  m_decor_chargeidSF_loose("SetMe"),
76  m_decor_chargemisidSF("SetMe"),
77  m_decor_chargemisidSF_loose("SetMe") {
78  declareProperty("config", m_config);
79  }

◆ ~ElectronScaleFactorCalculator()

virtual top::ElectronScaleFactorCalculator::~ElectronScaleFactorCalculator ( )
inlinevirtual

Definition at line 45 of file ElectronScaleFactorCalculator.h.

45 {}

◆ ElectronScaleFactorCalculator() [2/3]

top::ElectronScaleFactorCalculator::ElectronScaleFactorCalculator ( const ElectronScaleFactorCalculator &  rhs)
delete

◆ ElectronScaleFactorCalculator() [3/3]

top::ElectronScaleFactorCalculator::ElectronScaleFactorCalculator ( ElectronScaleFactorCalculator &&  rhs)
delete

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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 > &  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 > &  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 > &  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 > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, 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; }

◆ execute()

StatusCode top::ElectronScaleFactorCalculator::execute ( )

– Loop over all electron collections –///

– Tell the SF tools to use the nominal systematic –///

– Loop over all electrons in each collection –///

– Does the electron pass object selection? –///

– Get Efficiencies –///

– Get Scale Factors –///

– Decorate –///

– For nominal calibration, vary the SF systematics –///

– Trigger –/// – Trigger UP –///

– Trigger DOWN –///

– Trigger reset to nominal –///

– Reco –/// – Reco up –///

– Reco down –///

– Reco reset to nominal –///

– ID –/// – ID UP –///

– ID DOWN –///

– ID reset to nominal –///

– Iso –/// – Iso UP –///

– Iso DOWN –///

– Iso reset to nominal –///

– Iso DOWN –///

– Iso reset to nominal –///

– Charge ID –///

– Charge ID UP –///

– Charge ID DOWN –///

– Charge ID reset to nominal –///

– Charge ID UP –///

– Charge ID DOWN –///

– Charge ID reset to nominal –///

– Charge Mis ID –///

– Charge Mis ID STAT_UP –///

– Charge Mis ID STAT_DOWN –///

– Charge Mis ID SYS_UP –///

– Charge Mis ID SYS_DOWN –///

– Charge Mis ID reset to nominal –///

– Charge Mis ID STAT_UP –///

– Charge Mis ID STAT_DOWN –///

– Charge Mis ID SYS_UP –///

– Charge Mis ID SYS_DOWN –///

– Charge Mis ID reset to nominal –///

– Decorate –///

– Debug messages –///

–Trigger– ///

– Trigger reset to nominal –///

–Reco– ///

– Reco reset to nominal –///

–ID– ///

– ID reset to nominal –///

– Iso –///

– Iso reset to nominal –///

– Iso reset to nominal –///

– Decorate –///

–Trigger– ///

– Trigger reset to nominal –///

–Reco– ///

– Reco reset to nominal –///

–ID– ///

– ID reset to nominal –///

– Iso –///

– Iso reset to nominal –///

– Iso reset to nominal –///

– Decorate –///

Definition at line 352 of file ElectronScaleFactorCalculator.cxx.

352  {
354  for (auto currentSystematic : *m_config->systSgKeyMapElectrons()) {
355  const xAOD::ElectronContainer* electrons(nullptr);
356  top::check(evtStore()->retrieve(electrons, currentSystematic.second), "failed to retrieve electrons");
357 
359  top::check(m_electronEffSFTrigger->applySystematicVariation(m_systNominal), "Failed to set systematic");
360  top::check(m_electronEffSFTriggerLoose->applySystematicVariation(m_systNominal), "Failed to set systematic");
361  top::check(m_electronEffSFReco->applySystematicVariation(m_systNominal), "Failed to set systematic");
362  top::check(m_electronEffSFID->applySystematicVariation(m_systNominal), "Failed to set systematic");
363  top::check(m_electronEffSFIDLoose->applySystematicVariation(m_systNominal), "Failed to set systematic");
364  if (m_electronEffIso_exists) top::check(m_electronEffSFIso->applySystematicVariation(
365  m_systNominal), "Failed to set systematic");
366  if (m_electronEffIsoLoose_exists) top::check(m_electronEffSFIsoLoose->applySystematicVariation(
367  m_systNominal), "Failed to set systematic");
368  if (m_electronEffChargeID_exists) top::check(m_electronEffSFChargeID->applySystematicVariation(
369  m_systNominal), "Failed to set systematic");
370  if (m_electronEffChargeIDLoose_exists) top::check(m_electronEffSFChargeIDLoose->applySystematicVariation(
371  m_systNominal), "Failed to set systematic");
372  if (m_electronEffChargeMisID_exists) top::check(m_electronEffSFChargeMisID->applySystematicVariation(
373  m_systNominal), "Failed to set systematic");
374  if (m_electronEffChargeMisIDLoose_exists) top::check(m_electronEffSFChargeMisIDLoose->applySystematicVariation(
375  m_systNominal), "Failed to set systematic");
376 
378  for (auto electronPtr : *electrons) {
380  bool passSelection(false);
381  if (electronPtr->isAvailable<char>("passPreORSelection")) {
382  if (electronPtr->auxdataConst<char>("passPreORSelection") == 1) {
383  passSelection = true;
384  }
385  }
386  if (electronPtr->isAvailable<char>("passPreORSelectionLoose")) {
387  if (electronPtr->auxdataConst<char>("passPreORSelectionLoose") == 1) {
388  passSelection = true;
389  }
390  }
391 
392  if (passSelection) {
393  double Eff_Trigger(1.), Eff_TriggerLoose(1.);
394  double SF_Trigger(1.), SF_TriggerLoose(1.);
395  double SF_Reco(1.);
396  double SF_ID(1.), SF_IDLoose(1.);
397  double SF_Isol(1.), SF_IsolLoose(1.);
398  double SF_ChargeID(1.), SF_ChargeIDLoose(1.);
399  double SF_ChargeMisID(1.), SF_ChargeMisIDLoose(1.);
400 
402  top::check(m_electronEffTrigger->getEfficiencyScaleFactor(*electronPtr, Eff_Trigger), "Failed to get SF");
403  top::check(m_electronEffTriggerLoose->getEfficiencyScaleFactor(*electronPtr,
404  Eff_TriggerLoose), "Failed to get SF");
405 
407  top::check(m_electronEffSFTrigger->getEfficiencyScaleFactor(*electronPtr, SF_Trigger), "Failed to get SF");
408  top::check(m_electronEffSFTriggerLoose->getEfficiencyScaleFactor(*electronPtr,
409  SF_TriggerLoose), "Failed to get SF");
410  top::check(m_electronEffSFReco->getEfficiencyScaleFactor(*electronPtr, SF_Reco), "Failed to get SF");
411  top::check(m_electronEffSFID->getEfficiencyScaleFactor(*electronPtr, SF_ID), "Failed to get SF");
412  top::check(m_electronEffSFIDLoose->getEfficiencyScaleFactor(*electronPtr, SF_IDLoose), "Failed to get SF");
413  if (m_electronEffIso_exists) top::check(m_electronEffSFIso->getEfficiencyScaleFactor(*electronPtr,
414  SF_Isol),
415  "Failed to get SF");
416  if (m_electronEffIsoLoose_exists) top::check(m_electronEffSFIsoLoose->getEfficiencyScaleFactor(*electronPtr,
417  SF_IsolLoose),
418  "Failed to get SF");
419  if (m_electronEffChargeID_exists) top::check(m_electronEffSFChargeID->getEfficiencyScaleFactor(*electronPtr,
420  SF_ChargeID),
421  "Failed to get SF");
422  if (m_electronEffChargeIDLoose_exists) top::check(m_electronEffSFChargeIDLoose->getEfficiencyScaleFactor(*
423  electronPtr,
424  SF_ChargeIDLoose),
425  "Failed to get SF");
426  if (m_electronEffChargeMisID_exists) top::check(m_electronEffSFChargeMisID->getEfficiencyScaleFactor(*
427  electronPtr,
428  SF_ChargeMisID),
429  "Failed to get SF");
430  if (m_electronEffChargeMisIDLoose_exists) top::check(m_electronEffSFChargeMisIDLoose->getEfficiencyScaleFactor(
431  *electronPtr,
432  SF_ChargeMisIDLoose), "Failed to get SF");
433 
434 
436  electronPtr->auxdecor<float>(m_decor_triggerEff) = Eff_Trigger;
437  electronPtr->auxdecor<float>(m_decor_triggerEff_loose) = Eff_TriggerLoose;
438  electronPtr->auxdecor<float>(m_decor_triggerSF) = SF_Trigger;
439  electronPtr->auxdecor<float>(m_decor_triggerSF_loose) = SF_TriggerLoose;
440  electronPtr->auxdecor<float>(m_decor_recoSF) = SF_Reco;
441  electronPtr->auxdecor<float>(m_decor_idSF) = SF_ID;
442  electronPtr->auxdecor<float>(m_decor_idSF_loose) = SF_IDLoose;
443  electronPtr->auxdecor<float>(m_decor_isoSF) = SF_Isol;
444  electronPtr->auxdecor<float>(m_decor_isoSF_loose) = SF_IsolLoose;
445  electronPtr->auxdecor<float>(m_decor_chargeidSF) = SF_ChargeID;
446  electronPtr->auxdecor<float>(m_decor_chargeidSF_loose) = SF_ChargeIDLoose;
447  electronPtr->auxdecor<float>(m_decor_chargemisidSF) = SF_ChargeMisID;
448  electronPtr->auxdecor<float>(m_decor_chargemisidSF_loose) = SF_ChargeMisIDLoose;
449 
451  if (currentSystematic.first == m_config->nominalHashValue()) {
452  double EFF_Trigger_UP(1.), EFF_TriggerLoose_UP(1.);
453  double SF_Trigger_UP(1.), SF_TriggerLoose_UP(1.);
454  double SF_Reco_UP(1.);
455  double SF_ID_UP(1.), SF_IDLoose_UP(1.);
456  double SF_Isol_UP(1.), SF_IsolLoose_UP(1.);
457  double SF_ChargeID_UP(1.), SF_ChargeIDLoose_UP(1.);
458  double SF_ChargeMisID_STAT_UP(1.), SF_ChargeMisIDLoose_STAT_UP(1.);
459  double SF_ChargeMisID_SYST_UP(1.), SF_ChargeMisIDLoose_SYST_UP(1.);
460 
461  double EFF_Trigger_DOWN(1.), EFF_TriggerLoose_DOWN(1.);
462  double SF_Trigger_DOWN(1.), SF_TriggerLoose_DOWN(1.);
463  double SF_Reco_DOWN(1.);
464  double SF_ID_DOWN(1.), SF_IDLoose_DOWN(1.);
465  double SF_Isol_DOWN(1.), SF_IsolLoose_DOWN(1.);
466  double SF_ChargeID_DOWN(1.), SF_ChargeIDLoose_DOWN(1.);
467  double SF_ChargeMisID_STAT_DOWN(1.), SF_ChargeMisIDLoose_STAT_DOWN(1.);
468  double SF_ChargeMisID_SYST_DOWN(1.), SF_ChargeMisIDLoose_SYST_DOWN(1.);
469 
472  top::check(m_electronEffSFTrigger->applySystematicVariation(m_systTrigger_UP), "Failed to set systematic");
473  top::check(m_electronEffSFTriggerLoose->applySystematicVariation(
474  m_systTrigger_UP), "Failed to set systematic");
475  top::check(m_electronEffSFTrigger->getEfficiencyScaleFactor(*electronPtr, SF_Trigger_UP),
476  "Failed to get SF");
477  top::check(m_electronEffSFTriggerLoose->getEfficiencyScaleFactor(*electronPtr,
478  SF_TriggerLoose_UP), "Failed to get SF");
479  top::check(m_electronEffTrigger->applySystematicVariation(m_systTrigger_UP), "Failed to set systematic");
480  top::check(m_electronEffTriggerLoose->applySystematicVariation(m_systTrigger_UP),
481  "Failed to set systematic");
482  top::check(m_electronEffTrigger->getEfficiencyScaleFactor(*electronPtr, EFF_Trigger_UP),
483  "Failed to get SF");
484  top::check(m_electronEffTriggerLoose->getEfficiencyScaleFactor(*electronPtr,
485  EFF_TriggerLoose_UP), "Failed to get SF");
486 
488  top::check(m_electronEffSFTrigger->applySystematicVariation(m_systTrigger_DOWN),
489  "Failed to set systematic");
490  top::check(m_electronEffSFTriggerLoose->applySystematicVariation(
491  m_systTrigger_DOWN), "Failed to set systematic");
492  top::check(m_electronEffSFTrigger->getEfficiencyScaleFactor(*electronPtr,
493  SF_Trigger_DOWN), "Failed to get SF");
494  top::check(m_electronEffSFTriggerLoose->getEfficiencyScaleFactor(*electronPtr,
495  SF_TriggerLoose_DOWN), "Failed to get SF");
496  top::check(m_electronEffTrigger->applySystematicVariation(m_systTrigger_DOWN), "Failed to set systematic");
497  top::check(m_electronEffTriggerLoose->applySystematicVariation(
498  m_systTrigger_DOWN), "Failed to set systematic");
499  top::check(m_electronEffTrigger->getEfficiencyScaleFactor(*electronPtr,
500  EFF_Trigger_DOWN), "Failed to get SF");
501  top::check(m_electronEffTriggerLoose->getEfficiencyScaleFactor(*electronPtr,
502  EFF_TriggerLoose_DOWN), "Failed to get SF");
503 
504 
506  top::check(m_electronEffSFTrigger->applySystematicVariation(m_systNominal), "Failed to set systematic");
507  top::check(m_electronEffSFTriggerLoose->applySystematicVariation(m_systNominal),
508  "Failed to set systematic");
509  top::check(m_electronEffTrigger->applySystematicVariation(m_systNominal), "Failed to set systematic");
510  top::check(m_electronEffTriggerLoose->applySystematicVariation(m_systNominal), "Failed to set systematic");
511 
512 
515  top::check(m_electronEffSFReco->applySystematicVariation(m_systReco_UP), "Failed to set systematic");
516  top::check(m_electronEffSFReco->getEfficiencyScaleFactor(*electronPtr, SF_Reco_UP), "Failed to get SF");
517 
519  top::check(m_electronEffSFReco->applySystematicVariation(m_systReco_DOWN), "Failed to set systematic");
520  top::check(m_electronEffSFReco->getEfficiencyScaleFactor(*electronPtr, SF_Reco_DOWN), "Failed to get SF");
521 
523  top::check(m_electronEffSFReco->applySystematicVariation(m_systNominal), "Failed to set systematic");
524 
527  top::check(m_electronEffSFID->applySystematicVariation(m_systID_UP), "Failed to set systematic");
528  top::check(m_electronEffSFIDLoose->applySystematicVariation(m_systID_UP), "Failed to set systematic");
529  top::check(m_electronEffSFID->getEfficiencyScaleFactor(*electronPtr, SF_ID_UP), "Failed to get SF");
530  top::check(m_electronEffSFIDLoose->getEfficiencyScaleFactor(*electronPtr, SF_IDLoose_UP),
531  "Failed to get SF");
533  top::check(m_electronEffSFID->applySystematicVariation(m_systID_DOWN), "Failed to set systematic");
534  top::check(m_electronEffSFIDLoose->applySystematicVariation(m_systID_DOWN), "Failed to set systematic");
535  top::check(m_electronEffSFID->getEfficiencyScaleFactor(*electronPtr, SF_ID_DOWN), "Failed to get SF");
536  top::check(m_electronEffSFIDLoose->getEfficiencyScaleFactor(*electronPtr,
537  SF_IDLoose_DOWN), "Failed to get SF");
538 
540  top::check(m_electronEffSFID->applySystematicVariation(m_systNominal), "Failed to set systematic");
541  top::check(m_electronEffSFIDLoose->applySystematicVariation(m_systNominal), "Failed to set systematic");
542 
545  if (m_electronEffIso_exists) {
546  top::check(m_electronEffSFIso->applySystematicVariation(m_systIso_UP), "Failed to set systematic");
547  top::check(m_electronEffSFIso->getEfficiencyScaleFactor(*electronPtr, SF_Isol_UP), "Failed to get SF");
549  top::check(m_electronEffSFIso->applySystematicVariation(m_systIso_DOWN), "Failed to set systematic");
550  top::check(m_electronEffSFIso->getEfficiencyScaleFactor(*electronPtr, SF_Isol_DOWN), "Failed to get SF");
552  top::check(m_electronEffSFIso->applySystematicVariation(m_systNominal), "Failed to set systematic");
553  }
554  if (m_electronEffIsoLoose_exists) {
555  top::check(m_electronEffSFIsoLoose->applySystematicVariation(m_systIso_UP), "Failed to set systematic");
556  top::check(m_electronEffSFIsoLoose->getEfficiencyScaleFactor(*electronPtr,
557  SF_IsolLoose_UP), "Failed to get SF");
559  top::check(m_electronEffSFIsoLoose->applySystematicVariation(m_systIso_DOWN), "Failed to set systematic");
560  top::check(m_electronEffSFIsoLoose->getEfficiencyScaleFactor(*electronPtr,
561  SF_IsolLoose_DOWN), "Failed to get SF");
563  top::check(m_electronEffSFIsoLoose->applySystematicVariation(m_systNominal), "Failed to set systematic");
564  }
565 
567  if (m_electronEffChargeID_exists) {
569  top::check(m_electronEffSFChargeID->applySystematicVariation(
570  m_systChargeID_UP), "Failed to set systematic");
571  top::check(m_electronEffSFChargeID->getEfficiencyScaleFactor(*electronPtr,
572  SF_ChargeID_UP), "Failed to get SF");
574  top::check(m_electronEffSFChargeID->applySystematicVariation(
575  m_systChargeID_DOWN), "Failed to set systematic");
576  top::check(m_electronEffSFChargeID->getEfficiencyScaleFactor(*electronPtr,
577  SF_ChargeID_DOWN), "Failed to get SF");
579  top::check(m_electronEffSFChargeID->applySystematicVariation(m_systNominal), "Failed to set systematic");
580  }
581  if (m_electronEffChargeIDLoose_exists) {
583  top::check(m_electronEffSFChargeIDLoose->applySystematicVariation(
584  m_systChargeID_UP), "Failed to set systematic");
585  top::check(m_electronEffSFChargeIDLoose->getEfficiencyScaleFactor(*electronPtr,
586  SF_ChargeIDLoose_UP),
587  "Failed to get SF");
589  top::check(m_electronEffSFChargeIDLoose->applySystematicVariation(
590  m_systChargeID_DOWN), "Failed to set systematic");
591  top::check(m_electronEffSFChargeIDLoose->getEfficiencyScaleFactor(*electronPtr,
592  SF_ChargeIDLoose_DOWN),
593  "Failed to get SF");
595  top::check(m_electronEffSFChargeIDLoose->applySystematicVariation(
596  m_systNominal), "Failed to set systematic");
597  }
598 
600  if (m_electronEffChargeMisID_exists) {
602  top::check(m_electronEffSFChargeMisID->applySystematicVariation(
603  m_systChargeMisID_STAT_UP), "Failed to set systematic");
604  top::check(m_electronEffSFChargeMisID->getEfficiencyScaleFactor(*electronPtr,
605  SF_ChargeMisID_STAT_UP),
606  "Failed to get SF");
608  top::check(m_electronEffSFChargeMisID->applySystematicVariation(
609  m_systChargeMisID_STAT_DOWN), "Failed to set systematic");
610  top::check(m_electronEffSFChargeMisID->getEfficiencyScaleFactor(*electronPtr,
611  SF_ChargeMisID_STAT_DOWN),
612  "Failed to get SF");
614  top::check(m_electronEffSFChargeMisID->applySystematicVariation(
615  m_systChargeMisID_SYST_UP), "Failed to set systematic");
616  top::check(m_electronEffSFChargeMisID->getEfficiencyScaleFactor(*electronPtr,
617  SF_ChargeMisID_SYST_UP),
618  "Failed to get SF");
620  top::check(m_electronEffSFChargeMisID->applySystematicVariation(
621  m_systChargeMisID_SYST_DOWN), "Failed to set systematic");
622  top::check(m_electronEffSFChargeMisID->getEfficiencyScaleFactor(*electronPtr,
623  SF_ChargeMisID_SYST_DOWN),
624  "Failed to get SF");
626  top::check(m_electronEffSFChargeMisID->applySystematicVariation(m_systNominal),
627  "Failed to set systematic");
628  }
629  if (m_electronEffChargeMisIDLoose_exists) {
631  top::check(m_electronEffSFChargeMisIDLoose->applySystematicVariation(
632  m_systChargeMisID_STAT_UP), "Failed to set systematic");
633  top::check(m_electronEffSFChargeMisIDLoose->getEfficiencyScaleFactor(*electronPtr,
634  SF_ChargeMisIDLoose_STAT_UP),
635  "Failed to get SF");
637  top::check(m_electronEffSFChargeMisIDLoose->applySystematicVariation(
638  m_systChargeMisID_STAT_DOWN), "Failed to set systematic");
639  top::check(m_electronEffSFChargeMisIDLoose->getEfficiencyScaleFactor(*electronPtr,
640  SF_ChargeMisIDLoose_STAT_DOWN),
641  "Failed to get SF");
643  top::check(m_electronEffSFChargeMisIDLoose->applySystematicVariation(
644  m_systChargeMisID_SYST_UP), "Failed to set systematic");
645  top::check(m_electronEffSFChargeMisIDLoose->getEfficiencyScaleFactor(*electronPtr,
646  SF_ChargeMisIDLoose_SYST_UP),
647  "Failed to get SF");
649  top::check(m_electronEffSFChargeMisIDLoose->applySystematicVariation(
650  m_systChargeMisID_SYST_DOWN), "Failed to set systematic");
651  top::check(m_electronEffSFChargeMisIDLoose->getEfficiencyScaleFactor(*electronPtr,
652  SF_ChargeMisIDLoose_SYST_DOWN),
653  "Failed to get SF");
655  top::check(m_electronEffSFChargeMisIDLoose->applySystematicVariation(
656  m_systNominal), "Failed to set systematic");
657  }
658 
660  electronPtr->auxdecor<float>(m_decor_triggerEff + "_UP") = EFF_Trigger_UP;
661  electronPtr->auxdecor<float>(m_decor_triggerEff_loose + "_UP") = EFF_TriggerLoose_UP;
662  electronPtr->auxdecor<float>(m_decor_triggerSF + "_UP") = SF_Trigger_UP;
663  electronPtr->auxdecor<float>(m_decor_triggerSF_loose + "_UP") = SF_TriggerLoose_UP;
664  electronPtr->auxdecor<float>(m_decor_recoSF + "_UP") = SF_Reco_UP;
665  electronPtr->auxdecor<float>(m_decor_idSF + "_UP") = SF_ID_UP;
666  electronPtr->auxdecor<float>(m_decor_idSF_loose + "_UP") = SF_IDLoose_UP;
667  electronPtr->auxdecor<float>(m_decor_isoSF + "_UP") = SF_Isol_UP;
668  electronPtr->auxdecor<float>(m_decor_isoSF_loose + "_UP") = SF_IsolLoose_UP;
669  electronPtr->auxdecor<float>(m_decor_chargeidSF + "_UP") = SF_ChargeID_UP;
670  electronPtr->auxdecor<float>(m_decor_chargeidSF_loose + "_UP") = SF_ChargeIDLoose_UP;
671  electronPtr->auxdecor<float>(m_decor_chargemisidSF + "_STAT_UP") = SF_ChargeMisID_STAT_UP;
672  electronPtr->auxdecor<float>(m_decor_chargemisidSF_loose + "_STAT_UP") = SF_ChargeMisIDLoose_STAT_UP;
673  electronPtr->auxdecor<float>(m_decor_chargemisidSF + "_SYST_UP") = SF_ChargeMisID_SYST_UP;
674  electronPtr->auxdecor<float>(m_decor_chargemisidSF_loose + "_SYST_UP") = SF_ChargeMisIDLoose_SYST_UP;
675 
676  electronPtr->auxdecor<float>(m_decor_triggerEff + "_DOWN") = EFF_Trigger_DOWN;
677  electronPtr->auxdecor<float>(m_decor_triggerEff_loose + "_DOWN") = EFF_TriggerLoose_DOWN;
678  electronPtr->auxdecor<float>(m_decor_triggerSF + "_DOWN") = SF_Trigger_DOWN;
679  electronPtr->auxdecor<float>(m_decor_triggerSF_loose + "_DOWN") = SF_TriggerLoose_DOWN;
680  electronPtr->auxdecor<float>(m_decor_recoSF + "_DOWN") = SF_Reco_DOWN;
681  electronPtr->auxdecor<float>(m_decor_idSF + "_DOWN") = SF_ID_DOWN;
682  electronPtr->auxdecor<float>(m_decor_idSF_loose + "_DOWN") = SF_IDLoose_DOWN;
683  electronPtr->auxdecor<float>(m_decor_isoSF + "_DOWN") = SF_Isol_DOWN;
684  electronPtr->auxdecor<float>(m_decor_isoSF_loose + "_DOWN") = SF_IsolLoose_DOWN;
685  electronPtr->auxdecor<float>(m_decor_chargeidSF + "_DOWN") = SF_ChargeID_DOWN;
686  electronPtr->auxdecor<float>(m_decor_chargeidSF_loose + "_DOWN") = SF_ChargeIDLoose_DOWN;
687  electronPtr->auxdecor<float>(m_decor_chargemisidSF + "_STAT_DOWN") = SF_ChargeMisID_STAT_DOWN;
688  electronPtr->auxdecor<float>(m_decor_chargemisidSF_loose + "_STAT_DOWN") = SF_ChargeMisIDLoose_STAT_DOWN;
689  electronPtr->auxdecor<float>(m_decor_chargemisidSF + "_SYST_DOWN") = SF_ChargeMisID_SYST_DOWN;
690  electronPtr->auxdecor<float>(m_decor_chargemisidSF_loose + "_SYST_DOWN") = SF_ChargeMisIDLoose_SYST_DOWN;
691 
693 
694  ATH_MSG_DEBUG("Electron Trigger Eff = " << electronPtr->auxdataConst<float>(m_decor_triggerEff) << " + " <<
695  electronPtr->auxdataConst<float>(m_decor_triggerEff + "_UP") << " - " <<
696  electronPtr->auxdataConst<float>(m_decor_triggerEff + "_DOWN")
697  );
698 
699  ATH_MSG_DEBUG("Electron Trigger MediumLH SF = " << electronPtr->auxdataConst<float>(
700  m_decor_triggerSF) << " + " <<
701  electronPtr->auxdataConst<float>(m_decor_triggerSF + "_UP") << " - " <<
702  electronPtr->auxdataConst<float>(m_decor_triggerSF + "_DOWN")
703  );
704 
705  ATH_MSG_DEBUG("Electron Reco SF = " << electronPtr->auxdataConst<float>(m_decor_recoSF) << " + " <<
706  electronPtr->auxdataConst<float>(m_decor_recoSF + "_UP") << " - " <<
707  electronPtr->auxdataConst<float>(m_decor_recoSF + "_DOWN")
708  );
709 
710  ATH_MSG_DEBUG("Electron ID SF = " << electronPtr->auxdataConst<float>(m_decor_idSF) << " + " <<
711  electronPtr->auxdataConst<float>(m_decor_idSF + "_UP") << " - " <<
712  electronPtr->auxdataConst<float>(m_decor_idSF + "_DOWN")
713  );
714 
715  ATH_MSG_DEBUG("Electron Charge ID SF = " << electronPtr->auxdataConst<float>(m_decor_chargeidSF) << " + " <<
716  electronPtr->auxdataConst<float>(m_decor_chargeidSF + "_UP") << " - " <<
717  electronPtr->auxdataConst<float>(m_decor_chargeidSF + "_DOWN")
718  );
719 
720  ATH_MSG_DEBUG("Electron Charge Mis-ID SF = " << electronPtr->auxdataConst<float>(
721  m_decor_chargemisidSF) << " + " <<
722  electronPtr->auxdataConst<float>(m_decor_chargemisidSF + "_STAT_UP") << " - " <<
723  electronPtr->auxdataConst<float>(m_decor_chargemisidSF + "_STAT_DOWN") << " + " <<
724  electronPtr->auxdataConst<float>(m_decor_chargemisidSF + "_SYST_UP") << " - " <<
725  electronPtr->auxdataConst<float>(m_decor_chargemisidSF + "_SYST_DOWN")
726  );
727 
728 
730  if ((m_config->electronEfficiencySystematicModel() != "TOTAL") && (m_config->electronEfficiencySystematicModel() != "COMBMCTOYS")){
731  std::vector<float> vec_Eff_Trigger_UP, vec_Eff_Trigger_DOWN, vec_Eff_TriggerLoose_UP,
732  vec_Eff_TriggerLoose_DOWN;
733  std::vector<float> vec_SF_Trigger_UP, vec_SF_Trigger_DOWN, vec_SF_TriggerLoose_UP,
734  vec_SF_TriggerLoose_DOWN;
735  std::vector<float> vec_SF_Reco_UP, vec_SF_Reco_DOWN;
736  std::vector<float> vec_SF_ID_UP, vec_SF_ID_DOWN, vec_SF_IDLoose_UP, vec_SF_IDLoose_DOWN;
737  std::vector<float> vec_SF_Isol_UP, vec_SF_Isol_DOWN, vec_SF_IsolLoose_UP, vec_SF_IsolLoose_DOWN;
738  std::vector<float> vec_SF_ChargeID_UP, vec_SF_ChargeID_DOWN, vec_SF_ChargeIDLoose_UP,
739  vec_SF_ChargeIDLoose_DOWN;
740  std::vector<float> vec_SF_ChargeMisID_UP, vec_SF_ChargeMisID_DOWN, vec_SF_ChargeMisIDLoose_UP,
741  vec_SF_ChargeMisIDLoose_DOWN;
742 
743  double EFF_Trigger(1.), EFF_TriggerLoose(1.);
744  double SF_Trigger(1.), SF_TriggerLoose(1.);
745  double SF_Reco(1.);
746  double SF_ID(1.), SF_IDLoose(1.);
747  double SF_Isol(1.), SF_IsolLoose(1.);
748 
750  int count = 0;
751  for (const CP::SystematicSet& isyst : m_systTriggerCorrModel) {
752  if (count == 0) { //0 is nominal
753  count++;
754  continue;
755  }
756 
757  top::check(m_electronEffSFTriggerCorrModel->applySystematicVariation(isyst),
758  "Failed to set systematic");
759  top::check(m_electronEffSFTriggerLooseCorrModel->applySystematicVariation(
760  isyst), "Failed to set systematic");
761  top::check(m_electronEffSFTriggerCorrModel->getEfficiencyScaleFactor(*electronPtr,
762  SF_Trigger), "Failed to get SF");
763  top::check(m_electronEffSFTriggerLooseCorrModel->getEfficiencyScaleFactor(*electronPtr,
764  SF_TriggerLoose),
765  "Failed to get SF");
766  top::check(m_electronEffTriggerCorrModel->applySystematicVariation(isyst), "Failed to set systematic");
767  top::check(m_electronEffTriggerLooseCorrModel->applySystematicVariation(
768  isyst), "Failed to set systematic");
769  top::check(m_electronEffTriggerCorrModel->getEfficiencyScaleFactor(*electronPtr,
770  EFF_Trigger), "Failed to get SF");
771  top::check(m_electronEffTriggerLooseCorrModel->getEfficiencyScaleFactor(*electronPtr,
772  EFF_TriggerLoose),
773  "Failed to get SF");
774 
775  // split by down and up
776  if (count % 2 == 1) {
777  vec_SF_Trigger_DOWN.emplace_back(SF_Trigger);
778  vec_SF_TriggerLoose_DOWN.emplace_back(SF_TriggerLoose);
779  vec_Eff_Trigger_DOWN.emplace_back(EFF_Trigger);
780  vec_Eff_TriggerLoose_DOWN.emplace_back(EFF_TriggerLoose);
781  } else {
782  vec_SF_Trigger_UP.emplace_back(SF_Trigger);
783  vec_SF_TriggerLoose_UP.emplace_back(SF_TriggerLoose);
784  vec_Eff_Trigger_UP.emplace_back(EFF_Trigger);
785  vec_Eff_TriggerLoose_UP.emplace_back(EFF_TriggerLoose);
786  }
787 
788  count++;
789  }
790 
791  // Do some sanity check
792  if (vec_SF_Trigger_DOWN.size() != vec_SF_Trigger_UP.size()) {
793  throw std::runtime_error {
794  "ElectronScaleFactorCalculator::execute: Sizes of trigger SF for up and down are different"
795  };
796  }
797  if (vec_SF_TriggerLoose_DOWN.size() != vec_SF_TriggerLoose_UP.size()) {
798  throw std::runtime_error {
799  "ElectronScaleFactorCalculator::execute: Sizes of triggerLoose SF for up and down are different"
800  };
801  }
802  if (vec_Eff_Trigger_DOWN.size() != vec_Eff_Trigger_UP.size()) {
803  throw std::runtime_error {
804  "ElectronScaleFactorCalculator::execute: Sizes of trigger Eff for up and down are different"
805  };
806  }
807  if (vec_Eff_TriggerLoose_DOWN.size() != vec_Eff_TriggerLoose_UP.size()) {
808  throw std::runtime_error {
809  "ElectronScaleFactorCalculator::execute: Sizes of triggerLoose Eff for up and down are different"
810  };
811  }
812 
814  top::check(m_electronEffSFTriggerCorrModel->applySystematicVariation(
815  m_systNominal), "Failed to set systematic");
816  top::check(m_electronEffSFTriggerLooseCorrModel->applySystematicVariation(
817  m_systNominal), "Failed to set systematic");
818  top::check(m_electronEffTriggerCorrModel->applySystematicVariation(
819  m_systNominal), "Failed to set systematic");
820  top::check(m_electronEffTriggerLooseCorrModel->applySystematicVariation(
821  m_systNominal), "Failed to set systematic");
822 
824  count = 0;
825  for (const CP::SystematicSet& isyst : m_systRecoCorrModel) {
826  if (count == 0) { //0 is nominal
827  count++;
828  continue;
829  }
830 
831  top::check(m_electronEffSFRecoCorrModel->applySystematicVariation(isyst), "Failed to set systematic");
832  top::check(m_electronEffSFRecoCorrModel->getEfficiencyScaleFactor(*electronPtr,
833  SF_Reco), "Failed to get SF");
834 
835  if (count % 2 == 1) {
836  vec_SF_Reco_DOWN.emplace_back(SF_Reco);
837  } else {
838  vec_SF_Reco_UP.emplace_back(SF_Reco);
839  }
840  ++count;
841  }
842  if (vec_SF_Reco_DOWN.size() != vec_SF_Reco_UP.size()) {
843  throw std::runtime_error {
844  "ElectronScaleFactorCalculator::execute: Sizes of Reco SF for up and down are different"
845  };
846  }
847 
849  top::check(m_electronEffSFRecoCorrModel->applySystematicVariation(
850  m_systNominal), "Failed to set systematic");
851 
853  count = 0;
854  for (const CP::SystematicSet& isyst : m_systIDCorrModel) {
855  if (count == 0) { //0 is nominal
856  count++;
857  continue;
858  }
859 
860  top::check(m_electronEffSFIDCorrModel->applySystematicVariation(isyst), "Failed to set systematic");
861  top::check(m_electronEffSFIDLooseCorrModel->applySystematicVariation(isyst),
862  "Failed to set systematic");
863  top::check(m_electronEffSFIDCorrModel->getEfficiencyScaleFactor(*electronPtr, SF_ID),
864  "Failed to get SF");
865  top::check(m_electronEffSFIDLooseCorrModel->getEfficiencyScaleFactor(*electronPtr,
866  SF_IDLoose), "Failed to get SF");
867 
868  if (count % 2 == 1) {
869  vec_SF_ID_DOWN.emplace_back(SF_ID);
870  vec_SF_IDLoose_DOWN.emplace_back(SF_IDLoose);
871  } else {
872  vec_SF_ID_UP.emplace_back(SF_ID);
873  vec_SF_IDLoose_UP.emplace_back(SF_IDLoose);
874  }
875  ++count;
876  }
877  if (vec_SF_ID_DOWN.size() != vec_SF_ID_UP.size()) {
878  throw std::runtime_error {
879  "ElectronScaleFactorCalculator::execute: Sizes of ID SF for up and down are different"
880  };
881  }
882  if (vec_SF_IDLoose_DOWN.size() != vec_SF_IDLoose_UP.size()) {
883  throw std::runtime_error {
884  "ElectronScaleFactorCalculator::execute: Sizes of IDLoose SF for up and down are different"
885  };
886  }
887 
889  top::check(m_electronEffSFIDCorrModel->applySystematicVariation(m_systNominal),
890  "Failed to set systematic");
891  top::check(m_electronEffSFIDLooseCorrModel->applySystematicVariation(
892  m_systNominal), "Failed to set systematic");
893 
895  count = 0;
896  for (const CP::SystematicSet& isyst : m_systIsoCorrModel) {
897  if (count == 0) { //0 is nominal
898  count++;
899  continue;
900  }
901 
902  if (m_electronEffIso_exists) {
903  top::check(m_electronEffSFIsoCorrModel->applySystematicVariation(isyst), "Failed to set systematic");
904  top::check(m_electronEffSFIsoCorrModel->getEfficiencyScaleFactor(*electronPtr,
905  SF_Isol), "Failed to get SF");
907  top::check(m_electronEffSFIsoCorrModel->applySystematicVariation(
908  m_systNominal), "Failed to set systematic");
909  }
910  if (m_electronEffIsoLoose_exists) {
911  top::check(m_electronEffSFIsoLooseCorrModel->applySystematicVariation(
912  isyst), "Failed to set systematic");
913  top::check(m_electronEffSFIsoLooseCorrModel->getEfficiencyScaleFactor(*electronPtr,
914  SF_IsolLoose),
915  "Failed to get SF");
917  top::check(m_electronEffSFIsoLooseCorrModel->applySystematicVariation(
918  m_systNominal), "Failed to set systematic");
919  }
920  if (count % 2 == 1) {
921  vec_SF_Isol_DOWN.emplace_back(SF_Isol);
922  vec_SF_IsolLoose_DOWN.emplace_back(SF_IsolLoose);
923  } else {
924  vec_SF_Isol_UP.emplace_back(SF_Isol);
925  vec_SF_IsolLoose_UP.emplace_back(SF_IsolLoose);
926  }
927  ++count;
928  }
929  if (vec_SF_Isol_DOWN.size() != vec_SF_Isol_UP.size()) {
930  throw std::runtime_error {
931  "ElectronScaleFactorCalculator::execute: Sizes of Isol SF for up and down are different"
932  };
933  }
934  if (vec_SF_IsolLoose_DOWN.size() != vec_SF_IsolLoose_UP.size()) {
935  throw std::runtime_error {
936  "ElectronScaleFactorCalculator::execute: Sizes of IsolLoose SF for up and down are different"
937  };
938  }
939 
940 
942 
943  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerEff + "_CorrModel_UP") = vec_Eff_Trigger_UP;
944  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerEff_loose +
945  "_CorrModel_UP") = vec_Eff_TriggerLoose_UP;
946  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerSF + "_CorrModel_UP") = vec_SF_Trigger_UP;
947  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerSF_loose +
948  "_CorrModel_UP") = vec_SF_TriggerLoose_UP;
949  electronPtr->auxdecor<std::vector<float> >(m_decor_recoSF + "_CorrModel_UP") = vec_SF_Reco_UP;
950  electronPtr->auxdecor<std::vector<float> >(m_decor_idSF + "_CorrModel_UP") = vec_SF_ID_UP;
951  electronPtr->auxdecor<std::vector<float> >(m_decor_idSF_loose + "_CorrModel_UP") = vec_SF_IDLoose_UP;
952  electronPtr->auxdecor<std::vector<float> >(m_decor_isoSF + "_CorrModel_UP") = vec_SF_Isol_UP;
953  electronPtr->auxdecor<std::vector<float> >(m_decor_isoSF_loose + "_CorrModel_UP") = vec_SF_IsolLoose_UP;
954  electronPtr->auxdecor<std::vector<float> >(m_decor_chargeidSF + "_CorrModel_UP") = vec_SF_ChargeID_UP;
955  electronPtr->auxdecor<std::vector<float> >(m_decor_chargeidSF_loose +
956  "_CorrModel_UP") = vec_SF_ChargeIDLoose_UP;
957  electronPtr->auxdecor<std::vector<float> >(m_decor_chargemisidSF +
958  "_CorrModel_UP") = vec_SF_ChargeMisID_UP;
959  electronPtr->auxdecor<std::vector<float> >(m_decor_chargemisidSF_loose +
960  "_CorrModel_UP") = vec_SF_ChargeMisIDLoose_UP;
961 
962  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerEff + "_CorrModel_DOWN") = vec_Eff_Trigger_DOWN;
963  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerEff_loose +
964  "_CorrModel_DOWN") = vec_Eff_TriggerLoose_DOWN;
965  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerSF + "_CorrModel_DOWN") = vec_SF_Trigger_DOWN;
966  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerSF_loose +
967  "_CorrModel_DOWN") = vec_SF_TriggerLoose_DOWN;
968  electronPtr->auxdecor<std::vector<float> >(m_decor_recoSF + "_CorrModel_DOWN") = vec_SF_Reco_DOWN;
969  electronPtr->auxdecor<std::vector<float> >(m_decor_idSF + "_CorrModel_DOWN") = vec_SF_ID_DOWN;
970  electronPtr->auxdecor<std::vector<float> >(m_decor_idSF_loose + "_CorrModel_DOWN") = vec_SF_IDLoose_DOWN;
971  electronPtr->auxdecor<std::vector<float> >(m_decor_isoSF + "_CorrModel_DOWN") = vec_SF_Isol_DOWN;
972  electronPtr->auxdecor<std::vector<float> >(m_decor_isoSF_loose +
973  "_CorrModel_DOWN") = vec_SF_IsolLoose_DOWN;
974  electronPtr->auxdecor<std::vector<float> >(m_decor_chargeidSF + "_CorrModel_DOWN") = vec_SF_ChargeID_DOWN;
975  electronPtr->auxdecor<std::vector<float> >(m_decor_chargeidSF_loose +
976  "_CorrModel_DOWN") = vec_SF_ChargeIDLoose_DOWN;
977  electronPtr->auxdecor<std::vector<float> >(m_decor_chargemisidSF +
978  "_CorrModel_DOWN") = vec_SF_ChargeMisID_DOWN;
979  electronPtr->auxdecor<std::vector<float> >(m_decor_chargemisidSF_loose +
980  "_CorrModel_DOWN") = vec_SF_ChargeMisIDLoose_DOWN;
981  }//end of saving additional systematic model
982 
983 
984 
985  if (m_config->electronEfficiencySystematicModel() == "COMBMCTOYS"){
986  std::vector<float> vec_Eff_Trigger_UP, vec_Eff_Trigger_DOWN, vec_Eff_TriggerLoose_UP,
987  vec_Eff_TriggerLoose_DOWN;
988  std::vector<float> vec_SF_Trigger_UP, vec_SF_Trigger_DOWN, vec_SF_TriggerLoose_UP,
989  vec_SF_TriggerLoose_DOWN;
990  std::vector<float> vec_SF_Reco_UP, vec_SF_Reco_DOWN;
991  std::vector<float> vec_SF_ID_UP, vec_SF_ID_DOWN, vec_SF_IDLoose_UP, vec_SF_IDLoose_DOWN;
992  std::vector<float> vec_SF_Isol_UP, vec_SF_Isol_DOWN, vec_SF_IsolLoose_UP, vec_SF_IsolLoose_DOWN;
993  std::vector<float> vec_SF_ChargeID_UP, vec_SF_ChargeID_DOWN, vec_SF_ChargeIDLoose_UP,
994  vec_SF_ChargeIDLoose_DOWN;
995  std::vector<float> vec_SF_ChargeMisID_UP, vec_SF_ChargeMisID_DOWN, vec_SF_ChargeMisIDLoose_UP,
996  vec_SF_ChargeMisIDLoose_DOWN;
997 
998  double EFF_Trigger(1.), EFF_TriggerLoose(1.);
999  double SF_Trigger(1.), SF_TriggerLoose(1.);
1000  double SF_Reco(1.);
1001  double SF_ID(1.), SF_IDLoose(1.);
1002  double SF_Isol(1.), SF_IsolLoose(1.);
1003 
1005  for (const CP::SystematicSet& isyst : m_systTriggerCorrModel) {
1006 
1007  top::check(m_electronEffSFTriggerCorrModel->applySystematicVariation(isyst),
1008  "Failed to set systematic");
1009  top::check(m_electronEffSFTriggerLooseCorrModel->applySystematicVariation(
1010  isyst), "Failed to set systematic");
1011  top::check(m_electronEffSFTriggerCorrModel->getEfficiencyScaleFactor(*electronPtr,
1012  SF_Trigger), "Failed to get SF");
1013  top::check(m_electronEffSFTriggerLooseCorrModel->getEfficiencyScaleFactor(*electronPtr,
1014  SF_TriggerLoose),
1015  "Failed to get SF");
1016  top::check(m_electronEffTriggerCorrModel->applySystematicVariation(isyst), "Failed to set systematic");
1017  top::check(m_electronEffTriggerLooseCorrModel->applySystematicVariation(
1018  isyst), "Failed to set systematic");
1019  top::check(m_electronEffTriggerCorrModel->getEfficiencyScaleFactor(*electronPtr,
1020  EFF_Trigger), "Failed to get SF");
1021  top::check(m_electronEffTriggerLooseCorrModel->getEfficiencyScaleFactor(*electronPtr,
1022  EFF_TriggerLoose),
1023  "Failed to get SF");
1024 
1025  vec_SF_Trigger_DOWN.emplace_back(SF_Trigger);
1026  vec_SF_TriggerLoose_DOWN.emplace_back(SF_TriggerLoose);
1027  vec_Eff_Trigger_DOWN.emplace_back(EFF_Trigger);
1028  vec_Eff_TriggerLoose_DOWN.emplace_back(EFF_TriggerLoose);
1029  vec_SF_Trigger_UP.emplace_back(SF_Trigger);
1030  vec_SF_TriggerLoose_UP.emplace_back(SF_TriggerLoose);
1031  vec_Eff_Trigger_UP.emplace_back(EFF_Trigger);
1032  vec_Eff_TriggerLoose_UP.emplace_back(EFF_TriggerLoose);
1033  }
1034 
1035  // Do some sanity check
1036  if (vec_SF_Trigger_DOWN.size() != vec_SF_Trigger_UP.size()) {
1037  throw std::runtime_error {
1038  "ElectronScaleFactorCalculator::execute: Sizes of trigger SF for up and down are different"
1039  };
1040  }
1041  if (vec_SF_TriggerLoose_DOWN.size() != vec_SF_TriggerLoose_UP.size()) {
1042  throw std::runtime_error {
1043  "ElectronScaleFactorCalculator::execute: Sizes of triggerLoose SF for up and down are different"
1044  };
1045  }
1046  if (vec_Eff_Trigger_DOWN.size() != vec_Eff_Trigger_UP.size()) {
1047  throw std::runtime_error {
1048  "ElectronScaleFactorCalculator::execute: Sizes of trigger Eff for up and down are different"
1049  };
1050  }
1051  if (vec_Eff_TriggerLoose_DOWN.size() != vec_Eff_TriggerLoose_UP.size()) {
1052  throw std::runtime_error {
1053  "ElectronScaleFactorCalculator::execute: Sizes of triggerLoose Eff for up and down are different"
1054  };
1055  }
1056 
1058  top::check(m_electronEffSFTriggerCorrModel->applySystematicVariation(
1059  m_systNominal), "Failed to set systematic");
1060  top::check(m_electronEffSFTriggerLooseCorrModel->applySystematicVariation(
1061  m_systNominal), "Failed to set systematic");
1062  top::check(m_electronEffTriggerCorrModel->applySystematicVariation(
1063  m_systNominal), "Failed to set systematic");
1064  top::check(m_electronEffTriggerLooseCorrModel->applySystematicVariation(
1065  m_systNominal), "Failed to set systematic");
1066 
1068  for (const CP::SystematicSet& isyst : m_systRecoCorrModel) {
1069 
1070  top::check(m_electronEffSFRecoCorrModel->applySystematicVariation(isyst), "Failed to set systematic");
1071  top::check(m_electronEffSFRecoCorrModel->getEfficiencyScaleFactor(*electronPtr,
1072  SF_Reco), "Failed to get SF");
1073 
1074  vec_SF_Reco_DOWN.emplace_back(SF_Reco);
1075  vec_SF_Reco_UP.emplace_back(SF_Reco);
1076  }
1077  if (vec_SF_Reco_DOWN.size() != vec_SF_Reco_UP.size()) {
1078  throw std::runtime_error {
1079  "ElectronScaleFactorCalculator::execute: Sizes of Reco SF for up and down are different"
1080  };
1081  }
1082 
1084  top::check(m_electronEffSFRecoCorrModel->applySystematicVariation(
1085  m_systNominal), "Failed to set systematic");
1086 
1088  for (const CP::SystematicSet& isyst : m_systIDCorrModel) {
1089 
1090  top::check(m_electronEffSFIDCorrModel->applySystematicVariation(isyst), "Failed to set systematic");
1091  top::check(m_electronEffSFIDLooseCorrModel->applySystematicVariation(isyst),
1092  "Failed to set systematic");
1093  top::check(m_electronEffSFIDCorrModel->getEfficiencyScaleFactor(*electronPtr, SF_ID),
1094  "Failed to get SF");
1095  top::check(m_electronEffSFIDLooseCorrModel->getEfficiencyScaleFactor(*electronPtr,
1096  SF_IDLoose), "Failed to get SF");
1097 
1098  vec_SF_ID_DOWN.emplace_back(SF_ID);
1099  vec_SF_IDLoose_DOWN.emplace_back(SF_IDLoose);
1100  vec_SF_ID_UP.emplace_back(SF_ID);
1101  vec_SF_IDLoose_UP.emplace_back(SF_IDLoose);
1102  }
1103  if (vec_SF_ID_DOWN.size() != vec_SF_ID_UP.size()) {
1104  throw std::runtime_error {
1105  "ElectronScaleFactorCalculator::execute: Sizes of ID SF for up and down are different"
1106  };
1107  }
1108  if (vec_SF_IDLoose_DOWN.size() != vec_SF_IDLoose_UP.size()) {
1109  throw std::runtime_error {
1110  "ElectronScaleFactorCalculator::execute: Sizes of IDLoose SF for up and down are different"
1111  };
1112  }
1113 
1115  top::check(m_electronEffSFIDCorrModel->applySystematicVariation(m_systNominal),
1116  "Failed to set systematic");
1117  top::check(m_electronEffSFIDLooseCorrModel->applySystematicVariation(
1118  m_systNominal), "Failed to set systematic");
1119 
1121  for (const CP::SystematicSet& isyst : m_systIsoCorrModel) {
1122 
1123  if (m_electronEffIso_exists) {
1124  top::check(m_electronEffSFIsoCorrModel->applySystematicVariation(isyst), "Failed to set systematic");
1125  top::check(m_electronEffSFIsoCorrModel->getEfficiencyScaleFactor(*electronPtr,
1126  SF_Isol), "Failed to get SF");
1128  top::check(m_electronEffSFIsoCorrModel->applySystematicVariation(
1129  m_systNominal), "Failed to set systematic");
1130  }
1131  if (m_electronEffIsoLoose_exists) {
1132  top::check(m_electronEffSFIsoLooseCorrModel->applySystematicVariation(
1133  isyst), "Failed to set systematic");
1134  top::check(m_electronEffSFIsoLooseCorrModel->getEfficiencyScaleFactor(*electronPtr,
1135  SF_IsolLoose),
1136  "Failed to get SF");
1138  top::check(m_electronEffSFIsoLooseCorrModel->applySystematicVariation(
1139  m_systNominal), "Failed to set systematic");
1140  }
1141  vec_SF_Isol_DOWN.emplace_back(SF_Isol);
1142  vec_SF_IsolLoose_DOWN.emplace_back(SF_IsolLoose);
1143  vec_SF_Isol_UP.emplace_back(SF_Isol);
1144  vec_SF_IsolLoose_UP.emplace_back(SF_IsolLoose);
1145  }
1146  if (vec_SF_Isol_DOWN.size() != vec_SF_Isol_UP.size()) {
1147  throw std::runtime_error {
1148  "ElectronScaleFactorCalculator::execute: Sizes of Isol SF for up and down are different"
1149  };
1150  }
1151  if (vec_SF_IsolLoose_DOWN.size() != vec_SF_IsolLoose_UP.size()) {
1152  throw std::runtime_error {
1153  "ElectronScaleFactorCalculator::execute: Sizes of IsolLoose SF for up and down are different"
1154  };
1155  }
1156 
1157 
1159 
1160  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerEff + "_CorrModel_UP") = vec_Eff_Trigger_UP;
1161  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerEff_loose +
1162  "_CorrModel_UP") = vec_Eff_TriggerLoose_UP;
1163  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerSF + "_CorrModel_UP") = vec_SF_Trigger_UP;
1164  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerSF_loose +
1165  "_CorrModel_UP") = vec_SF_TriggerLoose_UP;
1166  electronPtr->auxdecor<std::vector<float> >(m_decor_recoSF + "_CorrModel_UP") = vec_SF_Reco_UP;
1167  electronPtr->auxdecor<std::vector<float> >(m_decor_idSF + "_CorrModel_UP") = vec_SF_ID_UP;
1168  electronPtr->auxdecor<std::vector<float> >(m_decor_idSF_loose + "_CorrModel_UP") = vec_SF_IDLoose_UP;
1169  electronPtr->auxdecor<std::vector<float> >(m_decor_isoSF + "_CorrModel_UP") = vec_SF_Isol_UP;
1170  electronPtr->auxdecor<std::vector<float> >(m_decor_isoSF_loose + "_CorrModel_UP") = vec_SF_IsolLoose_UP;
1171  electronPtr->auxdecor<std::vector<float> >(m_decor_chargeidSF + "_CorrModel_UP") = vec_SF_ChargeID_UP;
1172  electronPtr->auxdecor<std::vector<float> >(m_decor_chargeidSF_loose +
1173  "_CorrModel_UP") = vec_SF_ChargeIDLoose_UP;
1174  electronPtr->auxdecor<std::vector<float> >(m_decor_chargemisidSF +
1175  "_CorrModel_UP") = vec_SF_ChargeMisID_UP;
1176  electronPtr->auxdecor<std::vector<float> >(m_decor_chargemisidSF_loose +
1177  "_CorrModel_UP") = vec_SF_ChargeMisIDLoose_UP;
1178 
1179  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerEff + "_CorrModel_DOWN") = vec_Eff_Trigger_DOWN;
1180  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerEff_loose +
1181  "_CorrModel_DOWN") = vec_Eff_TriggerLoose_DOWN;
1182  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerSF + "_CorrModel_DOWN") = vec_SF_Trigger_DOWN;
1183  electronPtr->auxdecor<std::vector<float> >(m_decor_triggerSF_loose +
1184  "_CorrModel_DOWN") = vec_SF_TriggerLoose_DOWN;
1185  electronPtr->auxdecor<std::vector<float> >(m_decor_recoSF + "_CorrModel_DOWN") = vec_SF_Reco_DOWN;
1186  electronPtr->auxdecor<std::vector<float> >(m_decor_idSF + "_CorrModel_DOWN") = vec_SF_ID_DOWN;
1187  electronPtr->auxdecor<std::vector<float> >(m_decor_idSF_loose + "_CorrModel_DOWN") = vec_SF_IDLoose_DOWN;
1188  electronPtr->auxdecor<std::vector<float> >(m_decor_isoSF + "_CorrModel_DOWN") = vec_SF_Isol_DOWN;
1189  electronPtr->auxdecor<std::vector<float> >(m_decor_isoSF_loose +
1190  "_CorrModel_DOWN") = vec_SF_IsolLoose_DOWN;
1191  electronPtr->auxdecor<std::vector<float> >(m_decor_chargeidSF + "_CorrModel_DOWN") = vec_SF_ChargeID_DOWN;
1192  electronPtr->auxdecor<std::vector<float> >(m_decor_chargeidSF_loose +
1193  "_CorrModel_DOWN") = vec_SF_ChargeIDLoose_DOWN;
1194  electronPtr->auxdecor<std::vector<float> >(m_decor_chargemisidSF +
1195  "_CorrModel_DOWN") = vec_SF_ChargeMisID_DOWN;
1196  electronPtr->auxdecor<std::vector<float> >(m_decor_chargemisidSF_loose +
1197  "_CorrModel_DOWN") = vec_SF_ChargeMisIDLoose_DOWN;
1198  }//end of saving COMBMCTOYS systematic model
1199 
1200 
1201 
1203  } // Calibration systematic is nominal, so calculate SF systematics
1204  }
1205  }
1206  }
1207 
1208 
1209  return StatusCode::SUCCESS;
1210  }

◆ 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

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

◆ initialize()

StatusCode top::ElectronScaleFactorCalculator::initialize ( )
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 81 of file ElectronScaleFactorCalculator.cxx.

81  {
82  ATH_MSG_INFO(" top::ElectronScaleFactorCalculator initialize");
83 
84  top::check(m_electronEffSFTrigger.retrieve(), "Failed to retrieve electron SF Tool");
85  top::check(m_electronEffSFTriggerLoose.retrieve(), "Failed to retrieve electron SF Tool");
86 
87  if (m_config->electronEfficiencySystematicModel() != "TOTAL") {
88  top::check(m_electronEffSFTriggerCorrModel.retrieve(),
89  "Failed to retrieve electron SF Tool for correlation model");
90  top::check(
91  m_electronEffSFTriggerLooseCorrModel.retrieve(), "Failed to retrieve electron SF Tool for correlation model");
92  }
93 
94  top::check(m_electronEffSFReco.retrieve(), "Failed to retrieve electron SF Tool");
95  if (m_config->electronEfficiencySystematicModel() != "TOTAL") {
96  top::check(m_electronEffSFRecoCorrModel.retrieve(), "Failed to retrieve electron SF Tool for correlation model");
97  }
98 
99  if (asg::ToolStore::contains<IAsgElectronEfficiencyCorrectionTool> ("AsgElectronEfficiencyCorrectionTool_Iso")) {
100  m_electronEffIso_exists = true;
101  top::check(m_electronEffSFIso.retrieve(), "Failed to retrieve electron SF Tool");
102  if (m_config->electronEfficiencySystematicModel() != "TOTAL") {
103  top::check(m_electronEffSFIsoCorrModel.retrieve(), "Failed to retrieve electron SF Tool for correlation model");
104  }
105  }
106  if (asg::ToolStore::contains<IAsgElectronEfficiencyCorrectionTool> ("AsgElectronEfficiencyCorrectionTool_IsoLoose"))
107  {
108  m_electronEffIsoLoose_exists = true;
109  top::check(m_electronEffSFIsoLoose.retrieve(), "Failed to retrieve loose electron SF Tool");
110  if (m_config->electronEfficiencySystematicModel() != "TOTAL") {
111  top::check(
112  m_electronEffSFIsoLooseCorrModel.retrieve(),
113  "Failed to retrieve loose electron SF Tool for correlation model");
114  }
115  }
116  MsgStream& msgInfo = msg(MSG::Level::INFO);
117  // ChargeID efficiency and Charge mis-identification scale factors: to apply when enabling Electron Charge ID
118  // Selector
119  if (asg::ToolStore::contains<IAsgElectronEfficiencyCorrectionTool> ("AsgElectronEfficiencyCorrectionTool_ChargeID"))
120  {
121  m_electronEffChargeID_exists = true; // this scale factor currently exists only for MediumLHH electron
122  top::check(m_electronEffSFChargeID.retrieve(), "Failed to retrieve electron charge flip efficiency SF Tool");
123  msgInfo << "------>Systematics:\n";
124  for (auto sys:m_electronEffSFChargeID->recommendedSystematics())
125  msgInfo << "---> " << sys << "\n";
126  }
127  if (asg::ToolStore::contains<IAsgElectronEfficiencyCorrectionTool> (
128  "AsgElectronEfficiencyCorrectionTool_ChargeIDLoose")) {
129  m_electronEffChargeIDLoose_exists = true; // this scale factor currently exists only for MediumLHH electron
130  top::check(m_electronEffSFChargeIDLoose.retrieve(), "Failed to retrieve electron charge flip efficiency SF Tool");
131  msgInfo << "------>Systematics:\n";
132  for (auto sys:m_electronEffSFChargeIDLoose->recommendedSystematics())
133  msgInfo << "---> " << sys << "\n";
134  }
135  if (asg::ToolStore::contains<CP::ElectronChargeEfficiencyCorrectionTool> ("ElectronChargeEfficiencyCorrection") &&
136  m_config->doPileupReweighting()) { // tool requires RandomRunNumber set from it
137  m_electronEffChargeMisID_exists = true;
138  top::check(m_electronEffSFChargeMisID.retrieve(), "Failed to retrieve electron charge mis-id SF Tool");
139  msgInfo << "------>Systematics:\n";
140  for (auto sys:m_electronEffSFChargeMisID->recommendedSystematics())
141  msgInfo << "---> " << sys << "\n";
142  }
143  if (asg::ToolStore::contains<CP::ElectronChargeEfficiencyCorrectionTool> ("ElectronChargeEfficiencyCorrectionLoose")
144  &&
145  m_config->doPileupReweighting()) { // tool requires RandomRunNumber set from it
146  m_electronEffChargeMisIDLoose_exists = true;
147  top::check(m_electronEffSFChargeMisIDLoose.retrieve(), "Failed to retrieve electron charge mis-id SF Tool");
148  msgInfo << "------>Systematics:\n";
149  for (auto sys:m_electronEffSFChargeMisIDLoose->recommendedSystematics())
150  msgInfo << "---> " << sys << "\n";
151  }
152  msgInfo.doOutput();
153 
154  // If the isolation SF doesn't exist then check why...
155  // it is possible to continue if explicitly SFs are disabled via ElectronIsolationSF
156  if (!m_electronEffIso_exists) {
157  if (m_config->electronIsolationSF() != "None") {
158  ATH_MSG_ERROR("Electron isolation SFs not available."
159  " You can run with ElectronIsolationSF set to None if you don't need the SF.");
160  return StatusCode::FAILURE;
161  }
162  }
163  if (!m_electronEffIsoLoose_exists) {
164  if (m_config->electronIsolationSFLoose() != "None") {
165  ATH_MSG_ERROR("Electron loose isolation SFs not available."
166  " You can run with ElectronIsolationSFLoose set to None if you don't need the SF.");
167  return StatusCode::FAILURE;
168  }
169  }
170 
171  top::check(m_electronEffSFID.retrieve(), "Failed to retrieve electron SF Tool");
172  top::check(m_electronEffSFIDLoose.retrieve(), "Failed to retrieve electron SF Tool");
173 
174  if (m_config->electronEfficiencySystematicModel() != "TOTAL") {
175  top::check(m_electronEffSFIDCorrModel.retrieve(), "Failed to retrieve electron SF Tool for correlation model");
176  top::check(m_electronEffSFIDLooseCorrModel.retrieve(),
177  "Failed to retrieve electron SF Tool for correlation model");
178  }
179 
180  m_systTrigger_UP.insert(CP::SystematicVariation("EL_EFF_Trigger_TOTAL_1NPCOR_PLUS_UNCOR", 1));
181  m_systTrigger_DOWN.insert(CP::SystematicVariation("EL_EFF_Trigger_TOTAL_1NPCOR_PLUS_UNCOR", -1));
182  m_systReco_UP.insert(CP::SystematicVariation("EL_EFF_Reco_TOTAL_1NPCOR_PLUS_UNCOR", 1));
183  m_systReco_DOWN.insert(CP::SystematicVariation("EL_EFF_Reco_TOTAL_1NPCOR_PLUS_UNCOR", -1));
184  m_systID_UP.insert(CP::SystematicVariation("EL_EFF_ID_TOTAL_1NPCOR_PLUS_UNCOR", 1));
185  m_systID_DOWN.insert(CP::SystematicVariation("EL_EFF_ID_TOTAL_1NPCOR_PLUS_UNCOR", -1));
186  m_systIso_UP.insert(CP::SystematicVariation("EL_EFF_Iso_TOTAL_1NPCOR_PLUS_UNCOR", 1));
187  m_systIso_DOWN.insert(CP::SystematicVariation("EL_EFF_Iso_TOTAL_1NPCOR_PLUS_UNCOR", -1));
188  m_systIso_UP.insert(CP::SystematicVariation("EL_EFF_Iso_TOTAL_1NPCOR_PLUS_UNCOR", 1));
189  m_systIso_DOWN.insert(CP::SystematicVariation("EL_EFF_Iso_TOTAL_1NPCOR_PLUS_UNCOR", -1));
190  m_systChargeID_UP.insert(CP::SystematicVariation("EL_EFF_ChargeIDSel_TOTAL_1NPCOR_PLUS_UNCOR", 1));
191  m_systChargeID_DOWN.insert(CP::SystematicVariation("EL_EFF_ChargeIDSel_TOTAL_1NPCOR_PLUS_UNCOR", -1));
192  m_systChargeMisID_STAT_UP.insert(CP::SystematicVariation("EL_CHARGEID_STAT", 1));
193  m_systChargeMisID_STAT_DOWN.insert(CP::SystematicVariation("EL_CHARGEID_STAT", -1));
194  m_systChargeMisID_SYST_UP.insert(CP::SystematicVariation("EL_CHARGEID_SYStotal", 1));
195  m_systChargeMisID_SYST_DOWN.insert(CP::SystematicVariation("EL_CHARGEID_SYStotal", -1));
196 
197  if (m_config->electronEfficiencySystematicModel() != "TOTAL" && m_config->electronEfficiencySystematicModel() != "COMBMCTOYS") {
198  CP::SystematicSet triggerSet = m_electronEffSFTrigger->recommendedSystematics(); //currently we have only the
199  // TOTAL model implemented for
200  // trigger SF, it's useless to
201  // use an advanced model here
202  CP::SystematicSet recoSet = m_electronEffSFRecoCorrModel->recommendedSystematics();
203  CP::SystematicSet idSet = m_electronEffSFIDCorrModel->recommendedSystematics();
204  CP::SystematicSet isoSet = m_electronEffSFIsoCorrModel->recommendedSystematics();
205 
206  m_systTriggerCorrModel = CP::make_systematics_vector(triggerSet);
207  m_systRecoCorrModel = CP::make_systematics_vector(recoSet);
208  m_systIDCorrModel = CP::make_systematics_vector(idSet);
209  m_systIsoCorrModel = CP::make_systematics_vector(isoSet);
210 
211  ATH_MSG_INFO(
212  "For electron RECO, ID, ISOLATION using the correlation model " <<
213  m_config->electronEfficiencySystematicModel());
214  int count = 0, count2 = 0;
215  for (const CP::SystematicSet& isyst : m_systRecoCorrModel) {
216  count++;
217  if (count % 2 == 1) continue;
218  TString name = isyst.name();
219  name.ReplaceAll("__1down", "");
220  ATH_MSG_INFO(
221  "--->electron RECO " << m_config->electronEfficiencySystematicModel() << " component " << (count2++) << " is " <<
222  name);
223  }
224 
225  m_config->electronEfficiencySystematicModelRecoSize(count2);
226 
227 
228  count = 0;
229  count2 = 0;
230  for (const CP::SystematicSet& isyst : m_systIDCorrModel) {
231  count++;
232  if (count % 2 == 1) continue;
233  TString name = isyst.name();
234  name.ReplaceAll("__1down", "");
235  ATH_MSG_INFO(
236  "--->electron ID " << m_config->electronEfficiencySystematicModel() << " component " << (count2++) << " is " <<
237  name);
238  }
239 
240  m_config->electronEfficiencySystematicModelIdSize(count2);
241 
242 
243 
244  count = 0;
245  count2 = 0;
246  for (const CP::SystematicSet& isyst : m_systIsoCorrModel) {
247  count++;
248  if (count % 2 == 1) continue;
249  TString name = isyst.name();
250  name.ReplaceAll("__1down", "");
251  ATH_MSG_INFO(
252  "--->electron ISO " << m_config->electronEfficiencySystematicModel() << " component " << (count2++) << " is " <<
253  name);
254  }
255 
256  m_config->electronEfficiencySystematicModelIsoSize(count2);
257 
258 
259  }
260 
261 
262  if (m_config->electronEfficiencySystematicModel() == "COMBMCTOYS") {
263  CP::SystematicSet triggerSet = m_electronEffSFTrigger->recommendedSystematics(); //currently we have only the
264  // TOTAL model implemented for
265  // trigger SF, it's useless to
266  // use an advanced model here
267  CP::SystematicSet recoSet = m_electronEffSFRecoCorrModel->recommendedSystematics();
268  CP::SystematicSet idSet = m_electronEffSFIDCorrModel->recommendedSystematics();
269  CP::SystematicSet isoSet = m_electronEffSFIsoCorrModel->recommendedSystematics();
270 
271 
272  CP::MakeSystematicsVector recosysVecToys;
273  CP::MakeSystematicsVector idsysVecToys;
274  CP::MakeSystematicsVector isosysVecToys;
275 
276  recosysVecToys.addGroup("toys");
277  idsysVecToys.addGroup("toys");
278  isosysVecToys.addGroup("toys");
279 
280  recosysVecToys.setToys( m_config->electronEfficiencySystematicModelNToys() );
281  idsysVecToys.setToys( m_config->electronEfficiencySystematicModelNToys() );
282  isosysVecToys.setToys( m_config->electronEfficiencySystematicModelNToys() );
283 
284  recosysVecToys.calc(recoSet);
285  idsysVecToys.calc(idSet);
286  isosysVecToys.calc(isoSet);
287 
288  m_systRecoCorrModel=recosysVecToys.result("toys");
289  m_systIDCorrModel =idsysVecToys.result("toys");
290  m_systIsoCorrModel =isosysVecToys.result("toys");
291 
292  m_systTriggerCorrModel = CP::make_systematics_vector(triggerSet);
293 
294  ATH_MSG_INFO(
295  "For electron RECO, ID, ISOLATION using the correlation model " <<
296  m_config->electronEfficiencySystematicModel());
297  int count = 0;
298  for (const CP::SystematicSet& isyst : m_systRecoCorrModel) {
299  TString name = isyst.name();
300  ATH_MSG_INFO(
301  "--->electron RECO " << m_config->electronEfficiencySystematicModel() << " component " << count << " is " <<
302  name);
303  count++;
304  }
305  m_config->electronEfficiencySystematicModelRecoSize(count);
306 
307 
308  count = 0;
309  for (const CP::SystematicSet& isyst : m_systIDCorrModel) {
310  TString name = isyst.name();
311  ATH_MSG_INFO(
312  "--->electron ID " << m_config->electronEfficiencySystematicModel() << " component " << count << " is " <<
313  name);
314  count++;
315  }
316  m_config->electronEfficiencySystematicModelIdSize(count);
317 
318 
319  count = 0;
320  for (const CP::SystematicSet& isyst : m_systIsoCorrModel) {
321  TString name = isyst.name();
322  ATH_MSG_INFO(
323  "--->electron ISO " << m_config->electronEfficiencySystematicModel() << " component " << count << " is " <<
324  name);
325  count++;
326  }
327  m_config->electronEfficiencySystematicModelIsoSize(count);
328 
329 
330 
331  }
332 
333  m_decor_triggerEff = "EL_EFF_Trigger_" + m_config->electronID();
334  m_decor_triggerEff_loose = "EL_LOOSE_EFF_Trigger_" + m_config->electronIDLoose();
335  m_decor_triggerSF = "EL_SF_Trigger_" + m_config->electronID();
336  m_decor_triggerSF_loose = "EL_LOOSE_SF_Trigger_" + m_config->electronIDLoose();
337  m_decor_recoSF = "EL_SF_Reco";
338  m_decor_idSF = "EL_SF_ID_" + m_config->electronID();
339  m_decor_idSF_loose = "EL_LOOSE_SF_ID_" + m_config->electronIDLoose();
340  m_decor_isoSF = "EL_SF_Iso_" + m_config->electronIsolationSF();
341  m_decor_isoSF_loose = "EL_LOOSE_SF_Iso_" + m_config->electronIsolationSFLoose();
342  m_decor_chargeidSF = "EL_SF_ChargeID_" + m_config->electronID() + "_" + m_config->electronIsolation();
343  m_decor_chargeidSF_loose = "EL_LOOSE_SF_ChargeID_" + m_config->electronIDLoose() + "_" +
344  m_config->electronIsolationLoose();
345  m_decor_chargemisidSF = "EL_SF_ChargeMisID_" + m_config->electronID() + "_" + m_config->electronIsolation();
346  m_decor_chargemisidSF_loose = "EL_LOOSE_SF_ChargeMisID_" + m_config->electronIDLoose() + "_" +
347  m_config->electronIsolationLoose();
348 
349  return StatusCode::SUCCESS;
350  }

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

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

◆ operator=()

ElectronScaleFactorCalculator& top::ElectronScaleFactorCalculator::operator= ( const ElectronScaleFactorCalculator &  rhs)
delete

◆ 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 JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, top::TopObjectSelection, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

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

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

std::shared_ptr<top::TopConfig> top::ElectronScaleFactorCalculator::m_config
private

Definition at line 55 of file ElectronScaleFactorCalculator.h.

◆ m_decor_chargeidSF

std::string top::ElectronScaleFactorCalculator::m_decor_chargeidSF
private

Definition at line 120 of file ElectronScaleFactorCalculator.h.

◆ m_decor_chargeidSF_loose

std::string top::ElectronScaleFactorCalculator::m_decor_chargeidSF_loose
private

Definition at line 121 of file ElectronScaleFactorCalculator.h.

◆ m_decor_chargemisidSF

std::string top::ElectronScaleFactorCalculator::m_decor_chargemisidSF
private

Definition at line 122 of file ElectronScaleFactorCalculator.h.

◆ m_decor_chargemisidSF_loose

std::string top::ElectronScaleFactorCalculator::m_decor_chargemisidSF_loose
private

Definition at line 123 of file ElectronScaleFactorCalculator.h.

◆ m_decor_idSF

std::string top::ElectronScaleFactorCalculator::m_decor_idSF
private

Definition at line 116 of file ElectronScaleFactorCalculator.h.

◆ m_decor_idSF_loose

std::string top::ElectronScaleFactorCalculator::m_decor_idSF_loose
private

Definition at line 117 of file ElectronScaleFactorCalculator.h.

◆ m_decor_isoSF

std::string top::ElectronScaleFactorCalculator::m_decor_isoSF
private

Definition at line 118 of file ElectronScaleFactorCalculator.h.

◆ m_decor_isoSF_loose

std::string top::ElectronScaleFactorCalculator::m_decor_isoSF_loose
private

Definition at line 119 of file ElectronScaleFactorCalculator.h.

◆ m_decor_recoSF

std::string top::ElectronScaleFactorCalculator::m_decor_recoSF
private

Definition at line 115 of file ElectronScaleFactorCalculator.h.

◆ m_decor_triggerEff

std::string top::ElectronScaleFactorCalculator::m_decor_triggerEff
private

Definition at line 111 of file ElectronScaleFactorCalculator.h.

◆ m_decor_triggerEff_loose

std::string top::ElectronScaleFactorCalculator::m_decor_triggerEff_loose
private

Definition at line 112 of file ElectronScaleFactorCalculator.h.

◆ m_decor_triggerSF

std::string top::ElectronScaleFactorCalculator::m_decor_triggerSF
private

Definition at line 113 of file ElectronScaleFactorCalculator.h.

◆ m_decor_triggerSF_loose

std::string top::ElectronScaleFactorCalculator::m_decor_triggerSF_loose
private

Definition at line 114 of file ElectronScaleFactorCalculator.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_electronEffChargeID_exists

bool top::ElectronScaleFactorCalculator::m_electronEffChargeID_exists
private

Definition at line 92 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffChargeIDLoose_exists

bool top::ElectronScaleFactorCalculator::m_electronEffChargeIDLoose_exists
private

Definition at line 93 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffChargeMisID_exists

bool top::ElectronScaleFactorCalculator::m_electronEffChargeMisID_exists
private

Definition at line 94 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffChargeMisIDLoose_exists

bool top::ElectronScaleFactorCalculator::m_electronEffChargeMisIDLoose_exists
private

Definition at line 95 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffIso_exists

bool top::ElectronScaleFactorCalculator::m_electronEffIso_exists
private

Definition at line 86 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffIsoLoose_exists

bool top::ElectronScaleFactorCalculator::m_electronEffIsoLoose_exists
private

Definition at line 87 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFChargeID

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFChargeID
private

Definition at line 96 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFChargeIDLoose

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFChargeIDLoose
private

Definition at line 97 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFChargeMisID

ToolHandle<CP::ElectronChargeEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFChargeMisID
private

Definition at line 98 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFChargeMisIDLoose

ToolHandle<CP::ElectronChargeEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFChargeMisIDLoose
private

Definition at line 99 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFID

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFID
private

Definition at line 83 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFIDCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFIDCorrModel
private

Definition at line 106 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFIDLoose

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFIDLoose
private

Definition at line 84 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFIDLooseCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFIDLooseCorrModel
private

Definition at line 107 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFIso

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFIso
private

Definition at line 88 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFIsoCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFIsoCorrModel
private

Definition at line 108 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFIsoLoose

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFIsoLoose
private

Definition at line 89 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFIsoLooseCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFIsoLooseCorrModel
private

Definition at line 109 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFReco

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFReco
private

Definition at line 82 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFRecoCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFRecoCorrModel
private

Definition at line 105 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFTrigger

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFTrigger
private

Definition at line 78 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFTriggerCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFTriggerCorrModel
private

Definition at line 101 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFTriggerLoose

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFTriggerLoose
private

Definition at line 79 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffSFTriggerLooseCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffSFTriggerLooseCorrModel
private

Definition at line 102 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffTrigger

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffTrigger
private

Definition at line 80 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffTriggerCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffTriggerCorrModel
private

Definition at line 103 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffTriggerLoose

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffTriggerLoose
private

Definition at line 81 of file ElectronScaleFactorCalculator.h.

◆ m_electronEffTriggerLooseCorrModel

ToolHandle<IAsgElectronEfficiencyCorrectionTool> top::ElectronScaleFactorCalculator::m_electronEffTriggerLooseCorrModel
private

Definition at line 104 of file ElectronScaleFactorCalculator.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_systChargeID_DOWN

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systChargeID_DOWN
private

Definition at line 67 of file ElectronScaleFactorCalculator.h.

◆ m_systChargeID_UP

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systChargeID_UP
private

Definition at line 66 of file ElectronScaleFactorCalculator.h.

◆ m_systChargeMisID_STAT_DOWN

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systChargeMisID_STAT_DOWN
private

Definition at line 69 of file ElectronScaleFactorCalculator.h.

◆ m_systChargeMisID_STAT_UP

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systChargeMisID_STAT_UP
private

Definition at line 68 of file ElectronScaleFactorCalculator.h.

◆ m_systChargeMisID_SYST_DOWN

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systChargeMisID_SYST_DOWN
private

Definition at line 71 of file ElectronScaleFactorCalculator.h.

◆ m_systChargeMisID_SYST_UP

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systChargeMisID_SYST_UP
private

Definition at line 70 of file ElectronScaleFactorCalculator.h.

◆ m_systID_DOWN

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systID_DOWN
private

Definition at line 63 of file ElectronScaleFactorCalculator.h.

◆ m_systID_UP

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systID_UP
private

Definition at line 62 of file ElectronScaleFactorCalculator.h.

◆ m_systIDCorrModel

std::vector<CP::SystematicSet> top::ElectronScaleFactorCalculator::m_systIDCorrModel
private

Definition at line 75 of file ElectronScaleFactorCalculator.h.

◆ m_systIso_DOWN

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systIso_DOWN
private

Definition at line 65 of file ElectronScaleFactorCalculator.h.

◆ m_systIso_UP

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systIso_UP
private

Definition at line 64 of file ElectronScaleFactorCalculator.h.

◆ m_systIsoCorrModel

std::vector<CP::SystematicSet> top::ElectronScaleFactorCalculator::m_systIsoCorrModel
private

Definition at line 76 of file ElectronScaleFactorCalculator.h.

◆ m_systNominal

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systNominal
private

Definition at line 57 of file ElectronScaleFactorCalculator.h.

◆ m_systReco_DOWN

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systReco_DOWN
private

Definition at line 61 of file ElectronScaleFactorCalculator.h.

◆ m_systReco_UP

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systReco_UP
private

Definition at line 60 of file ElectronScaleFactorCalculator.h.

◆ m_systRecoCorrModel

std::vector<CP::SystematicSet> top::ElectronScaleFactorCalculator::m_systRecoCorrModel
private

Definition at line 74 of file ElectronScaleFactorCalculator.h.

◆ m_systTrigger_DOWN

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systTrigger_DOWN
private

Definition at line 59 of file ElectronScaleFactorCalculator.h.

◆ m_systTrigger_UP

CP::SystematicSet top::ElectronScaleFactorCalculator::m_systTrigger_UP
private

Definition at line 58 of file ElectronScaleFactorCalculator.h.

◆ m_systTriggerCorrModel

std::vector<CP::SystematicSet> top::ElectronScaleFactorCalculator::m_systTriggerCorrModel
private

Definition at line 73 of file ElectronScaleFactorCalculator.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:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
top::ElectronScaleFactorCalculator::m_systReco_DOWN
CP::SystematicSet m_systReco_DOWN
Definition: ElectronScaleFactorCalculator.h:61
top::ElectronScaleFactorCalculator::m_electronEffTriggerCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffTriggerCorrModel
Definition: ElectronScaleFactorCalculator.h:103
top::ElectronScaleFactorCalculator::m_systTrigger_UP
CP::SystematicSet m_systTrigger_UP
Definition: ElectronScaleFactorCalculator.h:58
top::ElectronScaleFactorCalculator::m_electronEffIsoLoose_exists
bool m_electronEffIsoLoose_exists
Definition: ElectronScaleFactorCalculator.h:87
top::ElectronScaleFactorCalculator::m_systRecoCorrModel
std::vector< CP::SystematicSet > m_systRecoCorrModel
Definition: ElectronScaleFactorCalculator.h:74
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
CP::MakeSystematicsVector
This class handles turning the list of systematics into the actual list of nuisance parameter points ...
Definition: MakeSystematicsVector.h:34
top::ElectronScaleFactorCalculator::m_electronEffSFTrigger
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFTrigger
Definition: ElectronScaleFactorCalculator.h:78
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
top::ElectronScaleFactorCalculator::m_electronEffSFIso
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIso
Definition: ElectronScaleFactorCalculator.h:88
top::ElectronScaleFactorCalculator::m_electronEffSFIsoCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIsoCorrModel
Definition: ElectronScaleFactorCalculator.h:108
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CP::make_systematics_vector
std::vector< CP::SystematicSet > make_systematics_vector(const SystematicSet &systematics)
utility functions for working with systematics
Definition: SystematicsUtil.cxx:25
top::ElectronScaleFactorCalculator::m_electronEffTriggerLoose
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffTriggerLoose
Definition: ElectronScaleFactorCalculator.h:81
top::ElectronScaleFactorCalculator::m_electronEffSFID
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFID
Definition: ElectronScaleFactorCalculator.h:83
top::ElectronScaleFactorCalculator::m_decor_isoSF_loose
std::string m_decor_isoSF_loose
Definition: ElectronScaleFactorCalculator.h:119
top::ElectronScaleFactorCalculator::m_electronEffIso_exists
bool m_electronEffIso_exists
Definition: ElectronScaleFactorCalculator.h:86
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
top::ElectronScaleFactorCalculator::m_electronEffTriggerLooseCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffTriggerLooseCorrModel
Definition: ElectronScaleFactorCalculator.h:104
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
top::ElectronScaleFactorCalculator::m_systTriggerCorrModel
std::vector< CP::SystematicSet > m_systTriggerCorrModel
Definition: ElectronScaleFactorCalculator.h:73
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
top::ElectronScaleFactorCalculator::m_electronEffChargeIDLoose_exists
bool m_electronEffChargeIDLoose_exists
Definition: ElectronScaleFactorCalculator.h:93
top::ElectronScaleFactorCalculator::m_systTrigger_DOWN
CP::SystematicSet m_systTrigger_DOWN
Definition: ElectronScaleFactorCalculator.h:59
top::ElectronScaleFactorCalculator::m_decor_chargeidSF_loose
std::string m_decor_chargeidSF_loose
Definition: ElectronScaleFactorCalculator.h:121
top::ElectronScaleFactorCalculator::m_electronEffSFTriggerLoose
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFTriggerLoose
Definition: ElectronScaleFactorCalculator.h:79
top::ElectronScaleFactorCalculator::m_decor_recoSF
std::string m_decor_recoSF
Definition: ElectronScaleFactorCalculator.h:115
top::ElectronScaleFactorCalculator::m_electronEffSFIsoLooseCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIsoLooseCorrModel
Definition: ElectronScaleFactorCalculator.h:109
top::ElectronScaleFactorCalculator::m_systID_DOWN
CP::SystematicSet m_systID_DOWN
Definition: ElectronScaleFactorCalculator.h:63
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
CP::SystematicVariation
Definition: SystematicVariation.h:47
top::ElectronScaleFactorCalculator::m_decor_isoSF
std::string m_decor_isoSF
Definition: ElectronScaleFactorCalculator.h:118
top::ElectronScaleFactorCalculator::m_systChargeMisID_STAT_DOWN
CP::SystematicSet m_systChargeMisID_STAT_DOWN
Definition: ElectronScaleFactorCalculator.h:69
top::ElectronScaleFactorCalculator::m_electronEffSFChargeMisID
ToolHandle< CP::ElectronChargeEfficiencyCorrectionTool > m_electronEffSFChargeMisID
Definition: ElectronScaleFactorCalculator.h:98
top::ElectronScaleFactorCalculator::m_electronEffSFIDCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIDCorrModel
Definition: ElectronScaleFactorCalculator.h:106
top::ElectronScaleFactorCalculator::m_systChargeID_DOWN
CP::SystematicSet m_systChargeID_DOWN
Definition: ElectronScaleFactorCalculator.h:67
mapkey::sys
@ sys
Definition: TElectronEfficiencyCorrectionTool.cxx:42
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
top::ElectronScaleFactorCalculator::m_electronEffSFRecoCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFRecoCorrModel
Definition: ElectronScaleFactorCalculator.h:105
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
CP::MakeSystematicsVector::result
const std::vector< SystematicSet > & result(const std::string &label) const
the list of nuisance parameter points generated with the given label
Definition: MakeSystematicsVector.cxx:81
CP::MakeSystematicsVector::addGroup
void addGroup(const std::string &val_label)
finish configuration for this group and add a new one
Definition: MakeSystematicsVector.cxx:183
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
top::ElectronScaleFactorCalculator::m_decor_chargemisidSF
std::string m_decor_chargemisidSF
Definition: ElectronScaleFactorCalculator.h:122
top::ElectronScaleFactorCalculator::m_systNominal
CP::SystematicSet m_systNominal
Definition: ElectronScaleFactorCalculator.h:57
top::ElectronScaleFactorCalculator::m_systChargeMisID_SYST_UP
CP::SystematicSet m_systChargeMisID_SYST_UP
Definition: ElectronScaleFactorCalculator.h:70
top::ElectronScaleFactorCalculator::m_systIso_DOWN
CP::SystematicSet m_systIso_DOWN
Definition: ElectronScaleFactorCalculator.h:65
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
top::ElectronScaleFactorCalculator::m_electronEffChargeMisIDLoose_exists
bool m_electronEffChargeMisIDLoose_exists
Definition: ElectronScaleFactorCalculator.h:95
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
top::ElectronScaleFactorCalculator::m_decor_triggerEff
std::string m_decor_triggerEff
Definition: ElectronScaleFactorCalculator.h:111
top::check
void check(bool thingToCheck, const std::string &usefulFailureMessage)
Print an error message and terminate if thingToCheck is false.
Definition: EventTools.cxx:15
python.xAODType.dummy
dummy
Definition: xAODType.py:4
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
top::ElectronScaleFactorCalculator::m_electronEffSFChargeMisIDLoose
ToolHandle< CP::ElectronChargeEfficiencyCorrectionTool > m_electronEffSFChargeMisIDLoose
Definition: ElectronScaleFactorCalculator.h:99
top::ElectronScaleFactorCalculator::m_electronEffSFChargeID
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFChargeID
Definition: ElectronScaleFactorCalculator.h:96
top::ElectronScaleFactorCalculator::m_systIsoCorrModel
std::vector< CP::SystematicSet > m_systIsoCorrModel
Definition: ElectronScaleFactorCalculator.h:76
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
top::ElectronScaleFactorCalculator::m_config
std::shared_ptr< top::TopConfig > m_config
Definition: ElectronScaleFactorCalculator.h:55
top::ElectronScaleFactorCalculator::m_systIso_UP
CP::SystematicSet m_systIso_UP
Definition: ElectronScaleFactorCalculator.h:64
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
top::ElectronScaleFactorCalculator::m_electronEffSFIDLoose
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIDLoose
Definition: ElectronScaleFactorCalculator.h:84
top::ElectronScaleFactorCalculator::m_electronEffChargeID_exists
bool m_electronEffChargeID_exists
Definition: ElectronScaleFactorCalculator.h:92
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
top::ElectronScaleFactorCalculator::m_electronEffSFTriggerLooseCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFTriggerLooseCorrModel
Definition: ElectronScaleFactorCalculator.h:102
top::ElectronScaleFactorCalculator::m_decor_chargemisidSF_loose
std::string m_decor_chargemisidSF_loose
Definition: ElectronScaleFactorCalculator.h:123
top::ElectronScaleFactorCalculator::m_decor_triggerSF_loose
std::string m_decor_triggerSF_loose
Definition: ElectronScaleFactorCalculator.h:114
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
top::ElectronScaleFactorCalculator::m_decor_triggerSF
std::string m_decor_triggerSF
Definition: ElectronScaleFactorCalculator.h:113
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:192
top::ElectronScaleFactorCalculator::m_systChargeMisID_STAT_UP
CP::SystematicSet m_systChargeMisID_STAT_UP
Definition: ElectronScaleFactorCalculator.h:68
top::ElectronScaleFactorCalculator::m_electronEffSFTriggerCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFTriggerCorrModel
Definition: ElectronScaleFactorCalculator.h:101
a
TList * a
Definition: liststreamerinfos.cxx:10
h
top::ElectronScaleFactorCalculator::m_decor_idSF
std::string m_decor_idSF
Definition: ElectronScaleFactorCalculator.h:116
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:16
top::ElectronScaleFactorCalculator::m_systIDCorrModel
std::vector< CP::SystematicSet > m_systIDCorrModel
Definition: ElectronScaleFactorCalculator.h:75
CP::MakeSystematicsVector::setToys
void setToys(unsigned val_toys)
set the number of toys to run for this group
Definition: MakeSystematicsVector.cxx:213
top::ElectronScaleFactorCalculator::m_systChargeMisID_SYST_DOWN
CP::SystematicSet m_systChargeMisID_SYST_DOWN
Definition: ElectronScaleFactorCalculator.h:71
top::ElectronScaleFactorCalculator::m_decor_idSF_loose
std::string m_decor_idSF_loose
Definition: ElectronScaleFactorCalculator.h:117
top::ElectronScaleFactorCalculator::m_electronEffSFIDLooseCorrModel
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIDLooseCorrModel
Definition: ElectronScaleFactorCalculator.h:107
top::ElectronScaleFactorCalculator::m_systID_UP
CP::SystematicSet m_systID_UP
Definition: ElectronScaleFactorCalculator.h:62
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CP::MakeSystematicsVector::calc
void calc(const SystematicSet &sysList)
fill in result
Definition: MakeSystematicsVector.cxx:94
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
top::ElectronScaleFactorCalculator::m_systReco_UP
CP::SystematicSet m_systReco_UP
Definition: ElectronScaleFactorCalculator.h:60
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
top::ElectronScaleFactorCalculator::m_systChargeID_UP
CP::SystematicSet m_systChargeID_UP
Definition: ElectronScaleFactorCalculator.h:66
top::ElectronScaleFactorCalculator::m_decor_triggerEff_loose
std::string m_decor_triggerEff_loose
Definition: ElectronScaleFactorCalculator.h:112
SG::DataProxy
Definition: DataProxy.h:44
top::ElectronScaleFactorCalculator::m_electronEffSFChargeIDLoose
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFChargeIDLoose
Definition: ElectronScaleFactorCalculator.h:97
top::ElectronScaleFactorCalculator::m_electronEffSFIsoLoose
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFIsoLoose
Definition: ElectronScaleFactorCalculator.h:89
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
top::ElectronScaleFactorCalculator::m_electronEffChargeMisID_exists
bool m_electronEffChargeMisID_exists
Definition: ElectronScaleFactorCalculator.h:94
top::ElectronScaleFactorCalculator::m_electronEffTrigger
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffTrigger
Definition: ElectronScaleFactorCalculator.h:80
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
top::ElectronScaleFactorCalculator::m_electronEffSFReco
ToolHandle< IAsgElectronEfficiencyCorrectionTool > m_electronEffSFReco
Definition: ElectronScaleFactorCalculator.h:82
fitman.k
k
Definition: fitman.py:528
top::ElectronScaleFactorCalculator::m_decor_chargeidSF
std::string m_decor_chargeidSF
Definition: ElectronScaleFactorCalculator.h:120
Generated on Fri Jun 28 2024 22:29:34 for ATLAS Offline Software by   doxygen 1.8.18