DerivationFramework::EGammaEnergyCalibrationWrapper Class Reference

#include <EGammaEnergyCalibrationWrapper.h>

Inheritance diagram for DerivationFramework::EGammaEnergyCalibrationWrapper:

Collaboration diagram for DerivationFramework::EGammaEnergyCalibrationWrapper:

Public Member Functions
StatusCode	initialize () override final
StatusCode	addBranches (const EventContext &ctx) const override final

Private Attributes
SG::ReadHandleKey< xAOD::EgammaContainer >	m_electronContainerKey
SG::ReadHandleKey< xAOD::EgammaContainer >	m_photonContainerKey
SG::WriteDecorHandleKey< xAOD::EgammaContainer >	m_electronEnergyDecoKey
SG::WriteDecorHandleKey< xAOD::EgammaContainer >	m_photonEnergyDecoKey
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}
ServiceHandle< IegammaMVASvc >	m_MVACalibSvc

Detailed Description

Definition at line 24 of file EGammaEnergyCalibrationWrapper.h.

Member Function Documentation

addBranches()

StatusCode DerivationFramework::EGammaEnergyCalibrationWrapper::addBranches ( const EventContext & ctx ) const

finaloverride

Definition at line 23 of file EGammaEnergyCalibrationWrapper.cxx.

{
  // Process electrons
  SG::ReadHandle<xAOD::EgammaContainer> electrons{m_electronContainerKey, ctx};
  if (!electrons.isValid()) {
    ATH_MSG_ERROR("Cannot retrieve electron container " << m_electronContainerKey.key());
    return StatusCode::FAILURE;
  }
 
  SG::WriteDecorHandle<xAOD::EgammaContainer, float> electronEnergyDeco{m_electronEnergyDecoKey, ctx};
  SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo_key, ctx);
  if (!evt.isValid()) {
    ATH_MSG_ERROR("Cannot retrieve EventInfo " << m_eventInfo_key.key());
    return StatusCode::FAILURE;
  }
 
  for (const xAOD::Egamma* eg : *electrons) {
    if (!eg) continue;
    const xAOD::CaloCluster* cluster = eg->caloCluster();
    float value = 0;
    if (!cluster) {
      ATH_MSG_ERROR("Electron object without CaloCluster, storing zero");
      electronEnergyDeco(*eg) = value;
      continue;
    }
 
    double calibratedEnergy = 0.;
    StatusCode sc = StatusCode::FAILURE;
 
    egammaMVACalib::GlobalEventInfo gei;
    gei.eventInfo = evt.cptr();
    sc = m_MVACalibSvc->getEnergy(*cluster, *eg, calibratedEnergy, gei);
 
    if (sc.isFailure()) {
      ATH_MSG_WARNING("MVACalibSvc failed for electron at eta=" << cluster->eta()
                       << " phi=" << cluster->phi());
    } else {
      value = static_cast<float>(calibratedEnergy);
    }
    electronEnergyDeco(*eg) = value;
  }
 
  // Process photons
  SG::ReadHandle<xAOD::EgammaContainer> photons{m_photonContainerKey, ctx};
  if (!photons.isValid()) {
    ATH_MSG_ERROR("Cannot retrieve photon container " << m_photonContainerKey.key());
    return StatusCode::FAILURE;
  }
 
  SG::WriteDecorHandle<xAOD::EgammaContainer, float> photonEnergyDeco{m_photonEnergyDecoKey, ctx};
  for (const xAOD::Egamma* eg : *photons) {
    if (!eg) continue;
    const xAOD::CaloCluster* cluster = eg->caloCluster();
    float value = 0;
    if (!cluster) {
      ATH_MSG_ERROR("Photon object without CaloCluster");
      photonEnergyDeco(*eg) = value;
      continue;
    }
 
    double calibratedEnergy = 0.;
    StatusCode sc = StatusCode::FAILURE;
    
    egammaMVACalib::GlobalEventInfo gei;
    gei.eventInfo = evt.cptr();
    sc = m_MVACalibSvc->getEnergy(*cluster, *eg, calibratedEnergy, gei);
 
    if (sc.isFailure()) {
      ATH_MSG_WARNING("MVACalibSvc failed for photon at eta=" << cluster->eta()
                       << " phi=" << cluster->phi());
    } else {
      value = static_cast<float>(calibratedEnergy);
    }
    photonEnergyDeco(*eg) = value;
  }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::EGammaEnergyCalibrationWrapper::initialize ( )

