Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Public Attributes | Private Attributes | List of all members
FPGAClusterConverter Class Reference

#include <FPGAClusterConverter.h>

Inheritance diagram for FPGAClusterConverter:
Collaboration diagram for FPGAClusterConverter:

Public Member Functions

 FPGAClusterConverter (const std::string &type, const std::string &name, const IInterface *)
 
virtual ~FPGAClusterConverter ()=default
 
virtual StatusCode initialize () override final
 
virtual StatusCode convertHits (const std::vector< FPGATrackSimHit > &, InDet::PixelClusterCollection &, InDet::SCT_ClusterCollection &) const override final
 
virtual StatusCode convertHits (const std::vector< const FPGATrackSimHit * > &, InDet::PixelClusterCollection &, InDet::SCT_ClusterCollection &) const override final
 
virtual StatusCode convertHits (const std::vector< FPGATrackSimHit > &hits, xAOD::PixelClusterContainer &pixelCont, xAOD::StripClusterContainer &SCTCont) const override final
 
virtual StatusCode convertClusters (const std::vector< FPGATrackSimCluster > &, InDet::PixelClusterCollection &, InDet::SCT_ClusterCollection &) const override final
 
virtual StatusCode convertClusters (const std::vector< FPGATrackSimCluster > &cl, xAOD::PixelClusterContainer &pixelCont, xAOD::StripClusterContainer &SCTCont) const override final
 
virtual StatusCode convertSpacePoints (const std::vector< FPGATrackSimCluster > &fpgaSPs, xAOD::SpacePointContainer &SPStripCont, xAOD::SpacePointContainer &SPPixelCont, xAOD::StripClusterContainer &stripClusterCont, xAOD::PixelClusterContainer &pixelClusterCont) const override final
 
virtual StatusCode createPixelCluster (const FPGATrackSimHit &h, const std::vector< Identifier > &rdoList, std::unique_ptr< InDet::PixelCluster > &) const override final
 
virtual StatusCode createPixelCluster (const FPGATrackSimHit &h, const std::vector< Identifier > &rdoList, xAOD::PixelCluster &) const override final
 
virtual StatusCode createSCTCluster (const FPGATrackSimHit &h, const std::vector< Identifier > &rdoList, std::unique_ptr< InDet::SCT_Cluster > &) const override final
 
virtual StatusCode createSCTCluster (const FPGATrackSimHit &h, const std::vector< Identifier > &rdoList, xAOD::StripCluster &) const override final
 
virtual StatusCode createPixelCluster (const FPGATrackSimCluster &, std::unique_ptr< InDet::PixelCluster > &) const override final
 
virtual StatusCode createPixelCluster (const FPGATrackSimCluster &, xAOD::PixelCluster &) const override final
 
virtual StatusCode createSCTCluster (const FPGATrackSimCluster &, std::unique_ptr< InDet::SCT_Cluster > &) const override final
 
virtual StatusCode createSCTCluster (const FPGATrackSimCluster &, xAOD::StripCluster &) const override final
 
virtual StatusCode createSP (const FPGATrackSimCluster &cl, xAOD::SpacePoint &sp, xAOD::StripClusterContainer &clustersCont) const override final
 
virtual StatusCode createPixelSPs (xAOD::SpacePointContainer &pixelSPs, xAOD::PixelClusterContainer &clustersCont) const override final
 
virtual StatusCode getRdoList (std::vector< Identifier > &rdoList, const FPGATrackSimCluster &cluster) const override final
 
virtual StatusCode getRdoList (std::vector< Identifier > &rdoList, const FPGATrackSimHit &hit) const override final
 
virtual StatusCode getStripsInfo (const xAOD::StripCluster &cl, float &halfStripLength, Amg::Vector3D &stripDirection, Amg::Vector3D &stripCenter) const override final
 

Public Attributes

SG::ReadHandleKey< FPGATrackSimClusterCollection > m_FPGAClusterKey {this, "FPGATrackSimClusterKey","FPGAClusters","FPGATrackSim Clusters key"}
 
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
 
bool m_doShift = true
 

Private Attributes

const PixelID * m_pixelId {nullptr}
 
const SCT_ID * m_SCTId {nullptr}
 
const InDetDD::PixelDetectorManager * m_pixelManager {nullptr}
 
const InDetDD::SCT_DetectorManager * m_SCTManager {nullptr}
 
ToolHandle< ISiLorentzAngleTool > m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "Tool to retrieve Lorentz angle of SCT"}
 
Gaudi::Property< bool > m_skipStripSpacePointFormation {this, "skipStripSpFormation", true, "Should be enabled in case we want to test strip seeding"}
 

Detailed Description

Definition at line 40 of file FPGAClusterConverter.h.

Constructor & Destructor Documentation

◆ FPGAClusterConverter()

FPGAClusterConverter::FPGAClusterConverter ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 20 of file FPGAClusterConverter.cxx.

20  :
21  base_class(type, name, parent) {}

◆ ~FPGAClusterConverter()

virtual FPGAClusterConverter::~FPGAClusterConverter ( )
virtualdefault

Member Function Documentation

◆ convertClusters() [1/2]

StatusCode FPGAClusterConverter::convertClusters ( const std::vector< FPGATrackSimCluster > &  clusters,
InDet::PixelClusterCollection &  pixelColl,
InDet::SCT_ClusterCollection &  SCTColl 
) const
finaloverridevirtual

Definition at line 163 of file FPGAClusterConverter.cxx.

165  {
166  ATH_MSG_DEBUG("Found " << clusters.size() << " FPGATrackSimClusters [InDet]");
167  // reserve some memory
168  pixelColl.reserve(clusters.size());
169  SCTColl.reserve(clusters.size());
170  for(const FPGATrackSimCluster& cl : clusters) {
171 
172  FPGATrackSimHit clEq = cl.getClusterEquiv();
173  std::vector<Identifier> rdoList;
174  ATH_CHECK(getRdoList(rdoList, cl));
175 
176  std::unique_ptr<InDet::PixelCluster> pixelCl{};
177  std::unique_ptr<InDet::SCT_Cluster> SCTCl{};
178 
179  if (clEq.isPixel()) {
180  ATH_CHECK(createPixelCluster(clEq, rdoList, pixelCl));
181  if (pixelCl) pixelColl.push_back(std::move(pixelCl));
182  }
183  if (clEq.isStrip()) {
184  ATH_CHECK(createSCTCluster(clEq, rdoList, SCTCl));
185  if (SCTCl) SCTColl.push_back(std::move(SCTCl));
186  }
187  }
188 
189  ATH_MSG_DEBUG("pixelColl size: " << pixelColl.size() << " SCTColl size: " << SCTColl.size());
190 
191  return StatusCode::SUCCESS;
192 }

◆ convertClusters() [2/2]

