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 | Private Member Functions | Private Attributes | List of all members
FPGATrackSimClusteringTool Class Reference

#include <FPGATrackSimClusteringTool.h>

Inheritance diagram for FPGATrackSimClusteringTool:
Collaboration diagram for FPGATrackSimClusteringTool:

Public Member Functions

 FPGATrackSimClusteringTool (const std::string &, const std::string &, const IInterface *)
 
virtual ~FPGATrackSimClusteringTool ()=default
 
virtual StatusCode DoClustering (FPGATrackSimLogicalEventInputHeader &, std::vector< FPGATrackSimCluster > &) const override
 

Private Member Functions

void SortedClustering (const std::vector< std::vector< FPGATrackSimHit > > &sorted_hits, std::vector< FPGATrackSimCluster > &) const
 
void Clustering (std::vector< FPGATrackSimHit >, std::vector< FPGATrackSimCluster > &) const
 
void reduceGlobalCoordPrecision (FPGATrackSimCluster &cluster) const
 
void reduceGlobalCoordPrecision (FPGATrackSimHit &hit) const
 
void splitAndSortHits (std::vector< FPGATrackSimHit > &hits, std::vector< std::vector< FPGATrackSimHit > > &hitsPerModule, int &eta_phi) const
 
void splitAndSortHits (std::vector< FPGATrackSimHit > &hits, std::vector< std::vector< FPGATrackSimHit > > &hitsPerModule) const
 
void splitHitsToModules (std::vector< FPGATrackSimHit > &hits, std::vector< std::vector< FPGATrackSimHit > > &hitsPerModule) const
 
void normaliseClusters (std::vector< FPGATrackSimCluster > &clusters) const
 
void sortHitsOnModules (std::vector< std::vector< FPGATrackSimHit > > &hitsPerModule, int &eta_phi) const
 
void sortHitsOnModules (std::vector< std::vector< FPGATrackSimHit > > &hitsPerModule) const
 
bool etaOrPhi (const FPGATrackSimHit &hit) const
 
bool sortIBLInput (const std::unique_ptr< FPGATrackSimHit > &i, const std::unique_ptr< FPGATrackSimHit > &j) const
 
bool sortPixelInput (const std::unique_ptr< FPGATrackSimHit > &i, const std::unique_ptr< FPGATrackSimHit > &j) const
 

Private Attributes

Gaudi::Property< bool > m_digitalClustering {this, "DigitalClustering", false, "flag to enable digital clustering instead of ToT weighted position calculation" }
 
Gaudi::Property< bool > m_reduceCoordPrecision {this, "ReduceCoordPrecision", false, "flag to enable reducing the precision of global coordinates" }
 
Gaudi::Property< float > m_coordRPrecision {this, "CoordRPrecision", 1./64., "fixed point precision of r coordinate" }
 
Gaudi::Property< float > m_coordPhiPrecision {this, "CoordPhiPrecision", 1./8192., "fixed point precision of phi coordinate" }
 
Gaudi::Property< float > m_coordZPrecision {this, "CoordZPrecision", 1./32., "fixed point precision of z coordinate" }
 

Detailed Description

Definition at line 32 of file FPGATrackSimClusteringTool.h.

Constructor & Destructor Documentation

◆ FPGATrackSimClusteringTool()

FPGATrackSimClusteringTool::FPGATrackSimClusteringTool ( const std::string &  algname,
const std::string &  name,
const IInterface *  ifc 
)

Definition at line 19 of file FPGATrackSimClusteringTool.cxx.

19  :
20  base_class(algname, name, ifc)
21 {
22 }

◆ ~FPGATrackSimClusteringTool()

virtual FPGATrackSimClusteringTool::~FPGATrackSimClusteringTool ( )
virtualdefault

Member Function Documentation

◆ Clustering()

void FPGATrackSimClusteringTool::Clustering ( std::vector< FPGATrackSimHit >  moduleHits,
std::vector< FPGATrackSimCluster > &  moduleClusters 
) const
private

Definition at line 99 of file FPGATrackSimClusteringTool.cxx.

