ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
AsgElectronEfficiencyCorrectionTool Class Referencefinalabstract

#include <AsgElectronEfficiencyCorrectionTool.h>

Inheritance diagram for AsgElectronEfficiencyCorrectionTool:
Collaboration diagram for AsgElectronEfficiencyCorrectionTool:

Classes

struct  SystConf
 

Public Member Functions

virtual void print () const =0
 Print the state of the tool. More...
 
virtual StatusCode sysInitialize ()
 Function initialising the tool in the correct way in Athena. More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode 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

virtual ASG_TOOL_CLASS(AsgElectronEfficiencyCorrectionTool, IAsgElectronEfficiencyCorrectionTool) public ~AsgElectronEfficiencyCorrectionTool () override final
 Standard destructor. More...
 
virtual StatusCode initialize () override final
 Gaudi Service Interface method implementations. More...
 
virtual StatusCode beginInputFile () override final
 Function called when a new input file is opened. More...
 
virtual StatusCode beginEvent () override final
 Function called when a new events is loaded. More...
 
virtual CP::SystematicSet affectingSystematics () const override final
 returns: the list of all systematics this tool can be affected by More...
 
virtual CP::SystematicSet recommendedSystematics () const override final
 returns: the list of all systematics this tool recommends to use More...
 
virtual bool isAffectedBySystematic (const CP::SystematicVariation &systematic) const override final
 returns: whether this tool is affected by the given systematis More...
 
virtual StatusCode applySystematicVariation (const CP::SystematicSet &systConfig) override final
 Configure this tool for the given systematics. More...
 
virtual CP::CorrectionCode getEfficiencyScaleFactor (const xAOD::Electron &inputObject, double &efficiencyScaleFactor) const override final
 
virtual CP::CorrectionCode getEfficiencyScaleFactor (const double et, const double cluster_eta, const unsigned int runNumber, double &efficiencyScaleFactor) const override final
 
virtual CP::CorrectionCode applyEfficiencyScaleFactor (const xAOD::Electron &inputObject) const override final
 
virtual int getNumberOfToys () const override final
 
virtual void printCorrelationModels () const override final
 print available/implemented correlation models More...
 
virtual const CP::SystematicSet & appliedSystematics () const override final
 returns: the currently applied systematics More...
 
virtual int systUncorrVariationIndex (const xAOD::Electron &inputObject) const override final
 
StatusCode registerSystematics ()
 
int currentSimplifiedUncorrSystRegion (const double cluster_eta, const double et) const
 
int currentUncorrSystRegion (const double cluster_eta, const double et) const
 
StatusCode InitSystematics ()
 initialize the systematics More...
 
virtual StatusCode getFile (const std::string &recokey, const std::string &idkey, const std::string &isokey, const std::string &trigkey)
 Gets the correction filename from map. More...
 
StatusCode get_simType_from_metadata (PATCore::ParticleDataType::DataType &result) const
 
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

bool m_metadata_retrieved = false
 To check if the metadata can be retrieved. More...
 
std::unique_ptr< Root::TElectronEfficiencyCorrectionTool > m_rootTool = nullptr
 Pointer to the underlying ROOT based tool. More...
 
std::unordered_map< CP::SystematicSet, CP::SystematicSet > m_systFilter
 Systematics filter map. More...
 
CP::SystematicSet m_affectedSys
 Affected systematic, should be done only once. More...
 
CP::SystematicSet * m_appliedSystematics
 Currently applied systematics. More...
 
std::string m_correlation_model_name
 
int m_correlation_model
 
std::string m_mapFile
 
std::string m_recoKey
 
std::string m_idKey
 
std::string m_isoKey
 
std::string m_trigKey
 
std::vector< std::string > m_corrFileNameList
 The list of file names. More...
 
std::string m_resultPrefix
 The prefix string for the result. More...
 
std::string m_resultName
 The string for the result. More...
 
std::string m_sysSubstring
 
std::string m_eventInfoCollectionName
 The Event info collection name. More...
 
bool m_useRandomRunNumber
 
int m_defaultRandomRunNumber
 
PATCore::ParticleDataType::DataType m_dataType
 
int m_dataTypeOverwrite
 Force the data type to a given value. More...
 
int m_number_of_toys
 
int m_seed_toys
 
double m_scale_toys
 
int m_nCorrSyst
 
int m_nUncorrSyst
 
std::vector< std::pair< float, std::vector< float > > > m_pteta_bins
 
std::vector< float > m_uncorrSimplfEtaBinsUser
 
std::vector< float > m_uncorrSimplfEtBinsUser
 
TH2F * m_UncorrRegions
 
int m_nSimpleUncorrSyst
 
std::string m_toysBasename
 
std::vector< CP::SystematicVariation > m_corrVarUp
 
std::vector< CP::SystematicVariation > m_corrVarDown
 
std::vector< CP::SystematicVariation > m_uncorrVarUp
 
std::vector< CP::SystematicVariation > m_uncorrVarDown
 
MetaStore_t m_inputMetaStore
 Object accessing the input metadata store. More...
 
MetaStore_t m_outputMetaStore
 Object accessing the output metadata store. More...
 
bool m_beginInputFileCalled
 Flag helping to discover when the tool misses the opening of the first input file. More...
 
bool m_useIncidents
 
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 33 of file AsgElectronEfficiencyCorrectionTool.h.

Member Typedef Documentation

◆ MetaStore_t

typedef ServiceHandle< StoreGateSvc > asg::AsgMetadataTool::MetaStore_t
inherited

Type of the metadata store object in Athena.

Definition at line 66 of file AsgMetadataTool.h.

◆ MetaStorePtr_t

typedef const ServiceHandle< StoreGateSvc >& asg::AsgMetadataTool::MetaStorePtr_t
inherited

Type of the metadata store pointer in standalone mode.

Definition at line 68 of file AsgMetadataTool.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~AsgElectronEfficiencyCorrectionTool()

AsgElectronEfficiencyCorrectionTool::~AsgElectronEfficiencyCorrectionTool ( )
finaloverrideprivatevirtual

Standard destructor.

Definition at line 142 of file AsgElectronEfficiencyCorrectionTool.cxx.

143 {
144  if (m_UncorrRegions) {
145  delete m_UncorrRegions;
146  }
147 }

Member Function Documentation

◆ affectingSystematics()

CP::SystematicSet AsgElectronEfficiencyCorrectionTool::affectingSystematics ( ) const
finaloverrideprivatevirtual

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

Implements CP::IReentrantSystematicsTool.

Definition at line 556 of file AsgElectronEfficiencyCorrectionTool.cxx.

557 {
558  return m_affectedSys;
559 }

◆ appliedSystematics()

virtual const CP::SystematicSet& AsgElectronEfficiencyCorrectionTool::appliedSystematics ( ) const
inlinefinaloverrideprivatevirtual

returns: the currently applied systematics

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 102 of file AsgElectronEfficiencyCorrectionTool.h.

103  {
104  return *m_appliedSystematics;
105  }

◆ applyEfficiencyScaleFactor()

CP::CorrectionCode AsgElectronEfficiencyCorrectionTool::applyEfficiencyScaleFactor ( const xAOD::Electron &  inputObject) const
finaloverrideprivatevirtual

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 523 of file AsgElectronEfficiencyCorrectionTool.cxx.

525 {
526  double efficiencyScaleFactor = 1.0;
527  CP::CorrectionCode result =
528  getEfficiencyScaleFactor(inputObject, efficiencyScaleFactor);
529  const static SG::AuxElement::Decorator<float> dec(m_resultPrefix +
530  m_resultName + "SF");
531  dec(inputObject) = efficiencyScaleFactor;
532  return result;
533 }

◆ applySystematicVariation()

StatusCode AsgElectronEfficiencyCorrectionTool::applySystematicVariation ( const CP::SystematicSet &  systConfig)
finaloverrideprivatevirtual

Configure this tool for the given systematics.

Apply one variation at a time.

Implements CP::ISystematicsTool.

Definition at line 582 of file AsgElectronEfficiencyCorrectionTool.cxx.

584 {
585  // First, check if this configuration exists in the filtered map/registy
586  auto itr = m_systFilter.find(systConfig);
587 
588  if (itr != m_systFilter.end()) {
589  CP::SystematicSet& mySysConf = itr->second;
590  m_appliedSystematics = &mySysConf;
591  }
592  // if not, we should register it, after it passes sanity checks
593  else {
594  // If it's a new input set, we need to filter it
595  CP::SystematicSet affectingSys = affectingSystematics();
596  CP::SystematicSet filteredSys;
597  if (!CP::SystematicSet::filterForAffectingSystematics(
598  systConfig, affectingSys, filteredSys)) {
599  ATH_MSG_ERROR(
600  "Unsupported combination of systematic variations passed to the tool!");
601  return StatusCode::FAILURE;
602  }
603  // Does filtered make sense, only one per time
604  if (filteredSys.size() > 1) {
605  ATH_MSG_ERROR(
606  "More than one systematic variation passed at the same time");
607  return StatusCode::FAILURE;
608  }
609 
610  if (filteredSys.empty() && !systConfig.empty()) {
611  ATH_MSG_DEBUG("systematics : ");
612  for (const auto& syst : systConfig) {
613  ATH_MSG_DEBUG(syst.name());
614  }
615  ATH_MSG_DEBUG(" Not supported ");
616  }
617  // insert to the registy
618  itr = m_systFilter.insert(std::make_pair(systConfig, filteredSys)).first;
619  // And return directly
620  CP::SystematicSet& mySysConf = itr->second;
621  m_appliedSystematics = &mySysConf;
622  }
623  return StatusCode::SUCCESS;
624 }