StatusCode FPGAClusterConverter::convertClusters ( const std::vector< FPGATrackSimCluster > &  cl,
xAOD::PixelClusterContainer &  pixelCont,
xAOD::StripClusterContainer &  SCTCont 
) const
finaloverridevirtual

Definition at line 194 of file FPGAClusterConverter.cxx.

196  {
197  ATH_MSG_DEBUG("Found " << clusters.size() << " FPGATrackSimClusters [xAOD]");
198  // reserve some memory
199  pixelCont.reserve(clusters.size());
200  SCTCont.reserve(clusters.size());
201 
202  for(const FPGATrackSimCluster& cl : clusters) {
203 
204  FPGATrackSimHit clEq = cl.getClusterEquiv();
205 
206  std::vector<Identifier> rdoList;
207  ATH_CHECK(getRdoList(rdoList, cl));
208 
209  if (clEq.isPixel()) {
210  xAOD::PixelCluster *xaod_pcl = new xAOD::PixelCluster();
211  pixelCont.push_back(xaod_pcl);
212  ATH_CHECK(createPixelCluster(clEq, rdoList, *xaod_pcl));
213  }
214  if (clEq.isStrip()) {
215  xAOD::StripCluster *xaod_scl = new xAOD::StripCluster();
216  SCTCont.push_back(xaod_scl);
217  ATH_CHECK(createSCTCluster(clEq, rdoList, *xaod_scl));
218  }
219  }
220 
221  ATH_MSG_DEBUG("xAOD pixelCont size: " << pixelCont.size() << " xAOD SCTCont size: " << SCTCont.size());
222 
223  return StatusCode::SUCCESS;
224 }

◆ convertHits() [1/3]

StatusCode FPGAClusterConverter::convertHits ( const std::vector< const FPGATrackSimHit * > &  hits,
InDet::PixelClusterCollection &  pixelColl,
InDet::SCT_ClusterCollection &  SCTColl 
) const
finaloverridevirtual

Definition at line 74 of file FPGAClusterConverter.cxx.

76  {
77  ATH_MSG_DEBUG("Found " << hits.size() << " FPGATrackSimHits [InDet]");
78 
79  // *** Match FPGATrackSimHit to FPGATrackSimCluster
80  SG::ReadHandle<FPGATrackSimClusterCollection> FPGAClustersHandle (m_FPGAClusterKey);
81  if (!FPGAClustersHandle.isValid()) {
82  ATH_MSG_FATAL("Failed to retrieve FPGATrackSimClusterCollection");
83  return StatusCode::FAILURE;
84  }
85  const FPGATrackSimClusterCollection *FPGAClusterColl = FPGAClustersHandle.cptr();
86 
87  for(const FPGATrackSimHit *h : hits){
88  IdentifierHash hash = h->getIdentifierHash();
89  FPGATrackSimCluster cl;
90  for (const FPGATrackSimCluster& cluster: *FPGAClusterColl){
91  FPGATrackSimHit clusterEq = cluster.getClusterEquiv();
92  if (hash == clusterEq.getIdentifierHash()) {
93  cl = cluster;
94  break;
95  }
96  }
97  FPGATrackSimHit clEq = cl.getClusterEquiv();
98 
99  // --- DEBUG
100  ATH_MSG_DEBUG("Hit identifier " << h->getIdentifierHash());
101  ATH_MSG_DEBUG("Cluster identifier " << clEq.getIdentifierHash());
102  // ---
103 
104  // *** FPGATrackSimCluster matched
105 
106  std::vector<Identifier> rdoList;
107  ATH_CHECK(getRdoList(rdoList,cl));
108 
109  std::unique_ptr<InDet::PixelCluster> pixelCl{};
110  std::unique_ptr<InDet::SCT_Cluster> SCTCl{};
111 
112  if (clEq.isPixel()) {
113  ATH_CHECK(createPixelCluster(clEq, rdoList, pixelCl));
114  if (pixelCl) pixelColl.push_back(std::move(pixelCl));
115  }
116  if (clEq.isStrip()) {
117  ATH_CHECK(createSCTCluster(clEq, rdoList, SCTCl));
118  if (SCTCl) SCTColl.push_back(std::move(SCTCl));
119  }
120 
121  }
122 
123  ATH_MSG_DEBUG("pixelColl size: " << pixelColl.size() << " SCTColl size: " << SCTColl.size());
124 
125  return StatusCode::SUCCESS;
126 
127 }

◆ convertHits() [2/3]

StatusCode FPGAClusterConverter::convertHits ( const std::vector< FPGATrackSimHit > &  hits,
InDet::PixelClusterCollection &  pixelColl,
InDet::SCT_ClusterCollection &  SCTColl 
) const
finaloverridevirtual

Definition at line 43 of file FPGAClusterConverter.cxx.

45  {
46  ATH_MSG_DEBUG("Found " << hits.size() << " FPGATrackSimHits [InDet]");
47  // reserve some memory
48  pixelColl.reserve(hits.size());
49  SCTColl.reserve(hits.size());
50  for(const FPGATrackSimHit& h : hits) {
51 
52  std::vector<Identifier> rdoList;
53  ATH_CHECK(getRdoList(rdoList, h));
54 
55  std::unique_ptr<InDet::PixelCluster> pixelCl{};
56  std::unique_ptr<InDet::SCT_Cluster> SCTCl{};
57 
58  if (h.isPixel()) {
59  ATH_CHECK(createPixelCluster(h, rdoList, pixelCl));
60  if (pixelCl) pixelColl.push_back(std::move(pixelCl));
61  }
62  if (h.isStrip()) {
63  ATH_CHECK(createSCTCluster(h, rdoList, SCTCl));
64  if (SCTCl) SCTColl.push_back(std::move(SCTCl));
65  }
66  }
67 
68  ATH_MSG_DEBUG("pixelColl size: " << pixelColl.size() << " SCTColl size: " << SCTColl.size() );
69 
70  return StatusCode::SUCCESS;
71 }

◆ convertHits() [3/3]

StatusCode FPGAClusterConverter::convertHits ( const std::vector< FPGATrackSimHit > &  hits,
xAOD::PixelClusterContainer &  pixelCont,
xAOD::StripClusterContainer &  SCTCont 
) const
finaloverridevirtual

Definition at line 130 of file FPGAClusterConverter.cxx.