99  {
100  std::vector<FPGATrackSimCluster> tempClusters;
101  FPGATrackSimHit clusterEquiv;
102  bool newCluster, newHit;
103 
104  //To hold the current cluster vars for comparison
105  //loop over the hits that we have been passed for this module
106  for( auto& hit: moduleHits){
107  bool is_clustered_hit = false;
108 
109  //Loop over the clusters we have already made, check if this hit should be added to them?
110  for( auto& cluster: tempClusters){
111  if(hit.isPixel()){
112  if (FPGATrackSimCLUSTERING::updatePixelCluster(cluster, hit, false, m_digitalClustering))
113  is_clustered_hit = true;
114  }
115  if(hit.isStrip()){
116  if (FPGATrackSimCLUSTERING::updateStripCluster(cluster, hit, false, m_digitalClustering))
117  is_clustered_hit = true;
118  }
119  }
120 
121  //If it is the first hit or a not clustered hit, then start a new cluster and add it to the output vector
122  if((is_clustered_hit==0) or (tempClusters.size()==0)){
123  FPGATrackSimCluster cluster;
124  if(hit.isPixel()){
125  // No need to check the return code here
126  FPGATrackSimCLUSTERING::updatePixelCluster(cluster, hit, true, m_digitalClustering);
127  } else if(hit.isStrip()){
128  FPGATrackSimCLUSTERING::updateStripCluster(cluster, hit, true, m_digitalClustering);
129  }
130  //Put this cluster into the output hits. Will update it in place.
131  tempClusters.push_back(cluster);
132  }
133  }
134 
135  // Merge overlapping clusters
136  for (auto& cluster : tempClusters) {
137  newCluster = true;
138 
139  for (auto& finalCluster : moduleClusters) {
140  int cPhi = cluster.getClusterEquiv().getPhiIndex();
141  int cPhiWidth = cluster.getClusterEquiv().getPhiWidth();
142  int cEta = cluster.getClusterEquiv().getEtaIndex();
143  int cEtaWidth = cluster.getClusterEquiv().getEtaWidth();
144  int fCPhi = finalCluster.getClusterEquiv().getPhiIndex();
145  int fCPhiWidth = finalCluster.getClusterEquiv().getPhiWidth();
146  int fCEta = finalCluster.getClusterEquiv().getEtaIndex();
147  int fCEtaWidth = finalCluster.getClusterEquiv().getEtaWidth();
148 
149  // check for overlap in phi
150  if ((fCPhi > cPhi + cPhiWidth - 1) ||
151  (cPhi > fCPhi + fCPhiWidth - 1))
152  continue;
153 
154  // check for overlap in eta
155  if ((fCEta > cEta + cEtaWidth - 1) ||
156  (cEta > fCEta + fCEtaWidth - 1))
157  continue;
158 
159  // remaining clusters are overlapping, check if clusters share hits
160  unsigned int sharedhits = 0;
161  for (auto & hit : cluster.getHitList()) {
162  newHit = true;
163  for (auto & finalHit : finalCluster.getHitList()) {
164  if (hit.getEtaIndex() == finalHit.getEtaIndex() &&
165  hit.getPhiIndex() == finalHit.getPhiIndex())
166  newHit = false;
167  }
168  if (!newHit) {
169  sharedhits++;
170  }
171  }
172 
173  if (sharedhits == 0)
174  continue;
175 
176  // Merge the clusters
177  newCluster = false;
178 
179  clusterEquiv = finalCluster.getClusterEquiv();
180 
181  // set new phi & phi width
182  if (cPhi < fCPhi) {
183  clusterEquiv.setPhiIndex(cPhi);
184  if (cPhi + cPhiWidth < fCPhi + fCPhiWidth)
185  clusterEquiv.setPhiWidth(fCPhiWidth + (fCPhi - cPhi));
186  else
187  clusterEquiv.setPhiWidth(cPhiWidth);
188  } else {
189  clusterEquiv.setPhiIndex(fCPhi);
190  if (!(cPhi + cPhiWidth < fCPhi + fCPhiWidth))
191  clusterEquiv.setPhiWidth(cPhiWidth + (cPhi - fCPhi));
192  else
193  clusterEquiv.setPhiWidth(fCPhiWidth);
194  }
195 
196  // set new eta & eta width
197  if (cEta < fCEta) {
198  clusterEquiv.setEtaIndex(cEta);
199  if (cEta + cEtaWidth < fCEta + fCEtaWidth)
200  clusterEquiv.setEtaWidth(fCEtaWidth + (fCEta - cEta));
201  else
202  clusterEquiv.setEtaWidth(cEtaWidth);
203  } else {
204  clusterEquiv.setEtaIndex(fCEta);
205  if (!(cEta + cEtaWidth < fCEta + fCEtaWidth))
206  clusterEquiv.setEtaWidth(cEtaWidth + (cEta - fCEta));
207  else
208  clusterEquiv.setEtaWidth(fCEtaWidth);
209  }
210 
211  finalCluster.setClusterEquiv(clusterEquiv);
212 
213  for (auto & hit : cluster.getHitList()) {
214  newHit = true;
215  for (auto & finalHit : finalCluster.getHitList()) {
216  if (hit.getEtaIndex() == finalHit.getEtaIndex() &&
217  hit.getPhiIndex() == finalHit.getPhiIndex())
218  newHit = false;
219  }
220  if (newHit) {
221  CXXUTILS_TRAPPING_FP;
222  clusterEquiv = finalCluster.getClusterEquiv();
223  float xOld = clusterEquiv.getX();
224  float yOld = clusterEquiv.getY();
225  float zOld = clusterEquiv.getZ();
226  float xPhiOld = clusterEquiv.getPhiCoord();
227  float xEtaOld = clusterEquiv.getEtaCoord();
228  float cPhiOld = clusterEquiv.getCentroidPhiIndex();
229  float cEtaOld = clusterEquiv.getCentroidEtaIndex();
230  float xNew = hit.getX();
231  float yNew = hit.getY();
232  float zNew = hit.getZ();
233  float xPhiNew = hit.getPhiCoord();
234  float xEtaNew = hit.getEtaCoord();
235  float cPhiNew = hit.getPhiIndex();
236  float cEtaNew = hit.getEtaIndex();
237  int tot = clusterEquiv.getToT();
238  int totNew = hit.getToT();
239  if (m_digitalClustering) {
240  // n+1 because that is old + new now
241  int n = finalCluster.getHitList().size();
242  clusterEquiv.setX((xOld*n + xNew) / (n+1));
243  clusterEquiv.setY((yOld*n + yNew) / (n+1));
244  clusterEquiv.setZ((zOld*n + zNew) / (n+1));
245  clusterEquiv.setPhiCoord((xPhiOld*n + xPhiNew) / (n+1));
246  clusterEquiv.setEtaCoord((xEtaOld*n + xEtaNew) / (n+1));
247  clusterEquiv.setCentroidPhiIndex((cPhiOld*n + cPhiNew) / (n+1));
248  clusterEquiv.setCentroidEtaIndex((cEtaOld*n + cEtaNew) / (n+1));
249  } else {
250  clusterEquiv.setX((xOld*tot + xNew*totNew) / (tot+totNew));
251  clusterEquiv.setY((yOld*tot + yNew*totNew) / (tot+totNew));
252  clusterEquiv.setZ((zOld*tot + zNew*totNew) / (tot+totNew));
253  clusterEquiv.setPhiCoord((xPhiOld*tot + xPhiNew*totNew) / (tot+totNew));
254  clusterEquiv.setEtaCoord((xEtaOld*tot + xEtaNew*totNew) / (tot+totNew));
255  clusterEquiv.setCentroidPhiIndex((cPhiOld*tot + cPhiNew*totNew) / (tot+totNew));
256  clusterEquiv.setCentroidEtaIndex((cEtaOld*tot + cEtaNew*totNew) / (tot+totNew));
257  }
258  clusterEquiv.setToT(tot + totNew);
259  finalCluster.setClusterEquiv(clusterEquiv);
260  finalCluster.push_backHitList(hit);
261  }
262  }
263  }
264 
265  if (newCluster)
266  moduleClusters.push_back(cluster);
267  }
268 }

