ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
CP::EgammaCalibrationAndSmearingTool Class Referenceabstract

#include <EgammaCalibrationAndSmearingTool.h>

Inheritance diagram for CP::EgammaCalibrationAndSmearingTool:
Collaboration diagram for CP::EgammaCalibrationAndSmearingTool:

Classes

struct  AbsEtaCaloPredicate
 
struct  DoubleOrAbsEtaCaloPredicate
 
struct  EtaCaloPredicate
 
struct  SysInfo
 

Public Member Functions

virtual double getEnergy (xAOD::Egamma *, const xAOD::EventInfo *)
 
virtual double getElectronMomentum (const xAOD::Electron *, const xAOD::EventInfo *)
 
double getResolution (const xAOD::Egamma &particle, bool withCT=true) const override
 
double intermodule_correction (double Ecl, double phi, double eta) const
 
double correction_phi_unif (double eta, double phi) const
 
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

enum  ResolutionDecorrelation { ResolutionDecorrelation::FULL, ResolutionDecorrelation::ONENP }
 
typedef unsigned int RandomNumber
 
typedef std::function< int(const EgammaCalibrationAndSmearingTool &, const xAOD::Egamma &, const xAOD::EventInfo &)> IdFunction
 
typedef std::function< bool(const xAOD::Egamma &)> EgammaPredicate
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

 EgammaCalibrationAndSmearingTool (const std::string &name)
 
 ~EgammaCalibrationAndSmearingTool ()
 
StatusCode initialize () override
 
virtual CP::CorrectionCode applyCorrection (xAOD::Egamma &) const override
 
virtual CP::CorrectionCode applyCorrection (xAOD::Egamma &input, const xAOD::EventInfo &event_info) const
 
virtual CP::CorrectionCode correctedCopy (const xAOD::Electron &, xAOD::Electron *&) const override
 
virtual CP::CorrectionCode correctedCopy (const xAOD::Photon &, xAOD::Photon *&) const override
 
double getEnergy (const xAOD::Photon &) const
 
double getEnergy (const xAOD::Electron &) const
 
virtual CP::SystematicSet affectingSystematics () const override
 the list of all systematics this tool can be affected by More...
 
virtual bool isAffectedBySystematic (const CP::SystematicVariation &systematic) const override
 Declare the interface that this class provides. More...
 
virtual CP::SystematicSet recommendedSystematics () const override
 the list of all systematics this tool recommends to use More...
 
virtual StatusCode applySystematicVariation (const CP::SystematicSet &systConfig) override
 effects: configure this tool for the given list of systematic variations. More...
 
virtual void setRandomSeedFunction (const IdFunction &&function)
 
const IdFunction getRandomSeedFunction () const
 
virtual double resolution (double energy, double cl_eta, double cl_etaCalo, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, bool withCT=false) const override
 
void setupSystematics ()
 
const EgammaPredicate EtaCaloPredicateFactory (double eta_min, double eta_max) const
 
const EgammaPredicate AbsEtaCaloPredicateFactory (double eta_min, double eta_max) const
 
const EgammaPredicate AbsEtaCaloPredicateFactory (std::pair< double, double > edges) const
 
const std::vector< EgammaPredicate > AbsEtaCaloPredicatesFactory (const std::vector< std::pair< double, double >> &edges) const
 
const std::vector< EgammaPredicate > AbsEtaCaloPredicatesFactory (const std::vector< double > &edges) const
 
const EgammaPredicate DoubleOrAbsEtaCaloPredicateFactory (double eta1_min, double eta1_max, double eta2_min, double eta2_max) const
 
PATCore::ParticleType::Type xAOD2ptype (const xAOD::Egamma &particle) const
 
egEnergyCorr::Scale::Variation oldtool_scale_flag_this_event (const xAOD::Egamma &p, const xAOD::EventInfo &event_info) const
 
egEnergyCorr::Resolution::Variation oldtool_resolution_flag_this_event (const xAOD::Egamma &p, const xAOD::EventInfo &event_info) 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

std::string m_ESModel
 
std::string m_decorrelation_model_name
 
std::string m_decorrelation_model_scale_name
 
std::string m_decorrelation_model_resolution_name
 
ScaleDecorrelation m_decorrelation_model_scale = ScaleDecorrelation::FULL
 
ResolutionDecorrelation m_decorrelation_model_resolution
 
egEnergyCorr::ESModel m_TESModel
 
int m_doScaleCorrection
 
int m_doSmearing
 
double m_varSF
 
std::string m_ResolutionType
 
egEnergyCorr::Resolution::resolutionType m_TResolutionType
 
int m_useFastSim
 
int m_use_AFII
 
PATCore::ParticleDataType::DataType m_simulation
 
int m_useIntermoduleCorrection
 
int m_usePhiUniformCorrection
 
int m_useCaloDistPhiUnifCorrection
 
int m_useGainCorrection
 
int m_doADCLinearityCorrection
 
int m_doLeakageCorrection
 
bool m_use_ep_combination
 
int m_use_mva_calibration
 
bool m_use_full_statistical_error
 
int m_use_temp_correction201215
 
int m_use_uA2MeV_2015_first2weeks_correction
 
bool m_use_mapping_correction
 
int m_user_random_run_number
 
int m_useGainInterpolation
 
int m_useLayerCorrection
 
int m_usePSCorrection
 
int m_useS12Correction
 
int m_useSaccCorrection
 
std::unique_ptr< TH2 > m_caloDistPhiUnifCorr
 
Gaudi::Property< bool > m_fixForMissingCells
 
ServiceHandle< IegammaMVASvc > m_MVACalibSvc
 
std::unique_ptr< egGain::GainUncertainty > m_gain_tool_run2
 
std::shared_ptr< LinearityADC > m_ADCLinearity_tool
 
egGain::GainTool * m_gain_tool = nullptr
 
egammaLayerRecalibTool * m_layer_recalibration_tool = nullptr
 
std::string m_layer_recalibration_tune
 
std::unique_ptr< AtlasRoot::egammaEnergyCorrectionTool > m_rootTool
 
std::string m_MVAfolder
 
std::map< CP::SystematicVariation, SysInfo > m_syst_description
 
std::map< CP::SystematicVariation, egEnergyCorr::Resolution::Variation > m_syst_description_resolution
 
egEnergyCorr::Scale::Variation m_currentScaleVariation_MC
 
egEnergyCorr::Scale::Variation m_currentScaleVariation_data
 
egEnergyCorr::Resolution::Variation m_currentResolutionVariation_MC
 
egEnergyCorr::Resolution::Variation m_currentResolutionVariation_data
 
EgammaPredicate m_currentScalePredicate
 
IdFunction m_set_seed_function
 
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
 

Static Private Attributes

static const int AUTO = 2
 
static const unsigned int m_Run2Run3runNumberTransition = 400000
 

Callback functions helping in metadata reading/writing

void setUseIncidents (const bool flag)
 
virtual void handle (const Incident &inc)
 Function receiving incidents from IncidentSvc/TEvent. More...
 
virtual StatusCode beginInputFile ()
 Function called when a new input file is opened. More...
 
virtual StatusCode endInputFile ()
 Function called when the currently open input file got completely processed. More...
 
virtual StatusCode beginEvent ()
 Function called when a new events is loaded. More...
 
virtual StatusCode metaDataStop ()
 Function called when the tool should write out its metadata. More...
 

Detailed Description

Definition at line 89 of file EgammaCalibrationAndSmearingTool.h.

Member Typedef Documentation

◆ EgammaPredicate

typedef std::function<bool(const xAOD::Egamma&)> CP::EgammaCalibrationAndSmearingTool::EgammaPredicate
private

Definition at line 111 of file EgammaCalibrationAndSmearingTool.h.

◆ IdFunction

typedef std::function<int(const EgammaCalibrationAndSmearingTool&, const xAOD::Egamma&, const xAOD::EventInfo&)> CP::EgammaCalibrationAndSmearingTool::IdFunction
private

Definition at line 110 of file EgammaCalibrationAndSmearingTool.h.

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

◆ RandomNumber

typedef unsigned int CP::EgammaCalibrationAndSmearingTool::RandomNumber
private

Definition at line 107 of file EgammaCalibrationAndSmearingTool.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ ResolutionDecorrelation

enum CP::EgammaCalibrationAndSmearingTool::ResolutionDecorrelation
strongprivate
Enumerator
FULL 
ONENP 

Definition at line 104 of file EgammaCalibrationAndSmearingTool.h.

104 { FULL, ONENP };

Constructor & Destructor Documentation

◆ EgammaCalibrationAndSmearingTool()

CP::EgammaCalibrationAndSmearingTool::EgammaCalibrationAndSmearingTool ( const std::string &  name)
private

Definition at line 266 of file EgammaCalibrationAndSmearingTool.cxx.

268  : asg::AsgMetadataTool(name),
269  m_TESModel(egEnergyCorr::UNDEFINED),
270  m_TResolutionType(egEnergyCorr::Resolution::SigmaEff90),
271  m_use_mapping_correction(false),
272  m_currentScaleVariation_MC(egEnergyCorr::Scale::None),
273  m_currentScaleVariation_data(egEnergyCorr::Scale::Nominal),
274  m_currentResolutionVariation_MC(egEnergyCorr::Resolution::Nominal),
275  m_currentResolutionVariation_data(egEnergyCorr::Resolution::None),
276  m_set_seed_function([](const EgammaCalibrationAndSmearingTool&,
277  const xAOD::Egamma& egamma,
278  const xAOD::EventInfo& ei) {
279  // avoid 0 as result, see
280  // https://root.cern.ch/root/html/TRandom3.html#TRandom3:SetSeed
281  return 1 + static_cast<RandomNumber>(
282  std::abs(egamma.caloCluster()->phi()) * 1E6 +
283  std::abs(egamma.caloCluster()->eta()) * 1E3 +
284  ei.eventNumber());
285  }) {
286 
287  declareProperty("ESModel", m_ESModel = "");
288  declareProperty("decorrelationModel", m_decorrelation_model_name = "");
289  declareProperty("decorrelationModelScale",
290  m_decorrelation_model_scale_name = "");
291  declareProperty("decorrelationModelResolution",
292  m_decorrelation_model_resolution_name = "");
293  declareProperty("ResolutionType", m_ResolutionType = "SigmaEff90");
294  declareProperty("varSF", m_varSF = 1.0);
295  declareProperty("doScaleCorrection", m_doScaleCorrection = AUTO);
296  declareProperty("doSmearing", m_doSmearing = AUTO);
297  declareProperty("useLayerCorrection", m_useLayerCorrection = AUTO);
298  declareProperty("usePSCorrection", m_usePSCorrection = AUTO);
299  declareProperty("useS12Correction", m_useS12Correction = AUTO);
300  declareProperty("useSaccCorrection", m_useSaccCorrection = AUTO);
301  declareProperty("useIntermoduleCorrection",
302  m_useIntermoduleCorrection = AUTO);
303  declareProperty("usePhiUniformCorrection", m_usePhiUniformCorrection = AUTO);
304  declareProperty("useCaloDistPhiUnifCorrection",
305  m_useCaloDistPhiUnifCorrection = AUTO);
306  declareProperty("useGainCorrection", m_useGainCorrection = AUTO);
307  declareProperty("useGainInterpolation", m_useGainInterpolation = AUTO);
308  declareProperty("doADCLinearityCorrection",
309  m_doADCLinearityCorrection = AUTO);
310  declareProperty("doLeakageCorrection", m_doLeakageCorrection = AUTO);
311  declareProperty("MVAfolder", m_MVAfolder = "");
312  declareProperty("layerRecalibrationTune", m_layer_recalibration_tune = "");
313  declareProperty("useEPCombination", m_use_ep_combination = false);
314  declareProperty("useMVACalibration", m_use_mva_calibration = AUTO);
315  declareProperty("use_full_statistical_error",
316  m_use_full_statistical_error = false);
317  declareProperty("use_temp_correction201215",
318  m_use_temp_correction201215 = AUTO);
319  declareProperty("use_uA2MeV_2015_first2weeks_correction",
320  m_use_uA2MeV_2015_first2weeks_correction = AUTO);
321  declareProperty("randomRunNumber", m_user_random_run_number = 0);
322  // this is the user input, it is never changed by the tool. The tool uses
323  // m_simulation.
324  declareProperty("useFastSim", m_useFastSim = -1,
325  "This should be explicitly set by the user depending on the "
326  "data type (int)0=full sim, (int)1=fast sim");
327  declareProperty(
328  "useAFII", m_use_AFII = -1,
329  "This is now deprecated. Kept for explicit error message for now");
330 }

◆ ~EgammaCalibrationAndSmearingTool()

CP::EgammaCalibrationAndSmearingTool::~EgammaCalibrationAndSmearingTool ( )
private

Definition at line 332 of file EgammaCalibrationAndSmearingTool.cxx.

332  {
333  ATH_MSG_DEBUG("destructor");
334  delete m_layer_recalibration_tool;
335  delete m_gain_tool;
336 }

Member Function Documentation

◆ AbsEtaCaloPredicateFactory() [1/2]

const EgammaPredicate CP::EgammaCalibrationAndSmearingTool::AbsEtaCaloPredicateFactory ( double  eta_min,
double  eta_max 
) const
inlineprivate

Definition at line 236 of file EgammaCalibrationAndSmearingTool.h.

237  {
238  /*return [eta_min, eta_max](const xAOD::Egamma& p) {
239  const double aeta = std::abs(xAOD::get_eta_calo(*p.caloCluster()));
240  return (aeta >= eta_min and aeta < eta_max); };*/
241  return AbsEtaCaloPredicate(eta_min, eta_max);
242  }

◆ AbsEtaCaloPredicateFactory() [2/2]

const EgammaPredicate CP::EgammaCalibrationAndSmearingTool::AbsEtaCaloPredicateFactory ( std::pair< double, double >  edges) const
inlineprivate

Definition at line 244 of file EgammaCalibrationAndSmearingTool.h.

245  {
246  return AbsEtaCaloPredicateFactory(edges.first, edges.second);
247  }

◆ AbsEtaCaloPredicatesFactory() [1/2]

const std::vector<EgammaPredicate> CP::EgammaCalibrationAndSmearingTool::AbsEtaCaloPredicatesFactory ( const std::vector< double > &  edges) const
inlineprivate

Definition at line 259 of file EgammaCalibrationAndSmearingTool.h.

260  {
261  std::vector<EgammaPredicate> result;
262  result.reserve(edges.size() - 1);
263  auto it2 = edges.begin();
264  auto it = it2++;
265  for (; it2 != edges.end(); ++it, ++it2) {
266  result.push_back(AbsEtaCaloPredicateFactory(*it, *it2));
267  }
268  return result;
269  }

◆ AbsEtaCaloPredicatesFactory() [2/2]

const std::vector<EgammaPredicate> CP::EgammaCalibrationAndSmearingTool::AbsEtaCaloPredicatesFactory ( const std::vector< std::pair< double, double >> &  edges) const
inlineprivate

Definition at line 249 of file EgammaCalibrationAndSmearingTool.h.

250  {
251  std::vector<EgammaPredicate> result;
252  result.reserve(edges.size());
253  for (const auto& it : edges) {
254  result.push_back(AbsEtaCaloPredicateFactory(it.first, it.second));
255  }
256  return result;
257  }

◆ affectingSystematics()

CP::SystematicSet CP::EgammaCalibrationAndSmearingTool::affectingSystematics ( ) const
overrideprivatevirtual

the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 1164 of file EgammaCalibrationAndSmearingTool.cxx.

1165  {
1166  CP::SystematicSet affecting_systematics;
1167  for (const auto& it : m_syst_description) {
1168  affecting_systematics.insert(it.first);
1169  }
1170  for (const auto& it : m_syst_description_resolution) {
1171  affecting_systematics.insert(it.first);
1172  }
1173 
1174  return affecting_systematics;
1175 }

◆ applyCorrection() [1/2]

CP::CorrectionCode CP::EgammaCalibrationAndSmearingTool::applyCorrection ( xAOD::Egamma &  input) const
overrideprivatevirtual

Implements CP::IEgammaCalibrationAndSmearingTool.

Definition at line 833 of file EgammaCalibrationAndSmearingTool.cxx.

834  {
835  // Retrieve the event information:
836  const xAOD::EventInfo* event_info = nullptr;
837  if (evtStore()->retrieve(event_info, "EventInfo").isFailure()) {
838  ATH_MSG_ERROR("No EventInfo object could be retrieved");
839  return CP::CorrectionCode::Error;
840  }
841  return applyCorrection(input, *event_info);
842 }

◆ applyCorrection() [2/2]

CP::CorrectionCode CP::EgammaCalibrationAndSmearingTool::applyCorrection ( xAOD::Egamma &  input,
const xAOD::EventInfo &  event_info 
) const
privatevirtual

Definition at line 888 of file EgammaCalibrationAndSmearingTool.cxx.

