testAthenaEgammaCalibTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// EDM include(s):
 
#include "xAODEgamma/ElectronContainer.h"
#include "xAODEgamma/PhotonContainer.h"
#include "xAODEgamma/Egamma.h"
#include "xAODCaloEvent/CaloCluster.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODCore/ShallowCopy.h"
#include "PATInterfaces/SystematicVariation.h"
#include "PATInterfaces/SystematicRegistry.h"
#include "AsgMessaging/StatusCode.h"
#include "ElectronPhotonFourMomentumCorrection/EgammaCalibrationAndSmearingTool.h"
#include "TString.h"
// local include
#include "testAthenaEgammaCalibTool.h"
 
testAthenaEgammaCalibTool::testAthenaEgammaCalibTool( const std::string& name, ISvcLocator* svcLoc )
  : AthAlgorithm( name, svcLoc ),
    m_EgammaCalibrationAndSmearingTool("CP::EgammaCalibrationAndSmearingTool/EgammaCalibrationAndSmearingTool", this)
{
  declareProperty( "SG_Electrons", m_sg_electrons = "Electrons" );
  declareProperty( "EgammaCalibrationAndSmearingTool", m_EgammaCalibrationAndSmearingTool);
}
 
 
StatusCode testAthenaEgammaCalibTool::initialize()
{
  // Greet the user:
  ATH_MSG_INFO( "Initialising..." );
 
  // Retrieve the tools:
  ATH_CHECK(m_EgammaCalibrationAndSmearingTool.retrieve());
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode testAthenaEgammaCalibTool::execute(const EventContext& /*ctx*/)
{
  const xAOD::EventInfo* event_info = nullptr;
  ATH_CHECK( evtStore()->retrieve( event_info) );
 
  const xAOD::ElectronContainer* electrons;
  ATH_CHECK( evtStore()->retrieve(electrons, m_sg_electrons) );
 
  //Clone
  xAOD::ShallowCopyResult_t<xAOD::ElectronContainer> electrons_shallowCopy = xAOD::shallowCopy( *electrons );
  xAOD::ElectronContainer* elsCorr = electrons_shallowCopy.first.get();
  //Record in StoreGate
  CHECK( evtStore()->record( std::move(electrons_shallowCopy.first), "ElectronCollectionCorr") );
  CHECK( evtStore()->record( std::move(electrons_shallowCopy.second), "ElectronCollectionCorrAux.") );
 
  //===========SYSTEMATICS
  const CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
  const CP::SystematicSet& recommendedSystematics = registry.recommendedSystematics();
  std::vector<CP::SystematicSet> sysList;
  // this is the nominal set
  sysList.emplace_back();
 
  ATH_MSG_INFO("SIZE of the systematics set:" << recommendedSystematics.size());
 
  for(const auto & recommendedSystematic : recommendedSystematics)
    {
      sysList.emplace_back();
      sysList.back().insert(recommendedSystematic);
    }
 
  std::vector<CP::SystematicSet>::const_iterator sysListItr;
 
  //Iterate over the shallow copy
  xAOD::ElectronContainer::iterator el_it      = elsCorr->begin();
  xAOD::ElectronContainer::iterator el_it_last = elsCorr->end();
  unsigned int i = 0;
  for (; el_it != el_it_last; ++el_it, ++i) {
    xAOD::Electron* el = *el_it;
    ATH_MSG_INFO("Electron " << i);
    ATH_MSG_INFO("xAOD/raw pt, eta, phi = " << el->pt() << ", " << el->eta() << ", " << el->phi());
 
    if(m_EgammaCalibrationAndSmearingTool->applyCorrection(*el) != CP::CorrectionCode::Ok){
      ATH_MSG_WARNING("Cannot calibrate electron");
    }
    ATH_MSG_INFO("Calibrated pt = " << el->pt());
 
    //systematics
    ATH_MSG_INFO("=============SYSTEMATICS CHECK NOW");
    for (sysListItr = sysList.begin(); sysListItr != sysList.end(); ++sysListItr)
      {
    // Tell the calibration tool which variation to apply
    if (m_EgammaCalibrationAndSmearingTool->applySystematicVariation(*sysListItr) != StatusCode::SUCCESS)
      {
        ATH_MSG_ERROR("Cannot configure calibration tool for systematics");
      }
    //For now remove by hand the photon ones
    TString syst_name = TString(sysListItr->name());
    if(!syst_name.BeginsWith("EL") && !syst_name.BeginsWith("EG")) continue;
 
    if(m_EgammaCalibrationAndSmearingTool->applyCorrection(*el) != CP::CorrectionCode::Ok){
      ATH_MSG_WARNING("Cannot calibrate electron");
    }
 
    ATH_MSG_INFO("Calibrated pt with systematic " << syst_name << " = " << el->pt());
      }
    ATH_MSG_INFO("=============END SYSTEMATICS ");
  }
 
  //test the correctedCopy method
  for (; el_it != el_it_last; ++el_it) {
    xAOD::Electron *copy_el = nullptr; // new object
    if (m_EgammaCalibrationAndSmearingTool->correctedCopy( **el_it, copy_el) != CP::CorrectionCode::Ok){
      ATH_MSG_WARNING("Could not apply correction to new electron object");
      continue;
    }
  }
 
  return StatusCode::SUCCESS;
}