◆ DoClustering()

StatusCode FPGATrackSimClusteringTool::DoClustering ( FPGATrackSimLogicalEventInputHeader &  header,
std::vector< FPGATrackSimCluster > &  clusters 
) const
overridevirtual

Definition at line 25 of file FPGATrackSimClusteringTool.cxx.

26 {
27  for (int i = 0; i<header.nTowers(); i++)
28  {
29  // Retreive the hits from the tower
30  FPGATrackSimTowerInputHeader& tower = *header.getTower(i);
31  std::vector<FPGATrackSimHit> hits = tower.hits();
32 
33  std::vector<std::vector<FPGATrackSimHit>> hitsPerModule;
34  std::vector<FPGATrackSimCluster> towerClusters;
35 
36  if (m_reduceCoordPrecision) {
37  for (auto &hit : hits)
38  reduceGlobalCoordPrecision(hit);
39  }
40 
41  splitAndSortHits(hits, hitsPerModule);
42  SortedClustering(hitsPerModule, towerClusters);
43  normaliseClusters(towerClusters);
44 
45  //remove the old hits from the tower...
46  tower.clearHits();
47  tower.reserveHits(towerClusters.size());
48  clusters.clear();
49  clusters.reserve(towerClusters.size());
50  if(i > 1)
51  ATH_MSG_WARNING("more than one tower, m_clusters is only going to contain those from the last one");
52 
53  unsigned cluster_count = 0;
54  unsigned int pixelCounter = 0;
55  unsigned int stripCounter = 0;
56  for ( auto &cluster: towerClusters){
57  if (m_reduceCoordPrecision)
58  reduceGlobalCoordPrecision(cluster);
59 
60  FPGATrackSimHit cluster_as_FPGATrackSimhit = cluster.getClusterEquiv();
61  cluster_as_FPGATrackSimhit.setHitType(HitType::clustered);
62  cluster_as_FPGATrackSimhit.setParentageMask(cluster_count); // making use of unused m_parentageMask to keep track of cluster index
63 
64  if(cluster_as_FPGATrackSimhit.getDetType() == SiliconTech::pixel)
65  {
66  cluster_as_FPGATrackSimhit.setCluster1ID(pixelCounter);
67  pixelCounter++;
68  }
69  else if(cluster_as_FPGATrackSimhit.getDetType() == SiliconTech::strip)
70  {
71  cluster_as_FPGATrackSimhit.setCluster1ID(stripCounter);
72  stripCounter++;
73  }
74  tower.addHit(cluster_as_FPGATrackSimhit);
75 
76  //send back a copy for monitoring and to check when writing out hits in each road
77  clusters.push_back(cluster);
78  cluster_count++;
79  }
80  }
81  ATH_MSG_DEBUG("Produced "<< clusters.size()<< " clusters");
82  return StatusCode::SUCCESS;
83 }