889  {
890 
891  // only used in simulation (for the smearing)
892  RandomNumber seed = m_set_seed_function(*this, input, event_info);
893 
894  static const SG::ConstAccessor<double> Es0Acc("correctedcl_Es0");
895  static const SG::ConstAccessor<double> Es1Acc("correctedcl_Es1");
896  static const SG::ConstAccessor<double> Es2Acc("correctedcl_Es2");
897  static const SG::ConstAccessor<double> Es3Acc("correctedcl_Es3");
898 
899  if (m_layer_recalibration_tool) {
900  ATH_MSG_DEBUG("applying energy recalibration before E0|E1|E2|E3 = "
901  << input.caloCluster()->energyBE(0) << "|"
902  << input.caloCluster()->energyBE(1) << "|"
903  << input.caloCluster()->energyBE(2) << "|"
904  << input.caloCluster()->energyBE(3));
905  const CP::CorrectionCode status_layer_recalibration =
906  m_layer_recalibration_tool->applyCorrection(input, event_info);
907  if (status_layer_recalibration == CP::CorrectionCode::Error) {
908  return CP::CorrectionCode::Error;
909  }
910  ATH_MSG_DEBUG("eta|phi = " << input.eta() << "|" << input.phi());
911  if (status_layer_recalibration == CP::CorrectionCode::Ok) {
912  ATH_MSG_DEBUG("decoration E0|E1|E2|E3 = "
913  << Es0Acc(*input.caloCluster()) << "|"
914  << Es1Acc(*input.caloCluster()) << "|"
915  << Es2Acc(*input.caloCluster()) << "|"
916  << Es3Acc(*input.caloCluster()) << "|");
917  if (Es2Acc(*input.caloCluster()) == 0 and
918  Es1Acc(*input.caloCluster()) == 0 and
919  Es3Acc(*input.caloCluster()) == 0 and
920  Es0Acc(*input.caloCluster()) == 0 and
921  (std::abs(input.eta()) < 1.37 or
922  (std::abs(input.eta()) > 1.55 and std::abs(input.eta()) < 2.47))) {
923  ATH_MSG_WARNING("all layer energies are zero");
924  }
925  }
926  }
927 
928  double energy = 0.;
929  // apply MVA calibration
930  if (!m_MVACalibSvc.empty()) {
931  if (input.author() !=
932  xAOD::EgammaParameters::AuthorFwdElectron) { // do not apply MVA
933  // calibration to fwd
934  // electrons
935  m_MVACalibSvc->getEnergy(*input.caloCluster(), input, energy)
936  .ignore(); // TODO check StatusCode
937  } else {
938  energy = input.e();
939  }
940  ATH_MSG_DEBUG("energy after MVA calibration = " << std::format("{:.2f}", energy));
941  } else {
942  energy = input.e();
943  }
944 
945  if (m_TESModel == egEnergyCorr::es2011c) {
946  // Crack calibation correction for es2011c (calibration hits calibration)
947  const auto ptype = xAOD2ptype(input);
948  const double etaden =
949  ptype == PATCore::ParticleType::Electron
950  ? static_cast<xAOD::Electron&>(input).trackParticle()->eta()
951  : input.caloCluster()->eta();
952  energy *= m_rootTool->applyMCCalibration(input.caloCluster()->eta(),
953  energy / cosh(etaden), ptype);
954  ATH_MSG_DEBUG("energy after crack calibration es2011c = "
955  << std::format("{:.2f}", energy));
956  }
957 
958  /*
959  * Here we check for each event the kind of data DATA vs FullSim
960  * The m_simulation flavour has already been configured
961  */
962  PATCore::ParticleDataType::DataType dataType =
963  (event_info.eventType(xAOD::EventInfo::IS_SIMULATION))
964  ? m_simulation
965  : PATCore::ParticleDataType::Data;
966 
967  unsigned int runNumber_for_tool = 0;
968 
969  // apply uniformity corrections to data
970  if (dataType == PATCore::ParticleDataType::Data) {
971  // Get run number
972  runNumber_for_tool = event_info.runNumber();
973  // Get etaCalo, phiCalo
974  const auto cl_eta = input.caloCluster()->eta();
975  double etaCalo = 0, phiCalo = 0;
976  if (m_ADCLinearity_tool || m_gain_tool_run2 || m_usePhiUniformCorrection) {
977  etaCalo = xAOD::get_eta_calo(*input.caloCluster(), input.author(), false);
978  if (m_usePhiUniformCorrection) {
979  phiCalo =
980  xAOD::get_phi_calo(*input.caloCluster(), input.author(), false);
981  }
982  }
983 
984  // Intermodule
985  if (m_useIntermoduleCorrection) {
986  energy =
987  intermodule_correction(energy, input.caloCluster()->phi(), cl_eta);
988  ATH_MSG_DEBUG("energy after intermodule correction = "
989  << std::format("{:.2f}", energy));
990  }
991 
992  // Calo distortion
993  if (m_TESModel == egEnergyCorr::es2023_R22_Run2_v0 &&
994  m_useCaloDistPhiUnifCorrection) {
995  double etaC = input.caloCluster()->eta();
996  double phiC = input.caloCluster()->phi();
997  int ieta = m_caloDistPhiUnifCorr->GetXaxis()->FindBin(etaC);
998  ieta = ieta == 0 ? 1
999  : (ieta > m_caloDistPhiUnifCorr->GetNbinsX()
1000  ? m_caloDistPhiUnifCorr->GetNbinsX()
1001  : ieta);
1002  int iphi = m_caloDistPhiUnifCorr->GetYaxis()->FindBin(phiC);
1003  iphi = iphi == 0 ? 1
1004  : (iphi > m_caloDistPhiUnifCorr->GetNbinsY()
1005  ? m_caloDistPhiUnifCorr->GetNbinsY()
1006  : iphi);
1007  energy *= m_caloDistPhiUnifCorr->GetBinContent(ieta, iphi);
1008  ATH_MSG_DEBUG(
1009  "energy after phi uniformity correction (for calo distortion) = "
1010  << std::format("{:.2f}", energy));
1011  }
1012 
1013  // Phi
1014  if (m_usePhiUniformCorrection) {
1015  energy *= correction_phi_unif(etaCalo, phiCalo);
1016  ATH_MSG_DEBUG("energy after uniformity correction = "
1017  << std::format("{:.2f}", energy));
1018  }
1019 
1020  // ADC
1021  if (m_ADCLinearity_tool) {
1022  double et = energy / std::cosh(cl_eta);
1023  double corr =
1024  m_ADCLinearity_tool->getCorr(etaCalo, et, xAOD2ptype(input));
1025  energy *= corr;
1026  ATH_MSG_DEBUG("energy after ADC linearity correction = "
1027  << std::format("{:.2f}", energy));
1028  }
1029 
1030  // Gain
1031  if (m_gain_tool) {
1032  const auto es2 = Es2Acc.isAvailable(*input.caloCluster())
1033  ? Es2Acc(*input.caloCluster())
1034  : input.caloCluster()->energyBE(2);
1035  if (!(std::abs(cl_eta) < 1.52 and std::abs(cl_eta) > 1.37) and
1036  std::abs(cl_eta) < 2.4)
1037  energy = m_gain_tool->CorrectionGainTool(
1038  cl_eta, energy / GeV, es2 / GeV,
1039  xAOD2ptype(input)); // cl_eta ok, TODO: check corrected E2
1040  } else if (m_gain_tool_run2) {
1041  double et = energy / std::cosh(cl_eta);
1042  double corr = m_gain_tool_run2->getUncertainty(etaCalo, et,
1043  xAOD2ptype(input), true);
1044  energy /= (1 + corr);
1045  }
1046  ATH_MSG_DEBUG("energy after gain correction = " << std::format("{:.2f}", energy));
1047  } else {
1048  if (m_user_random_run_number == 0) {
1049  static const SG::AuxElement::Accessor<unsigned int>
1050  randomrunnumber_getter("RandomRunNumber");
1051  if (randomrunnumber_getter.isAvailable(event_info)) {
1052  runNumber_for_tool = randomrunnumber_getter(event_info);
1053  } else {
1054  ATH_MSG_ERROR(
1055  "Pileup tool not run before using "
1056  "ElectronPhotonFourMomentumCorrection! Assuming it is 2016. If you "
1057  "want to force a specific period set the property randomRunNumber "
1058  "of the tool, e.g. in the job option: "
1059  "tool.randomRunNumber = 123456 or "
1060  "tool.randomRunNumber = "
1061  "EgammaCalibrationAndSmearingToolRunNumbersExample.run_2016");
1062  runNumber_for_tool = EgammaCalibPeriodRunNumbersExample::run_2016;
1063  }
1064  } else {
1065  runNumber_for_tool = m_user_random_run_number;
1066  }
1067  }
1068 
1069  const double eraw = ((Es0Acc.isAvailable(*input.caloCluster())
1070  ? Es0Acc(*input.caloCluster())
1071  : input.caloCluster()->energyBE(0)) +
1072  (Es1Acc.isAvailable(*input.caloCluster())
1073  ? Es1Acc(*input.caloCluster())
1074  : input.caloCluster()->energyBE(1)) +
1075  (Es2Acc.isAvailable(*input.caloCluster())
1076  ? Es2Acc(*input.caloCluster())
1077  : input.caloCluster()->energyBE(2)) +
1078  (Es3Acc.isAvailable(*input.caloCluster())
1079  ? Es3Acc(*input.caloCluster())
1080  : input.caloCluster()->energyBE(3)));
1081 
1082 
1083  if (dataType == PATCore::ParticleDataType::Fast)
1084  ATH_MSG_DEBUG("is fast");
1085  else if (dataType == PATCore::ParticleDataType::Full)
1086  ATH_MSG_DEBUG("is full");
1087  else if (dataType == PATCore::ParticleDataType::Data)
1088  ATH_MSG_DEBUG("is data");
1089 
1090  // apply scale factors or systematics
1091  energy = m_rootTool->getCorrectedEnergy(
1092  runNumber_for_tool, dataType, xAOD2ptype(input),
1093  input.caloCluster()->eta(),
1094  input.caloCluster()->etaBE(2),
1095  xAOD::get_eta_calo(*input.caloCluster(), input.author(), false), energy,
1096  Es2Acc.isAvailable(*input.caloCluster())
1097  ? Es2Acc(*input.caloCluster())
1098  : input.caloCluster()->energyBE(2),
1099  eraw, seed, oldtool_scale_flag_this_event(input, event_info),
1100  oldtool_resolution_flag_this_event(input, event_info), m_TResolutionType,
1101  m_varSF);
1102 
1103  ATH_MSG_DEBUG("energy after scale/systematic correction = " << std::format("{:.2f}", energy));
1104 
1105  // TODO: this check should be done before systematics variations
1106  const double new_energy2 = energy * energy;
1107  const double m2 = input.m() * input.m();
1108  const double p2 = new_energy2 > m2 ? new_energy2 - m2 : 0.;
1109  input.setPt(sqrt(p2) / cosh(input.eta()));
1110  ATH_MSG_DEBUG("after setting pt, energy = " << input.e());
1111  return CP::CorrectionCode::Ok;
1112 }

◆ applySystematicVariation()

StatusCode CP::EgammaCalibrationAndSmearingTool::applySystematicVariation ( const CP::SystematicSet &  systConfig)
overrideprivatevirtual

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

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

Implements CP::ISystematicsTool.

Definition at line 1908 of file EgammaCalibrationAndSmearingTool.cxx.

1909  {
1910 
1911  // set the nominal one (no systematics)
1912  m_currentScaleVariation_MC = egEnergyCorr::Scale::None;
1913  m_currentScaleVariation_data = m_doScaleCorrection
1914  ? egEnergyCorr::Scale::Nominal
1915  : egEnergyCorr::Scale::None;
1916  m_currentResolutionVariation_MC = m_doSmearing
1917  ? egEnergyCorr::Resolution::Nominal
1918  : egEnergyCorr::Resolution::None;
1919  m_currentResolutionVariation_data = egEnergyCorr::Resolution::None;
1920  m_currentScalePredicate = [](const xAOD::Egamma&) { return true; };
1921 
1922  if (systConfig.empty())
1923  return StatusCode::SUCCESS;
1924 
1925  // the following code allows only ONE systematic variation at a time (1 for
1926  // scale, 1 for resolution)
1927 
1928  bool first_scale = true;
1929  bool first_resolution = true;
1930  for (const auto& it : systConfig) {
1931  const auto found_scale = m_syst_description.find(it);
1932  if (found_scale != m_syst_description.end()) {
1933  if (not first_scale) {
1934  ATH_MSG_ERROR("multiple scale variations not supported");
1935  throw std::runtime_error("multiple scale variations not supported");
1936  }
1937  first_scale = false;
1938  m_currentScaleVariation_MC = found_scale->second.effect;
1939  m_currentScalePredicate = found_scale->second.predicate;
1940  }
1941 
1942  const auto found_resolution = m_syst_description_resolution.find(it);
1943  if (found_resolution != m_syst_description_resolution.end()) {
1944  if (not first_resolution) {
1945  ATH_MSG_ERROR("multiple resolution variations not supported");
1946  throw std::runtime_error(
1947  "multiple resolution variations not supported");
1948  }
1949  first_resolution = false;
1950  m_currentResolutionVariation_MC = found_resolution->second;
1951  }
1952  }
1953 
1954  return StatusCode::SUCCESS;
1955 }

◆ beginEvent()

StatusCode asg::AsgMetadataTool::beginEvent ( )
protectedvirtualinherited

Function called when a new events is loaded.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in AsgElectronEfficiencyCorrectionTool, TrigConf::xAODConfigTool, TauAnalysisTools::TauSelectionTool, TauAnalysisTools::DiTauSelectionTool, TauAnalysisTools::CommonSmearingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, Trig::TrigDecisionTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, Trig::TrigConfBunchCrossingTool, xAODMaker::TriggerMenuMetaDataTool, and Trig::xAODBunchCrossingTool.

Definition at line 196 of file AsgMetadataTool.cxx.

196  {
197 
198  // Return gracefully:
199  return StatusCode::SUCCESS;
200  }

◆ beginInputFile()

StatusCode asg::AsgMetadataTool::beginInputFile ( )
protectedvirtualinherited

Function called when a new input file is opened.

Dummy implementation that can be overridden by the derived tool.

Reimplemented in AsgElectronEfficiencyCorrectionTool, TrigConf::xAODConfigTool, PMGTools::PMGTruthWeightTool, BookkeeperTool, xAODMaker::FileMetaDataTool, BookkeeperDumperTool, Trig::TrigDecisionTool, xAODMaker::TriggerMenuMetaDataTool, xAODMaker::TruthMetaDataTool, Trig::xAODBunchCrossingTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, and TauAnalysisTools::TauSmearingTool.

Definition at line 180 of file AsgMetadataTool.cxx.

180  {
181 
182  // Return gracefully:
183  return StatusCode::SUCCESS;
184  }

◆ correctedCopy() [1/2]

CP::CorrectionCode CP::EgammaCalibrationAndSmearingTool::correctedCopy ( const xAOD::Electron &  input,
xAOD::Electron *&  output 
) const
overrideprivatevirtual

Implements CP::IEgammaCalibrationAndSmearingTool.

Definition at line 844 of file EgammaCalibrationAndSmearingTool.cxx.

845  {
846  // A sanity check:
847  if (output)
848  ATH_MSG_WARNING(
849  "Non-null pointer received. "
850  "There's a possible memory leak!");
851 
852  output = new xAOD::Electron();
853  output->makePrivateStore(input);
854  return applyCorrection(*output);
855 }

◆ correctedCopy() [2/2]

CP::CorrectionCode CP::EgammaCalibrationAndSmearingTool::correctedCopy ( const xAOD::Photon &  input,
xAOD::Photon *&  output 
) const
overrideprivatevirtual

Implements CP::IEgammaCalibrationAndSmearingTool.

Definition at line 857 of file EgammaCalibrationAndSmearingTool.cxx.

858  {
859  // A sanity check:
860  if (output)
861  ATH_MSG_WARNING(
862  "Non-null pointer received. "
863  "There's a possible memory leak!");
864 
865  output = new xAOD::Photon();
866  output->makePrivateStore(input);
867  return applyCorrection(*output);
868 }

◆ correction_phi_unif()

double CP::EgammaCalibrationAndSmearingTool::correction_phi_unif ( double  eta,
double  phi 
) const

Definition at line 2143 of file EgammaCalibrationAndSmearingTool.cxx.

2144  {
2145  constexpr double PI = M_PI;
2146  double Fcorr = 1.0;
2147 
2148  if (m_use_mapping_correction) {
2149  // wrong mapping HV -> sectors in run1
2150  if (eta < -0.4 && eta > -0.6) {
2151  if (phi < (14 * PI / 32.) && phi > (13 * PI / 32.)) {
2152  Fcorr += 0.035;
2153  } else if (phi < (13 * PI / 32.) && phi > (12 * PI / 32.)) {
2154  Fcorr -= 0.035;
2155  }
2156  }
2157  }
2158 
2159  if (m_TESModel == egEnergyCorr::es2017_summer_improved ||
2160  m_TESModel == egEnergyCorr::es2017_summer_final ||
2161  m_TESModel == egEnergyCorr::es2017_R21_v0 ||
2162  m_TESModel == egEnergyCorr::es2017_R21_v1 or
2163  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 ||
2164  m_TESModel == egEnergyCorr::es2018_R21_v0 ||
2165  m_TESModel == egEnergyCorr::es2018_R21_v1 ||
2166  m_TESModel == egEnergyCorr::es2022_R22_PRE ||
2167  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
2168 
2169  if (eta < 0.2 && eta > 0.) {
2170  if (phi < (-7 * 2 * PI / 32.) && phi > (-8 * 2 * PI / 32.)) {
2171  Fcorr = 1.016314;
2172  }
2173  }
2174 
2175  else if (eta < 0.6 && eta > 0.4) {
2176  if (phi < 0 && phi > (-2 * PI / 32.)) {
2177  Fcorr = 1.041591;
2178  } else if (phi < (-4 * 2 * PI / 32.) && phi > (-5 * 2 * PI / 32.)) {
2179  Fcorr = 1.067346;
2180  }
2181  }
2182 
2183  else if (eta < 0.8 && eta > 0.6) {
2184  if (phi < (7 * 2 * PI / 32.) && phi > (6 * 2 * PI / 32.)) {
2185  Fcorr = 1.027980;
2186  }
2187  }
2188 
2189  else if (eta < 1.4 && eta > 1.2) {
2190  if (phi < (-9 * 2 * PI / 32.) && phi > (-10 * 2 * PI / 32.)) {
2191  Fcorr = 1.020299;
2192  } else if (phi < (-11 * 2 * PI / 32.) && phi > (-12 * 2 * PI / 32.)) {
2193  Fcorr = 1.051426;
2194  }
2195  }
2196 
2197  else if (eta < 2.3 && eta > 2.1) {
2198  if (phi < (-12 * 2 * PI / 32.) && phi > (-13 * 2 * PI / 32.)) {
2199  Fcorr = 1.071695;
2200  }
2201  }
2202 
2203  else if (eta < 0. && eta > -0.2) {
2204  if (phi < (-12 * 2 * PI / 32.) && phi > (-13 * 2 * PI / 32.)) {
2205  Fcorr = 1.008227;
2206  } else if (phi < (-8 * 2 * PI / 32.) && phi > (-9 * 2 * PI / 32.)) {
2207  Fcorr = 1.013929;
2208  }
2209  }
2210 
2211  else if (eta < -0.2 && eta > -0.4) {
2212  if (phi < (-9 * 2 * PI / 32.) && phi > (-10 * 2 * PI / 32.)) {
2213  Fcorr = 1.015749;
2214  }
2215  }
2216 
2217  else if (eta < -1.2 && eta > -1.4) {
2218  if (phi < (-6 * 2 * PI / 32.) && phi > (-7 * 2 * PI / 32.)) {
2219  Fcorr = 1.064954;
2220  }
2221  }
2222 
2223  else if (eta < -1.6 && eta > -1.8) {
2224  if (phi < (9 * 2 * PI / 32.) && phi > (8 * 2 * PI / 32.)) {
2225  Fcorr = 1.027448;
2226  }
2227  }
2228 
2229  else if (eta < -2.3 && eta > -2.5) {
2230  if (phi < (-8 * 2 * PI / 32.) && phi > (-9 * 2 * PI / 32.)) {
2231  Fcorr = 1.025882;
2232  } else if (phi < (5 * 2 * PI / 32.) && phi > (4 * 2 * PI / 32.)) {
2233  Fcorr = 1.036616;
2234  } else if (phi < (9 * 2 * PI / 32.) && phi > (8 * 2 * PI / 32.)) {
2235  Fcorr = 1.053838;
2236  } else if (phi < (10 * 2 * PI / 32.) && phi > (9 * 2 * PI / 32.)) {
2237  Fcorr = 1.026856;
2238  } else if (phi < (11 * 2 * PI / 32.) && phi > (10 * 2 * PI / 32.)) {
2239  Fcorr = 0.994382;
2240  }
2241  }
2242 
2243  } // es2017_summer_improved end
2244 
2245  else {
2246  if (eta < 0.6 && eta > 0.4) {
2247  if (phi < 0 && phi > (-2 * PI / 32.)) {
2248  Fcorr = 1.028;
2249  } else if (phi < (-4 * 2 * PI / 32.) && phi > (-5 * 2 * PI / 32.)) {
2250  Fcorr = 1.044;
2251  }
2252  }
2253 
2254  else if (eta < 0.8 && eta > 0.6) {
2255  if (phi < (7 * 2 * PI / 32.) && phi > (6 * 2 * PI / 32.)) {
2256  Fcorr = 1.022;
2257  }
2258  }
2259 
2260  else if (eta < 1.4 && eta > 1.2) {
2261  if (phi < (-11 * 2 * PI / 32.) && phi > (-12 * 2 * PI / 32.)) {
2262  Fcorr = 1.038;
2263  }
2264  }
2265 
2266  else if (eta < 2.0 && eta > 1.9) {
2267  if (phi < (10 * 2 * PI / 32.) && phi > (9 * 2 * PI / 32.)) {
2268  Fcorr = 1.029;
2269  }
2270  }
2271 
2272  else if (eta < -1.2 && eta > -1.4) {
2273  if (phi < (-4 * 2 * PI / 32.) && phi > (-5 * 2 * PI / 32.)) {
2274  Fcorr = 1.048;
2275  } else if (phi < (-6 * 2 * PI / 32.) && phi > (-7 * 2 * PI / 32.)) {
2276  Fcorr = 1.048;
2277  }
2278  }
2279 
2280  else if (eta < -1.6 && eta > -1.8) {
2281  if (phi < (9 * 2 * PI / 32.) && phi > (8 * 2 * PI / 32.)) {
2282  Fcorr = 1.024;
2283  }
2284  }
2285 
2286  else if (eta < -2.3 && eta > -2.5) {
2287  if (phi < (-8 * 2 * PI / 32.) && phi > (-9 * 2 * PI / 32.)) {
2288  Fcorr = 1.037;
2289  } else if (phi < (5 * 2 * PI / 32.) && phi > (4 * 2 * PI / 32.)) {
2290  Fcorr = 1.031;
2291  } else if (phi < (9 * 2 * PI / 32.) && phi > (8 * 2 * PI / 32.)) {
2292  Fcorr = 1.040;
2293  } else if (phi < (10 * 2 * PI / 32.) && phi > (9 * 2 * PI / 32.)) {
2294  Fcorr = 1.030;
2295  } else if (phi < (11 * 2 * PI / 32.) && phi > (10 * 2 * PI / 32.)) {
2296  Fcorr = 1.020;
2297  }
2298  }
2299  }
2300 
2301  return Fcorr;
2302 }

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

◆ DoubleOrAbsEtaCaloPredicateFactory()

const EgammaPredicate CP::EgammaCalibrationAndSmearingTool::DoubleOrAbsEtaCaloPredicateFactory ( double  eta1_min,
double  eta1_max,
double  eta2_min,
double  eta2_max 
) const
inlineprivate

Definition at line 290 of file EgammaCalibrationAndSmearingTool.h.

292  {
293  return DoubleOrAbsEtaCaloPredicate(eta1_min, eta1_max, eta2_min, eta2_max);
294  }

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

◆ EtaCaloPredicateFactory()

const EgammaPredicate CP::EgammaCalibrationAndSmearingTool::EtaCaloPredicateFactory ( double  eta_min,
double  eta_max 
) const
inlineprivate

Definition at line 216 of file EgammaCalibrationAndSmearingTool.h.

217  {
218  return EtaCaloPredicate(eta_min, eta_max);
219  }

◆ 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

◆ getElectronMomentum()

double CP::EgammaCalibrationAndSmearingTool::getElectronMomentum ( const xAOD::Electron *  el,
const xAOD::EventInfo *  event_info 
)
virtual

Definition at line 1140 of file EgammaCalibrationAndSmearingTool.cxx.

1141  {
1142  PATCore::ParticleDataType::DataType dataType =
1143  (event_info->eventType(xAOD::EventInfo::IS_SIMULATION))
1144  ? m_simulation
1145  : PATCore::ParticleDataType::Data;
1146 
1147  const xAOD::TrackParticle* eTrack = el->trackParticle();
1148 
1149  // track momentum and eta
1150  const float el_tracketa = eTrack->eta();
1151  const float el_trackmomentum = eTrack->pt() * cosh(el->eta());
1152 
1153  return m_rootTool->getCorrectedMomentum(
1154  dataType, PATCore::ParticleType::Electron, el_trackmomentum, el_tracketa,
1155  oldtool_scale_flag_this_event(*el, *event_info), m_varSF);
1156 }

