ATLAS Offline Software
FPGAClusterConverter.cxx
Go to the documentation of this file.
1 
2 // Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 
4 #include "FPGAClusterConverter.h"
5 
6 #include "AtlasDetDescr/AtlasDetectorID.h"
7 #include "InDetIdentifier/PixelID.h"
8 #include "InDetIdentifier/SCT_ID.h"
9 #include "Identifier/IdentifierHash.h"
10 
11 #include "PixelReadoutGeometry/PixelDetectorManager.h"
12 #include "SCT_ReadoutGeometry/SCT_DetectorManager.h"
13 
14 #include "PixelReadoutGeometry/PixelModuleDesign.h"
15 #include "SCT_ReadoutGeometry/SCT_ModuleSideDesign.h"
16 #include "SCT_ReadoutGeometry/StripStereoAnnulusDesign.h"
17 
18 #include "TrkSpacePoint/SpacePointCollection.h"
19 
20 FPGAClusterConverter::FPGAClusterConverter(const std::string& type, const std::string& name, const IInterface* parent):
21  base_class(type, name, parent) {}
22 
23 StatusCode FPGAClusterConverter::initialize() {
24 
25  ATH_MSG_DEBUG("Initializing FPGAClusterConverter...");
26 
27  // Get SCT & pixel Identifier helpers
28  ATH_CHECK(detStore()->retrieve(m_pixelId, "PixelID"));
29  ATH_CHECK(detStore()->retrieve(m_SCTId, "SCT_ID"));
30  ATH_CHECK(detStore()->retrieve(m_pixelManager));
31  ATH_CHECK(detStore()->retrieve(m_SCTManager));
32  ATH_CHECK(m_lorentzAngleToolPixel.retrieve());
33  ATH_CHECK(m_lorentzAngleToolStrip.retrieve());
34 
35  ATH_CHECK( m_FPGAClusterKey.initialize() );
36  ATH_CHECK(m_beamSpotKey.initialize());
37 
38  return StatusCode::SUCCESS;
39 
40 }
41 
42 // Functions converting collections of FPGATrackSim Hits or Clusters into InDet or xAOD cluster collections / containers
43 
44 StatusCode FPGAClusterConverter::convertHits(const std::vector<FPGATrackSimHit>& hits,
45  InDet::PixelClusterCollection& pixelColl,
46  InDet::SCT_ClusterCollection& SCTColl) const {
47  ATH_MSG_DEBUG("Found " << hits.size() << " FPGATrackSimHits [InDet]");
48  // reserve some memory
49  pixelColl.reserve(hits.size());
50  SCTColl.reserve(hits.size());
51  for(const FPGATrackSimHit& h : hits) {
52 
53  std::vector<Identifier> rdoList;
54  ATH_CHECK(getRdoList(rdoList, h));
55 
56  std::unique_ptr<InDet::PixelCluster> pixelCl{};
57  std::unique_ptr<InDet::SCT_Cluster> SCTCl{};
58 
59  if (h.isPixel()) {
60  ATH_CHECK(createPixelCluster(h, rdoList, pixelCl));
61  if (pixelCl) pixelColl.push_back(std::move(pixelCl));
62  }
63  if (h.isStrip()) {
64  ATH_CHECK(createSCTCluster(h, rdoList, SCTCl));
65  if (SCTCl) SCTColl.push_back(std::move(SCTCl));
66  }
67  }
68 
69  ATH_MSG_DEBUG("pixelColl size: " << pixelColl.size() << " SCTColl size: " << SCTColl.size() );
70 
71  return StatusCode::SUCCESS;
72 }
73 
74 // To be used in Track conversion
75 StatusCode FPGAClusterConverter::convertHits(const std::vector<const FPGATrackSimHit*>& hits,
76  InDet::PixelClusterCollection& pixelColl,
77  InDet::SCT_ClusterCollection& SCTColl) const {
78  ATH_MSG_DEBUG("Found " << hits.size() << " FPGATrackSimHits [InDet]");
79 
80  // *** Match FPGATrackSimHit to FPGATrackSimCluster
81  SG::ReadHandle<FPGATrackSimClusterCollection> FPGAClustersHandle (m_FPGAClusterKey);
82  if (!FPGAClustersHandle.isValid()) {
83  ATH_MSG_FATAL("Failed to retrieve FPGATrackSimClusterCollection");
84  return StatusCode::FAILURE;
85  }
86  const FPGATrackSimClusterCollection *FPGAClusterColl = FPGAClustersHandle.cptr();
87 
88  for(const FPGATrackSimHit *h : hits){
89  IdentifierHash hash = h->getIdentifierHash();
90  FPGATrackSimCluster cl;
91  for (const FPGATrackSimCluster& cluster: *FPGAClusterColl){
92  FPGATrackSimHit clusterEq = cluster.getClusterEquiv();
93  if (hash == clusterEq.getIdentifierHash()) {
94  cl = cluster;
95  break;
96  }
97  }
98  FPGATrackSimHit clEq = cl.getClusterEquiv();
99 
100  // --- DEBUG
101  ATH_MSG_DEBUG("Hit identifier " << h->getIdentifierHash());
102  ATH_MSG_DEBUG("Cluster identifier " << clEq.getIdentifierHash());
103  // ---
104 
105  // *** FPGATrackSimCluster matched
106 
107  std::vector<Identifier> rdoList;
108  ATH_CHECK(getRdoList(rdoList,cl));
109 
110  std::unique_ptr<InDet::PixelCluster> pixelCl{};
111  std::unique_ptr<InDet::SCT_Cluster> SCTCl{};
112 
113  if (clEq.isPixel()) {
114  ATH_CHECK(createPixelCluster(clEq, rdoList, pixelCl));
115  if (pixelCl) pixelColl.push_back(std::move(pixelCl));
116  }
117  if (clEq.isStrip()) {
118  ATH_CHECK(createSCTCluster(clEq, rdoList, SCTCl));
119  if (SCTCl) SCTColl.push_back(std::move(SCTCl));
120  }
121 
122  }
123 
124  ATH_MSG_DEBUG("pixelColl size: " << pixelColl.size() << " SCTColl size: " << SCTColl.size());
125 
126  return StatusCode::SUCCESS;
127 
128 }
129 
130 
131 StatusCode FPGAClusterConverter::convertHits(const std::vector<FPGATrackSimHit>& hits,
132  xAOD::PixelClusterContainer& pixelCont,
133  xAOD::StripClusterContainer& SCTCont) const {
134  ATH_MSG_DEBUG("Found " << hits.size() << " FPGATrackSimHits [xAOD]");
135  // reserve some memory
136  pixelCont.reserve(hits.size());
137  SCTCont.reserve(hits.size());
138  for(const FPGATrackSimHit& h : hits) {
139 
140  std::vector<Identifier> rdoList;
141  ATH_CHECK(getRdoList(rdoList, h));
142 
143  if (h.isPixel()) {
144  xAOD::PixelCluster *xaod_pcl = new xAOD::PixelCluster();
145  pixelCont.push_back(xaod_pcl);
146  ATH_CHECK(createPixelCluster(h, rdoList, *xaod_pcl));
147  }
148  if (h.isStrip()) {
149  xAOD::StripCluster *xaod_scl = new xAOD::StripCluster();
150  SCTCont.push_back(xaod_scl);
151  ATH_CHECK(createSCTCluster(h, rdoList, *xaod_scl));
152  if(!xaod_scl->rdoList().size())
153  SCTCont.pop_back();
154  }
155  }
156 
157  ATH_MSG_DEBUG("xAOD pixelCont size: " << pixelCont.size() << " xAOD pixelCont size: " << SCTCont.size());
158 
159  return StatusCode::SUCCESS;
160 }
161 
162 
163 
164 StatusCode FPGAClusterConverter::convertClusters(const std::vector<FPGATrackSimCluster>& clusters,
165  InDet::PixelClusterCollection& pixelColl,
166  InDet::SCT_ClusterCollection& SCTColl) const {
167  ATH_MSG_DEBUG("Found " << clusters.size() << " FPGATrackSimClusters [InDet]");
168  // reserve some memory
169  pixelColl.reserve(clusters.size());
170  SCTColl.reserve(clusters.size());
171  for(const FPGATrackSimCluster& cl : clusters) {
172 
173  FPGATrackSimHit clEq = cl.getClusterEquiv();
174  std::vector<Identifier> rdoList;
175  ATH_CHECK(getRdoList(rdoList, cl));
176 
177  std::unique_ptr<InDet::PixelCluster> pixelCl{};
178  std::unique_ptr<InDet::SCT_Cluster> SCTCl{};
179 
180  if (clEq.isPixel()) {
181  ATH_CHECK(createPixelCluster(clEq, rdoList, pixelCl));
182  if (pixelCl) pixelColl.push_back(std::move(pixelCl));
183  }
184  if (clEq.isStrip()) {
185  ATH_CHECK(createSCTCluster(clEq, rdoList, SCTCl));
186  if (SCTCl) SCTColl.push_back(std::move(SCTCl));
187  }
188  }
189 
190  ATH_MSG_DEBUG("pixelColl size: " << pixelColl.size() << " SCTColl size: " << SCTColl.size());
191 
192  return StatusCode::SUCCESS;
193 }
194 
195 StatusCode FPGAClusterConverter::convertClusters(const std::vector<FPGATrackSimCluster>& clusters,
196  xAOD::PixelClusterContainer& pixelCont,
197  xAOD::StripClusterContainer& SCTCont) const {
198  ATH_MSG_DEBUG("Found " << clusters.size() << " FPGATrackSimClusters [xAOD]");
199  // reserve some memory
200  pixelCont.reserve(clusters.size());
201  SCTCont.reserve(clusters.size());
202 
203  for(const FPGATrackSimCluster& cl : clusters) {
204 
205  FPGATrackSimHit clEq = cl.getClusterEquiv();
206 
207  std::vector<Identifier> rdoList;
208  ATH_CHECK(getRdoList(rdoList, cl));
209 
210  if (clEq.isPixel()) {
211  xAOD::PixelCluster *xaod_pcl = new xAOD::PixelCluster();
212  pixelCont.push_back(xaod_pcl);
213  ATH_CHECK(createPixelCluster(clEq, rdoList, *xaod_pcl));
214  }
215  if (clEq.isStrip()) {
216  xAOD::StripCluster *xaod_scl = new xAOD::StripCluster();
217  SCTCont.push_back(xaod_scl);
218  ATH_CHECK(createSCTCluster(clEq, rdoList, *xaod_scl));
219  }
220  }
221 
222  ATH_MSG_DEBUG("xAOD pixelCont size: " << pixelCont.size() << " xAOD SCTCont size: " << SCTCont.size());
223 
224  return StatusCode::SUCCESS;
225 }
226 
227 StatusCode FPGAClusterConverter::convertSpacePoints(const std::vector<FPGATrackSimCluster>& fpgaSPs,
228  xAOD::SpacePointContainer& SPStripCont,
229  xAOD::SpacePointContainer& SPPixelCont,
230  xAOD::StripClusterContainer& stripClusterCont,
231  xAOD::PixelClusterContainer& pixelClusterCont) const {
232  ATH_MSG_INFO("Converting Pixel SPs");
233  SPPixelCont.reserve(pixelClusterCont.size());
234  ATH_CHECK(createPixelSPs(SPPixelCont, pixelClusterCont));
235 
236  if (not m_skipStripSpacePointFormation) {
237  ATH_MSG_INFO("Converting Strip SPs");
238  SPStripCont.reserve(fpgaSPs.size());
239  for (const FPGATrackSimCluster& cl : fpgaSPs) {
240  xAOD::SpacePoint* xaod_sp = new xAOD::SpacePoint();
241  SPStripCont.push_back(xaod_sp);
242  ATH_CHECK(createSP(cl, *xaod_sp, stripClusterCont));
243  if (!xaod_sp->elementIdList().size()) SPStripCont.pop_back();
244  }
245  }
246 
247  return StatusCode::SUCCESS;
248 }
249 
250 StatusCode FPGAClusterConverter::createPixelCluster(const FPGATrackSimHit& h, const std::vector<Identifier>& rdoList, std::unique_ptr<InDet::PixelCluster>& cl) const {
251  ATH_MSG_DEBUG("\tCreate InDet::PixelCluster from FPGATrackSimHit");
252 
253  IdentifierHash hash = h.getIdentifierHash();
254 
255  float etaWidth = h.getEtaWidth();
256  float phiWidth = h.getPhiWidth();
257  int phiIndex = h.getPhiIndex();
258  int etaIndex = h.getEtaIndex();
259 
260  const InDetDD::SiDetectorElement* pDE = m_pixelManager->getDetectorElement(hash);
261 
262  if( !pDE ) {
263  ATH_MSG_ERROR("Detector Element doesn't exist " << hash);
264  return StatusCode::FAILURE;
265  }
266 
267  // *** Get cell from id
268  Identifier wafer_id = m_pixelId->wafer_id(hash);
269  Identifier hit_id = m_pixelId->pixel_id(wafer_id, phiIndex, etaIndex);
270  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(hit_id);
271  if(!cell.isValid()) {
272  ATH_MSG_DEBUG("\t\tcell not valid");
273  return StatusCode::FAILURE;
274  }
275  const InDetDD::PixelModuleDesign* design (dynamic_cast<const InDetDD::PixelModuleDesign*>(&pDE->design()));
276 
277  // **** Get InDet::SiWidth
278 
279  int colMin = static_cast<int>(etaIndex-0.5*etaWidth);
280  int colMax = colMin+etaWidth;
281 
282  int rowMin = static_cast<int>(phiIndex-0.5*phiWidth);
283  int rowMax = rowMin+phiWidth;
284 
285  double etaW = design->widthFromColumnRange(colMin, colMax-1);
286  double phiW = design->widthFromRowRange(rowMin, rowMax-1);
287 
288  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,etaWidth),Amg::Vector2D(phiW,etaW));
289 
290  // **** Get SiLocalPosition from cell id and define Amg::Vector2D position
291  InDetDD::SiLocalPosition silPos(pDE->rawLocalPositionOfCell(cell));
292  Amg::Vector2D localPos(silPos);
293 
294  //TODO: understand if shift is needed
295  if (m_doShift) {
296  double shift = m_lorentzAngleToolPixel->getLorentzShift(hash,Gaudi::Hive::currentContext());
297  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
298  localPos = localPosShift;
299  }
300 
301  Amg::Vector3D globalPos = pDE->globalPosition(localPos);
302  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
303  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPos.x() << " y=" << globalPos.y() << " z=" << globalPos.z() );
304 
305  Amg::MatrixX cov(2,2);
306  cov.setZero();
307 
308  if (m_broadErrors) {
309  cov(0,0) = siWidth.phiR()*siWidth.phiR()/12;
310  cov(1,1) = siWidth.z()*siWidth.z()/12;
311  }
312  else {
313  cov(0,0) = siWidth.phiR()*siWidth.phiR()/(12*siWidth.colRow().x()*siWidth.colRow().x());
314  cov(1,1) = siWidth.z()*siWidth.z()/(12*siWidth.colRow().y()*siWidth.colRow().y());
315  }
316 
317  float dummy_omegax = 0.5;
318  float dummy_omegay = 0.5;
319  bool split = false;
320  float splitProb1 = 0;
321  float splitProb2 = 0;
322 
323  cl = std::make_unique<InDet::PixelCluster>(hit_id, localPos, std::vector<Identifier>(rdoList), siWidth, pDE, Amg::MatrixX(cov), dummy_omegax, dummy_omegay, split, splitProb1, splitProb2);
324 
325  return StatusCode::SUCCESS;
326 }
327 
328 StatusCode FPGAClusterConverter::createPixelCluster(const FPGATrackSimHit& h,const std::vector<Identifier>& rdoList, xAOD::PixelCluster &cl) const {
329  ATH_MSG_DEBUG("\tCreate xAOD::PixelCluster from FPGATrackSimHit");
330 
331  IdentifierHash hash = h.getIdentifierHash();
332 
333  const InDetDD::SiDetectorElement* pDE = m_pixelManager->getDetectorElement(hash);
334 
335  if( !pDE ) {
336  ATH_MSG_ERROR("Detector Element doesn't exist " << hash);
337  return StatusCode::FAILURE;
338  }
339 
340  // *** Get cell from id
341  Identifier wafer_id = m_pixelId->wafer_id(hash);
342  Identifier hit_id = m_pixelId->pixel_id(wafer_id, h.getPhiIndex(), h.getEtaIndex());
343  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(hit_id);
344  if(!cell.isValid()) {
345  ATH_MSG_DEBUG("\t\tcell not valid");
346  return StatusCode::FAILURE;
347  }
348  const InDetDD::PixelModuleDesign* design (dynamic_cast<const InDetDD::PixelModuleDesign*>(&pDE->design()));
349 
350  // **** Get InDet::SiWidth
351  int rowmin = h.getMinPhiIndex();
352  int rowmax = h.getMaxPhiIndex();
353  int colmin = h.getMinEtaIndex();
354  int colmax = h.getMaxEtaIndex();
355 
356  // Quick test to check that none of these 4 hit some number limits
357  // Check for uninitialized values (still at int min/max)
358  if (colmin == std::numeric_limits<int>::max() || colmax == std::numeric_limits<int>::min() ||
359  rowmin == std::numeric_limits<int>::max() || rowmax == std::numeric_limits<int>::min()) {
360  ATH_MSG_ERROR("Pixel cluster indices appear uninitialized: colmin=" << colmin << ", colmax=" << colmax
361  << ", rowmin=" << rowmin << ", rowmax=" << rowmax);
362  return StatusCode::FAILURE;
363  }
364  // Check for negative indices
365  if (colmin < 0 || colmax < 0 || rowmin < 0 || rowmax < 0) {
366  ATH_MSG_ERROR("Pixel cluster indices out of range: colmin=" << colmin << ", colmax=" << colmax
367  << ", rowmin=" << rowmin << ", rowmax=" << rowmax);
368  return StatusCode::FAILURE;
369  }
370  // Check for max < min
371  if (colmax < colmin || rowmax < rowmin) {
372  ATH_MSG_ERROR("Pixel cluster index max < min: colmin=" << colmin << ", colmax=" << colmax
373  << ", rowmin=" << rowmin << ", rowmax=" << rowmax);
374  return StatusCode::FAILURE;
375  }
376 
377  double zWidth = design->widthFromColumnRange(colmin, colmax);
378  double phiRWidth = design->widthFromRowRange(rowmin, rowmax);
379 
380  InDet::SiWidth siWidth(Amg::Vector2D(h.getPhiWidth(),h.getEtaWidth()), Amg::Vector2D(phiRWidth,zWidth));
381 
382 
383  // **** Get SiLocalPosition from cell id and define Amg::Vector2D position
384  InDetDD::SiLocalPosition silPos(pDE->rawLocalPositionOfCell(cell));
385  Amg::Vector2D localPos(silPos);
386 
387  if(m_useInherentLocalCoordinates){
388  // replace localPos with the one stored in the FPGATrackSimHit
389  localPos(0,0) = h.getPhiCoord();
390  localPos(1,0) = h.getEtaCoord();
391  }
392  //TODO: understand if shift is needed
393  if (m_doShift) {
394  double shift = m_lorentzAngleToolPixel->getLorentzShift(hash,Gaudi::Hive::currentContext());
395  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
396  localPos = localPosShift;
397  }
398 
399  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
400 
401  Amg::MatrixX cov(2,2);
402  cov.setZero();
403 
404  if (m_broadErrors) {
405  cov(0,0) = siWidth.phiR()*siWidth.phiR()/12;
406  cov(1,1) = siWidth.z()*siWidth.z()/12;
407  }
408  else {
409  cov(0,0) = siWidth.phiR()*siWidth.phiR()/(12*siWidth.colRow().x()*siWidth.colRow().x());
410  cov(1,1) = siWidth.z()*siWidth.z()/(12*siWidth.colRow().y()*siWidth.colRow().y());
411  }
412 
413  bool split = false;
414  float splitProb1 = 0;
415  float splitProb2 = 0;
416 
417  Eigen::Matrix<float,2,1> localPosition(localPos.x(), localPos.y());
418  Eigen::Matrix<float,2,2> localCovariance;
419  localCovariance.setZero();
420  localCovariance(0, 0) = cov(0, 0);
421  localCovariance(1, 1) = cov(1, 1);
422 
423  Eigen::Matrix<float,3,1> globalPosition(h.getX(),h.getY(),h.getZ());
424  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPosition.x() << " y=" << globalPosition.y() << " z=" << globalPosition.z() );
425 
426  cl.setMeasurement<2>(hash, localPosition, localCovariance);
427  cl.setIdentifier( rdoList.front().get_compact() );
428  cl.setRDOlist(rdoList);
429  cl.globalPosition() = globalPosition;
430  cl.setChannelsInPhiEta(siWidth.colRow()[0], siWidth.colRow()[1]);
431  cl.setWidthInEta(static_cast<float>(siWidth.widthPhiRZ()[1]));
432  cl.setIsSplit(split);
433  cl.setSplitProbabilities(splitProb1, splitProb2);
434  ATH_MSG_DEBUG("\t\txaod width in eta " << cl.widthInEta());
435 
436  return StatusCode::SUCCESS;
437 }
438 
439 StatusCode FPGAClusterConverter::createSCTCluster(const FPGATrackSimHit& h, const std::vector<Identifier>& rdoList, std::unique_ptr<InDet::SCT_Cluster>& cl) const {
440  ATH_MSG_DEBUG("\t Create InDet::SCTCluster from FPGATrackSimHit ");
441 
442 
443  IdentifierHash hash = h.getIdentifierHash();
444 
445  float phiWidth = h.getPhiWidth();
446  int strip = static_cast<int>(h.getPhiIndex());
447  ATH_CHECK(strip >= 0);
448  const InDetDD::SiDetectorElement* pDE = m_SCTManager->getDetectorElement(hash);
449  ATH_CHECK(pDE != nullptr);
450 
451 
452  Identifier wafer_id = m_SCTId->wafer_id(hash);
453  Identifier strip_id = m_SCTId->strip_id(wafer_id, strip);
454  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(strip_id);
455  ATH_MSG_DEBUG("\t\tcell: " << cell);
456  ATH_MSG_DEBUG("\t\tstrip_id " << strip_id);
457  ATH_MSG_DEBUG("\t\tstrip: " << cell);
458  ATH_MSG_DEBUG("\t\tStrip from idHelper: " << m_SCTId->strip(strip_id) );
459 
460  const InDetDD::SCT_ModuleSideDesign* design;
461  if (pDE->isBarrel()){
462  design = (static_cast<const InDetDD::SCT_ModuleSideDesign*>(&pDE->design()));
463  } else{
464  design = (static_cast<const InDetDD::StripStereoAnnulusDesign*>(&pDE->design()));
465  }
466 
467  const int firstStrip = m_SCTId->strip(rdoList.front());
468  const int lastStrip = m_SCTId->strip(rdoList.back());
469  const int row = m_SCTId->row(rdoList.front());
470  const int firstStrip1D = design->strip1Dim (firstStrip, row );
471  const int lastStrip1D = design->strip1Dim( lastStrip, row );
472  const InDetDD::SiCellId cell1(firstStrip1D);
473  const InDetDD::SiCellId cell2(lastStrip1D);
474  const InDetDD::SiLocalPosition firstStripPos( pDE->rawLocalPositionOfCell(cell1 ));
475  const InDetDD::SiLocalPosition lastStripPos( pDE->rawLocalPositionOfCell(cell2) );
476  const InDetDD::SiLocalPosition centre( (firstStripPos+lastStripPos) * 0.5 );
477  const double width = design->stripPitch() * ( lastStrip - firstStrip + 1 );
478 
479  const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends( design->endsOfStrip(centre) );
480  const double stripLength( std::abs(ends.first.xEta() - ends.second.xEta()) );
481 
482  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,1), Amg::Vector2D(width,stripLength) ); //TODO: ok??
483  Amg::Vector2D localPos(centre.xPhi(), centre.xEta());
484 
485  ATH_MSG_DEBUG("\t\tcentre eta: " << centre.xEta() << " phi: " << centre.xPhi());
486  ATH_MSG_DEBUG("\t\tStrip length: " << stripLength );
487  ATH_MSG_DEBUG("\t\tlocal position before shift: " << localPos.x() << " phi: " << localPos.y());
488  if (m_doShift) {
489  double shift = m_lorentzAngleToolStrip->getLorentzShift(hash,Gaudi::Hive::currentContext());
490  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
491  localPos = localPosShift;
492  }
493 
494  Amg::Vector3D globalPos = pDE->globalPosition(localPos);
495  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
496  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPos.x() << " y=" << globalPos.y() << " z=" << globalPos.z() );
497 
498  // Fill cov matrix. TODO: compare with https://gitlab.cern.ch/atlas/athena/-/blob/main/InnerDetector/InDetRecTools/SiClusterizationTool/src/ClusterMakerTool.cxx and xAOD function
499  const double col_x = siWidth.colRow().x();
500  const double col_y = siWidth.colRow().y();
501 
502  double scale_factor = 1.;
503  if ( std::abs(col_x-1) < std::numeric_limits<double>::epsilon() )
504  scale_factor = 1.05;
505  else if ( std::abs(col_x-2) < std::numeric_limits<double>::epsilon() )
506  scale_factor = 0.27;
507 
508  auto cov = Amg::MatrixX(2,2);
509  cov.setIdentity();
510  cov.fillSymmetric(0, 0, scale_factor * scale_factor * siWidth.phiR() * siWidth.phiR() * (1./12.));
511  cov.fillSymmetric(1, 1, siWidth.z() * siWidth.z() / col_y / col_y * (1./12.));
512 
513  // rotation for endcap SCT
514  if(pDE->design().shape() == InDetDD::Trapezoid || pDE->design().shape() == InDetDD::Annulus) {
515  double sn = pDE->sinStereoLocal(localPos);
516  double sn2 = sn*sn;
517  double cs2 = 1.-sn2;
518  double w = pDE->phiPitch(localPos)/pDE->phiPitch();
519  double v0 = (cov)(0,0)*w*w;
520  double v1 = (cov)(1,1);
521  cov.fillSymmetric( 0, 0, cs2 * v0 + sn2 * v1 );
522  cov.fillSymmetric( 0, 1, sn * std::sqrt(cs2) * (v0 - v1) );
523  cov.fillSymmetric( 1, 1, sn2 * v0 + cs2 * v1 );
524  }
525 
526  cl = std::make_unique<InDet::SCT_Cluster>(strip_id, localPos, std::vector<Identifier>(rdoList), siWidth, pDE, Amg::MatrixX(cov));
527 
528  return StatusCode::SUCCESS;
529 }
530 
531 StatusCode FPGAClusterConverter::createSCTCluster(const FPGATrackSimHit& h, const std::vector<Identifier>& rdoList, xAOD::StripCluster& cl) const {
532  ATH_MSG_DEBUG("\t Create xAOD::StripCluster from FPGATrackSimHit ");
533  //https://gitlab.cern.ch/atlas/athena/-/blob/main/InnerDetector/InDetRecTools/SiClusterizationTool/src/SCT_ClusteringTool.cxx
534 
535  IdentifierHash hash = h.getIdentifierHash();
536 
537  float phiWidth = h.getPhiWidth();
538  int strip = static_cast<int>(h.getPhiIndex());
539  ATH_CHECK(strip >= 0);
540  const InDetDD::SiDetectorElement* sDE = m_SCTManager->getDetectorElement(hash);
541  ATH_CHECK(sDE != nullptr);
542 
543  Identifier wafer_id = m_SCTId->wafer_id(hash);
544  Identifier strip_id = m_SCTId->strip_id(wafer_id, strip);
545  InDetDD::SiCellId cell = sDE->cellIdFromIdentifier(strip_id);
546  ATH_MSG_DEBUG("\t\tcell: " << cell);
547  ATH_MSG_DEBUG("\t\tstrip_id " << strip_id);
548  ATH_MSG_DEBUG("\t\tstrip: " << cell);
549  ATH_MSG_DEBUG("\t\tStrip from idHelper: " << m_SCTId->strip(strip_id) );
550 
551  const InDetDD::SCT_ModuleSideDesign* design;
552  if (sDE->isBarrel()){
553  design = (static_cast<const InDetDD::SCT_ModuleSideDesign*>(&sDE->design()));
554  } else{
555  design = (static_cast<const InDetDD::StripStereoAnnulusDesign*>(&sDE->design()));
556  }
557 
558  const int firstStrip = m_SCTId->strip(rdoList.front());
559  const int lastStrip = m_SCTId->strip(rdoList.back());
560  const int row = m_SCTId->row(rdoList.front());
561  const int firstStrip1D = design->strip1Dim (firstStrip, row);
562  const int lastStrip1D = design->strip1Dim(lastStrip, row);
563  const InDetDD::SiCellId cell1(firstStrip1D);
564  const InDetDD::SiCellId cell2(lastStrip1D);
565  if (cell2 != design->cellIdInRange(cell2) || cell1 != design->cellIdInRange(cell1)) { // this seems to solve EFTRACK-743
566  ATH_MSG_WARNING("Cell ID out of range. Skip making this Strip cluster");
567  return StatusCode::SUCCESS;
568  }
569  const InDetDD::SiLocalPosition firstStripPos( sDE->rawLocalPositionOfCell(cell1 ));
570  const InDetDD::SiLocalPosition lastStripPos( sDE->rawLocalPositionOfCell(cell2) );
571  const InDetDD::SiLocalPosition centre( (firstStripPos+lastStripPos) * 0.5 );
572  const double width = design->stripPitch() * ( lastStrip - firstStrip + 1 );
573 
574  const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends( design->endsOfStrip(centre) );
575  const double stripLength( std::abs(ends.first.xEta() - ends.second.xEta()) );
576 
577  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,1), Amg::Vector2D(width,stripLength) ); //TODO: ok??
578  Amg::Vector2D localPos(centre.xPhi(), centre.xEta());
579  if(m_useInherentLocalCoordinates){
580  // replace localPos with the one stored in the FPGATrackSimHit
581  localPos(0,0) = h.getPhiCoord();
582  }
583  ATH_MSG_DEBUG("\t\tcentre eta: " << centre.xEta() << " phi: " << centre.xPhi());
584  ATH_MSG_DEBUG("\t\tStrip length: " << stripLength );
585  ATH_MSG_DEBUG("\t\tlocal position before shift: " << localPos.x() << " phi: " << localPos.y());
586 
587  if (m_doShift) {
588  double shift = m_lorentzAngleToolStrip->getLorentzShift(hash,Gaudi::Hive::currentContext());
589  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
590  localPos = localPosShift;
591  }
592 
593  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
594 
595  /* TODO */
596  Eigen::Matrix<float,1,1> localPosition;
597  Eigen::Matrix<float,1,1> localCovariance;
598  localCovariance.setZero();
599 
600  if (sDE->isBarrel()) {
601  localPosition(0, 0) = localPos.x();
602  localCovariance(0, 0) = sDE->phiPitch() * sDE->phiPitch() * (1. / 12.);
603  }
604  else {
605  InDetDD::SiCellId cellId = sDE->cellIdOfPosition(localPos);
606  const InDetDD::StripStereoAnnulusDesign* designNew = dynamic_cast<const InDetDD::StripStereoAnnulusDesign*>(&sDE->design());
607 
608  if (!cellId.isValid() || cellId != designNew->cellIdInRange(cellId)) {
609  std::ostringstream msg;
610  msg << "Original cellId: " << cellId << " (strip=" << cellId.strip() << ")\n";
611  msg << "Cell ID invalid or out of range. Resetting to the closest cell of the active area.\n";
612  const InDetDD::SiCellId minCell = InDetDD::SiCellId(0); // get the first cell of the module
613  const Amg::Vector2D localPosMin = sDE->rawLocalPositionOfCell(minCell); // get raw local coordinates in Vector2D of the first cell
614  const InDetDD::SiCellId maxCell = InDetDD::SiCellId(designNew->cells() - 1); // get the last cell of the module
615  const Amg::Vector2D localPosMax = sDE->rawLocalPositionOfCell(maxCell); // get raw local coordinates in Vector2D of the last cell
616  msg << "Active area boundaries [eta,phi]: min [" << localPosMin.x() << ", " << localPosMin.y() << "] , " <<
617  "max [" << localPosMax.x() << ", " << localPosMax.y() << "]\n";
618  msg << "Compared to localPos of invalid cell: [" << localPos.x() << ", " << localPos.y() << "]\n";
619 
620  // find the closest cell of the active area and assign it to cellId
621  // this ignores the Lorentz corrections but re-positions the cluster within the active area
622  if (std::abs(localPos[Trk::locR] - localPosMin[Trk::locR]) < std::abs(localPos[Trk::locR] - localPosMax[Trk::locR])) {
623  // this check should suffice instead of something like the following:
624  // (std::sqrt(std::pow(localPos.x() - localPosMin.x(), 2) + std::pow(localPos.y() - localPosMin.y(), 2)) <
625  // std::sqrt(std::pow(localPos.x() - localPosMax.x(), 2) + std::pow(localPos.y() - localPosMax.y(), 2)))
626  msg << " \\___ resetting to minCell [" << localPosMin.x() << ", " << localPosMin.y() << "]";
627  cellId = minCell;
628  } else {
629  msg << " \\___ resetting to maxCell [" << localPosMax.x() << ", " << localPosMax.y() << "]";
630  cellId = maxCell;
631  }
632  ATH_MSG_WARNING(msg.str());
633  }
634  InDetDD::SiLocalPosition localInPolar = designNew->localPositionOfCellPC(cellId);
635  localPosition(0, 0) = localInPolar.xPhi();
636  localCovariance(0, 0) = designNew->phiPitchPhi() * designNew->phiPitchPhi() * (1./12.);
637  }
638 
639  Eigen::Matrix<float,3,1> globalPosition(h.getX(),h.getY(),h.getZ());
640  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPosition.x() << " y=" << globalPosition.y() << " z=" << globalPosition.z() );
641 
642  cl.setMeasurement<1>(hash, localPosition, localCovariance);
643  cl.setIdentifier( rdoList.front().get_compact() );
644  cl.setRDOlist(rdoList);
645  cl.globalPosition() = globalPosition;
646  cl.setChannelsInPhi(siWidth.colRow()[0]);
647 
648  return StatusCode::SUCCESS;
649 }
650 
651 StatusCode FPGAClusterConverter::createPixelCluster(const FPGATrackSimCluster& cluster, std::unique_ptr<InDet::PixelCluster>& cl) const {
652  ATH_MSG_DEBUG("\t Create InDet::PixelCluster from FPGATrackSimCluster");
653  FPGATrackSimHit clEq = cluster.getClusterEquiv();
654  std::vector<Identifier> rdoList;
655  ATH_CHECK(getRdoList(rdoList, cluster));
656  ATH_CHECK(createPixelCluster(clEq, rdoList, cl));
657  return StatusCode::SUCCESS;
658 }
659 
660 StatusCode FPGAClusterConverter::createPixelCluster(const FPGATrackSimCluster& cluster, xAOD::PixelCluster& cl) const {
661  ATH_MSG_DEBUG("\t Create xAOD::PixelCluster from FPGATrackSimCluster");
662  FPGATrackSimHit clEq = cluster.getClusterEquiv();
663  std::vector<Identifier> rdoList;
664  ATH_CHECK(getRdoList(rdoList, cluster));
665  ATH_CHECK(createPixelCluster(clEq, rdoList, cl));
666  return StatusCode::SUCCESS;
667 }
668 
669 StatusCode FPGAClusterConverter::createSCTCluster(const FPGATrackSimCluster& cluster, std::unique_ptr<InDet::SCT_Cluster>& cl) const {
670  ATH_MSG_DEBUG("\t Create InDet::SCT_Cluster from FPGATrackSimCluster");
671  FPGATrackSimHit clEq = cluster.getClusterEquiv();
672  std::vector<Identifier> rdoList;
673  ATH_CHECK(getRdoList(rdoList, cluster));
674  ATH_CHECK(createSCTCluster(clEq, rdoList,cl));
675  return StatusCode::SUCCESS;
676 }
677 
678 StatusCode FPGAClusterConverter::createSCTCluster(const FPGATrackSimCluster& cluster, xAOD::StripCluster& cl) const {
679  ATH_MSG_DEBUG("\t Create xAOD::StripCluster from FPGATrackSimCluster");
680  FPGATrackSimHit clEq = cluster.getClusterEquiv();
681  std::vector<Identifier> rdoList;
682  ATH_CHECK(getRdoList(rdoList, cluster));
683  ATH_CHECK(createSCTCluster(clEq, rdoList, cl));
684  return StatusCode::SUCCESS;
685 }
686 
687 
688 StatusCode FPGAClusterConverter::createPixelSPs(xAOD::SpacePointContainer& pixelSPs, xAOD::PixelClusterContainer& clustersCont) const {
689 
690  for (const xAOD::PixelCluster* p_cl : clustersCont)
691  {
692  pixelSPs.emplace_back(new xAOD::SpacePoint);
693 
694  // Global position
695  Eigen::Matrix<float, 3, 1> globalPos(p_cl->globalPosition().x(), p_cl->globalPosition().y(), p_cl->globalPosition().z());
696 
697  // Covariance
698  // TODO: check if we need to scale covariance based on rotation matrix like in PixelSpacePointFormationTool.cxx
699  const float & cov_r = p_cl->localCovariance<2>()(0,0);
700  const float & cov_z = p_cl->localCovariance<2>()(1,0);
701 
702  pixelSPs.back()->setSpacePoint(
703  p_cl->identifierHash(),
704  globalPos,
705  cov_r,
706  cov_z,
707  std::vector< const xAOD::UncalibratedMeasurement* >({ p_cl }) // measurement list
708  );
709  }
710 
711  return StatusCode::SUCCESS;
712 }
713 
714 
715 StatusCode FPGAClusterConverter::createSP(const FPGATrackSimCluster& cl, xAOD::SpacePoint& sp , xAOD::StripClusterContainer& clustersCont ) const {
716 
717  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
718  const InDet::BeamSpotData* beamSpot = *beamSpotHandle;
719  Amg::Vector3D vertex = beamSpot->beamVtx().position();
720 
721  const FPGATrackSimHit& clEq = cl.getClusterEquiv();
722 
723  const IdentifierHash& hash = clEq.getIdentifierHash();
724 
725  // Global position and covariance
726 
727  Eigen::Matrix<float,3,1> globalPos(clEq.getX(),clEq.getY(),clEq.getZ());
728 
729  // Covariance
730  // TODO: update to ITk? Can it be done as for pixel? (L728-729)?
731  // Lines taken from SCT_SpacePoint::setupLocalCovarianceSCT()
732  float deltaY = 0.0004; // roughly pitch of SCT (80 mu) / sqrt(12)
733  float covTerm = 1600.*deltaY;
734  Eigen::Matrix<float, 2, 1> variance(0.1, 8.*covTerm);
735  const InDetDD::SiDetectorElement* element = m_SCTManager->getDetectorElement(hash);
736  // Swap r/z covariance terms for endcap clusters
737  if ( element->isEndcap() )
738  std::swap( variance(0, 0), variance(1, 0) );
739  float cov_r = variance(0,0);
740  float cov_z = variance(1,0);
741 
742  // ***** Get Strips related infos *****
743 
744  // idHashes and measurements
745  std::vector<unsigned int> idHashList;
746  std::vector<const xAOD::UncalibratedMeasurement_v1*> measurements;
747 
748  //Get measurements
749 
750  float topHalfStripLength, bottomHalfStripLength;
751  Amg::Vector3D topStripDirection;
752  Amg::Vector3D bottomStripDirection;
753  Amg::Vector3D stripCenter1;
754  Amg::Vector3D stripCenter2;
755  int index = 0;
756  for (const FPGATrackSimHit& h : cl.getHitList()) {
757  idHashList.push_back(h.getIdentifierHash());
758  for (auto orig_cl : clustersCont) {
759  if (h.getIdentifierHash()==orig_cl->identifierHash()) {
760  if (index == 0) {ATH_CHECK(getStripsInfo(*orig_cl, topHalfStripLength, topStripDirection, stripCenter1));}
761  if (index == 1) {ATH_CHECK(getStripsInfo(*orig_cl, bottomHalfStripLength, bottomStripDirection, stripCenter2));}
762  measurements.push_back(orig_cl);
763  index++;
764  }
765  }
766  }
767 
768  Amg::Vector3D topTrajDir = 2. * ( stripCenter1 - vertex);
769  Amg::Vector3D topStripCenter = 0.5 * topTrajDir;
770  Amg::Vector3D stripCenterDistance = stripCenter1 - stripCenter2;
771 
772  ATH_MSG_DEBUG("topHalfStripLength = " << topHalfStripLength << " bottomHalfStripLength = " << bottomHalfStripLength);
773  ATH_MSG_DEBUG("topStripDirection = (" << topStripDirection.x() <<", " << topStripDirection.y() <<", " << topStripDirection.z() <<") " << "bottomStripDirection = (" << bottomStripDirection.x() <<", " << bottomStripDirection.y() <<", " << bottomStripDirection.z() <<") " );
774  ATH_MSG_DEBUG("stripCenterDistance = (" << stripCenterDistance.x() <<", " << stripCenterDistance.y() <<", " << stripCenterDistance.z() << ")" );
775  ATH_MSG_DEBUG("topStripCenter = (" << topStripCenter.x() <<", " << topStripCenter.y() <<", " << topStripCenter.z() << ")" );
776 
777  // Fill xAOD::SpacePoint
778  sp.setSpacePoint(
779  std::move(idHashList),
780  globalPos,
781  cov_r,
782  cov_z,
783  std::move(measurements),
784  topHalfStripLength,
785  bottomHalfStripLength,
786  topStripDirection.cast<float>(),
787  bottomStripDirection.cast<float>(),
788  stripCenterDistance.cast<float>(),
789  topStripCenter.cast<float>()
790  );
791 
792  return StatusCode::SUCCESS;
793 }
794 
795 StatusCode FPGAClusterConverter::getRdoList(std::vector<Identifier> &rdoList, const FPGATrackSimCluster& cluster) const {
796 
797  std::vector<FPGATrackSimHit> hits = cluster.getHitList();
798 
799  for (const FPGATrackSimHit& h : hits) {
800  IdentifierHash hash = h.getIdentifierHash();
801  int phiIndex = h.getPhiIndex();
802  int etaIndex = h.getEtaIndex();
803 
804  if (h.isPixel()) {
805  Identifier wafer_id_hit = m_pixelId->wafer_id(hash);
806  Identifier hit_id = m_pixelId->pixel_id(wafer_id_hit, phiIndex, etaIndex);
807  rdoList.push_back(hit_id);
808  }
809  if (h.isStrip()) {
810  Identifier wafer_id_hit = m_SCTId->wafer_id(hash);
811  Identifier hit_id = m_SCTId->strip_id(wafer_id_hit, int(phiIndex));
812  rdoList.push_back(hit_id);
813  }
814  }
815 
816  return StatusCode::SUCCESS;
817 
818 }
819 
820 
821 StatusCode FPGAClusterConverter::getRdoList(std::vector<Identifier> &rdoList, const FPGATrackSimHit& h) const {
822 
823  IdentifierHash hash = h.getIdentifierHash();
824  int phiIndex = h.getPhiIndex();
825  int etaIndex = h.getEtaIndex();
826 
827  if (h.isPixel()) {
828  Identifier wafer_id_hit = m_pixelId->wafer_id(hash);
829  Identifier hit_id = m_pixelId->pixel_id(wafer_id_hit, phiIndex, etaIndex);
830  rdoList.push_back(hit_id);
831  }
832  if (h.isStrip()) {
833  Identifier wafer_id_hit = m_SCTId->wafer_id(hash);
834  Identifier hit_id = m_SCTId->strip_id(wafer_id_hit, int(phiIndex));
835  rdoList.push_back(hit_id);
836  }
837 
838  return StatusCode::SUCCESS;
839 }
840 
841 StatusCode FPGAClusterConverter::getStripsInfo(const xAOD::StripCluster& cl, float& halfStripLength, Amg::Vector3D& stripDirection, Amg::Vector3D& stripCenter) const {
842 
843  const int &strip = m_SCTId->strip(cl.rdoList().front());
844  const IdentifierHash &hash = cl.identifierHash();
845 
846  const InDetDD::SiDetectorElement* sDE = m_SCTManager->getDetectorElement(hash);
847 
848  const Identifier &wafer_id = m_SCTId->wafer_id(hash);
849  const Identifier &strip_id = m_SCTId->strip_id(wafer_id, strip);
850  const InDetDD::SiCellId & cell = sDE->cellIdFromIdentifier(strip_id);
851 
852  const InDetDD::SiLocalPosition localPos( sDE->rawLocalPositionOfCell(cell ));
853  std::pair<Amg::Vector3D, Amg::Vector3D> end = (sDE->endsOfStrip(localPos));
854  stripCenter = 0.5 * (end.first + end.second);
855  Amg::Vector3D stripDir = end.first - end.second;
856 
857  halfStripLength = 0.5 * stripDir.norm();
858  stripDirection = stripDir / (2. * (halfStripLength));
859 
860  return StatusCode::SUCCESS;
861 }
862 
DataVector::reserve
void reserve(size_type n)
Attempt to preallocate enough memory for a specified number of elements.
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
PixelID.h
This is an Identifier helper class for the Pixel subdetector. This class is a factory for creating co...
FPGAClusterConverter::m_doShift
Gaudi::Property< bool > m_doShift
Definition: FPGAClusterConverter.h:99
FPGAClusterConverter::m_skipStripSpacePointFormation
Gaudi::Property< bool > m_skipStripSpacePointFormation
Definition: FPGAClusterConverter.h:98
InDetDD::SiDetectorElement::isEndcap
bool isEndcap() const
InDetDD::SCT_ModuleSideDesign::stripPitch
virtual double stripPitch(const SiLocalPosition &chargePos) const =0
give the strip pitch (dependence on position needed for forward)
FPGAClusterConverter::m_lorentzAngleToolPixel
ToolHandle< ISiLorentzAngleTool > m_lorentzAngleToolPixel
Definition: FPGAClusterConverter.h:95
FPGAClusterConverter::m_SCTManager
const InDetDD::SCT_DetectorManager * m_SCTManager
Definition: FPGAClusterConverter.h:93
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SCT_ID.h
This is an Identifier helper class for the SCT subdetector. This class is a factory for creating comp...
InDetDD::SolidStateDetectorElementBase::cellIdOfPosition
SiCellId cellIdOfPosition(const Amg::Vector2D &localPos) const
As in previous method but returns SiCellId.
Definition: SolidStateDetectorElementBase.cxx:224
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
FPGATrackSimCluster::getHitList
hitVector const & getHitList() const
Definition: FPGATrackSimCluster.h:30
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
SiliconTech::strip
@ strip
FPGATrackSimHit::isStrip
bool isStrip() const
Definition: FPGATrackSimHit.h:65
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
DataVector::emplace_back
value_type emplace_back(value_type pElem)
Add an element to the end of the collection.
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::locX
@ locX
Definition: ParamDefs.h:37
InDetDD::PixelModuleDesign::widthFromRowRange
double widthFromRowRange(const int rowMin, const int rowMax) const
Method to calculate phi width from a row range.
Definition: PixelModuleDesign.cxx:179
InDetDD::PixelModuleDesign
Definition: PixelModuleDesign.h:45
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:38
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
FPGATrackSimCluster
Definition: FPGATrackSimCluster.h:24
xAOD::SpacePoint_v1::elementIdList
const std::vector< DetectorIDHashType > & elementIdList() const
Returns the IdentifierHash of the spacepoint (corresponds to the detector element IdentifierHash)
Definition: SpacePoint_v1.cxx:14
makeComparison.deltaY
int deltaY
Definition: makeComparison.py:44
InDetDD::StripStereoAnnulusDesign::cellIdInRange
virtual SiCellId cellIdInRange(const SiCellId &) const override
DEPRECATED: only used in a stupid example (2014) Check if cell is in range.
Definition: StripStereoAnnulusDesign.cxx:532
SCT_ModuleSideDesign.h
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
InDetDD::SCT_ModuleSideDesign
Definition: SCT_ModuleSideDesign.h:40
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
FPGAClusterConverter::m_FPGAClusterKey
SG::ReadHandleKey< FPGATrackSimClusterCollection > m_FPGAClusterKey
Definition: FPGAClusterConverter.h:84
InDet::SiWidth::widthPhiRZ
const Amg::Vector2D & widthPhiRZ() const
Definition: SiWidth.h:121
InDetDD::DetectorDesign::shape
virtual DetectorShape shape() const
Shape of element.
Definition: DetectorDesign.cxx:96
FPGAClusterConverter::convertHits
virtual StatusCode convertHits(const std::vector< FPGATrackSimHit > &, InDet::PixelClusterCollection &, InDet::SCT_ClusterCollection &) const override final
Definition: FPGAClusterConverter.cxx:44
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
FPGATrackSimHit::getX
float getX() const
Definition: FPGATrackSimHit.h:149
InDetDD::SiCellId::isValid
bool isValid() const
Test if its in a valid state.
Definition: SiCellId.h:136
CaloClusterMLCalib::epsilon
constexpr float epsilon
Definition: CaloClusterMLGaussianMixture.h:16
plotBeamSpotVxVal.cov
cov
Definition: plotBeamSpotVxVal.py:200
FPGAClusterConverter::m_useInherentLocalCoordinates
Gaudi::Property< bool > m_useInherentLocalCoordinates
Definition: FPGAClusterConverter.h:100
keylayer_zslicemap.row
row
Definition: keylayer_zslicemap.py:155
xAOD::SpacePoint_v1
Definition: SpacePoint_v1.h:29
Trk::locR
@ locR
Definition: ParamDefs.h:44
xAOD::SpacePoint
SpacePoint_v1 SpacePoint
Definition: Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/SpacePoint.h:12
FPGAClusterConverter::m_broadErrors
Gaudi::Property< bool > m_broadErrors
Definition: FPGAClusterConverter.h:101
InDetDD::SiCellId::strip
int strip() const
Get strip number. Equivalent to phiIndex().
Definition: SiCellId.h:131
InDetDD::SCT_ModuleSideDesign::cells
int cells() const
number of readout stips within module side:
Definition: SCT_ModuleSideDesign.h:228
InDetDD::SCT_DetectorManager::getDetectorElement
virtual const SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements via Identifier
Definition: SCT_DetectorManager.cxx:66
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:360
xAOD::StripCluster_v1::rdoList
const std::vector< Identifier > rdoList() const
Returns the list of identifiers of the channels building the cluster.
Definition: StripCluster_v1.cxx:37
FPGAClusterConverter::m_pixelManager
const InDetDD::PixelDetectorManager * m_pixelManager
Definition: FPGAClusterConverter.h:92
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
FPGAClusterConverter::m_lorentzAngleToolStrip
ToolHandle< ISiLorentzAngleTool > m_lorentzAngleToolStrip
Definition: FPGAClusterConverter.h:96
FPGAClusterConverter::getStripsInfo
virtual StatusCode getStripsInfo(const xAOD::StripCluster &cl, float &halfStripLength, Amg::Vector3D &stripDirection, Amg::Vector3D &stripCenter) const override final
Definition: FPGAClusterConverter.cxx:841
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
SCT_CalibAlgs::lastStrip
@ lastStrip
Definition: SCT_CalibNumbers.h:10
FPGAClusterConverter::m_SCTId
const SCT_ID * m_SCTId
Definition: FPGAClusterConverter.h:91
InDetDD::SiLocalPosition
Definition: SiLocalPosition.h:31
InDetDD::SiLocalPosition::xPhi
double xPhi() const
position along phi direction:
Definition: SiLocalPosition.h:123
FPGAClusterConverter::m_pixelId
const PixelID * m_pixelId
Definition: FPGAClusterConverter.h:90
AtlasDetectorID.h
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
xAOD::StripCluster
StripCluster_v1 StripCluster
Define the version of the strip cluster class.
Definition: StripCluster.h:13
InDetDD::SiDetectorElement::phiPitch
double phiPitch() const
Pitch (inline methods)
FPGATrackSimClusterCollection
std::vector< FPGATrackSimCluster > FPGATrackSimClusterCollection
Definition: FPGATrackSimClusterCollection.h:13
InDetDD::SiDetectorElement::cellIdFromIdentifier
virtual SiCellId cellIdFromIdentifier(const Identifier &identifier) const override final
SiCellId from Identifier.
Definition: SiDetectorElement.cxx:120
SpacePointCollection.h
InDetDD::PixelModuleDesign::widthFromColumnRange
double widthFromColumnRange(const int colMin, const int colMax) const
Method to calculate eta width from a column range.
Definition: PixelModuleDesign.cxx:167
InDetDD::SCT_ModuleSideDesign::cellIdInRange
virtual SiCellId cellIdInRange(const SiCellId &cellId) const override
Check if cell is in range.
Definition: SCT_ModuleSideDesign.cxx:101
PixelDetectorManager.h
FPGAClusterConverter::FPGAClusterConverter
FPGAClusterConverter(const std::string &type, const std::string &name, const IInterface *)
Definition: FPGAClusterConverter.cxx:20
FPGAClusterConverter::createSCTCluster
virtual StatusCode createSCTCluster(const FPGATrackSimHit &h, const std::vector< Identifier > &rdoList, std::unique_ptr< InDet::SCT_Cluster > &) const override final
Definition: FPGAClusterConverter.cxx:439
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
parseMapping.v0
def v0
Definition: parseMapping.py:149
xAOD::PixelCluster
PixelCluster_v1 PixelCluster
Define the version of the pixel cluster class.
Definition: Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/PixelCluster.h:13
InDetDD::SiLocalPosition::xEta
double xEta() const
position along eta direction:
Definition: SiLocalPosition.h:118
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
InDetDD::Annulus
@ Annulus
Definition: DetectorDesign.h:42
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
FPGAClusterConverter::createSP
virtual StatusCode createSP(const FPGATrackSimCluster &cl, xAOD::SpacePoint &sp, xAOD::StripClusterContainer &clustersCont) const override final
Definition: FPGAClusterConverter.cxx:715
SCT_ID::row
int row(const Identifier &id) const
Definition: SCT_ID.h:716
InDetDD::StripStereoAnnulusDesign
Definition: StripStereoAnnulusDesign.h:50
xAOD::SpacePoint_v1::setSpacePoint
void setSpacePoint(DetectorIDHashType idHash, const Eigen::Matrix< float, 3, 1 > &globPos, float cov_r, float cov_z, std::vector< const xAOD::UncalibratedMeasurement * > &&measurementIndexes)
Definition: SpacePoint_v1.cxx:123
FPGAClusterConverter::getRdoList
virtual StatusCode getRdoList(std::vector< Identifier > &rdoList, const FPGATrackSimCluster &cluster) const override final
Definition: FPGAClusterConverter.cxx:795
test_pyathena.parent
parent
Definition: test_pyathena.py:15
xAOD::StripCluster_v1
Definition: StripCluster_v1.h:17
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimHit::getY
float getY() const
Definition: FPGATrackSimHit.h:150
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
FPGATrackSimHit::getIdentifierHash
unsigned getIdentifierHash() const
Definition: FPGATrackSimHit.h:81
DataVector::back
const T * back() const
Access the last element in the collection as an rvalue.
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
FPGAClusterConverter::convertClusters
virtual StatusCode convertClusters(const std::vector< FPGATrackSimCluster > &, InDet::PixelClusterCollection &, InDet::SCT_ClusterCollection &) const override final
Definition: FPGAClusterConverter.cxx:164
FPGATrackSimHit::isPixel
bool isPixel() const
Definition: FPGATrackSimHit.h:64
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
FPGATrackSimHit::getZ
float getZ() const
Definition: FPGATrackSimHit.h:151
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
InDetDD::SiDetectorElement::endsOfStrip
std::pair< Amg::Vector3D, Amg::Vector3D > endsOfStrip(const Amg::Vector2D &position) const
Special method for SCT to retrieve the two ends of a "strip" Returned coordinates are in global frame...
Definition: SiDetectorElement.cxx:339
FPGAClusterConverter::createPixelCluster
virtual StatusCode createPixelCluster(const FPGATrackSimHit &h, const std::vector< Identifier > &rdoList, std::unique_ptr< InDet::PixelCluster > &) const override final
Definition: FPGAClusterConverter.cxx:250
FPGATrackSimCluster::getClusterEquiv
FPGATrackSimHit const & getClusterEquiv() const
Definition: FPGATrackSimCluster.h:31
InDetDD::StripStereoAnnulusDesign::phiPitchPhi
double phiPitchPhi(const SiLocalPosition &localPosition) const
Definition: StripStereoAnnulusDesign.h:291
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
IdentifierHash.h
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
InDetDD::SiDetectorElement::isBarrel
bool isBarrel() const
FPGAClusterConverter::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: FPGAClusterConverter.h:85
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
FPGAClusterConverter::convertSpacePoints
virtual StatusCode convertSpacePoints(const std::vector< FPGATrackSimCluster > &fpgaSPs, xAOD::SpacePointContainer &SPStripCont, xAOD::SpacePointContainer &SPPixelCont, xAOD::StripClusterContainer &stripClusterCont, xAOD::PixelClusterContainer &pixelClusterCont) const override final
Definition: FPGAClusterConverter.cxx:227
InDetDD::SiCellId
Definition: SiCellId.h:29
eflowRec::phiIndex
unsigned int phiIndex(float phi, float binsize)
calculate phi index for a given phi
Definition: EtaPhiLUT.cxx:23
StripStereoAnnulusDesign.h
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
InDetDD::SolidStateDetectorElementBase::rawLocalPositionOfCell
Amg::Vector2D rawLocalPositionOfCell(const SiCellId &cellId) const
Returns position (center) of cell.
Definition: SolidStateDetectorElementBase.cxx:230
InDet::BeamSpotData
Definition: BeamSpotData.h:21
xAOD::PixelCluster_v1
Definition: PixelCluster_v1.h:17
h
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:108
InDetDD::SCT_ModuleSideDesign::strip1Dim
virtual int strip1Dim(int strip, int row) const override
only relevant for SCT.
Definition: SCT_ModuleSideDesign.h:279
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
SCT_ID::strip
int strip(const Identifier &id) const
Definition: SCT_ID.h:722
PixelModuleDesign.h
InDetDD::SolidStateDetectorElementBase::globalPosition
HepGeom::Point3D< double > globalPosition(const HepGeom::Point3D< double > &localPos) const
transform a reconstruction local position into a global position (inline):
DataVector::pop_back
void pop_back()
Remove the last element from the collection.
PixelID::pixel_id
Identifier pixel_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int phi_index, int eta_index) const
For an individual pixel.
Definition: PixelID.h:428
InDetDD::SiDetectorElement::sinStereoLocal
double sinStereoLocal(const Amg::Vector2D &localPos) const
Angle of strip in local frame with respect to the etaAxis.
Definition: SiDetectorElement.cxx:288
xAOD::phiWidth
phiWidth
Definition: RingSetConf_v1.cxx:606
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
InDet::SiWidth
Definition: SiWidth.h:25
InDet::SiWidth::colRow
const Amg::Vector2D & colRow() const
Definition: SiWidth.h:115
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:491
SCT_CalibAlgs::firstStrip
@ firstStrip
Definition: SCT_CalibNumbers.h:10
InDetDD::PixelDetectorManager::getDetectorElement
virtual const SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements : via Identifier
Definition: PixelDetectorManager.cxx:80
InDet::SiWidth::phiR
double phiR() const
Definition: SiWidth.h:126
SCT_ID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side) const
For a single side of module.
Definition: SCT_ID.h:464
SCT_DetectorManager.h
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:198
InDetDD::SiDetectorElement::design
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
InDet::SCT_ClusterCollection
Trk::PrepRawDataCollection< SCT_Cluster > SCT_ClusterCollection
Definition: SCT_ClusterCollection.h:26
InDetDD::StripStereoAnnulusDesign::localPositionOfCellPC
SiLocalPosition localPositionOfCellPC(const SiCellId &cellId) const
This is for debugging only.
Definition: StripStereoAnnulusDesign.cxx:428
InDetDD::SCT_ModuleSideDesign::endsOfStrip
virtual std::pair< SiLocalPosition, SiLocalPosition > endsOfStrip(const SiLocalPosition &position) const override=0
give the ends of strips
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:25
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
FPGAClusterConverter::initialize
virtual StatusCode initialize() override final
Definition: FPGAClusterConverter.cxx:23
maxCell
#define maxCell
FPGAClusterConverter::createPixelSPs
virtual StatusCode createPixelSPs(xAOD::SpacePointContainer &pixelSPs, xAOD::PixelClusterContainer &clustersCont) const override final
Definition: FPGAClusterConverter.cxx:688
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
InDet::SiWidth::z
double z() const
Definition: SiWidth.h:131
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
InDet::PixelClusterCollection
Trk::PrepRawDataCollection< PixelCluster > PixelClusterCollection
Definition: PixelClusterCollection.h:26
InDetDD::Trapezoid
@ Trapezoid
Definition: DetectorDesign.h:42
FPGAClusterConverter.h
SCT_ID::strip_id
Identifier strip_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side, int strip) const
For an individual strip.
Definition: SCT_ID.h:535
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sat Nov 1 2025 21:10:17 for ATLAS Offline Software by   doxygen 1.8.18