◆ etaOrPhi()

bool FPGATrackSimClusteringTool::etaOrPhi ( const FPGATrackSimHit &  hit) const
private

Definition at line 375 of file FPGATrackSimClusteringTool.cxx.

375  {
376 
377  /*This currently might get complicated as eta/phi ordering varies depending on the position in the detector.
378  * For ITK-20-00-00 Step 2.2 inclined duals layout, worked out by Naoki.
379  * Detector position | Module Type (# chip) | Column | Row |
380  * =============================================================================
381  * Barrel Layer 0 Eta module 1-6 | 2 (double) | eta | phi |
382  * Barrel Layer 0 Eta module 7-22 | 1 (single) | phi | eta |
383  * Barrel Layer 1 Eta module 1-6 | 3 (quad) | eta | phi |
384  * Barrel Layer 1 Eta module 7-19 | 3 | phi | eta |
385  * Barrel Layer 2 Eta module 1-11 | 3 | eta | phi |
386  * Barrel Layer 2 Eta module 12-22 | 2 | phi | eta |
387  * Barrel Layer 3 Eta module 1-12 | 3 | eta | phi |
388  * Barrel Layer 3 Eta module 13-25 | 2 | phi | eta |
389  * Barrel Layer 4 Eta module 1-13 | 3 | eta | phi |
390  * Barrel Layer 4 Eta module 14-26 | 2 | phi | eta |
391  * All Endcap modules | 3 | eta | phi |
392  * =============================================================================
393  * Module Type 1 = Single, 2, Dual, 3 Quad
394  * 328x400 blocks
395  * Hit type is essentially isPixel
396  * DetectorZone 0 = Barrel, -ive/+ive = endcaps
397  */
398 
399  //Check if the two hits are from the same module
400  //If it is not a barrel module then sort eta as column
401  if(hit.getDetectorZone() != DetectorZone::barrel){
402  return ETA;
403  }
404  //Otherwise it is a barrel module and now things get more complicated
405  else {
406  //Start by looking at what layer it is in
407  if (hit.getPhysLayer() == 0 || hit.getPhysLayer() == 1) {
408  if (hit.getEtaModule() <=6) {
409  return ETA;
410  } else {
411  return PHI;
412  }
413  } else if (hit.getPhysLayer() == 2) {
414  if (hit.getEtaModule() <=11) {
415  return ETA;
416  } else {
417  return PHI;
418  }
419  } else if (hit.getPhysLayer() == 3) {
420  if (hit.getEtaModule() <=12) {
421  return ETA;
422  } else {
423  return PHI;
424  }
425  } else if (hit.getPhysLayer() == 4) {
426  if (hit.getEtaModule() <=13) {
427  return ETA;
428  } else {
429  return PHI;
430  }
431  }
432  }
433  //Default to ETA, but shouldn't reach here
434  return ETA;
435 }

◆ normaliseClusters()

void FPGATrackSimClusteringTool::normaliseClusters ( std::vector< FPGATrackSimCluster > &  clusters) const
private

Definition at line 352 of file FPGATrackSimClusteringTool.cxx.

352  {
353  for( auto &cluster:clusters){
354  //Grab the cluster equiv
355  FPGATrackSimHit clusterEquiv = cluster.getClusterEquiv();
356  //Update the clusterEquiv's position and width
357  if(clusterEquiv.isStrip()){
358  //Clear the groupsize, set this to be one as we are only clustering one row.
359  clusterEquiv.setEtaWidth(1);
360  clusterEquiv.setCentroidPhiIndex(clusterEquiv.getCentroidPhiIndex()/fpgatracksim::scaleHitFactor);
361  clusterEquiv.setPhiWidth(clusterEquiv.getPhiWidth()+1);
362  } else {
363  // Nothing to normalise for pixel clusters
364  continue;
365  }
366  cluster.setClusterEquiv(clusterEquiv);
367  }
368 }