◆ getEnergy() [1/3]

double CP::EgammaCalibrationAndSmearingTool::getEnergy ( const xAOD::Electron &  input) const
private

Definition at line 879 of file EgammaCalibrationAndSmearingTool.cxx.

880  {
881  xAOD::Electron* new_particle = nullptr;
882  ANA_CHECK_THROW(correctedCopy(input, new_particle));
883  const double e = new_particle->e();
884  delete new_particle;
885  return e;
886 }

◆ getEnergy() [2/3]

double CP::EgammaCalibrationAndSmearingTool::getEnergy ( const xAOD::Photon &  input) const
private

Definition at line 870 of file EgammaCalibrationAndSmearingTool.cxx.

871  {
872  xAOD::Photon* new_particle = nullptr;
873  ANA_CHECK_THROW(correctedCopy(input, new_particle));
874  const double e = new_particle->e();
875  delete new_particle;
876  return e;
877 }

◆ getEnergy() [3/3]

double CP::EgammaCalibrationAndSmearingTool::getEnergy ( xAOD::Egamma *  p,
const xAOD::EventInfo *  event_info 
)
virtual

Definition at line 1114 of file EgammaCalibrationAndSmearingTool.cxx.

1115  {
1116  ANA_CHECK_THROW(applyCorrection(*p, *event_info));
1117  ATH_MSG_DEBUG("returning " << p->e());
1118  return p->e();
1119 }

◆ getKey()

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

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

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

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

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

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

◆ getName()

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

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

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

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

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

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

◆ getProperty()

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

Get one of the tool's properties.

◆ getRandomSeedFunction()

const IdFunction CP::EgammaCalibrationAndSmearingTool::getRandomSeedFunction ( ) const
inlineprivate

Definition at line 147 of file EgammaCalibrationAndSmearingTool.h.

147 { return m_set_seed_function; }

◆ getResolution()

double CP::EgammaCalibrationAndSmearingTool::getResolution ( const xAOD::Egamma &  particle,
bool  withCT = true 
) const
overridevirtual

Implements CP::IEgammaCalibrationAndSmearingTool.

Definition at line 815 of file EgammaCalibrationAndSmearingTool.cxx.

816  {
817  const auto ptype = xAOD2ptype(particle);
818  const auto cl_etaCalo =
819  xAOD::get_eta_calo(*particle.caloCluster(), particle.author());
820 
821  return m_rootTool->resolution(particle.e(), particle.caloCluster()->eta(),
822  cl_etaCalo, ptype, withCT,
823  false); // TODO: always for full simulation
824 }

◆ 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 CP::EgammaCalibrationAndSmearingTool::initialize ( )
overrideprivatevirtual

Implements CP::IEgammaCalibrationAndSmearingTool.

Definition at line 338 of file EgammaCalibrationAndSmearingTool.cxx.

338  {
339  ATH_MSG_INFO("Initialization");
340 
341  if (m_ESModel == "es2015XX") {
342  ATH_MSG_ERROR("es2015XX is deprecated. Use es2015PRE");
343  }
344 
345  if (m_ESModel == "es2010") {
346  m_TESModel = egEnergyCorr::es2010;
347  } // legacy
348  else if (m_ESModel == "es2011c") {
349  m_TESModel = egEnergyCorr::es2011c;
350  } // mc11c : faulty G4; old geometry
351  else if (m_ESModel == "es2011d") {
352  m_TESModel = egEnergyCorr::es2011d;
353  } // mc11d : corrected G4; new geometry == final Run1 scheme
354  else if (m_ESModel == "es2012a") {
355  m_TESModel = egEnergyCorr::es2012a;
356  } // mc12a : "crude" G4 fix; old geometry
357  else if (m_ESModel == "es2012c") {
358  m_TESModel = egEnergyCorr::es2012c;
359  } // mc12c : corrected G4; new geometry == final Run1 scheme
360  else if (m_ESModel == "es2012XX") {
361  m_TESModel = egEnergyCorr::es2012XX;
362  } else if (m_ESModel == "es2015PRE") {
363  m_TESModel = egEnergyCorr::es2015PRE;
364  } else if (m_ESModel == "es2015PRE_res_improved") {
365  m_TESModel = egEnergyCorr::es2015PRE_res_improved;
366  } else if (m_ESModel == "es2015cPRE") {
367  m_TESModel = egEnergyCorr::es2015cPRE;
368  } else if (m_ESModel == "es2015cPRE_res_improved") {
369  m_TESModel = egEnergyCorr::es2015cPRE_res_improved;
370  } else if (m_ESModel == "es2015c_summer") {
371  m_TESModel = egEnergyCorr::es2015c_summer;
372  } else if (m_ESModel == "es2016PRE") {
373  m_TESModel = egEnergyCorr::es2016PRE;
374  } else if (m_ESModel == "es2016data_mc15c") {
375  m_TESModel = egEnergyCorr::es2017;
376  } else if (m_ESModel == "es2016data_mc15c_summer") {
377  m_TESModel = egEnergyCorr::es2017_summer;
378  } else if (m_ESModel == "es2016data_mc15c_summer_improved") {
379  m_TESModel = egEnergyCorr::es2017_summer_improved;
380  } else if (m_ESModel == "es2016data_mc15c_final") {
381  m_TESModel = egEnergyCorr::es2017_summer_final;
382  } else if (m_ESModel == "es2015_5TeV") {
383  m_TESModel = egEnergyCorr::es2015_5TeV;
384  } else if (m_ESModel == "es2017_R21_PRE") {
385  m_TESModel = egEnergyCorr::es2017_R21_PRE;
386  } else if (m_ESModel == "es2017_R21_v0") {
387  m_TESModel = egEnergyCorr::es2017_R21_v0;
388  } else if (m_ESModel == "es2017_R21_v1") {
389  m_TESModel = egEnergyCorr::es2017_R21_v1;
390  } else if (m_ESModel == "es2017_R21_ofc0_v1") {
391  m_TESModel = egEnergyCorr::es2017_R21_ofc0_v1;
392  } else if (m_ESModel == "es2018_R21_v0") {
393  m_TESModel = egEnergyCorr::es2018_R21_v0;
394  } else if (m_ESModel == "es2018_R21_v1") {
395  m_TESModel = egEnergyCorr::es2018_R21_v1;
396  } else if (m_ESModel == "es2022_R22_PRE") {
397  m_TESModel = egEnergyCorr::es2022_R22_PRE;
398  } else if (m_ESModel == "es2023_R22_Run2_v0") {
399  m_TESModel = egEnergyCorr::es2023_R22_Run2_v0;
400  } else if (m_ESModel.empty()) {
401  ATH_MSG_ERROR("you must set ESModel property");
402  return StatusCode::FAILURE;
403  } else {
404  ATH_MSG_ERROR("Cannot understand model " << m_ESModel);
405  return StatusCode::FAILURE;
406  }
407 
408  if (m_ResolutionType == "Gaussian") {
409  m_TResolutionType = egEnergyCorr::Resolution::Gaussian;
410  } else if (m_ResolutionType == "SigmaEff80") {
411  m_TResolutionType = egEnergyCorr::Resolution::SigmaEff80;
412  } else if (m_ResolutionType == "SigmaEff90") {
413  m_TResolutionType = egEnergyCorr::Resolution::SigmaEff90;
414  } else {
415  ATH_MSG_ERROR("Cannot understand resolution " << m_ResolutionType);
416  return StatusCode::FAILURE;
417  }
418 
419  if (m_use_AFII != -1) {
420  ATH_MSG_ERROR(
421  "Property useAFII is deprecated. It is now replaced with useFastSim, "
422  "which should be explicitly configured");
423  return StatusCode::FAILURE;
424  }
425 
426  if (m_useFastSim == 1) {
427  m_simulation = PATCore::ParticleDataType::Fast;
428  } else if (m_useFastSim == 0) {
429  m_simulation = PATCore::ParticleDataType::Full;
430  } else {
431  ATH_MSG_ERROR("Property useFastSim should be explicitly configured");
432  return StatusCode::FAILURE;
433  }
434 
435  if (m_TESModel == egEnergyCorr::es2022_R22_PRE &&
436  m_simulation == PATCore::ParticleDataType::Fast) {
437  ATH_MSG_ERROR(
438  "Sample is FastSim but no AF3 calibration is available yet with "
439  "es2022_R22_PRE recommendations. Please get in touch with the EGamma "
440  "CP group in case you are using this");
441  return StatusCode::FAILURE;
442  }
443 
444  // configure decorrelation model, translate string property to internal class
445  // enum
446  /* S R SR
447  0. 0 0 0 WARNING Full, Full (this is the default without configuration)
448  1. 0 0 1 SR
449  2. 0 1 0 FATAL
450  3. 0 1 1 WARNING SR then R
451  4. 1 0 0 FATAL
452  5. 1 0 1 WARNING SR then S
453  6. 1 1 0 S, R
454  7. 1 1 1 FATAL
455  */
456  if (m_decorrelation_model_name.empty() and
457  m_decorrelation_model_scale_name.empty() and
458  m_decorrelation_model_resolution_name.empty()) {
459  // case 0
460  ATH_MSG_WARNING("no decorrelation model specified, assuming full model");
461  m_decorrelation_model_scale = ScaleDecorrelation::FULL;
462  m_decorrelation_model_resolution = ResolutionDecorrelation::FULL;
463  m_decorrelation_model_name = "FULL_v1";
464  } else if (not m_decorrelation_model_name.empty() and
465  not m_decorrelation_model_scale_name.empty() and
466  not m_decorrelation_model_resolution_name.empty()) {
467  // case 7
468  ATH_MSG_FATAL("too many flags for the decorrelation model");
469  return StatusCode::FAILURE;
470  } else {
471  // set scale decorrelation model
472  if (not m_decorrelation_model_scale_name.empty()) { // case 4, 5, 6, (7)
473  if (not m_decorrelation_model_name.empty()) {
474  ATH_MSG_WARNING(
475  "flag decorrelation model ignored for scale decorrelation model");
476  } // case 5
477  if (m_decorrelation_model_scale_name == "1NP_v1")
478  m_decorrelation_model_scale = ScaleDecorrelation::ONENP;
479  else if (m_decorrelation_model_scale_name == "FULL_ETACORRELATED_v1")
480  m_decorrelation_model_scale = ScaleDecorrelation::FULL_ETA_CORRELATED;
481  else if (m_decorrelation_model_scale_name == "1NPCOR_PLUS_UNCOR")
482  m_decorrelation_model_scale = ScaleDecorrelation::ONENP_PLUS_UNCONR;
483  else if (m_decorrelation_model_scale_name == "FULL_v1")
484  m_decorrelation_model_scale = ScaleDecorrelation::FULL;
485  else {
486  ATH_MSG_FATAL("cannot understand the scale decorrelation model '"
487  << m_decorrelation_model_scale_name << "'(typo?)");
488  return StatusCode::FAILURE;
489  }
490  } else if (not m_decorrelation_model_name.empty()) { // case 1, 3
491  if (m_decorrelation_model_name == "1NP_v1")
492  m_decorrelation_model_scale = ScaleDecorrelation::ONENP;
493  else if (m_decorrelation_model_name == "FULL_ETACORRELATED_v1")
494  m_decorrelation_model_scale = ScaleDecorrelation::FULL_ETA_CORRELATED;
495  else if (m_decorrelation_model_name == "1NPCOR_PLUS_UNCOR")
496  m_decorrelation_model_scale = ScaleDecorrelation::ONENP_PLUS_UNCONR;
497  else if (m_decorrelation_model_name == "FULL_v1")
498  m_decorrelation_model_scale = ScaleDecorrelation::FULL;
499  else {
500  ATH_MSG_FATAL("cannot understand the decorrelation model '"
501  << m_decorrelation_model_name << "'(typo?)");
502  return StatusCode::FAILURE;
503  }
504  } else { // case 2, (7)
505  ATH_MSG_FATAL(
506  "not information how to initialize the scale decorrelation model");
507  return StatusCode::FAILURE;
508  }
509 
510  // set resolution decorralation model
511  if (not m_decorrelation_model_resolution_name
512  .empty()) { // case 2, 3, 6, (7)
513  if (not m_decorrelation_model_name.empty()) {
514  ATH_MSG_WARNING(
515  "flag decorrelation model ignored for resolution decorrelation "
516  "model");
517  } // case 3
518  if (m_decorrelation_model_resolution_name == "1NP_v1")
519  m_decorrelation_model_resolution = ResolutionDecorrelation::ONENP;
520  else if (m_decorrelation_model_resolution_name == "FULL_v1")
521  m_decorrelation_model_resolution = ResolutionDecorrelation::FULL;
522  else {
523  ATH_MSG_FATAL("cannot understand the resolution decorrelation model '"
524  << m_decorrelation_model_resolution_name << "'(typo?)");
525  return StatusCode::FAILURE;
526  }
527  } else if (not m_decorrelation_model_name.empty()) { // case 1, 5
528  if (m_decorrelation_model_name == "1NP_v1")
529  m_decorrelation_model_resolution = ResolutionDecorrelation::ONENP;
530  else if (m_decorrelation_model_name == "FULL_ETACORRELATED_v1")
531  m_decorrelation_model_resolution = ResolutionDecorrelation::FULL;
532  else if (m_decorrelation_model_name == "1NPCOR_PLUS_UNCOR")
533  m_decorrelation_model_resolution = ResolutionDecorrelation::ONENP;
534  else if (m_decorrelation_model_name == "FULL_v1")
535  m_decorrelation_model_resolution = ResolutionDecorrelation::FULL;
536  else {
537  ATH_MSG_FATAL("cannot understand the decorrelation model '"
538  << m_decorrelation_model_name << "'(typo?)");
539  return StatusCode::FAILURE;
540  }
541  }
542  }
543 
544  // create correction tool
545  ATH_MSG_DEBUG("creating internal correction tool");
546  m_rootTool = std::make_unique<AtlasRoot::egammaEnergyCorrectionTool>();
547  if (!m_rootTool) {
548  ATH_MSG_ERROR("Cannot initialize underlying tool");
549  return StatusCode::FAILURE;
550  }
551  m_rootTool->setESModel(m_TESModel);
552 
553  if (m_TESModel == egEnergyCorr::es2023_R22_Run2_v0 &&
554  (m_useGainInterpolation == AUTO || m_useGainInterpolation == 1)) {
555  ATH_MSG_DEBUG(
556  "Using linear interpolation in the gain tool (uncertainties only)");
557  m_useGainInterpolation = 1;
558  m_rootTool->setApplyL2GainInterpolation();
559  }
560  m_rootTool->msg().setLevel(this->msg().level());
561  m_rootTool->initialize();
562 
563  // configure MVA calibration
564  if (m_use_mva_calibration != 0) {
565  ATH_MSG_DEBUG("creating MVA calibration tool (if needed)");
566  if (m_MVAfolder.empty()) { // automatically configure MVA tool
567  m_MVAfolder = egammaMVAToolFolder(m_TESModel);
568  }
569 
570  if (not m_MVAfolder.empty()) {
571 
572  // electron MVA tool
573  asg::AsgToolConfig config_mva_electron(
574  "egammaMVACalibTool/tool_mva_electron");
575  config_mva_electron.setPropertyFromString("folder", m_MVAfolder);
576  ATH_CHECK(config_mva_electron.setProperty("use_layer_corrected", true));
577  ;
578  ATH_CHECK(config_mva_electron.setProperty(
579  "ParticleType", xAOD::EgammaParameters::electron));
580 
581  // unconverted photon MVA tool
582  asg::AsgToolConfig config_mva_unconverted(
583  "egammaMVACalibTool/tool_mva_unconverted");
584  config_mva_unconverted.setPropertyFromString("folder", m_MVAfolder);
585  ATH_CHECK(
586  config_mva_unconverted.setProperty("use_layer_corrected", true));
587  ATH_CHECK(config_mva_unconverted.setProperty(
588  "ParticleType", xAOD::EgammaParameters::unconvertedPhoton));
589 
590  // converted photon MVA tool
591  asg::AsgToolConfig config_mva_converted(
592  "egammaMVACalibTool/tool_mva_converted");
593  config_mva_converted.setPropertyFromString("folder", m_MVAfolder);
594  ATH_CHECK(config_mva_converted.setProperty("use_layer_corrected", true));
595  ATH_CHECK(config_mva_converted.setProperty(
596  "ParticleType", xAOD::EgammaParameters::convertedPhoton));
597 
598  // initialize the ServiceHandler egammaMVASvc
599  // make the name unique
600  std::ostringstream mva_service_name;
601  mva_service_name << "egammaMVASvc/service_mva_egamma_id"
602  << (void const*)this;
603  asg::AsgServiceConfig config_mva_service(mva_service_name.str());
604  ATH_CHECK(config_mva_service.addPrivateTool("ElectronTool",
605  config_mva_electron));
606  ATH_CHECK(config_mva_service.addPrivateTool("UnconvertedPhotonTool",
607  config_mva_unconverted));
608  ATH_CHECK(config_mva_service.addPrivateTool("ConvertedPhotonTool",
609  config_mva_converted));
610  ATH_CHECK(
611  config_mva_service.setProperty("OutputLevel", this->msg().level()));
612  ATH_CHECK(config_mva_service.makeService(m_MVACalibSvc));
613  } else {
614  m_use_mva_calibration = false;
615  }
616  }
617 
618  // configure layer recalibration tool
619  // For now: layer recalibration not applied to PRE release 21 (using run 1
620  // based calibration applied at reco level)
621  // for following R21 recommendations, need to apply the run2/run1 layer
622  // calibration ratio
623  if (m_ESModel == "es2017_R21_PRE") {
624  ATH_MSG_INFO("Layer recalibration already applied at cell level");
625  m_useLayerCorrection = false;
626  } else if (!m_useLayerCorrection) {
627  ATH_MSG_INFO("Layer corrections disabled!");
628  } else {
629  ATH_MSG_DEBUG("initializing layer recalibration tool (if needed)");
630  if (m_layer_recalibration_tune
631  .empty()) { // automatically configure layer recalibration tool
632  m_layer_recalibration_tool =
633  egammaLayerRecalibToolFactory(m_TESModel, m_useSaccCorrection)
634  .release();
635  if (!m_layer_recalibration_tool) {
636  ATH_MSG_INFO("not using layer recalibration");
637  }
638  } else {
639  m_layer_recalibration_tool =
640  new egammaLayerRecalibTool(m_layer_recalibration_tune);
641  }
642  if (m_layer_recalibration_tool) {
643  m_layer_recalibration_tool->msg().setLevel(this->msg().level());
644  m_layer_recalibration_tool->fixForMissingCells(m_fixForMissingCells);
645  if (!m_usePSCorrection) {
646  ATH_MSG_INFO("PS corrections disabled!");
647  m_layer_recalibration_tool->disable_PSCorrections();
648  }
649  if (!m_useS12Correction) {
650  ATH_MSG_INFO("S12 corrections disabled!");
651  m_layer_recalibration_tool->disable_S12Corrections();
652  }
653  if (!m_useSaccCorrection) {
654  ATH_MSG_INFO("Sacc corrections disabled!");
655  m_layer_recalibration_tool->disable_SaccCorrections();
656  }
657  }
658  }
659 
660  if (m_use_temp_correction201215 != AUTO)
661  m_rootTool->use_temp_correction201215(m_use_temp_correction201215);
662  if (m_use_uA2MeV_2015_first2weeks_correction != AUTO)
663  m_rootTool->use_uA2MeV_2015_first2weeks_correction(
664  m_use_uA2MeV_2015_first2weeks_correction);
665  if (not m_use_full_statistical_error and
666  m_decorrelation_model_scale == ScaleDecorrelation::FULL) {
667  m_rootTool->useStatErrorScaling(true);
668  }
669 
670  if (m_use_ep_combination) {
671  ATH_MSG_ERROR("ep combination not supported yet");
672  throw std::runtime_error("ep combination not supported yet");
673  }
674 
675  if (m_useIntermoduleCorrection == AUTO) {
676  m_useIntermoduleCorrection = use_intermodule_correction(m_TESModel);
677  }
678  if (m_usePhiUniformCorrection == AUTO) {
679  m_usePhiUniformCorrection = use_phi_uniform_correction(m_TESModel);
680  }
681  m_use_mapping_correction = not is_run2(m_TESModel);
682  if (m_useGainCorrection == AUTO &&
683  m_TESModel != egEnergyCorr::es2023_R22_Run2_v0) {
684  ATH_MSG_DEBUG("initializing gain tool");
685  m_gain_tool = gainToolFactory(m_TESModel).release();
686  m_useGainCorrection = bool(m_gain_tool);
687  } else if (m_useGainCorrection == AUTO &&
688  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
689  m_useGainCorrection = 0;
690  } else if (m_useGainCorrection == 1) {
691  if (m_TESModel != egEnergyCorr::es2023_R22_Run2_v0) {
692  m_useGainCorrection = 0;
693  ATH_MSG_ERROR(
694  "cannot instantiate gain tool for this model (you can only disable "
695  "the gain tool, but not enable it)");
696  } else {
697  ATH_MSG_INFO(
698  "initializing gain tool for run2 final precision recommendations");
699  ATH_MSG_WARNING(
700  "Gain corrections required but Zee scales are derived without Gain, "
701  "will cause inconsistency!");
702  std::string gain_tool_run_2_filename = PathResolverFindCalibFile(
703  "ElectronPhotonFourMomentumCorrection/v29/"
704  "gain_uncertainty_specialRun.root");
705  m_gain_tool_run2.reset(new egGain::GainUncertainty(
706  gain_tool_run_2_filename, false, "GainCorrection",
707  m_useGainInterpolation));
708  m_gain_tool_run2->msg().setLevel(this->msg().level());
709  }
710  }
711 
712  if (m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
713  // ADC non linearity correction
714  if (m_doADCLinearityCorrection == AUTO || m_doADCLinearityCorrection == 1) {
715  m_doADCLinearityCorrection = 1;
716  std::string adcLinearityCorr_filename = PathResolverFindCalibFile(
717  "ElectronPhotonFourMomentumCorrection/v25/linearity_ADC.root");
718  m_ADCLinearity_tool.reset(new LinearityADC(adcLinearityCorr_filename));
719  m_ADCLinearity_tool->msg().setLevel(this->msg().level());
720  m_rootTool->setADCTool(m_ADCLinearity_tool);
721  } else {
722  ATH_MSG_WARNING(
723  "es2023_R22_Run2_v0 recommendations use ADC corrections for scale "
724  "derivation. Disabling the ADCLinearity flag will create "
725  "inconsistency!");
726  }
727 
728  if (m_doLeakageCorrection == AUTO || m_doLeakageCorrection == 1) {
729  m_doLeakageCorrection = 1;
730  m_rootTool->setApplyLeakageCorrection(true);
731  }
732 
733  // Calo distortion phi unif correction
734  if (m_useCaloDistPhiUnifCorrection == AUTO ||
735  m_useCaloDistPhiUnifCorrection == 1) {
736  m_useCaloDistPhiUnifCorrection = 1;
737  std::string phiUnifCorrfileName = PathResolverFindCalibFile(
738  "ElectronPhotonFourMomentumCorrection/v32/"
739  "egammaEnergyCorrectionData.root");
740  std::unique_ptr<TFile> fCorr(
741  TFile::Open(phiUnifCorrfileName.c_str(), "READ"));
742  m_caloDistPhiUnifCorr.reset(
743  dynamic_cast<TH2*>(fCorr->Get("CaloDistortionPhiUniformityCorrection/"
744  "es2023_R22_Run2_v0/h2DcorrPhiUnif")));
745  m_caloDistPhiUnifCorr->SetDirectory(nullptr);
746  } else {
747  ATH_MSG_WARNING(
748  "es2023_R22_Run2_v0 recommendations use CaloDistPhiUnif for scale "
749  "derivation. Disabling the CaloDistPhiUnif flag will create "
750  "inconsistency!");
751  }
752  }
753 
754  // No scale correction for release 21 ==> obsolete
755  /*if (m_ESModel == "es2017_R21_PRE"){
756  m_doScaleCorrection = 0;
757  }
758  */
759 
760  ATH_MSG_INFO("ESModel: " << m_ESModel);
761  ATH_MSG_INFO("ResolutionType: " << m_ResolutionType);
762  ATH_MSG_INFO("decorrelation Model: " << m_decorrelation_model_name);
763  ATH_MSG_DEBUG("layer correction = " << m_useLayerCorrection);
764  ATH_MSG_DEBUG("PS correction = " << m_usePSCorrection);
765  ATH_MSG_DEBUG("S12 correction = " << m_useS12Correction);
766  ATH_MSG_DEBUG("Sacc correction = " << m_useSaccCorrection);
767  ATH_MSG_DEBUG("intermodule correction = " << m_useIntermoduleCorrection);
768  ATH_MSG_DEBUG("phi uniformity correction = " << m_usePhiUniformCorrection);
769  ATH_MSG_DEBUG("distorted calo phi uniformity correction = "
770  << m_useCaloDistPhiUnifCorrection);
771  ATH_MSG_DEBUG("gain correction = " << m_useGainCorrection);
772  ATH_MSG_DEBUG("ADC non-linearity correction = " << m_doADCLinearityCorrection);
773  ATH_MSG_DEBUG("leakage correction for photons = " << m_doLeakageCorrection);
774  ATH_MSG_DEBUG("smearing = " << m_doSmearing);
775  ATH_MSG_DEBUG("insitu scales = " << m_doScaleCorrection);
776  ATH_MSG_DEBUG("ep combination = " << m_use_ep_combination);
777  ATH_MSG_DEBUG("use MVA calibration = " << m_use_mva_calibration);
778  ATH_MSG_DEBUG(
779  "use temperature correction 2015 = " << m_use_temp_correction201215);
780  ATH_MSG_DEBUG("use uA2MeV correction 2015 1/2 week = "
781  << m_use_uA2MeV_2015_first2weeks_correction);
782 
783  setupSystematics();
784 
785  applySystematicVariation(CP::SystematicSet())
786  .ignore(); // this set the flags for the internal tool without
787  // systematics
788  CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
789  if (registry.registerSystematics(*this) != StatusCode::SUCCESS)
790  return StatusCode::FAILURE;
791 
792  return StatusCode::SUCCESS;
793 }

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

