PadClusterizationAlg.cxx

Go to the documentation of this file.

 
#include "PadClusterizationAlg.h"
 
#include "HGTD_Identifier/HGTD_ID.h"
#include "StoreGate/WriteHandle.h"
#include "AthenaMonitoringKernel/Monitored.h"
 
namespace HGTD {
 
PadClusterizationAlg::PadClusterizationAlg(const std::string& name,
                                           ISvcLocator* pSvcLocator)
    : AthReentrantAlgorithm(name, pSvcLocator) {}
 
StatusCode PadClusterizationAlg::initialize() {
 
  ATH_CHECK(m_clusterization_tool.retrieve());
 
  ATH_CHECK(m_rdo_rh_key.initialize());
  ATH_CHECK(m_prd_wh_key.initialize());
 
  ATH_CHECK(detStore()->retrieve(m_hgtd_idhelper, "HGTD_ID"));
  ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
  
  return StatusCode::SUCCESS;
}
 
StatusCode PadClusterizationAlg::execute(const EventContext& ctx) const {
  auto timer = Monitored::Timer<std::chrono::milliseconds>( "TIME_execute" );
  auto mon = Monitored::Group( m_monTool, timer );
 
  // retrieve the RDOs
  SG::ReadHandle<HGTD_RDO_Container> rdo_container_handle(m_rdo_rh_key, ctx);
 
  const HGTD_RDO_Container* rdo_container = rdo_container_handle.cptr();
 
  if (not rdo_container) {
    //assume this is fast digi input and ignore
    return StatusCode::SUCCESS;
  }
 
  // register the PRD container in storegate
  SG::WriteHandle<HGTD_ClusterContainer> prd_container_handle(
      m_prd_wh_key, ctx);
 
  ATH_CHECK(
      prd_container_handle.record(std::make_unique<HGTD_ClusterContainer>(
          m_hgtd_idhelper->wafer_hash_max())));
 
  HGTD_ClusterContainer* locp_prd_container = prd_container_handle.ptr();
 
   std::unique_ptr<DataPool<HGTD_Cluster>> dataItemsPool = nullptr;
   const bool hasExternalCache = rdo_container->hasExternalCache();
    if (!hasExternalCache) {
      dataItemsPool = std::make_unique<DataPool<HGTD_Cluster>>(ctx);
      dataItemsPool->reserve(10000);  // Some large default size
    }
 
 
  // Transform the RDOs collection by collection
  for (const auto rdo_collection : *rdo_container) {
    if (rdo_collection->empty()) {
      continue;
    }
 
    std::unique_ptr<HGTD_ClusterCollection> prd_collection =
        m_clusterization_tool->clusterize(*rdo_collection,dataItemsPool.get());
 
    // can happen if some channels are masked, not really relevant currently
    if (prd_collection->empty()) {
      continue;
    }
    const IdentifierHash identifyHash{prd_collection->identifyHash()};
    if (locp_prd_container
            ->addCollection(prd_collection.release(),identifyHash)
            .isFailure()) {
      ATH_MSG_WARNING("Could not add ClusterCollection to container!");
    }
  } // END LOOP over container
 
  return StatusCode::SUCCESS;
}
 
} // namespace HGTD