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 271 of file EgammaCalibrationAndSmearingTool.cxx.

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

◆ ~EgammaCalibrationAndSmearingTool()

CP::EgammaCalibrationAndSmearingTool::~EgammaCalibrationAndSmearingTool ( )
private

Definition at line 337 of file EgammaCalibrationAndSmearingTool.cxx.

337  {
338  ATH_MSG_DEBUG("destructor");
339  delete m_layer_recalibration_tool;
340  delete m_gain_tool;
341 }

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 1172 of file EgammaCalibrationAndSmearingTool.cxx.

1173  {
1174  CP::SystematicSet affecting_systematics;
1175  for (const auto& it : m_syst_description) {
1176  affecting_systematics.insert(it.first);
1177  }
1178  for (const auto& it : m_syst_description_resolution) {
1179  affecting_systematics.insert(it.first);
1180  }
1181 
1182  return affecting_systematics;
1183 }

◆ applyCorrection() [1/2]

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

Implements CP::IEgammaCalibrationAndSmearingTool.

Definition at line 841 of file EgammaCalibrationAndSmearingTool.cxx.

842  {
843  // Retrieve the event information:
844  const xAOD::EventInfo* event_info = nullptr;
845  if (evtStore()->retrieve(event_info, "EventInfo").isFailure()) {
846  ATH_MSG_ERROR("No EventInfo object could be retrieved");
847  return CP::CorrectionCode::Error;
848  }
849  return applyCorrection(input, *event_info);
850 }

◆ applyCorrection() [2/2]

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

Definition at line 896 of file EgammaCalibrationAndSmearingTool.cxx.

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

◆ 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 1928 of file EgammaCalibrationAndSmearingTool.cxx.

1929  {
1930 
1931  // set the nominal one (no systematics)
1932  m_currentScaleVariation_MC = egEnergyCorr::Scale::None;
1933  m_currentScaleVariation_data = m_doScaleCorrection
1934  ? egEnergyCorr::Scale::Nominal
1935  : egEnergyCorr::Scale::None;
1936  m_currentResolutionVariation_MC = m_doSmearing
1937  ? egEnergyCorr::Resolution::Nominal
1938  : egEnergyCorr::Resolution::None;
1939  m_currentResolutionVariation_data = egEnergyCorr::Resolution::None;
1940  m_currentScalePredicate = [](const xAOD::Egamma&) { return true; };
1941 
1942  if (systConfig.empty())
1943  return StatusCode::SUCCESS;
1944 
1945  // the following code allows only ONE systematic variation at a time (1 for
1946  // scale, 1 for resolution)
1947 
1948  bool first_scale = true;
1949  bool first_resolution = true;
1950  for (const auto& it : systConfig) {
1951  const auto found_scale = m_syst_description.find(it);
1952  if (found_scale != m_syst_description.end()) {
1953  if (not first_scale) {
1954  ATH_MSG_ERROR("multiple scale variations not supported");
1955  throw std::runtime_error("multiple scale variations not supported");
1956  }
1957  first_scale = false;
1958  m_currentScaleVariation_MC = found_scale->second.effect;
1959  m_currentScalePredicate = found_scale->second.predicate;
1960  }
1961 
1962  const auto found_resolution = m_syst_description_resolution.find(it);
1963  if (found_resolution != m_syst_description_resolution.end()) {
1964  if (not first_resolution) {
1965  ATH_MSG_ERROR("multiple resolution variations not supported");
1966  throw std::runtime_error(
1967  "multiple resolution variations not supported");
1968  }
1969  first_resolution = false;
1970  m_currentResolutionVariation_MC = found_resolution->second;
1971  }
1972  }
1973 
1974  return StatusCode::SUCCESS;
1975 }

◆ 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 852 of file EgammaCalibrationAndSmearingTool.cxx.

853  {
854  // A sanity check:
855  if (output)
856  ATH_MSG_WARNING(
857  "Non-null pointer received. "
858  "There's a possible memory leak!");
859 
860  output = new xAOD::Electron();
861  output->makePrivateStore(input);
862  return applyCorrection(*output);
863 }

◆ correctedCopy() [2/2]

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

Implements CP::IEgammaCalibrationAndSmearingTool.

Definition at line 865 of file EgammaCalibrationAndSmearingTool.cxx.

866  {
867  // A sanity check:
868  if (output)
869  ATH_MSG_WARNING(
870  "Non-null pointer received. "
871  "There's a possible memory leak!");
872 
873  output = new xAOD::Photon();
874  output->makePrivateStore(input);
875  return applyCorrection(*output);
876 }

◆ correction_phi_unif()

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

Definition at line 2164 of file EgammaCalibrationAndSmearingTool.cxx.

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

◆ 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 1148 of file EgammaCalibrationAndSmearingTool.cxx.