◆ beginEvent()

StatusCode AsgElectronEfficiencyCorrectionTool::beginEvent ( )
finaloverrideprivatevirtual

Function called when a new events is loaded.

Dummy implementation that can be overridden by the derived tool.

Reimplemented from asg::AsgMetadataTool.

Definition at line 913 of file AsgElectronEfficiencyCorrectionTool.cxx.

914 {
915 
916  if (m_dataTypeOverwrite != -1)
917  return StatusCode::SUCCESS;
918  if (m_metadata_retrieved)
919  return StatusCode::SUCCESS;
920 
921  m_metadata_retrieved = true;
922  return StatusCode::SUCCESS;
923 }

◆ beginInputFile()

StatusCode AsgElectronEfficiencyCorrectionTool::beginInputFile ( )
finaloverrideprivatevirtual

Function called when a new input file is opened.

Dummy implementation that can be overridden by the derived tool.

Reimplemented from asg::AsgMetadataTool.

Definition at line 878 of file AsgElectronEfficiencyCorrectionTool.cxx.

879 {
880 
881  // User forced a particular dataType
882  if (m_dataTypeOverwrite != -1)
883  return StatusCode::SUCCESS;
884 
885  PATCore::ParticleDataType::DataType dataType_metadata;
886  const StatusCode status = get_simType_from_metadata(dataType_metadata);
887  // Metadata got retrieved
888  if (status == StatusCode::SUCCESS) {
889  m_metadata_retrieved = true;
890  ATH_MSG_DEBUG("metadata from new file: "
891  << (dataType_metadata == PATCore::ParticleDataType::Data
892  ? "data"
893  : (dataType_metadata == PATCore::ParticleDataType::Full
894  ? "full simulation"
895  : "fast simulation")));
896 
897  if (dataType_metadata != PATCore::ParticleDataType::Data) {
898  if (m_dataTypeOverwrite == -1) {
899  m_dataType = dataType_metadata;
900  } else {
901  ATH_MSG_DEBUG(
902  "Applying SF corrections to data while they make sense only for MC");
903  }
904  }
905  } else { // not able to retrieve metadata
906  m_metadata_retrieved = false;
907  ATH_MSG_DEBUG("not able to retrieve metadata");
908  }
909  return StatusCode::SUCCESS;
910 }

◆ currentSimplifiedUncorrSystRegion()

int AsgElectronEfficiencyCorrectionTool::currentSimplifiedUncorrSystRegion ( const double  cluster_eta,
const double  et 
) const
private

Definition at line 700 of file AsgElectronEfficiencyCorrectionTool.cxx.

703 {
704  int ptbin = std::as_const(*m_UncorrRegions).GetXaxis()->FindBin(et) - 1;
705  if (ptbin < 0 ||
706  ptbin >= std::as_const(*m_UncorrRegions).GetXaxis()->GetNbins()) {
707  ATH_MSG_WARNING(
708  " Found electron with Et = "
709  << et / 1000. << " GeV, where you specified boundaries of ["
710  << std::as_const(*m_UncorrRegions).GetXaxis()->GetBinLowEdge(1) << ","
711  << std::as_const(*m_UncorrRegions)
712  .GetXaxis()
713  ->GetBinUpEdge(
714  std::as_const(*m_UncorrRegions).GetXaxis()->GetNbins())
715  << "] for the SIMPLIFIED correlation model ");
716  return -1;
717  }
718  int etabin =
719  std::as_const(*m_UncorrRegions).GetYaxis()->FindBin(std::abs(cluster_eta)) -
720  1;
721  if (etabin < 0 ||
722  etabin >= std::as_const(*m_UncorrRegions).GetYaxis()->GetNbins()) {
723  ATH_MSG_WARNING(
724  " Found electron with |eta| = "
725  << std::abs(cluster_eta) << ", where you specified boundaries of ["
726  << std::as_const(*m_UncorrRegions).GetYaxis()->GetBinLowEdge(1) << ","
727  << std::as_const(*m_UncorrRegions)
728  .GetYaxis()
729  ->GetBinUpEdge(
730  std::as_const(*m_UncorrRegions).GetYaxis()->GetNbins())
731  << "] for the SIMPLIFIED correlation model ");
732  return -1;
733  }
734  int reg = ((etabin)*m_UncorrRegions->GetNbinsX() + ptbin);
735  return reg;
736 }

◆ currentUncorrSystRegion()

int AsgElectronEfficiencyCorrectionTool::currentUncorrSystRegion ( const double  cluster_eta,
const double  et 
) const
private

Definition at line 739 of file AsgElectronEfficiencyCorrectionTool.cxx.

742 {
743  int etabin = 0;
744  int reg = 0;
745  bool found = false;
746  float cluster_eta_electron = 0;
747  auto itr_ptBEGIN = m_pteta_bins.begin();
748  auto itr_ptEND = m_pteta_bins.end();
749  for (; itr_ptBEGIN != itr_ptEND; ++itr_ptBEGIN) {
750  auto itr_ptBEGINplusOne = itr_ptBEGIN;
751  ++itr_ptBEGINplusOne;
752  // Find the pt bin : Larger or equal from the current and the next one is
753  // the last or the next one is larger.
754  if (et >= itr_ptBEGIN->first &&
755  (itr_ptBEGINplusOne == itr_ptEND || et < itr_ptBEGINplusOne->first)) {
756  if ((itr_ptBEGIN->second).at(0) >= 0) {
757  cluster_eta_electron = std::abs(cluster_eta);
758  } else {
759  cluster_eta_electron = (cluster_eta);
760  };
761  for (unsigned int etab = 0; etab < ((itr_ptBEGIN->second).size());
762  ++etab) {
763  unsigned int etabnext = etab + 1;
764  // Find the eta bin : Larger or equal from the current and the next one
765  // is the last or the next one is larger:.
766  if ((cluster_eta_electron) >= (itr_ptBEGIN->second).at(etab) &&
767  (etabnext == itr_ptBEGIN->second.size() ||
768  cluster_eta_electron < itr_ptBEGIN->second.at(etabnext))) {
769  found = true;
770  break;
771  }
772  // We did not find it. Increment eta and continue looking
773  etabin++;
774  }
775  }
776  if (found) {
777  break;
778  }
779  // Add the full size of the "passed" eta row
780  reg += (itr_ptBEGIN->second).size();
781  }
782  if (!found) {
783  ATH_MSG_WARNING("No index for the uncorrelated systematic was found, "
784  "returning the maximum index");
785  return m_nCorrSyst;
786  }
787  reg = reg + etabin;
788  return reg;
789 }

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

◆ endInputFile()

StatusCode asg::AsgMetadataTool::endInputFile ( )
protectedvirtualinherited

Function called when the currently open input file got completely processed.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in BookkeeperTool, HFORSelectionTool, xAODMaker::FileMetaDataTool, BookkeeperDumperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 188 of file AsgMetadataTool.cxx.

188  {
189 
190  // Return gracefully:
191  return StatusCode::SUCCESS;
192  }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ get_simType_from_metadata()

StatusCode AsgElectronEfficiencyCorrectionTool::get_simType_from_metadata ( PATCore::ParticleDataType::DataType &  result) const
private

Definition at line 926 of file AsgElectronEfficiencyCorrectionTool.cxx.

928 {
929 
930 #ifndef XAOD_STANDALONE
931  // Determine MC/Data
932  std::string dataType("");
933  if ((AthAnalysisHelper::retrieveMetadata(
934  "/TagInfo", "project_name", dataType, inputMetaStore()))
935  .isSuccess()) {
936  if (!(dataType == "IS_SIMULATION")) {
937  result = PATCore::ParticleDataType::Data;
938  ATH_MSG_DEBUG("Running on data");
939  return StatusCode::SUCCESS;
940  }
941  // Determine Fast/FullSim
942  if (dataType == "IS_SIMULATION") {
943  std::string simType("");
944  ATH_CHECK(AthAnalysisHelper::retrieveMetadata("/Simulation/Parameters",
945  "SimulationFlavour",
946  simType,
947  inputMetaStore()));
948  std::transform(simType.begin(), simType.end(), simType.begin(), ::toupper);
949  result = (simType.find("ATLFAST") == std::string::npos)
950  ? PATCore::ParticleDataType::Full
951  : PATCore::ParticleDataType::Fast;
952  return StatusCode::SUCCESS;
953  }
954  }
955 #endif
956  // Here's how things will work dual use, when file metadata is available in
957  // files
958  if (inputMetaStore()->contains<xAOD::FileMetaData>("FileMetaData")) {
959  const xAOD::FileMetaData* fmd = nullptr;
960  ATH_CHECK(inputMetaStore()->retrieve(fmd, "FileMetaData"));
961 
962  std::string simType("");
963  const bool s = fmd->value(xAOD::FileMetaData::simFlavour, simType);
964  if (!s) {
965  ATH_MSG_DEBUG("no sim flavour from metadata: must be data");
966  result = PATCore::ParticleDataType::Data;
967  return StatusCode::SUCCESS;
968  } else {
969  ATH_MSG_DEBUG("sim type = " + simType);
970  std::transform(simType.begin(), simType.end(), simType.begin(), ::toupper);
971  result = (simType.find("ATLFAST") == std::string::npos)
972  ? PATCore::ParticleDataType::Full
973  : PATCore::ParticleDataType::Fast;
974  return StatusCode::SUCCESS;
975  }
976  } else { // no metadata in the file
977  ATH_MSG_DEBUG("no metadata found in the file");
978  return StatusCode::FAILURE;
979  }
980 }

