testAthenaPhotonAlg.cxx File Reference

#include "testAthenaPhotonAlg.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODEgamma/PhotonContainer.h"
#include "xAODEgamma/PhotonAuxContainer.h"
#include "xAODCore/ShallowCopy.h"
#include "EgammaAnalysisInterfaces/IAsgPhotonEfficiencyCorrectionTool.h"

Include dependency graph for testAthenaPhotonAlg.cxx:

Go to the source code of this file.

Functions
namespace	ADD_CMODE (CP)

Function Documentation

ADD_CMODE()

namespace ADD_CMODE

(

CP

)

Definition at line 1 of file testAthenaPhotonAlg.cxx.

                        {
 
testAthenaPhotonAlg::testAthenaPhotonAlg( const std::string& name, ISvcLocator* pSvcLocator ) : AthAlgorithm( name, pSvcLocator ),  m_photonSF("CP::AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool",this){
 
  //declareProperty( "Property", m_nProperty ); //example property declaration
  declareProperty( "PhotonEfficiencyCorrectionTool", m_photonSF );
}
//
testAthenaPhotonAlg::~testAthenaPhotonAlg() = default;
 
 
StatusCode testAthenaPhotonAlg::initialize() {
  ATH_MSG_INFO ("Initializing " << name() << "...");
  // Retrieve the tool
  ATH_CHECK( m_photonSF.retrieve() );
  return StatusCode::SUCCESS;
}
 
StatusCode testAthenaPhotonAlg::finalize() {
  ATH_MSG_INFO ("Finalizing " << name() << "...");
  // Clean up
  ATH_CHECK( m_photonSF.release() );
  return StatusCode::SUCCESS;
}
 
StatusCode testAthenaPhotonAlg::execute(const EventContext& /*ctx*/) {
  ATH_MSG_DEBUG ("Executing " << name() << "...");
 
//----------------------------
 // Event information
 //---------------------------
 const xAOD::EventInfo* eventInfo = nullptr; //NOTE: Everything that comes from the storegate direct from the input files is const!
 
 // ask the event store to retrieve the xAOD EventInfo container
 //ATH_CHECK( evtStore()->retrieve( eventInfo, "EventInfo") );  // the second argument ("EventInfo") is the key name
 ATH_CHECK( evtStore()->retrieve( eventInfo) );
 // if there is only one container of that type in the xAOD (as with the EventInfo container), you do not need to pass
 // the key name, the default will be taken as the only key name in the xAOD
 
 // check if data or MC
 bool isMC = true;
 if(!eventInfo->eventType(xAOD::EventInfo::IS_SIMULATION ) ){
   isMC = false;
 }
 if(!isMC) ATH_MSG_ERROR("This is data, no scale factors should be used on the data!");
 
 //---------
 // photons
 //---------
 const xAOD::PhotonContainer* photons = nullptr;
 ATH_CHECK( evtStore()->retrieve( photons, "Photons") );
 ATH_MSG_DEBUG("Found "<<photons->size() <<" photons in event, itterate....");
 
// Let's create a shallow copy of the const photon container, and decorate it with the obtained SF
auto inContShallowCopy = xAOD::shallowCopy( *photons );
 
//creates a new photon container to hold the subset as well as the needed auxiliary container
  auto umyphotons = std::make_unique<xAOD::PhotonContainer>();
  auto myphotonsAux = std::make_unique<xAOD::PhotonAuxContainer>();
  // You need to tell the photon container in which auxiliary container it should write its member variables
  umyphotons->setStore( myphotonsAux.get() ); //gives it a new associated aux container
 
  // Also record to storegate: you must record both the container and the auxcontainer.
  // Note that storegate takes ownership of these objects, i.e., you must not try to delete them yourself.
  xAOD::PhotonContainer* myphotons = umyphotons.get();
  ATH_CHECK( evtStore()->record(std::move(umyphotons),  "MyPhotons" ) );
  ATH_CHECK( evtStore()->record(std::move(myphotonsAux), "MyPhotonsAux" ) );
 
// Loop over all Photons in the shallow-copy container, decorate it with SF, and store in new xAOD file, in addition print out all SF (with get* function)
for ( xAOD::Photon* ph : *(inContShallowCopy.first) ) {
 
  //if ( std::abs(ph->eta()) > 2.37 || ph->pt()<15000. ) continue;
  //if (std::abs(ph->eta())>=1.37 && std::abs(ph->eta())<=1.52) continue;
  ATH_MSG_DEBUG( "  photon pt = " << ph->pt() <<", photon eta = " << ph->eta() );
 
  double SF, SFerr; // for photon SF and the apropriate error
  if(!m_photonSF->getEfficiencyScaleFactor(*ph,SF)){
    ATH_MSG_WARNING( "Couldn't get photon scale factor!" );
    continue;
  }
  if(!m_photonSF->getEfficiencyScaleFactorError(*ph,SFerr)){
    ATH_MSG_WARNING( "Couldn't get photon scale factor uncertainty!" );
    continue;
  }
  ATH_MSG_DEBUG( "  photon SF = " << SF <<", photon SF sys error = " << SFerr );
 
  // applyEfficiencyScaleFactor - decorate the object (*photon)
  if ( m_photonSF->applyEfficiencyScaleFactor(*ph) == CP::CorrectionCode::Error ) {
    ATH_MSG_ERROR("PhotonEfficiencyCorrectionTool reported a CP::CorrectionCode::Error");
    return StatusCode::FAILURE;
  }
 
  // add it to a new photon container which will be writed to a new file
  myphotons->push_back(std::make_unique<xAOD::Photon>());
  *(myphotons->back()) = *ph;
} // and loop on photons
 
  return StatusCode::SUCCESS;
}
}