ClusterizationAlg.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#include "AthenaMonitoringKernel/Monitored.h"
#include "xAODInDetMeasurement/ContainerAccessor.h"
#include "ActsInterop/TableUtils.h"
#include "AthAllocators/DataPool.h"
 
namespace ActsTrk {
 
template <typename IClusteringTool, bool useCache>
ClusterizationAlg<IClusteringTool, useCache>::ClusterizationAlg(const std::string& name,
                                ISvcLocator* pSvcLocator)
    : AthReentrantAlgorithm(name, pSvcLocator)
{}
 
template <typename IClusteringTool, bool useCache>
StatusCode ClusterizationAlg<IClusteringTool, useCache>::initialize()
{
    ATH_MSG_DEBUG("Initializing " << name() << " ...");
 
    ATH_CHECK(m_rdoContainerKey.initialize());
    ATH_CHECK(m_clusterContainerKey.initialize());
    ATH_CHECK(m_roiCollectionKey.initialize());
 
    ATH_CHECK(m_detEleCollKey.initialize());
    ATH_CHECK(m_detElStatus.initialize());
    
    ATH_CHECK(m_clusteringTool.retrieve());
    ATH_CHECK(m_regionSelector.retrieve());
 
    ATH_CHECK(detStore()->retrieve(m_idHelper, m_idHelperName));
 
    // Monitoring
    ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
 
    //caching
    ATH_CHECK(m_ClusterCache.initialize(useCache));
    ATH_CHECK(m_ClusterCacheBackend.initialize(useCache));
 
    return StatusCode::SUCCESS;
}
 
template <typename IClusteringTool, bool useCache>
StatusCode ClusterizationAlg<IClusteringTool, useCache>::finalize()
{
  ATH_MSG_INFO("Clusterization statistics" << std::endl << makeTable(m_stat,
                                     std::array<std::string, kNStat>{
                                       "RDOs",
                                       "Clusters"
                                     }).columnWidth(10));
  
  return StatusCode::SUCCESS;
}
 
template <typename IClusteringTool, bool useCache>
StatusCode ClusterizationAlg<IClusteringTool, useCache>::execute(const EventContext& ctx) const
{
  auto timer = Monitored::Timer<std::chrono::milliseconds>( "TIME_execute" );
  auto timer_rdoReading = Monitored::Timer<std::chrono::milliseconds>( "TIME_readingRDOs" );
  auto timer_processing = Monitored::Timer<std::chrono::milliseconds>( "TIME_clusterization" );
  auto mon_nclusters = Monitored::Scalar<int>( "NClustersCreated" );
  auto mon = Monitored::Group( m_monTool, timer, timer_rdoReading, timer_processing, mon_nclusters );
    
  timer_rdoReading.start();
  SG::ReadHandle<RDOContainer> rdoContainerHandle = SG::makeHandle(m_rdoContainerKey, ctx);
  ATH_CHECK(rdoContainerHandle.isValid());
  const RDOContainer* rdoContainer = rdoContainerHandle.cptr();
  timer_rdoReading.stop();
 
  SG::ReadHandle<TrigRoiDescriptorCollection> roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
  ATH_CHECK(roiCollectionHandle.isValid());
  const TrigRoiDescriptorCollection *roiCollection = roiCollectionHandle.cptr();
 
  SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_detEleCollKey, ctx );
  ATH_CHECK(detEleHandle.isValid());
  const InDetDD::SiDetectorElementCollection* elements = detEleHandle.cptr();
 
  SG::ReadHandle< InDet::SiDetectorElementStatus > detEleStatusHandle = SG::makeHandle(m_detElStatus, ctx);
  ATH_CHECK(detEleStatusHandle.isValid());
  const InDet::SiDetectorElementStatus* detEleStatus = detEleStatusHandle.cptr();
 
  timer_processing.start();
 
  Cache_WriteHandle cacheHandle;
  if constexpr (useCache) {
    cacheHandle = Cache_WriteHandle(m_ClusterCache, ctx);
    auto updateHandle = Cache_BackendUpdateHandle(m_ClusterCacheBackend, ctx);
    ATH_CHECK(updateHandle.isValid());
    ATH_CHECK(cacheHandle.record(std::make_unique<Cache_IDC>(updateHandle.ptr())));
    ATH_CHECK(cacheHandle.isValid());
  }
 
  // count number of elements and store some collections
  std::vector<IdentifierHash> listOfIds;
  listOfIds.reserve(elements->size());
 
  std::vector<bool> toBeProcessedIds(elements->size(), false);
 
  std::vector<Cache_IDCLock> idclocks;
 