◆ reduceGlobalCoordPrecision() [1/2]

void FPGATrackSimClusteringTool::reduceGlobalCoordPrecision ( FPGATrackSimCluster &  cluster) const
private

Definition at line 711 of file FPGATrackSimClusteringTool.cxx.

711  {
712  FPGATrackSimHit clusterEquiv = cluster.getClusterEquiv();
713  float pos[3] = { clusterEquiv.getR(), clusterEquiv.getGPhi(), clusterEquiv.getZ() };
714 
715  pos[0] = std::trunc(pos[0] / m_coordRPrecision) * m_coordRPrecision;
716  pos[1] = std::trunc(pos[1] / m_coordPhiPrecision) * m_coordPhiPrecision;
717  pos[2] = std::trunc(pos[2] / m_coordZPrecision) * m_coordZPrecision;
718 
719  clusterEquiv.setX(pos[0] * std::cos(pos[1]));
720  clusterEquiv.setY(pos[0] * std::sin(pos[1]));
721  clusterEquiv.setZ(pos[2]);
722 
723  cluster.setClusterEquiv(clusterEquiv);
724 }

◆ reduceGlobalCoordPrecision() [2/2]

void FPGATrackSimClusteringTool::reduceGlobalCoordPrecision ( FPGATrackSimHit &  hit) const
private

Definition at line 726 of file FPGATrackSimClusteringTool.cxx.

726  {
727  float pos[3] = { hit.getR(), hit.getGPhi(), hit.getZ() };
728 
729  pos[0] = std::trunc(pos[0] / m_coordRPrecision) * m_coordRPrecision;
730  pos[1] = std::trunc(pos[1] / m_coordPhiPrecision) * m_coordPhiPrecision;
731  pos[2] = std::trunc(pos[2] / m_coordZPrecision) * m_coordZPrecision;
732 
733  hit.setX(pos[0] * std::cos(pos[1]));
734  hit.setY(pos[0] * std::sin(pos[1]));
735  hit.setZ(pos[2]);
736 }

◆ SortedClustering()

void FPGATrackSimClusteringTool::SortedClustering ( const std::vector< std::vector< FPGATrackSimHit > > &  sorted_hits,
std::vector< FPGATrackSimCluster > &  clusters 
) const
private

Definition at line 86 of file FPGATrackSimClusteringTool.cxx.

86  {
87  std::vector<FPGATrackSimCluster> moduleClusters;
88  //Loop over the sorted modules that we have
89  for( auto& moduleHits:sorted_hits){
90  //Make the clusters for this module
91  Clustering(moduleHits, moduleClusters);
92  //Put these clusters into the output list
93  clusters.insert(clusters.end(), moduleClusters.begin(), moduleClusters.end());
94  //Clear the vector or this will get messy
95  moduleClusters.clear();
96  }
97 }

◆ sortHitsOnModules() [1/2]

void FPGATrackSimClusteringTool::sortHitsOnModules ( std::vector< std::vector< FPGATrackSimHit > > &  hitsPerModule) const
private

Definition at line 335 of file FPGATrackSimClusteringTool.cxx.

335  {
336  //Loop over the module separated hits
337  for ( auto& module:hitsPerModule){
338  if (module.size() > 1) {
339  if (module.at(0).isStrip())
340  std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputEta);
341  }
342  if (module.size() > 1) {
343  if (module.at(0).isStrip())
344  std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputPhi);
345  }
346  }
347 }

◆ sortHitsOnModules() [2/2]

void FPGATrackSimClusteringTool::sortHitsOnModules ( std::vector< std::vector< FPGATrackSimHit > > &  hitsPerModule,
int &  eta_phi 
) const
private

Definition at line 305 of file FPGATrackSimClusteringTool.cxx.

305  {
306  //Loop over the module separated hits
307  for ( auto& module:hitsPerModule){
308  //Work out if columns are ETA (1) || PHI (0)
309  if(etaOrPhi(module.at(0)) == true){
310  //Sort by ETA first
311  eta_phi = ETA;
312  if (module.size() > 1) {
313  if (module.at(0).isStrip())
314  std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputEta);
315  }
316  if (module.size() > 1) {
317  if (module.at(0).isStrip())
318  std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputPhi);
319  }
320  } else {
321  //Sort by PHI first
322  eta_phi = PHI;
323  if (module.size() > 1) {
324  if (module.at(0).isStrip())
325  std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputPhi);
326  }
327  if (module.size() > 1) {
328  if (module.at(0).isStrip())
329  std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputEta);
330  }
331  }
332  }
333 }

