ATLAS Offline Software
Loading...
Searching...
No Matches
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
31
32StatusCode 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
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
OCL_CHECK
#define OCL_CHECK(err, call)
Definition PixelClustering.cxx:12
IntegrationBase::loadProgram
StatusCode loadProgram(const std::string &xclbin)
Find the xclbin file and load it into the OpenCL program object.
Definition IntegrationBase.cxx:115
IntegrationBase::m_program
cl::Program m_program
Program object containing the kernel.
Definition IntegrationBase.h:68
IntegrationBase::initialize
virtual StatusCode initialize() override
Detect the OpenCL devices and prepare OpenCL context.
Definition IntegrationBase.cxx:16
IntegrationBase::m_context
cl::Context m_context
Context object for the application.
Definition IntegrationBase.h:67
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
IntegrationBase::m_accelerator
cl::Device m_accelerator
Device object for the accelerator card.
Definition IntegrationBase.h:66
PixelClustering::m_xAODClusterMaker
ToolHandle< xAODClusterMaker > m_xAODClusterMaker
Definition PixelClustering.h:40
PixelClustering::m_refTV
Gaudi::Property< std::string > m_refTV
Reference TestVector.
Definition PixelClustering.h:35
PixelClustering::execute
StatusCode execute(const EventContext &ctx) const override
Should be overriden by derived classes to perform meaningful work.
Definition PixelClustering.cxx:32
PixelClustering::m_pixelRDOKey
SG::ReadHandleKey< PixelRDO_Container > m_pixelRDOKey
Definition PixelClustering.h:37
PixelClustering::m_inputTV
Gaudi::Property< std::string > m_inputTV
Input TestVector.
Definition PixelClustering.h:34
PixelClustering::m_FPGADataFormatTool
ToolHandle< FPGADataFormatTool > m_FPGADataFormatTool
Definition PixelClustering.h:39
PixelClustering::m_kernelName
Gaudi::Property< std::string > m_kernelName
Kernel name.
Definition PixelClustering.h:33
PixelClustering::m_xclbin
Gaudi::Property< std::string > m_xclbin
Path and name of the xclbin file.
Definition PixelClustering.h:32
PixelClustering::initialize
StatusCode initialize() override
Detect the OpenCL devices and prepare OpenCL context.
Definition PixelClustering.cxx:18
EFTrackingTransient::MAX_NUM_CLUSTERS
constexpr unsigned int MAX_NUM_CLUSTERS
Definition EFTrackingTransient.h:43
EFTrackingTransient::PIXEL_CONTAINER_BUF_SIZE
constexpr uint32_t PIXEL_CONTAINER_BUF_SIZE
Definition EFTrackingTransient.h:38
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:270
EFTrackingTransient::PixelClusterAuxInput
The PixelClusterAuxInput struct is used to simplify the creaction of the xAOD::PixelClusterContainer.
Definition EFTrackingTransient.h:238
EFTrackingTransient::PixelClusterAuxInput::rdoList
std::vector< unsigned long long > rdoList
Definition EFTrackingTransient.h:244
Generated on for ATLAS Offline Software by doxygen 1.14.0