◆ getEfficiencyScaleFactor() [1/2]

CP::CorrectionCode AsgElectronEfficiencyCorrectionTool::getEfficiencyScaleFactor ( const double  et,
const double  cluster_eta,
const unsigned int  runNumber,
double &  efficiencyScaleFactor 
) const
finaloverrideprivatevirtual

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 383 of file AsgElectronEfficiencyCorrectionTool.cxx.

388 {
389  // We pass only one variation per time
390  // The applied systematic is always one systematic.
391  // Either is relevant and acquires a value
392  // or stays 0.
393  double sys(0);
394 
395  // Let's try to figure already what we are to do
396  bool doSFOnly = appliedSystematics().empty();
397  bool doToys = (m_correlation_model == correlationModel::MCTOYS ||
398  m_correlation_model == correlationModel::COMBMCTOYS);
399  bool isTotal = (m_correlation_model == correlationModel::TOTAL);
400  bool isFull = (m_correlation_model == correlationModel::FULL);
401  bool isSimplified = (m_correlation_model == correlationModel::SIMPLIFIED);
402 
403  // Lets see if we have an uncorrelated syst variation passed
404  int unCorrSign = 0;
405  // or a correlated one
406  int indexCorrelated = -999;
407  int correlatedSign = 0;
408  if (!(doSFOnly || doToys || isTotal) && (isFull || isSimplified)) {
409  const auto& sysName = appliedSystematics().begin()->name();
410  bool isUncorr = (sysName.find("UncorrUnc") != std::string::npos);
411  int currentUncorReg = -999;
412  if (isUncorr) {
413  // Can we find an uncorrelated region?
414  if (isFull) {
415  currentUncorReg = currentUncorrSystRegion(cluster_eta, et);
416  } else if (isSimplified) {
417  currentUncorReg = currentSimplifiedUncorrSystRegion(cluster_eta, et);
418  }
419  if (currentUncorReg < 0) {
420  return CP::CorrectionCode::OutOfValidityRange;
421  }
422  // And use it to if we got the "right" syst variation
423  if (appliedSystematics().matchSystematic(
424  m_uncorrVarDown[currentUncorReg])) {
425  unCorrSign = -1;
426  } else if (appliedSystematics().matchSystematic(
427  m_uncorrVarUp[currentUncorReg])) {
428  unCorrSign = 1;
429  }
430  } else if (m_nCorrSyst != 0) {//if we have 0 we do not care ...
431  if (sysName.find("CorrUnc") != std::string::npos) {
432  // given the name convention we
433  const auto varNumEnd = sysName.rfind("__");
434  const auto varNumBegin = sysName.rfind("NP") + 2;
435  const int varIndex =
436  std::stoi(sysName.substr(varNumBegin, (varNumEnd - varNumBegin)));
437  if (appliedSystematics().matchSystematic(m_corrVarUp[varIndex])) {
438  indexCorrelated = varIndex;
439  correlatedSign = 1;
440  } else if (appliedSystematics().matchSystematic(
441  m_corrVarDown[varIndex])) {
442  indexCorrelated = varIndex;
443  correlatedSign = -1;
444  }
445  } // find CorrUncertainty in name
446  } // not Uncorr and we have CorrSyst
447  } // Not (SF or toys or total)
448 
449  // Now lets do the call
450  // For now we more or less calculate on demand only
451  // the Correlated and the toys we can see if we want
452  // top opt also the "TOTAL"
453  Root::TElectronEfficiencyCorrectionTool::Result result;
454  const int status =
455  m_rootTool->calculate(m_dataType, runNumber, cluster_eta, et, /* in MeV */
456  result, isTotal);
457 
458  // if status 0 something went wrong
459  if (!status) {
460  efficiencyScaleFactor = 1;
461  return CP::CorrectionCode::OutOfValidityRange;
462  }
463  // At this point we have the SF
464  efficiencyScaleFactor = result.SF;
465  //And if all we need we can return
466  if (doSFOnly) {
467  return CP::CorrectionCode::Ok;
468  }
469 
470  // First the logic if the user requested toys
471  if (doToys) {
472  auto toy = appliedSystematics().getToyVariationByBaseName(m_toysBasename);
473  toy.second = m_scale_toys;
474  sys = result.toys[toy.first - 1] * m_scale_toys;
475  // return here for Toy variations
476  efficiencyScaleFactor = sys;
477  return CP::CorrectionCode::Ok;
478  }
479  // The "TOTAL" single uncertainty uncorrelated+correlated
480  else if (isTotal) {
481  sys = result.Total;
482  if (appliedSystematics().matchSystematic(m_uncorrVarUp[0])) {
483  return HelperFunc(efficiencyScaleFactor, sys);
484  }
485  if (appliedSystematics().matchSystematic(m_uncorrVarDown[0])) {
486  return HelperFunc(efficiencyScaleFactor, -1 * sys);
487  }
488  }
489  // Then the uncorrelated part for the SiMPLIFIED/FULL models
490  else if (unCorrSign!=0) {
491  sys = unCorrSign * result.UnCorr;
492  return HelperFunc(efficiencyScaleFactor, sys);
493  }
494 
495  // If we reach this point
496  // it means we need to do the correlated part
497  // for the FULL/SIMPLIFIED models.
498  // First if there are not correlated systematic
499  if (m_nCorrSyst == 0) {
500 
501  if (appliedSystematics().matchSystematic(m_corrVarUp[0])) {
502  sys = std::sqrt(result.Total * result.Total -
503  result.UnCorr * result.UnCorr); // total
504  // -stat
505  return HelperFunc(efficiencyScaleFactor, sys);
506  }
507  if (appliedSystematics().matchSystematic(m_corrVarDown[0])) {
508  sys = -1 * std::sqrt(result.Total * result.Total -
509  result.UnCorr * result.UnCorr); // total
510  // -stat
511  return HelperFunc(efficiencyScaleFactor, sys);
512  }
513  }
514  //or if we had
515  if (correlatedSign != 0) {
516  sys = correlatedSign * result.Corr[indexCorrelated];
517  return HelperFunc(efficiencyScaleFactor, sys);
518  }
519  return CP::CorrectionCode::Ok;
520 }

◆ getEfficiencyScaleFactor() [2/2]

CP::CorrectionCode AsgElectronEfficiencyCorrectionTool::getEfficiencyScaleFactor ( const xAOD::Electron &  inputObject,
double &  efficiencyScaleFactor 
) const
finaloverrideprivatevirtual

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 320 of file AsgElectronEfficiencyCorrectionTool.cxx.

323 {
324 
325  efficiencyScaleFactor = 1;
326  // Retrieve the proper random Run Number
327  unsigned int runNumber = m_defaultRandomRunNumber;
328  if (m_useRandomRunNumber) {
329  const xAOD::EventInfo* eventInfo =
330  evtStore()->retrieve<const xAOD::EventInfo>(m_eventInfoCollectionName);
331  if (!eventInfo) {
332  ATH_MSG_ERROR("Could not retrieve EventInfo object!");
333  return CP::CorrectionCode::Error;
334  }
335  static const SG::AuxElement::Accessor<unsigned int> randomrunnumber(
336  "RandomRunNumber");
337  if (!randomrunnumber.isAvailable(*eventInfo)) {
338  ATH_MSG_WARNING(
339  "Pileup tool not run before using ElectronEfficiencyTool! SFs do not "
340  "reflect PU distribution in data");
341  return CP::CorrectionCode::Error;
342  }
343  runNumber = randomrunnumber(*(eventInfo));
344  }
345  //
346  // Get the result
347  //
348  double cluster_eta(-9999.9);
349 
350  const xAOD::CaloCluster* cluster = inputObject.caloCluster();
351  if (!cluster) {
352  ATH_MSG_ERROR("ERROR no cluster associated to the Electron \n");
353  return CP::CorrectionCode::Error;
354  }
355 
356  // we need to use different variables for central and forward electrons
357  static const SG::AuxElement::ConstAccessor<uint16_t> accAuthor("author");
358  if (accAuthor.isAvailable(inputObject) &&
359  accAuthor(inputObject) == xAOD::EgammaParameters::AuthorFwdElectron) {
360  cluster_eta = cluster->eta();
361  } else {
362  cluster_eta = cluster->etaBE(2);
363  }
364 
365  // use et from cluster because it is immutable under syst variations of
366  // electron energy scale
367  const double energy = cluster->e();
368  const double parEta = inputObject.eta();
369  const double coshEta = std::cosh(parEta);
370  double et = (coshEta != 0.) ? energy / coshEta : 0.;
371  // allow for a 5% margin at the lowest pT bin boundary (i.e. increase et by 5%
372  // for sub-threshold electrons). This assures that electrons that pass the
373  // threshold only under syst variations of energy get a scale factor assigned.
374  auto itr_pt = m_pteta_bins.begin();
375  if (itr_pt != m_pteta_bins.end() && et < itr_pt->first) {
376  et = et * 1.05;
377  }
378  return getEfficiencyScaleFactor(et, cluster_eta, runNumber,
379  efficiencyScaleFactor);
380 }