132  {
133  ATH_MSG_DEBUG("Found " << hits.size() << " FPGATrackSimHits [xAOD]");
134  // reserve some memory
135  pixelCont.reserve(hits.size());
136  SCTCont.reserve(hits.size());
137  for(const FPGATrackSimHit& h : hits) {
138 
139  std::vector<Identifier> rdoList;
140  ATH_CHECK(getRdoList(rdoList, h));
141 
142  if (h.isPixel()) {
143  xAOD::PixelCluster *xaod_pcl = new xAOD::PixelCluster();
144  pixelCont.push_back(xaod_pcl);
145  ATH_CHECK(createPixelCluster(h, rdoList, *xaod_pcl));
146  }
147  if (h.isStrip()) {
148  xAOD::StripCluster *xaod_scl = new xAOD::StripCluster();
149  SCTCont.push_back(xaod_scl);
150  ATH_CHECK(createSCTCluster(h, rdoList, *xaod_scl));
151  if(!xaod_scl->rdoList().size())
152  SCTCont.pop_back();
153  }
154  }
155 
156  ATH_MSG_DEBUG("xAOD pixelCont size: " << pixelCont.size() << " xAOD pixelCont size: " << SCTCont.size());
157 
158  return StatusCode::SUCCESS;
159 }

◆ convertSpacePoints()

StatusCode FPGAClusterConverter::convertSpacePoints ( const std::vector< FPGATrackSimCluster > &  fpgaSPs,
xAOD::SpacePointContainer &  SPStripCont,
xAOD::SpacePointContainer &  SPPixelCont,
xAOD::StripClusterContainer &  stripClusterCont,
xAOD::PixelClusterContainer &  pixelClusterCont 
) const
finaloverridevirtual

Definition at line 226 of file FPGAClusterConverter.cxx.

230  {
231  ATH_MSG_INFO("Converting Pixel SPs");
232  SPPixelCont.reserve(pixelClusterCont.size());
233  ATH_CHECK(createPixelSPs(SPPixelCont, pixelClusterCont));
234 
235  if (not m_skipStripSpacePointFormation) {
236  ATH_MSG_INFO("Converting Strip SPs");
237  SPStripCont.reserve(fpgaSPs.size());
238  for (const FPGATrackSimCluster& cl : fpgaSPs) {
239  xAOD::SpacePoint* xaod_sp = new xAOD::SpacePoint();
240  SPStripCont.push_back(xaod_sp);
241  ATH_CHECK(createSP(cl, *xaod_sp, stripClusterCont));
242  if (!xaod_sp->elementIdList().size()) SPStripCont.pop_back();
243  }
244  }
245 
246  return StatusCode::SUCCESS;
247 }

◆ createPixelCluster() [1/4]

StatusCode FPGAClusterConverter::createPixelCluster ( const FPGATrackSimCluster &  cluster,
std::unique_ptr< InDet::PixelCluster > &  cl 
) const
finaloverridevirtual

Definition at line 590 of file FPGAClusterConverter.cxx.

590  {
591  ATH_MSG_DEBUG("\t Create InDet::PixelCluster from FPGATrackSimCluster");
592  FPGATrackSimHit clEq = cluster.getClusterEquiv();
593  std::vector<Identifier> rdoList;
594  ATH_CHECK(getRdoList(rdoList, cluster));
595  ATH_CHECK(createPixelCluster(clEq, rdoList, cl));
596  return StatusCode::SUCCESS;
597 }

◆ createPixelCluster() [2/4]

StatusCode FPGAClusterConverter::createPixelCluster ( const FPGATrackSimCluster &  cluster,
xAOD::PixelCluster &  cl 
) const
finaloverridevirtual

Definition at line 599 of file FPGAClusterConverter.cxx.

599  {
600  ATH_MSG_DEBUG("\t Create xAOD::PixelCluster from FPGATrackSimCluster");
601  FPGATrackSimHit clEq = cluster.getClusterEquiv();
602  std::vector<Identifier> rdoList;
603  ATH_CHECK(getRdoList(rdoList, cluster));
604  ATH_CHECK(createPixelCluster(clEq, rdoList, cl));
605  return StatusCode::SUCCESS;
606 }

◆ createPixelCluster() [3/4]

StatusCode FPGAClusterConverter::createPixelCluster ( const FPGATrackSimHit &  h,
const std::vector< Identifier > &  rdoList,
std::unique_ptr< InDet::PixelCluster > &  cl 
) const
finaloverridevirtual

Definition at line 249 of file FPGAClusterConverter.cxx.

249  {
250  ATH_MSG_DEBUG("\tCreate InDet::PixelCluster from FPGATrackSimHit");
251 
252  IdentifierHash hash = h.getIdentifierHash();
253 
254  float etaWidth = h.getEtaWidth();
255  float phiWidth = h.getPhiWidth();
256  int phiIndex = h.getPhiIndex();
257  int etaIndex = h.getEtaIndex();
258 
259  const InDetDD::SiDetectorElement* pDE = m_pixelManager->getDetectorElement(hash);
260 
261  if( !pDE ) {
262  ATH_MSG_ERROR("Detector Element doesn't exist " << hash);
263  return StatusCode::FAILURE;
264  }
265 
266  // *** Get cell from id
267  Identifier wafer_id = m_pixelId->wafer_id(hash);
268  Identifier hit_id = m_pixelId->pixel_id(wafer_id, phiIndex, etaIndex);
269  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(hit_id);
270  if(!cell.isValid()) {
271  ATH_MSG_DEBUG("\t\tcell not valid");
272  return StatusCode::FAILURE;
273  }
274  const InDetDD::PixelModuleDesign* design (dynamic_cast<const InDetDD::PixelModuleDesign*>(&pDE->design()));
275 
276  // **** Get InDet::SiWidth
277 
278  int colMin = static_cast<int>(etaIndex-0.5*etaWidth);
279  int colMax = colMin+etaWidth;
280 
281  int rowMin = static_cast<int>(phiIndex-0.5*phiWidth);
282  int rowMax = rowMin+phiWidth;
283 
284  double etaW = design->widthFromColumnRange(colMin, colMax-1);
285  double phiW = design->widthFromRowRange(rowMin, rowMax-1);
286 
287  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,etaWidth),Amg::Vector2D(phiW,etaW));
288 
289  // **** Get SiLocalPosition from cell id and define Amg::Vector2D position
290  InDetDD::SiLocalPosition silPos(pDE->rawLocalPositionOfCell(cell));
291  Amg::Vector2D localPos(silPos);
292 
293  //TODO: understand if shift is needed
294  if (m_doShift) {
295  double shift = m_lorentzAngleTool->getLorentzShift(hash,Gaudi::Hive::currentContext());
296  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
297  localPos = localPosShift;
298  }
299 
300  Amg::Vector3D globalPos = pDE->globalPosition(localPos);
301  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
302  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPos.x() << " y=" << globalPos.y() << " z=" << globalPos.z() );
303 
304  Amg::MatrixX cov(2,2);
305  cov.setZero();
306 
307  cov(0,0) = siWidth.phiR()*siWidth.phiR()/12;
308  cov(1,1) = siWidth.z()*siWidth.z()/12;
309  float dummy_omegax = 0.5;
310  float dummy_omegay = 0.5;
311  bool split = false;
312  float splitProb1 = 0;
313  float splitProb2 = 0;
314 
315  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);
316 
317  return StatusCode::SUCCESS;
318 }

