ATLAS Offline Software
PassThroughTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
10 #include "EFTrackingFPGAUtility/PassThroughTool.h"
11 
12 
13 StatusCode PassThroughTool::initialize()
14 {
15  ATH_MSG_INFO("Initializing PassThroughTool tool");
16  ATH_CHECK(m_stripClustersKey.initialize());
17  ATH_CHECK(m_pixelClustersKey.initialize());
18  ATH_CHECK(m_spacePointsKey.initialize());
19 
20  return StatusCode::SUCCESS;
21 }
22 
23 StatusCode PassThroughTool::runPassThrough(EFTrackingTransient::StripClusterAuxInput &scAux,
24  EFTrackingTransient::PixelClusterAuxInput &pxAux,
25  EFTrackingTransient::SpacePointAuxInput &stripSpAux,
26  EFTrackingTransient::SpacePointAuxInput &pixelSpAux,
27  EFTrackingTransient::Metadata *metadata,
28  const EventContext &ctx) const
29 {
30  // Retrieve the strip and pixel cluster container from the event store
31  SG::ReadHandle<xAOD::StripClusterContainer> inputStripClusters(
32  m_stripClustersKey, ctx);
33  SG::ReadHandle<xAOD::PixelClusterContainer> inputPixelClusters(
34  m_pixelClustersKey, ctx);
35 
36  // Retrieve the space point container from the event store
37  SG::ReadHandle<xAOD::SpacePointContainer> inputSpacePoints(
38  m_spacePointsKey, ctx);
39 
40  // Check if the strip cluster container is valid
41  if (!inputStripClusters.isValid())
42  {
43  ATH_MSG_ERROR("Failed to retrieve: " << m_stripClustersKey);
44  return StatusCode::FAILURE;
45  }
46 
47  // Check if the pixel cluster container is valid
48  if (!inputPixelClusters.isValid())
49  {
50  ATH_MSG_ERROR("Failed to retrieve: " << m_pixelClustersKey);
51  return StatusCode::FAILURE;
52  }
53 
54  // Check if the space point container is valid
55  if (!inputSpacePoints.isValid())
56  {
57  ATH_MSG_ERROR("Failed to retrieve: " << m_spacePointsKey);
58  return StatusCode::FAILURE;
59  }
60 
61  if (msgLvl(MSG::DEBUG))
62  {
63  ATH_MSG_DEBUG("StripClusterContainer is valid");
64  ATH_MSG_DEBUG("PixelClusterContainer is valid");
65  ATH_MSG_DEBUG("SpacePointContainer is valid");
66  ATH_MSG_DEBUG("Size of pixel clusters is : " << inputPixelClusters->size());
67  ATH_MSG_DEBUG("Size of strip clusters is : " << inputStripClusters->size());
68  ATH_MSG_DEBUG("Size of space points is : " << inputSpacePoints->size());
69  }
70 
71  // Prepare the input data for the kernel
72  std::vector<EFTrackingTransient::StripCluster> ef_stripClusters;
73  std::vector<EFTrackingTransient::PixelCluster> ef_pixelClusters;
74  std::vector<EFTrackingTransient::SpacePoint> ef_pixelSpacePoints;
75  std::vector<EFTrackingTransient::SpacePoint> ef_stripSpacePoints;
76 
77  // Store measurement pointers for space points
78  std::vector<std::vector<const xAOD::UncalibratedMeasurement*>> pixelSpMeasurements;
79  std::vector<std::vector<const xAOD::UncalibratedMeasurement*>> stripSpMeasurements;
80 
81  // Get the input cluster data
82  ATH_CHECK(getInputClusterData(inputStripClusters.get(), ef_stripClusters, inputStripClusters->size()));
83  ATH_CHECK(getInputClusterData(inputPixelClusters.get(), ef_pixelClusters, inputPixelClusters->size()));
84 
85  // Get the input space point data
86  ATH_CHECK(getInputSpacePointData(inputSpacePoints.get(), ef_pixelSpacePoints, pixelSpMeasurements,
87  inputSpacePoints->size(), false));
88 
89  if (msgLvl(MSG::DEBUG))
90  { // add a guard to prevent out of bounds access
91  const int maxToPrintStripCl = std::min<int>(3, ef_stripClusters.size());
92  // Print a few clusters to verify the conversion
93  for (int i = 0; i < maxToPrintStripCl; i++)
94  {
95  ATH_MSG_DEBUG("StripCluster["
96  << i << "]: " << ef_stripClusters.at(i).localPosition
97  << ", " << ef_stripClusters.at(i).localCovariance << ", "
98  << ef_stripClusters.at(i).idHash << ", "
99  << ef_stripClusters.at(i).id << ", "
100  << ef_stripClusters.at(i).globalPosition[0] << ", "
101  << ef_stripClusters.at(i).globalPosition[1] << ", "
102  << ef_stripClusters.at(i).globalPosition[2] << ", "
103  << ef_stripClusters.at(i).rdoList[0] << ", "
104  << ef_stripClusters.at(i).channelsInPhi);
105  }
106  // Pixel clusters
107  const int maxToPrintPixelCl = std::min<int>(3, ef_pixelClusters.size());
108  for (int i = 0; i < maxToPrintPixelCl; i++)
109  {
110  ATH_MSG_DEBUG("PixelCluster["
111  << i << "]: " << ef_pixelClusters.at(i).id << ", "
112  << ef_pixelClusters.at(i).idHash << ", "
113  << ef_pixelClusters.at(i).localPosition[0] << ", "
114  << ef_pixelClusters.at(i).localPosition[1] << ", "
115  << ef_pixelClusters.at(i).localCovariance[0] << ", "
116  << ef_pixelClusters.at(i).localCovariance[1] << ", "
117  << ef_pixelClusters.at(i).globalPosition[0] << ", "
118  << ef_pixelClusters.at(i).globalPosition[1] << ", "
119  << ef_pixelClusters.at(i).globalPosition[2] << ", "
120  << ef_pixelClusters.at(i).rdoList[0] << ", "
121  << ef_pixelClusters.at(i).channelsInPhi << ", "
122  << ef_pixelClusters.at(i).channelsInEta << ", "
123  << ef_pixelClusters.at(i).widthInEta << ", "
124  << ef_pixelClusters.at(i).totList[0] << ", "
125  << ef_pixelClusters.at(i).totalToT << ", "
126  << ef_pixelClusters.at(i).chargeList[0] << ", "
127  << ef_pixelClusters.at(i).totalCharge << ", "
128  << ef_pixelClusters.at(i).energyLoss << ", "
129  << ef_pixelClusters.at(i).isSplit << ", "
130  << ef_pixelClusters.at(i).splitProbability1 << ", "
131  << ef_pixelClusters.at(i).splitProbability2 << ", "
132  << ef_pixelClusters.at(i).lvl1a);
133  }
134  }
135 
136  // Determine if we are running sw or hw
137  if (m_runSW)
138  {
139  ATH_MSG_INFO("Running the sw ver of the pass-through kernel");
140  // Strip cluster
141  std::vector<float> scLocalPosition(m_maxClusterNum);
142  std::vector<float> scLocalCovariance(m_maxClusterNum);
143  std::vector<unsigned int> scIdHash(m_maxClusterNum);
144  std::vector<long unsigned int> scId(m_maxClusterNum);
145  std::vector<float> scGlobalPosition(m_maxClusterNum * 3);
146  std::vector<unsigned long long> scRdoList(m_maxClusterNum * 5000);
147  std::vector<int> scChannelsInPhi(m_maxClusterNum);
148 
149  EFTrackingTransient::StripClusterOutput ef_scOutput;
150 
151  ef_scOutput.scLocalPosition = scLocalPosition.data();
152  ef_scOutput.scLocalCovariance = scLocalCovariance.data();
153  ef_scOutput.scIdHash = scIdHash.data();
154  ef_scOutput.scId = scId.data();
155  ef_scOutput.scGlobalPosition = scGlobalPosition.data();
156  ef_scOutput.scRdoList = scRdoList.data();
157  ef_scOutput.scChannelsInPhi = scChannelsInPhi.data();
158 
159  // Pixel cluster
160  std::vector<float> pcLocalPosition(m_maxClusterNum * 2);
161  std::vector<float> pcLocalCovariance(m_maxClusterNum * 2);
162  std::vector<unsigned int> pcIdHash(m_maxClusterNum);
163  std::vector<long unsigned int> pcId(m_maxClusterNum);
164  std::vector<float> pcGlobalPosition(m_maxClusterNum * 3);
165  std::vector<unsigned long long> pcRdoList(m_maxClusterNum * 5000);
166  std::vector<int> pcChannelsInPhi(m_maxClusterNum);
167  std::vector<int> pcChannelsInEta(m_maxClusterNum);
168  std::vector<float> pcWidthInEta(m_maxClusterNum);
169  std::vector<int> pcTotList(m_maxClusterNum * 5000);
170  std::vector<int> pcTotalToT(m_maxClusterNum);
171  std::vector<float> pcChargeList(m_maxClusterNum * 5000);
172  std::vector<float> pcTotalCharge(m_maxClusterNum);
173  std::vector<float> pcEnergyLoss(m_maxClusterNum);
174  std::vector<char> pcIsSplit(m_maxClusterNum);
175  std::vector<float> pcSplitProbability1(m_maxClusterNum);
176  std::vector<float> pcSplitProbability2(m_maxClusterNum);
177  std::vector<int> pcLvl1a(m_maxClusterNum);
178 
179  EFTrackingTransient::PixelClusterOutput ef_pcOutput;
180 
181  ef_pcOutput.pcLocalPosition = pcLocalPosition.data();
182  ef_pcOutput.pcLocalCovariance = pcLocalCovariance.data();
183  ef_pcOutput.pcIdHash = pcIdHash.data();
184  ef_pcOutput.pcId = pcId.data();
185  ef_pcOutput.pcGlobalPosition = pcGlobalPosition.data();
186  ef_pcOutput.pcRdoList = pcRdoList.data();
187  ef_pcOutput.pcChannelsInPhi = pcChannelsInPhi.data();
188  ef_pcOutput.pcChannelsInEta = pcChannelsInEta.data();
189  ef_pcOutput.pcWidthInEta = pcWidthInEta.data();
190  ef_pcOutput.pcTotList = pcTotList.data();
191  ef_pcOutput.pcTotalToT = pcTotalToT.data();
192  ef_pcOutput.pcChargeList = pcChargeList.data();
193  ef_pcOutput.pcTotalCharge = pcTotalCharge.data();
194  ef_pcOutput.pcEnergyLoss = pcEnergyLoss.data();
195  ef_pcOutput.pcIsSplit = pcIsSplit.data();
196  ef_pcOutput.pcSplitProbability1 = pcSplitProbability1.data();
197  ef_pcOutput.pcSplitProbability2 = pcSplitProbability2.data();
198  ef_pcOutput.pcLvl1a = pcLvl1a.data();
199 
200  // Space point output structures
201  std::vector<unsigned int> pspIdHash(m_maxSpacePointNum);
202  std::vector<float> pspGlobalPosition(m_maxSpacePointNum * 3);
203  std::vector<float> pspRadius(m_maxSpacePointNum);
204  std::vector<float> pspVarianceR(m_maxSpacePointNum);
205  std::vector<float> pspVarianceZ(m_maxSpacePointNum);
206  std::vector<int> pspMeasurementIndexes(m_maxSpacePointNum);
207  std::vector<unsigned int> pspElementIdList(m_maxSpacePointNum);
208 
209  EFTrackingTransient::SpacePointOutput ef_pspOutput;
210  ef_pspOutput.spIdHash = pspIdHash.data();
211  ef_pspOutput.spGlobalPosition = pspGlobalPosition.data();
212  ef_pspOutput.spRadius = pspRadius.data();
213  ef_pspOutput.spVarianceR = pspVarianceR.data();
214  ef_pspOutput.spVarianceZ = pspVarianceZ.data();
215  ef_pspOutput.spMeasurementIndexes = pspMeasurementIndexes.data();
216  ef_pspOutput.spElementIdList = pspElementIdList.data();
217 
218  // Strip space point
219  std::vector<unsigned int> sspIdHash(m_maxSpacePointNum);
220  std::vector<float> sspGlobalPosition(m_maxSpacePointNum * 3);
221  std::vector<float> sspRadius(m_maxSpacePointNum);
222  std::vector<float> sspVarianceR(m_maxSpacePointNum);
223  std::vector<float> sspVarianceZ(m_maxSpacePointNum);
224  std::vector<int> sspMeasurementIndexes(m_maxSpacePointNum);
225  std::vector<unsigned int> sspElementIdList(m_maxSpacePointNum);
226 
227  EFTrackingTransient::SpacePointOutput ef_sspOutput;
228  ef_sspOutput.spIdHash = sspIdHash.data();
229  ef_sspOutput.spGlobalPosition = sspGlobalPosition.data();
230  ef_sspOutput.spRadius = sspRadius.data();
231  ef_sspOutput.spVarianceR = sspVarianceR.data();
232  ef_sspOutput.spVarianceZ = sspVarianceZ.data();
233  ef_sspOutput.spMeasurementIndexes = sspMeasurementIndexes.data();
234  ef_sspOutput.spElementIdList = sspElementIdList.data();
235 
236  // Process clusters and optionally space points if enabled
237  if (m_clusterOnlyPassThrough) {
238  ATH_CHECK(passThroughSW_clusterOnly(ef_stripClusters, ef_scOutput,
239  ef_pixelClusters, ef_pcOutput,
240  metadata));
241  } else {
242  ATH_CHECK(passThroughSW(ef_stripClusters, ef_scOutput,
243  ef_pixelClusters, ef_pcOutput,
244  ef_stripSpacePoints, ef_sspOutput,
245  ef_pixelSpacePoints, ef_pspOutput,
246  metadata));
247  }
248 
249  // resize the vector to be the length of the cluster
250  scLocalPosition.resize(metadata->numOfStripClusters);
251  scLocalCovariance.resize(metadata->numOfStripClusters);
252  scIdHash.resize(metadata->numOfStripClusters);
253  scId.resize(metadata->numOfStripClusters);
254  scGlobalPosition.resize(metadata->numOfStripClusters * 3);
255  scRdoList.resize(metadata->scRdoIndexSize);
256  scChannelsInPhi.resize(metadata->numOfStripClusters);
257 
258  pcLocalPosition.resize(metadata->numOfPixelClusters * 2);
259  pcLocalCovariance.resize(metadata->numOfPixelClusters * 2);
260  pcIdHash.resize(metadata->numOfPixelClusters);
261  pcId.resize(metadata->numOfPixelClusters);
262  pcGlobalPosition.resize(metadata->numOfPixelClusters * 3);
263  pcRdoList.resize(metadata->pcRdoIndexSize);
264  pcChannelsInPhi.resize(metadata->numOfPixelClusters);
265  pcChannelsInEta.resize(metadata->numOfPixelClusters);
266  pcWidthInEta.resize(metadata->numOfPixelClusters);
267  pcTotList.resize(metadata->pcTotIndexSize);
268  pcTotalToT.resize(metadata->numOfPixelClusters);
269  pcChargeList.resize(metadata->pcChargeIndexSize);
270  pcTotalCharge.resize(metadata->numOfPixelClusters);
271  pcEnergyLoss.resize(metadata->numOfPixelClusters);
272  pcIsSplit.resize(metadata->numOfPixelClusters);
273  pcSplitProbability1.resize(metadata->numOfPixelClusters);
274  pcSplitProbability2.resize(metadata->numOfPixelClusters);
275  pcLvl1a.resize(metadata->numOfPixelClusters);
276 
277  if (msgLvl(MSG::DEBUG)) {
278  // add guard to prevent out of bounds access
279  // in instances of not having any/enough stip clusters
280  const unsigned int nStripClustersToPrint = std::min(3u,
281  static_cast<unsigned int>(scLocalPosition.size()));
282  // print 3 strip clusters
283  for (unsigned i = 0; i < nStripClustersToPrint; i++)
284  {
285  ATH_MSG_DEBUG("scLocalPosition["
286  << i << "] = " << ef_scOutput.scLocalPosition[i]);
287  ATH_MSG_DEBUG("scLocalCovariance["
288  << i << "] = " << ef_scOutput.scLocalCovariance[i]);
289  ATH_MSG_DEBUG("scIdHash[" << i << "] = " << ef_scOutput.scIdHash[i]);
290  ATH_MSG_DEBUG("scId[" << i << "] = " << ef_scOutput.scId[i]);
291  ATH_MSG_DEBUG("scGlobalPosition["
292  << i << "] = " << ef_scOutput.scGlobalPosition[i * 3] << ", "
293  << ef_scOutput.scGlobalPosition[i * 3 + 1] << ", "
294  << ef_scOutput.scGlobalPosition[i * 3 + 2]);
295  ATH_MSG_DEBUG("scRdoList[" << i << "] = " << ef_scOutput.scRdoList[i]);
296  ATH_MSG_DEBUG("scChannelsInPhi["
297  << i << "] = " << ef_scOutput.scChannelsInPhi[i]);
298  }
299 
300  // print 3 pixel clusters
301  const unsigned int nPixelClustersToPrint = std::min(3u,
302  static_cast<unsigned int>(pcLocalPosition.size()));
303  // add guard to prevent out of bounds access; same logic as above
304  for (unsigned i = 0; i < nPixelClustersToPrint; i++)
305  {
306  ATH_MSG_DEBUG("pcLocalPosition["
307  << i << "] = " << ef_pcOutput.pcLocalPosition[i * 2] << ", "
308  << ef_pcOutput.pcLocalPosition[i * 2 + 1]);
309  ATH_MSG_DEBUG("pcLocalCovariance["
310  << i << "] = " << ef_pcOutput.pcLocalCovariance[i * 2] << ", "
311  << ef_pcOutput.pcLocalCovariance[i * 2 + 1]);
312  ATH_MSG_DEBUG("pcIdHash[" << i << "] = " << ef_pcOutput.pcIdHash[i]);
313  ATH_MSG_DEBUG("pcId[" << i << "] = " << ef_pcOutput.pcId[i]);
314  ATH_MSG_DEBUG("pcGlobalPosition["
315  << i << "] = " << ef_pcOutput.pcGlobalPosition[i * 3] << ", "
316  << ef_pcOutput.pcGlobalPosition[i * 3 + 1] << ", "
317  << ef_pcOutput.pcGlobalPosition[i * 3 + 2]);
318  ATH_MSG_DEBUG("pcRdoList[" << i << "] = " << ef_pcOutput.pcRdoList[i]);
319  ATH_MSG_DEBUG("pcChannelsInPhi["
320  << i << "] = " << ef_pcOutput.pcChannelsInPhi[i]);
321  ATH_MSG_DEBUG("pcChannelsInEta["
322  << i << "] = " << ef_pcOutput.pcChannelsInEta[i]);
323  ATH_MSG_DEBUG("pcWidthInEta["
324  << i << "] = " << ef_pcOutput.pcWidthInEta[i]);
325  ATH_MSG_DEBUG("pcTotList[" << i << "] = " << ef_pcOutput.pcTotList[i]);
326  ATH_MSG_DEBUG("pcTotalToT["
327  << i << "] = " << ef_pcOutput.pcTotalToT[i]);
328  ATH_MSG_DEBUG("pcChargeList["
329  << i << "] = " << ef_pcOutput.pcChargeList[i]);
330  ATH_MSG_DEBUG("pcTotalCharge["
331  << i << "] = " << ef_pcOutput.pcTotalCharge[i]);
332  ATH_MSG_DEBUG("pcEnergyLoss["
333  << i << "] = " << ef_pcOutput.pcEnergyLoss[i]);
334  ATH_MSG_DEBUG("pcIsSplit[" << i << "] = " << ef_pcOutput.pcIsSplit[i]);
335  ATH_MSG_DEBUG("pcSplitProbability1["
336  << i << "] = " << ef_pcOutput.pcSplitProbability1[i]);
337  ATH_MSG_DEBUG("pcSplitProbability2["
338  << i << "] = " << ef_pcOutput.pcSplitProbability2[i]);
339  ATH_MSG_DEBUG("pcLvl1a[" << i << "] = " << ef_pcOutput.pcLvl1a[i]);
340  }
341  }
342 
343  // Group data to make the strip cluster container
344  scAux.localPosition = std::move(scLocalPosition);
345  scAux.localCovariance = std::move(scLocalCovariance);
346  scAux.idHash = std::move(scIdHash);
347  scAux.id = std::move(scId);
348  scAux.globalPosition = std::move(scGlobalPosition);
349  scAux.rdoList = std::move(scRdoList);
350  scAux.channelsInPhi = std::move(scChannelsInPhi);
351 
352  // Group data to make the pixel cluster container
353  pxAux.id = std::move(pcId);
354  pxAux.idHash = std::move(pcIdHash);
355  pxAux.localPosition = std::move(pcLocalPosition);
356  pxAux.localCovariance = std::move(pcLocalCovariance);
357  pxAux.globalPosition = std::move(pcGlobalPosition);
358  pxAux.rdoList = std::move(pcRdoList);
359  pxAux.channelsInPhi = std::move(pcChannelsInPhi);
360  pxAux.channelsInEta = std::move(pcChannelsInEta);
361  pxAux.widthInEta = std::move(pcWidthInEta);
362  pxAux.totList = std::move(pcTotList);
363  pxAux.totalToT = std::move(pcTotalToT);
364  pxAux.chargeList = std::move(pcChargeList);
365  pxAux.totalCharge = std::move(pcTotalCharge);
366  pxAux.energyLoss = std::move(pcEnergyLoss);
367  pxAux.isSplit = std::move(pcIsSplit);
368  pxAux.splitProbability1 = std::move(pcSplitProbability1);
369  pxAux.splitProbability2 = std::move(pcSplitProbability2);
370  pxAux.lvl1a = std::move(pcLvl1a);
371 
372  // Transfer pixel space point data to pixelSpAux
373  for (unsigned int i = 0; i < metadata->numOfPixelSpacePoints; i++) {
374  pixelSpAux.elementIdList.push_back(ef_pspOutput.spElementIdList[i]);
375 
376  // Copy x,y,z position
377  pixelSpAux.globalPosition.push_back(ef_pspOutput.spGlobalPosition[i*3]);
378  pixelSpAux.globalPosition.push_back(ef_pspOutput.spGlobalPosition[i*3+1]);
379  pixelSpAux.globalPosition.push_back(ef_pspOutput.spGlobalPosition[i*3+2]);
380 
381  pixelSpAux.measurementIndexes.push_back(ef_pspOutput.spMeasurementIndexes[i]);
382  pixelSpAux.varianceR.push_back(ef_pspOutput.spVarianceR[i]);
383  pixelSpAux.varianceZ.push_back(ef_pspOutput.spVarianceZ[i]);
384  }
385 
386  // Transfer strip space point data to stripSpAux
387  for (unsigned int i = 0; i < metadata->numOfStripSpacePoints; i++) {
388  // For strip space points, add both element IDs
389  stripSpAux.elementIdList.push_back(ef_sspOutput.spElementIdList[i*2]);
390  stripSpAux.elementIdList.push_back(ef_sspOutput.spElementIdList[i*2+1]);
391 
392  // Add position data
393  stripSpAux.globalPosition.push_back(ef_sspOutput.spGlobalPosition[i*3]);
394  stripSpAux.globalPosition.push_back(ef_sspOutput.spGlobalPosition[i*3+1]);
395  stripSpAux.globalPosition.push_back(ef_sspOutput.spGlobalPosition[i*3+2]);
396 
397  // Add measurement indexes
398  stripSpAux.measurementIndexes.push_back(ef_sspOutput.spMeasurementIndexes[i*2]);
399  stripSpAux.measurementIndexes.push_back(ef_sspOutput.spMeasurementIndexes[i*2+1]);
400 
401  // Add variance data
402  stripSpAux.varianceR.push_back(ef_sspOutput.spVarianceR[i]);
403  stripSpAux.varianceZ.push_back(ef_sspOutput.spVarianceZ[i]);
404  }
405 
406 
407  if (msgLvl(MSG::DEBUG)) {
408  // add guard to prevent out of bounds access
409  // in instances of not having any/enough strip space points
410  const int maxToPrintStripSp = std::min<int>(3,
411  static_cast<int>(stripSpAux.elementIdList.size()));
412  // Print strip space points
413  ATH_MSG_DEBUG("Printing first few strip space points:");
414  for (int i = 0; i < maxToPrintStripSp; i++) {
415  ATH_MSG_DEBUG("StripSpacePoint[" << i << "]: "
416  << "position=(" << stripSpAux.globalPosition[i*3] << ", "
417  << stripSpAux.globalPosition[i*3+1] << ", "
418  << stripSpAux.globalPosition[i*3+2] << ")"
419  << ", varianceR=" << stripSpAux.varianceR[i]
420  << ", varianceZ=" << stripSpAux.varianceZ[i]);
421  }
422  // Print pixel space points
423  ATH_MSG_DEBUG("Printing first few pixel space points:");
424  // add guard to prevent out of bounds access
425  // in instances of not having any/enough pixel space points
426  const int maxToPrintPixelSp = std::min<int>(3,
427  static_cast<int>(pixelSpAux.elementIdList.size()));
428  for (int i = 0; i < maxToPrintPixelSp; i++) {
429  ATH_MSG_DEBUG("PixelSpacePoint[" << i << "]: "
430  << "position=(" << pixelSpAux.globalPosition[i*3] << ", "
431  << pixelSpAux.globalPosition[i*3+1] << ", "
432  << pixelSpAux.globalPosition[i*3+2] << ")"
433  << ", varianceR=" << pixelSpAux.varianceR[i]
434  << ", varianceZ=" << pixelSpAux.varianceZ[i]);
435  }
436 
437  }
438  }
439  else
440  {
441  ATH_MSG_INFO("FPGA mode is not implemented yet");
442  return StatusCode::SUCCESS;
443  }
444 
445  return StatusCode::SUCCESS;
446 }
447 
448 StatusCode PassThroughTool::getInputClusterData(
449  const xAOD::StripClusterContainer *sc,
450  std::vector<EFTrackingTransient::StripCluster> &ef_sc,
451  unsigned long N) const
452 {
453  if (N > sc->size())
454  {
455  ATH_MSG_ERROR("You want to get the "
456  << N << "th strip cluster, but there are only " << sc->size()
457  << " strip clusters in the container.");
458  return StatusCode::FAILURE;
459  }
460  ATH_MSG_DEBUG("Making vector of strip clusters...");
461  for (unsigned long i = 0; i < N; i++)
462  {
463  EFTrackingTransient::StripCluster cache;
464  // Get the data from the input xAOD::StripClusterContainer and set it to the
465  // cache
466  cache.localPosition = sc->at(i)->localPosition<1>()(0, 0);
467  cache.localCovariance = sc->at(i)->localCovariance<1>()(0, 0);
468  cache.idHash = sc->at(i)->identifierHash();
469  cache.id = sc->at(i)->identifier();
470  cache.globalPosition[0] = sc->at(i)->globalPosition()[0];
471  cache.globalPosition[1] = sc->at(i)->globalPosition()[1];
472  cache.globalPosition[2] = sc->at(i)->globalPosition()[2];
473 
474  for (unsigned long j = 0; j < sc->at(i)->rdoList().size(); j++)
475  {
476  cache.rdoList[j] = sc->at(i)->rdoList().at(j).get_compact();
477  }
478 
479  cache.channelsInPhi = sc->at(i)->channelsInPhi();
480  cache.sizeOfRDOList = sc->at(i)->rdoList().size();
481 
482  ef_sc.push_back(cache);
483  }
484 
485  ATH_MSG_DEBUG("Made " << ef_sc.size() << " strip clusters in the vector");
486  return StatusCode::SUCCESS;
487 }
488 
489 StatusCode PassThroughTool::getInputClusterData(
490  const xAOD::PixelClusterContainer *pc,
491  std::vector<EFTrackingTransient::PixelCluster> &ef_pc,
492  unsigned long N) const
493 {
494  if (N > pc->size())
495  {
496  ATH_MSG_ERROR("You want to get the "
497  << N << "th pixel cluster, but there are only " << pc->size()
498  << " pixel clusters in the container.");
499  return StatusCode::FAILURE;
500  }
501  ATH_MSG_DEBUG("Making vector of pixel clusters...");
502  for (unsigned long i = 0; i < N; i++)
503  {
504  EFTrackingTransient::PixelCluster cache;
505  // Get the data from the input xAOD::PixelClusterContainer and set it to the
506  // cache
507  cache.id = pc->at(i)->identifier();
508  cache.idHash = pc->at(i)->identifierHash();
509  cache.localPosition[0] = pc->at(i)->localPosition<2>()(0, 0);
510  cache.localPosition[1] = pc->at(i)->localPosition<2>()(1, 0);
511  cache.localCovariance[0] = pc->at(i)->localCovariance<2>()(0, 0);
512  cache.localCovariance[1] = pc->at(i)->localCovariance<2>()(1, 1);
513  cache.globalPosition[0] = pc->at(i)->globalPosition()[0];
514  cache.globalPosition[1] = pc->at(i)->globalPosition()[1];
515  cache.globalPosition[2] = pc->at(i)->globalPosition()[2];
516 
517  for (long unsigned int j = 0; j < pc->at(i)->rdoList().size(); j++)
518  {
519  cache.rdoList[j] = pc->at(i)->rdoList().at(j).get_compact();
520  }
521 
522  cache.channelsInPhi = pc->at(i)->channelsInPhi();
523  cache.channelsInEta = pc->at(i)->channelsInEta();
524  cache.widthInEta = pc->at(i)->widthInEta();
525 
526  for (long unsigned int j = 0; j < pc->at(i)->totList().size(); j++)
527  {
528  cache.totList[j] = pc->at(i)->totList().at(j);
529  }
530 
531  cache.totalToT = pc->at(i)->totalToT();
532 
533  for (long unsigned int j = 0; j < pc->at(i)->chargeList().size(); j++)
534  {
535  cache.chargeList[j] = pc->at(i)->chargeList().at(j);
536  }
537 
538  cache.totalCharge = pc->at(i)->totalCharge();
539  cache.energyLoss = pc->at(i)->energyLoss();
540  cache.isSplit = pc->at(i)->isSplit();
541  cache.splitProbability1 = pc->at(i)->splitProbability1();
542  cache.splitProbability2 = pc->at(i)->splitProbability2();
543  cache.lvl1a = pc->at(i)->lvl1a();
544  cache.sizeOfRDOList = pc->at(i)->rdoList().size();
545  cache.sizeOfTotList = pc->at(i)->totList().size();
546  cache.sizeOfChargeList = pc->at(i)->chargeList().size();
547 
548  ef_pc.push_back(cache);
549  }
550 
551  ATH_MSG_DEBUG("Made " << ef_pc.size() << " pixel clusters in the vector");
552  return StatusCode::SUCCESS;
553 }
554 
555 StatusCode PassThroughTool::getInputSpacePointData(
556  const xAOD::SpacePointContainer *sp,
557  std::vector<EFTrackingTransient::SpacePoint> &ef_sp,
558  std::vector<std::vector<const xAOD::UncalibratedMeasurement *>> &sp_meas,
559  unsigned long N, bool isStrip) const
560 {
561  if (N > sp->size())
562  {
563  ATH_MSG_ERROR("You want to get the "
564  << N << "th space point, but there are only " << sp->size()
565  << " SpacePoint in the container.");
566  return StatusCode::FAILURE;
567  }
568  ATH_MSG_DEBUG("Making vector of space point...");
569  for (unsigned long i = 0; i < N; i++)
570  {
571  EFTrackingTransient::SpacePoint cache;
572  const auto * thisSp = sp->at(i);
573  // Get the data from the input xAOD::SpacePointContainer and set it to the
574  // cache
575  cache.idHash[0] = thisSp->elementIdList()[0];
576  cache.globalPosition[0] = thisSp->x();
577  cache.globalPosition[1] = thisSp->y();
578  cache.globalPosition[2] = thisSp->z();
579  cache.radius = thisSp->radius();
580  cache.cov_r = thisSp->varianceR();
581  cache.cov_z = thisSp->varianceZ();
582 
583  // Pass the uncalibrated measurement for later stage of xAOD container
584  // creation for spacepoint
585  std::vector<const xAOD::UncalibratedMeasurement *> temp_vec(
586  thisSp->measurements().size());
587  std::copy(thisSp->measurements().begin(),
588  thisSp->measurements().end(), temp_vec.begin());
589 
590  sp_meas.push_back(std::move(temp_vec));
591 
592  if (isStrip)
593  {
594  cache.idHash[1] = thisSp->elementIdList()[1];
595  cache.topHalfStripLength = thisSp->topHalfStripLength();
596  cache.bottomHalfStripLength = thisSp->bottomHalfStripLength();
597  std::copy(thisSp->topStripDirection().data(),
598  thisSp->topStripDirection().data() +
599  thisSp->topStripDirection().size(),
600  cache.topStripDirection);
601  std::copy(thisSp->bottomStripDirection().data(),
602  thisSp->bottomStripDirection().data() +
603  thisSp->bottomStripDirection().size(),
604  cache.bottomStripDirection);
605  std::copy(thisSp->stripCenterDistance().data(),
606  thisSp->stripCenterDistance().data() +
607  thisSp->stripCenterDistance().size(),
608  cache.stripCenterDistance);
609  std::copy(thisSp->topStripCenter().data(),
610  thisSp->topStripCenter().data() +
611  thisSp->topStripCenter().size(),
612  cache.topStripCenter);
613  }
614  ef_sp.push_back(cache);
615  }
616 
617  ATH_MSG_DEBUG("Made " << ef_sp.size() << " space points in the vector");
618  return StatusCode::SUCCESS;
619 }
620 
621 // Full pass-throuh kernel, sw ver.
622 // Including pixel/strip clusters and spcepoints
623 StatusCode PassThroughTool::passThroughSW(
624  const std::vector<EFTrackingTransient::StripCluster> &inputSC,
625  EFTrackingTransient::StripClusterOutput &ef_scOutput,
626  // PixelCluster
627  const std::vector<EFTrackingTransient::PixelCluster> &inputPC,
628  EFTrackingTransient::PixelClusterOutput &ef_pcOutput,
629  // Strip SpacePoint
630  const std::vector<EFTrackingTransient::SpacePoint> &inputSSP,
631  EFTrackingTransient::SpacePointOutput &ef_sspOutput,
632  // Pixel SpacePoint
633  const std::vector<EFTrackingTransient::SpacePoint> &inputPSP,
634  EFTrackingTransient::SpacePointOutput &ef_pspOutput,
635  EFTrackingTransient::Metadata *metadata) const
636 {
637  // Add error checking at the beginning of the passThroughSW method
638  if (inputSC.empty()) {
639  ATH_MSG_DEBUG("No strip clusters found.");
640  // Set strip-related metadata to 0
641  metadata->numOfStripClusters = 0;
642  metadata->numOfStripSpacePoints = 0;
643  return StatusCode::SUCCESS;
644  }
645 
646  if (inputPC.empty()) {
647  ATH_MSG_DEBUG("No pixel clusters found.");
648  // Set pixel-related metadata to 0
649  metadata->numOfPixelClusters = 0;
650  metadata->numOfPixelSpacePoints = 0;
651  return StatusCode::SUCCESS;
652  }
653 
654  int rdoIndex_counter = 0;
655 
656  unsigned int inputscRdoIndexSize = 0;
657  unsigned int inputpcRdoIndexSize = 0;
658 
659  // transfer inputStripClusters
660  ATH_MSG_DEBUG("Transfering strip clusters...");
661  for (size_t i = 0; i < inputSC.size(); i++)
662  {
663  ef_scOutput.scLocalPosition[i] = inputSC[i].localPosition;
664  ef_scOutput.scLocalCovariance[i] = inputSC[i].localCovariance;
665  ef_scOutput.scIdHash[i] = inputSC[i].idHash;
666  ef_scOutput.scId[i] = inputSC[i].id;
667  ef_scOutput.scGlobalPosition[i * 3] = inputSC[i].globalPosition[0];
668  ef_scOutput.scGlobalPosition[i * 3 + 1] = inputSC[i].globalPosition[1];
669  ef_scOutput.scGlobalPosition[i * 3 + 2] = inputSC[i].globalPosition[2];
670 
671  inputscRdoIndexSize += inputSC[i].sizeOfRDOList;
672 
673  for (int j = 0; j < inputSC[i].sizeOfRDOList; j++)
674  {
675  ef_scOutput.scRdoList[rdoIndex_counter + j] = inputSC[i].rdoList[j];
676  }
677  // update the index counter
678  ef_scOutput.scChannelsInPhi[i] = inputSC[i].channelsInPhi;
679  rdoIndex_counter += inputSC[i].sizeOfRDOList;
680  metadata[0].scRdoIndex[i] = inputSC[i].sizeOfRDOList;
681  }
682 
683  // transfer inputPC
684  rdoIndex_counter = 0;
685  int totIndex_counter = 0;
686  int chargeIndex_counter = 0;
687 
688  unsigned int inputpcTotListsize = 0;
689  unsigned int inputpcChargeListsize = 0;
690 
691  // trasnsfer_pc:
692  for (size_t i = 0; i < inputPC.size(); i++)
693  {
694  ef_pcOutput.pcLocalPosition[i * 2] = inputPC[i].localPosition[0];
695  ef_pcOutput.pcLocalPosition[i * 2 + 1] = inputPC[i].localPosition[1];
696  ef_pcOutput.pcLocalCovariance[i * 2] = inputPC[i].localCovariance[0];
697  ef_pcOutput.pcLocalCovariance[i * 2 + 1] = inputPC[i].localCovariance[1];
698  ef_pcOutput.pcIdHash[i] = inputPC[i].idHash;
699  ef_pcOutput.pcId[i] = inputPC[i].id;
700  ef_pcOutput.pcGlobalPosition[i * 3] = inputPC[i].globalPosition[0];
701  ef_pcOutput.pcGlobalPosition[i * 3 + 1] = inputPC[i].globalPosition[1];
702  ef_pcOutput.pcGlobalPosition[i * 3 + 2] = inputPC[i].globalPosition[2];
703 
704  inputpcRdoIndexSize += inputPC[i].sizeOfRDOList;
705 
706  for (int j = 0; j < inputPC[i].sizeOfRDOList; j++)
707  {
708  ef_pcOutput.pcRdoList[rdoIndex_counter + j] = inputPC[i].rdoList[j];
709  }
710  ef_pcOutput.pcChannelsInPhi[i] = inputPC[i].channelsInPhi;
711  ef_pcOutput.pcChannelsInEta[i] = inputPC[i].channelsInEta;
712  ef_pcOutput.pcWidthInEta[i] = inputPC[i].widthInEta;
713 
714  inputpcTotListsize += inputPC[i].sizeOfTotList;
715 
716  for (int j = 0; j < inputPC[i].sizeOfTotList; j++)
717  {
718  ef_pcOutput.pcTotList[totIndex_counter + j] = inputPC[i].totList[j];
719  }
720  ef_pcOutput.pcTotalToT[i] = inputPC[i].totalToT;
721 
722  inputpcChargeListsize += inputPC[i].sizeOfChargeList;
723 
724  for (int j = 0; j < inputPC[i].sizeOfChargeList; j++)
725  {
726  ef_pcOutput.pcChargeList[chargeIndex_counter + j] =
727  inputPC[i].chargeList[j];
728  }
729  ef_pcOutput.pcTotalCharge[i] = inputPC[i].totalCharge;
730  ef_pcOutput.pcEnergyLoss[i] = inputPC[i].energyLoss;
731  ef_pcOutput.pcIsSplit[i] = inputPC[i].isSplit;
732  ef_pcOutput.pcSplitProbability1[i] = inputPC[i].splitProbability1;
733  ef_pcOutput.pcSplitProbability2[i] = inputPC[i].splitProbability2;
734  ef_pcOutput.pcLvl1a[i] = inputPC[i].lvl1a;
735 
736  // update the index counter
737  rdoIndex_counter += inputPC[i].sizeOfRDOList;
738  totIndex_counter += inputPC[i].sizeOfTotList;
739  chargeIndex_counter += inputPC[i].sizeOfChargeList;
740  metadata[0].pcRdoIndex[i] = inputPC[i].sizeOfRDOList;
741  metadata[0].pcTotIndex[i] = inputPC[i].sizeOfTotList;
742  metadata[0].pcChargeIndex[i] = inputPC[i].sizeOfChargeList;
743  }
744 
745  // transfer metadata for clusters
746  metadata[0].numOfStripClusters = inputSC.size();
747  metadata[0].numOfPixelClusters = inputPC.size();
748  metadata[0].scRdoIndexSize = inputscRdoIndexSize;
749  metadata[0].pcRdoIndexSize = inputpcRdoIndexSize;
750  metadata[0].pcTotIndexSize = inputpcTotListsize;
751  metadata[0].pcChargeIndexSize = inputpcChargeListsize;
752 
753  // Now handle space points if not in cluster-only mode
754  if (!m_clusterOnlyPassThrough) {
755  // Process pixel space points
756  ATH_MSG_DEBUG("Processing " << inputPSP.size() << " pixel space points");
757 
758  // loop over the pixel space points and transfer the data to the output
759  for (size_t i = 0; i < inputPSP.size(); i++) {
760  ef_pspOutput.spElementIdList[i] = inputPSP[i].idHash[0];
761  ef_pspOutput.spGlobalPosition[i * 3] = inputPSP[i].globalPosition[0];
762  ef_pspOutput.spGlobalPosition[i * 3 + 1] = inputPSP[i].globalPosition[1];
763  ef_pspOutput.spGlobalPosition[i * 3 + 2] = inputPSP[i].globalPosition[2];
764  ef_pspOutput.spVarianceR[i] = inputPSP[i].cov_r;
765  ef_pspOutput.spVarianceZ[i] = inputPSP[i].cov_z;
766  ef_pspOutput.spMeasurementIndexes[i] = i; // Index for linking
767  }
768 
769  // Process strip space points
770  ATH_MSG_DEBUG("Processing " << inputSSP.size() << " strip space points");
771 
772  // loop over the strip space points and transfer the data to the output
773  for (size_t i = 0; i < inputSSP.size(); i++) {
774  // For strip space points, we need two element IDs per space point
775  ef_sspOutput.spElementIdList[i * 2] = inputSSP[i].idHash[0];
776  ef_sspOutput.spElementIdList[i * 2 + 1] = inputSSP[i].idHash[1];
777 
778  // Position (x,y,z for each point)
779  ef_sspOutput.spGlobalPosition[i * 3] = inputSSP[i].globalPosition[0];
780  ef_sspOutput.spGlobalPosition[i * 3 + 1] = inputSSP[i].globalPosition[1];
781  ef_sspOutput.spGlobalPosition[i * 3 + 2] = inputSSP[i].globalPosition[2];
782 
783  // Two measurement indexes for strip space points
784  // placeholder values
785  ef_sspOutput.spMeasurementIndexes[i * 2] = i * 2;
786  ef_sspOutput.spMeasurementIndexes[i * 2 + 1] = i * 2 + 1;
787 
788  // Variance values
789  ef_sspOutput.spVarianceR[i] = inputSSP[i].cov_r;
790  ef_sspOutput.spVarianceZ[i] = inputSSP[i].cov_z;
791  }
792 
793  // Update metadata for space points
794  metadata[0].numOfPixelSpacePoints = inputPSP.size();
795  metadata[0].numOfStripSpacePoints = inputSSP.size();
796  } else {
797  // If we're processing clusters only, ensure space point counts are zero
798  metadata[0].numOfPixelSpacePoints = 0;
799  metadata[0].numOfStripSpacePoints = 0;
800  }
801 
802  ATH_MSG_DEBUG("Metadata: ");
803  ATH_MSG_DEBUG("numOfStripClusters: " << metadata[0].numOfStripClusters);
804  ATH_MSG_DEBUG("numOfPixelClusters: " << metadata[0].numOfPixelClusters);
805  ATH_MSG_DEBUG("numOfStripSpacePoints: " << metadata[0].numOfStripSpacePoints);
806  ATH_MSG_DEBUG("numOfPixelSpacePoints: " << metadata[0].numOfPixelSpacePoints);
807 
808  if (msgLvl(MSG::DEBUG)) {
809  // Print pixel space points
810  // add guard to prevent out of bounds access
811  // in instances of not having any/enough pixel space points
812  const int maxToPrintPixelSp = std::min<int>(3,
813  static_cast<int>(inputPSP.size()));
814  ATH_MSG_DEBUG("Printing first few pixel space points:");
815  for (int i = 0; i < maxToPrintPixelSp; i++) {
816  ATH_MSG_DEBUG("PixelSpacePoint[" << i << "]: "
817  << "position=(" << inputPSP[i].globalPosition[0] << ", "
818  << inputPSP[i].globalPosition[1] << ", "
819  << inputPSP[i].globalPosition[2] << ")"
820  << ", varianceR=" << inputPSP[i].cov_r
821  << ", varianceZ=" << inputPSP[i].cov_z);
822  }
823 
824  // Print strip space points
825  // add guard to prevent out of bounds access
826  // in instances of not having any/enough strip space points
827  const int maxToPrintStripSp = std::min<int>(3,
828  static_cast<int>(inputSSP.size()));
829  ATH_MSG_DEBUG("Printing first few strip space points:");
830  for (int i = 0; i < maxToPrintStripSp; i++) {
831  ATH_MSG_DEBUG("StripSpacePoint[" << i << "]: "
832  << "position=(" << inputSSP[i].globalPosition[0] << ", "
833  << inputSSP[i].globalPosition[1] << ", "
834  << inputSSP[i].globalPosition[2] << ")"
835  << ", varianceR=" << inputSSP[i].cov_r
836  << ", varianceZ=" << inputSSP[i].cov_z);
837  }
838  }
839 
840  return StatusCode::SUCCESS;
841 }
842 
843 // Cluster-only ver of sw pass-through
844 StatusCode PassThroughTool::passThroughSW_clusterOnly(
845  const std::vector<EFTrackingTransient::StripCluster> &inputSC,
846  EFTrackingTransient::StripClusterOutput &ef_scOutput,
847  // PixelCluster
848  const std::vector<EFTrackingTransient::PixelCluster> &inputPC,
849  EFTrackingTransient::PixelClusterOutput &ef_pcOutput,
850  // Metadata
851  EFTrackingTransient::Metadata *metadata)
852  const
853 {
854  int rdoIndex_counter = 0;
855 
856  unsigned int inputscRdoIndexSize = 0;
857 
858  // transfer inputStripClusters
859  ATH_MSG_DEBUG("Transfering strip clusters...");
860  for (size_t i = 0; i < inputSC.size(); i++)
861  {
862  ef_scOutput.scLocalPosition[i] = inputSC[i].localPosition;
863  ef_scOutput.scLocalCovariance[i] = inputSC[i].localCovariance;
864  ef_scOutput.scIdHash[i] = inputSC[i].idHash;
865  ef_scOutput.scId[i] = inputSC[i].id;
866  ef_scOutput.scGlobalPosition[i * 3] = inputSC[i].globalPosition[0];
867  ef_scOutput.scGlobalPosition[i * 3 + 1] = inputSC[i].globalPosition[1];
868  ef_scOutput.scGlobalPosition[i * 3 + 2] = inputSC[i].globalPosition[2];
869 
870  inputscRdoIndexSize += inputSC[i].sizeOfRDOList;
871 
872  for (int j = 0; j < inputSC[i].sizeOfRDOList; j++)
873  {
874  ef_scOutput.scRdoList[rdoIndex_counter + j] = inputSC[i].rdoList[j];
875  }
876  // update the index counter
877  ef_scOutput.scChannelsInPhi[i] = inputSC[i].channelsInPhi;
878  rdoIndex_counter += inputSC[i].sizeOfRDOList;
879  metadata[0].scRdoIndex[i] = inputSC[i].sizeOfRDOList;
880  }
881 
882  // transfer inputPC
883  rdoIndex_counter = 0;
884  int totIndex_counter = 0;
885  int chargeIndex_counter = 0;
886 
887  unsigned int inputpcRdoIndexSize = 0;
888  unsigned int inputpcTotListsize = 0;
889  unsigned int inputpcChargeListsize = 0;
890 
891  // trasnsfer_pc:
892  ATH_MSG_DEBUG("Transfering pixel clusters...");
893  for (size_t i = 0; i < inputPC.size(); i++)
894  {
895  ef_pcOutput.pcLocalPosition[i * 2] = inputPC[i].localPosition[0];
896  ef_pcOutput.pcLocalPosition[i * 2 + 1] = inputPC[i].localPosition[1];
897  ef_pcOutput.pcLocalCovariance[i * 2] = inputPC[i].localCovariance[0];
898  ef_pcOutput.pcLocalCovariance[i * 2 + 1] = inputPC[i].localCovariance[1];
899  ef_pcOutput.pcIdHash[i] = inputPC[i].idHash;
900  ef_pcOutput.pcId[i] = inputPC[i].id;
901  ef_pcOutput.pcGlobalPosition[i * 3] = inputPC[i].globalPosition[0];
902  ef_pcOutput.pcGlobalPosition[i * 3 + 1] = inputPC[i].globalPosition[1];
903  ef_pcOutput.pcGlobalPosition[i * 3 + 2] = inputPC[i].globalPosition[2];
904 
905  inputpcRdoIndexSize += inputPC[i].sizeOfRDOList;
906 
907  for (int j = 0; j < inputPC[i].sizeOfRDOList; j++)
908  {
909  ef_pcOutput.pcRdoList[rdoIndex_counter + j] = inputPC[i].rdoList[j];
910  }
911  ef_pcOutput.pcChannelsInPhi[i] = inputPC[i].channelsInPhi;
912  ef_pcOutput.pcChannelsInEta[i] = inputPC[i].channelsInEta;
913  ef_pcOutput.pcWidthInEta[i] = inputPC[i].widthInEta;
914 
915  inputpcTotListsize += inputPC[i].sizeOfTotList;
916 
917  for (int j = 0; j < inputPC[i].sizeOfTotList; j++)
918  {
919  ef_pcOutput.pcTotList[totIndex_counter + j] = inputPC[i].totList[j];
920  }
921  ef_pcOutput.pcTotalToT[i] = inputPC[i].totalToT;
922 
923  inputpcChargeListsize += inputPC[i].sizeOfChargeList;
924 
925  for (int j = 0; j < inputPC[i].sizeOfChargeList; j++)
926  {
927  ef_pcOutput.pcChargeList[chargeIndex_counter + j] =
928  inputPC[i].chargeList[j];
929  }
930  ef_pcOutput.pcTotalCharge[i] = inputPC[i].totalCharge;
931  ef_pcOutput.pcEnergyLoss[i] = inputPC[i].energyLoss;
932  ef_pcOutput.pcIsSplit[i] = inputPC[i].isSplit;
933  ef_pcOutput.pcSplitProbability1[i] = inputPC[i].splitProbability1;
934  ef_pcOutput.pcSplitProbability2[i] = inputPC[i].splitProbability2;
935  ef_pcOutput.pcLvl1a[i] = inputPC[i].lvl1a;
936 
937  // update the index counter
938  rdoIndex_counter += inputPC[i].sizeOfRDOList;
939  totIndex_counter += inputPC[i].sizeOfTotList;
940  chargeIndex_counter += inputPC[i].sizeOfChargeList;
941  metadata[0].pcRdoIndex[i] = inputPC[i].sizeOfRDOList;
942  metadata[0].pcTotIndex[i] = inputPC[i].sizeOfTotList;
943  metadata[0].pcChargeIndex[i] = inputPC[i].sizeOfChargeList;
944  }
945  // transfer metadata
946  metadata[0].numOfStripClusters = inputSC.size();
947  metadata[0].numOfPixelClusters = inputPC.size();
948  metadata[0].scRdoIndexSize = inputscRdoIndexSize;
949  metadata[0].pcRdoIndexSize = inputpcRdoIndexSize;
950  metadata[0].pcTotIndexSize = inputpcTotListsize;
951  metadata[0].pcChargeIndexSize = inputpcChargeListsize;
952 
953  ATH_MSG_DEBUG("Metadata: ");
954  ATH_MSG_DEBUG("numOfStripClusters: " << metadata[0].numOfStripClusters);
955  ATH_MSG_DEBUG("numOfPixelClusters: " << metadata[0].numOfPixelClusters);
956  ATH_MSG_DEBUG("numOfStripSpacePoints: " << metadata[0].numOfStripSpacePoints);
957  ATH_MSG_DEBUG("numOfPixelSpacePoints: " << metadata[0].numOfPixelSpacePoints);
958 
959  // If we're processing clusters, we should also set up space point metadata
960  // This ensures downstream code knows there are no space points yet
961  metadata[0].numOfPixelSpacePoints = 0;
962  metadata[0].numOfStripSpacePoints = 0;
963 
964  ATH_MSG_DEBUG("Updated Metadata: ");
965  ATH_MSG_DEBUG("numOfPixelSpacePoints: " << metadata[0].numOfPixelSpacePoints);
966  ATH_MSG_DEBUG("numOfStripSpacePoints: " << metadata[0].numOfStripSpacePoints);
967 
968  return StatusCode::SUCCESS;
969 }
EFTrackingTransient::PixelCluster::totList
int totList[1000]
Definition: EFTrackingTransient.h:92
EFTrackingTransient::StripClusterOutput::scRdoList
unsigned long long * scRdoList
Definition: EFTrackingTransient.h:163
EFTrackingTransient::PixelCluster
The PixelClusters struct contains all xAOD::PixelCluster data members.
Definition: EFTrackingTransient.h:82
EFTrackingTransient::SpacePointOutput::spGlobalPosition
float * spGlobalPosition
Definition: EFTrackingTransient.h:204
EFTrackingTransient::PixelClusterAuxInput::localPosition
std::vector< float > localPosition
Definition: EFTrackingTransient.h:241
EFTrackingTransient::PixelClusterAuxInput::channelsInEta
std::vector< int > channelsInEta
Definition: EFTrackingTransient.h:246
PassThroughTool::m_runSW
Gaudi::Property< bool > m_runSW
Software mode, not running on the FPGA.
Definition: PassThroughTool.h:123
EFTrackingTransient::PixelCluster::sizeOfRDOList
int sizeOfRDOList
Definition: EFTrackingTransient.h:101
EFTrackingTransient::PixelClusterAuxInput
The PixelClusterAuxInput struct is used to simplify the creaction of the xAOD::PixelClusterContainer.
Definition: EFTrackingTransient.h:238
EFTrackingTransient::PixelCluster::lvl1a
int lvl1a
Definition: EFTrackingTransient.h:100
EFTrackingTransient::PixelClusterAuxInput::chargeList
std::vector< float > chargeList
Definition: EFTrackingTransient.h:250
EFTrackingTransient::StripClusterAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingTransient.h:228
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
EFTrackingTransient::PixelClusterOutput::pcIdHash
unsigned int * pcIdHash
Definition: EFTrackingTransient.h:176
EFTrackingTransient::PixelClusterAuxInput::splitProbability2
std::vector< float > splitProbability2
Definition: EFTrackingTransient.h:255
EFTrackingTransient::PixelCluster::idHash
unsigned int idHash
Definition: EFTrackingTransient.h:84
EFTrackingTransient::PixelClusterOutput::pcSplitProbability2
float * pcSplitProbability2
Definition: EFTrackingTransient.h:190
EFTrackingTransient::SpacePointAuxInput
The SpacePointAuxInput struct is used to simplify the creaction of the xAOD::SpacePointContainer.
Definition: EFTrackingTransient.h:266
EFTrackingTransient::PixelCluster::sizeOfChargeList
int sizeOfChargeList
Definition: EFTrackingTransient.h:103
EFTrackingTransient::PixelCluster::splitProbability2
float splitProbability2
Definition: EFTrackingTransient.h:99
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
EFTrackingTransient::PixelClusterOutput::pcSplitProbability1
float * pcSplitProbability1
Definition: EFTrackingTransient.h:189
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
EFTrackingTransient::PixelClusterOutput::pcEnergyLoss
float * pcEnergyLoss
Definition: EFTrackingTransient.h:187
EFTrackingTransient::PixelClusterAuxInput::totalCharge
std::vector< float > totalCharge
Definition: EFTrackingTransient.h:251
EFTrackingTransient::StripClusterAuxInput::localCovariance
std::vector< float > localCovariance
Definition: EFTrackingTransient.h:225
EFTrackingTransient::SpacePointOutput::spMeasurementIndexes
int * spMeasurementIndexes
Definition: EFTrackingTransient.h:208
PassThroughTool::passThroughSW_clusterOnly
StatusCode passThroughSW_clusterOnly(const std::vector< EFTrackingTransient::StripCluster > &inputSC, EFTrackingTransient::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingTransient::PixelCluster > &inputPC, EFTrackingTransient::PixelClusterOutput &ef_pcOutput, EFTrackingTransient::Metadata *metadata) const
This is a cluster-only version (sw) of the pass-through kernel This is used for cluter level studies.
Definition: PassThroughTool.cxx:844
PassThroughTool::m_spacePointsKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_spacePointsKey
Definition: PassThroughTool.h:139
EFTrackingTransient::PixelClusterOutput::pcTotalCharge
float * pcTotalCharge
Definition: EFTrackingTransient.h:186
EFTrackingTransient::Metadata
The structure of the Metadata containing data after clusterization.
Definition: EFTrackingTransient.h:136
EFTrackingTransient::PixelClusterOutput::pcChargeList
float * pcChargeList
Definition: EFTrackingTransient.h:185
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
PassThroughTool::m_stripClustersKey
SG::ReadHandleKey< xAOD::StripClusterContainer > m_stripClustersKey
Definition: PassThroughTool.h:133
EFTrackingTransient::SpacePoint::bottomStripDirection
float bottomStripDirection[3]
Definition: EFTrackingTransient.h:125
EFTrackingTransient::SpacePoint::topHalfStripLength
float topHalfStripLength
Definition: EFTrackingTransient.h:122
PassThroughTool.h
EFTrackingTransient::SpacePoint::bottomHalfStripLength
float bottomHalfStripLength
Definition: EFTrackingTransient.h:123
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
EFTrackingTransient::StripClusterAuxInput::rdoList
std::vector< unsigned long long > rdoList
Definition: EFTrackingTransient.h:229
EFTrackingTransient::StripCluster
The StripClusters struct contains all xAOD::StripCluster data members.
Definition: EFTrackingTransient.h:64
EFTrackingTransient::PixelClusterOutput::pcLocalCovariance
float * pcLocalCovariance
Definition: EFTrackingTransient.h:175
EFTrackingTransient::PixelClusterOutput::pcId
long unsigned int * pcId
Definition: EFTrackingTransient.h:177
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
EFTrackingTransient::SpacePointOutput::spVarianceR
float * spVarianceR
Definition: EFTrackingTransient.h:206
EFTrackingTransient::PixelCluster::sizeOfTotList
int sizeOfTotList
Definition: EFTrackingTransient.h:102
EFTrackingTransient::SpacePointOutput::spIdHash
unsigned int * spIdHash
Definition: EFTrackingTransient.h:203
EFTrackingTransient::SpacePointOutput::spVarianceZ
float * spVarianceZ
Definition: EFTrackingTransient.h:207
EFTrackingTransient::PixelCluster::channelsInPhi
int channelsInPhi
Definition: EFTrackingTransient.h:89
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
EFTrackingTransient::PixelCluster::rdoList
unsigned long long rdoList[1000]
Definition: EFTrackingTransient.h:88
EFTrackingTransient::StripCluster::globalPosition
float globalPosition[3]
Definition: EFTrackingTransient.h:69
EFTrackingTransient::SpacePoint::stripCenterDistance
float stripCenterDistance[3]
Definition: EFTrackingTransient.h:126
EFTrackingTransient::SpacePoint
The SpacePoint struct contains all xAOD::SpacePoint data members.
Definition: EFTrackingTransient.h:113
EFTrackingTransient::StripCluster::localCovariance
float localCovariance
Definition: EFTrackingTransient.h:66
EFTrackingTransient::StripClusterOutput::scIdHash
unsigned int * scIdHash
Definition: EFTrackingTransient.h:160
PassThroughTool::m_maxSpacePointNum
Gaudi::Property< unsigned int > m_maxSpacePointNum
Definition: PassThroughTool.h:129
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
PassThroughTool::getInputClusterData
StatusCode getInputClusterData(const xAOD::StripClusterContainer *sc, std::vector< EFTrackingTransient::StripCluster > &ef_sc, unsigned long N) const
Convert the strip cluster from xAOD container to simple std::vector of EFTrackingTransient::StripClus...
Definition: PassThroughTool.cxx:448
EFTrackingTransient::PixelClusterAuxInput::rdoList
std::vector< unsigned long long > rdoList
Definition: EFTrackingTransient.h:244
PassThroughTool::m_clusterOnlyPassThrough
Gaudi::Property< bool > m_clusterOnlyPassThrough
Use the cluster-only pass through tool
Definition: PassThroughTool.h:125
EFTrackingTransient::PixelCluster::chargeList
float chargeList[1000]
Definition: EFTrackingTransient.h:94
lumiFormat.i
int i
Definition: lumiFormat.py:85
EFTrackingTransient::PixelClusterAuxInput::localCovariance
std::vector< float > localCovariance
Definition: EFTrackingTransient.h:242
EFTrackingTransient::SpacePoint::cov_r
float cov_r
Definition: EFTrackingTransient.h:118
EFTrackingTransient::SpacePointAuxInput::varianceR
std::vector< float > varianceR
Definition: EFTrackingTransient.h:270
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::ReadHandle::get
const_pointer_type get() const
Dereference the pointer, but don't cache anything.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
EFTrackingTransient::PixelClusterOutput::pcLocalPosition
float * pcLocalPosition
Definition: EFTrackingTransient.h:174
EFTrackingTransient::StripClusterOutput::scLocalCovariance
float * scLocalCovariance
Definition: EFTrackingTransient.h:159
EFTrackingTransient::SpacePointAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingTransient.h:268
EFTrackingTransient::StripClusterAuxInput::idHash
std::vector< unsigned int > idHash
Definition: EFTrackingTransient.h:226
EFTrackingTransient::StripClusterOutput::scId
long unsigned int * scId
Definition: EFTrackingTransient.h:161
EFTrackingTransient::PixelCluster::splitProbability1
float splitProbability1
Definition: EFTrackingTransient.h:98
EFTrackingTransient::SpacePointAuxInput::varianceZ
std::vector< float > varianceZ
Definition: EFTrackingTransient.h:271
EFTrackingTransient::PixelCluster::channelsInEta
int channelsInEta
Definition: EFTrackingTransient.h:90
EFTrackingTransient::PixelClusterAuxInput::totalToT
std::vector< int > totalToT
Definition: EFTrackingTransient.h:249
EFTrackingTransient::PixelClusterOutput::pcWidthInEta
float * pcWidthInEta
Definition: EFTrackingTransient.h:182
EFTrackingTransient::PixelClusterOutput::pcIsSplit
char * pcIsSplit
Definition: EFTrackingTransient.h:188
EFTrackingTransient::SpacePointOutput::spElementIdList
unsigned int * spElementIdList
Definition: EFTrackingTransient.h:209
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
EFTrackingTransient::PixelClusterOutput::pcRdoList
unsigned long long * pcRdoList
Definition: EFTrackingTransient.h:179
EFTrackingTransient::PixelCluster::widthInEta
float widthInEta
Definition: EFTrackingTransient.h:91
PassThroughTool::initialize
StatusCode initialize() override
Definition: PassThroughTool.cxx:13
EFTrackingTransient::PixelCluster::totalCharge
float totalCharge
Definition: EFTrackingTransient.h:95
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::SpacePoint::topStripDirection
float topStripDirection[3]
Definition: EFTrackingTransient.h:124
EFTrackingTransient::SpacePointAuxInput::measurementIndexes
std::vector< int > measurementIndexes
Definition: EFTrackingTransient.h:278
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
EFTrackingTransient::StripCluster::id
long unsigned int id
Definition: EFTrackingTransient.h:68
EFTrackingTransient::StripClusterOutput::scLocalPosition
float * scLocalPosition
Definition: EFTrackingTransient.h:158
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
EFTrackingTransient::PixelClusterAuxInput::splitProbability1
std::vector< float > splitProbability1
Definition: EFTrackingTransient.h:254
EFTrackingTransient::PixelClusterAuxInput::idHash
std::vector< unsigned int > idHash
Definition: EFTrackingTransient.h:240
EFTrackingTransient::PixelClusterAuxInput::lvl1a
std::vector< int > lvl1a
Definition: EFTrackingTransient.h:256
EFTrackingTransient::SpacePointAuxInput::elementIdList
std::vector< unsigned int > elementIdList
Definition: EFTrackingTransient.h:267
dumpTgcDigiThreshold.isStrip
list isStrip
Definition: dumpTgcDigiThreshold.py:33
EFTrackingTransient::StripClusterOutput
The StripClusters struct contains the output arrays from the FPGA.
Definition: EFTrackingTransient.h:156
EFTrackingTransient::StripCluster::sizeOfRDOList
int sizeOfRDOList
Definition: EFTrackingTransient.h:72
EFTrackingTransient::StripClusterAuxInput
The StripClusterAuxInput struct is used to simplify the creaction of the xAOD::StripClusterContainer.
Definition: EFTrackingTransient.h:223
EFTrackingTransient::StripClusterAuxInput::localPosition
std::vector< float > localPosition
Definition: EFTrackingTransient.h:224
EFTrackingTransient::PixelCluster::isSplit
char isSplit
Definition: EFTrackingTransient.h:97
PassThroughTool::getInputSpacePointData
StatusCode getInputSpacePointData(const xAOD::SpacePointContainer *sp, std::vector< EFTrackingTransient::SpacePoint > &ef_sp, std::vector< std::vector< const xAOD::UncalibratedMeasurement * >> &sp_meas, unsigned long N, bool isStrip) const
Convert the space point from xAOD container to simple std::vector of EFTrackingTransient::SpacePoint.
Definition: PassThroughTool.cxx:555
EFTrackingTransient::SpacePointOutput
The Pixel/Strip SpacePoints struct contains the output arrays from the FPGA.
Definition: EFTrackingTransient.h:201
EFTrackingTransient::StripCluster::idHash
unsigned int idHash
Definition: EFTrackingTransient.h:67
EFTrackingTransient::PixelClusterAuxInput::channelsInPhi
std::vector< int > channelsInPhi
Definition: EFTrackingTransient.h:245
PassThroughTool::passThroughSW
StatusCode passThroughSW(const std::vector< EFTrackingTransient::StripCluster > &inputSC, EFTrackingTransient::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingTransient::PixelCluster > &inputPC, EFTrackingTransient::PixelClusterOutput &ef_pcOutput, const std::vector< EFTrackingTransient::SpacePoint > &inputSSP, EFTrackingTransient::SpacePointOutput &ef_sspOutput, const std::vector< EFTrackingTransient::SpacePoint > &inputPSP, EFTrackingTransient::SpacePointOutput &ef_pspOutput, EFTrackingTransient::Metadata *metadata) const
Software version of the pass-through kernel.
Definition: PassThroughTool.cxx:623
EFTrackingTransient::PixelCluster::localCovariance
float localCovariance[2]
Definition: EFTrackingTransient.h:86
EFTrackingTransient::StripClusterOutput::scGlobalPosition
float * scGlobalPosition
Definition: EFTrackingTransient.h:162
EFTrackingTransient::PixelClusterOutput
The PixelClusters struct contains the output arrays from the FPGA.
Definition: EFTrackingTransient.h:172
EFTrackingTransient::PixelClusterOutput::pcChannelsInEta
int * pcChannelsInEta
Definition: EFTrackingTransient.h:181
EFTrackingTransient::SpacePoint::radius
float radius
Definition: EFTrackingTransient.h:117
EFTrackingTransient::PixelClusterOutput::pcGlobalPosition
float * pcGlobalPosition
Definition: EFTrackingTransient.h:178
EFTrackingTransient::PixelClusterAuxInput::id
std::vector< long unsigned int > id
Definition: EFTrackingTransient.h:239
EFTrackingTransient::PixelClusterAuxInput::widthInEta
std::vector< float > widthInEta
Definition: EFTrackingTransient.h:247
EFTrackingTransient::PixelClusterAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingTransient.h:243
EFTrackingTransient::StripCluster::channelsInPhi
int channelsInPhi
Definition: EFTrackingTransient.h:71
EFTrackingTransient::SpacePoint::topStripCenter
float topStripCenter[3]
Definition: EFTrackingTransient.h:127
DEBUG
#define DEBUG
Definition: page_access.h:11
EFTrackingTransient::PixelCluster::globalPosition
float globalPosition[3]
Definition: EFTrackingTransient.h:87
EFTrackingTransient::PixelClusterOutput::pcChannelsInPhi
int * pcChannelsInPhi
Definition: EFTrackingTransient.h:180
PassThroughTool::m_pixelClustersKey
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_pixelClustersKey
Definition: PassThroughTool.h:136
EFTrackingTransient::StripClusterAuxInput::id
std::vector< long unsigned int > id
Definition: EFTrackingTransient.h:227
PassThroughTool::runPassThrough
StatusCode runPassThrough(EFTrackingTransient::StripClusterAuxInput &scAux, EFTrackingTransient::PixelClusterAuxInput &pxAux, EFTrackingTransient::SpacePointAuxInput &stripSpAux, EFTrackingTransient::SpacePointAuxInput &pixelSpAux, EFTrackingTransient::Metadata *metadata, const EventContext &ctx) const
Call this function at the DataPreparationPipeline to run the pass-through kernels.
Definition: PassThroughTool.cxx:23
EFTrackingTransient::StripClusterAuxInput::channelsInPhi
std::vector< int > channelsInPhi
Definition: EFTrackingTransient.h:230
EFTrackingTransient::PixelClusterOutput::pcLvl1a
int * pcLvl1a
Definition: EFTrackingTransient.h:191
EFTrackingTransient::PixelCluster::totalToT
int totalToT
Definition: EFTrackingTransient.h:93
PassThroughTool::m_maxClusterNum
Gaudi::Property< unsigned int > m_maxClusterNum
Definition: PassThroughTool.h:127
calibdata.copy
bool copy
Definition: calibdata.py:26
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
EFTrackingTransient::SpacePointOutput::spRadius
float * spRadius
Definition: EFTrackingTransient.h:205
EFTrackingTransient::StripCluster::rdoList
unsigned long long rdoList[1000]
Definition: EFTrackingTransient.h:70
EFTrackingTransient::PixelClusterAuxInput::energyLoss
std::vector< float > energyLoss
Definition: EFTrackingTransient.h:252
EFTrackingTransient::PixelClusterAuxInput::totList
std::vector< int > totList
Definition: EFTrackingTransient.h:248
EFTrackingTransient::PixelCluster::localPosition
float localPosition[2]
Definition: EFTrackingTransient.h:85
EFTrackingTransient::SpacePoint::globalPosition
float globalPosition[3]
Definition: EFTrackingTransient.h:116
EFTrackingTransient::StripCluster::localPosition
float localPosition
Definition: EFTrackingTransient.h:65
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
EFTrackingTransient::PixelClusterAuxInput::isSplit
std::vector< char > isSplit
Definition: EFTrackingTransient.h:253
python.SystemOfUnits.pc
float pc
Definition: SystemOfUnits.py:114
EFTrackingTransient::PixelClusterOutput::pcTotList
int * pcTotList
Definition: EFTrackingTransient.h:183
EFTrackingTransient::StripClusterOutput::scChannelsInPhi
int * scChannelsInPhi
Definition: EFTrackingTransient.h:164
EFTrackingTransient::PixelClusterOutput::pcTotalToT
int * pcTotalToT
Definition: EFTrackingTransient.h:184
EFTrackingTransient::PixelCluster::id
long unsigned int id
Definition: EFTrackingTransient.h:83
EFTrackingTransient::SpacePoint::cov_z
float cov_z
Definition: EFTrackingTransient.h:119
EFTrackingTransient::PixelCluster::energyLoss
float energyLoss
Definition: EFTrackingTransient.h:96
EFTrackingTransient::SpacePoint::idHash
unsigned int idHash[2]
Definition: EFTrackingTransient.h:115
Generated on Tue Nov 25 2025 21:16:25 for ATLAS Offline Software by   doxygen 1.8.18