1149  {
1150  PATCore::ParticleDataType::DataType dataType =
1151  (event_info->eventType(xAOD::EventInfo::IS_SIMULATION))
1152  ? m_simulation
1153  : PATCore::ParticleDataType::Data;
1154 
1155  const xAOD::TrackParticle* eTrack = el->trackParticle();
1156 
1157  // track momentum and eta
1158  const float el_tracketa = eTrack->eta();
1159  const float el_trackmomentum = eTrack->pt() * cosh(el->eta());
1160 
1161  return m_rootTool->getCorrectedMomentum(
1162  dataType, PATCore::ParticleType::Electron, el_trackmomentum, el_tracketa,
1163  oldtool_scale_flag_this_event(*el, *event_info), m_varSF);
1164 }

◆ getEnergy() [1/3]

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

Definition at line 887 of file EgammaCalibrationAndSmearingTool.cxx.

888  {
889  xAOD::Electron* new_particle = nullptr;
890  ANA_CHECK_THROW(correctedCopy(input, new_particle));
891  const double e = new_particle->e();
892  delete new_particle;
893  return e;
894 }

◆ getEnergy() [2/3]

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

Definition at line 878 of file EgammaCalibrationAndSmearingTool.cxx.

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

◆ getEnergy() [3/3]

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

Definition at line 1122 of file EgammaCalibrationAndSmearingTool.cxx.

1123  {
1124  ANA_CHECK_THROW(applyCorrection(*p, *event_info));
1125  ATH_MSG_DEBUG("returning " << p->e());
1126  return p->e();
1127 }

◆ 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 823 of file EgammaCalibrationAndSmearingTool.cxx.

824  {
825  const auto ptype = xAOD2ptype(particle);
826  const auto cl_etaCalo =
827  xAOD::get_eta_calo(*particle.caloCluster(), particle.author());
828 
829  return m_rootTool->resolution(particle.e(), particle.caloCluster()->eta(),
830  cl_etaCalo, ptype, withCT,
831  false); // TODO: always for full simulation
832 }

◆ 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 343 of file EgammaCalibrationAndSmearingTool.cxx.

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

◆ 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 1977 of file EgammaCalibrationAndSmearingTool.cxx.

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

◆ 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 1166 of file EgammaCalibrationAndSmearingTool.cxx.

1167  {
1168  CP::SystematicSet sys = affectingSystematics();
1169  return sys.find(systematic) != sys.end();
1170 }

◆ 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 1141 of file EgammaCalibrationAndSmearingTool.cxx.

1142  {
1143  return event_info.eventType(xAOD::EventInfo::IS_SIMULATION)
1144  ? m_currentResolutionVariation_MC
1145  : m_currentResolutionVariation_data;
1146 }

◆ 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 1130 of file EgammaCalibrationAndSmearingTool.cxx.

1131  {
1132  if (!event_info.eventType(xAOD::EventInfo::IS_SIMULATION))
1133  return m_currentScaleVariation_data;
1134  if (m_currentScalePredicate(p))
1135  return m_currentScaleVariation_MC;
1136  else
1137  return egEnergyCorr::Scale::None;
1138 }

◆ 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 1923 of file EgammaCalibrationAndSmearingTool.cxx.

1924  {
1925  return affectingSystematics();
1926 }

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

836  {
837  return m_rootTool->resolution(energy, cl_eta, cl_etaCalo, ptype, withCT,
838  false);
839 }

◆ 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 1185 of file EgammaCalibrationAndSmearingTool.cxx.

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

◆ 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 803 of file EgammaCalibrationAndSmearingTool.cxx.

804  {
805  auto ptype = PATCore::ParticleType::Electron;
806  // no ForwardElectron ptype: consider them as Electron
807  if (xAOD::EgammaHelpers::isElectron(&particle) ||
808  particle.author() == xAOD::EgammaParameters::AuthorFwdElectron) {
809  ptype = PATCore::ParticleType::Electron;
810  } else if (xAOD::EgammaHelpers::isPhoton(&particle)) {
811  if (xAOD::EgammaHelpers::isConvertedPhoton(&particle)) {
812  ptype = PATCore::ParticleType::ConvertedPhoton;
813  } else {
814  ptype = PATCore::ParticleType::UnconvertedPhoton;
815  }
816  } else {
817  ATH_MSG_ERROR("particle is not electron of photon");
818  throw std::runtime_error("particle is not electron or photon");
819  }
820  return ptype;
821 }

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:1172
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:271
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:852
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:183
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:83
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:295
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:29
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:1130
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:1928
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:229
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:332
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:1141
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:2164
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:1185
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:228
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:803
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:1977
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::es2024_Run3_ofc0_v0
@ es2024_Run3_ofc0_v0
Definition: egammaEnergyCorrectionTool.h:329
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:225
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:133
egammaLayerRecalibTool::disable_SaccCorrections
void disable_SaccCorrections()
Definition: egammaLayerRecalibTool.h:360
CP::EgammaCalibrationAndSmearingTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::Egamma &) const override
Definition: EgammaCalibrationAndSmearingTool.cxx:841
SG::DataProxy
Definition: DataProxy.h:45
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 Sun Dec 22 2024 21:56:59 for ATLAS Offline Software by   doxygen 1.8.18