◆ createPixelCluster() [4/4]

StatusCode FPGAClusterConverter::createPixelCluster ( const FPGATrackSimHit &  h,
const std::vector< Identifier > &  rdoList,
xAOD::PixelCluster &  cl 
) const
finaloverridevirtual

Definition at line 320 of file FPGAClusterConverter.cxx.

320  {
321  ATH_MSG_DEBUG("\tCreate xAOD::PixelCluster from FPGATrackSimHit");
322 
323  IdentifierHash hash = h.getIdentifierHash();
324 
325  float etaWidth = h.getEtaWidth();
326  float phiWidth = h.getPhiWidth();
327  int phiIndex = h.getPhiIndex();
328  int etaIndex = h.getEtaIndex();
329 
330  const InDetDD::SiDetectorElement* pDE = m_pixelManager->getDetectorElement(hash);
331 
332  if( !pDE ) {
333  ATH_MSG_ERROR("Detector Element doesn't exist " << hash);
334  return StatusCode::FAILURE;
335  }
336 
337  // *** Get cell from id
338  Identifier wafer_id = m_pixelId->wafer_id(hash);
339  Identifier hit_id = m_pixelId->pixel_id(wafer_id, phiIndex, etaIndex);
340  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(hit_id);
341  if(!cell.isValid()) {
342  ATH_MSG_DEBUG("\t\tcell not valid");
343  return StatusCode::FAILURE;
344  }
345  const InDetDD::PixelModuleDesign* design (dynamic_cast<const InDetDD::PixelModuleDesign*>(&pDE->design()));
346 
347  // **** Get InDet::SiWidth
348 
349  int colMin = static_cast<int>(etaIndex-0.5*etaWidth);
350  int colMax = colMin+etaWidth;
351 
352  int rowMin = static_cast<int>(phiIndex-0.5*phiWidth);
353  int rowMax = rowMin+phiWidth;
354 
355  double etaW = design->widthFromColumnRange(colMin, colMax-1);
356  double phiW = design->widthFromRowRange(rowMin, rowMax-1);
357 
358  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,etaWidth),Amg::Vector2D(phiW,etaW));
359 
360  // **** Get SiLocalPosition from cell id and define Amg::Vector2D position
361  InDetDD::SiLocalPosition silPos(pDE->rawLocalPositionOfCell(cell));
362  Amg::Vector2D localPos(silPos);
363 
364  //TODO: understand if shift is needed
365 
366  if (m_doShift) {
367  double shift = m_lorentzAngleTool->getLorentzShift(hash,Gaudi::Hive::currentContext());
368  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
369  localPos = localPosShift;
370  }
371 
372  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
373 
374  Amg::MatrixX cov(2,2);
375  cov.setZero();
376 
377  cov(0,0) = siWidth.phiR()*siWidth.phiR()/12;
378  cov(1,1) = siWidth.z()*siWidth.z()/12;
379 
380  float omegax = 0.5;
381  float omegay = 0.5;
382  bool split = false;
383  float splitProb1 = 0;
384  float splitProb2 = 0;
385 
386  Eigen::Matrix<float,2,1> localPosition(localPos.x(), localPos.y());
387  Eigen::Matrix<float,2,2> localCovariance;
388  localCovariance.setZero();
389  localCovariance(0, 0) = cov(0, 0);
390  localCovariance(1, 1) = cov(1, 1);
391 
392  Eigen::Matrix<float,3,1> globalPosition(h.getX(),h.getY(),h.getZ());
393  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPosition.x() << " y=" << globalPosition.y() << " z=" << globalPosition.z() );
394 
395  cl.setMeasurement<2>(hash, localPosition, localCovariance);
396  cl.setIdentifier( rdoList.front().get_compact() );
397  cl.setRDOlist(rdoList);
398  cl.globalPosition() = globalPosition;
399  cl.setChannelsInPhiEta(siWidth.colRow()[0], siWidth.colRow()[1]);
400  cl.setWidthInEta(static_cast<float>(siWidth.widthPhiRZ()[1]));
401  cl.setOmegas(omegax, omegay);
402  cl.setIsSplit(split);
403  cl.setSplitProbabilities(splitProb1, splitProb2);
404  ATH_MSG_DEBUG("\t\txaod width in eta " << cl.widthInEta());
405 
406  return StatusCode::SUCCESS;
407 }

◆ createPixelSPs()

StatusCode FPGAClusterConverter::createPixelSPs ( xAOD::SpacePointContainer &  pixelSPs,
xAOD::PixelClusterContainer &  clustersCont 
) const
finaloverridevirtual

Definition at line 627 of file FPGAClusterConverter.cxx.

627  {
628 
629  for (const xAOD::PixelCluster* p_cl : clustersCont)
630  {
631  pixelSPs.emplace_back(new xAOD::SpacePoint);
632 
633  // Global position
634  Eigen::Matrix<float, 3, 1> globalPos(p_cl->globalPosition().x(), p_cl->globalPosition().y(), p_cl->globalPosition().z());
635 
636  // Covariance
637  // TODO: check if we need to scale covariance based on rotation matrix like in PixelSpacePointFormationTool.cxx
638  const float & cov_r = p_cl->localCovariance<2>()(0,0);
639  const float & cov_z = p_cl->localCovariance<2>()(1,0);
640 
641  // measurement list
642  std::vector< const xAOD::UncalibratedMeasurement* > measurementLinks({ p_cl });
643 
644  pixelSPs.back()->setSpacePoint(
645  p_cl->identifierHash(),
646  globalPos,
647  cov_r,
648  cov_z,
649  measurementLinks
650  );
651  }
652 
653  return StatusCode::SUCCESS;
654 }

◆ createSCTCluster() [1/4]

StatusCode FPGAClusterConverter::createSCTCluster ( const FPGATrackSimCluster &  cluster,
std::unique_ptr< InDet::SCT_Cluster > &  cl 
) const
finaloverridevirtual

Definition at line 608 of file FPGAClusterConverter.cxx.

608  {
609  ATH_MSG_DEBUG("\t Create InDet::SCT_Cluster from FPGATrackSimCluster");
610  FPGATrackSimHit clEq = cluster.getClusterEquiv();
611  std::vector<Identifier> rdoList;
612  ATH_CHECK(getRdoList(rdoList, cluster));
613  ATH_CHECK(createSCTCluster(clEq, rdoList,cl));
614  return StatusCode::SUCCESS;
615 }

◆ createSCTCluster() [2/4]

StatusCode FPGAClusterConverter::createSCTCluster ( const FPGATrackSimCluster &  cluster,
xAOD::StripCluster &  cl 
) const
finaloverridevirtual

Definition at line 617 of file FPGAClusterConverter.cxx.

