ATLAS Offline Software
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 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 getRdoList (std::vector< Identifier > &rdoList, const FPGATrackSimCluster &cluster) const override final
 
virtual StatusCode getRdoList (std::vector< Identifier > &rdoList, const FPGATrackSimHit &hit) const override final
 

Public Attributes

SG::ReadHandleKey< FPGATrackSimClusterCollection > m_FPGAClusterKey {this, "FPGATrackSimClusterKey","FPGAClusters","FPGATrackSim Clusters key"}
 
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"}
 

Detailed Description

Definition at line 36 of file FPGAClusterConverter.h.

Constructor & Destructor Documentation

◆ FPGAClusterConverter()

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

Definition at line 18 of file FPGAClusterConverter.cxx.

18  :
19  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 158 of file FPGAClusterConverter.cxx.

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

◆ convertClusters() [2/2]

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

Definition at line 191 of file FPGAClusterConverter.cxx.

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

◆ convertHits() [1/3]

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

Definition at line 71 of file FPGAClusterConverter.cxx.

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

◆ convertHits() [2/3]

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

Definition at line 40 of file FPGAClusterConverter.cxx.

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

◆ convertHits() [3/3]

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

Definition at line 127 of file FPGAClusterConverter.cxx.

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

◆ createPixelCluster() [1/4]

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

Definition at line 562 of file FPGAClusterConverter.cxx.

562  {
563  ATH_MSG_DEBUG("\t Create InDet::PixelCluster from FPGATrackSimCluster");
564  FPGATrackSimHit clEq = cluster.getClusterEquiv();
565  std::vector<Identifier> rdoList;
566  ATH_CHECK(getRdoList(rdoList, cluster));
567  ATH_CHECK(createPixelCluster(clEq, rdoList, cl));
568  return StatusCode::SUCCESS;
569 }

◆ createPixelCluster() [2/4]

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

Definition at line 571 of file FPGAClusterConverter.cxx.

571  {
572  ATH_MSG_DEBUG("\t Create xAOD::PixelCluster from FPGATrackSimCluster");
573  FPGATrackSimHit clEq = cluster.getClusterEquiv();
574  std::vector<Identifier> rdoList;
575  ATH_CHECK(getRdoList(rdoList, cluster));
576  ATH_CHECK(createPixelCluster(clEq, rdoList, cl));
577  return StatusCode::SUCCESS;
578 }

◆ 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 223 of file FPGAClusterConverter.cxx.

223  {
224  ATH_MSG_DEBUG("\tCreate InDet::PixelCluster from FPGATrackSimHit");
225 
226  IdentifierHash hash = h.getIdentifierHash();
227 
228  float etaWidth = h.getEtaWidth();
229  float phiWidth = h.getPhiWidth();
230  int phiIndex = h.getPhiIndex();
231  int etaIndex = h.getEtaIndex();
232 
233  const InDetDD::SiDetectorElement* pDE = m_pixelManager->getDetectorElement(hash);
234 
235  if( !pDE ) {
236  ATH_MSG_ERROR("Detector Element doesn't exist " << hash);
237  return StatusCode::FAILURE;
238  }
239 
240  // *** Get cell from id
241  Identifier wafer_id = m_pixelId->wafer_id(hash);
242  Identifier hit_id = m_pixelId->pixel_id(wafer_id, phiIndex, etaIndex);
243  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(hit_id);
244  if(!cell.isValid()) {
245  ATH_MSG_DEBUG("\t\tcell not valid");
246  return StatusCode::FAILURE;
247  }
248  const InDetDD::PixelModuleDesign* design (dynamic_cast<const InDetDD::PixelModuleDesign*>(&pDE->design()));
249 
250  // **** Get InDet::SiWidth
251 
252  int colMin = static_cast<int>(etaIndex-0.5*etaWidth);
253  int colMax = colMin+etaWidth;
254 
255  int rowMin = static_cast<int>(phiIndex-0.5*phiWidth);
256  int rowMax = rowMin+phiWidth;
257 
258  double etaW = design->widthFromColumnRange(colMin, colMax-1);
259  double phiW = design->widthFromRowRange(rowMin, rowMax-1);
260 
261  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,etaWidth),Amg::Vector2D(phiW,etaW));
262 
263  // **** Get SiLocalPosition from cell id and define Amg::Vector2D position
264  InDetDD::SiLocalPosition silPos(pDE->rawLocalPositionOfCell(cell));
265  Amg::Vector2D localPos(silPos);
266 
267  //TODO: understand if shift is needed
268  if (m_doShift) {
269  double shift = m_lorentzAngleTool->getLorentzShift(hash);
270  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
271  localPos = localPosShift;
272  }
273 
274  Amg::Vector3D globalPos = pDE->globalPosition(localPos);
275  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
276  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPos.x() << " y=" << globalPos.y() << " z=" << globalPos.z() );
277 
278  Amg::MatrixX cov(2,2);
279  cov.setZero();
280 
281  cov(0,0) = siWidth.phiR()*siWidth.phiR()/12;
282  cov(1,1) = siWidth.z()*siWidth.z()/12;
283  float dummy_omegax = 0.5;
284  float dummy_omegay = 0.5;
285  bool split = false;
286  float splitProb1 = 0;
287  float splitProb2 = 0;
288 
289  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);
290 
291  return StatusCode::SUCCESS;
292 }

