PFAlgorithm.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#include "PFAlgorithm.h"
#include "xAODCaloEvent/CaloClusterAuxContainer.h"
#include "PFClusterFiller.h"
#include "PFTrackFiller.h"
 
PFAlgorithm::PFAlgorithm(const std::string& name, ISvcLocator* pSvcLocator)
  : AthReentrantAlgorithm(name, pSvcLocator)
  , m_IPFSubtractionTools(this)
  , m_IPFBaseTools(this)
  , m_IPFUnifiedBaseTools(this)
{
  declareProperty("SubtractionToolList", m_IPFSubtractionTools, "List of Private Subtraction IPFSubtractionTools");
  declareProperty("BaseToolList", m_IPFBaseTools, "List of Private IPFBaseTools");
  declareProperty("UnifiedBaseTools", m_IPFUnifiedBaseTools, "List of Private IPFUnifiedBaseTools");
}
 
StatusCode PFAlgorithm::initialize(){
 
  ATH_CHECK(m_IPFClusterSelectorTool);
  ATH_CHECK(m_IPFSubtractionTools.retrieve());
  ATH_CHECK(m_IPFBaseTools.retrieve());
  ATH_CHECK(m_IPFUnifiedBaseTools.retrieve());
  
  ATH_CHECK(m_eflowRecTracksReadHandleKey.initialize());
 
  ATH_CHECK(m_eflowRecClustersWriteHandleKey.initialize());
  ATH_CHECK(m_eflowCaloObjectsWriteHandleKey.initialize());
  ATH_CHECK(m_caloClustersWriteHandleKey.initialize());
 
  if (!m_monTool.empty()) ATH_CHECK(m_monTool.retrieve());
 
  printTools();
 
  return StatusCode::SUCCESS;
}
 
StatusCode PFAlgorithm::execute(const EventContext& ctx) const{
  // Define monitored quantities
  auto t_exec = Monitored::Timer<std::chrono::milliseconds>( "TIME_execute" );
    Monitored::ScopedTimer execution_time(t_exec); 
  auto t_subtract = Monitored::Timer<std::chrono::milliseconds>( "TIME_subtract" );
  auto N_efrClusters = Monitored::Scalar( "N_efrClusters", 0 );
 
  ATH_MSG_DEBUG("Executing");
 
  SG::WriteHandle<eflowCaloObjectContainer> eflowCaloObjectsWriteHandle(m_eflowCaloObjectsWriteHandleKey, ctx);
  ATH_CHECK(eflowCaloObjectsWriteHandle.record(std::make_unique<eflowCaloObjectContainer>()));
  eflowCaloObjectContainer* theElowCaloObjectContainer = eflowCaloObjectsWriteHandle.ptr();
 
  SG::WriteHandle<xAOD::CaloClusterContainer> caloClustersWriteHandle(m_caloClustersWriteHandleKey, ctx);
  ATH_CHECK(caloClustersWriteHandle.record(std::make_unique<xAOD::CaloClusterContainer>(),
                                           std::make_unique<xAOD::CaloClusterAuxContainer>()));
  ATH_MSG_DEBUG("CaloClusterWriteHandle has container of size" << caloClustersWriteHandle->size());
 
  SG::ReadHandle<eflowRecTrackContainer> eflowRecTracksReadHandle(m_eflowRecTracksReadHandleKey, ctx);
  eflowRecTrackContainer localEFlowRecTrackContainer(*eflowRecTracksReadHandle.ptr());
 
  /* Record the eflowRecCluster output container */
  SG::WriteHandle<eflowRecClusterContainer> eflowRecClustersWriteHandle(m_eflowRecClustersWriteHandleKey, ctx);
  ATH_CHECK(eflowRecClustersWriteHandle.record(std::make_unique<eflowRecClusterContainer>()));
  eflowRecClusterContainer& theEFlowRecClusterContainerReference = *(eflowRecClustersWriteHandle.ptr());
 
  xAOD::CaloClusterContainer& theCaloClusterContainerReference = *(caloClustersWriteHandle.ptr());
  ATH_CHECK(m_IPFClusterSelectorTool->execute(theEFlowRecClusterContainerReference, theCaloClusterContainerReference));
 
  // Explicitly start/stop the timer around the subtraction tool calls
  t_subtract.start();
  /* Run the SubtractionTools */
 
  if (m_useUnified){
    PFData data;
    data.caloObjects = theElowCaloObjectContainer;
 
    PFTrackFiller::fillTracksToConsider(data, localEFlowRecTrackContainer);
 
    PFClusterFiller::fillClustersToConsider(data, theEFlowRecClusterContainerReference);
 
    for (const auto& thisIPFUnifiedBaseTool : m_IPFUnifiedBaseTools){
      ATH_CHECK(thisIPFUnifiedBaseTool->processPFlowData(ctx, data));
    }
  }
  
  else{
    for (auto thisIPFSubtractionTool : m_IPFSubtractionTools){
      thisIPFSubtractionTool->execute(
        ctx,
        theElowCaloObjectContainer,
        &localEFlowRecTrackContainer,
        &theEFlowRecClusterContainerReference);
    }
    t_subtract.stop();
 
    if (msgLvl(MSG::DEBUG)) {
      for (auto thisEFTrack : localEFlowRecTrackContainer) {
        msg() << "This efRecTrack has E,pt,eta and phi of " << thisEFTrack->getTrack()->e() << ", "
              << thisEFTrack->getTrack()->pt() << ", " << thisEFTrack->getTrack()->eta() << " and "
              << thisEFTrack->getTrack()->phi() << endmsg;
      }
 
      for (auto thisEFCluster : *(eflowRecClustersWriteHandle.ptr())) {
        msg() << "This efRecCluster has E,pt,eta and phi of " << thisEFCluster->getCluster()->e() << ","
              << thisEFCluster->getCluster()->pt() << ", " << thisEFCluster->getCluster()->eta() << " and "
              << thisEFCluster->getCluster()->phi() << endmsg;
      }
    }
 
    N_efrClusters = theEFlowRecClusterContainerReference.size();
 
    /* Run the other AglTools */
    for (auto thisIPFBaseTool :  m_IPFBaseTools){
      ATH_CHECK(thisIPFBaseTool->execute(ctx, *theElowCaloObjectContainer));
    }
  }
 
  auto mon = Monitored::Group(m_monTool, t_exec, t_subtract, N_efrClusters);
  return StatusCode::SUCCESS;
}
 