617  {
618  ATH_MSG_DEBUG("\t Create xAOD::StripCluster from FPGATrackSimCluster");
619  FPGATrackSimHit clEq = cluster.getClusterEquiv();
620  std::vector<Identifier> rdoList;
621  ATH_CHECK(getRdoList(rdoList, cluster));
622  ATH_CHECK(createSCTCluster(clEq, rdoList, cl));
623  return StatusCode::SUCCESS;
624 }

◆ createSCTCluster() [3/4]

StatusCode FPGAClusterConverter::createSCTCluster ( const FPGATrackSimHit &  h,
const std::vector< Identifier > &  rdoList,
std::unique_ptr< InDet::SCT_Cluster > &  cl 
) const
finaloverridevirtual

Definition at line 409 of file FPGAClusterConverter.cxx.

409  {
410  ATH_MSG_DEBUG("\t Create InDet::SCTCluster from FPGATrackSimHit ");
411 
412 
413  IdentifierHash hash = h.getIdentifierHash();
414 
415  float phiWidth = h.getPhiWidth();
416  int strip = static_cast<int>(h.getPhiIndex());
417  ATH_CHECK(strip >= 0);
418  const InDetDD::SiDetectorElement* pDE = m_SCTManager->getDetectorElement(hash);
419  ATH_CHECK(pDE != nullptr);
420 
421 
422  Identifier wafer_id = m_SCTId->wafer_id(hash);
423  Identifier strip_id = m_SCTId->strip_id(wafer_id, strip);
424  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(strip_id);
425  ATH_MSG_DEBUG("\t\tcell: " << cell);
426  ATH_MSG_DEBUG("\t\tstrip_id " << strip_id);
427  ATH_MSG_DEBUG("\t\tstrip: " << cell);
428  ATH_MSG_DEBUG("\t\tStrip from idHelper: " << m_SCTId->strip(strip_id) );
429 
430  const InDetDD::SCT_ModuleSideDesign* design;
431  if (pDE->isBarrel()){
432  design = (static_cast<const InDetDD::SCT_ModuleSideDesign*>(&pDE->design()));
433  } else{
434  design = (static_cast<const InDetDD::StripStereoAnnulusDesign*>(&pDE->design()));
435  }
436 
437  const int firstStrip = m_SCTId->strip(rdoList.front());
438  const int lastStrip = m_SCTId->strip(rdoList.back());
439  const int row = m_SCTId->row(rdoList.front());
440  const int firstStrip1D = design->strip1Dim (firstStrip, row );
441  const int lastStrip1D = design->strip1Dim( lastStrip, row );
442  const InDetDD::SiCellId cell1(firstStrip1D);
443  const InDetDD::SiCellId cell2(lastStrip1D);
444  const InDetDD::SiLocalPosition firstStripPos( pDE->rawLocalPositionOfCell(cell1 ));
445  const InDetDD::SiLocalPosition lastStripPos( pDE->rawLocalPositionOfCell(cell2) );
446  const InDetDD::SiLocalPosition centre( (firstStripPos+lastStripPos) * 0.5 );
447  const double width = design->stripPitch() * ( lastStrip - firstStrip + 1 );
448 
449  const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends( design->endsOfStrip(centre) );
450  const double stripLength( std::abs(ends.first.xEta() - ends.second.xEta()) );
451 
452  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,1), Amg::Vector2D(width,stripLength) ); //TODO: ok??
453  Amg::Vector2D localPos(centre.xPhi(), centre.xEta());
454 
455  ATH_MSG_DEBUG("\t\tcentre eta: " << centre.xEta() << " phi: " << centre.xPhi());
456  ATH_MSG_DEBUG("\t\tStrip length: " << stripLength );
457  ATH_MSG_DEBUG("\t\tlocal position before shift: " << localPos.x() << " phi: " << localPos.y());
458  if (m_doShift) {
459  double shift = m_lorentzAngleTool->getLorentzShift(hash,Gaudi::Hive::currentContext());
460  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
461  localPos = localPosShift;
462  }
463 
464  Amg::Vector3D globalPos = pDE->globalPosition(localPos);
465  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
466  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPos.x() << " y=" << globalPos.y() << " z=" << globalPos.z() );
467 
468  // Fill cov matrix. TODO: compare with https://gitlab.cern.ch/atlas/athena/-/blob/main/InnerDetector/InDetRecTools/SiClusterizationTool/src/ClusterMakerTool.cxx and xAOD function
469  const double col_x = siWidth.colRow().x();
470  const double col_y = siWidth.colRow().y();
471 
472  double scale_factor = 1.;
473  if ( std::abs(col_x-1) < std::numeric_limits<double>::epsilon() )
474  scale_factor = 1.05;
475  else if ( std::abs(col_x-2) < std::numeric_limits<double>::epsilon() )
476  scale_factor = 0.27;
477 
478  auto cov = Amg::MatrixX(2,2);
479  cov.setIdentity();
480  cov.fillSymmetric(0, 0, scale_factor * scale_factor * siWidth.phiR() * siWidth.phiR() * (1./12.));
481  cov.fillSymmetric(1, 1, siWidth.z() * siWidth.z() / col_y / col_y * (1./12.));
482 
483  // rotation for endcap SCT
484  if(pDE->design().shape() == InDetDD::Trapezoid || pDE->design().shape() == InDetDD::Annulus) {
485  double sn = pDE->sinStereoLocal(localPos);
486  double sn2 = sn*sn;
487  double cs2 = 1.-sn2;
488  double w = pDE->phiPitch(localPos)/pDE->phiPitch();
489  double v0 = (cov)(0,0)*w*w;
490  double v1 = (cov)(1,1);
491  cov.fillSymmetric( 0, 0, cs2 * v0 + sn2 * v1 );
492  cov.fillSymmetric( 0, 1, sn * std::sqrt(cs2) * (v0 - v1) );
493  cov.fillSymmetric( 1, 1, sn2 * v0 + cs2 * v1 );
494  }
495 
496  cl = std::make_unique<InDet::SCT_Cluster>(strip_id, localPos, std::vector<Identifier>(rdoList), siWidth, pDE, Amg::MatrixX(cov));
497 
498  return StatusCode::SUCCESS;
499 }

◆ createSCTCluster() [4/4]

StatusCode FPGAClusterConverter::createSCTCluster ( const FPGATrackSimHit &  h,
const std::vector< Identifier > &  rdoList,
xAOD::StripCluster &  cl 
) const
finaloverridevirtual

Definition at line 501 of file FPGAClusterConverter.cxx.