◆ sortIBLInput()

bool FPGATrackSimClusteringTool::sortIBLInput ( const std::unique_ptr< FPGATrackSimHit > &  i,
const std::unique_ptr< FPGATrackSimHit > &  j 
) const
private

◆ sortPixelInput()

bool FPGATrackSimClusteringTool::sortPixelInput ( const std::unique_ptr< FPGATrackSimHit > &  i,
const std::unique_ptr< FPGATrackSimHit > &  j 
) const
private

◆ splitAndSortHits() [1/2]

void FPGATrackSimClusteringTool::splitAndSortHits ( std::vector< FPGATrackSimHit > &  hits,
std::vector< std::vector< FPGATrackSimHit > > &  hitsPerModule 
) const
private

Definition at line 275 of file FPGATrackSimClusteringTool.cxx.

275  {
276  splitHitsToModules(hits, hitsPerModule);
277  sortHitsOnModules(hitsPerModule);
278 }

◆ splitAndSortHits() [2/2]

void FPGATrackSimClusteringTool::splitAndSortHits ( std::vector< FPGATrackSimHit > &  hits,
std::vector< std::vector< FPGATrackSimHit > > &  hitsPerModule,
int &  eta_phi 
) const
private

Definition at line 270 of file FPGATrackSimClusteringTool.cxx.

270  {
271  splitHitsToModules(hits, hitsPerModule);
272  sortHitsOnModules(hitsPerModule, eta_phi);
273 }

◆ splitHitsToModules()

void FPGATrackSimClusteringTool::splitHitsToModules ( std::vector< FPGATrackSimHit > &  hits,
std::vector< std::vector< FPGATrackSimHit > > &  hitsPerModule 
) const
private

Definition at line 282 of file FPGATrackSimClusteringTool.cxx.

282  {
283  //To hold the current module
284  std::vector<FPGATrackSimHit> currentModule;
285  uint hashing = 0;
286  //Split the incoming hits into hits by module
287  for ( auto& hit:hits){
288  if(hashing == 0){
289  currentModule.push_back(hit);
290  hashing = hit.getIdentifierHash();
291  } else if (hit.getIdentifierHash() == hashing) {
292  currentModule.push_back(hit);
293  } else {
294  hitsPerModule.push_back(currentModule);
295  currentModule.clear();
296  hashing = hit.getIdentifierHash();
297  currentModule.push_back(hit);
298  }
299  }
300 
301  // Now push that last one
302  if (currentModule.size() > 0) hitsPerModule.push_back(currentModule);
303 }

Member Data Documentation

◆ m_coordPhiPrecision

Gaudi::Property<float> FPGATrackSimClusteringTool::m_coordPhiPrecision {this, "CoordPhiPrecision", 1./8192., "fixed point precision of phi coordinate" }
private

Definition at line 46 of file FPGATrackSimClusteringTool.h.

◆ m_coordRPrecision

Gaudi::Property<float> FPGATrackSimClusteringTool::m_coordRPrecision {this, "CoordRPrecision", 1./64., "fixed point precision of r coordinate" }
private

Definition at line 45 of file FPGATrackSimClusteringTool.h.

◆ m_coordZPrecision

Gaudi::Property<float> FPGATrackSimClusteringTool::m_coordZPrecision {this, "CoordZPrecision", 1./32., "fixed point precision of z coordinate" }
private

Definition at line 47 of file FPGATrackSimClusteringTool.h.

◆ m_digitalClustering

Gaudi::Property<bool> FPGATrackSimClusteringTool::m_digitalClustering {this, "DigitalClustering", false, "flag to enable digital clustering instead of ToT weighted position calculation" }
private

Definition at line 43 of file FPGATrackSimClusteringTool.h.

◆ m_reduceCoordPrecision

Gaudi::Property<bool> FPGATrackSimClusteringTool::m_reduceCoordPrecision {this, "ReduceCoordPrecision", false, "flag to enable reducing the precision of global coordinates" }
private

Definition at line 44 of file FPGATrackSimClusteringTool.h.