◆ createPixelCluster() [4/4]

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

Definition at line 294 of file FPGAClusterConverter.cxx.

294  {
295  ATH_MSG_DEBUG("\tCreate xAOD::PixelCluster from FPGATrackSimHit");
296 
297  IdentifierHash hash = h.getIdentifierHash();
298 
299  float etaWidth = h.getEtaWidth();
300  float phiWidth = h.getPhiWidth();
301  int phiIndex = h.getPhiIndex();
302  int etaIndex = h.getEtaIndex();
303 
304  const InDetDD::SiDetectorElement* pDE = m_pixelManager->getDetectorElement(hash);
305 
306  if( !pDE ) {
307  ATH_MSG_ERROR("Detector Element doesn't exist " << hash);
308  return StatusCode::FAILURE;
309  }
310 
311  // *** Get cell from id
312  Identifier wafer_id = m_pixelId->wafer_id(hash);
313  Identifier hit_id = m_pixelId->pixel_id(wafer_id, phiIndex, etaIndex);
314  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(hit_id);
315  if(!cell.isValid()) {
316  ATH_MSG_DEBUG("\t\tcell not valid");
317  return StatusCode::FAILURE;
318  }
319  const InDetDD::PixelModuleDesign* design (dynamic_cast<const InDetDD::PixelModuleDesign*>(&pDE->design()));
320 
321  // **** Get InDet::SiWidth
322 
323  int colMin = static_cast<int>(etaIndex-0.5*etaWidth);
324  int colMax = colMin+etaWidth;
325 
326  int rowMin = static_cast<int>(phiIndex-0.5*phiWidth);
327  int rowMax = rowMin+phiWidth;
328 
329  double etaW = design->widthFromColumnRange(colMin, colMax-1);
330  double phiW = design->widthFromRowRange(rowMin, rowMax-1);
331 
332  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,etaWidth),Amg::Vector2D(phiW,etaW));
333 
334  // **** Get SiLocalPosition from cell id and define Amg::Vector2D position
335  InDetDD::SiLocalPosition silPos(pDE->rawLocalPositionOfCell(cell));
336  Amg::Vector2D localPos(silPos);
337 
338  //TODO: understand if shift is needed
339 
340  if (m_doShift) {
341  double shift = m_lorentzAngleTool->getLorentzShift(hash);
342  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
343  localPos = localPosShift;
344  }
345 
346  Amg::Vector3D globalPos = pDE->globalPosition(localPos);
347  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
348  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPos.x() << " y=" << globalPos.y() << " z=" << globalPos.z() );
349 
350  Amg::MatrixX cov(2,2);
351  cov.setZero();
352 
353  cov(0,0) = siWidth.phiR()*siWidth.phiR()/12;
354  cov(1,1) = siWidth.z()*siWidth.z()/12;
355 
356  float omegax = 0.5;
357  float omegay = 0.5;
358  bool split = false;
359  float splitProb1 = 0;
360  float splitProb2 = 0;
361 
362  Eigen::Matrix<float,2,1> localPosition(localPos.x(), localPos.y());
363  Eigen::Matrix<float,2,2> localCovariance;
364  localCovariance.setZero();
365  localCovariance(0, 0) = cov(0, 0);
366  localCovariance(1, 1) = cov(1, 1);
367 
368  Eigen::Matrix<float,3,1> globalPosition(globalPos.x(), globalPos.y(), globalPos.z()); // TODO: or positionShift?
369 
370  cl.setMeasurement<2>(hash, localPosition, localCovariance);
371  cl.setIdentifier( rdoList.front().get_compact() );
372  cl.setRDOlist(rdoList);
373  cl.globalPosition() = globalPosition;
374  cl.setChannelsInPhiEta(siWidth.colRow()[0], siWidth.colRow()[1]);
375  cl.setWidthInEta(static_cast<float>(siWidth.widthPhiRZ()[1]));
376  cl.setOmegas(omegax, omegay);
377  cl.setIsSplit(split);
378  cl.setSplitProbabilities(splitProb1, splitProb2);
379  ATH_MSG_DEBUG("\t\txaod width in eta " << cl.widthInEta());
380 
381  return StatusCode::SUCCESS;
382 }