◆ intermodule_correction()

double CP::EgammaCalibrationAndSmearingTool::intermodule_correction ( double  Ecl,
double  phi,
double  eta 
) const

Definition at line 1957 of file EgammaCalibrationAndSmearingTool.cxx.

1958  {
1959 
1960  // Intermodule Widening Correction: E_corr = E / (a' - b' * ((1 / (1 +
1961  // exp((phi_mod - 2 * pi / 32) * c))) * (1 / (1 + exp((phi_mod - 2 * pi / 32)
1962  // * (d)))))) (phi_min, phi_max) : [a' = a / a, b' = b / a, c, d]
1963 
1964  double Ecl_corr = 0.;
1965  int DivInt = 0;
1966  double pi = M_PI;
1967 
1968  if (m_TESModel == egEnergyCorr::es2017_summer_improved ||
1969  m_TESModel == egEnergyCorr::es2017_summer_final ||
1970  m_TESModel == egEnergyCorr::es2017_R21_v0 ||
1971  m_TESModel == egEnergyCorr::es2017_R21_v1 ||
1972  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1973  m_TESModel == egEnergyCorr::es2018_R21_v0 ||
1974  m_TESModel == egEnergyCorr::es2018_R21_v1 ||
1975  m_TESModel == egEnergyCorr::es2022_R22_PRE ||
1976  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1977 
1978  double phi_mod = 0;
1979  if (phi < 0)
1980  phi_mod = fmod(phi, 2 * pi / 16.) + pi / 8.;
1981  else
1982  phi_mod = fmod(phi, 2 * pi / 16.);
1983 
1984  // The correction concerns only the barrel
1985  if (std::abs(eta) <= 1.37) {
1986 
1987  if (phi < (-7 * pi / 8) && phi > (-1 * pi))
1988  Ecl_corr =
1989  Ecl /
1990  (1 - 0.1086 *
1991  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 175.2759))) *
1992  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-189.3612))))));
1993  if (phi < (-6 * pi / 8) && phi > (-7 * pi / 8))
1994  Ecl_corr =
1995  Ecl /
1996  (1 - 0.0596 *
1997  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 170.8305))) *
1998  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-233.3782))))));
1999  if (phi < (-5 * pi / 8) && phi > (-6 * pi / 8))
2000  Ecl_corr =
2001  Ecl /
2002  (1 - 0.0596 *
2003  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 147.1451))) *
2004  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-139.3386))))));
2005  if (phi < (-4 * pi / 8) && phi > (-5 * pi / 8))
2006  Ecl_corr =
2007  Ecl /
2008  (1 - 0.0583 *
2009  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 168.4644))) *
2010  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-246.2897))))));
2011  if (phi < (-3 * pi / 8) && phi > (-4 * pi / 8))
2012  Ecl_corr =
2013  Ecl /
2014  (1 - 0.0530 *
2015  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 177.6703))) *
2016  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-198.3227))))));
2017  if (phi < (-2 * pi / 8) && phi > (-3 * pi / 8))
2018  Ecl_corr =
2019  Ecl /
2020  (1 - 0.0672 *
2021  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 145.0693))) *
2022  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-242.1771))))));
2023  if (phi < (-1 * pi / 8) && phi > (-2 * pi / 8))
2024  Ecl_corr =
2025  Ecl /
2026  (1 - 0.0871 *
2027  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 132.3303))) *
2028  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-166.1833))))));
2029  if (phi < (0 * pi / 8) && phi > (-1 * pi / 8))
2030  Ecl_corr =
2031  Ecl /
2032  (1 - 0.0948 *
2033  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 127.6780))) *
2034  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-150.0700))))));
2035  if (phi < (1 * pi / 8) && phi > (0 * pi / 8))
2036  Ecl_corr =
2037  Ecl /
2038  (1 - 0.1166 *
2039  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 172.0679))) *
2040  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-235.3293))))));
2041  if (phi < (2 * pi / 8) && phi > (1 * pi / 8))
2042  Ecl_corr =
2043  Ecl /
2044  (1 - 0.1172 *
2045  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 190.3524))) *
2046  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-198.9400))))));
2047  if (phi < (3 * pi / 8) && phi > (2 * pi / 8))
2048  Ecl_corr =
2049  Ecl /
2050  (1 - 0.1292 *
2051  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 158.0540))) *
2052  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-165.3893))))));
2053  if (phi < (4 * pi / 8) && phi > (3 * pi / 8))
2054  Ecl_corr =
2055  Ecl /
2056  (1 - 0.1557 *
2057  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 162.2793))) *
2058  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-133.5131))))));
2059  if (phi < (5 * pi / 8) && phi > (4 * pi / 8))
2060  Ecl_corr =
2061  Ecl /
2062  (1 - 0.1659 *
2063  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 180.5270))) *
2064  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-168.5074))))));
2065  if (phi < (6 * pi / 8) && phi > (5 * pi / 8))
2066  Ecl_corr =
2067  Ecl /
2068  (1 - 0.1123 *
2069  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 128.2277))) *
2070  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-154.4455))))));
2071  if (phi < (7 * pi / 8) && phi > (6 * pi / 8))
2072  Ecl_corr =
2073  Ecl /
2074  (1 - 0.1394 *
2075  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 192.1216))) *
2076  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-198.0727))))));
2077  if (phi < (8 * pi / 8) && phi > (7 * pi / 8))
2078  Ecl_corr =
2079  Ecl /
2080  (1 - 0.1001 *
2081  ((1 / (1 + exp((phi_mod - 2 * pi / 32.) * 199.1735))) *
2082  (1 / (1 + exp((phi_mod - 2 * pi / 32.) * (-176.4056))))));
2083  }
2084 
2085  // No correction for the EC
2086  else {
2087  Ecl_corr = Ecl;
2088  }
2089 
2090  }
2091 
2092  else {
2093 
2094  // Definitions of module folding into four quarters (top, left, bottom and
2095  // right)
2096 
2097  DivInt = (int)(phi / ((2 * pi) / 16.));
2098  double phi_mod = phi - DivInt * (2 * pi / 16.);
2099 
2100  // Centring on the intermodule --> phi_mod will now be in [0,0.4]
2101  if (phi_mod < 0)
2102  phi_mod += pi / 8.;
2103 
2104  // The correction concerns only the barrel
2105  if (std::abs(eta) <= 1.4) {
2106 
2107  // Top quarter
2108  if (phi < (3 * pi) / 4. && phi >= pi / 4.) {
2109  Ecl_corr =
2110  Ecl / (1 - 0.131 * ((1 / (1 + exp((phi_mod - 0.2) * 199.08))) *
2111  (1 / (1 + exp((phi_mod - 0.2) * (-130.36))))));
2112  }
2113 
2114  // Right quarter
2115  if (phi < pi / 4. && phi >= -pi / 4.) {
2116  Ecl_corr =
2117  Ecl / (1 - 0.0879 * ((1 / (1 + exp((phi_mod - 0.2) * 221.01))) *
2118  (1 / (1 + exp((phi_mod - 0.2) * (-149.51))))));
2119  }
2120  // Bottom quarter
2121  if (phi < -pi / 4. && phi >= (-3 * pi) / 4.) {
2122  Ecl_corr =
2123  Ecl / (1 - 0.0605 * ((1 / (1 + exp((phi_mod - 0.2) * 281.37))) *
2124  (1 / (1 + exp((phi_mod - 0.2) * (-170.29))))));
2125  }
2126  // Left quarter
2127  if ((phi < (-3 * pi) / 4.) || (phi >= (3 * pi) / 4.)) {
2128  Ecl_corr =
2129  Ecl / (1 - 0.102 * ((1 / (1 + exp((phi_mod - 0.2) * 235.37))) *
2130  (1 / (1 + exp((phi_mod - 0.2) * (-219.04))))));
2131  }
2132  }
2133 
2134  // No correction for the EC
2135  else {
2136  Ecl_corr = Ecl;
2137  }
2138  }
2139 
2140  return Ecl_corr;
2141 }

◆ isAffectedBySystematic()

bool CP::EgammaCalibrationAndSmearingTool::isAffectedBySystematic ( const CP::SystematicVariation &  systematic) const
overrideprivatevirtual

Declare the interface that this class provides.

returns: whether this tool is affected by the given systematics

Implements CP::ISystematicsTool.

Definition at line 1158 of file EgammaCalibrationAndSmearingTool.cxx.

1159  {
1160  CP::SystematicSet sys = affectingSystematics();
1161  return sys.find(systematic) != sys.end();
1162 }

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

◆ oldtool_resolution_flag_this_event()

egEnergyCorr::Resolution::Variation CP::EgammaCalibrationAndSmearingTool::oldtool_resolution_flag_this_event ( const xAOD::Egamma &  p,
const xAOD::EventInfo &  event_info 
) const
inlineprivate

Definition at line 1133 of file EgammaCalibrationAndSmearingTool.cxx.

1134  {
1135  return event_info.eventType(xAOD::EventInfo::IS_SIMULATION)
1136  ? m_currentResolutionVariation_MC
1137  : m_currentResolutionVariation_data;
1138 }

◆ oldtool_scale_flag_this_event()

egEnergyCorr::Scale::Variation CP::EgammaCalibrationAndSmearingTool::oldtool_scale_flag_this_event ( const xAOD::Egamma &  p,
const xAOD::EventInfo &  event_info 
) const
inlineprivate

Definition at line 1122 of file EgammaCalibrationAndSmearingTool.cxx.

1123  {
1124  if (!event_info.eventType(xAOD::EventInfo::IS_SIMULATION))
1125  return m_currentScaleVariation_data;
1126  if (m_currentScalePredicate(p))
1127  return m_currentScaleVariation_MC;
1128  else
1129  return egEnergyCorr::Scale::None;
1130 }

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

◆ recommendedSystematics()

CP::SystematicSet CP::EgammaCalibrationAndSmearingTool::recommendedSystematics ( ) const
overrideprivatevirtual

the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 1903 of file EgammaCalibrationAndSmearingTool.cxx.

1904  {
1905  return affectingSystematics();
1906 }

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

◆ resolution()

double CP::EgammaCalibrationAndSmearingTool::resolution ( double  energy,
double  cl_eta,
double  cl_etaCalo,
PATCore::ParticleType::Type  ptype = PATCore::ParticleType::Electron,
bool  withCT = false 
) const
overrideprivatevirtual

Implements CP::IEgammaCalibrationAndSmearingTool.

Definition at line 826 of file EgammaCalibrationAndSmearingTool.cxx.

828  {
829  return m_rootTool->resolution(energy, cl_eta, cl_etaCalo, ptype, withCT,
830  false);
831 }

◆ setRandomSeedFunction()

virtual void CP::EgammaCalibrationAndSmearingTool::setRandomSeedFunction ( const IdFunction &&  function)
inlineprivatevirtual

Definition at line 144 of file EgammaCalibrationAndSmearingTool.h.

144  {
145  m_set_seed_function = function;
146  }

◆ setupSystematics()

void CP::EgammaCalibrationAndSmearingTool::setupSystematics ( )
private

Definition at line 1177 of file EgammaCalibrationAndSmearingTool.cxx.

