ATLAS Offline Software
PixelClustering.cxx
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3  */
4 
5 #include "EFTrackingFPGAPipeline/PixelClustering.h"
6 
7 #include "EFTrackingFPGAUtility/EFTrackingTransient.h"
8 
9 #include <fstream>
10 #include <CL/cl_ext.h>
11 
12 #define OCL_CHECK(err, call) \
13  call; \
14  if (err != 0) { \
15  ATH_MSG_DEBUG("Error calling " << #call << ", error code: " << err); \
16  }
17 
18 StatusCode PixelClustering::initialize()
19 {
20  ATH_CHECK(m_pixelRDOKey.initialize());
21 
22  ATH_CHECK(m_FPGADataFormatTool.retrieve());
23  ATH_CHECK(m_xAODClusterMaker.retrieve());
24 
25  ATH_CHECK(IntegrationBase::precheck({m_xclbin, m_kernelName, m_inputTV, m_refTV}));
26  ATH_CHECK(IntegrationBase::initialize());
27  ATH_CHECK(IntegrationBase::loadProgram(m_xclbin));
28 
29  return StatusCode::SUCCESS;
30 }
31 
32 StatusCode PixelClustering::execute(const EventContext &ctx) const
33 {
34  ATH_MSG_DEBUG("In execute(), event slot: " << ctx.slot());
35 
36  auto pixelRDOHandle = SG::makeHandle(m_pixelRDOKey, ctx);
37 
38  std::vector<uint64_t> inbufPixClustVec;
39  std::vector<IdentifierHash> listOfIds;
40  if(!m_FPGADataFormatTool->convertPixelHitsToFPGADataFormat(*pixelRDOHandle, inbufPixClustVec, listOfIds, ctx)) {
41  return StatusCode::FAILURE;
42  }
43 
44  unsigned int inbufPixClustSize = inbufPixClustVec.size();
45 
46  cl_int err;
47 
48  cl::CommandQueue queuePixClust{};
49  OCL_CHECK(err, queuePixClust = cl::CommandQueue(m_context, m_accelerator, CL_QUEUE_PROFILING_ENABLE, &err));
50 
51  cl::Kernel kernelPixClust{};
52  OCL_CHECK(err, kernelPixClust = cl::Kernel(m_program, "pixel_clustering_tool", &err));
53 
54  cl::Buffer clInbufPixClust{};
55  std::unique_ptr<uint64_t, decltype(std::free) *> inbufPixClust(static_cast<uint64_t*>(aligned_alloc(64, sizeof(uint64_t) * inbufPixClustSize)), std::free);
56  for (unsigned int i = 0; i < inbufPixClustSize; ++i) {
57  inbufPixClust.get()[i] = inbufPixClustVec.at(i);
58  ATH_MSG_DEBUG("inbufPixClust[" << std::setw(6) << i << "] = 0x" << std::hex << std::setfill('0') << std::setw(16) << inbufPixClust.get()[i] << std::setfill(' ') << std::dec);
59  }
60  // Clean inbufPixClustVec to save memory
61  inbufPixClustVec.resize(1);
62  inbufPixClustVec.clear();
63  OCL_CHECK(err, clInbufPixClust = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY, sizeof(uint64_t) * inbufPixClustSize, inbufPixClust.get(), &err));
64  OCL_CHECK(err, err = kernelPixClust.setArg(0, clInbufPixClust));
65  cl::Buffer clOutbufPixClust{};
66  unsigned int outbufPixClustSize = inbufPixClustSize + 9164 + 6;
67  std::unique_ptr<uint64_t, decltype(std::free) *> outbufPixClust(static_cast<uint64_t*>(aligned_alloc(64, sizeof(uint64_t) * outbufPixClustSize)), std::free);
68  OCL_CHECK(err, clOutbufPixClust = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_WRITE_ONLY, sizeof(uint64_t) * outbufPixClustSize, outbufPixClust.get(), &err));
69  OCL_CHECK(err, err = kernelPixClust.setArg(1, clOutbufPixClust));
70  cl::Buffer clOutbufEDMPixClust{};
71  unsigned int outbufEDMPixClustSize = inbufPixClustSize * 10 + 6;
72  std::unique_ptr<uint64_t, decltype(std::free) *> outbufEDMPixClust(static_cast<uint64_t*>(aligned_alloc(64, sizeof(uint64_t) * outbufEDMPixClustSize)), std::free);
73  OCL_CHECK(err, clOutbufEDMPixClust = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_WRITE_ONLY, sizeof(uint64_t) * outbufEDMPixClustSize, outbufEDMPixClust.get(), &err));
74  OCL_CHECK(err, err = kernelPixClust.setArg(2, clOutbufEDMPixClust));
75 
76  ATH_MSG_INFO("Making clusters out of " << inbufPixClustSize - 6 << " channels over threshold");
77  // Write data to accelerator
78  auto write_start = std::chrono::high_resolution_clock::now();
79  OCL_CHECK(err, err = queuePixClust.enqueueMigrateMemObjects({clInbufPixClust}, 0));
80  OCL_CHECK(err, err = queuePixClust.finish());
81  auto write_end = std::chrono::high_resolution_clock::now();
82 
83  // Run algorithm on accelerator
84  OCL_CHECK(err, err = queuePixClust.enqueueTask(kernelPixClust));
85  OCL_CHECK(err, err = queuePixClust.finish());
86  auto compute_end = std::chrono::high_resolution_clock::now();
87 
88  // Read back result
89  OCL_CHECK(err, err = queuePixClust.enqueueMigrateMemObjects({clOutbufPixClust}, CL_MIGRATE_MEM_OBJECT_HOST));
90  OCL_CHECK(err, err = queuePixClust.enqueueMigrateMemObjects({clOutbufEDMPixClust}, CL_MIGRATE_MEM_OBJECT_HOST));
91  OCL_CHECK(err, err = queuePixClust.finish());
92  auto read_end = std::chrono::high_resolution_clock::now();
93 
94  auto total_latency = std::chrono::duration<float, std::micro>(read_end - write_start).count();
95  auto write_latency = std::chrono::duration<float, std::micro>(write_end - write_start).count();
96  auto compute_latency = std::chrono::duration<float, std::micro>(compute_end - write_end).count();
97  auto read_latency = std::chrono::duration<float, std::micro>(read_end - compute_end).count();
98  ATH_MSG_INFO("Total latency:" << total_latency << " us, " << "Compute latency: " << compute_latency << " us");
99  ATH_MSG_INFO("Write latency:" << write_latency << " us, " << "Read latency: " << read_latency << " us");
100  ATH_MSG_INFO("Clusters found, calculate coordinates");
101 
102  cl::CommandQueue queuePixCoords{};
103  OCL_CHECK(err, queuePixCoords = cl::CommandQueue(m_context, m_accelerator, CL_QUEUE_PROFILING_ENABLE, &err));
104  cl::Kernel kernelPixCoords{};
105  OCL_CHECK(err, kernelPixCoords = cl::Kernel(m_program, "l2g_pixel_tool", &err));
106 
107  cl::Buffer clInbufPixCoords{};
108  std::unique_ptr<uint64_t, decltype(std::free) *> inbufPixCoords(static_cast<uint64_t*>(aligned_alloc(64, sizeof(uint64_t) * outbufPixClustSize)), std::free);
109  for (unsigned int i = 0; i < outbufPixClustSize; ++i) {
110  ATH_MSG_DEBUG("outbufPixClust[" << std::setw(6) << i << "] = 0x" << std::hex << std::setfill('0') << std::setw(16) << outbufPixClust.get()[i] << std::setfill(' ') << std::dec);
111  inbufPixCoords.get()[i] = outbufPixClust.get()[i];
112  }
113  OCL_CHECK(err, clInbufPixCoords = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY, sizeof(uint64_t) * outbufPixClustSize, inbufPixCoords.get(), &err));
114  OCL_CHECK(err, err = kernelPixCoords.setArg(0, clInbufPixCoords));
115 
116  cl::Buffer clInbufEDMPixCoords{};
117  std::unique_ptr<uint64_t, decltype(std::free) *> inbufEDMPixCoords(static_cast<uint64_t*>(aligned_alloc(64, sizeof(uint64_t) * outbufEDMPixClustSize)), std::free);
118  for (unsigned int i = 0; i < outbufEDMPixClustSize; ++i) {
119  ATH_MSG_DEBUG("outbufEDMPixClust[" << std::setw(6) << i << "] = 0x" << std::hex << std::setfill('0') << std::setw(16) << outbufEDMPixClust.get()[i] << std::setfill(' ') << std::dec);
120  inbufEDMPixCoords.get()[i] = outbufEDMPixClust.get()[i];
121  // Resize EDM container to be not larger than neccessary
122  if ((i > 2) && ((i - 3) % 10 == 0) && (((outbufEDMPixClust.get()[i] & (((1ULL << 8) - 1ULL) << 56)) >> 56) == 0xcd) && (((outbufEDMPixClust.get()[i - 1] & (((1ULL << 1) - 1ULL) << 25)) >> 25))) {
123  outbufEDMPixClustSize = i + 3;
124  }
125  }
126  OCL_CHECK(err, clInbufEDMPixCoords = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY, sizeof(uint64_t) * outbufEDMPixClustSize, inbufEDMPixCoords.get(), &err));
127  OCL_CHECK(err, err = kernelPixCoords.setArg(1, clInbufEDMPixCoords));
128 
129  cl::Buffer clOutbufPixCoords{};
130  unsigned int outbufPixCoordsSize = inbufPixClustSize * 2 + 9164 + 6;
131  std::unique_ptr<uint64_t, decltype(std::free) *> outbufPixCoords(static_cast<uint64_t*>(aligned_alloc(64, sizeof(uint64_t) * outbufPixCoordsSize)), std::free);
132  OCL_CHECK(err, clOutbufPixCoords = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_WRITE_ONLY, sizeof(uint64_t) * outbufPixCoordsSize, outbufPixCoords.get(), &err));
133  OCL_CHECK(err, err = kernelPixCoords.setArg(2, clOutbufPixCoords));
134  cl::Buffer clOutbufEDMPixCoords{};
135  std::unique_ptr<uint64_t, decltype(std::free) *> outbufEDMPixCoords(static_cast<uint64_t*>(aligned_alloc(64, sizeof(uint64_t) * outbufEDMPixClustSize)), std::free);
136  OCL_CHECK(err, clOutbufEDMPixCoords = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_WRITE_ONLY, sizeof(uint64_t) * outbufEDMPixClustSize, outbufEDMPixCoords.get(), &err));
137  OCL_CHECK(err, err = kernelPixCoords.setArg(3, clOutbufEDMPixCoords));
138 
139  // Write data to accelerator
140  write_start = std::chrono::high_resolution_clock::now();
141  OCL_CHECK(err, err = queuePixCoords.enqueueMigrateMemObjects({clInbufPixCoords}, 0));
142  OCL_CHECK(err, err = queuePixCoords.enqueueMigrateMemObjects({clInbufEDMPixCoords}, 0));
143  OCL_CHECK(err, err = queuePixCoords.finish());
144  write_end = std::chrono::high_resolution_clock::now();
145 
146  // Run algorithm on accelerator
147  OCL_CHECK(err, err = queuePixCoords.enqueueTask(kernelPixCoords));
148  OCL_CHECK(err, err = queuePixCoords.finish());
149  compute_end = std::chrono::high_resolution_clock::now();
150 
151  // Read back result
152  OCL_CHECK(err, err = queuePixCoords.enqueueMigrateMemObjects({clOutbufPixCoords}, CL_MIGRATE_MEM_OBJECT_HOST));
153  OCL_CHECK(err, err = queuePixCoords.enqueueMigrateMemObjects({clOutbufEDMPixCoords}, CL_MIGRATE_MEM_OBJECT_HOST));
154  OCL_CHECK(err, err = queuePixCoords.finish());
155  read_end = std::chrono::high_resolution_clock::now();
156 
157  total_latency = std::chrono::duration<float, std::micro>(read_end - write_start).count();
158  write_latency = std::chrono::duration<float, std::micro>(write_end - write_start).count();
159  compute_latency = std::chrono::duration<float, std::micro>(compute_end - write_end).count();
160  read_latency = std::chrono::duration<float, std::micro>(read_end - compute_end).count();
161  ATH_MSG_INFO("Total latency:" << total_latency << " us, " << "Compute latency: " << compute_latency << " us");
162  ATH_MSG_INFO("Write latency:" << write_latency << " us, " << "Read latency: " << read_latency << " us");
163  ATH_MSG_INFO("Coordinates calculated, transform to xAOD::PixelCluster compatible formats");
164 
165  for (unsigned int i = 0; i < outbufPixCoordsSize; ++i) {
166  ATH_MSG_DEBUG("outbufPixCoords[" << std::setw(6) << i << "] = 0x" << std::hex << std::setfill('0') << std::setw(16) << outbufPixCoords.get()[i] << std::setfill(' ') << std::dec);
167  }
168 
169  cl::CommandQueue queuePixEDMPrep{};
170  OCL_CHECK(err, queuePixEDMPrep = cl::CommandQueue(m_context, m_accelerator, CL_QUEUE_PROFILING_ENABLE, &err));
171  cl::Kernel kernelPixEDMPrep{};
172  OCL_CHECK(err, kernelPixEDMPrep = cl::Kernel(m_program, "EDMPrep", &err));
173 
174  cl::Buffer clInbufEDMPixEDMPrep{};
175  std::unique_ptr<uint64_t, decltype(std::free) *> inbufEDMPixEDMPrep(static_cast<uint64_t*>(aligned_alloc(64, sizeof(uint64_t) * outbufEDMPixClustSize)), std::free);
176  for (unsigned int i = 0; i < outbufEDMPixClustSize; ++i) {
177  inbufEDMPixEDMPrep.get()[i] = outbufEDMPixCoords.get()[i];
178  ATH_MSG_DEBUG("inbufEDMPixEDMPrep[" << std::setw(6) << i << "] = 0x" << std::hex << std::setfill('0') << std::setw(16) << inbufEDMPixEDMPrep.get()[i] << std::setfill(' ') << std::dec);
179  }
180  OCL_CHECK(err, clInbufEDMPixEDMPrep = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY, sizeof(uint64_t) * outbufEDMPixClustSize, inbufEDMPixEDMPrep.get(), &err));
181  OCL_CHECK(err, err = kernelPixEDMPrep.setArg(0, clInbufEDMPixEDMPrep));
182 
183  cl::Buffer clOutbufEDMPixEDMPrep{};
184  std::unique_ptr<uint64_t, decltype(std::free) *> outbufEDMPixEDMPrep(static_cast<uint64_t*>(aligned_alloc(512, sizeof(uint64_t) * EFTrackingTransient::PIXEL_CONTAINER_BUF_SIZE)), std::free);
185  OCL_CHECK(err, clOutbufEDMPixEDMPrep = cl::Buffer(m_context, CL_MEM_USE_HOST_PTR | CL_MEM_WRITE_ONLY, sizeof(uint64_t) * EFTrackingTransient::PIXEL_CONTAINER_BUF_SIZE, outbufEDMPixEDMPrep.get(), &err));
186  OCL_CHECK(err, err = kernelPixEDMPrep.setArg(1, clOutbufEDMPixEDMPrep));
187 
188  // Write data to accelerator
189  write_start = std::chrono::high_resolution_clock::now();
190  OCL_CHECK(err, err = queuePixEDMPrep.enqueueMigrateMemObjects({clInbufEDMPixEDMPrep}, 0));
191  OCL_CHECK(err, err = queuePixEDMPrep.finish());
192  write_end = std::chrono::high_resolution_clock::now();
193 
194  // Run algorithm on accelerator
195  OCL_CHECK(err, err = queuePixEDMPrep.enqueueTask(kernelPixEDMPrep));
196  OCL_CHECK(err, err = queuePixEDMPrep.finish());
197  compute_end = std::chrono::high_resolution_clock::now();
198 
199  // Read back result
200  OCL_CHECK(err, err = queuePixEDMPrep.enqueueMigrateMemObjects({clOutbufEDMPixEDMPrep}, CL_MIGRATE_MEM_OBJECT_HOST));
201  OCL_CHECK(err, err = queuePixEDMPrep.finish());
202  read_end = std::chrono::high_resolution_clock::now();
203 
204  for (unsigned int i = 0; i < EFTrackingTransient::PIXEL_CONTAINER_BUF_SIZE; ++i)
205  ATH_MSG_DEBUG("outbufEDMPixEDMPrep[" << std::setw(6) << i << "] = 0x" << std::hex << std::setfill('0') << std::setw(16) << outbufEDMPixEDMPrep.get()[i] << std::setfill(' ') << std::dec);
206 
207  total_latency = std::chrono::duration<float, std::micro>(read_end - write_start).count();
208  write_latency = std::chrono::duration<float, std::micro>(write_end - write_start).count();
209  compute_latency = std::chrono::duration<float, std::micro>(compute_end - write_end).count();
210  read_latency = std::chrono::duration<float, std::micro>(read_end - compute_end).count();
211  ATH_MSG_INFO("Total latency:" << total_latency << " us, " << "Compute latency: " << compute_latency << " us");
212  ATH_MSG_INFO("Write latency:" << write_latency << " us, " << "Read latency: " << read_latency << " us");
213  ATH_MSG_INFO("Received data for making xAOD::PixelCluster's");
214 
215  uint64_t* pixelClusters = (uint64_t*)outbufEDMPixEDMPrep.get();
216  unsigned int numClusters = pixelClusters[0];
217  ATH_MSG_INFO("Received " << numClusters << " clusters");
218 
219  write_start = std::chrono::high_resolution_clock::now();
220  std::unique_ptr<EFTrackingTransient::Metadata> metadata = std::make_unique<EFTrackingTransient::Metadata>();
221 
222  metadata->numOfPixelClusters = numClusters;
223  metadata->pcRdoIndexSize = numClusters;
224 
225  EFTrackingTransient::PixelClusterAuxInput pcAux;
226 
227  int rdoCounter, row;
228  uint64_t rdo;
229  for (unsigned int i = 0; i < numClusters; ++i) {
230  ATH_MSG_DEBUG("New Cluster number " << i);
231  rdoCounter = 0;
232  row = 0;
233  pcAux.idHash.push_back(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]);
234  ATH_MSG_DEBUG("idHash = " << pcAux.idHash.back());
235 
236  row++;
237  pcAux.id.push_back(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]);
238  ATH_MSG_DEBUG("id = " << pcAux.id.back());
239 
240  row++;
241  rdo = pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8];
242  if (rdo) {
243  pcAux.rdoList.push_back(rdo);
244  rdoCounter++;
245  ATH_MSG_DEBUG("rdo = " << pcAux.rdoList.back());
246  }
247 
248  row++;
249  rdo = pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8];
250  if (rdo) {
251  pcAux.rdoList.push_back(rdo);
252  rdoCounter++;
253  ATH_MSG_DEBUG("rdo = " << pcAux.rdoList.back());
254  }
255 
256  row++;
257  rdo = pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8];
258  if (rdo) {
259  pcAux.rdoList.push_back(rdo);
260  rdoCounter++;
261  ATH_MSG_DEBUG("rdo = " << pcAux.rdoList.back());
262  }
263 
264  row++;
265  rdo = pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8];
266  if (rdo) {
267  pcAux.rdoList.push_back(rdo);
268  rdoCounter++;
269  ATH_MSG_DEBUG("rdo = " << pcAux.rdoList.back());
270  }
271 
272  row++;
273  pcAux.localPosition.push_back(std::bit_cast<double>(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]));
274  ATH_MSG_DEBUG("local x = " << pcAux.localPosition.back());
275 
276  row++;
277  pcAux.localPosition.push_back(std::bit_cast<double>(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]));
278  ATH_MSG_DEBUG("local y = " << pcAux.localPosition.back());
279 
280  row++;
281  pcAux.localCovariance.push_back(std::bit_cast<double>(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]));
282  ATH_MSG_DEBUG("local covariance [0, 0] = " << pcAux.localCovariance.back());
283 
284  row++;
285  pcAux.localCovariance.push_back(std::bit_cast<double>(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]));
286  ATH_MSG_DEBUG("local covariance [1, 1] = " << pcAux.localCovariance.back());
287 
288  row++;
289  pcAux.globalPosition.push_back(std::bit_cast<double>(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]));
290  ATH_MSG_DEBUG("global x = " << pcAux.globalPosition.back());
291 
292  row++;
293  pcAux.globalPosition.push_back(std::bit_cast<double>(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]));
294  ATH_MSG_DEBUG("global y = " << pcAux.globalPosition.back());
295 
296  row++;
297  pcAux.globalPosition.push_back(std::bit_cast<double>(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]));
298  ATH_MSG_DEBUG("global z = " << pcAux.globalPosition.back());
299 
300  row++;
301  pcAux.channelsInPhi.push_back(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]);
302  ATH_MSG_DEBUG("channels in phi = " << pcAux.channelsInPhi.back());
303 
304  row++;
305  pcAux.channelsInEta.push_back(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]);
306  ATH_MSG_DEBUG("chanels in eta = " << pcAux.channelsInEta.back());
307 
308  row++;
309  pcAux.widthInEta.push_back(std::bit_cast<double>(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]));
310  ATH_MSG_DEBUG("width in eta = " << pcAux.widthInEta.back());
311 
312  row++;
313  row++;
314  row++;
315  pcAux.totalToT.push_back(pixelClusters[row * EFTrackingTransient::MAX_NUM_CLUSTERS + i + 8]);
316  ATH_MSG_DEBUG("total ToT = " << pcAux.totalToT.back());
317 
318  metadata->pcRdoIndex[i] = rdoCounter;
319  }
320 
321  ATH_CHECK(m_xAODClusterMaker->makePixelClusterContainer(pcAux, metadata.get(), ctx));
322  write_end = std::chrono::high_resolution_clock::now();
323  write_latency = std::chrono::duration<float, std::micro>(write_end - write_start).count();
324  ATH_MSG_INFO("xAOD::PixelClusterContainer made in " << write_latency << " us");
325 
326  return StatusCode::SUCCESS;
327 }
328 
329 #undef OCL_CHECK
EFTrackingTransient::PixelClusterAuxInput::localPosition
std::vector< float > localPosition
Definition: EFTrackingTransient.h:229
IntegrationBase::m_accelerator
cl::Device m_accelerator
Device object for the accelerator card.
Definition: IntegrationBase.h:66
IntegrationBase::initialize
virtual StatusCode initialize() override
Detect the OpenCL devices and prepare OpenCL context.
Definition: IntegrationBase.cxx:16
EFTrackingTransient::PixelClusterAuxInput::channelsInEta
std::vector< int > channelsInEta
Definition: EFTrackingTransient.h:234
EFTrackingTransient::PIXEL_CONTAINER_BUF_SIZE
constexpr unsigned long PIXEL_CONTAINER_BUF_SIZE
Definition: EFTrackingTransient.h:36
EFTrackingTransient::PixelClusterAuxInput
The PixelClusterAuxInput struct is used to simplify the creaction of the xAOD::PixelClusterContainer.
Definition: EFTrackingTransient.h:226
OCL_CHECK
#define OCL_CHECK(err, call)
Definition: PixelClustering.cxx:12
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
PixelClustering::execute
StatusCode execute(const EventContext &ctx) const override
Should be overriden by derived classes to perform meaningful work.
Definition: PixelClustering.cxx:32
EFTrackingTransient::MAX_NUM_CLUSTERS
constexpr unsigned int MAX_NUM_CLUSTERS
Definition: EFTrackingTransient.h:27
IntegrationBase::m_context
cl::Context m_context
Context object for the application.
Definition: IntegrationBase.h:67
keylayer_zslicemap.row
row
Definition: keylayer_zslicemap.py:155
PixelClustering::m_refTV
Gaudi::Property< std::string > m_refTV
Reference TestVector.
Definition: PixelClustering.h:35
PixelClustering.h
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
PixelClustering::initialize
StatusCode initialize() override
Detect the OpenCL devices and prepare OpenCL context.
Definition: PixelClustering.cxx:18
PixelClustering::m_xclbin
Gaudi::Property< std::string > m_xclbin
Path and name of the xclbin file.
Definition: PixelClustering.h:32
python.handimod.now
now
Definition: handimod.py:674
PixelClustering::m_kernelName
Gaudi::Property< std::string > m_kernelName
Kernel name.
Definition: PixelClustering.h:33
EFTrackingTransient::PixelClusterAuxInput::rdoList
std::vector< unsigned long long > rdoList
Definition: EFTrackingTransient.h:232
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:183
lumiFormat.i
int i
Definition: lumiFormat.py:85
EFTrackingTransient::PixelClusterAuxInput::localCovariance
std::vector< float > localCovariance
Definition: EFTrackingTransient.h:230
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
EFTrackingTransient::PixelClusterAuxInput::totalToT
std::vector< int > totalToT
Definition: EFTrackingTransient.h:237
PixelClustering::m_inputTV
Gaudi::Property< std::string > m_inputTV
Input TestVector.
Definition: PixelClustering.h:34
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IntegrationBase::precheck
StatusCode precheck(const std::vector< Gaudi::Property< std::string >> &inputs) const
Check if the the desired Gaudi properties are set.
Definition: IntegrationBase.cxx:154
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
EFTrackingTransient::PixelClusterAuxInput::idHash
std::vector< unsigned int > idHash
Definition: EFTrackingTransient.h:228
IntegrationBase::loadProgram
StatusCode loadProgram(const std::string &xclbin)
Find the xclbin file and load it into the OpenCL program object.
Definition: IntegrationBase.cxx:115
EFTrackingTransient.h
EFTrackingTransient::PixelClusterAuxInput::channelsInPhi
std::vector< int > channelsInPhi
Definition: EFTrackingTransient.h:233
EFTrackingTransient::PixelClusterAuxInput::id
std::vector< long unsigned int > id
Definition: EFTrackingTransient.h:227
EFTrackingTransient::PixelClusterAuxInput::widthInEta
std::vector< float > widthInEta
Definition: EFTrackingTransient.h:235
EFTrackingTransient::PixelClusterAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingTransient.h:231
PixelClustering::m_xAODClusterMaker
ToolHandle< xAODClusterMaker > m_xAODClusterMaker
Definition: PixelClustering.h:40
PixelClustering::m_FPGADataFormatTool
ToolHandle< FPGADataFormatTool > m_FPGADataFormatTool
Definition: PixelClustering.h:39
IntegrationBase::m_program
cl::Program m_program
Program object containing the kernel.
Definition: IntegrationBase.h:68
PixelClustering::m_pixelRDOKey
SG::ReadHandleKey< PixelRDO_Container > m_pixelRDOKey
Definition: PixelClustering.h:37
Generated on Mon Sep 29 2025 21:16:45 for ATLAS Offline Software by   doxygen 1.8.18