TrigEgammaPrecisionElectronHypoAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#include "TrigEgammaPrecisionElectronHypoAlg.h"
#include "TrigCompositeUtils/HLTIdentifier.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
#include "TrigSteeringEvent/TrigRoiDescriptorCollection.h"
#include "AthViews/ViewHelper.h"
#include "AthenaMonitoringKernel/Monitored.h"
 
namespace TCU = TrigCompositeUtils;
 
TrigEgammaPrecisionElectronHypoAlg::TrigEgammaPrecisionElectronHypoAlg( const std::string& name, ISvcLocator* pSvcLocator ) :
  ::HypoBase( name, pSvcLocator ) {}
 
 
StatusCode TrigEgammaPrecisionElectronHypoAlg::initialize() 
{
 
  ATH_MSG_DEBUG ( "Initializing " << name() << "..." );
 
  ATH_CHECK( m_hypoTools.retrieve() );
 
  ATH_MSG_DEBUG( "Retrieving egammaElectronCBTool..."  );
  ATH_CHECK(m_egammaElectronCBTools.retrieve());
 
  // Now we try to retrieve the ElectronPhotonSelectorTools that we will use to apply the electron Identification. This is a *must*
  ATH_MSG_DEBUG( "Retrieving egammaElectronLHTool..."  );
  ATH_CHECK(m_egammaElectronLHTools.retrieve());
  ATH_MSG_DEBUG( "Retrieving egammaElectronDNNTool..."  );
  ATH_CHECK(m_egammaElectronDNNTools.retrieve());
 
  // Retrieving Luminosity info
  ATH_MSG_DEBUG( "Retrieving luminosityCondData..."  );
  ATH_CHECK( m_avgMuKey.initialize() );
  ATH_CHECK( m_electronsKey.initialize() );
  renounce( m_electronsKey );// electrons are made in views, so they are not in the EvtStore: hide them
 
  renounce (m_decorD0Key);
  renounce (m_decorClEtaKey);
  renounce (m_decorClPhiKey);
  ATH_CHECK( m_decorD0Key.initialize() );
  ATH_CHECK( m_decorClEtaKey.initialize() );
  ATH_CHECK( m_decorClPhiKey.initialize() );
 
  if (! m_monTool.empty() ) ATH_CHECK( m_monTool.retrieve() );
  return StatusCode::SUCCESS;
}
 
 
StatusCode TrigEgammaPrecisionElectronHypoAlg::execute( const EventContext& context ) const 
{  
 
  ATH_MSG_DEBUG ( "Executing " << name() << "..." );
 
  auto timer = Monitored::Timer("TIME_exec");
  auto timer_lh = Monitored::Timer("TIME_LH_exec");
  auto timer_dnn = Monitored::Timer("TIME_DNN_exec");
  auto monitoring = Monitored::Group( m_monTool, timer, timer_lh, timer_dnn);
 
 
  timer.start();
 
 
  auto previousDecisionsHandle = SG::makeHandle( decisionInput(), context );
  ATH_CHECK( previousDecisionsHandle.isValid() );
  ATH_MSG_DEBUG( "Running in precisionElectron step with "<< previousDecisionsHandle->size() <<" previous decisions");
 
 
  // new decisions
  // new output decisions
  SG::WriteHandle<TCU::DecisionContainer> outputHandle = TCU::createAndStore(decisionOutput(), context );
  auto decisions = outputHandle.ptr();
 
  // input for decision
  std::vector<ITrigEgammaPrecisionElectronHypoTool::ElectronInfo> toolInput;
 
  // loop over previous decisions
  size_t counter=0;
  for ( auto previousDecision: *previousDecisionsHandle ) {
 
    //get updated RoI  
    auto roiELInfo = TCU::findLink<TrigRoiDescriptorCollection>( previousDecision, TCU::roiString() );
 
    ATH_CHECK( roiELInfo.isValid() );
    const TrigRoiDescriptor* roi = *(roiELInfo.link);
    const auto viewEL = previousDecision->objectLink<ViewContainer>( TCU::viewString() );
    ATH_CHECK( viewEL.isValid() );
    auto electronHandle = ViewHelper::makeHandle( *viewEL, m_electronsKey, context);
    ATH_CHECK( electronHandle.isValid() );
    ATH_MSG_DEBUG ( "Precision Electron handle size: " << electronHandle->size() << "..." );
 
    // Make decorators to output track d0 and cluster eta/phi
    auto decor_d0 = ViewHelper::makeHandle<float> (*viewEL, m_decorD0Key, context);
    auto decor_clEta = ViewHelper::makeHandle<float> (*viewEL, m_decorClEtaKey, context);
    auto decor_clPhi = ViewHelper::makeHandle<float> (*viewEL, m_decorClPhiKey, context);
 
    // This algorithm adds a few decorations to the input electrons.
    // But sometimes we can be given views on which another instance of this
    // algorithm has already run.  We need to avoid redoing the decorations
    // in that case, or we'll crash.
    // We can even be given a mixture of views, some of which have
    // the decorations already done and some not, so we can't really
    // configure this statically.
    // Test if the decoration is there, and trust that the overall
    // configuration ensures that two threads won't try to write the
    // same decoration at the same time.
    bool hasDecor = decor_d0.isAvailable();
 
    // Used for checking earlier decorations.
    static const SG::ConstAccessor<float> acc_d0 (SG::decorKeyFromKey (m_decorD0Key.key()));
    static const SG::ConstAccessor<float> acc_clEta (SG::decorKeyFromKey (m_decorClEtaKey.key()));
    static const SG::ConstAccessor<float> acc_clPhi (SG::decorKeyFromKey (m_decorClPhiKey.key()));
 
    // Loop over the electronHandles
    size_t validelectrons=0;
    for (const xAOD::Electron* ele : *electronHandle) {
      
      {
        auto el = ViewHelper::makeLink( *viewEL, electronHandle, ele->index() );
        ATH_MSG_DEBUG ( "Checking el.isValid()...");
        if( !el.isValid() ) {
          ATH_MSG_DEBUG ( "Precision ElectronHandle in position " << ele->index() << " -> invalid ElemntLink!. Skipping...");
        }
 
        ATH_CHECK(el.isValid());
        ATH_MSG_DEBUG ( "Precision ElectronHandle in position " << ele->index() << " processing...");
        auto d = TCU::newDecisionIn( decisions, TCU::hypoAlgNodeName() );
        d->setObjectLink( TCU::featureString(),  el );
        TCU::linkToPrevious( d, decisionInput().key(), counter );
 
        // create the info
        ITrigEgammaPrecisionElectronHypoTool::ElectronInfo info(d, roi, ele, previousDecision);
 
        // Retrieve avgmu value from event info
        SG::ReadDecorHandle<xAOD::EventInfo,float> eventInfoDecor(m_avgMuKey, context);
 
        if(eventInfoDecor.isPresent()){
          float avg_mu = eventInfoDecor(0);
          ATH_MSG_DEBUG("Average mu " << avg_mu);
          info.valueDecorator["avgmu"] = avg_mu;
        }
 
        // Decorate the info with all CB decisions
        for (std::size_t i = 0; i < m_cbNames.size(); ++i) {
          auto const& pidname = m_cbNames[i];
          info.pidDecorator[pidname] = (bool)m_egammaElectronCBTools[i]->accept(context, ele);
        }
 
        // Decorate the info with all LH decisions
        ATH_MSG_DEBUG ("Using LH Tool..");
        int idx=0;
        for ( auto &pidname : m_lhNames ){
          timer_lh.start();
          if(eventInfoDecor.isPresent()) {
            float avg_mu = eventInfoDecor(0);
            float lhvalue = m_egammaElectronLHTools[idx]->calculate(context, ele,avg_mu);
            info.valueDecorator[pidname+"LHValue"] = lhvalue;
            info.pidDecorator[pidname] = (bool)m_egammaElectronLHTools[idx]->accept(context, ele,avg_mu);
          }else{
            float lhvalue = m_egammaElectronLHTools[idx]->calculate(context, ele);
            info.valueDecorator[pidname+"LHValue"] = lhvalue;
            ATH_MSG_WARNING("EventInfo decoration not available!");
            info.pidDecorator[pidname] = (bool)m_egammaElectronLHTools[idx]->accept(context, ele);
          }
          timer_lh.stop();
  
          idx++;
        }
       
        // Decorate the info with DNN decision
        ATH_MSG_DEBUG ("Using DNN Tool..");
        idx = 0;
        for ( auto &pidname : m_dnnNames ){
          ATH_MSG_DEBUG("pidname: "<<pidname);
          timer_dnn.start();
          if(eventInfoDecor.isPresent()) {
            float avg_mu = eventInfoDecor(0);
            info.pidDecorator[pidname] = (bool)m_egammaElectronDNNTools[idx]->accept(context, ele,avg_mu);
            ATH_MSG_DEBUG("info.pidDecorator[pidname]: "<<info.pidDecorator[pidname]);
          }else{
            ATH_MSG_WARNING("EventInfo decoration not available!");
            info.pidDecorator[pidname] = (bool)m_egammaElectronDNNTools[idx]->accept(context, ele);
            ATH_MSG_DEBUG("info.pidDecorator[pidname]: "<<info.pidDecorator[pidname]);
          }
          timer_dnn.stop();
          idx++;
        }
 
        // Add track d0 and cluster eta/phi decorations for output electrons
        if (hasDecor) {
          // If the decorations are already there, verify that they
          // match what we would write.
          if (acc_d0(*ele) != ele->trackParticle()->d0() ||
              acc_clEta(*ele) !=  ele->caloCluster()->etaBE(2) ||
              acc_clPhi(*ele) != ele->caloCluster()->phiBE(2))
          {
            ATH_MSG_ERROR( "Decoration mismatch: "
                           << acc_d0(*ele) << "<->" << ele->trackParticle()->d0()
                           << acc_clEta(*ele) << "<->" << ele->caloCluster()->etaBE(2)
                           << acc_clPhi(*ele) << "<->" << ele->caloCluster()->phiBE(2) );
          }
        }
        else {
          decor_d0(*ele) = ele->trackParticle()->d0();
          decor_clEta(*ele) = ele->caloCluster()->etaBE(2);
          decor_clPhi(*ele) = ele->caloCluster()->phiBE(2);
        }
 
        toolInput.push_back( info );
        validelectrons++;
      }
    }
 
    ATH_MSG_DEBUG( "Electrons with valid links: " << validelectrons );
    ATH_MSG_DEBUG( "roi, electron, previous decision to new decision " << counter << " for roi " );
    counter++;
  }
 
 
  ATH_MSG_DEBUG( "Found "<<toolInput.size()<<" inputs to tools");
  for ( auto& tool: m_hypoTools ) {
    ATH_CHECK( tool->decide( toolInput ) );
  }
 
  ATH_CHECK( hypoBaseOutputProcessing(outputHandle) );
  return StatusCode::SUCCESS;
}