1177  {
1178  const EgammaPredicate always = [](const xAOD::Egamma&) { return true; };
1179 
1180  // Try to simplify a bit for the ones that are fully correlate in eta,
1181  // whatever the model and that are not included in the macros including
1182  // - ADC non linearity
1183  // - L2Gain
1184  // - Leakage
1185  // - Conversion related
1186  // - TopoCluster threshold
1187  // - AF2
1188  // - PS_BARREL_B12
1189  // - S12EXTRALASTETABINRUN2
1190  // - ZEESTAT
1191  // - Run3 pre OFC + EXTRA
1192  if (m_decorrelation_model_scale == ScaleDecorrelation::FULL_ETA_CORRELATED ||
1193  m_decorrelation_model_scale == ScaleDecorrelation::FULL) {
1194  // Electron leakage, ADCLin, convReco only in final run2 recommendations
1195  if (m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1196  // systematic related to ADC non linearity correction. Before 2022, there
1197  // was not correction, nor related systematic
1198  if (m_doADCLinearityCorrection) {
1199  m_syst_description[CP::SystematicVariation("EG_SCALE_ADCLIN", +1)] =
1200  SysInfo{always, egEnergyCorr::Scale::ADCLinUp};
1201  m_syst_description[CP::SystematicVariation("EG_SCALE_ADCLIN", -1)] =
1202  SysInfo{always, egEnergyCorr::Scale::ADCLinDown};
1203  }
1204  // Gain splitted uncertainty
1205  m_syst_description[CP::SystematicVariation("EG_SCALE_L2MEDIUMGAIN", +1)] =
1206  SysInfo{always, egEnergyCorr::Scale::L2MediumGainUp};
1207  m_syst_description[CP::SystematicVariation("EG_SCALE_L2MEDIUMGAIN", -1)] =
1208  SysInfo{always, egEnergyCorr::Scale::L2MediumGainDown};
1209  m_syst_description[CP::SystematicVariation("EG_SCALE_L2LOWGAIN", +1)] =
1210  SysInfo{always, egEnergyCorr::Scale::L2LowGainUp};
1211  m_syst_description[CP::SystematicVariation("EG_SCALE_L2LOWGAIN", -1)] =
1212  SysInfo{always, egEnergyCorr::Scale::L2LowGainDown};
1213 
1214  // Electron leakage
1215  m_syst_description[CP::SystematicVariation("EG_SCALE_LEAKAGEELEC", +1)] =
1216  SysInfo{always, egEnergyCorr::Scale::LeakageElecUp};
1217  m_syst_description[CP::SystematicVariation("EG_SCALE_LEAKAGEELEC", -1)] =
1218  SysInfo{always, egEnergyCorr::Scale::LeakageElecDown};
1219 
1220  // Conversion related
1221  m_syst_description[CP::SystematicVariation("PH_SCALE_CONVRECO", +1)] =
1222  SysInfo{always, egEnergyCorr::Scale::ConvRecoUp};
1223  m_syst_description[CP::SystematicVariation("PH_SCALE_CONVRECO", -1)] =
1224  SysInfo{always, egEnergyCorr::Scale::ConvRecoDown};
1225  }
1226  // The equivalent of convReco (convefficiency and convfakerate) for other
1227  // models
1228  else {
1229  m_syst_description[CP::SystematicVariation("PH_SCALE_CONVEFFICIENCY",
1230  +1)] =
1231  SysInfo{always, egEnergyCorr::Scale::ConvEfficiencyUp};
1232  m_syst_description[CP::SystematicVariation("PH_SCALE_CONVEFFICIENCY",
1233  -1)] =
1234  SysInfo{always, egEnergyCorr::Scale::ConvEfficiencyDown};
1235  m_syst_description[CP::SystematicVariation("PH_SCALE_CONVFAKERATE", +1)] =
1236  SysInfo{always, egEnergyCorr::Scale::ConvFakeRateUp};
1237  m_syst_description[CP::SystematicVariation("PH_SCALE_CONVFAKERATE", -1)] =
1238  SysInfo{always, egEnergyCorr::Scale::ConvFakeRateDown};
1239  }
1240 
1241  // additional systematics for R22 OFC and MC21 pre and bulk
1242  if (m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1243  m_syst_description[CP::SystematicVariation("EG_SCALE_OFC", +1)] =
1244  SysInfo{always, egEnergyCorr::Scale::OFCUp};
1245  m_syst_description[CP::SystematicVariation("EG_SCALE_OFC", -1)] =
1246  SysInfo{always, egEnergyCorr::Scale::OFCDown};
1247 
1248  m_syst_description[CP::SystematicVariation("EG_SCALE_EXTRARUN3PRE", +1)] =
1249  SysInfo{always, egEnergyCorr::Scale::EXTRARUN3PREUp};
1250  m_syst_description[CP::SystematicVariation("EG_SCALE_EXTRARUN3PRE", -1)] =
1251  SysInfo{always, egEnergyCorr::Scale::EXTRARUN3PREDown};
1252  }
1253 
1254  if (m_TESModel == egEnergyCorr::es2017_R21_v0 or
1255  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1256  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1257  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1258  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1259  m_TESModel == egEnergyCorr::es2022_R22_PRE or
1260  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1261 
1262  // topo clustr threshold systematics aded to release 21 recommendations
1263  m_syst_description[CP::SystematicVariation("EG_SCALE_TOPOCLUSTER_THRES",
1264  +1)] =
1265  SysInfo{always, egEnergyCorr::Scale::topoClusterThresUp};
1266  m_syst_description[CP::SystematicVariation("EG_SCALE_TOPOCLUSTER_THRES",
1267  -1)] =
1268  SysInfo{always, egEnergyCorr::Scale::topoClusterThresDown};
1269 
1270  // and extra AF2 systematics for release 21 recommendations - Moriond 2018
1271  // - pending proper AF2 to FullSim correction with release 21
1272  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2", +1)] =
1273  SysInfo{always, egEnergyCorr::Scale::af2Up};
1274  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2", -1)] =
1275  SysInfo{always, egEnergyCorr::Scale::af2Down};
1276  }
1277 
1278  // PS correlated barrel uncertainty
1279  if (m_TESModel == egEnergyCorr::es2017_summer_final or
1280  m_TESModel == egEnergyCorr::es2017_R21_v0 or
1281  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1282  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1283  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1284  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1285  m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1286  m_syst_description[CP::SystematicVariation("EG_SCALE_PS_BARREL_B12",
1287  +1)] =
1288  SysInfo{always, egEnergyCorr::Scale::PSb12Up};
1289  m_syst_description[CP::SystematicVariation("EG_SCALE_PS_BARREL_B12",
1290  -1)] =
1291  SysInfo{always, egEnergyCorr::Scale::PSb12Down};
1292  }
1293 
1294  // additional systematic for S12 last eta bin run2
1295  if (m_TESModel == egEnergyCorr::es2017 or
1296  m_TESModel == egEnergyCorr::es2017_summer or
1297  m_TESModel == egEnergyCorr::es2017_summer_improved or
1298  m_TESModel == egEnergyCorr::es2015_5TeV) {
1299  m_syst_description[CP::SystematicVariation(
1300  "EG_SCALE_S12EXTRALASTETABINRUN2", +1)] =
1301  SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up};
1302  m_syst_description[CP::SystematicVariation(
1303  "EG_SCALE_S12EXTRALASTETABINRUN2", -1)] =
1304  SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down};
1305  }
1306 
1307  // Zee stat, if for FULL we do not ask for m_use_full_statistical_error
1308  if (m_decorrelation_model_scale ==
1309  ScaleDecorrelation::FULL_ETA_CORRELATED or
1310  !m_use_full_statistical_error) {
1311  // return 1 variation only, fully correlated in eta, equal to the correct
1312  // value but scaled by sqrt(number of bins) the scaling is done by the old
1313  // tool
1314  m_syst_description[CP::SystematicVariation("EG_SCALE_ZEESTAT", +1)] =
1315  SysInfo{always, egEnergyCorr::Scale::ZeeStatUp};
1316  m_syst_description[CP::SystematicVariation("EG_SCALE_ZEESTAT", -1)] =
1317  SysInfo{always, egEnergyCorr::Scale::ZeeStatDown};
1318  }
1319  }
1320  if (m_decorrelation_model_scale == ScaleDecorrelation::ONENP) {
1321  // TODO: independet implementation of ALL UP looping on all the variations
1322  m_syst_description[CP::SystematicVariation("EG_SCALE_ALL", +1)] =
1323  SysInfo{always, egEnergyCorr::Scale::AllUp};
1324  m_syst_description[CP::SystematicVariation("EG_SCALE_ALL", -1)] =
1325  SysInfo{always, egEnergyCorr::Scale::AllDown};
1326  // extra AF2 systematics in addition to the 1NP
1327  if (m_TESModel == egEnergyCorr::es2017_R21_v0 ||
1328  m_TESModel == egEnergyCorr::es2017_R21_v1 ||
1329  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1330  m_TESModel == egEnergyCorr::es2018_R21_v0 ||
1331  m_TESModel == egEnergyCorr::es2018_R21_v1 ||
1332  m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1333  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2", +1)] =
1334  SysInfo{always, egEnergyCorr::Scale::af2Up};
1335  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2", -1)] =
1336  SysInfo{always, egEnergyCorr::Scale::af2Down};
1337  }
1338  } else if (m_decorrelation_model_scale ==
1339  ScaleDecorrelation::FULL_ETA_CORRELATED) {
1340 // all the physical effects separately, considered as fully correlated in eta
1341 
1342 // common systematics for all the esmodels
1343 #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
1344  m_syst_description[CP::SystematicVariation(#name, +1)] = \
1345  SysInfo{always, flagup}; \
1346  m_syst_description[CP::SystematicVariation(#name, -1)] = \
1347  SysInfo{always, flagdown};
1348 #include "ElectronPhotonFourMomentumCorrection/systematics_S12_2022.def"
1349 #undef SYSMACRO
1350 
1351  if (m_TESModel != egEnergyCorr::es2023_R22_Run2_v0) {
1352  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB", +1)] =
1353  SysInfo{always, egEnergyCorr::Scale::LArCalibUp};
1354  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB", -1)] =
1355  SysInfo{always, egEnergyCorr::Scale::LArCalibDown};
1356  m_syst_description[CP::SystematicVariation("EG_SCALE_L2GAIN", +1)] =
1357  SysInfo{always, egEnergyCorr::Scale::L2GainUp};
1358  m_syst_description[CP::SystematicVariation("EG_SCALE_L2GAIN", -1)] =
1359  SysInfo{always, egEnergyCorr::Scale::L2GainDown};
1360  }
1361 
1362  // additional systematics for S12 run2
1363  if (m_TESModel == egEnergyCorr::es2015PRE_res_improved or
1364  m_TESModel == egEnergyCorr::es2015PRE or
1365  m_TESModel == egEnergyCorr::es2015cPRE or
1366  m_TESModel == egEnergyCorr::es2015c_summer or
1367  m_TESModel == egEnergyCorr::es2016PRE or
1368  m_TESModel == egEnergyCorr::es2017 or
1369  m_TESModel == egEnergyCorr::es2017_summer or
1370  m_TESModel == egEnergyCorr::es2017_summer_improved or
1371  m_TESModel == egEnergyCorr::es2015_5TeV) {
1372  m_syst_description[CP::SystematicVariation(
1373  "EG_SCALE_LARCALIB_EXTRA2015PRE", +1)] =
1374  SysInfo{always, egEnergyCorr::Scale::LArCalibExtra2015PreUp};
1375  m_syst_description[CP::SystematicVariation(
1376  "EG_SCALE_LARCALIB_EXTRA2015PRE", -1)] =
1377  SysInfo{always, egEnergyCorr::Scale::LArCalibExtra2015PreDown};
1378  }
1379 
1380  // additional systematics for temperature run1->run2
1381  if (m_TESModel == egEnergyCorr::es2015PRE_res_improved or
1382  m_TESModel == egEnergyCorr::es2015PRE or
1383  m_TESModel == egEnergyCorr::es2015cPRE or
1384  m_TESModel == egEnergyCorr::es2015c_summer or
1385  m_TESModel == egEnergyCorr::es2016PRE) {
1386  m_syst_description[CP::SystematicVariation(
1387  "EG_SCALE_LARTEMPERATURE_EXTRA2015PRE", +1)] =
1388  SysInfo{always, egEnergyCorr::Scale::LArTemperature2015PreUp};
1389  m_syst_description[CP::SystematicVariation(
1390  "EG_SCALE_LARTEMPERATURE_EXTRA2015PRE", -1)] =
1391  SysInfo{always, egEnergyCorr::Scale::LArTemperature2015PreDown};
1392  }
1393 
1394  // additional systematic for temperature 2015->2016
1395  if (m_TESModel == egEnergyCorr::es2016PRE) {
1396  m_syst_description[CP::SystematicVariation(
1397  "EG_SCALE_LARTEMPERATURE_EXTRA2016PRE", +1)] =
1398  SysInfo{always, egEnergyCorr::Scale::LArTemperature2016PreUp};
1399  m_syst_description[CP::SystematicVariation(
1400  "EG_SCALE_LARTEMPERATURE_EXTRA2016PRE", -1)] =
1401  SysInfo{always, egEnergyCorr::Scale::LArTemperature2016PreDown};
1402  }
1403 
1404  // additional systematic for PP0 region
1405  if (m_TESModel == egEnergyCorr::es2017 or
1406  m_TESModel == egEnergyCorr::es2017_summer or
1407  m_TESModel == egEnergyCorr::es2017_summer_improved or
1408  m_TESModel == egEnergyCorr::es2017_summer_final or
1409  m_TESModel == egEnergyCorr::es2015_5TeV or
1410  m_TESModel == egEnergyCorr::es2017_R21_v0 or
1411  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1412  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1413  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1414  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1415  m_TESModel == egEnergyCorr::es2022_R22_PRE or
1416  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1417  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0", +1)] =
1418  SysInfo{always, egEnergyCorr::Scale::MatPP0Up};
1419  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0", -1)] =
1420  SysInfo{always, egEnergyCorr::Scale::MatPP0Down};
1421  }
1422 
1423  // systematic related to wtots1
1424  if (m_TESModel == egEnergyCorr::es2017 or
1425  m_TESModel == egEnergyCorr::es2017_summer or
1426  m_TESModel == egEnergyCorr::es2017_summer_improved or
1427  m_TESModel == egEnergyCorr::es2017_summer_final or
1428  m_TESModel == egEnergyCorr::es2015_5TeV or
1429  m_TESModel == egEnergyCorr::es2017_R21_v0 or
1430  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1431  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1432  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1433  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1434  m_TESModel == egEnergyCorr::es2022_R22_PRE or
1435  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1436  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1", +1)] =
1437  SysInfo{always, egEnergyCorr::Scale::Wtots1Up};
1438  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1", -1)] =
1439  SysInfo{always, egEnergyCorr::Scale::Wtots1Down};
1440  }
1441 
1442  // systematic for the scintillators
1443  if (m_TESModel == egEnergyCorr::es2015cPRE or
1444  m_TESModel == egEnergyCorr::es2015c_summer or
1445  m_TESModel == egEnergyCorr::es2016PRE or
1446  m_TESModel == egEnergyCorr::es2017 or
1447  m_TESModel == egEnergyCorr::es2017_summer or
1448  m_TESModel == egEnergyCorr::es2017_summer_improved or
1449  m_TESModel == egEnergyCorr::es2017_summer_final or
1450  m_TESModel == egEnergyCorr::es2015_5TeV or
1451  m_TESModel == egEnergyCorr::es2017_R21_v0 or
1452  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1453  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1454  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1455  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1456  m_TESModel == egEnergyCorr::es2022_R22_PRE or
1457  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1458  // scintillator systematics
1459  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR",
1460  +1)] =
1461  SysInfo{always, egEnergyCorr::Scale::E4ScintillatorUp};
1462  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR",
1463  -1)] =
1464  SysInfo{always, egEnergyCorr::Scale::E4ScintillatorDown};
1465  }
1466 
1467  } else if (m_decorrelation_model_scale ==
1468  ScaleDecorrelation::ONENP_PLUS_UNCONR) {
1469 // qsum of all variations correlated 8/13 TeV + uncorrelated (additional
1470 // systematics for 2015PRE or 2016) all the physical effects separately,
1471 // considered as fully correlated in eta
1472 // TODO: fix for es2017
1473 #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
1474  m_syst_description[CP::SystematicVariation(#name, +1)] = \
1475  SysInfo{always, flagup}; \
1476  m_syst_description[CP::SystematicVariation(#name, -1)] = \
1477  SysInfo{always, flagdown};
1478 #include "ElectronPhotonFourMomentumCorrection/systematics_1NPCOR_PLUS_UNCOR.def"
1479 #undef SYSMACRO
1480 
1481  // additional systematic for S12 last eta bin run2 - not needed anymore for
1482  // last 20.7 model since it is part of bin per bin E1/E2 uncertainty in root
1483  // file
1484  if (m_TESModel == egEnergyCorr::es2017 or
1485  m_TESModel == egEnergyCorr::es2017_summer or
1486  m_TESModel == egEnergyCorr::es2017_summer_improved) {
1487  m_syst_description[CP::SystematicVariation(
1488  "EG_SCALE_S12EXTRALASTETABINRUN2", +1)] =
1489  SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up};
1490  m_syst_description[CP::SystematicVariation(
1491  "EG_SCALE_S12EXTRALASTETABINRUN2", -1)] =
1492  SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down};
1493  }
1494 
1495  } else if (m_decorrelation_model_scale == ScaleDecorrelation::FULL) {
1496  using pairvector = std::vector<std::pair<double, double>>;
1497  const pairvector decorrelation_bins_BE = {{0., 1.45}, {1.52, 2.5}};
1498  const std::vector<double> decorrelation_edges_TWELVE = {
1499  0., 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4};
1500  std::vector<double> decorrelation_edges_MODULE = {
1501  0., 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.37, 1.52, 1.8};
1502  const std::vector<double> decorrelation_edges_MATERIAL = {0.0, 1.1, 1.5,
1503  2.1, 2.5};
1504 
1505  std::vector<double> decorrelation_edges_S12;
1506  // for es2018_R21_v1 : 4 eta bins for muon E1/E2 uncertainty correlation
1507  if (m_TESModel == egEnergyCorr::es2018_R21_v1) {
1508  decorrelation_edges_S12.resize(5);
1509  decorrelation_edges_S12 = {0., 1.35, 1.5, 2.4, 2.5};
1510  } else if (m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1511  decorrelation_edges_S12.resize(8);
1512  decorrelation_edges_S12 = {0., 0.6, 1.0, 1.35, 1.5, 1.8, 2.4, 2.5};
1513  //
1514  // PS scale from muons, so "crack" is a bit different
1515  decorrelation_edges_MODULE[7] = 1.4;
1516  decorrelation_edges_MODULE[8] = 1.5;
1517  }
1518  // for previous run 2 muon calibration with 20.7, 5 eta bins for E1/E2
1519  // uncertainty correlation
1520  else {
1521  decorrelation_edges_S12.resize(6);
1522  decorrelation_edges_S12 = {0., 0.6, 1.4, 1.5, 2.4, 2.5};
1523  }
1524 
1525  if (m_TESModel != egEnergyCorr::es2017_summer_final and
1526  m_TESModel != egEnergyCorr::es2017_R21_v0 and
1527  m_TESModel != egEnergyCorr::es2017_R21_v1 and
1528  m_TESModel != egEnergyCorr::es2017_R21_ofc0_v1 and
1529  m_TESModel != egEnergyCorr::es2018_R21_v0 and
1530  m_TESModel != egEnergyCorr::es2018_R21_v1 and
1531  m_TESModel != egEnergyCorr::es2022_R22_PRE and
1532  m_TESModel != egEnergyCorr::es2023_R22_Run2_v0) {
1533 #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
1534  if (bool(fullcorrelated)) { \
1535  m_syst_description[CP::SystematicVariation(#name, +1)] = \
1536  SysInfo{always, flagup}; \
1537  m_syst_description[CP::SystematicVariation(#name, -1)] = \
1538  SysInfo{always, flagdown}; \
1539  } else { \
1540  int i = 0; \
1541  for (const auto& p : AbsEtaCaloPredicatesFactory(decorrelation)) { \
1542  m_syst_description[CP::SystematicVariation( \
1543  #name "__ETABIN" + std::to_string(i), +1)] = SysInfo{p, flagup}; \
1544  m_syst_description[CP::SystematicVariation( \
1545  #name "__ETABIN" + std::to_string(i), -1)] = SysInfo{p, flagdown}; \
1546  i += 1; \
1547  } \
1548  }
1549 #include "ElectronPhotonFourMomentumCorrection/systematics.def"
1550 #undef SYSMACRO
1551  } else if (m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1552 #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
1553  if (bool(fullcorrelated)) { \
1554  m_syst_description[CP::SystematicVariation(#name, +1)] = \
1555  SysInfo{always, flagup}; \
1556  m_syst_description[CP::SystematicVariation(#name, -1)] = \
1557  SysInfo{always, flagdown}; \
1558  } else { \
1559  int i = 0; \
1560  for (const auto& p : AbsEtaCaloPredicatesFactory(decorrelation)) { \
1561  m_syst_description[CP::SystematicVariation( \
1562  #name "__ETABIN" + std::to_string(i), +1)] = SysInfo{p, flagup}; \
1563  m_syst_description[CP::SystematicVariation( \
1564  #name "__ETABIN" + std::to_string(i), -1)] = SysInfo{p, flagdown}; \
1565  i += 1; \
1566  } \
1567  }
1568 #include "ElectronPhotonFourMomentumCorrection/systematics_S12_2022.def"
1569 #undef SYSMACRO
1570  } else {
1571 #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
1572  if (bool(fullcorrelated)) { \
1573  m_syst_description[CP::SystematicVariation(#name, +1)] = \
1574  SysInfo{always, flagup}; \
1575  m_syst_description[CP::SystematicVariation(#name, -1)] = \
1576  SysInfo{always, flagdown}; \
1577  } else { \
1578  int i = 0; \
1579  for (const auto& p : AbsEtaCaloPredicatesFactory(decorrelation)) { \
1580  m_syst_description[CP::SystematicVariation( \
1581  #name "__ETABIN" + std::to_string(i), +1)] = SysInfo{p, flagup}; \
1582  m_syst_description[CP::SystematicVariation( \
1583  #name "__ETABIN" + std::to_string(i), -1)] = SysInfo{p, flagdown}; \
1584  i += 1; \
1585  } \
1586  }
1587 #include "ElectronPhotonFourMomentumCorrection/systematics_S12.def"
1588 #undef SYSMACRO
1589  } // else
1590 
1591  if (m_use_full_statistical_error) {
1592  // statistical error, decorrelate in *all* the bins
1593  int i = 0;
1594  const TAxis& axis_statistical_error(m_rootTool->get_ZeeStat_eta_axis());
1595  for (int ibin = 1; ibin <= axis_statistical_error.GetNbins(); ++ibin) {
1596  auto p = EtaCaloPredicateFactory(
1597  axis_statistical_error.GetBinLowEdge(ibin),
1598  axis_statistical_error.GetBinLowEdge(ibin + 1));
1599  m_syst_description[CP::SystematicVariation(
1600  "EG_SCALE_ZEESTAT__ETABIN" + std::to_string(i), +1)] =
1601  SysInfo{p, egEnergyCorr::Scale::ZeeStatUp};
1602  m_syst_description[CP::SystematicVariation(
1603  "EG_SCALE_ZEESTAT__ETABIN" + std::to_string(i), -1)] =
1604  SysInfo{p, egEnergyCorr::Scale::ZeeStatDown};
1605  ++i;
1606  }
1607  }
1608 
1609  // additional systematics for S12 run2
1610  if (m_TESModel == egEnergyCorr::es2015PRE_res_improved or
1611  m_TESModel == egEnergyCorr::es2015PRE or
1612  m_TESModel == egEnergyCorr::es2015cPRE or
1613  m_TESModel == egEnergyCorr::es2015c_summer or
1614  m_TESModel == egEnergyCorr::es2016PRE or
1615  m_TESModel == egEnergyCorr::es2017 or
1616  m_TESModel == egEnergyCorr::es2017_summer or
1617  m_TESModel == egEnergyCorr::es2017_summer_improved or
1618  m_TESModel == egEnergyCorr::es2015_5TeV) {
1619  m_syst_description[CP::SystematicVariation(
1620  "EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN0", +1)] =
1621  SysInfo{AbsEtaCaloPredicateFactory({0, 1.45}),
1622  egEnergyCorr::Scale::LArCalibExtra2015PreUp};
1623  m_syst_description[CP::SystematicVariation(
1624  "EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN0", -1)] =
1625  SysInfo{AbsEtaCaloPredicateFactory({0, 1.45}),
1626  egEnergyCorr::Scale::LArCalibExtra2015PreDown};
1627  m_syst_description[CP::SystematicVariation(
1628  "EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN1", +1)] =
1629  SysInfo{AbsEtaCaloPredicateFactory({1.45, 2.47}),
1630  egEnergyCorr::Scale::LArCalibExtra2015PreUp};
1631  m_syst_description[CP::SystematicVariation(
1632  "EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN1", -1)] =
1633  SysInfo{AbsEtaCaloPredicateFactory({1.45, 2.47}),
1634  egEnergyCorr::Scale::LArCalibExtra2015PreDown};
1635  m_syst_description[CP::SystematicVariation(
1636  "EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN2", +1)] =
1637  SysInfo{AbsEtaCaloPredicateFactory({2.47, 3.2}),
1638  egEnergyCorr::Scale::LArCalibExtra2015PreUp};
1639  m_syst_description[CP::SystematicVariation(
1640  "EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN2", -1)] =
1641  SysInfo{AbsEtaCaloPredicateFactory({2.47, 3.2}),
1642  egEnergyCorr::Scale::LArCalibExtra2015PreDown};
1643  }
1644 
1645  // additional systematics for temperature run1->run2
1646  if (m_TESModel == egEnergyCorr::es2015PRE_res_improved or
1647  m_TESModel == egEnergyCorr::es2015PRE or
1648  m_TESModel == egEnergyCorr::es2015cPRE or
1649  m_TESModel == egEnergyCorr::es2015c_summer or
1650  m_TESModel == egEnergyCorr::es2016PRE) {
1651  m_syst_description[CP::SystematicVariation(
1652  "EG_SCALE_LARTEMPERATURE_EXTRA2015PRE__ETABIN0", +1)] =
1653  SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[0]),
1654  egEnergyCorr::Scale::LArTemperature2015PreUp};
1655  m_syst_description[CP::SystematicVariation(
1656  "EG_SCALE_LARTEMPERATURE_EXTRA2015PRE__ETABIN0", -1)] =
1657  SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[0]),
1658  egEnergyCorr::Scale::LArTemperature2015PreDown};
1659  m_syst_description[CP::SystematicVariation(
1660  "EG_SCALE_LARTEMPERATURE_EXTRA2015PRE__ETABIN1", +1)] =
1661  SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[1]),
1662  egEnergyCorr::Scale::LArTemperature2015PreUp};
1663  m_syst_description[CP::SystematicVariation(
1664  "EG_SCALE_LARTEMPERATURE_EXTRA2015PRE__ETABIN1", -1)] =
1665  SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[1]),
1666  egEnergyCorr::Scale::LArTemperature2015PreDown};
1667  }
1668 
1669  // additional systematic for temperature 2015->2016
1670  if (m_TESModel == egEnergyCorr::es2016PRE) {
1671  m_syst_description[CP::SystematicVariation(
1672  "EG_SCALE_LARTEMPERATURE_EXTRA2016PRE__ETABIN0", +1)] =
1673  SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[0]),
1674  egEnergyCorr::Scale::LArTemperature2016PreUp};
1675  m_syst_description[CP::SystematicVariation(
1676  "EG_SCALE_LARTEMPERATURE_EXTRA2016PRE__ETABIN1", +1)] =
1677  SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[1]),
1678  egEnergyCorr::Scale::LArTemperature2016PreUp};
1679  m_syst_description[CP::SystematicVariation(
1680  "EG_SCALE_LARTEMPERATURE_EXTRA2016PRE__ETABIN0", -1)] =
1681  SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[0]),
1682  egEnergyCorr::Scale::LArTemperature2016PreDown};
1683  m_syst_description[CP::SystematicVariation(
1684  "EG_SCALE_LARTEMPERATURE_EXTRA2016PRE__ETABIN1", -1)] =
1685  SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[1]),
1686  egEnergyCorr::Scale::LArTemperature2016PreDown};
1687  }
1688 
1689  // additional systematic for PP0 region
1690  if (m_TESModel == egEnergyCorr::es2017 or
1691  m_TESModel == egEnergyCorr::es2017_summer or
1692  m_TESModel == egEnergyCorr::es2017_summer_improved or
1693  m_TESModel == egEnergyCorr::es2017_summer_final or
1694  m_TESModel == egEnergyCorr::es2015_5TeV or
1695  m_TESModel == egEnergyCorr::es2017_R21_v0 or
1696  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1697  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1698  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1699  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1700  m_TESModel == egEnergyCorr::es2022_R22_PRE or
1701  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1702  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0__ETABIN0",
1703  +1)] = SysInfo{
1704  AbsEtaCaloPredicateFactory(0, 1.5), egEnergyCorr::Scale::MatPP0Up};
1705  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0__ETABIN1",
1706  +1)] = SysInfo{
1707  AbsEtaCaloPredicateFactory(1.5, 2.5), egEnergyCorr::Scale::MatPP0Up};
1708  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0__ETABIN0",
1709  -1)] = SysInfo{
1710  AbsEtaCaloPredicateFactory(0, 1.5), egEnergyCorr::Scale::MatPP0Down};
1711  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0__ETABIN1",
1712  -1)] =
1713  SysInfo{AbsEtaCaloPredicateFactory(1.5, 2.5),
1714  egEnergyCorr::Scale::MatPP0Down};
1715  }
1716 
1717  // systematic related to wtots1
1718  if (m_TESModel == egEnergyCorr::es2017 or
1719  m_TESModel == egEnergyCorr::es2017_summer or
1720  m_TESModel == egEnergyCorr::es2017_summer_improved or
1721  m_TESModel == egEnergyCorr::es2017_summer_final or
1722  m_TESModel == egEnergyCorr::es2015_5TeV or
1723  m_TESModel == egEnergyCorr::es2017_R21_v0 or
1724  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1725  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1726  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1727  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1728  m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1729  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1", +1)] =
1730  SysInfo{always, egEnergyCorr::Scale::Wtots1Up};
1731  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1", -1)] =
1732  SysInfo{always, egEnergyCorr::Scale::Wtots1Down};
1733  }
1734 
1735  // systematic related to wtots1, decorrelate eta bin [1.52,1.82] from rest
1736  if (m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1737  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1__ETABIN0",
1738  +1)] =
1739  SysInfo{DoubleOrAbsEtaCaloPredicate(0, 1.52, 1.82, 2.47),
1740  egEnergyCorr::Scale::Wtots1Up};
1741  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1__ETABIN0",
1742  -1)] =
1743  SysInfo{DoubleOrAbsEtaCaloPredicate(0, 1.52, 1.82, 2.47),
1744  egEnergyCorr::Scale::Wtots1Down};
1745  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1__ETABIN1",
1746  +1)] =
1747  SysInfo{AbsEtaCaloPredicateFactory({1.52, 1.82}),
1748  egEnergyCorr::Scale::Wtots1Up};
1749  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1__ETABIN1",
1750  -1)] =
1751  SysInfo{AbsEtaCaloPredicateFactory({1.52, 1.82}),
1752  egEnergyCorr::Scale::Wtots1Down};
1753  }
1754 
1755  // systematic for the scintillators
1756  if (m_TESModel == egEnergyCorr::es2015cPRE or
1757  m_TESModel == egEnergyCorr::es2015c_summer or
1758  m_TESModel == egEnergyCorr::es2016PRE or
1759  m_TESModel == egEnergyCorr::es2017 or
1760  m_TESModel == egEnergyCorr::es2017_summer or
1761  m_TESModel == egEnergyCorr::es2017_summer_improved or
1762  m_TESModel == egEnergyCorr::es2017_summer_final or
1763  m_TESModel == egEnergyCorr::es2015_5TeV or
1764  m_TESModel == egEnergyCorr::es2017_R21_v0 or
1765  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1766  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1767  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1768  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1769  m_TESModel == egEnergyCorr::es2022_R22_PRE or
1770  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1771  m_syst_description[CP::SystematicVariation(
1772  "EG_SCALE_E4SCINTILLATOR__ETABIN0", +1)] =
1773  SysInfo{AbsEtaCaloPredicateFactory(1.4, 1.46),
1774  egEnergyCorr::Scale::E4ScintillatorUp};
1775  m_syst_description[CP::SystematicVariation(
1776  "EG_SCALE_E4SCINTILLATOR__ETABIN1", +1)] =
1777  SysInfo{AbsEtaCaloPredicateFactory(1.46, 1.52),
1778  egEnergyCorr::Scale::E4ScintillatorUp};
1779  m_syst_description[CP::SystematicVariation(
1780  "EG_SCALE_E4SCINTILLATOR__ETABIN2", +1)] =
1781  SysInfo{AbsEtaCaloPredicateFactory(1.52, 1.6),
1782  egEnergyCorr::Scale::E4ScintillatorUp};
1783  m_syst_description[CP::SystematicVariation(
1784  "EG_SCALE_E4SCINTILLATOR__ETABIN0", -1)] =
1785  SysInfo{AbsEtaCaloPredicateFactory(1.4, 1.46),
1786  egEnergyCorr::Scale::E4ScintillatorDown};
1787  m_syst_description[CP::SystematicVariation(
1788  "EG_SCALE_E4SCINTILLATOR__ETABIN1", -1)] =
1789  SysInfo{AbsEtaCaloPredicateFactory(1.46, 1.52),
1790  egEnergyCorr::Scale::E4ScintillatorDown};
1791  m_syst_description[CP::SystematicVariation(
1792  "EG_SCALE_E4SCINTILLATOR__ETABIN2", -1)] =
1793  SysInfo{AbsEtaCaloPredicateFactory(1.52, 1.6),
1794  egEnergyCorr::Scale::E4ScintillatorDown};
1795  }
1796  } else {
1797  ATH_MSG_FATAL("scale decorrelation model invalid");
1798  }
1799 
1800  // resolution systematics
1801  if (m_decorrelation_model_resolution == ResolutionDecorrelation::ONENP) {
1802  m_syst_description_resolution[CP::SystematicVariation(
1803  "EG_RESOLUTION_ALL", +1)] = egEnergyCorr::Resolution::AllUp;
1804  m_syst_description_resolution[CP::SystematicVariation(
1805  "EG_RESOLUTION_ALL", -1)] = egEnergyCorr::Resolution::AllDown;
1806  } else if (m_decorrelation_model_resolution ==
1807  ResolutionDecorrelation::FULL) {
1808  m_syst_description_resolution[CP::SystematicVariation(
1809  "EG_RESOLUTION_ZSMEARING", +1)] = egEnergyCorr::Resolution::ZSmearingUp;
1810  m_syst_description_resolution[CP::SystematicVariation(
1811  "EG_RESOLUTION_ZSMEARING", -1)] =
1812  egEnergyCorr::Resolution::ZSmearingDown;
1813  m_syst_description_resolution[CP::SystematicVariation(
1814  "EG_RESOLUTION_SAMPLINGTERM", +1)] =
1815  egEnergyCorr::Resolution::SamplingTermUp;
1816  m_syst_description_resolution[CP::SystematicVariation(
1817  "EG_RESOLUTION_SAMPLINGTERM", -1)] =
1818  egEnergyCorr::Resolution::SamplingTermDown;
1819  m_syst_description_resolution[CP::SystematicVariation(
1820  "EG_RESOLUTION_MATERIALID", +1)] =
1821  egEnergyCorr::Resolution::MaterialIDUp;
1822  m_syst_description_resolution[CP::SystematicVariation(
1823  "EG_RESOLUTION_MATERIALID", -1)] =
1824  egEnergyCorr::Resolution::MaterialIDDown;
1825  m_syst_description_resolution[CP::SystematicVariation(
1826  "EG_RESOLUTION_MATERIALCALO", +1)] =
1827  egEnergyCorr::Resolution::MaterialCaloUp;
1828  m_syst_description_resolution[CP::SystematicVariation(
1829  "EG_RESOLUTION_MATERIALCALO", -1)] =
1830  egEnergyCorr::Resolution::MaterialCaloDown;
1831  m_syst_description_resolution[CP::SystematicVariation(
1832  "EG_RESOLUTION_MATERIALGAP", +1)] =
1833  egEnergyCorr::Resolution::MaterialGapUp;
1834  m_syst_description_resolution[CP::SystematicVariation(
1835  "EG_RESOLUTION_MATERIALGAP", -1)] =
1836  egEnergyCorr::Resolution::MaterialGapDown;
1837  m_syst_description_resolution[CP::SystematicVariation(
1838  "EG_RESOLUTION_MATERIALCRYO", +1)] =
1839  egEnergyCorr::Resolution::MaterialCryoUp;
1840  m_syst_description_resolution[CP::SystematicVariation(
1841  "EG_RESOLUTION_MATERIALCRYO", -1)] =
1842  egEnergyCorr::Resolution::MaterialCryoDown;
1843  m_syst_description_resolution[CP::SystematicVariation(
1844  "EG_RESOLUTION_PILEUP", +1)] = egEnergyCorr::Resolution::PileUpUp;
1845  m_syst_description_resolution[CP::SystematicVariation(
1846  "EG_RESOLUTION_PILEUP", -1)] = egEnergyCorr::Resolution::PileUpDown;
1847  if (m_TESModel == egEnergyCorr::es2017 or
1848  m_TESModel == egEnergyCorr::es2017_summer or
1849  m_TESModel == egEnergyCorr::es2017_summer_improved or
1850  m_TESModel == egEnergyCorr::es2017_summer_final or
1851  m_TESModel == egEnergyCorr::es2015_5TeV or
1852  m_TESModel == egEnergyCorr::es2017_R21_v0 or
1853  m_TESModel == egEnergyCorr::es2017_R21_v1 or
1854  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or
1855  m_TESModel == egEnergyCorr::es2018_R21_v0 or
1856  m_TESModel == egEnergyCorr::es2018_R21_v1 or
1857  m_TESModel == egEnergyCorr::es2022_R22_PRE or
1858  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1859  m_syst_description_resolution[CP::SystematicVariation(
1860  "EG_RESOLUTION_MATERIALIBL", +1)] =
1861  egEnergyCorr::Resolution::MaterialIBLUp;
1862  m_syst_description_resolution[CP::SystematicVariation(
1863  "EG_RESOLUTION_MATERIALIBL", -1)] =
1864  egEnergyCorr::Resolution::MaterialIBLDown;
1865  m_syst_description_resolution[CP::SystematicVariation(
1866  "EG_RESOLUTION_MATERIALPP0", +1)] =
1867  egEnergyCorr::Resolution::MaterialPP0Up;
1868  m_syst_description_resolution[CP::SystematicVariation(
1869  "EG_RESOLUTION_MATERIALPP0", -1)] =
1870  egEnergyCorr::Resolution::MaterialPP0Down;
1871  if (m_TESModel == egEnergyCorr::es2017_R21_v1 ||
1872  m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1873  m_TESModel == egEnergyCorr::es2018_R21_v0 ||
1874  m_TESModel == egEnergyCorr::es2018_R21_v1 ||
1875  m_TESModel == egEnergyCorr::es2022_R22_PRE ||
1876  m_TESModel == egEnergyCorr::es2023_R22_Run2_v0) {
1877  m_syst_description_resolution[CP::SystematicVariation(
1878  "EG_RESOLUTION_AF2", +1)] = egEnergyCorr::Resolution::af2Up;
1879  m_syst_description_resolution[CP::SystematicVariation(
1880  "EG_RESOLUTION_AF2", -1)] = egEnergyCorr::Resolution::af2Down;
1881  }
1882  if (m_TESModel == egEnergyCorr::es2022_R22_PRE) { // exta sys. for Run-3
1883  // pre-recommendations
1884  m_syst_description_resolution[CP::SystematicVariation(
1885  "EG_RESOLUTION_OFC", +1)] = egEnergyCorr::Resolution::OFCUp;
1886  m_syst_description_resolution[CP::SystematicVariation(
1887  "EG_RESOLUTION_OFC", -1)] = egEnergyCorr::Resolution::OFCDown;
1888  }
1889  }
1890  } else {
1891  ATH_MSG_FATAL("resolution decorrelation model invalid");
1892  }
1893 
1894  // ep combination systematics
1895  if (m_use_ep_combination) {
1896  m_syst_description[CP::SystematicVariation("EL_SCALE_MOMENTUM", +1)] =
1897  SysInfo{always, egEnergyCorr::Scale::MomentumUp};
1898  m_syst_description[CP::SystematicVariation("EL_SCALE_MOMENTUM", -1)] =
1899  SysInfo{always, egEnergyCorr::Scale::MomentumDown};
1900  }
1901 }

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

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