◆ getFile()

StatusCode AsgElectronEfficiencyCorrectionTool::getFile ( const std::string &  recokey,
const std::string &  idkey,
const std::string &  isokey,
const std::string &  trigkey 
)
privatevirtual

Gets the correction filename from map.

Definition at line 825 of file AsgElectronEfficiencyCorrectionTool.cxx.

829 {
830 
831  std::string mapFileName = PathResolverFindCalibFile(m_mapFile);
832  std::string key =
833  ElRecomFileHelpers::convertToOneKey(recokey, idkey, isokey, trigkey);
834  std::string value = ElRecomFileHelpers::getValueByKey(mapFileName, key);
835 
836  if (!value.empty()) {
837  m_corrFileNameList.push_back(value);
838  } else {
839  if (mapFileName.empty()) {
840  ATH_MSG_ERROR(
841  "Map file does not exist, Please set the path and version properly..");
842  } else {
843  ATH_MSG_ERROR(
844  "Key "
845  << key
846  << " does not exist in the map file, Please configure it properly..");
847  }
848  return StatusCode::FAILURE;
849  }
850 
851  ATH_MSG_DEBUG("Full File Name is " + value);
852  return StatusCode::SUCCESS;
853 }

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

◆ getNumberOfToys()

virtual int AsgElectronEfficiencyCorrectionTool::getNumberOfToys ( ) const
inlinefinaloverrideprivatevirtual

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 84 of file AsgElectronEfficiencyCorrectionTool.h.

85  {
86  return m_number_of_toys;
87  };

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ handle()

void asg::AsgMetadataTool::handle ( const Incident &  inc)
protectedvirtualinherited

Function receiving incidents from IncidentSvc/TEvent.

Reimplemented in Trig::TrigDecisionTool.

Definition at line 130 of file AsgMetadataTool.cxx.

130  {
131 
132  // Tell the user what's happening:
133  ATH_MSG_VERBOSE( "Callback received with incident: " << inc.type() );
134 
135  // Call the appropriate member function:
136  if( inc.type() == IncidentType::BeginInputFile ) {
137  m_beginInputFileCalled = true;
138  if( beginInputFile().isFailure() ) {
139  ATH_MSG_FATAL( "Failed to call beginInputFile()" );
140  throw std::runtime_error( "Couldn't call beginInputFile()" );
141  }
142  } else if( inc.type() == IncidentType::EndInputFile ) {
143  if( endInputFile().isFailure() ) {
144  ATH_MSG_FATAL( "Failed to call endInputFile()" );
145  throw std::runtime_error( "Couldn't call endInputFile()" );
146  }
147  } else if( inc.type() == IncidentType::BeginEvent ) {
148  // If the tool didn't catch the begin input file incident for the
149  // first input file of the job, then call the appropriate function
150  // now.
151  if( ! m_beginInputFileCalled ) {
152  m_beginInputFileCalled = true;
153  if( beginInputFile().isFailure() ) {
154  ATH_MSG_FATAL( "Failed to call beginInputFile()" );
155  throw std::runtime_error( "Couldn't call beginInputFile()" );
156  }
157  }
158  if( beginEvent().isFailure() ) {
159  ATH_MSG_FATAL( "Failed to call beginEvent()" );
160  throw std::runtime_error( "Couldn't call beginEvent()" );
161  }
162 
163  #ifdef XAOD_STANDALONE
164  } else if( inc.type() == IncidentType::MetaDataStop ) {
165  if( metaDataStop().isFailure() ) {
166  ATH_MSG_FATAL( "Failed to call metaDataStop()" );
167  throw std::runtime_error( "Couldn't call metaDataStop()" );
168  }
169 
170  #endif // XAOD_STANDALONE
171  } else {
172  ATH_MSG_WARNING( "Unknown incident type received in AsgMetaDataTool: " << inc.type() );
173  }
174 
175  return;
176  }

◆ initialize()

StatusCode AsgElectronEfficiencyCorrectionTool::initialize ( )
finaloverrideprivatevirtual

Gaudi Service Interface method implementations.

Reimplemented from asg::AsgTool.

Definition at line 150 of file AsgElectronEfficiencyCorrectionTool.cxx.

151 {
152  // Forward the message level
153  m_rootTool->msg().setLevel(this->msg().level());
154 
155  if (m_corrFileNameList.empty() && m_recoKey.empty() && m_idKey.empty() &&
156  m_trigKey.empty() && m_isoKey.empty()) {
157  ATH_MSG_ERROR("CorrectionFileNameList as well as SFKeys are empty! Please "
158  "configure it properly...");
159  return StatusCode::FAILURE;
160  }
161  /*
162  * When metadata are available
163  * m_dataType will be whatever the metadata says i.e Full or Fast
164  * Its default value is Full.
165  * The user can overwrite all these ,using a flag,
166  * and force a specific dataType
167  */
168  if (m_dataTypeOverwrite != -1) {
169  if (m_dataTypeOverwrite !=
170  static_cast<int>(PATCore::ParticleDataType::Full) &&
171  m_dataTypeOverwrite !=
172  static_cast<int>(PATCore::ParticleDataType::Fast)) {
173  ATH_MSG_ERROR("Unsupported Particle Data Type Overwrite"
174  << m_dataTypeOverwrite);
175  return StatusCode::FAILURE;
176  }
177  m_dataType =
178  static_cast<PATCore::ParticleDataType::DataType>(m_dataTypeOverwrite);
179  }
180  // Find the relevant input files
181  // Fill the vector with filename using keys if the user
182  // has not passed the full filename as a property
183  if (m_corrFileNameList.empty()) {
184  if (getFile(m_recoKey, m_idKey, m_isoKey, m_trigKey).isFailure()) {
185  ATH_MSG_ERROR("No Root file input specified, and not available map file");
186  return StatusCode::FAILURE;
187  }
188  }
189  // Resolve the paths to the input files for the full Geant4 simualtion
190  // corrections
191  for (auto& ifile : m_corrFileNameList) {
192 
193  std::string filename = PathResolverFindCalibFile(ifile);
194  if (filename.empty()) {
195  ATH_MSG_ERROR("Could NOT resolve file name " << ifile);
196  return StatusCode::FAILURE;
197  } else {
198  ATH_MSG_DEBUG(" Path found = " << filename);
199  }
200  m_rootTool->addFileName(filename);
201  // Determine the systematics substring according to the name of the input
202  // file
203  if (ifile.find("efficiencySF.") != std::string::npos) {
204  m_sysSubstring = "Trigger_";
205  }
206  if (ifile.find("efficiencySF.offline") != std::string::npos) {
207  m_sysSubstring = "ID_";
208  }
209  if (ifile.find("efficiencySF.offline.RecoTrk") != std::string::npos) {
210  m_sysSubstring = "Reco_";
211  }
212  if (ifile.find("efficiencySF.offline.Fwd") != std::string::npos) {
213  m_sysSubstring = "FwdID_";
214  }
215  if (ifile.find("efficiencySF.Isolation") != std::string::npos) {
216  m_sysSubstring = "Iso_";
217  }
218  if (ifile.find("efficiency.") != std::string::npos) {
219  m_sysSubstring = "TriggerEff_";
220  }
221  if (ifile.find("efficiencySF.ChargeID") != std::string::npos) {
222  m_sysSubstring = "ChargeIDSel_";
223  }
224  if (m_sysSubstring.empty()) {
225  ATH_MSG_ERROR("Could NOT find systematics Substring file name "
226  << m_sysSubstring);
227  return StatusCode::FAILURE;
228  }
229  }
230  //
231  // Find the proper correlation Model
232  if (m_correlation_model_name == "COMBMCTOYS") {
233  m_correlation_model = correlationModel::COMBMCTOYS;
234  } else if (m_correlation_model_name == "MCTOYS") {
235  m_correlation_model = correlationModel::MCTOYS;
236  } else if (m_correlation_model_name == "FULL") {
237  m_correlation_model = correlationModel::FULL;
238  } else if (m_correlation_model_name == "SIMPLIFIED") {
239  m_correlation_model = correlationModel::SIMPLIFIED;
240  // a few checks on the binning that the user might have specified
241  if (m_uncorrSimplfEtaBinsUser.empty() || m_uncorrSimplfEtBinsUser.empty() ||
242  m_uncorrSimplfEtBinsUser.size() < 2 ||
243  m_uncorrSimplfEtaBinsUser.size() < 2) {
244  ATH_MSG_ERROR("Something went wrong when specifying bins for the "
245  "SIMPLIFIED correlation model ");
246  return StatusCode::FAILURE;
247  }
248  } else if (m_correlation_model_name == "TOTAL") {
249  m_correlation_model = correlationModel::TOTAL;
250  } else if (m_correlation_model_name == "SYST") {
251  m_correlation_model = correlationModel::SYST;
252  } else {
253  ATH_MSG_ERROR("Unknown correlation model " + m_correlation_model_name);
254  return StatusCode::FAILURE;
255  }
256  ATH_MSG_DEBUG("Correlation model: " + m_correlation_model_name
257  << " Enum " << m_correlation_model);
258 
259  // Histogram of simplified uncorrelated regions
260  if (m_correlation_model == correlationModel::SIMPLIFIED) {
261  m_UncorrRegions = new TH2F("UncorrRegions",
262  "UncorrRegions",
263  m_uncorrSimplfEtBinsUser.size() - 1,
264  &(m_uncorrSimplfEtBinsUser[0]),
265  m_uncorrSimplfEtaBinsUser.size() - 1,
266  &(m_uncorrSimplfEtaBinsUser[0]));
267  m_UncorrRegions->SetDirectory(nullptr);
268 
269  // bins not entries here
270  m_nSimpleUncorrSyst = (m_uncorrSimplfEtaBinsUser.size() - 1) *
271  (m_uncorrSimplfEtBinsUser.size() - 1);
272  }
273  // Finish the preaparation of the underlying tool
274  if (m_seed_toys != 0) {
275  m_rootTool->setSeed(m_seed_toys);
276  }
277  //
278  if (m_correlation_model == correlationModel::COMBMCTOYS) {
279  m_rootTool->bookCombToyMCScaleFactors(m_number_of_toys);
280  }
281  //
282  if (m_correlation_model == correlationModel::MCTOYS) {
283  m_rootTool->bookToyMCScaleFactors(m_number_of_toys);
284  }
285  // We need to initialize the underlying ROOT TSelectorTool
286  if (0 == m_rootTool->initialize()) {
287  ATH_MSG_ERROR(
288  "Could not initialize the TElectronEfficiencyCorrectionTool!");
289  return StatusCode::FAILURE;
290  }
291 
292  // get Nsyst
293  m_nCorrSyst = m_rootTool->getNSyst();
294  std::map<float, std::vector<float>> tmp;
295  m_nUncorrSyst = m_rootTool->getNbins(tmp);
296  // copy over to vector for better access
297  for (const auto& i : tmp) {
298  m_pteta_bins.emplace_back(i.first, i.second);
299  }
300 
301  // Initialize the systematics
302  if (InitSystematics() != StatusCode::SUCCESS) {
303  ATH_MSG_ERROR("(InitSystematics() != StatusCode::SUCCESS)");
304  return StatusCode::FAILURE;
305  }
306  // Add the recommended systematics to the registry
307  if (registerSystematics() != StatusCode::SUCCESS) {
308  ATH_MSG_ERROR("(registerSystematics() != StatusCode::SUCCESS)");
309  return StatusCode::FAILURE;
310  }
311  // Configure for nominal systematics
312  if (applySystematicVariation(CP::SystematicSet()) != StatusCode::SUCCESS) {
313  ATH_MSG_ERROR("Could not configure for nominal settings");
314  return StatusCode::FAILURE;
315  }
316  return StatusCode::SUCCESS;
317 }