501  {
502  ATH_MSG_DEBUG("\t Create xAOD::StripCluster from FPGATrackSimHit ");
503  //https://gitlab.cern.ch/atlas/athena/-/blob/main/InnerDetector/InDetRecTools/SiClusterizationTool/src/SCT_ClusteringTool.cxx
504 
505  IdentifierHash hash = h.getIdentifierHash();
506 
507  float phiWidth = h.getPhiWidth();
508  int strip = static_cast<int>(h.getPhiIndex());
509  ATH_CHECK(strip >= 0);
510  const InDetDD::SiDetectorElement* pDE = m_SCTManager->getDetectorElement(hash);
511  ATH_CHECK(pDE != nullptr);
512 
513  Identifier wafer_id = m_SCTId->wafer_id(hash);
514  Identifier strip_id = m_SCTId->strip_id(wafer_id, strip);
515  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(strip_id);
516  ATH_MSG_DEBUG("\t\tcell: " << cell);
517  ATH_MSG_DEBUG("\t\tstrip_id " << strip_id);
518  ATH_MSG_DEBUG("\t\tstrip: " << cell);
519  ATH_MSG_DEBUG("\t\tStrip from idHelper: " << m_SCTId->strip(strip_id) );
520 
521  const InDetDD::SCT_ModuleSideDesign* design;
522  if (pDE->isBarrel()){
523  design = (static_cast<const InDetDD::SCT_ModuleSideDesign*>(&pDE->design()));
524  } else{
525  design = (static_cast<const InDetDD::StripStereoAnnulusDesign*>(&pDE->design()));
526  }
527 
528  const int firstStrip = m_SCTId->strip(rdoList.front());
529  const int lastStrip = m_SCTId->strip(rdoList.back());
530  const int row = m_SCTId->row(rdoList.front());
531  const int firstStrip1D = design->strip1Dim (firstStrip, row );
532  const int lastStrip1D = design->strip1Dim( lastStrip, row );
533  const InDetDD::SiCellId cell1(firstStrip1D);
534  const InDetDD::SiCellId cell2(lastStrip1D);
535  if (cell2 != design->cellIdInRange(cell2) || cell1 != design->cellIdInRange(cell1)) { // this seems to solve EFTRACK-743
536  ATH_MSG_WARNING("Cell ID out of range. Skip making this Strip cluster");
537  return StatusCode::SUCCESS;
538  }
539  const InDetDD::SiLocalPosition firstStripPos( pDE->rawLocalPositionOfCell(cell1 ));
540  const InDetDD::SiLocalPosition lastStripPos( pDE->rawLocalPositionOfCell(cell2) );
541  const InDetDD::SiLocalPosition centre( (firstStripPos+lastStripPos) * 0.5 );
542  const double width = design->stripPitch() * ( lastStrip - firstStrip + 1 );
543 
544  const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends( design->endsOfStrip(centre) );
545  const double stripLength( std::abs(ends.first.xEta() - ends.second.xEta()) );
546 
547  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,1), Amg::Vector2D(width,stripLength) ); //TODO: ok??
548  Amg::Vector2D localPos(centre.xPhi(), centre.xEta());
549  ATH_MSG_DEBUG("\t\tcentre eta: " << centre.xEta() << " phi: " << centre.xPhi());
550  ATH_MSG_DEBUG("\t\tStrip length: " << stripLength );
551  ATH_MSG_DEBUG("\t\tlocal position before shift: " << localPos.x() << " phi: " << localPos.y());
552 
553  if (m_doShift) {
554  double shift = m_lorentzAngleTool->getLorentzShift(hash,Gaudi::Hive::currentContext());
555  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
556  localPos = localPosShift;
557  }
558 
559  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
560 
561  /* TODO */
562  Eigen::Matrix<float,1,1> localPosition;
563  Eigen::Matrix<float,1,1> localCovariance;
564  localCovariance.setZero();
565 
566  if (pDE->isBarrel()) {
567  localPosition(0, 0) = localPos.x();
568  localCovariance(0, 0) = pDE->phiPitch() * pDE->phiPitch() * (1./12.);
569  } else {
570  InDetDD::SiCellId cellId = pDE->cellIdOfPosition(localPos);
571  const InDetDD::StripStereoAnnulusDesign *designNew = dynamic_cast<const InDetDD::StripStereoAnnulusDesign *>(&pDE->design());
572  if ( designNew == nullptr ) return StatusCode::FAILURE;
573  InDetDD::SiLocalPosition localInPolar = designNew->localPositionOfCellPC(cellId);
574  localPosition(0, 0) = localInPolar.xPhi();
575  localCovariance(0, 0) = designNew->phiPitchPhi() * designNew->phiPitchPhi() * (1./12.);
576  }
577 
578  Eigen::Matrix<float,3,1> globalPosition(h.getX(),h.getY(),h.getZ());
579  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPosition.x() << " y=" << globalPosition.y() << " z=" << globalPosition.z() );
580 
581  cl.setMeasurement<1>(hash, localPosition, localCovariance);
582  cl.setIdentifier( rdoList.front().get_compact() );
583  cl.setRDOlist(rdoList);
584  cl.globalPosition() = globalPosition;
585  cl.setChannelsInPhi(siWidth.colRow()[0]);
586 
587  return StatusCode::SUCCESS;
588 }

◆ createSP()

StatusCode FPGAClusterConverter::createSP ( const FPGATrackSimCluster &  cl,
xAOD::SpacePoint &  sp,
xAOD::StripClusterContainer &  clustersCont 
) const
finaloverridevirtual

Definition at line 657 of file FPGAClusterConverter.cxx.