◆ createSCTCluster() [1/4]

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

Definition at line 580 of file FPGAClusterConverter.cxx.

580  {
581  ATH_MSG_DEBUG("\t Create InDet::SCT_Cluster from FPGATrackSimCluster");
582  FPGATrackSimHit clEq = cluster.getClusterEquiv();
583  std::vector<Identifier> rdoList;
584  ATH_CHECK(getRdoList(rdoList, cluster));
585  ATH_CHECK(createSCTCluster(clEq, rdoList,cl));
586  return StatusCode::SUCCESS;
587 }

◆ createSCTCluster() [2/4]

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

Definition at line 589 of file FPGAClusterConverter.cxx.

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

◆ 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 384 of file FPGAClusterConverter.cxx.

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

◆ createSCTCluster() [4/4]

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

Definition at line 476 of file FPGAClusterConverter.cxx.

476  {
477  ATH_MSG_DEBUG("\t Create xAOD::StripCluster from FPGATrackSimHit ");
478  //https://gitlab.cern.ch/atlas/athena/-/blob/main/InnerDetector/InDetRecTools/SiClusterizationTool/src/SCT_ClusteringTool.cxx
479 
480  IdentifierHash hash = h.getIdentifierHash();
481 
482  float phiWidth = h.getPhiWidth();
483  int strip = static_cast<int>(h.getPhiCoord());
484  ATH_CHECK(strip >= 0);
485  const InDetDD::SiDetectorElement* pDE = m_SCTManager->getDetectorElement(hash);
486  ATH_CHECK(pDE != nullptr);
487 
488  Identifier wafer_id = m_SCTId->wafer_id(hash);
489  Identifier strip_id = m_SCTId->strip_id(wafer_id, strip);
490  InDetDD::SiCellId cell = pDE->cellIdFromIdentifier(strip_id);
491  ATH_MSG_DEBUG("\t\tcell: " << cell);
492  ATH_MSG_DEBUG("\t\tstrip_id " << strip_id);
493  ATH_MSG_DEBUG("\t\tstrip: " << cell);
494  ATH_MSG_DEBUG("\t\tStrip from idHelper: " << m_SCTId->strip(strip_id) );
495 
496  const InDetDD::SCT_ModuleSideDesign* design;
497  if (pDE->isBarrel()){
498  design = (static_cast<const InDetDD::SCT_ModuleSideDesign*>(&pDE->design()));
499  } else{
500  design = (static_cast<const InDetDD::StripStereoAnnulusDesign*>(&pDE->design()));
501  }
502 
503  const int firstStrip = m_SCTId->strip(rdoList.front());
504  const int lastStrip = m_SCTId->strip(rdoList.back());
505  const int row = m_SCTId->row(rdoList.front());
506  const int firstStrip1D = design->strip1Dim (firstStrip, row );
507  const int lastStrip1D = design->strip1Dim( lastStrip, row );
508  const InDetDD::SiCellId cell1(firstStrip1D);
509  const InDetDD::SiCellId cell2(lastStrip1D);
510  const InDetDD::SiLocalPosition firstStripPos( pDE->rawLocalPositionOfCell(cell1 ));
511  const InDetDD::SiLocalPosition lastStripPos( pDE->rawLocalPositionOfCell(cell2) );
512  const InDetDD::SiLocalPosition centre( (firstStripPos+lastStripPos) * 0.5 );
513  const double width = design->stripPitch() * ( lastStrip - firstStrip + 1 );
514 
515  const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends( design->endsOfStrip(centre) );
516  const double stripLength( std::abs(ends.first.xEta() - ends.second.xEta()) );
517 
518  InDet::SiWidth siWidth(Amg::Vector2D(phiWidth,1), Amg::Vector2D(width,stripLength) ); //TODO: ok??
519  Amg::Vector2D localPos(centre.xPhi(), centre.xEta());
520  ATH_MSG_DEBUG("\t\tcentre eta: " << centre.xEta() << " phi: " << centre.xPhi());
521  ATH_MSG_DEBUG("\t\tStrip length: " << stripLength );
522  ATH_MSG_DEBUG("\t\tlocal position before shift: " << localPos.x() << " phi: " << localPos.y());
523 
524  if (m_doShift) {
525  double shift = m_lorentzAngleTool->getLorentzShift(hash);
526  Amg::Vector2D localPosShift(localPos[Trk::locX]+shift,localPos[Trk::locY]);
527  localPos = localPosShift;
528  }
529 
530  Amg::Vector3D globalPos = pDE->globalPosition(localPos);
531  ATH_MSG_DEBUG("\t\tLocal position: x=" << localPos.x() << " y=" << localPos.y() );
532  ATH_MSG_DEBUG("\t\tGlobal position: x=" << globalPos.x() << " y=" << globalPos.y() << " z=" << globalPos.z() );
533 
534  /* TODO */
535  Eigen::Matrix<float,1,1> localPosition;
536  Eigen::Matrix<float,1,1> localCovariance;
537  localCovariance.setZero();
538 
539  if (pDE->isBarrel()) {
540  localPosition(0, 0) = localPos.x();
541  localCovariance(0, 0) = pDE->phiPitch() * pDE->phiPitch() * (1./12.);
542  } else {
543  InDetDD::SiCellId cellId = pDE->cellIdOfPosition(localPos);
544  const InDetDD::StripStereoAnnulusDesign *designNew = dynamic_cast<const InDetDD::StripStereoAnnulusDesign *>(&pDE->design());
545  if ( designNew == nullptr ) return StatusCode::FAILURE;
546  InDetDD::SiLocalPosition localInPolar = designNew->localPositionOfCellPC(cellId);
547  localPosition(0, 0) = localInPolar.xPhi();
548  localCovariance(0, 0) = designNew->phiPitchPhi() * designNew->phiPitchPhi() * (1./12.);
549  }
550 
551  Eigen::Matrix<float,3,1> globalPosition(globalPos.x(), globalPos.y(), globalPos.z());
552 
553  cl.setMeasurement<1>(hash, localPosition, localCovariance);
554  cl.setIdentifier( rdoList.front().get_compact() );
555  cl.setRDOlist(rdoList);
556  cl.globalPosition() = globalPosition;
557  cl.setChannelsInPhi(siWidth.colRow()[0]);
558 
559  return StatusCode::SUCCESS;
560 }