◆ xAOD2ptype()

PATCore::ParticleType::Type CP::EgammaCalibrationAndSmearingTool::xAOD2ptype ( const xAOD::Egamma &  particle) const
private

Definition at line 795 of file EgammaCalibrationAndSmearingTool.cxx.

796  {
797  auto ptype = PATCore::ParticleType::Electron;
798  // no ForwardElectron ptype: consider them as Electron
799  if (xAOD::EgammaHelpers::isElectron(&particle) ||
800  particle.author() == xAOD::EgammaParameters::AuthorFwdElectron) {
801  ptype = PATCore::ParticleType::Electron;
802  } else if (xAOD::EgammaHelpers::isPhoton(&particle)) {
803  if (xAOD::EgammaHelpers::isConvertedPhoton(&particle)) {
804  ptype = PATCore::ParticleType::ConvertedPhoton;
805  } else {
806  ptype = PATCore::ParticleType::UnconvertedPhoton;
807  }
808  } else {
809  ATH_MSG_ERROR("particle is not electron of photon");
810  throw std::runtime_error("particle is not electron or photon");
811  }
812  return ptype;
813 }

Member Data Documentation

◆ AUTO

const int CP::EgammaCalibrationAndSmearingTool::AUTO = 2
staticprivate

Definition at line 105 of file EgammaCalibrationAndSmearingTool.h.

◆ m_ADCLinearity_tool

std::shared_ptr<LinearityADC> CP::EgammaCalibrationAndSmearingTool::m_ADCLinearity_tool
private

Definition at line 311 of file EgammaCalibrationAndSmearingTool.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_caloDistPhiUnifCorr

std::unique_ptr<TH2> CP::EgammaCalibrationAndSmearingTool::m_caloDistPhiUnifCorr
private

Definition at line 196 of file EgammaCalibrationAndSmearingTool.h.

◆ m_currentResolutionVariation_data

egEnergyCorr::Resolution::Variation CP::EgammaCalibrationAndSmearingTool::m_currentResolutionVariation_data
private

Definition at line 333 of file EgammaCalibrationAndSmearingTool.h.

◆ m_currentResolutionVariation_MC

egEnergyCorr::Resolution::Variation CP::EgammaCalibrationAndSmearingTool::m_currentResolutionVariation_MC
private

Definition at line 332 of file EgammaCalibrationAndSmearingTool.h.

◆ m_currentScalePredicate

EgammaPredicate CP::EgammaCalibrationAndSmearingTool::m_currentScalePredicate
private

Definition at line 335 of file EgammaCalibrationAndSmearingTool.h.

◆ m_currentScaleVariation_data

egEnergyCorr::Scale::Variation CP::EgammaCalibrationAndSmearingTool::m_currentScaleVariation_data
private

Definition at line 331 of file EgammaCalibrationAndSmearingTool.h.

◆ m_currentScaleVariation_MC

egEnergyCorr::Scale::Variation CP::EgammaCalibrationAndSmearingTool::m_currentScaleVariation_MC
private

Definition at line 330 of file EgammaCalibrationAndSmearingTool.h.

◆ m_decorrelation_model_name

std::string CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_name
private

Definition at line 158 of file EgammaCalibrationAndSmearingTool.h.

◆ m_decorrelation_model_resolution

ResolutionDecorrelation CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_resolution
private
Initial value:
=
ResolutionDecorrelation::FULL

Definition at line 162 of file EgammaCalibrationAndSmearingTool.h.

◆ m_decorrelation_model_resolution_name

std::string CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_resolution_name
private

Definition at line 160 of file EgammaCalibrationAndSmearingTool.h.

◆ m_decorrelation_model_scale

ScaleDecorrelation CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_scale = ScaleDecorrelation::FULL
private

Definition at line 161 of file EgammaCalibrationAndSmearingTool.h.

◆ m_decorrelation_model_scale_name

std::string CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_scale_name
private

Definition at line 159 of file EgammaCalibrationAndSmearingTool.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_doADCLinearityCorrection

int CP::EgammaCalibrationAndSmearingTool::m_doADCLinearityCorrection
private

Definition at line 179 of file EgammaCalibrationAndSmearingTool.h.

◆ m_doLeakageCorrection

int CP::EgammaCalibrationAndSmearingTool::m_doLeakageCorrection
private

Definition at line 180 of file EgammaCalibrationAndSmearingTool.h.

◆ m_doScaleCorrection

int CP::EgammaCalibrationAndSmearingTool::m_doScaleCorrection
private

Definition at line 165 of file EgammaCalibrationAndSmearingTool.h.

◆ m_doSmearing

int CP::EgammaCalibrationAndSmearingTool::m_doSmearing
private

Definition at line 166 of file EgammaCalibrationAndSmearingTool.h.

◆ m_ESModel

std::string CP::EgammaCalibrationAndSmearingTool::m_ESModel
private

Definition at line 157 of file EgammaCalibrationAndSmearingTool.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_fixForMissingCells

Gaudi::Property<bool> CP::EgammaCalibrationAndSmearingTool::m_fixForMissingCells
private
Initial value:
{
this, "FixForMissingCells", true,
"AOD fix for cell recovery in core egamma cluster"}

Definition at line 198 of file EgammaCalibrationAndSmearingTool.h.

◆ m_gain_tool

egGain::GainTool* CP::EgammaCalibrationAndSmearingTool::m_gain_tool = nullptr
private

Definition at line 312 of file EgammaCalibrationAndSmearingTool.h.

◆ m_gain_tool_run2

std::unique_ptr<egGain::GainUncertainty> CP::EgammaCalibrationAndSmearingTool::m_gain_tool_run2
private

