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 565 of file AsgElectronEfficiencyCorrectionTool.cxx.

566 {
567  return m_affectedSys;
568 }

◆ 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 532 of file AsgElectronEfficiencyCorrectionTool.cxx.

534 {
535  double efficiencyScaleFactor = 1.0;
536  CP::CorrectionCode result =
537  getEfficiencyScaleFactor(inputObject, efficiencyScaleFactor);
538  const static SG::AuxElement::Decorator<float> dec(m_resultPrefix +
539  m_resultName + "SF");
540  dec(inputObject) = efficiencyScaleFactor;
541  return result;
542 }

◆ 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 591 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ 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 922 of file AsgElectronEfficiencyCorrectionTool.cxx.

923 {
924 
925  if (m_dataTypeOverwrite != -1)
926  return StatusCode::SUCCESS;
927  if (m_metadata_retrieved)
928  return StatusCode::SUCCESS;
929 
930  m_metadata_retrieved = true;
931  return StatusCode::SUCCESS;
932 }

◆ 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 887 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ currentSimplifiedUncorrSystRegion()

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

Definition at line 709 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ currentUncorrSystRegion()

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

Definition at line 748 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ 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, 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 935 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ 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 392 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ getEfficiencyScaleFactor() [2/2]

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

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 329 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ 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 834 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ 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  // Check if the input contains uncorr/stat necessary
302  // to run non-total systematic model
303  if (m_correlation_model != correlationModel::TOTAL &&
304  m_rootTool->uncorrEmpty(m_dataType) ) {
305  ATH_MSG_ERROR("Called correlation model "+m_correlation_model_name+
306  " but input does not contain necessary histograms.");
307  return StatusCode::FAILURE;
308  }
309 
310  // Initialize the systematics
311  if (InitSystematics() != StatusCode::SUCCESS) {
312  ATH_MSG_ERROR("(InitSystematics() != StatusCode::SUCCESS)");
313  return StatusCode::FAILURE;
314  }
315  // Add the recommended systematics to the registry
316  if (registerSystematics() != StatusCode::SUCCESS) {
317  ATH_MSG_ERROR("(registerSystematics() != StatusCode::SUCCESS)");
318  return StatusCode::FAILURE;
319  }
320  // Configure for nominal systematics
321  if (applySystematicVariation(CP::SystematicSet()) != StatusCode::SUCCESS) {
322  ATH_MSG_ERROR("Could not configure for nominal settings");
323  return StatusCode::FAILURE;
324  }
325  return StatusCode::SUCCESS;
326 }

◆ InitSystematics()

StatusCode AsgElectronEfficiencyCorrectionTool::InitSystematics ( )
private

initialize the systematics

Definition at line 639 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ 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 549 of file AsgElectronEfficiencyCorrectionTool.cxx.

551 {
552  if (systematic.empty()) {
553  return false;
554  }
555  CP::SystematicSet sys = affectingSystematics();
556  if (m_correlation_model == correlationModel::MCTOYS ||
557  m_correlation_model == correlationModel::COMBMCTOYS) {
558  return (sys.begin()->ensembleContains(systematic));
559  } else {
560  return (sys.find(systematic) != sys.end());
561  }
562 }

◆ 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, 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, 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 585 of file AsgElectronEfficiencyCorrectionTool.cxx.

586 {
587  return affectingSystematics();
588 }

◆ registerSystematics()

StatusCode AsgElectronEfficiencyCorrectionTool::registerSystematics ( )
private

Definition at line 572 of file AsgElectronEfficiencyCorrectionTool.cxx.

573 {
574  CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
575 
576  if (registry.registerSystematics(*this) != StatusCode::SUCCESS) {
577  ATH_MSG_ERROR(
578  "Failed to add systematic to list of recommended systematics.");
579  return StatusCode::FAILURE;
580  }
581  return StatusCode::SUCCESS;
582 }

◆ 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 801 of file AsgElectronEfficiencyCorrectionTool.cxx.

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

◆ 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:834
python.Dso.registry
registry
Definition: Control/AthenaServices/python/Dso.py:159
AsgElectronEfficiencyCorrectionTool::m_correlation_model
int m_correlation_model
Definition: AsgElectronEfficiencyCorrectionTool.h:154
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:591
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
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:639
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:68
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:748
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:572
athena.value
value
Definition: athena.py:124
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:55
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
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
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
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
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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:59
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:85
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:228
AsgElectronEfficiencyCorrectionTool::getEfficiencyScaleFactor
virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::Electron &inputObject, double &efficiencyScaleFactor) const override final
Definition: AsgElectronEfficiencyCorrectionTool.cxx:329
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:935
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:565
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:536
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:623
xAOD::Egamma_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: Egamma_v1.cxx:65
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:798
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
LArCellNtuple.ifile
string ifile
Definition: LArCellNtuple.py:133
SG::DataProxy
Definition: DataProxy.h:45
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:709
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
asg::AsgMetadataTool::m_useIncidents
bool m_useIncidents
Definition: AsgMetadataTool.h:128
Generated on Sun Dec 22 2024 21:26:46 for ATLAS Offline Software by   doxygen 1.8.18