◆ InitSystematics()

StatusCode AsgElectronEfficiencyCorrectionTool::InitSystematics ( )
private

initialize the systematics

Definition at line 630 of file AsgElectronEfficiencyCorrectionTool.cxx.

631 {
632  const std::string prefix = "EL_EFF_" + m_sysSubstring;
633  const std::string prefixUncorr = prefix + m_correlation_model_name + "_";
634  // Toys
635  if (m_correlation_model == correlationModel::COMBMCTOYS) {
636  m_toysBasename = prefix + "COMBMCTOY";
637  m_affectedSys.insert(
638  (CP::SystematicVariation::makeToyEnsemble(m_toysBasename)));
639  } else if (m_correlation_model == correlationModel::MCTOYS) {
640  m_toysBasename = prefix + "MCTOY";
641  m_affectedSys.insert(
642  (CP::SystematicVariation::makeToyEnsemble(m_toysBasename)));
643  // Correlated for the different models (1 or Full set)
644  } else if (m_correlation_model != correlationModel::TOTAL) {
645  if (m_nCorrSyst == 0) {
646  auto varUp = CP::SystematicVariation(prefix + "CorrUncertainty", 1);
647  auto varDown = CP::SystematicVariation(prefix + "CorrUncertainty", -1);
648  m_corrVarUp.push_back(varUp);
649  m_corrVarDown.push_back(varDown);
650  m_affectedSys.insert(varUp);
651  m_affectedSys.insert(varDown);
652  } else
653  for (int i = 0; i < m_nCorrSyst; ++i) {
654  auto varUp =
655  CP::SystematicVariation(prefix + Form("CorrUncertaintyNP%d", i), 1);
656  auto varDown =
657  CP::SystematicVariation(prefix + Form("CorrUncertaintyNP%d", i), -1);
658  m_corrVarUp.push_back(varUp);
659  m_corrVarDown.push_back(varDown);
660  m_affectedSys.insert(varUp);
661  m_affectedSys.insert(varDown);
662  }
663  }
664  // Different tratement for the uncorrelated per model
665  if (m_correlation_model == correlationModel::TOTAL) {
666  auto varUp = CP::SystematicVariation(prefixUncorr + "1NPCOR_PLUS_UNCOR", 1);
667  auto varDown =
668  CP::SystematicVariation(prefixUncorr + "1NPCOR_PLUS_UNCOR", -1);
669  m_uncorrVarUp.push_back(varUp);
670  m_uncorrVarDown.push_back(varDown);
671  m_affectedSys.insert(varUp);
672  m_affectedSys.insert(varDown);
673  } else if (m_correlation_model == correlationModel::FULL) {
674  for (int i = 0; i < m_nUncorrSyst; ++i) {
675  auto varUp = CP::SystematicVariation(
676  prefixUncorr + Form("UncorrUncertaintyNP%d", i), 1);
677  auto varDown = CP::SystematicVariation(
678  prefixUncorr + Form("UncorrUncertaintyNP%d", i), -1);
679  m_uncorrVarUp.push_back(varUp);
680  m_uncorrVarDown.push_back(varDown);
681  m_affectedSys.insert(varUp);
682  m_affectedSys.insert(varDown);
683  }
684  } else if (m_correlation_model == correlationModel::SIMPLIFIED) {
685  for (int i = 0; i < m_nSimpleUncorrSyst; ++i) {
686  auto varUp = CP::SystematicVariation(
687  prefixUncorr + Form("UncorrUncertaintyNP%d", i), 1);
688  auto varDown = CP::SystematicVariation(
689  prefixUncorr + Form("UncorrUncertaintyNP%d", i), -1);
690  m_uncorrVarUp.push_back(varUp);
691  m_uncorrVarDown.push_back(varDown);
692  m_affectedSys.insert(varUp);
693  m_affectedSys.insert(varDown);
694  }
695  }
696  return StatusCode::SUCCESS;
697 }

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

◆ inputMetaStore()

AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::inputMetaStore ( ) const
inherited

Accessor for the input metadata store.

Definition at line 88 of file AsgMetadataTool.cxx.

88  {
89 
90 #ifdef XAOD_STANDALONE
91  return &m_inputMetaStore;
92 #else // XAOD_STANDALONE
93  return m_inputMetaStore;
94 #endif // XAOD_STANDALONE
95  }

◆ isAffectedBySystematic()

bool AsgElectronEfficiencyCorrectionTool::isAffectedBySystematic ( const CP::SystematicVariation &  systematic) const
finaloverrideprivatevirtual

returns: whether this tool is affected by the given systematis

returns: bool indicating if affected by the variation

Implements CP::ISystematicsTool.

Definition at line 540 of file AsgElectronEfficiencyCorrectionTool.cxx.

542 {
543  if (systematic.empty()) {
544  return false;
545  }
546  CP::SystematicSet sys = affectingSystematics();
547  if (m_correlation_model == correlationModel::MCTOYS ||
548  m_correlation_model == correlationModel::COMBMCTOYS) {
549  return (sys.begin()->ensembleContains(systematic));
550  } else {
551  return (sys.find(systematic) != sys.end());
552  }
553 }

◆ metaDataStop()

StatusCode asg::AsgMetadataTool::metaDataStop ( )
protectedvirtualinherited

Function called when the tool should write out its metadata.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in xAODMaker::FileMetaDataTool, BookkeeperTool, BookkeeperDumperTool, xAODMaker::TriggerMenuMetaDataTool, and xAODMaker::TruthMetaDataTool.

Definition at line 204 of file AsgMetadataTool.cxx.

204  {
205 
206  // Return gracefully:
207  return StatusCode::SUCCESS;
208  }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msg_level_name()

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

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

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

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

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

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

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ outputMetaStore()

AsgMetadataTool::MetaStorePtr_t asg::AsgMetadataTool::outputMetaStore ( ) const
inherited

Accessor for the output metadata store.

Definition at line 97 of file AsgMetadataTool.cxx.

97  {
98 
99 #ifdef XAOD_STANDALONE
100  return &m_outputMetaStore;
101 #else // XAOD_STANDALONE
102  return m_outputMetaStore;
103 #endif // XAOD_STANDALONE
104  }

◆ print() [1/2]

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  }