StatusCode PFAlgorithm::finalize(){ return StatusCode::SUCCESS;}
 
void PFAlgorithm::printTools() {
  ATH_MSG_VERBOSE(" ");
  ATH_MSG_VERBOSE("List of IPFSubtraction tools in execution sequence:");
  ATH_MSG_VERBOSE("------------------------------------");
  ATH_MSG_VERBOSE(" ");
  unsigned int subtractionToolCtr = 0;
  for (auto thisIPFSubtractionTool : m_IPFSubtractionTools){
    subtractionToolCtr++;
    ATH_MSG_VERBOSE(std::setw(2) << std::setiosflags(std::ios_base::right) << subtractionToolCtr << ".) "
            << std::resetiosflags(std::ios_base::right) << std::setw(36) << std::setfill('.')
            << std::setiosflags(std::ios_base::left) << thisIPFSubtractionTool->type() << std::setfill('.')
                    << thisIPFSubtractionTool->name() << std::setfill(' '));
  }  
  ATH_MSG_VERBOSE(" ");
  ATH_MSG_VERBOSE("------------------------------------");
 
  ATH_MSG_VERBOSE(" ");
  ATH_MSG_VERBOSE("List of IPFBase tools in execution sequence:");
  ATH_MSG_VERBOSE("------------------------------------");
  ATH_MSG_VERBOSE(" ");
  unsigned int baseToolCtr = 0;
  for (auto thisIPFBaseTool : m_IPFBaseTools){
    baseToolCtr++;
    ATH_MSG_VERBOSE(std::setw(2) << std::setiosflags(std::ios_base::right) << baseToolCtr << ".) "
            << std::resetiosflags(std::ios_base::right) << std::setw(36) << std::setfill('.')
            << std::setiosflags(std::ios_base::left) << thisIPFBaseTool->type() << std::setfill('.')
                    << thisIPFBaseTool->name() << std::setfill(' '));
  }  
  ATH_MSG_VERBOSE(" ");
  ATH_MSG_VERBOSE("------------------------------------");
  
  
}