finaloverride

Definition at line 12 of file EGammaEnergyCalibrationWrapper.cxx.

{
  ATH_CHECK(m_electronContainerKey.initialize());
  ATH_CHECK(m_photonContainerKey.initialize());
  ATH_CHECK(m_electronEnergyDecoKey.initialize());
  ATH_CHECK(m_photonEnergyDecoKey.initialize());
  ATH_CHECK(m_eventInfo_key.initialize());
  ATH_CHECK(m_MVACalibSvc.retrieve());
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_electronContainerKey

SG::ReadHandleKey<xAOD::EgammaContainer> DerivationFramework::EGammaEnergyCalibrationWrapper::m_electronContainerKey

private

Initial value:

{
      this, "ElectronContainerName", "Electrons", "Electron container"
    }

Definition at line 34 of file EGammaEnergyCalibrationWrapper.h.

                                                               {
      this, "ElectronContainerName", "Electrons", "Electron container"
    };

m_electronEnergyDecoKey

SG::WriteDecorHandleKey<xAOD::EgammaContainer> DerivationFramework::EGammaEnergyCalibrationWrapper::m_electronEnergyDecoKey

private

Initial value:

{
      this, "decoratorTransformerEnergy", m_electronContainerKey, "", "Calibrated energy decoration for electrons"
    }

Definition at line 42 of file EGammaEnergyCalibrationWrapper.h.

                                                                      {
      this, "decoratorTransformerEnergy", m_electronContainerKey, "", "Calibrated energy decoration for electrons"
    };

m_eventInfo_key

SG::ReadHandleKey<xAOD::EventInfo> DerivationFramework::EGammaEnergyCalibrationWrapper::m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}

private

Definition at line 50 of file EGammaEnergyCalibrationWrapper.h.

{this, "EventInfo", "EventInfo", "Input event information"};

m_MVACalibSvc

ServiceHandle<IegammaMVASvc> DerivationFramework::EGammaEnergyCalibrationWrapper::m_MVACalibSvc

private

Initial value:

{
      this, "TransformerCalibSvc", "", "Calibration service using Transformer model"
    }

Definition at line 52 of file EGammaEnergyCalibrationWrapper.h.

                                              {
      this, "TransformerCalibSvc", "", "Calibration service using Transformer model"
    };

m_photonContainerKey

SG::ReadHandleKey<xAOD::EgammaContainer> DerivationFramework::EGammaEnergyCalibrationWrapper::m_photonContainerKey

private

Initial value:

{
      this, "PhotonContainerName", "Photons", "Photon container"
    }

Definition at line 38 of file EGammaEnergyCalibrationWrapper.h.

                                                             {
      this, "PhotonContainerName", "Photons", "Photon container"
    };

m_photonEnergyDecoKey

SG::WriteDecorHandleKey<xAOD::EgammaContainer> DerivationFramework::EGammaEnergyCalibrationWrapper::m_photonEnergyDecoKey

private

Initial value:

{
      this, "decoratorTransformerEnergyPhoton", m_photonContainerKey, "", "Calibrated energy decoration for photons"
    }

Definition at line 46 of file EGammaEnergyCalibrationWrapper.h.

                                                                    {
      this, "decoratorTransformerEnergyPhoton", m_photonContainerKey, "", "Calibrated energy decoration for photons"
    };

---

The documentation for this class was generated from the following files:

• EGammaEnergyCalibrationWrapper.h
• EGammaEnergyCalibrationWrapper.cxx