◆ print() [2/2]

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

Print the state of the tool.

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

◆ printCorrelationModels()

virtual void AsgElectronEfficiencyCorrectionTool::printCorrelationModels ( ) const
inlinefinaloverrideprivatevirtual

print available/implemented correlation models

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 89 of file AsgElectronEfficiencyCorrectionTool.h.

90  {
91  ATH_MSG_INFO(
92  " Available Correlation Models for the ElectronEfficiencyCorrectionTool");
93  ATH_MSG_INFO("FULL");
94  ATH_MSG_INFO("SIMPLIFIED");
95  ATH_MSG_INFO("MCTOYS");
96  ATH_MSG_INFO("SYST");
97  ATH_MSG_INFO("COMBMCTOYS");
98  ATH_MSG_INFO("TOTAL");
99  };

◆ recommendedSystematics()

CP::SystematicSet AsgElectronEfficiencyCorrectionTool::recommendedSystematics ( ) const
finaloverrideprivatevirtual

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

Implements CP::IReentrantSystematicsTool.

Definition at line 576 of file AsgElectronEfficiencyCorrectionTool.cxx.

577 {
578  return affectingSystematics();
579 }

◆ registerSystematics()

StatusCode AsgElectronEfficiencyCorrectionTool::registerSystematics ( )
private

Definition at line 563 of file AsgElectronEfficiencyCorrectionTool.cxx.

564 {
565  CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
566 
567  if (registry.registerSystematics(*this) != StatusCode::SUCCESS) {
568  ATH_MSG_ERROR(
569  "Failed to add systematic to list of recommended systematics.");
570  return StatusCode::FAILURE;
571  }
572  return StatusCode::SUCCESS;
573 }

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

◆ setUseIncidents()

void asg::AsgMetadataTool::setUseIncidents ( const bool  flag)
inlineprotectedinherited

Definition at line 132 of file AsgMetadataTool.h.

133  {
134  m_useIncidents = flag;
135  }

◆ sysInitialize()

StatusCode asg::AsgMetadataTool::sysInitialize ( )
virtualinherited

Function initialising the tool in the correct way in Athena.

This function is used to set up the callbacks from IncidentSvc in Athena at the right time during initialisation, without the user having to do anything special in his/her code.

Reimplemented from AthCommonDataStore< AthCommonMsg< AlgTool > >.

Definition at line 110 of file AsgMetadataTool.cxx.

110  {
111 
112 #ifndef XAOD_STANDALONE
113  if (m_useIncidents) {
114  // Connect to the IncidentSvc:
115  ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
116  ATH_CHECK( incSvc.retrieve() );
117 
118  // Set up the right callbacks: don't rethrow exceptions, any failure and we should end
119  incSvc->addListener( this, IncidentType::BeginEvent, 0, false );
120  }
121  // Let the base class do its thing:
122  ATH_CHECK( AlgTool::sysInitialize() );
123 
124 #endif // not XAOD_STANDALONE
125 
126  // Return gracefully:
127  return StatusCode::SUCCESS;
128  }

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

◆ systUncorrVariationIndex()

int AsgElectronEfficiencyCorrectionTool::systUncorrVariationIndex ( const xAOD::Electron &  inputObject) const
finaloverrideprivatevirtual

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 792 of file AsgElectronEfficiencyCorrectionTool.cxx.

794 {
795  int currentSystRegion = -999;
796  double cluster_eta(-9999.9);
797  double et(0.0);
798 
799  et = inputObject.pt();
800  const xAOD::CaloCluster* cluster = inputObject.caloCluster();
801  if (!cluster) {
802  ATH_MSG_ERROR("ERROR no cluster associated to the Electron \n");
803  return currentSystRegion;
804  }
805  cluster_eta = cluster->etaBE(2);
806  switch (m_correlation_model) {
807  case correlationModel::SIMPLIFIED: {
808  currentSystRegion = currentSimplifiedUncorrSystRegion(cluster_eta, et);
809  break;
810  }
811  case correlationModel::FULL: {
812  currentSystRegion = currentUncorrSystRegion(cluster_eta, et);
813  break;
814  }
815  default: {
816  // not there for the other models
817  break;
818  }
819  }
820  return currentSystRegion;
821 }

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

CP::SystematicSet AsgElectronEfficiencyCorrectionTool::m_affectedSys
private

Affected systematic, should be done only once.

Definition at line 147 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_appliedSystematics

CP::SystematicSet* AsgElectronEfficiencyCorrectionTool::m_appliedSystematics
private

Currently applied systematics.

Definition at line 150 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_beginInputFileCalled

bool asg::AsgMetadataTool::m_beginInputFileCalled
privateinherited

Flag helping to discover when the tool misses the opening of the first input file.

Definition at line 126 of file AsgMetadataTool.h.

◆ m_correlation_model

int AsgElectronEfficiencyCorrectionTool::m_correlation_model
private

Definition at line 154 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_correlation_model_name

std::string AsgElectronEfficiencyCorrectionTool::m_correlation_model_name
private

Definition at line 153 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_corrFileNameList

std::vector<std::string> AsgElectronEfficiencyCorrectionTool::m_corrFileNameList
private

The list of file names.

Definition at line 166 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_corrVarDown

std::vector<CP::SystematicVariation> AsgElectronEfficiencyCorrectionTool::m_corrVarDown
private

Definition at line 215 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_corrVarUp

std::vector<CP::SystematicVariation> AsgElectronEfficiencyCorrectionTool::m_corrVarUp
private

Definition at line 214 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_dataType

PATCore::ParticleDataType::DataType AsgElectronEfficiencyCorrectionTool::m_dataType
private

Definition at line 185 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_dataTypeOverwrite

int AsgElectronEfficiencyCorrectionTool::m_dataTypeOverwrite
private

Force the data type to a given value.

Definition at line 188 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_defaultRandomRunNumber

int AsgElectronEfficiencyCorrectionTool::m_defaultRandomRunNumber
private

Definition at line 182 of file AsgElectronEfficiencyCorrectionTool.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_eventInfoCollectionName

std::string AsgElectronEfficiencyCorrectionTool::m_eventInfoCollectionName
private

The Event info collection name.

Definition at line 178 of file AsgElectronEfficiencyCorrectionTool.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_idKey

std::string AsgElectronEfficiencyCorrectionTool::m_idKey
private

Definition at line 161 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_inputMetaStore

MetaStore_t asg::AsgMetadataTool::m_inputMetaStore
privateinherited

Object accessing the input metadata store.

Definition at line 119 of file AsgMetadataTool.h.

◆ m_isoKey

std::string AsgElectronEfficiencyCorrectionTool::m_isoKey
private

Definition at line 162 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_mapFile

std::string AsgElectronEfficiencyCorrectionTool::m_mapFile
private

Definition at line 157 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_metadata_retrieved

bool AsgElectronEfficiencyCorrectionTool::m_metadata_retrieved = false
private

To check if the metadata can be retrieved.

Definition at line 138 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_nCorrSyst

int AsgElectronEfficiencyCorrectionTool::m_nCorrSyst
private

Definition at line 200 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_nSimpleUncorrSyst

int AsgElectronEfficiencyCorrectionTool::m_nSimpleUncorrSyst
private

Definition at line 210 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_number_of_toys

int AsgElectronEfficiencyCorrectionTool::m_number_of_toys
private

Definition at line 191 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_nUncorrSyst

int AsgElectronEfficiencyCorrectionTool::m_nUncorrSyst
private

Definition at line 201 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_outputMetaStore

MetaStore_t asg::AsgMetadataTool::m_outputMetaStore
privateinherited

Object accessing the output metadata store.

Definition at line 121 of file AsgMetadataTool.h.

◆ m_pteta_bins

std::vector<std::pair<float, std::vector<float> > > AsgElectronEfficiencyCorrectionTool::m_pteta_bins
private

Definition at line 202 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_recoKey

std::string AsgElectronEfficiencyCorrectionTool::m_recoKey
private

Definition at line 160 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_resultName

std::string AsgElectronEfficiencyCorrectionTool::m_resultName
private

The string for the result.

Definition at line 172 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_resultPrefix

std::string AsgElectronEfficiencyCorrectionTool::m_resultPrefix
private

The prefix string for the result.

Definition at line 169 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_rootTool

std::unique_ptr<Root::TElectronEfficiencyCorrectionTool> AsgElectronEfficiencyCorrectionTool::m_rootTool = nullptr
private

Pointer to the underlying ROOT based tool.

Definition at line 141 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_scale_toys

double AsgElectronEfficiencyCorrectionTool::m_scale_toys
private

Definition at line 197 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_seed_toys

int AsgElectronEfficiencyCorrectionTool::m_seed_toys
private

Definition at line 194 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_sysSubstring

std::string AsgElectronEfficiencyCorrectionTool::m_sysSubstring
private

Definition at line 175 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_systFilter

std::unordered_map<CP::SystematicSet, CP::SystematicSet> AsgElectronEfficiencyCorrectionTool::m_systFilter
private

Systematics filter map.

Definition at line 144 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_toysBasename

std::string AsgElectronEfficiencyCorrectionTool::m_toysBasename
private

Definition at line 213 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_trigKey

std::string AsgElectronEfficiencyCorrectionTool::m_trigKey
private

