2 Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
5 #include "AthenaMonitoringKernel/Monitored.h"
6 #include "xAODInDetMeasurement/ContainerAccessor.h"
7 #include "ActsInterop/TableUtils.h"
11 template <typename IClusteringTool, bool useCache>
12 ClusterizationAlg<IClusteringTool, useCache>::ClusterizationAlg(const std::string& name,
13 ISvcLocator* pSvcLocator)
14 : AthReentrantAlgorithm(name, pSvcLocator)
17 template <typename IClusteringTool, bool useCache>
18 StatusCode ClusterizationAlg<IClusteringTool, useCache>::initialize()
20 ATH_MSG_DEBUG("Initializing " << name() << " ...");
22 ATH_CHECK(m_rdoContainerKey.initialize());
23 ATH_CHECK(m_clusterContainerKey.initialize());
24 ATH_CHECK(m_roiCollectionKey.initialize());
26 ATH_CHECK(m_detEleCollKey.initialize());
27 ATH_CHECK(m_detElStatus.initialize());
29 ATH_CHECK(m_clusteringTool.retrieve());
30 ATH_CHECK(m_regionSelector.retrieve());
32 ATH_CHECK(detStore()->retrieve(m_idHelper, m_idHelperName));
35 ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
38 ATH_CHECK(m_ClusterCache.initialize(useCache));
39 ATH_CHECK(m_ClusterCacheBackend.initialize(useCache));
41 return StatusCode::SUCCESS;
44 template <typename IClusteringTool, bool useCache>
45 StatusCode ClusterizationAlg<IClusteringTool, useCache>::finalize()
47 ATH_MSG_INFO("Clusterization statistics" << std::endl << makeTable(m_stat,
48 std::array<std::string, kNStat>{
53 return StatusCode::SUCCESS;
56 template <typename IClusteringTool, bool useCache>
57 StatusCode ClusterizationAlg<IClusteringTool, useCache>::execute(const EventContext& ctx) const
59 auto timer = Monitored::Timer<std::chrono::milliseconds>( "TIME_execute" );
60 auto mon_nclusters = Monitored::Scalar<int>("NClustersCreated");
61 auto mon = Monitored::Group( m_monTool, timer, mon_nclusters );
63 SG::ReadHandle<RDOContainer> rdoContainerHandle = SG::makeHandle(m_rdoContainerKey, ctx);
64 ATH_CHECK(rdoContainerHandle.isValid());
65 const RDOContainer* rdoContainer = rdoContainerHandle.cptr();
67 SG::ReadHandle<TrigRoiDescriptorCollection> roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
68 ATH_CHECK(roiCollectionHandle.isValid());
69 const TrigRoiDescriptorCollection *roiCollection = roiCollectionHandle.cptr();
71 SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_detEleCollKey, ctx );
72 ATH_CHECK(detEleHandle.isValid());
73 const InDetDD::SiDetectorElementCollection* elements = detEleHandle.cptr();
75 SG::ReadHandle< InDet::SiDetectorElementStatus > detEleStatusHandle = SG::makeHandle(m_detElStatus, ctx);
76 ATH_CHECK(detEleStatusHandle.isValid());
77 const InDet::SiDetectorElementStatus* detEleStatus = detEleStatusHandle.cptr();
79 Cache_WriteHandle cacheHandle;
80 if constexpr (useCache) {
81 cacheHandle = Cache_WriteHandle(m_ClusterCache, ctx);
82 auto updateHandle = Cache_BackendUpdateHandle(m_ClusterCacheBackend, ctx);
83 ATH_CHECK(updateHandle.isValid());
84 ATH_CHECK(cacheHandle.record(std::make_unique<Cache_IDC>(updateHandle.ptr())));
85 ATH_CHECK(cacheHandle.isValid());
88 // count number of elements and store some collections
89 std::vector<IdentifierHash> listOfIds;
90 listOfIds.reserve(elements->size());
92 std::vector<bool> toBeProcessedIds(elements->size(), false);
94 std::vector<const InDetDD::SiDetectorElement*> processedElements {};
95 processedElements.reserve(elements->size());
96 std::vector<typename IClusteringTool::ClusterCollection> clusterCollection {};
97 clusterCollection.reserve(elements->size());
99 std::vector<Cache_IDCLock> idclocks;
102 std::size_t nClusters = 0ul;
103 for (const auto* roi : *roiCollection) {
106 m_regionSelector->lookup(ctx)->HashIDList(*roi, listOfIds);
109 for (const IdentifierHash& id : listOfIds) {
110 if (not id.is_valid()) {
111 ATH_MSG_ERROR("Id hash is not valid: " << id);
112 return StatusCode::FAILURE;
115 // check if already considered
116 if (toBeProcessedIds[id]) continue;
117 toBeProcessedIds[id] = true;
119 Cache_IDCLock cache_wh;
120 if constexpr (useCache) {
121 //obtain a write handle
122 auto tmp = cacheHandle->getWriteHandle(id);
123 Cache_IDCLock::Swap(cache_wh, tmp);
124 //check if already available
125 if(cache_wh.OnlineAndPresentInAnotherView()) continue;
128 const InDetDD::SiDetectorElement* element = elements->getDetectorElement(id);
130 ATH_MSG_ERROR("Cannot retrieve Detector Element for id hash: " << id);
131 return StatusCode::FAILURE;
134 // unpack RDOs and store them
135 const RawDataCollection* rdos = rdoContainer->indexFindPtr(id);
136 if (not rdos or rdos->empty()) {
140 if constexpr (useCache) {
141 idclocks.push_back( std::move(cache_wh) );
144 m_stat[kNRdo] += rdos->size();
145 // make ACTS clusters
146 ATH_CHECK( m_clusteringTool->clusterize(ctx,
150 clusterCollection) );
151 processedElements.push_back( element );
152 nClusters += clusterCollection.back().size();
156 mon_nclusters = nClusters;
158 SG::WriteHandle<ClusterContainer> clusterHandle = SG::makeHandle(m_clusterContainerKey, ctx);
159 ATH_CHECK(clusterHandle.record( std::make_unique<ClusterContainer>(),
160 std::make_unique<ClusterAuxContainer>() ));
161 ClusterContainer *clusterContainer = clusterHandle.ptr();
163 // Fast Insertion of N elements
164 using xAODCluster_t = typename ClusterContainer::base_value_type;
165 std::vector<xAODCluster_t*> toAddCollection;
166 toAddCollection.reserve(nClusters);
167 for (std::size_t i(0); i<nClusters; ++i)
168 toAddCollection.push_back(new xAODCluster_t());
169 clusterContainer->insert(clusterContainer->end(),
170 toAddCollection.begin(),
171 toAddCollection.end());
173 // Fill the collection to xAOD format, computing necessary quantities
174 std::size_t xaodCounter = 0ul;
175 typename ClusterContainer::iterator finalElement = clusterContainer->end();
176 for (std::size_t i(0); i<clusterCollection.size(); ++i) {
177 const InDetDD::SiDetectorElement* element = processedElements[i];
178 typename IClusteringTool::ClusterCollection& actsClusters = clusterCollection[i];
180 typename ClusterContainer::iterator itr = clusterContainer->begin() + xaodCounter;
181 if ( std::distance(itr, finalElement) < static_cast<long int>(actsClusters.size()) ) {
182 ATH_MSG_ERROR("Inconsistent size of clusters");
183 return StatusCode::FAILURE;
186 ATH_CHECK( m_clusteringTool->makeClusters(ctx,
191 if constexpr (useCache) {
193 ATH_CHECK(Cache::Helper<BaseClusterType>::insert(idclocks[i],
196 xaodCounter + actsClusters.size()));
199 xaodCounter += actsClusters.size();
202 m_stat[kNClusters] += clusterContainer->size();
203 ATH_MSG_DEBUG("Clusters produced size: "<<clusterContainer->size());
204 return StatusCode::SUCCESS;
207 } // namespace ActsTrk