The documentation for this class was generated from the following files:
FPGATrackSimCLUSTERING::updateStripCluster
bool updateStripCluster(FPGATrackSimCluster &currentCluster, FPGATrackSimHit &incomingHit, bool newCluster, bool digitalClustering)
Definition: FPGATrackSimClusteringTool.cxx:540
FPGATrackSimTowerInputHeader::clearHits
void clearHits()
Definition: FPGATrackSimTowerInputHeader.h:49
CXXUTILS_TRAPPING_FP
#define CXXUTILS_TRAPPING_FP
Definition: trapping_fp.h:24
FPGATrackSimClusteringTool::sortHitsOnModules
void sortHitsOnModules(std::vector< std::vector< FPGATrackSimHit > > &hitsPerModule, int &eta_phi) const
Definition: FPGATrackSimClusteringTool.cxx:305
getMenu.algname
algname
Definition: getMenu.py:54
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
SiliconTech::strip
@ strip
FPGATrackSimHit::getEtaModule
int getEtaModule(bool old=false) const
Definition: FPGATrackSimHit.h:87
FPGATrackSimHit::isStrip
bool isStrip() const
Definition: FPGATrackSimHit.h:65
header
Definition: hcg.cxx:526
FPGATrackSimHit::getToT
unsigned getToT() const
Definition: FPGATrackSimHit.h:155
FPGATrackSimCLUSTERING::sortITkInputPhi
bool sortITkInputPhi(const FPGATrackSimHit &hitA, const FPGATrackSimHit &HitB)
Definition: FPGATrackSimClusteringTool.cxx:703
FPGATrackSimCluster
Definition: FPGATrackSimCluster.h:24
FPGATrackSimHit::setEtaIndex
void setEtaIndex(unsigned v)
Definition: FPGATrackSimHit.h:102
FPGATrackSimCLUSTERING::updatePixelCluster
bool updatePixelCluster(FPGATrackSimCluster &currentCluster, FPGATrackSimHit &incomingHit, bool newCluster, bool digitalClustering)
Definition: FPGATrackSimClusteringTool.cxx:458
FPGATrackSimHit::setPhiCoord
void setPhiCoord(float v)
Definition: FPGATrackSimHit.h:105
FPGATrackSimHit::setCentroidPhiIndex
void setCentroidPhiIndex(float v)
Definition: FPGATrackSimHit.h:103
FPGATrackSimHit::getX
float getX() const
Definition: FPGATrackSimHit.h:140
FPGATrackSimHit::setEtaWidth
void setEtaWidth(unsigned v)
Definition: FPGATrackSimHit.h:78
FPGATrackSimClusteringTool::m_coordPhiPrecision
Gaudi::Property< float > m_coordPhiPrecision
Definition: FPGATrackSimClusteringTool.h:46
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
RoiUtil::PHI
@ PHI
Definition: RoiSerialise.cxx:31
FPGATrackSimHit::setY
void setY(float v)
Definition: FPGATrackSimHit.h:138
std::stable_sort
void stable_sort(std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, std::reverse_iterator< DataModel_detail::iterator< DVL > > end, Compare comp)
Specialization of stable_sort for DataVector/List.
Definition: DVL_algorithms.h:711
FPGATrackSimTowerInputHeader::addHit
void addHit(const FPGATrackSimHit &s)
Definition: FPGATrackSimTowerInputHeader.h:48
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
FPGATrackSimHit::getGPhi
float getGPhi() const
Definition: FPGATrackSimHit.h:144
FPGATrackSimClusteringTool::etaOrPhi
bool etaOrPhi(const FPGATrackSimHit &hit) const
Definition: FPGATrackSimClusteringTool.cxx:375
FPGATrackSimHit::getPhiCoord
float getPhiCoord() const
Definition: FPGATrackSimHit.h:111
python.PyAthena.module
module
Definition: PyAthena.py:131
FPGATrackSimHit::setX
void setX(float v)
Definition: FPGATrackSimHit.h:137
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
FPGATrackSimHit::setToT
void setToT(unsigned v)
Definition: FPGATrackSimHit.h:148
FPGATrackSimHit::setPhiIndex
void setPhiIndex(unsigned v)
Definition: FPGATrackSimHit.h:101
columnar::ContainerId::cluster
@ cluster
lumiFormat.i
int i
Definition: lumiFormat.py:85
beamspotman.n
n
Definition: beamspotman.py:731
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
FPGATrackSimHit::setEtaCoord
void setEtaCoord(float v)
Definition: FPGATrackSimHit.h:106
FPGATrackSimClusteringTool::normaliseClusters
void normaliseClusters(std::vector< FPGATrackSimCluster > &clusters) const
Definition: FPGATrackSimClusteringTool.cxx:352
FPGATrackSimCLUSTERING::sortITkInputEta
bool sortITkInputEta(const FPGATrackSimHit &hitA, const FPGATrackSimHit &hitB)
Definition: FPGATrackSimClusteringTool.cxx:694
FPGATrackSimHit::getY
float getY() const
Definition: FPGATrackSimHit.h:141
FPGATrackSimClusteringTool::m_coordZPrecision
Gaudi::Property< float > m_coordZPrecision
Definition: FPGATrackSimClusteringTool.h:47
FPGATrackSimHit::setCluster1ID
void setCluster1ID(int v)
Definition: FPGATrackSimHit.h:182
FPGATrackSimHit::getZ
float getZ() const
Definition: FPGATrackSimHit.h:142
FPGATrackSimHit::getDetectorZone
DetectorZone getDetectorZone() const
Definition: FPGATrackSimHit.h:59
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
FPGATrackSimClusteringTool::SortedClustering
void SortedClustering(const std::vector< std::vector< FPGATrackSimHit > > &sorted_hits, std::vector< FPGATrackSimCluster > &) const
Definition: FPGATrackSimClusteringTool.cxx:86
FPGATrackSimHit::getCentroidPhiIndex
float getCentroidPhiIndex() const
Definition: FPGATrackSimHit.h:109
HitType::clustered
@ clustered
FPGATrackSimClusteringTool::m_reduceCoordPrecision
Gaudi::Property< bool > m_reduceCoordPrecision
Definition: FPGATrackSimClusteringTool.h:44
FPGATrackSimHit::setPhiWidth
void setPhiWidth(unsigned v)
Definition: FPGATrackSimHit.h:79
RoiUtil::ETA
@ ETA
Definition: RoiSerialise.cxx:30
FPGATrackSimClusteringTool::splitAndSortHits
void splitAndSortHits(std::vector< FPGATrackSimHit > &hits, std::vector< std::vector< FPGATrackSimHit > > &hitsPerModule, int &eta_phi) const
Definition: FPGATrackSimClusteringTool.cxx:270
FPGATrackSimHit::getEtaCoord
float getEtaCoord() const
Definition: FPGATrackSimHit.h:112
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
FPGATrackSimHit::setZ
void setZ(float v)
Definition: FPGATrackSimHit.h:139
FPGATrackSimClusteringTool::m_digitalClustering
Gaudi::Property< bool > m_digitalClustering
Definition: FPGATrackSimClusteringTool.h:43
FPGATrackSimHit::getCentroidEtaIndex
float getCentroidEtaIndex() const
Definition: FPGATrackSimHit.h:110
fpgatracksim::scaleHitFactor
constexpr float scaleHitFactor
Definition: FPGATrackSimConstants.h:18
FPGATrackSimHit::getR
float getR() const
Definition: FPGATrackSimHit.h:143
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
FPGATrackSimClusteringTool::splitHitsToModules
void splitHitsToModules(std::vector< FPGATrackSimHit > &hits, std::vector< std::vector< FPGATrackSimHit > > &hitsPerModule) const
Definition: FPGATrackSimClusteringTool.cxx:282
FPGATrackSimTowerInputHeader::reserveHits
void reserveHits(size_t size)
Definition: FPGATrackSimTowerInputHeader.h:50
FPGATrackSimHit::getDetType
SiliconTech getDetType() const
Definition: FPGATrackSimHit.h:58
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
DetectorZone::barrel
@ barrel
FPGATrackSimTowerInputHeader::hits
const std::vector< FPGATrackSimHit > & hits() const
Definition: FPGATrackSimTowerInputHeader.h:46
FPGATrackSimHit::getPhysLayer
unsigned getPhysLayer(bool old=false) const
Definition: FPGATrackSimHit.cxx:72
FPGATrackSimClusteringTool::reduceGlobalCoordPrecision
void reduceGlobalCoordPrecision(FPGATrackSimCluster &cluster) const
Definition: FPGATrackSimClusteringTool.cxx:711
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
FPGATrackSimHit::setCentroidEtaIndex
void setCentroidEtaIndex(float v)
Definition: FPGATrackSimHit.h:104
FPGATrackSimHit::setParentageMask
void setParentageMask(unsigned long v)
Definition: FPGATrackSimHit.h:153
FPGATrackSimTowerInputHeader
Definition: FPGATrackSimTowerInputHeader.h:18
FPGATrackSimHit::getPhiWidth
unsigned getPhiWidth() const
Definition: FPGATrackSimHit.h:86
SiliconTech::pixel
@ pixel
FPGATrackSimHit::setHitType
void setHitType(HitType type)
Definition: FPGATrackSimHit.h:54
FPGATrackSimClusteringTool::m_coordRPrecision
Gaudi::Property< float > m_coordRPrecision
Definition: FPGATrackSimClusteringTool.h:45
FPGATrackSimClusteringTool::Clustering
void Clustering(std::vector< FPGATrackSimHit >, std::vector< FPGATrackSimCluster > &) const
Definition: FPGATrackSimClusteringTool.cxx:99
Generated on Tue Apr 22 2025 21:33:22 for ATLAS Offline Software by   doxygen 1.8.18