◆ getRdoList() [1/2]

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

Definition at line 598 of file FPGAClusterConverter.cxx.

598  {
599 
600  std::vector<FPGATrackSimHit> hits = cluster.getHitList();
601 
602  for (const FPGATrackSimHit& h : hits) {
603  IdentifierHash hash = h.getIdentifierHash();
604  int phiIndex = h.getPhiIndex();
605  int etaIndex = h.getEtaIndex();
606 
607  if (h.isPixel()) {
608  Identifier wafer_id_hit = m_pixelId->wafer_id(hash);
609  Identifier hit_id = m_pixelId->pixel_id(wafer_id_hit, phiIndex, etaIndex);
610  rdoList.push_back(hit_id);
611  }
612  if (h.isStrip()) {
613  Identifier wafer_id_hit = m_SCTId->wafer_id(hash);
614  Identifier hit_id = m_SCTId->strip_id(wafer_id_hit, int(phiIndex));
615  rdoList.push_back(hit_id);
616  }
617  }
618 
619  return StatusCode::SUCCESS;
620 
621 }

◆ getRdoList() [2/2]

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

Definition at line 624 of file FPGAClusterConverter.cxx.

624  {
625 
626  IdentifierHash hash = h.getIdentifierHash();
627  int phiIndex = h.getPhiIndex();
628  int etaIndex = h.getEtaIndex();
629 
630  if (h.isPixel()) {
631  Identifier wafer_id_hit = m_pixelId->wafer_id(hash);
632  Identifier hit_id = m_pixelId->pixel_id(wafer_id_hit, phiIndex, etaIndex);
633  rdoList.push_back(hit_id);
634  }
635  if (h.isStrip()) {
636  Identifier wafer_id_hit = m_SCTId->wafer_id(hash);
637  Identifier hit_id = m_SCTId->strip_id(wafer_id_hit, int(phiIndex));
638  rdoList.push_back(hit_id);
639  }
640 
641  return StatusCode::SUCCESS;
642 }

◆ initialize()

StatusCode FPGAClusterConverter::initialize ( )
finaloverridevirtual

Definition at line 21 of file FPGAClusterConverter.cxx.

21  {
22 
23  ATH_MSG_DEBUG("Initializing FPGAClusterConverter...");
24 
25  // Get SCT & pixel Identifier helpers
26  ATH_CHECK(detStore()->retrieve(m_pixelId, "PixelID"));
27  ATH_CHECK(detStore()->retrieve(m_SCTId, "SCT_ID"));
28  ATH_CHECK(detStore()->retrieve(m_pixelManager));
29  ATH_CHECK(detStore()->retrieve(m_SCTManager));
30  ATH_CHECK(m_lorentzAngleTool.retrieve());
31 
32  ATH_CHECK( m_FPGAClusterKey.initialize() );
33 
34  return StatusCode::SUCCESS;
35 
36 }