Definition at line 163 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_UncorrRegions

TH2F* AsgElectronEfficiencyCorrectionTool::m_UncorrRegions
private

Definition at line 209 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_uncorrSimplfEtaBinsUser

std::vector<float> AsgElectronEfficiencyCorrectionTool::m_uncorrSimplfEtaBinsUser
private

Definition at line 205 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_uncorrSimplfEtBinsUser

std::vector<float> AsgElectronEfficiencyCorrectionTool::m_uncorrSimplfEtBinsUser
private

Definition at line 206 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_uncorrVarDown

std::vector<CP::SystematicVariation> AsgElectronEfficiencyCorrectionTool::m_uncorrVarDown
private

Definition at line 217 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_uncorrVarUp

std::vector<CP::SystematicVariation> AsgElectronEfficiencyCorrectionTool::m_uncorrVarUp
private

Definition at line 216 of file AsgElectronEfficiencyCorrectionTool.h.

◆ m_useIncidents

bool asg::AsgMetadataTool::m_useIncidents
privateinherited

Definition at line 128 of file AsgMetadataTool.h.

◆ m_useRandomRunNumber

bool AsgElectronEfficiencyCorrectionTool::m_useRandomRunNumber
private

Definition at line 181 of file AsgElectronEfficiencyCorrectionTool.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
AsgElectronEfficiencyCorrectionTool::getFile
virtual StatusCode getFile(const std::string &recokey, const std::string &idkey, const std::string &isokey, const std::string &trigkey)
Gets the correction filename from map.
Definition: AsgElectronEfficiencyCorrectionTool.cxx:825
python.Dso.registry
registry
Definition: Control/AthenaServices/python/Dso.py:159
AsgElectronEfficiencyCorrectionTool::m_correlation_model
int m_correlation_model
Definition: AsgElectronEfficiencyCorrectionTool.h:154
TestSUSYToolsAlg.ifile
ifile
Definition: TestSUSYToolsAlg.py:92
CaloCondBlobAlgs_fillNoiseFromASCII.sysName
sysName
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:93
AsgElectronEfficiencyCorrectionTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const CP::SystematicSet &systConfig) override final
Configure this tool for the given systematics.
Definition: AsgElectronEfficiencyCorrectionTool.cxx:582
et
Extra patterns decribing particle interation process.
CP::SystematicSet::getToyVariationByBaseName
std::pair< unsigned, float > getToyVariationByBaseName(const std::string &basename) const
the toy variation for the given basename
Definition: SystematicSet.cxx:201
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
AsgElectronEfficiencyCorrectionTool::m_corrFileNameList
std::vector< std::string > m_corrFileNameList
The list of file names.
Definition: AsgElectronEfficiencyCorrectionTool.h:166
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
asg::AsgMetadataTool::beginEvent
virtual StatusCode beginEvent()
Function called when a new events is loaded.
Definition: AsgMetadataTool.cxx:196
get_generator_info.result
result
Definition: get_generator_info.py:21
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
AsgElectronEfficiencyCorrectionTool::m_idKey
std::string m_idKey
Definition: AsgElectronEfficiencyCorrectionTool.h:161
AsgElectronEfficiencyCorrectionTool::m_appliedSystematics
CP::SystematicSet * m_appliedSystematics
Currently applied systematics.
Definition: AsgElectronEfficiencyCorrectionTool.h:150
AsgElectronEfficiencyCorrectionTool::m_rootTool
std::unique_ptr< Root::TElectronEfficiencyCorrectionTool > m_rootTool
Pointer to the underlying ROOT based tool.
Definition: AsgElectronEfficiencyCorrectionTool.h:141
AsgElectronEfficiencyCorrectionTool::m_mapFile
std::string m_mapFile
Definition: AsgElectronEfficiencyCorrectionTool.h:157
AsgElectronEfficiencyCorrectionTool::InitSystematics
StatusCode InitSystematics()
initialize the systematics
Definition: AsgElectronEfficiencyCorrectionTool.cxx:630
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
correlationModel::FULL
@ FULL
Definition: AsgElectronEfficiencyCorrectionTool.cxx:49
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:66
AsgElectronEfficiencyCorrectionTool::m_uncorrSimplfEtaBinsUser
std::vector< float > m_uncorrSimplfEtaBinsUser
Definition: AsgElectronEfficiencyCorrectionTool.h:205
CP::SystematicSet::size
size_t size() const
returns: size of the set
Definition: SystematicSet.h:71
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CP::SystematicSet::empty
bool empty() const
returns: whether the set is empty
Definition: SystematicSet.h:67
PATCore::ParticleDataType::Fast
@ Fast
Definition: PATCoreEnums.h:22
AsgElectronEfficiencyCorrectionTool::m_useRandomRunNumber
bool m_useRandomRunNumber
Definition: AsgElectronEfficiencyCorrectionTool.h:181
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
correlationModel::SYST
@ SYST
Definition: AsgElectronEfficiencyCorrectionTool.cxx:52
AsgElectronEfficiencyCorrectionTool::currentUncorrSystRegion
int currentUncorrSystRegion(const double cluster_eta, const double et) const
Definition: AsgElectronEfficiencyCorrectionTool.cxx:739
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
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
asg::AsgMetadataTool::inputMetaStore
MetaStorePtr_t inputMetaStore() const
Accessor for the input metadata store.
Definition: AsgMetadataTool.cxx:88
AsgElectronEfficiencyCorrectionTool::registerSystematics
StatusCode registerSystematics()
Definition: AsgElectronEfficiencyCorrectionTool.cxx:563
athena.value
value
Definition: athena.py:122
asg::AsgMetadataTool::m_beginInputFileCalled
bool m_beginInputFileCalled
Flag helping to discover when the tool misses the opening of the first input file.
Definition: AsgMetadataTool.h:126
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:54
asg::AsgMetadataTool::endInputFile
virtual StatusCode endInputFile()
Function called when the currently open input file got completely processed.
Definition: AsgMetadataTool.cxx:188
asg::AsgMetadataTool::m_outputMetaStore
MetaStore_t m_outputMetaStore
Object accessing the output metadata store.
Definition: AsgMetadataTool.h:121
AsgElectronEfficiencyCorrectionTool::m_resultName
std::string m_resultName
The string for the result.
Definition: AsgElectronEfficiencyCorrectionTool.h:172
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
xAOD::EgammaParameters::AuthorFwdElectron
const uint16_t AuthorFwdElectron
Electron reconstructed by the Forward cluster-based algorithm.
Definition: EgammaDefs.h:30
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
AsgElectronEfficiencyCorrectionTool::m_correlation_model_name
std::string m_correlation_model_name
Definition: AsgElectronEfficiencyCorrectionTool.h:153
CP::SystematicVariation
Definition: SystematicVariation.h:47
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
python.DomainsRegistry.reg
reg
globals -----------------------------------------------------------------—
Definition: DomainsRegistry.py:343
PATCore::ParticleDataType::Data
@ Data
Definition: PATCoreEnums.h:22
mapkey::sys
@ sys
Definition: TElectronEfficiencyCorrectionTool.cxx:42
AsgElectronEfficiencyCorrectionTool::m_defaultRandomRunNumber
int m_defaultRandomRunNumber
Definition: AsgElectronEfficiencyCorrectionTool.h:182
AsgElectronEfficiencyCorrectionTool::m_dataType
PATCore::ParticleDataType::DataType m_dataType
Definition: AsgElectronEfficiencyCorrectionTool.h:185
PATCore::ParticleDataType::DataType
DataType
Definition: PATCoreEnums.h:22
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
xAOD::FileMetaData_v1::value
bool value(MetaDataType type, std::string &val) const
Get a pre-defined string value out of the object.
Definition: FileMetaData_v1.cxx:195
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AsgElectronEfficiencyCorrectionTool::m_isoKey
std::string m_isoKey
Definition: AsgElectronEfficiencyCorrectionTool.h:162
xAOD::FileMetaData_v1::simFlavour
@ simFlavour
Fast or Full sim [string].
Definition: FileMetaData_v1.h:76
PATCore::ParticleDataType::Full
@ Full
Definition: PATCoreEnums.h:22
xAOD::CaloCluster_v1::etaBE
float etaBE(const unsigned layer) const
Get the eta in one layer of the EM Calo.
Definition: CaloCluster_v1.cxx:644
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
correlationModel::MCTOYS
@ MCTOYS
Definition: AsgElectronEfficiencyCorrectionTool.cxx:48
AsgElectronEfficiencyCorrectionTool::m_uncorrSimplfEtBinsUser
std::vector< float > m_uncorrSimplfEtBinsUser
Definition: AsgElectronEfficiencyCorrectionTool.h:206
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
CP::CorrectionCode::OutOfValidityRange
@ OutOfValidityRange
Input object is out of validity range.
Definition: CorrectionCode.h:37
Root::TElectronEfficiencyCorrectionTool::Result
Definition: TElectronEfficiencyCorrectionTool.h:42
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition: CorrectionCode.h:36
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
AsgElectronEfficiencyCorrectionTool::m_toysBasename
std::string m_toysBasename
Definition: AsgElectronEfficiencyCorrectionTool.h:213
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:58
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
lumiFormat.i
int i
Definition: lumiFormat.py:92
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AsgElectronEfficiencyCorrectionTool::m_uncorrVarDown
std::vector< CP::SystematicVariation > m_uncorrVarDown
Definition: AsgElectronEfficiencyCorrectionTool.h:217
asg::AsgMetadataTool::beginInputFile
virtual StatusCode beginInputFile()
Function called when a new input file is opened.
Definition: AsgMetadataTool.cxx:180
master.flag
bool flag
Definition: master.py:29
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition: Egamma_v1.cxx:388
AsgElectronEfficiencyCorrectionTool::m_nCorrSyst
int m_nCorrSyst
Definition: AsgElectronEfficiencyCorrectionTool.h:200
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
AsgElectronEfficiencyCorrectionTool::m_recoKey
std::string m_recoKey
Definition: AsgElectronEfficiencyCorrectionTool.h:160
AsgElectronEfficiencyCorrectionTool::appliedSystematics
virtual const CP::SystematicSet & appliedSystematics() const override final
returns: the currently applied systematics
Definition: AsgElectronEfficiencyCorrectionTool.h:102
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
AsgElectronEfficiencyCorrectionTool::m_number_of_toys
int m_number_of_toys
Definition: AsgElectronEfficiencyCorrectionTool.h:191
AsgElectronEfficiencyCorrectionTool::m_resultPrefix
std::string m_resultPrefix
The prefix string for the result.
Definition: AsgElectronEfficiencyCorrectionTool.h:169
asg::AsgMetadataTool::metaDataStop
virtual StatusCode metaDataStop()
Function called when the tool should write out its metadata.
Definition: AsgMetadataTool.cxx:204
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AsgElectronEfficiencyCorrectionTool::m_seed_toys
int m_seed_toys
Definition: AsgElectronEfficiencyCorrectionTool.h:194
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
AsgElectronEfficiencyCorrectionTool::m_nUncorrSyst
int m_nUncorrSyst
Definition: AsgElectronEfficiencyCorrectionTool.h:201
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
correlationModel::COMBMCTOYS
@ COMBMCTOYS
Definition: AsgElectronEfficiencyCorrectionTool.cxx:47
xAOD::FileMetaData_v1
Class holding file-level metadata about an xAOD file.
Definition: FileMetaData_v1.h:34
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
AsgElectronEfficiencyCorrectionTool::m_scale_toys
double m_scale_toys
Definition: AsgElectronEfficiencyCorrectionTool.h:197
AsgElectronEfficiencyCorrectionTool::m_dataTypeOverwrite
int m_dataTypeOverwrite
Force the data type to a given value.
Definition: AsgElectronEfficiencyCorrectionTool.h:188
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
AsgElectronEfficiencyCorrectionTool::m_corrVarDown
std::vector< CP::SystematicVariation > m_corrVarDown
Definition: AsgElectronEfficiencyCorrectionTool.h:215
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
asg::AsgMetadataTool::m_inputMetaStore
MetaStore_t m_inputMetaStore
Object accessing the input metadata store.
Definition: AsgMetadataTool.h:119
CP::SystematicSet::insert
void insert(const SystematicVariation &systematic)
description: insert a systematic into the set
Definition: SystematicSet.cxx:88
correlationModel::SIMPLIFIED
@ SIMPLIFIED
Definition: AsgElectronEfficiencyCorrectionTool.cxx:50
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
AsgElectronEfficiencyCorrectionTool::getEfficiencyScaleFactor
virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::Electron &inputObject, double &efficiencyScaleFactor) const override final
Definition: AsgElectronEfficiencyCorrectionTool.cxx:320
AsgElectronEfficiencyCorrectionTool::m_systFilter
std::unordered_map< CP::SystematicSet, CP::SystematicSet > m_systFilter
Systematics filter map.
Definition: AsgElectronEfficiencyCorrectionTool.h:144
AsgElectronEfficiencyCorrectionTool::m_eventInfoCollectionName
std::string m_eventInfoCollectionName
The Event info collection name.
Definition: AsgElectronEfficiencyCorrectionTool.h:178
AsgElectronEfficiencyCorrectionTool::get_simType_from_metadata
StatusCode get_simType_from_metadata(PATCore::ParticleDataType::DataType &result) const
Definition: AsgElectronEfficiencyCorrectionTool.cxx:926
AsgElectronEfficiencyCorrectionTool::m_trigKey
std::string m_trigKey
Definition: AsgElectronEfficiencyCorrectionTool.h:163
AsgElectronEfficiencyCorrectionTool::affectingSystematics
virtual CP::SystematicSet affectingSystematics() const override final
returns: the list of all systematics this tool can be affected by
Definition: AsgElectronEfficiencyCorrectionTool.cxx:556
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
AsgElectronEfficiencyCorrectionTool::m_uncorrVarUp
std::vector< CP::SystematicVariation > m_uncorrVarUp
Definition: AsgElectronEfficiencyCorrectionTool.h:216
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition: CorrectionCode.h:38
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ElRecomFileHelpers::convertToOneKey
std::string convertToOneKey(const std::string &recokey, const std::string &idkey, const std::string &isokey, const std::string &trigkey)
Definition: ElRecomFileHelpers.cxx:38
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
AsgElectronEfficiencyCorrectionTool::m_nSimpleUncorrSyst
int m_nSimpleUncorrSyst
Definition: AsgElectronEfficiencyCorrectionTool.h:210
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CP::SystematicVariation::empty
bool empty() const
returns: whether this is an empty systematic, i.e.
Definition: SystematicVariation.cxx:294
CP::SystematicRegistry
This module implements the central registry for handling systematic uncertainties with CP tools.
Definition: SystematicRegistry.h:25
AsgElectronEfficiencyCorrectionTool::m_affectedSys
CP::SystematicSet m_affectedSys
Affected systematic, should be done only once.
Definition: AsgElectronEfficiencyCorrectionTool.h:147
CP::SystematicSet::begin
const_iterator begin() const
description: const iterator to the beginning of the set
Definition: SystematicSet.h:55
DeMoScan.first
bool first
Definition: DeMoScan.py:534
AsgElectronEfficiencyCorrectionTool::m_corrVarUp
std::vector< CP::SystematicVariation > m_corrVarUp
Definition: AsgElectronEfficiencyCorrectionTool.h:214
AsgElectronEfficiencyCorrectionTool::m_UncorrRegions
TH2F * m_UncorrRegions
Definition: AsgElectronEfficiencyCorrectionTool.h:209
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CP::CorrectionCode
Return value from object correction CP tools.
Definition: CorrectionCode.h:31
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
xAOD::Egamma_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: Egamma_v1.cxx:65
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
AsgElectronEfficiencyCorrectionTool::m_pteta_bins
std::vector< std::pair< float, std::vector< float > > > m_pteta_bins
Definition: AsgElectronEfficiencyCorrectionTool.h:202
AsgElectronEfficiencyCorrectionTool::m_sysSubstring
std::string m_sysSubstring
Definition: AsgElectronEfficiencyCorrectionTool.h:175
xAOD::Egamma_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: Egamma_v1.cxx:70
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
merge.status
status
Definition: merge.py:17
AsgElectronEfficiencyCorrectionTool::m_metadata_retrieved
bool m_metadata_retrieved
To check if the metadata can be retrieved.
Definition: AsgElectronEfficiencyCorrectionTool.h:138
SG::DataProxy
Definition: DataProxy.h:44
ElRecomFileHelpers::getValueByKey
std::string getValueByKey(const std::string &mapFile, const std::string &key)
Definition: ElRecomFileHelpers.cxx:75
CP::SystematicVariation::makeToyEnsemble
static SystematicVariation makeToyEnsemble(const std::string &basename)
constructor for toy systematics ensemble
Definition: SystematicVariation.cxx:258
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
CP::SystematicSet::filterForAffectingSystematics
static StatusCode filterForAffectingSystematics(const SystematicSet &systConfig, const SystematicSet &affectingSystematics, SystematicSet &filteredSystematics)
description: filter the systematics for the affected systematics returns: success guarantee: strong f...
Definition: SystematicSet.cxx:213
correlationModel::TOTAL
@ TOTAL
Definition: AsgElectronEfficiencyCorrectionTool.cxx:51
fitman.k
k
Definition: fitman.py:528
CP::SystematicRegistry::getInstance
static SystematicRegistry & getInstance()
Get the singleton instance of the registry for the curren thread.
Definition: SystematicRegistry.cxx:25
AthAnalysisHelper::retrieveMetadata
static std::string retrieveMetadata(const std::string &folder, const std::string &key, const ServiceHandle< StoreGateSvc > &inputMetaStore)
method that always returns as a string you can use from, e.g, pyROOT with evt = ROOT....
Definition: AthAnalysisHelper.h:254
ServiceHandle< IIncidentSvc >
AsgElectronEfficiencyCorrectionTool::currentSimplifiedUncorrSystRegion
int currentSimplifiedUncorrSystRegion(const double cluster_eta, const double et) const
Definition: AsgElectronEfficiencyCorrectionTool.cxx:700
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
asg::AsgMetadataTool::m_useIncidents
bool m_useIncidents
Definition: AsgMetadataTool.h:128
Generated on Fri Jun 28 2024 21:38:58 for ATLAS Offline Software by   doxygen 1.8.18