ATLAS Offline Software
ClusterizationAlg.icc
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "AthenaMonitoringKernel/Monitored.h"
6 #include "xAODInDetMeasurement/ContainerAccessor.h"
7 #include "ActsInterop/TableUtils.h"
8 
9 namespace ActsTrk {
10 
11 template <typename IClusteringTool, bool useCache>
12 ClusterizationAlg<IClusteringTool, useCache>::ClusterizationAlg(const std::string& name,
13  ISvcLocator* pSvcLocator)
14  : AthReentrantAlgorithm(name, pSvcLocator)
15 {}
16 
17 template <typename IClusteringTool, bool useCache>
18 StatusCode ClusterizationAlg<IClusteringTool, useCache>::initialize()
19 {
20  ATH_MSG_DEBUG("Initializing " << name() << " ...");
21 
22  ATH_CHECK(m_rdoContainerKey.initialize());
23  ATH_CHECK(m_clusterContainerKey.initialize());
24  ATH_CHECK(m_roiCollectionKey.initialize());
25 
26  ATH_CHECK(m_detEleCollKey.initialize());
27  ATH_CHECK(m_detElStatus.initialize());
28 
29  ATH_CHECK(m_clusteringTool.retrieve());
30  ATH_CHECK(m_regionSelector.retrieve());
31 
32  ATH_CHECK(detStore()->retrieve(m_idHelper, m_idHelperName));
33 
34  // Monitoring
35  ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
36 
37  //caching
38  ATH_CHECK(m_ClusterCache.initialize(useCache));
39  ATH_CHECK(m_ClusterCacheBackend.initialize(useCache));
40 
41  return StatusCode::SUCCESS;
42 }
43 
44 template <typename IClusteringTool, bool useCache>
45 StatusCode ClusterizationAlg<IClusteringTool, useCache>::finalize()
46 {
47  ATH_MSG_INFO("Clusterization statistics" << std::endl << makeTable(m_stat,
48  std::array<std::string, kNStat>{
49  "RDOs",
50  "Clusters"
51  }).columnWidth(10));
52 
53  return StatusCode::SUCCESS;
54 }
55 
56 template <typename IClusteringTool, bool useCache>
57 StatusCode ClusterizationAlg<IClusteringTool, useCache>::execute(const EventContext& ctx) const
58 {
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 );
62 
63  SG::ReadHandle<RDOContainer> rdoContainerHandle = SG::makeHandle(m_rdoContainerKey, ctx);
64  ATH_CHECK(rdoContainerHandle.isValid());
65  const RDOContainer* rdoContainer = rdoContainerHandle.cptr();
66 
67  SG::ReadHandle<TrigRoiDescriptorCollection> roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
68  ATH_CHECK(roiCollectionHandle.isValid());
69  const TrigRoiDescriptorCollection *roiCollection = roiCollectionHandle.cptr();
70 
71  SG::ReadCondHandle< InDetDD::SiDetectorElementCollection > detEleHandle = SG::makeHandle( m_detEleCollKey, ctx );
72  ATH_CHECK(detEleHandle.isValid());
73  const InDetDD::SiDetectorElementCollection* elements = detEleHandle.cptr();
74 
75  SG::ReadHandle< InDet::SiDetectorElementStatus > detEleStatusHandle = SG::makeHandle(m_detElStatus, ctx);
76  ATH_CHECK(detEleStatusHandle.isValid());
77  const InDet::SiDetectorElementStatus* detEleStatus = detEleStatusHandle.cptr();
78 
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());
86  }
87 
88  // count number of elements and store some collections
89  std::vector<IdentifierHash> listOfIds;
90  listOfIds.reserve(elements->size());
91 
92  std::vector<bool> toBeProcessedIds(elements->size(), false);
93 
94  std::vector<const InDetDD::SiDetectorElement*> processedElements {};
95  processedElements.reserve(elements->size());
96  std::vector<typename IClusteringTool::ClusterCollection> clusterCollection {};
97  clusterCollection.reserve(elements->size());
98 
99  std::vector<Cache_IDCLock> idclocks;
100 
101  // loop on ROIs
102  std::size_t nClusters = 0ul;
103  for (const auto* roi : *roiCollection) {
104  // get list of ids
105  listOfIds.clear();
106  m_regionSelector->lookup(ctx)->HashIDList(*roi, listOfIds);
107 
108  // loop on IDs
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;
113  }
114 
115  // check if already considered
116  if (toBeProcessedIds[id]) continue;
117  toBeProcessedIds[id] = true;
118 
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;
126  }
127 
128  const InDetDD::SiDetectorElement* element = elements->getDetectorElement(id);
129  if (not element) {
130  ATH_MSG_ERROR("Cannot retrieve Detector Element for id hash: " << id);
131  return StatusCode::FAILURE;
132  }
133 
134  // unpack RDOs and store them
135  const RawDataCollection* rdos = rdoContainer->indexFindPtr(id);
136  if (not rdos or rdos->empty()) {
137  continue;
138  }
139 
140  if constexpr (useCache) {
141  idclocks.push_back( std::move(cache_wh) );
142  }
143 
144  m_stat[kNRdo] += rdos->size();
145  // make ACTS clusters
146  ATH_CHECK( m_clusteringTool->clusterize(ctx,
147  *rdos,
148  *detEleStatus,
149  *element,
150  clusterCollection) );
151  processedElements.push_back( element );
152  nClusters += clusterCollection.back().size();
153  } // loop on IDs
154  } // loop on ROIs
155 
156  mon_nclusters = nClusters;
157 
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();
162 
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());
172 
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];
179 
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;
184  }
185 
186  ATH_CHECK( m_clusteringTool->makeClusters(ctx,
187  actsClusters,
188  *element,
189  itr) );
190 
191  if constexpr (useCache) {
192  // add to the cache
193  ATH_CHECK(Cache::Helper<BaseClusterType>::insert(idclocks[i],
194  clusterContainer,
195  xaodCounter,
196  xaodCounter + actsClusters.size()));
197  }
198 
199  xaodCounter += actsClusters.size();
200  }
201 
202  m_stat[kNClusters] += clusterContainer->size();
203  ATH_MSG_DEBUG("Clusters produced size: "<<clusterContainer->size());
204  return StatusCode::SUCCESS;
205 }
206 
207 } // namespace ActsTrk