Member Data Documentation

◆ m_doShift

bool FPGAClusterConverter::m_doShift = true

Definition at line 74 of file FPGAClusterConverter.h.

◆ m_FPGAClusterKey

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

Definition at line 72 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 83 of file FPGAClusterConverter.h.

◆ m_pixelId

const PixelID* FPGAClusterConverter::m_pixelId {nullptr}
private

Definition at line 78 of file FPGAClusterConverter.h.

◆ m_pixelManager

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

Definition at line 80 of file FPGAClusterConverter.h.

◆ m_SCTId

const SCT_ID* FPGAClusterConverter::m_SCTId {nullptr}
private

Definition at line 79 of file FPGAClusterConverter.h.

◆ m_SCTManager

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

Definition at line 81 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
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:81
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:29
FPGATrackSimCluster::getHitList
hitVector const & getHitList() const
Definition: FPGATrackSimCluster.h:30
SiliconTech::strip
@ strip
FPGATrackSimHit::isStrip
bool isStrip() const
Definition: FPGATrackSimHit.h:62
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
Trk::locX
@ locX
Definition: ParamDefs.h:43
InDetDD::PixelModuleDesign
Definition: PixelModuleDesign.h:48
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:44
FPGATrackSimCluster
Definition: FPGATrackSimCluster.h:25
FPGAClusterConverter::m_lorentzAngleTool
ToolHandle< ISiLorentzAngleTool > m_lorentzAngleTool
Definition: FPGAClusterConverter.h:83
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
InDetDD::SCT_ModuleSideDesign
Definition: SCT_ModuleSideDesign.h:40
FPGAClusterConverter::m_FPGAClusterKey
SG::ReadHandleKey< FPGATrackSimClusterCollection > m_FPGAClusterKey
Definition: FPGAClusterConverter.h:72
InDetDD::DetectorDesign::shape
virtual DetectorShape shape() const
Shape of element.
Definition: DetectorDesign.cxx:96
plotBeamSpotVxVal.cov
cov
Definition: plotBeamSpotVxVal.py:201
InDetDD::SCT_DetectorManager::getDetectorElement
virtual SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements via Identifier
Definition: SCT_DetectorManager.cxx:64
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
SCT_CalibAlgs::lastStrip
@ lastStrip
Definition: SCT_CalibNumbers.h:10
FPGAClusterConverter::m_pixelManager
const InDetDD::PixelDetectorManager * m_pixelManager
Definition: FPGAClusterConverter.h:80
FPGATrackSimHit
Definition: FPGATrackSimHit.h:38
FPGAClusterConverter::m_SCTId
const SCT_ID * m_SCTId
Definition: FPGAClusterConverter.h:79
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:78
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
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:384
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
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
InDetDD::Annulus
@ Annulus
Definition: DetectorDesign.h:42
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArG4ShowerLibProcessing.hits
hits
Definition: LArG4ShowerLibProcessing.py:136
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:598
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
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:76
FPGATrackSimHit::isPixel
bool isPixel() const
Definition: FPGATrackSimHit.h:61
FPGAClusterConverter::m_doShift
bool m_doShift
Definition: FPGAClusterConverter.h:74
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
FPGAClusterConverter::createPixelCluster
virtual StatusCode createPixelCluster(const FPGATrackSimHit &h, const std::vector< Identifier > &rdoList, std::unique_ptr< InDet::PixelCluster > &) const override final
Definition: FPGAClusterConverter.cxx:223
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:195
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.
InDetDD::SiDetectorElement::isBarrel
bool isBarrel() const
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
InDetDD::SolidStateDetectorElementBase::rawLocalPositionOfCell
Amg::Vector2D rawLocalPositionOfCell(const SiCellId &cellId) const
Returns position (center) of cell.
Definition: SolidStateDetectorElementBase.cxx:230
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
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):
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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
xAOD::phiWidth
phiWidth
Definition: RingSetConf_v1.cxx:612
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
InDet::SiWidth
Definition: SiWidth.h:25
SCT_CalibAlgs::firstStrip
@ firstStrip
Definition: SCT_CalibNumbers.h:10
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
Definition: IdentifierHash.h:38
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.
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
Generated on Fri Jul 5 2024 21:45:40 for ATLAS Offline Software by   doxygen 1.8.18