657  {
658 
659  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
660  const InDet::BeamSpotData* beamSpot = *beamSpotHandle;
661  Amg::Vector3D vertex = beamSpot->beamVtx().position();
662 
663  const FPGATrackSimHit& clEq = cl.getClusterEquiv();
664 
665  const IdentifierHash& hash = clEq.getIdentifierHash();
666 
667  // Global position and covariance
668 
669  Eigen::Matrix<float,3,1> globalPos(clEq.getX(),clEq.getY(),clEq.getZ());
670 
671  // Covariance
672  // TODO: update to ITk? Can it be done as for pixel? (L728-729)?
673  // Lines taken from SCT_SpacePoint::setupLocalCovarianceSCT()
674  float deltaY = 0.0004; // roughly pitch of SCT (80 mu) / sqrt(12)
675  float covTerm = 1600.*deltaY;
676  Eigen::Matrix<float, 2, 1> variance(0.1, 8.*covTerm);
677  const InDetDD::SiDetectorElement* element = m_SCTManager->getDetectorElement(hash);
678  // Swap r/z covariance terms for endcap clusters
679  if ( element->isEndcap() )
680  std::swap( variance(0, 0), variance(1, 0) );
681  float cov_r = variance(0,0);
682  float cov_z = variance(1,0);
683 
684  // ***** Get Strips related infos *****
685 
686  // idHashes and measurements
687  std::vector<unsigned int> idHashList;
688  std::vector<const xAOD::UncalibratedMeasurement_v1*> measurements;
689 
690  //Get measurements
691 
692  float topHalfStripLength, bottomHalfStripLength;
693  Amg::Vector3D topStripDirection;
694  Amg::Vector3D bottomStripDirection;
695  Amg::Vector3D stripCenter1;
696  Amg::Vector3D stripCenter2;
697  int index = 0;
698  for (const FPGATrackSimHit& h : cl.getHitList()) {
699  idHashList.push_back(h.getIdentifierHash());
700  for (auto orig_cl : clustersCont) {
701  if (h.getIdentifierHash()==orig_cl->identifierHash()) {
702  if (index == 0) {ATH_CHECK(getStripsInfo(*orig_cl, topHalfStripLength, topStripDirection, stripCenter1));}
703  if (index == 1) {ATH_CHECK(getStripsInfo(*orig_cl, bottomHalfStripLength, bottomStripDirection, stripCenter2));}
704  measurements.push_back(orig_cl);
705  index++;
706  }
707  }
708  }
709 
710  Amg::Vector3D topTrajDir = 2. * ( stripCenter1 - vertex);
711  Amg::Vector3D topStripCenter = 0.5 * topTrajDir;
712  Amg::Vector3D stripCenterDistance = stripCenter1 - stripCenter2;
713 
714  ATH_MSG_DEBUG("topHalfStripLength = " << topHalfStripLength << " bottomHalfStripLength = " << bottomHalfStripLength);
715  ATH_MSG_DEBUG("topStripDirection = (" << topStripDirection.x() <<", " << topStripDirection.y() <<", " << topStripDirection.z() <<") " << "bottomStripDirection = (" << bottomStripDirection.x() <<", " << bottomStripDirection.y() <<", " << bottomStripDirection.z() <<") " );
716  ATH_MSG_DEBUG("stripCenterDistance = (" << stripCenterDistance.x() <<", " << stripCenterDistance.y() <<", " << stripCenterDistance.z() << ")" );
717  ATH_MSG_DEBUG("topStripCenter = (" << topStripCenter.x() <<", " << topStripCenter.y() <<", " << topStripCenter.z() << ")" );
718 
719  // Fill xAOD::SpacePoint
720  sp.setSpacePoint(
721  idHashList,
722  globalPos,
723  cov_r,
724  cov_z,
725  measurements,
726  topHalfStripLength,
727  bottomHalfStripLength,
728  topStripDirection.cast<float>(),
729  bottomStripDirection.cast<float>(),
730  stripCenterDistance.cast<float>(),
731  topStripCenter.cast<float>()
732  );
733 
734  return StatusCode::SUCCESS;
735 }

◆ getRdoList() [1/2]

StatusCode FPGAClusterConverter::getRdoList ( std::vector< Identifier > &  rdoList,
const FPGATrackSimCluster &  cluster 
) const
finaloverridevirtual

Definition at line 737 of file FPGAClusterConverter.cxx.

737  {
738 
739  std::vector<FPGATrackSimHit> hits = cluster.getHitList();
740 
741  for (const FPGATrackSimHit& h : hits) {
742  IdentifierHash hash = h.getIdentifierHash();
743  int phiIndex = h.getPhiIndex();
744  int etaIndex = h.getEtaIndex();
745 
746  if (h.isPixel()) {
747  Identifier wafer_id_hit = m_pixelId->wafer_id(hash);
748  Identifier hit_id = m_pixelId->pixel_id(wafer_id_hit, phiIndex, etaIndex);
749  rdoList.push_back(hit_id);
750  }
751  if (h.isStrip()) {
752  Identifier wafer_id_hit = m_SCTId->wafer_id(hash);
753  Identifier hit_id = m_SCTId->strip_id(wafer_id_hit, int(phiIndex));
754  rdoList.push_back(hit_id);
755  }
756  }
757 
758  return StatusCode::SUCCESS;
759 
760 }

◆ getRdoList() [2/2]

StatusCode FPGAClusterConverter::getRdoList ( std::vector< Identifier > &  rdoList,
const FPGATrackSimHit &  hit 
) const
finaloverridevirtual

Definition at line 763 of file FPGAClusterConverter.cxx.

763  {
764 
765  IdentifierHash hash = h.getIdentifierHash();
766  int phiIndex = h.getPhiIndex();
767  int etaIndex = h.getEtaIndex();
768 
769  if (h.isPixel()) {
770  Identifier wafer_id_hit = m_pixelId->wafer_id(hash);
771  Identifier hit_id = m_pixelId->pixel_id(wafer_id_hit, phiIndex, etaIndex);
772  rdoList.push_back(hit_id);
773  }
774  if (h.isStrip()) {
775  Identifier wafer_id_hit = m_SCTId->wafer_id(hash);
776  Identifier hit_id = m_SCTId->strip_id(wafer_id_hit, int(phiIndex));
777  rdoList.push_back(hit_id);
778  }
779 
780  return StatusCode::SUCCESS;
781 }

◆ getStripsInfo()

StatusCode FPGAClusterConverter::getStripsInfo ( const xAOD::StripCluster &  cl,
float &  halfStripLength,
Amg::Vector3D &  stripDirection,
Amg::Vector3D &  stripCenter 
) const
finaloverridevirtual

Definition at line 783 of file FPGAClusterConverter.cxx.

783  {
784 
785  const int &strip = m_SCTId->strip(cl.rdoList().front());
786  const IdentifierHash &hash = cl.identifierHash();
787 
788  const InDetDD::SiDetectorElement* pDE = m_SCTManager->getDetectorElement(hash);
789 
790  const Identifier &wafer_id = m_SCTId->wafer_id(hash);
791  const Identifier &strip_id = m_SCTId->strip_id(wafer_id, strip);
792  const InDetDD::SiCellId & cell = pDE->cellIdFromIdentifier(strip_id);
793 
794  const InDetDD::SiLocalPosition localPos( pDE->rawLocalPositionOfCell(cell ));
795  std::pair<Amg::Vector3D, Amg::Vector3D> end = (pDE->endsOfStrip(localPos));
796  stripCenter = 0.5 * (end.first + end.second);
797  Amg::Vector3D stripDir = end.first - end.second;
798 
799  halfStripLength = 0.5 * stripDir.norm();
800  stripDirection = stripDir / (2. * (halfStripLength));
801 
802  return StatusCode::SUCCESS;
803 }

◆ initialize()

StatusCode FPGAClusterConverter::initialize ( )
finaloverridevirtual

Definition at line 23 of file FPGAClusterConverter.cxx.

23  {
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_lorentzAngleTool.retrieve());
33 
34  ATH_CHECK( m_FPGAClusterKey.initialize() );
35  ATH_CHECK(m_beamSpotKey.initialize());
36 
37  return StatusCode::SUCCESS;
38 
39 }

Member Data Documentation

◆ m_beamSpotKey

SG::ReadCondHandleKey< InDet::BeamSpotData > FPGAClusterConverter::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

Definition at line 85 of file FPGAClusterConverter.h.

◆ m_doShift

bool FPGAClusterConverter::m_doShift = true

Definition at line 87 of file FPGAClusterConverter.h.