Definition at line 310 of file EgammaCalibrationAndSmearingTool.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_layer_recalibration_tool

egammaLayerRecalibTool* CP::EgammaCalibrationAndSmearingTool::m_layer_recalibration_tool = nullptr
private

Definition at line 313 of file EgammaCalibrationAndSmearingTool.h.

◆ m_layer_recalibration_tune

std::string CP::EgammaCalibrationAndSmearingTool::m_layer_recalibration_tune
private

Definition at line 314 of file EgammaCalibrationAndSmearingTool.h.

◆ m_MVACalibSvc

ServiceHandle<IegammaMVASvc> CP::EgammaCalibrationAndSmearingTool::m_MVACalibSvc
private
Initial value:
{this, "MVACalibSvc", "",
"calibration service"}

Definition at line 308 of file EgammaCalibrationAndSmearingTool.h.

◆ m_MVAfolder

std::string CP::EgammaCalibrationAndSmearingTool::m_MVAfolder
private

Definition at line 318 of file EgammaCalibrationAndSmearingTool.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_ResolutionType

std::string CP::EgammaCalibrationAndSmearingTool::m_ResolutionType
private

Definition at line 168 of file EgammaCalibrationAndSmearingTool.h.

◆ m_rootTool

std::unique_ptr<AtlasRoot::egammaEnergyCorrectionTool> CP::EgammaCalibrationAndSmearingTool::m_rootTool
private

Definition at line 317 of file EgammaCalibrationAndSmearingTool.h.

◆ m_Run2Run3runNumberTransition

const unsigned int CP::EgammaCalibrationAndSmearingTool::m_Run2Run3runNumberTransition = 400000
staticprivate

Definition at line 155 of file EgammaCalibrationAndSmearingTool.h.

◆ m_set_seed_function

IdFunction CP::EgammaCalibrationAndSmearingTool::m_set_seed_function
private

Definition at line 337 of file EgammaCalibrationAndSmearingTool.h.

◆ m_simulation

PATCore::ParticleDataType::DataType CP::EgammaCalibrationAndSmearingTool::m_simulation
private
Initial value:
=
PATCore::ParticleDataType::Full

Definition at line 172 of file EgammaCalibrationAndSmearingTool.h.

◆ m_syst_description

std::map<CP::SystematicVariation, SysInfo> CP::EgammaCalibrationAndSmearingTool::m_syst_description
private

Definition at line 325 of file EgammaCalibrationAndSmearingTool.h.

◆ m_syst_description_resolution

std::map<CP::SystematicVariation, egEnergyCorr::Resolution::Variation> CP::EgammaCalibrationAndSmearingTool::m_syst_description_resolution
private

Definition at line 327 of file EgammaCalibrationAndSmearingTool.h.

◆ m_TESModel

egEnergyCorr::ESModel CP::EgammaCalibrationAndSmearingTool::m_TESModel
private

Definition at line 164 of file EgammaCalibrationAndSmearingTool.h.

◆ m_TResolutionType

egEnergyCorr::Resolution::resolutionType CP::EgammaCalibrationAndSmearingTool::m_TResolutionType
private

Definition at line 169 of file EgammaCalibrationAndSmearingTool.h.

◆ m_use_AFII

int CP::EgammaCalibrationAndSmearingTool::m_use_AFII
private

Definition at line 171 of file EgammaCalibrationAndSmearingTool.h.

◆ m_use_ep_combination

bool CP::EgammaCalibrationAndSmearingTool::m_use_ep_combination
private

Definition at line 181 of file EgammaCalibrationAndSmearingTool.h.

◆ m_use_full_statistical_error

bool CP::EgammaCalibrationAndSmearingTool::m_use_full_statistical_error
private

Definition at line 183 of file EgammaCalibrationAndSmearingTool.h.

◆ m_use_mapping_correction

bool CP::EgammaCalibrationAndSmearingTool::m_use_mapping_correction
private

Definition at line 186 of file EgammaCalibrationAndSmearingTool.h.

◆ m_use_mva_calibration

int CP::EgammaCalibrationAndSmearingTool::m_use_mva_calibration
private

Definition at line 182 of file EgammaCalibrationAndSmearingTool.h.

◆ m_use_temp_correction201215

int CP::EgammaCalibrationAndSmearingTool::m_use_temp_correction201215
private

Definition at line 184 of file EgammaCalibrationAndSmearingTool.h.

◆ m_use_uA2MeV_2015_first2weeks_correction

int CP::EgammaCalibrationAndSmearingTool::m_use_uA2MeV_2015_first2weeks_correction
private

Definition at line 185 of file EgammaCalibrationAndSmearingTool.h.

◆ m_useCaloDistPhiUnifCorrection

int CP::EgammaCalibrationAndSmearingTool::m_useCaloDistPhiUnifCorrection
private

Definition at line 177 of file EgammaCalibrationAndSmearingTool.h.

◆ m_useFastSim

int CP::EgammaCalibrationAndSmearingTool::m_useFastSim
private

Definition at line 170 of file EgammaCalibrationAndSmearingTool.h.

◆ m_useGainCorrection

int CP::EgammaCalibrationAndSmearingTool::m_useGainCorrection
private

Definition at line 178 of file EgammaCalibrationAndSmearingTool.h.

◆ m_useGainInterpolation

int CP::EgammaCalibrationAndSmearingTool::m_useGainInterpolation
private

Definition at line 188 of file EgammaCalibrationAndSmearingTool.h.

◆ m_useIncidents

bool asg::AsgMetadataTool::m_useIncidents
privateinherited

Definition at line 128 of file AsgMetadataTool.h.

◆ m_useIntermoduleCorrection

int CP::EgammaCalibrationAndSmearingTool::m_useIntermoduleCorrection
private

Definition at line 175 of file EgammaCalibrationAndSmearingTool.h.

◆ m_useLayerCorrection

int CP::EgammaCalibrationAndSmearingTool::m_useLayerCorrection
private

Definition at line 189 of file EgammaCalibrationAndSmearingTool.h.

◆ m_usePhiUniformCorrection

int CP::EgammaCalibrationAndSmearingTool::m_usePhiUniformCorrection
private

Definition at line 176 of file EgammaCalibrationAndSmearingTool.h.

◆ m_usePSCorrection

int CP::EgammaCalibrationAndSmearingTool::m_usePSCorrection
private

Definition at line 190 of file EgammaCalibrationAndSmearingTool.h.

◆ m_user_random_run_number

int CP::EgammaCalibrationAndSmearingTool::m_user_random_run_number
private

Definition at line 187 of file EgammaCalibrationAndSmearingTool.h.

◆ m_useS12Correction

int CP::EgammaCalibrationAndSmearingTool::m_useS12Correction
private

Definition at line 191 of file EgammaCalibrationAndSmearingTool.h.

◆ m_useSaccCorrection

int CP::EgammaCalibrationAndSmearingTool::m_useSaccCorrection
private

Definition at line 192 of file EgammaCalibrationAndSmearingTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_varSF

double CP::EgammaCalibrationAndSmearingTool::m_varSF
private

