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<const InDetDD::SiDetectorElement*> processedElements {};
  processedElements.reserve(elements->size());
  std::vector<typename IClusteringTool::ClusterCollection> clusterCollection {};
  clusterCollection.reserve(elements->size());
 
  std::vector<Cache_IDCLock> idclocks;
 
  Acts::Ccl::ClusteringData data;
  
  // loop on ROIs
  std::size_t nClusters = 0ul;
  for (const auto* roi : *roiCollection) {
    // get list of ids
    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) );
      }
      
      m_stat[kNRdo] += rdos->size();
      // make ACTS clusters
      ATH_CHECK( m_clusteringTool->clusterize(ctx,
                          *rdos,
                          *detEleStatus,
                          *element,
                data,
                          clusterCollection) );
      processedElements.push_back( element );
      nClusters += clusterCollection.back().size();
    } // 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();});
 
  // Fill the collection to xAOD format, computing necessary quantities
  std::size_t xaodCounter = 0ul;
  typename ClusterContainer::iterator finalElement = clusterContainer->end();
  for (std::size_t i(0); i<clusterCollection.size(); ++i) {
    const InDetDD::SiDetectorElement* element = processedElements[i];
    typename IClusteringTool::ClusterCollection& actsClusters = clusterCollection[i];
 
    typename ClusterContainer::iterator itr = clusterContainer->begin() + xaodCounter;
    if ( std::distance(itr, finalElement) < static_cast<long int>(actsClusters.size()) ) {
      ATH_MSG_ERROR("Inconsistent size of clusters");
      return StatusCode::FAILURE;
    }
 
    ATH_CHECK( m_clusteringTool->makeClusters(ctx,
                          actsClusters,
                          *element,
                          itr) );
    
    if constexpr (useCache) {
      // add to the cache
      ATH_CHECK(Cache::Helper<BaseClusterType>::insert(idclocks[i],
                               clusterContainer,
                               xaodCounter,
                               xaodCounter + actsClusters.size()));
    }
 
    xaodCounter += actsClusters.size();
  }
 
  m_stat[kNClusters] += clusterContainer->size();
  ATH_MSG_DEBUG("Clusters produced size: "<<clusterContainer->size());
  timer_processing.stop();
  return StatusCode::SUCCESS;
}
  
} // namespace ActsTrk