◆ m_FPGAClusterKey

SG::ReadHandleKey<FPGATrackSimClusterCollection> FPGAClusterConverter::m_FPGAClusterKey {this, "FPGATrackSimClusterKey","FPGAClusters","FPGATrackSim Clusters key"}

Definition at line 84 of file FPGAClusterConverter.h.

◆ m_lorentzAngleTool

ToolHandle<ISiLorentzAngleTool> FPGAClusterConverter::m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "Tool to retrieve Lorentz angle of SCT"}
private

Definition at line 96 of file FPGAClusterConverter.h.

◆ m_pixelId

const PixelID* FPGAClusterConverter::m_pixelId {nullptr}
private

Definition at line 91 of file FPGAClusterConverter.h.

◆ m_pixelManager

const InDetDD::PixelDetectorManager* FPGAClusterConverter::m_pixelManager {nullptr}
private

Definition at line 93 of file FPGAClusterConverter.h.

◆ m_SCTId

const SCT_ID* FPGAClusterConverter::m_SCTId {nullptr}
private

Definition at line 92 of file FPGAClusterConverter.h.

◆ m_SCTManager

const InDetDD::SCT_DetectorManager* FPGAClusterConverter::m_SCTManager {nullptr}
private

Definition at line 94 of file FPGAClusterConverter.h.

◆ m_skipStripSpacePointFormation

Gaudi::Property<bool> FPGAClusterConverter::m_skipStripSpacePointFormation {this, "skipStripSpFormation", true, "Should be enabled in case we want to test strip seeding"}
private

Definition at line 98 of file FPGAClusterConverter.h.

The documentation for this class was generated from the following files:
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
query_example.row
row
Definition: query_example.py:24
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_SCTManager
const InDetDD::SCT_DetectorManager * m_SCTManager
Definition: FPGAClusterConverter.h:94
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
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
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
Definition: PixelModuleDesign.h:48
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:38
FPGATrackSimCluster
Definition: FPGATrackSimCluster.h:24
makeComparison.deltaY
int deltaY
Definition: makeComparison.py:44
FPGAClusterConverter::m_lorentzAngleTool
ToolHandle< ISiLorentzAngleTool > m_lorentzAngleTool
Definition: FPGAClusterConverter.h:96
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
FPGAClusterConverter::m_FPGAClusterKey
SG::ReadHandleKey< FPGATrackSimClusterCollection > m_FPGAClusterKey
Definition: FPGAClusterConverter.h:84
InDetDD::DetectorDesign::shape
virtual DetectorShape shape() const
Shape of element.
Definition: DetectorDesign.cxx:96
FPGATrackSimHit::getX
float getX() const
Definition: FPGATrackSimHit.h:140
plotBeamSpotVxVal.cov
cov
Definition: plotBeamSpotVxVal.py:201
xAOD::SpacePoint_v1
Definition: SpacePoint_v1.h:29
xAOD::SpacePoint
SpacePoint_v1 SpacePoint
Definition: Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/SpacePoint.h:12
InDetDD::SCT_DetectorManager::getDetectorElement
virtual 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:364
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:33
FPGAClusterConverter::m_pixelManager
const InDetDD::PixelDetectorManager * m_pixelManager
Definition: FPGAClusterConverter.h:93
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
FPGAClusterConverter::getStripsInfo
virtual StatusCode getStripsInfo(const xAOD::StripCluster &cl, float &halfStripLength, Amg::Vector3D &stripDirection, Amg::Vector3D &stripCenter) const override final
Definition: FPGAClusterConverter.cxx:783
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
xAOD::SpacePoint_v1::elementIdList
const std::vector< DetectorIDHashType > & elementIdList() const
Returns the IdentifierHash of the spacepoint (corresponds to the detector element IdentifierHash)
FPGAClusterConverter::m_SCTId
const SCT_ID * m_SCTId
Definition: FPGAClusterConverter.h:92
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:91
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
InDetDD::SCT_ModuleSideDesign::cellIdInRange
virtual SiCellId cellIdInRange(const SiCellId &cellId) const override
Check if cell is in range.
Definition: SCT_ModuleSideDesign.cxx:101
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:409
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
columnar::ContainerId::cluster
@ cluster
parseMapping.v0
def v0
Definition: parseMapping.py:149
SCT_CalibAlgs::firstStrip
@ firstStrip
Definition: SCT_CalibNumbers.h:10
xAOD::PixelCluster
PixelCluster_v1 PixelCluster
Define the version of the pixel cluster class.
Definition: Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/PixelCluster.h:13
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:657
SCT_ID::row
int row(const Identifier &id) const
Definition: SCT_ID.h:758
InDetDD::StripStereoAnnulusDesign
Definition: StripStereoAnnulusDesign.h:50
FPGAClusterConverter::getRdoList
virtual StatusCode getRdoList(std::vector< Identifier > &rdoList, const FPGATrackSimCluster &cluster) const override final
Definition: FPGAClusterConverter.cxx:737
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:141
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
xAOD::SpacePoint_v1::setSpacePoint
void setSpacePoint(DetectorIDHashType idHash, const Eigen::Matrix< float, 3, 1 > &globPos, float cov_r, float cov_z, const std::vector< const xAOD::UncalibratedMeasurement * > &measurementIndexes)
Definition: SpacePoint_v1.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.
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
FPGATrackSimHit::isPixel
bool isPixel() const
Definition: FPGATrackSimHit.h:64
FPGATrackSimHit::getZ
float getZ() const
Definition: FPGATrackSimHit.h:142
FPGAClusterConverter::m_doShift
bool m_doShift
Definition: FPGAClusterConverter.h:87
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:249
InDetDD::StripStereoAnnulusDesign::phiPitchPhi
double phiPitchPhi(const SiLocalPosition &localPosition) const
Definition: StripStereoAnnulusDesign.h:291
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
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
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
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:109
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:764
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:432
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
SCT_CalibAlgs::lastStrip
@ lastStrip
Definition: SCT_CalibNumbers.h:10
xAOD::phiWidth
phiWidth
Definition: RingSetConf_v1.cxx:612
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
InDet::SiWidth
Definition: SiWidth.h:25
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:455
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
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:200
InDetDD::SiDetectorElement::design
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
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:26
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
FPGAClusterConverter::createPixelSPs
virtual StatusCode createPixelSPs(xAOD::SpacePointContainer &pixelSPs, xAOD::PixelClusterContainer &clustersCont) const override final
Definition: FPGAClusterConverter.cxx:627
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
InDetDD::Trapezoid
@ Trapezoid
Definition: DetectorDesign.h:42
InDetDD::PixelDetectorManager::getDetectorElement
virtual SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements : via Identifier
Definition: PixelDetectorManager.cxx:80
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 Tue Apr 15 2025 21:33:35 for ATLAS Offline Software by   doxygen 1.8.18