Definition at line 167 of file EgammaCalibrationAndSmearingTool.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
python.Dso.registry
registry
Definition: Control/AthenaServices/python/Dso.py:159
CP::EgammaCalibrationAndSmearingTool::m_useFastSim
int m_useFastSim
Definition: EgammaCalibrationAndSmearingTool.h:170
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
egEnergyCorr::Resolution::MaterialPP0Up
@ MaterialPP0Up
Definition: egammaEnergyCorrectionTool.h:93
egEnergyCorr::Scale::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:266
CP::EgammaCalibrationAndSmearingTool::m_doADCLinearityCorrection
int m_doADCLinearityCorrection
Definition: EgammaCalibrationAndSmearingTool.h:179
PATCore::ParticleType::UnconvertedPhoton
@ UnconvertedPhoton
Definition: PATCoreEnums.h:38
et
Extra patterns decribing particle interation process.
egEnergyCorr::Resolution::SamplingTermUp
@ SamplingTermUp
Definition: egammaEnergyCorrectionTool.h:74
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
egEnergyCorr::es2011c
@ es2011c
Definition: egammaEnergyCorrectionTool.h:289
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
egEnergyCorr::Scale::LArCalibExtra2015PreDown
@ LArCalibExtra2015PreDown
Definition: egammaEnergyCorrectionTool.h:166
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
xAOD::EgammaParameters::convertedPhoton
@ convertedPhoton
Definition: EgammaEnums.h:20
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
python.SystemOfUnits.m2
int m2
Definition: SystemOfUnits.py:92
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
egEnergyCorr::es2011d
@ es2011d
Definition: egammaEnergyCorrectionTool.h:291
CP::EgammaCalibrationAndSmearingTool::affectingSystematics
virtual CP::SystematicSet affectingSystematics() const override
the list of all systematics this tool can be affected by
Definition: EgammaCalibrationAndSmearingTool.cxx:1164
egEnergyCorr::Scale::OFCUp
@ OFCUp
Definition: egammaEnergyCorrectionTool.h:265
CP::EgammaCalibrationAndSmearingTool::m_ResolutionType
std::string m_ResolutionType
Definition: EgammaCalibrationAndSmearingTool.h:168
vtune_athena.format
format
Definition: vtune_athena.py:14
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
CP::EgammaCalibrationAndSmearingTool::EgammaCalibrationAndSmearingTool
EgammaCalibrationAndSmearingTool(const std::string &name)
Definition: EgammaCalibrationAndSmearingTool.cxx:266
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
correlationModel::FULL
@ FULL
Definition: AsgElectronEfficiencyCorrectionTool.cxx:49
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
egEnergyCorr::Scale::LArTemperature2016PreUp
@ LArTemperature2016PreUp
Definition: egammaEnergyCorrectionTool.h:171
CP::EgammaCalibrationAndSmearingTool::m_use_ep_combination
bool m_use_ep_combination
Definition: EgammaCalibrationAndSmearingTool.h:181
CP::EgammaCalibrationAndSmearingTool::m_caloDistPhiUnifCorr
std::unique_ptr< TH2 > m_caloDistPhiUnifCorr
Definition: EgammaCalibrationAndSmearingTool.h:196
egEnergyCorr::Scale::ConvFakeRateDown
@ ConvFakeRateDown
Definition: egammaEnergyCorrectionTool.h:255
egEnergyCorr::Resolution::ZSmearingUp
@ ZSmearingUp
Definition: egammaEnergyCorrectionTool.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
egEnergyCorr::Scale::AllDown
@ AllDown
Definition: egammaEnergyCorrectionTool.h:273
xAOD::Egamma_v1::e
virtual double e() const override final
The total energy of the particle.
Definition: Egamma_v1.cxx:90
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
egEnergyCorr::Scale::L2GainDown
@ L2GainDown
Definition: egammaEnergyCorrectionTool.h:226
egEnergyCorr::Resolution::SigmaEff90
@ SigmaEff90
Definition: egammaEnergyCorrectionTool.h:116
CP::SystematicSet::empty
bool empty() const
returns: whether the set is empty
Definition: SystematicSet.h:67
egEnergyCorr::Scale::LArTemperature2015PreDown
@ LArTemperature2015PreDown
Definition: egammaEnergyCorrectionTool.h:168
PATCore::ParticleDataType::Fast
@ Fast
Definition: PATCoreEnums.h:22
CP::EgammaCalibrationAndSmearingTool::m_currentScaleVariation_data
egEnergyCorr::Scale::Variation m_currentScaleVariation_data
Definition: EgammaCalibrationAndSmearingTool.h:331
egEnergyCorr::es2017_R21_v1
@ es2017_R21_v1
Definition: egammaEnergyCorrectionTool.h:320
egEnergyCorr::Scale::LeakageElecUp
@ LeakageElecUp
Definition: egammaEnergyCorrectionTool.h:197
CP::EgammaCalibrationAndSmearingTool::m_useSaccCorrection
int m_useSaccCorrection
Definition: EgammaCalibrationAndSmearingTool.h:192
CP::EgammaCalibrationAndSmearingTool::ResolutionDecorrelation::ONENP
@ ONENP
CP::EgammaCalibrationAndSmearingTool::correctedCopy
virtual CP::CorrectionCode correctedCopy(const xAOD::Electron &, xAOD::Electron *&) const override
Definition: EgammaCalibrationAndSmearingTool.cxx:844
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_name
std::string m_decorrelation_model_name
Definition: EgammaCalibrationAndSmearingTool.h:158
egEnergyCorr::Scale::MatPP0Down
@ MatPP0Down
Definition: egammaEnergyCorrectionTool.h:242
skel.it
it
Definition: skel.GENtoEVGEN.py:396
CP::use_intermodule_correction
bool use_intermodule_correction(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:180
egEnergyCorr::es2015PRE_res_improved
@ es2015PRE_res_improved
Definition: egammaEnergyCorrectionTool.h:304
egEnergyCorr::Resolution::af2Down
@ af2Down
Definition: egammaEnergyCorrectionTool.h:98
CP::EgammaCalibrationAndSmearingTool::m_currentScalePredicate
EgammaPredicate m_currentScalePredicate
Definition: EgammaCalibrationAndSmearingTool.h:335
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
M_PI
#define M_PI
Definition: ActiveFraction.h:11
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
egEnergyCorr::Scale::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:132
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
egEnergyCorr::Resolution::Gaussian
@ Gaussian
Definition: egammaEnergyCorrectionTool.h:112
CP::EgammaCalibrationAndSmearingTool::m_gain_tool
egGain::GainTool * m_gain_tool
Definition: EgammaCalibrationAndSmearingTool.h:312
CP::EgammaCalibrationAndSmearingTool::m_doScaleCorrection
int m_doScaleCorrection
Definition: EgammaCalibrationAndSmearingTool.h:165
egEnergyCorr::Scale::EXTRARUN3PREDown
@ EXTRARUN3PREDown
Definition: egammaEnergyCorrectionTool.h:270
egEnergyCorr::Scale::L2LowGainDown
@ L2LowGainDown
Definition: egammaEnergyCorrectionTool.h:229
CP::EgammaCalibrationAndSmearingTool::m_doLeakageCorrection
int m_doLeakageCorrection
Definition: EgammaCalibrationAndSmearingTool.h:180
egEnergyCorr::Scale::ZeeStatUp
@ ZeeStatUp
Definition: egammaEnergyCorrectionTool.h:144
PI
const float PI
Definition: test_isolaitonTool.cxx:61
CP::EgammaCalibrationAndSmearingTool::m_simulation
PATCore::ParticleDataType::DataType m_simulation
Definition: EgammaCalibrationAndSmearingTool.h:172
xAOD::Egamma_v1
Definition: Egamma_v1.h:56
CP::egammaMVAToolFolder
std::string egammaMVAToolFolder(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:82
egammaLayerRecalibTool::disable_S12Corrections
void disable_S12Corrections()
Definition: egammaLayerRecalibTool.h:359
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< double >
egammaLayerRecalibTool::applyCorrection
CP::CorrectionCode applyCorrection(xAOD::Egamma &, const xAOD::EventInfo &event_info) const
Definition: egammaLayerRecalibTool.cxx:951
asg::AsgMetadataTool::endInputFile
virtual StatusCode endInputFile()
Function called when the currently open input file got completely processed.
Definition: AsgMetadataTool.cxx:188
CP::EgammaCalibrationAndSmearingTool::m_use_mva_calibration
int m_use_mva_calibration
Definition: EgammaCalibrationAndSmearingTool.h:182
egEnergyCorr::Scale::Wtots1Up
@ Wtots1Up
Definition: egammaEnergyCorrectionTool.h:237
CP::EgammaCalibrationAndSmearingTool::RandomNumber
unsigned int RandomNumber
Definition: EgammaCalibrationAndSmearingTool.h:107
asg::AsgMetadataTool::m_outputMetaStore
MetaStore_t m_outputMetaStore
Object accessing the output metadata store.
Definition: AsgMetadataTool.h:121
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
CP::EgammaCalibrationAndSmearingTool::m_use_temp_correction201215
int m_use_temp_correction201215
Definition: EgammaCalibrationAndSmearingTool.h:184
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
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
CP::SystematicVariation
Definition: SystematicVariation.h:47
CP::EgammaCalibrationAndSmearingTool::m_useGainCorrection
int m_useGainCorrection
Definition: EgammaCalibrationAndSmearingTool.h:178
egEnergyCorr::Scale::ConvRecoDown
@ ConvRecoDown
Definition: egammaEnergyCorrectionTool.h:262
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_scale_name
std::string m_decorrelation_model_scale_name
Definition: EgammaCalibrationAndSmearingTool.h:159
xAOD::EventInfo_v1::IS_SIMULATION
@ IS_SIMULATION
true: simulation, false: data
Definition: EventInfo_v1.h:151
egEnergyCorr::Resolution::PileUpUp
@ PileUpUp
Definition: egammaEnergyCorrectionTool.h:88
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
PATCore::ParticleDataType::Data
@ Data
Definition: PATCoreEnums.h:22
mapkey::sys
@ sys
Definition: TElectronEfficiencyCorrectionTool.cxx:42
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
pi
#define pi
Definition: TileMuonFitter.cxx:65
egEnergyCorr::Scale::L2GainUp
@ L2GainUp
Definition: egammaEnergyCorrectionTool.h:225
PATCore::ParticleDataType::DataType
DataType
Definition: PATCoreEnums.h:22
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
egEnergyCorr::Resolution::MaterialGapUp
@ MaterialGapUp
Definition: egammaEnergyCorrectionTool.h:82
egEnergyCorr::es2017_R21_v0
@ es2017_R21_v0
Definition: egammaEnergyCorrectionTool.h:318
egamma
Definition: egamma.h:58
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ExpressionParsing::isAvailable
bool isAvailable(const T_Aux &cont, SG::auxid_t auxid)
egEnergyCorr::Scale::LeakageElecDown
@ LeakageElecDown
Definition: egammaEnergyCorrectionTool.h:198
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
egEnergyCorr::Scale::L2LowGainUp
@ L2LowGainUp
Definition: egammaEnergyCorrectionTool.h:230
ANA_CHECK_THROW
#define ANA_CHECK_THROW(EXP)
check whether the given expression was successful, throwing an exception on failure
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:339
CP::EgammaCalibrationAndSmearingTool::m_use_full_statistical_error
bool m_use_full_statistical_error
Definition: EgammaCalibrationAndSmearingTool.h:183
CP::EgammaCalibrationAndSmearingTool::oldtool_scale_flag_this_event
egEnergyCorr::Scale::Variation oldtool_scale_flag_this_event(const xAOD::Egamma &p, const xAOD::EventInfo &event_info) const
Definition: EgammaCalibrationAndSmearingTool.cxx:1122
egEnergyCorr::Scale::MomentumUp
@ MomentumUp
Definition: egammaEnergyCorrectionTool.h:137
PATCore::ParticleDataType::Full
@ Full
Definition: PATCoreEnums.h:22
PATCore::ParticleType::ConvertedPhoton
@ ConvertedPhoton
Definition: PATCoreEnums.h:39
egEnergyCorr::es2015cPRE
@ es2015cPRE
Definition: egammaEnergyCorrectionTool.h:305
CP::EgammaCalibrationAndSmearingTool::m_usePhiUniformCorrection
int m_usePhiUniformCorrection
Definition: EgammaCalibrationAndSmearingTool.h:176
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
egEnergyCorr::Scale::LArTemperature2015PreUp
@ LArTemperature2015PreUp
Definition: egammaEnergyCorrectionTool.h:167
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_resolution
ResolutionDecorrelation m_decorrelation_model_resolution
Definition: EgammaCalibrationAndSmearingTool.h:162
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
egGain::GainUncertainty
Definition: GainUncertainty.h:17
CP::EgammaCalibrationAndSmearingTool::m_user_random_run_number
int m_user_random_run_number
Definition: EgammaCalibrationAndSmearingTool.h:187
CP::EgammaCalibrationAndSmearingTool::m_useIntermoduleCorrection
int m_useIntermoduleCorrection
Definition: EgammaCalibrationAndSmearingTool.h:175
egEnergyCorr::Scale::AllUp
@ AllUp
Definition: egammaEnergyCorrectionTool.h:272
CP::EgammaCalibrationAndSmearingTool::m_currentResolutionVariation_MC
egEnergyCorr::Resolution::Variation m_currentResolutionVariation_MC
Definition: EgammaCalibrationAndSmearingTool.h:332
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition: CorrectionCode.h:36
egEnergyCorr::Resolution::ZSmearingDown
@ ZSmearingDown
Definition: egammaEnergyCorrectionTool.h:69
CP::EgammaCalibrationAndSmearingTool::EgammaPredicate
std::function< bool(const xAOD::Egamma &)> EgammaPredicate
Definition: EgammaCalibrationAndSmearingTool.h:111
CP::EgammaCalibrationAndSmearingTool::m_MVACalibSvc
ServiceHandle< IegammaMVASvc > m_MVACalibSvc
Definition: EgammaCalibrationAndSmearingTool.h:308
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
egEnergyCorr::Scale::LArCalibUp
@ LArCalibUp
Definition: egammaEnergyCorrectionTool.h:155
egEnergyCorr::Resolution::MaterialPP0Down
@ MaterialPP0Down
Definition: egammaEnergyCorrectionTool.h:94
egEnergyCorr::es2010
@ es2010
Definition: egammaEnergyCorrectionTool.h:287
CP::EgammaCalibrationAndSmearingTool::m_currentScaleVariation_MC
egEnergyCorr::Scale::Variation m_currentScaleVariation_MC
Definition: EgammaCalibrationAndSmearingTool.h:330
CP::EgammaCalibrationAndSmearingTool::m_ESModel
std::string m_ESModel
Definition: EgammaCalibrationAndSmearingTool.h:157
xAOD::EgammaHelpers::isConvertedPhoton
bool isConvertedPhoton(const xAOD::Egamma *eg, bool excludeTRT=false)
is the object a converted photon
Definition: EgammaxAODHelpers.cxx:25
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
asg::AsgToolConfig
an object that can create a AsgTool
Definition: AsgToolConfig.h:22
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
egEnergyCorr::Resolution::MaterialCryoUp
@ MaterialCryoUp
Definition: egammaEnergyCorrectionTool.h:84
egEnergyCorr::es2017_R21_PRE
@ es2017_R21_PRE
Definition: egammaEnergyCorrectionTool.h:316
CP::EgammaCalibrationAndSmearingTool::AbsEtaCaloPredicateFactory
const EgammaPredicate AbsEtaCaloPredicateFactory(double eta_min, double eta_max) const
Definition: EgammaCalibrationAndSmearingTool.h:236
egEnergyCorr::es2015cPRE_res_improved
@ es2015cPRE_res_improved
Definition: egammaEnergyCorrectionTool.h:306
lumiFormat.i
int i
Definition: lumiFormat.py:85
egEnergyCorr::Scale::topoClusterThresUp
@ topoClusterThresUp
Definition: egammaEnergyCorrectionTool.h:207
egEnergyCorr::Scale::ConvEfficiencyDown
@ ConvEfficiencyDown
Definition: egammaEnergyCorrectionTool.h:253
CP::EgammaCalibrationAndSmearingTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const CP::SystematicSet &systConfig) override
effects: configure this tool for the given list of systematic variations.
Definition: EgammaCalibrationAndSmearingTool.cxx:1908
CP::EgammaCalibrationAndSmearingTool::m_currentResolutionVariation_data
egEnergyCorr::Resolution::Variation m_currentResolutionVariation_data
Definition: EgammaCalibrationAndSmearingTool.h:333
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CP::is_run2
bool is_run2(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:225
xAOD::EgammaHelpers::isElectron
bool isElectron(const xAOD::Egamma *eg)
is the object an electron (not Fwd)
Definition: EgammaxAODHelpers.cxx:12
CP::EgammaCalibrationAndSmearingTool::m_TESModel
egEnergyCorr::ESModel m_TESModel
Definition: EgammaCalibrationAndSmearingTool.h:164
LinearityADC
parameterization of correction for ADC non linearity
Definition: LinearityADC.h:25
egEnergyCorr::Scale::MomentumDown
@ MomentumDown
Definition: egammaEnergyCorrectionTool.h:138
asg::AsgMetadataTool::beginInputFile
virtual StatusCode beginInputFile()
Function called when a new input file is opened.
Definition: AsgMetadataTool.cxx:180
egEnergyCorr::Scale::ConvRecoUp
@ ConvRecoUp
Definition: egammaEnergyCorrectionTool.h:261
master.flag
bool flag
Definition: master.py:29
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
egEnergyCorr::Resolution::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:62
CP::EgammaCalibrationAndSmearingTool::m_varSF
double m_varSF
Definition: EgammaCalibrationAndSmearingTool.h:167
asg::AsgMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AsgMessaging.cxx:49
egEnergyCorr::es2012a
@ es2012a
Definition: egammaEnergyCorrectionTool.h:295
CP::EgammaCalibrationAndSmearingTool::m_useGainInterpolation
int m_useGainInterpolation
Definition: EgammaCalibrationAndSmearingTool.h:188
egammaLayerRecalibTool::disable_PSCorrections
void disable_PSCorrections()
Definition: egammaLayerRecalibTool.h:358
asg::AsgMetadataTool::metaDataStop
virtual StatusCode metaDataStop()
Function called when the tool should write out its metadata.
Definition: AsgMetadataTool.cxx:204
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
ParticleImpl::phi
virtual double phi() const
phi in [-pi,pi[
Definition: ParticleImpl.h:524
egEnergyCorr::es2017_summer
@ es2017_summer
Definition: egammaEnergyCorrectionTool.h:310
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
egEnergyCorr::es2015c_summer
@ es2015c_summer
Definition: egammaEnergyCorrectionTool.h:307
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
CP::EgammaCalibrationAndSmearingTool::m_usePSCorrection
int m_usePSCorrection
Definition: EgammaCalibrationAndSmearingTool.h:190
egEnergyCorr::Scale::L2MediumGainUp
@ L2MediumGainUp
Definition: egammaEnergyCorrectionTool.h:228
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
egEnergyCorr::Scale::af2Up
@ af2Up
Definition: egammaEnergyCorrectionTool.h:245
ParticleImpl::eta
virtual double eta() const
pseudo rapidity
Definition: ParticleImpl.h:514
CP::EgammaCalibrationAndSmearingTool::m_use_mapping_correction
bool m_use_mapping_correction
Definition: EgammaCalibrationAndSmearingTool.h:186
egEnergyCorr::Scale::None
@ None
Definition: egammaEnergyCorrectionTool.h:129
CP::EgammaCalibrationAndSmearingTool::EtaCaloPredicateFactory
const EgammaPredicate EtaCaloPredicateFactory(double eta_min, double eta_max) const
Definition: EgammaCalibrationAndSmearingTool.h:216
egEnergyCorr::Resolution::MaterialCryoDown
@ MaterialCryoDown
Definition: egammaEnergyCorrectionTool.h:83
egEnergyCorr::UNDEFINED
@ UNDEFINED
Definition: egammaEnergyCorrectionTool.h:330
CP::EgammaCalibrationAndSmearingTool::m_ADCLinearity_tool
std::shared_ptr< LinearityADC > m_ADCLinearity_tool
Definition: EgammaCalibrationAndSmearingTool.h:311
CP::EgammaCalibrationAndSmearingTool::m_TResolutionType
egEnergyCorr::Resolution::resolutionType m_TResolutionType
Definition: EgammaCalibrationAndSmearingTool.h:169
CP::EgammaCalibrationAndSmearingTool::m_gain_tool_run2
std::unique_ptr< egGain::GainUncertainty > m_gain_tool_run2
Definition: EgammaCalibrationAndSmearingTool.h:310
egGain::GainTool::CorrectionGainTool
double CorrectionGainTool(double eta_input, double energy_input, double energy_layer2_input, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron) const
Definition: GainTool.cxx:139
CP::EgammaCalibrationAndSmearingTool::oldtool_resolution_flag_this_event
egEnergyCorr::Resolution::Variation oldtool_resolution_flag_this_event(const xAOD::Egamma &p, const xAOD::EventInfo &event_info) const
Definition: EgammaCalibrationAndSmearingTool.cxx:1133
egEnergyCorr::Scale::ZeeStatDown
@ ZeeStatDown
Definition: egammaEnergyCorrectionTool.h:145
CP::EgammaCalibrationAndSmearingTool::correction_phi_unif
double correction_phi_unif(double eta, double phi) const
Definition: EgammaCalibrationAndSmearingTool.cxx:2143
CP::GeV
const double GeV
Definition: EgammaCalibrationAndSmearingTool.cxx:42
CP::EgammaCalibrationAndSmearingTool::m_doSmearing
int m_doSmearing
Definition: EgammaCalibrationAndSmearingTool.h:166
CP::EgammaCalibrationAndSmearingTool::ResolutionDecorrelation::FULL
@ FULL
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
CP::EgammaCalibrationAndSmearingTool::AUTO
static const int AUTO
Definition: EgammaCalibrationAndSmearingTool.h:105
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
egEnergyCorr::Resolution::None
@ None
Definition: egammaEnergyCorrectionTool.h:59
merge.output
output
Definition: merge.py:17
CP::EgammaCalibrationAndSmearingTool::m_use_AFII
int m_use_AFII
Definition: EgammaCalibrationAndSmearingTool.h:171
CP::EgammaCalibrationAndSmearingTool::m_rootTool
std::unique_ptr< AtlasRoot::egammaEnergyCorrectionTool > m_rootTool
Definition: EgammaCalibrationAndSmearingTool.h:317
egEnergyCorr::Resolution::PileUpDown
@ PileUpDown
Definition: egammaEnergyCorrectionTool.h:87
egEnergyCorr::Scale::E4ScintillatorUp
@ E4ScintillatorUp
Definition: egammaEnergyCorrectionTool.h:179
CP::EgammaCalibrationAndSmearingTool::setupSystematics
void setupSystematics()
Definition: EgammaCalibrationAndSmearingTool.cxx:1177
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
egEnergyCorr::Scale::LArCalibExtra2015PreUp
@ LArCalibExtra2015PreUp
Definition: egammaEnergyCorrectionTool.h:165
CP::SystematicSet::insert
void insert(const SystematicVariation &systematic)
description: insert a systematic into the set
Definition: SystematicSet.cxx:88
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
egEnergyCorr::Resolution::MaterialIBLUp
@ MaterialIBLUp
Definition: egammaEnergyCorrectionTool.h:91
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
egEnergyCorr::es2016PRE
@ es2016PRE
Definition: egammaEnergyCorrectionTool.h:308
egEnergyCorr::es2017_summer_final
@ es2017_summer_final
Definition: egammaEnergyCorrectionTool.h:312
CP::EgammaCalibrationAndSmearingTool::xAOD2ptype
PATCore::ParticleType::Type xAOD2ptype(const xAOD::Egamma &particle) const
Definition: EgammaCalibrationAndSmearingTool.cxx:795
xAOD::get_phi_calo
float get_phi_calo(const xAOD::CaloCluster &cluster, int author, bool do_throw=false)
Definition: EgammaCalibrationAndSmearingTool.h:41
egEnergyCorr::Scale::ADCLinUp
@ ADCLinUp
Definition: egammaEnergyCorrectionTool.h:193
asg::AsgServiceConfig
an object that can create a AsgService
Definition: AsgServiceConfig.h:25
egEnergyCorr::Resolution::OFCUp
@ OFCUp
Definition: egammaEnergyCorrectionTool.h:101
CP::EgammaCalibrationAndSmearingTool::m_MVAfolder
std::string m_MVAfolder
Definition: EgammaCalibrationAndSmearingTool.h:318
egEnergyCorr::Scale::MatPP0Up
@ MatPP0Up
Definition: egammaEnergyCorrectionTool.h:241
egEnergyCorr::es2012XX
@ es2012XX
Definition: egammaEnergyCorrectionTool.h:302
egEnergyCorr::Scale::ADCLinDown
@ ADCLinDown
Definition: egammaEnergyCorrectionTool.h:194
xAOD::Electron_v1
Definition: Electron_v1.h:34
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down
@ S12ExtraLastEtaBinRun2Down
Definition: egammaEnergyCorrectionTool.h:212
egEnergyCorr::es2023_R22_Run2_v0
@ es2023_R22_Run2_v0
Definition: egammaEnergyCorrectionTool.h:328
egEnergyCorr::es2012c
@ es2012c
Definition: egammaEnergyCorrectionTool.h:297
egEnergyCorr::Resolution::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:102
egEnergyCorr::Scale::PSb12Down
@ PSb12Down
Definition: egammaEnergyCorrectionTool.h:190
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
CP::EgammaCalibrationAndSmearingTool::m_syst_description
std::map< CP::SystematicVariation, SysInfo > m_syst_description
Definition: EgammaCalibrationAndSmearingTool.h:325
egEnergyCorr::es2017
@ es2017
Definition: egammaEnergyCorrectionTool.h:309
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
egEnergyCorr::es2018_R21_v1
@ es2018_R21_v1
Definition: egammaEnergyCorrectionTool.h:325
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
CP::EgammaCalibrationAndSmearingTool::intermodule_correction
double intermodule_correction(double Ecl, double phi, double eta) const
Definition: EgammaCalibrationAndSmearingTool.cxx:1957
egEnergyCorr::Resolution::SigmaEff80
@ SigmaEff80
Definition: egammaEnergyCorrectionTool.h:114
egEnergyCorr::Scale::ConvEfficiencyUp
@ ConvEfficiencyUp
Definition: egammaEnergyCorrectionTool.h:252
CP::EgammaCalibrationAndSmearingTool::m_set_seed_function
IdFunction m_set_seed_function
Definition: EgammaCalibrationAndSmearingTool.h:337
egEnergyCorr::Scale::PSb12Up
@ PSb12Up
Definition: egammaEnergyCorrectionTool.h:189
egammaLayerRecalibTool
Definition: egammaLayerRecalibTool.h:317
egEnergyCorr::Scale::E4ScintillatorDown
@ E4ScintillatorDown
Definition: egammaEnergyCorrectionTool.h:180
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition: CorrectionCode.h:38
egEnergyCorr::Resolution::MaterialIDDown
@ MaterialIDDown
Definition: egammaEnergyCorrectionTool.h:77
CP::EgammaCalibrationAndSmearingTool::m_useLayerCorrection
int m_useLayerCorrection
Definition: EgammaCalibrationAndSmearingTool.h:189
egEnergyCorr::Scale::ConvFakeRateUp
@ ConvFakeRateUp
Definition: egammaEnergyCorrectionTool.h:254
a
TList * a
Definition: liststreamerinfos.cxx:10
egEnergyCorr::Resolution::MaterialIDUp
@ MaterialIDUp
Definition: egammaEnergyCorrectionTool.h:78
egEnergyCorr::Scale::Wtots1Down
@ Wtots1Down
Definition: egammaEnergyCorrectionTool.h:238
h
egEnergyCorr::es2017_summer_improved
@ es2017_summer_improved
Definition: egammaEnergyCorrectionTool.h:311
xAOD::Photon_v1
Definition: Photon_v1.h:37
asg::AsgMetadataTool
Base class for dual-use tools that provide file metadata access.
Definition: AsgMetadataTool.h:48
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CP::SystematicRegistry
This module implements the central registry for handling systematic uncertainties with CP tools.
Definition: SystematicRegistry.h:25
xAOD::EgammaHelpers::isPhoton
bool isPhoton(const xAOD::Egamma *eg)
is the object a photon
Definition: EgammaxAODHelpers.cxx:21
egEnergyCorr::Resolution::MaterialCaloUp
@ MaterialCaloUp
Definition: egammaEnergyCorrectionTool.h:80
egEnergyCorr::Resolution::SamplingTermDown
@ SamplingTermDown
Definition: egammaEnergyCorrectionTool.h:73
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CP::EgammaCalibrationAndSmearingTool::m_layer_recalibration_tool
egammaLayerRecalibTool * m_layer_recalibration_tool
Definition: EgammaCalibrationAndSmearingTool.h:313
CP::CorrectionCode
Return value from object correction CP tools.
Definition: CorrectionCode.h:31
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
CP::use_phi_uniform_correction
bool use_phi_uniform_correction(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:221
xAOD::get_eta_calo
float get_eta_calo(const xAOD::CaloCluster &cluster, int author, bool do_throw=false)
Definition: EgammaCalibrationAndSmearingTool.h:64
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_resolution_name
std::string m_decorrelation_model_resolution_name
Definition: EgammaCalibrationAndSmearingTool.h:160
egEnergyCorr::Scale::L2MediumGainDown
@ L2MediumGainDown
Definition: egammaEnergyCorrectionTool.h:227
egEnergyCorr::Resolution::MaterialGapDown
@ MaterialGapDown
Definition: egammaEnergyCorrectionTool.h:81
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
EgammaCalibPeriodRunNumbersExample::run_2016
const int run_2016
Definition: Interfaces/EgammaAnalysisInterfaces/EgammaAnalysisInterfaces/IEgammaCalibrationAndSmearingTool.h:21
egEnergyCorr::es2017_R21_ofc0_v1
@ es2017_R21_ofc0_v1
Definition: egammaEnergyCorrectionTool.h:322
egEnergyCorr::Scale::EXTRARUN3PREUp
@ EXTRARUN3PREUp
Definition: egammaEnergyCorrectionTool.h:269
CP::gainToolFactory
std::unique_ptr< egGain::GainTool > gainToolFactory(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:44
egEnergyCorr::Scale::LArTemperature2016PreDown
@ LArTemperature2016PreDown
Definition: egammaEnergyCorrectionTool.h:172
egEnergyCorr::es2022_R22_PRE
@ es2022_R22_PRE
Definition: egammaEnergyCorrectionTool.h:327
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
egEnergyCorr::Scale::LArCalibDown
@ LArCalibDown
Definition: egammaEnergyCorrectionTool.h:156
PATCore::ParticleType::Electron
@ Electron
Definition: PATCoreEnums.h:40
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
egammaLayerRecalibTool::fixForMissingCells
void fixForMissingCells(bool fix=true)
Definition: egammaLayerRecalibTool.h:356
CP::egammaLayerRecalibToolFactory
std::unique_ptr< egammaLayerRecalibTool > egammaLayerRecalibToolFactory(egEnergyCorr::ESModel model, int enableSacc)
Definition: EgammaCalibrationAndSmearingTool.cxx:131
egammaLayerRecalibTool::disable_SaccCorrections
void disable_SaccCorrections()
Definition: egammaLayerRecalibTool.h:360
CP::EgammaCalibrationAndSmearingTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::Egamma &) const override
Definition: EgammaCalibrationAndSmearingTool.cxx:833
SG::DataProxy
Definition: DataProxy.h:44
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
CP::EgammaCalibrationAndSmearingTool::m_syst_description_resolution
std::map< CP::SystematicVariation, egEnergyCorr::Resolution::Variation > m_syst_description_resolution
Definition: EgammaCalibrationAndSmearingTool.h:327
egEnergyCorr::Resolution::af2Up
@ af2Up
Definition: egammaEnergyCorrectionTool.h:97
egEnergyCorr::Scale::af2Down
@ af2Down
Definition: egammaEnergyCorrectionTool.h:246
egEnergyCorr::es2015_5TeV
@ es2015_5TeV
Definition: egammaEnergyCorrectionTool.h:314
egEnergyCorr::Resolution::AllUp
@ AllUp
Definition: egammaEnergyCorrectionTool.h:66
egEnergyCorr::Resolution::MaterialCaloDown
@ MaterialCaloDown
Definition: egammaEnergyCorrectionTool.h:79
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up
@ S12ExtraLastEtaBinRun2Up
Definition: egammaEnergyCorrectionTool.h:211
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_scale
ScaleDecorrelation m_decorrelation_model_scale
Definition: EgammaCalibrationAndSmearingTool.h:161
egEnergyCorr::es2018_R21_v0
@ es2018_R21_v0
Definition: egammaEnergyCorrectionTool.h:324
CP::EgammaCalibrationAndSmearingTool::m_useS12Correction
int m_useS12Correction
Definition: EgammaCalibrationAndSmearingTool.h:191
egEnergyCorr::es2015PRE
@ es2015PRE
Definition: egammaEnergyCorrectionTool.h:303
CP::EgammaCalibrationAndSmearingTool::m_layer_recalibration_tune
std::string m_layer_recalibration_tune
Definition: EgammaCalibrationAndSmearingTool.h:314
CP::EgammaCalibrationAndSmearingTool::m_useCaloDistPhiUnifCorrection
int m_useCaloDistPhiUnifCorrection
Definition: EgammaCalibrationAndSmearingTool.h:177
fitman.k
k
Definition: fitman.py:528
xAOD::EventInfo_v1::eventType
bool eventType(EventType type) const
Check for one particular bitmask value.
CP::SystematicRegistry::getInstance
static SystematicRegistry & getInstance()
Get the singleton instance of the registry for the curren thread.
Definition: SystematicRegistry.cxx:25
CP::EgammaCalibrationAndSmearingTool::m_use_uA2MeV_2015_first2weeks_correction
int m_use_uA2MeV_2015_first2weeks_correction
Definition: EgammaCalibrationAndSmearingTool.h:185
egEnergyCorr::Scale::topoClusterThresDown
@ topoClusterThresDown
Definition: egammaEnergyCorrectionTool.h:208
CP::EgammaCalibrationAndSmearingTool::m_fixForMissingCells
Gaudi::Property< bool > m_fixForMissingCells
Definition: EgammaCalibrationAndSmearingTool.h:198
ServiceHandle< IIncidentSvc >
egEnergyCorr::Resolution::MaterialIBLDown
@ MaterialIBLDown
Definition: egammaEnergyCorrectionTool.h:92
asg::AsgMetadataTool::m_useIncidents
bool m_useIncidents
Definition: AsgMetadataTool.h:128
xAOD::EgammaParameters::unconvertedPhoton
@ unconvertedPhoton
Definition: EgammaEnums.h:19
egEnergyCorr::Resolution::AllDown
@ AllDown
Definition: egammaEnergyCorrectionTool.h:65
Generated on Thu Nov 7 2024 22:10:57 for ATLAS Offline Software by   doxygen 1.8.18