  unsigned int n_rdos_total=0u;
  unsigned int n_cluster_total=0u;
  unsigned int n_modules=0u;
  // numbers not double counting corrected.
  // So, in case of large overlap of ROIs, will overallocate
  // the temporary cluster collection
  for (const auto* roi : *roiCollection) {
     // get list of ids
     listOfIds.clear();
     m_regionSelector->lookup(ctx)->HashIDList(*roi, listOfIds);
     auto [roi_n_cluster, roi_n_rdos] = m_clusteringTool->countCells(*rdoContainer, listOfIds,*elements );
     n_cluster_total += roi_n_cluster;
     n_rdos_total += roi_n_rdos;
     n_modules += listOfIds.size();
  }
 
  typename IClusteringTool::CellContainer cellContainer(n_modules, n_cluster_total, n_rdos_total);
 
  // loop on ROIs
  unsigned int nRDOs = 0u;
  std::size_t nClusters = 0ul;
  // if the roiCollection is larger than one than listOfIds does not contain the correct
  // HashIDList and the lists have to be requested again.
  bool request_id_list_again = roiCollection->size()!=1;
  for (const auto* roi : *roiCollection) {
    // get list of ids
    // if the roi collection contains a single element listOfIds
    // already contains the result
    if (request_id_list_again) {
       listOfIds.clear();
       m_regionSelector->lookup(ctx)->HashIDList(*roi, listOfIds);
    }
 
    // loop on IDs
    for (const IdentifierHash& id : listOfIds) {      
      if (not id.is_valid()) {
    ATH_MSG_ERROR("Id hash is not valid: " << id);
    return StatusCode::FAILURE;
      }
      
      // check if already considered
      if (toBeProcessedIds[id]) continue;
      toBeProcessedIds[id] = true;
 
      Cache_IDCLock cache_wh;
      if constexpr (useCache) {
    //obtain a write handle
    auto tmp = cacheHandle->getWriteHandle(id);
    Cache_IDCLock::Swap(cache_wh, tmp);
    //check if already available
    if(cache_wh.OnlineAndPresentInAnotherView()) continue;
      }
 
      const InDetDD::SiDetectorElement* element = elements->getDetectorElement(id);
      if (not element) {
    ATH_MSG_ERROR("Cannot retrieve Detector Element for id hash: " << id);
    return StatusCode::FAILURE;
      }          
 
      // unpack RDOs and store them
      const RawDataCollection* rdos = rdoContainer->indexFindPtr(id);
      if (not rdos or rdos->empty()) {
    continue;
      }
 
      if constexpr (useCache) {
    idclocks.push_back( std::move(cache_wh) );
      }
      // make ACTS clusters
      ATH_CHECK( m_clusteringTool->clusterize(ctx,
                          *rdos,
                          *detEleStatus,
                          *element,
                          cellContainer) );
      nRDOs+=rdos->size();
      nClusters += cellContainer.m_moduleClusterRange.back().nClusters();
    } // loop on IDs
  } // loop on ROIs
 
  mon_nclusters = nClusters;
  
  SG::WriteHandle<ClusterContainer> clusterHandle = SG::makeHandle(m_clusterContainerKey, ctx);
  ATH_CHECK(clusterHandle.record( std::make_unique<ClusterContainer>(SG::VIEW_ELEMENTS, SG::ALWAYS_TRACK_INDICES),
                  std::make_unique<ClusterAuxContainer>() ));
  ClusterContainer *clusterContainer = clusterHandle.ptr();
 
  using xAODCluster_t = typename ClusterContainer::base_value_type;
  DataPool<xAODCluster_t> pool (nClusters);
  clusterContainer->push_new(nClusters, [&pool]() {return pool.nextElementPtr();});
 
  std::any cache = m_clusteringTool->createEventDataCache (*clusterHandle,cellContainer.nCellsTotal());
 
  // Fill the collection to xAOD format, computing necessary quantities
  std::size_t xaodCounter = 0ul;
  for (std::size_t i(0); i<cellContainer.size(); ++i) {
    const InDetDD::SiDetectorElement* element = elements->getDetectorElement(cellContainer.moduleClusterRange(i).idHash);
 
    ATH_CHECK( m_clusteringTool->makeClusters(ctx,
                                              *rdoContainer,
                                              cellContainer,
                                              i,
                          *element,
                                              xaodCounter,
                                              *clusterContainer,
                                              cache) );
    assert( i < cellContainer.nModules() ) ;
    unsigned int n_new_clusters=cellContainer.moduleClusterRange(i).nClusters();
    if constexpr (useCache) {
      ATH_CHECK(Cache::Helper<BaseClusterType>::insert(idclocks[i],
                               clusterContainer,
                               xaodCounter,
                               xaodCounter + n_new_clusters));
    }
    xaodCounter+=n_new_clusters;
  }
 
  m_stat[kNRdo] += nRDOs;
  m_stat[kNClusters] += clusterContainer->size();
  ATH_MSG_DEBUG("Clusters produced size: "<<clusterContainer->size());
  timer_processing.stop();
  return StatusCode::SUCCESS;
}
  
} // namespace ActsTrk