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
FPGATrackSimSpacePointsTool Class Reference

#include <FPGATrackSimSpacePointsTool.h>

Inheritance diagram for FPGATrackSimSpacePointsTool:
Collaboration diagram for FPGATrackSimSpacePointsTool:

Public Member Functions

virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual StatusCode DoSpacePoints (FPGATrackSimLogicalEventInputHeader &, std::vector< FPGATrackSimCluster > &) override
 

Private Member Functions

StatusCode fillMaps (std::vector< FPGATrackSimHit > &hits)
 
StatusCode makeSpacePoints (FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
 
void calcPosition (FPGATrackSimHit &hit_in, FPGATrackSimHit &hit_out, float &x, float &y, float &z)
 
bool searchForMatch (FPGATrackSimHit &hit_in, std::vector< FPGATrackSimHit > &hits_outer, FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
 
void addSpacePoints (FPGATrackSimHit hit_in, FPGATrackSimHit hit_out, FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
 
void reduceGlobalCoordPrecision (FPGATrackSimHit &hit) const
 

Private Attributes

std::map< std::vector< int >, std::pair< std::vector< FPGATrackSimHit >, std::vector< FPGATrackSimHit > > > m_map
 
std::vector< FPGATrackSimHit > m_pixel
 
Gaudi::Property< float > m_phiwindow { this, "PhiWindow", 0.008, "Distance in phi to consider two hits for making a space-point" }
 
Gaudi::Property< bool > m_duplicate { this, "Duplication", false, "Duplicate spacepoints to layer on the other side of the stave" }
 
Gaudi::Property< bool > m_filter { this, "Filtering", false, "Filter out incomplete spacepoints" }
 
Gaudi::Property< bool > m_filterClose { this, "FilteringClosePoints", false, "Filter out single hits cloes to spacepoints" }
 
Gaudi::Property< bool > m_sameModulesOnly { this, "SameModulesOnly", false, "Only use hits on the same physical (eta) module" }
 
Gaudi::Property< bool > m_boundsCheck { this, "BoundsCheck", false, "Perform a module bounds check in the endcaps" }
 
Gaudi::Property< bool > m_reduceCoordPrecision {this, "ReduceCoordPrecision", false, "flag to enable reduc ing 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" }
 
unsigned m_inputhits = 0
 
unsigned m_spacepts = 0
 
unsigned m_filteredhits = 0
 
unsigned m_adjacent_eta_sp = 0
 
unsigned m_adjacent_phi_sp = 0
 
unsigned m_diagonal_sp = 0
 
TH1I * m_spacepts_per_hit = nullptr
 

Detailed Description

Definition at line 19 of file FPGATrackSimSpacePointsTool.h.

Member Function Documentation

◆ addSpacePoints()

void FPGATrackSimSpacePointsTool::addSpacePoints ( FPGATrackSimHit  hit_in,
FPGATrackSimHit  hit_out,
FPGATrackSimTowerInputHeader &  tower,
std::vector< FPGATrackSimCluster > &  spacepoints 
)
private

Definition at line 252 of file FPGATrackSimSpacePointsTool.cxx.

253 {
254  // Make a spacepoint
255  //------------------
256  float x,y,z;
257  calcPosition(hit_in, hit_out, x, y, z);
258 
259  float phi_window = abs(hit_in.getGPhi()-hit_out.getGPhi());
260 
261  // Let's print out the coords of the spacepoints we identify.
262  float r = TMath::Sqrt(x*x + y*y);
263  ATH_MSG_DEBUG("Spacepoint x = " << x << ", y = " << y << ", z = " << z << ", r = " << r);
264  ATH_MSG_DEBUG(" Paired hit z = " << hit_in.getZ() << ", r = " << hit_in.getR() << ", phi = " << hit_in.getGPhi() << ", phi module = " << hit_in.getPhiModule() << ", eta module = " << hit_in.getEtaModule());
265  ATH_MSG_DEBUG(" Paired hit z = " << hit_out.getZ() << ", r = " << hit_out.getR() << ", phi = " << hit_out.getGPhi() << ", phi module = " << hit_out.getPhiModule() << ", eta module = " << hit_out.getEtaModule());
266 
267  // We need to merge the truth information for the hits together in order
268  // to use them in matrix generation.
269 
270  const FPGATrackSimMultiTruth truth_in = hit_in.getTruth();
271  const FPGATrackSimMultiTruth truth_out = hit_out.getTruth();
272 
273  FPGATrackSimMultiTruth new_truth;
274  new_truth.add(truth_in);
275  new_truth.add(truth_out);
276  //hit_in.setTruth(new_truth);
277 
278  //hit_in.setX(x);
279  //hit_in.setY(y);
280  //hit_in.setZ(z);
281 
282  // TODO this is probably no longer necessary, we should just overwrite the local coordinates
283  // of both hit, I think?
284  //hit_in.setPairedHit(hit_in);
285 
286  // This function now does everything (I think) including storing the correct
287  // local coordinates for later retrieval.
288  // Maybe it should return a new FPGATrackSimHit rather than modifying in place.
289  hit_in.makeSpacepoint(x, y, z, phi_window, hit_out, new_truth);
290  hit_in.setCluster2ID(hit_out.getCluster1ID());
291 
292  if (m_reduceCoordPrecision)
293  reduceGlobalCoordPrecision(hit_in);
294 
295  // abusing hit type 'guessed' to be able to indentify it as spacepoint later on
296  // Guessed is ambiguous with an actual guessed hit-- there is a spacepoint type which
297  // should be used instead.
298  // hit_in.setHitType(HitType::guessed);
299  // hit_in.setHitType(HitType::spacepoint);
300  tower.addHit(hit_in);
301 
302  if (m_duplicate) {
303  hit_out.makeSpacepoint(x, y, z, phi_window, hit_in, new_truth);
304  hit_out.setCluster2ID(hit_in.getCluster1ID());
305 
306  if (m_reduceCoordPrecision)
307  reduceGlobalCoordPrecision(hit_out);
308 
309  tower.addHit(hit_out);
310  }
311 
312  // push back a copy for monitoring
313  FPGATrackSimCluster sp;
314  sp.setClusterEquiv(hit_in);
315  sp.push_backHitList(hit_in);
316  sp.push_backHitList(hit_out);
317  spacepoints.push_back(sp);
318 
319 }

◆ calcPosition()

void FPGATrackSimSpacePointsTool::calcPosition ( FPGATrackSimHit &  hit_in,
FPGATrackSimHit &  hit_out,
float &  x,
float &  y,
float &  z 
)
private

Definition at line 323 of file FPGATrackSimSpacePointsTool.cxx.

324 {
325  float phi_sp = (hit_in.getGPhi() + hit_out.getGPhi()) / 2.0;
326  float r_sp = (hit_in.getR() + hit_out.getR()) / 2.0;;
327  float z_sp = (hit_in.getZ() + hit_out.getZ()) / 2.0;;
328 
329  float delta_phi_local = (hit_in.getGPhi() - hit_out.getGPhi()) * r_sp; // distance in phi dir in mm
330 
331  if (hit_in.isBarrel())
332  {
333  static const float stereo_angle = 0.026; // barrel
334  z_sp += delta_phi_local/tan(stereo_angle)/2.0;
335  }
336  else
337  {
338  static const float stereo_angle = 0.020; // endcap
339  r_sp += delta_phi_local/tan(stereo_angle)/2.0;
340 
341  // don't let r_sp out of range of edge of module TODO fix hardcode
342  // Allow for the bounds check to be disabled, since it may mess up a linear fit.
343  if (m_boundsCheck) {
344  float r_bounds[19] = {394.0, 415.5, 442.0, 472.4, 498.85, 521.45, 547.05, 566.65, 591.0, 621.8, 654.7, 683.9, 710.2, 739.4, 784.2, 838.8, 887.6, 937.7, 967.8};
345 
346  if (hit_in.getEtaModule()==hit_in.getEtaModule()) {
347  float r_limited = std::max(r_sp,r_bounds[hit_in.getEtaModule()]);
348  r_limited = std::min(r_sp,r_bounds[hit_in.getEtaModule()+1]);
349  if (r_sp!=r_limited) {
350  ATH_MSG_WARNING("Spacepoint location not in module boundary: r_sp=" << r_sp
351  << " not in [" << r_bounds[hit_in.getEtaModule()] << "," << r_bounds[hit_in.getEtaModule()+1] << "]");
352  r_sp=r_limited;
353  }
354  } else if (hit_in.getEtaModule()==hit_in.getEtaModule()+1) {
355  float window = 3; //mm, max possible distance between hits from same track with reasonable incline to module
356  float r_limited = std::max(r_sp,r_bounds[hit_in.getEtaModule()+1]-window);
357  r_limited = std::min(r_sp,r_bounds[hit_in.getEtaModule()+1]+window);
358  if (r_sp!=r_limited) {
359  ATH_MSG_WARNING("Crossing spacepoint location too far from module boundary: r_sp=" << r_sp
360  << " not in [" << r_bounds[hit_in.getEtaModule()+1]-window << "," << r_bounds[hit_in.getEtaModule()+1]+window << "]");
361  r_sp=r_limited;
362  }
363  }
364  }
365  }
366 
367  // insert new values
368  x = r_sp*cos(phi_sp);
369  y = r_sp*sin(phi_sp);
370  z = z_sp;
371 }

◆ DoSpacePoints()

StatusCode FPGATrackSimSpacePointsTool::DoSpacePoints ( FPGATrackSimLogicalEventInputHeader &  header,
std::vector< FPGATrackSimCluster > &  spacepoints 
)
overridevirtual

Definition at line 43 of file FPGATrackSimSpacePointsTool.cxx.

44 {
45  for (int i = 0; i < header.nTowers(); ++i)
46  {
47  FPGATrackSimTowerInputHeader &tower = *header.getTower(i);
48  std::vector<FPGATrackSimHit> hits = tower.hits();
49  if (hits.empty()) continue;
50 
51  m_inputhits += hits.size();
52  ATH_CHECK(fillMaps(hits));
53  ATH_CHECK(makeSpacePoints(tower,spacepoints));
54  }
55 
56  return StatusCode::SUCCESS;
57 }

◆ fillMaps()

StatusCode FPGATrackSimSpacePointsTool::fillMaps ( std::vector< FPGATrackSimHit > &  hits)
private

Definition at line 60 of file FPGATrackSimSpacePointsTool.cxx.

61 {
62  m_map.clear();
63  m_pixel.clear();
64 
65  int strip_hits = 0;
66  for (auto hit : hits) {
67 
68  if (hit.isPixel()) {
69  // just save them so we can put them back
70  m_pixel.push_back(hit);
71  ATH_MSG_DEBUG("Pixel hit z = " << hit.getZ() << ", r = " << hit.getR() << ", phi = " << hit.getGPhi());
72  continue;
73  }
74  strip_hits += 1;
75 
76  std::vector<int> module_desc(4);
77 
78  module_desc[0] = (int)hit.getDetectorZone();
79  module_desc[1] = hit.getPhysLayer()/2; //div 2 gives layer as part of pair
80  unsigned side = hit.getPhysLayer()%2; // even/odd layer
81  module_desc[2] = hit.getPhiModule();
82  module_desc[3] = hit.getEtaModule();
83 
84  if (side==0)
85  m_map[module_desc].first.push_back(hit);
86  else
87  m_map[module_desc].second.push_back(hit);
88  }
89 
90  ATH_MSG_DEBUG("Running spacepoints default tool over " << strip_hits << " strip hits.");
91 
92  return StatusCode::SUCCESS;
93 }

◆ finalize()

StatusCode FPGATrackSimSpacePointsTool::finalize ( )
overridevirtual

Definition at line 28 of file FPGATrackSimSpacePointsTool.cxx.

29 {
30  ATH_MSG_INFO("Spacepoints report");
31  ATH_MSG_INFO("-----------------------------------------");
32  ATH_MSG_INFO("Strip Hits Input " << m_inputhits);
33  ATH_MSG_INFO("Spacepoints Ouput " << m_spacepts);
34  ATH_MSG_INFO("Filtered Hits " << m_filteredhits);
35  ATH_MSG_INFO("Adjacent Eta Module SPs " << m_adjacent_eta_sp);
36  ATH_MSG_INFO("Adjacent Phi Module SPs " << m_adjacent_phi_sp);
37  ATH_MSG_INFO("Diagonal Module SPs " << m_diagonal_sp);
38  ATH_MSG_INFO("Spacepoints per hit " << m_spacepts_per_hit->GetMean());
39  ATH_MSG_INFO("-----------------------------------------");
40  return StatusCode::SUCCESS;
41 }

◆ initialize()

StatusCode FPGATrackSimSpacePointsTool::initialize ( )
overridevirtual

Definition at line 16 of file FPGATrackSimSpacePointsTool.cxx.

17 {
18  ATH_MSG_INFO("Using spacepoints default tool");
19  if (m_duplicate) ATH_MSG_INFO("Duplicating spacepoint to layer on the other side of the stave");
20  if (m_filter) ATH_MSG_INFO("Filtering out incomplete spacepoints");
21  if (m_filterClose) ATH_MSG_INFO("Filtering out single hits close to spacepoints");
22 
23  m_spacepts_per_hit = new TH1I("spacepts_per_hit","",20,0,20);
24 
25  return StatusCode::SUCCESS;
26 }

◆ makeSpacePoints()

StatusCode FPGATrackSimSpacePointsTool::makeSpacePoints ( FPGATrackSimTowerInputHeader &  tower,
std::vector< FPGATrackSimCluster > &  spacepoints 
)
private

Definition at line 95 of file FPGATrackSimSpacePointsTool.cxx.

96 {
97 
98  // delete the old clusters, this will be replaced by the spacepoints
99  tower.clearHits();
100 
101  for (auto entry : m_map)
102  {
103  // std::vector<int> const & module_desc = entry.first;
104  std::vector<FPGATrackSimHit>& hits_inner = entry.second.first;
105  std::vector<FPGATrackSimHit>& hits_outer = entry.second.second;
106 
107  for (auto hit_in : hits_inner) {
108  int startsize = spacepoints.size();
109  bool foundPair = searchForMatch(hit_in,hits_outer,tower,spacepoints);
110 
111  if (!foundPair && !m_sameModulesOnly) {
112  // search in +1 eta direction
113  std::vector<int> nextmod = entry.first;
114  nextmod[3]+=1; // increment eta module counter
115  auto entry2 = m_map.find(nextmod);
116  if (entry2!=m_map.end()) {
117  foundPair = searchForMatch(hit_in,entry2->second.second,tower,spacepoints);
118  if (foundPair) m_adjacent_eta_sp++;
119  }
120  }
121 
122  // Also seek in +1 phi direction.
123  if (!foundPair && !m_sameModulesOnly) {
124  // search in +1 eta direction
125  std::vector<int> nextphimod = entry.first;
126  nextphimod[2]+=1; // increment phi module counter
127  auto entry3 = m_map.find(nextphimod);
128  if (entry3!=m_map.end()) {
129  foundPair = searchForMatch(hit_in,entry3->second.second,tower,spacepoints);
130  if (foundPair) m_adjacent_phi_sp++;
131  }
132  }
133 
134  // If all else fails, seek in +1 eta, +1 phi direction.
135  if (!foundPair && !m_sameModulesOnly) {
136  // search in +1 eta direction
137  std::vector<int> next2mod = entry.first;
138  next2mod[3]+=1; // increment eta module counter
139  next2mod[2]+=1; // increment phi module counter
140  auto entry4 = m_map.find(next2mod);
141  if (entry4!=m_map.end()) {
142  foundPair = searchForMatch(hit_in,entry4->second.second,tower,spacepoints);
143  if (foundPair) m_diagonal_sp++;
144  }
145  }
146 
147  if (!foundPair) {
148  if (m_filter) m_filteredhits++;
149  else {
150  tower.addHit(hit_in); // add unpaired hit_in
151  ATH_MSG_DEBUG("Unpaired hit z = " << hit_in.getZ() << ", r = " << hit_in.getR() << ", phi = " << hit_in.getGPhi() << ", phi module = " << hit_in.getPhiModule() << ", eta module = " << hit_in.getEtaModule());
152  }
153  }
154 
155  m_spacepts_per_hit->Fill(spacepoints.size()-startsize);
156  }
157 
158  // add unpaired outer hits TODO use the hit type instead of another loop
159  for (const FPGATrackSimHit& hit_out : hits_outer) {
160  bool foundPair=false;
161  for (const FPGATrackSimHit& hit_in : hits_inner) {
162  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
163  foundPair=true;
164  break;
165  }
166  }
167 
168  // search in -1 eta direction
169  std::vector<int> nextmod = entry.first;
170  nextmod[3]-=1; // increment eta module counter
171  auto entry2 = m_map.find(nextmod);
172  if (entry2!=m_map.end()) {
173  for (auto hit_in : entry2->second.first) {
174  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
175  foundPair=true;
176  m_adjacent_eta_sp++;
177  break;
178  }
179  }
180  }
181 
182  // Also seek in -1 phi direction.
183  if (!foundPair) {
184  // search in +1 eta direction
185  std::vector<int> nextphimod = entry.first;
186  nextphimod[2]-=1; // increment phi module counter
187  auto entry3 = m_map.find(nextphimod);
188  if (entry3!=m_map.end()) {
189  for (auto hit_in : entry3->second.first) {
190  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
191  foundPair=true;
192  m_adjacent_phi_sp++;
193  break;
194  }
195  }
196  }
197  }
198 
199  // If all else fails, seek in -1 eta, -1 phi direction.
200  if (!foundPair) {
201  // search in +1 eta direction
202  std::vector<int> next2mod = entry.first;
203  next2mod[3]-=1; // increment eta module counter
204  next2mod[2]-=1; // increment phi module counter
205  auto entry4 = m_map.find(next2mod);
206  if (entry4!=m_map.end()) {
207  for (auto hit_in : entry4->second.first) {
208  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
209  foundPair=true;
210  m_diagonal_sp++;
211  break;
212  }
213  }
214  }
215  }
216 
217  if (!foundPair) {
218  if (m_filter) m_filteredhits++;
219  else {
220  tower.addHit(hit_out);
221  ATH_MSG_DEBUG("Unpaired hit z = " << hit_out.getZ() << ", r = " << hit_out.getR() << ", phi = " << hit_out.getGPhi() << ", phi module = " << hit_out.getPhiModule() << ", eta module = " << hit_out.getEtaModule());
222  }
223  }
224  }
225  }
226 
227  // add back the pixles
228  for (const FPGATrackSimHit& hit: m_pixel) tower.addHit(hit);
229 
230  m_inputhits -= m_pixel.size(); // so count is just input strips
231  m_spacepts += spacepoints.size();
232 
233 
234  return StatusCode::SUCCESS;
235 }

◆ reduceGlobalCoordPrecision()

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

Definition at line 373 of file FPGATrackSimSpacePointsTool.cxx.

373  {
374  float pos[3] = { hit.getR(), hit.getGPhi(), hit.getZ() };
375 
376  pos[0] = std::trunc(pos[0] / m_coordRPrecision) * m_coordRPrecision;
377  pos[1] = std::trunc(pos[1] / m_coordPhiPrecision) * m_coordPhiPrecision;
378  pos[2] = std::trunc(pos[2] / m_coordZPrecision) * m_coordZPrecision;
379 
380  hit.setX(pos[0] * std::cos(pos[1]));
381  hit.setY(pos[0] * std::sin(pos[1]));
382  hit.setZ(pos[2]);
383 }

◆ searchForMatch()

bool FPGATrackSimSpacePointsTool::searchForMatch ( FPGATrackSimHit &  hit_in,
std::vector< FPGATrackSimHit > &  hits_outer,
FPGATrackSimTowerInputHeader &  tower,
std::vector< FPGATrackSimCluster > &  spacepoints 
)
private

Definition at line 238 of file FPGATrackSimSpacePointsTool.cxx.

239 {
240  bool foundPair = false;
241  for (const FPGATrackSimHit& hit_out : hits_outer)
242  {
243  // Too far apart to be from same track
244  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
245  addSpacePoints(hit_in,hit_out,tower,spacepoints);
246  foundPair=true;
247  }
248  }
249  return foundPair;
250 }

Member Data Documentation

◆ m_adjacent_eta_sp

unsigned FPGATrackSimSpacePointsTool::m_adjacent_eta_sp = 0
private

Definition at line 57 of file FPGATrackSimSpacePointsTool.h.

◆ m_adjacent_phi_sp

unsigned FPGATrackSimSpacePointsTool::m_adjacent_phi_sp = 0
private

Definition at line 58 of file FPGATrackSimSpacePointsTool.h.

◆ m_boundsCheck

Gaudi::Property<bool> FPGATrackSimSpacePointsTool::m_boundsCheck { this, "BoundsCheck", false, "Perform a module bounds check in the endcaps" }
private

Definition at line 47 of file FPGATrackSimSpacePointsTool.h.

◆ m_coordPhiPrecision

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

Definition at line 50 of file FPGATrackSimSpacePointsTool.h.

◆ m_coordRPrecision

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

Definition at line 49 of file FPGATrackSimSpacePointsTool.h.

◆ m_coordZPrecision

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

Definition at line 51 of file FPGATrackSimSpacePointsTool.h.

◆ m_diagonal_sp

unsigned FPGATrackSimSpacePointsTool::m_diagonal_sp = 0
private

Definition at line 59 of file FPGATrackSimSpacePointsTool.h.

◆ m_duplicate

Gaudi::Property<bool> FPGATrackSimSpacePointsTool::m_duplicate { this, "Duplication", false, "Duplicate spacepoints to layer on the other side of the stave" }
private

Definition at line 43 of file FPGATrackSimSpacePointsTool.h.

◆ m_filter

Gaudi::Property<bool> FPGATrackSimSpacePointsTool::m_filter { this, "Filtering", false, "Filter out incomplete spacepoints" }
private

Definition at line 44 of file FPGATrackSimSpacePointsTool.h.

◆ m_filterClose

Gaudi::Property<bool> FPGATrackSimSpacePointsTool::m_filterClose { this, "FilteringClosePoints", false, "Filter out single hits cloes to spacepoints" }
private

Definition at line 45 of file FPGATrackSimSpacePointsTool.h.

◆ m_filteredhits

unsigned FPGATrackSimSpacePointsTool::m_filteredhits = 0
private

Definition at line 56 of file FPGATrackSimSpacePointsTool.h.

◆ m_inputhits

unsigned FPGATrackSimSpacePointsTool::m_inputhits = 0
private

Definition at line 54 of file FPGATrackSimSpacePointsTool.h.

◆ m_map

std::map<std::vector<int>,std::pair<std::vector<FPGATrackSimHit>,std::vector<FPGATrackSimHit> > > FPGATrackSimSpacePointsTool::m_map
private

Definition at line 39 of file FPGATrackSimSpacePointsTool.h.

◆ m_phiwindow

Gaudi::Property<float> FPGATrackSimSpacePointsTool::m_phiwindow { this, "PhiWindow", 0.008, "Distance in phi to consider two hits for making a space-point" }
private

Definition at line 42 of file FPGATrackSimSpacePointsTool.h.

◆ m_pixel

std::vector<FPGATrackSimHit> FPGATrackSimSpacePointsTool::m_pixel
private

Definition at line 40 of file FPGATrackSimSpacePointsTool.h.

◆ m_reduceCoordPrecision

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

Definition at line 48 of file FPGATrackSimSpacePointsTool.h.

◆ m_sameModulesOnly

Gaudi::Property<bool> FPGATrackSimSpacePointsTool::m_sameModulesOnly { this, "SameModulesOnly", false, "Only use hits on the same physical (eta) module" }
private

Definition at line 46 of file FPGATrackSimSpacePointsTool.h.

◆ m_spacepts

unsigned FPGATrackSimSpacePointsTool::m_spacepts = 0
private

Definition at line 55 of file FPGATrackSimSpacePointsTool.h.

◆ m_spacepts_per_hit

TH1I* FPGATrackSimSpacePointsTool::m_spacepts_per_hit = nullptr
private

Definition at line 60 of file FPGATrackSimSpacePointsTool.h.

The documentation for this class was generated from the following files:
FPGATrackSimSpacePointsTool::fillMaps
StatusCode fillMaps(std::vector< FPGATrackSimHit > &hits)
Definition: FPGATrackSimSpacePointsTool.cxx:60
beamspotman.r
def r
Definition: beamspotman.py:676
FPGATrackSimTowerInputHeader::clearHits
void clearHits()
Definition: FPGATrackSimTowerInputHeader.h:49
FPGATrackSimHit::getPhiModule
unsigned getPhiModule() const
Definition: FPGATrackSimHit.h:88
FPGATrackSimSpacePointsTool::m_spacepts
unsigned m_spacepts
Definition: FPGATrackSimSpacePointsTool.h:55
FPGATrackSimSpacePointsTool::m_coordPhiPrecision
Gaudi::Property< float > m_coordPhiPrecision
Definition: FPGATrackSimSpacePointsTool.h:50
FPGATrackSimSpacePointsTool::makeSpacePoints
StatusCode makeSpacePoints(FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
Definition: FPGATrackSimSpacePointsTool.cxx:95
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSimHit::getEtaModule
int getEtaModule(bool old=false) const
Definition: FPGATrackSimHit.h:87
header
Definition: hcg.cxx:526
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FPGATrackSimCluster
Definition: FPGATrackSimCluster.h:24
FPGATrackSimSpacePointsTool::m_phiwindow
Gaudi::Property< float > m_phiwindow
Definition: FPGATrackSimSpacePointsTool.h:42
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
FPGATrackSimSpacePointsTool::m_map
std::map< std::vector< int >, std::pair< std::vector< FPGATrackSimHit >, std::vector< FPGATrackSimHit > > > m_map
Definition: FPGATrackSimSpacePointsTool.h:39
FPGATrackSimHit::makeSpacepoint
void makeSpacepoint(float x, float y, float z, float window, FPGATrackSimHit &other, FPGATrackSimMultiTruth &new_truth)
Definition: FPGATrackSimHit.cxx:99
FPGATrackSimSpacePointsTool::m_duplicate
Gaudi::Property< bool > m_duplicate
Definition: FPGATrackSimSpacePointsTool.h:43
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
FPGATrackSimHit::setY
void setY(float v)
Definition: FPGATrackSimHit.h:138
FPGATrackSimCluster::setClusterEquiv
void setClusterEquiv(const FPGATrackSimHit &input)
Definition: FPGATrackSimCluster.h:35
x
#define x
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
TRT::Hit::side
@ side
Definition: HitInfo.h:83
FPGATrackSimHit::getTruth
const FPGATrackSimMultiTruth & getTruth() const
Definition: FPGATrackSimHit.h:161
FPGATrackSimSpacePointsTool::searchForMatch
bool searchForMatch(FPGATrackSimHit &hit_in, std::vector< FPGATrackSimHit > &hits_outer, FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
Definition: FPGATrackSimSpacePointsTool.cxx:238
FPGATrackSimHit::setX
void setX(float v)
Definition: FPGATrackSimHit.h:137
FPGATrackSimSpacePointsTool::m_pixel
std::vector< FPGATrackSimHit > m_pixel
Definition: FPGATrackSimSpacePointsTool.h:40
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
FPGATrackSimSpacePointsTool::m_reduceCoordPrecision
Gaudi::Property< bool > m_reduceCoordPrecision
Definition: FPGATrackSimSpacePointsTool.h:48
FPGATrackSimMultiTruth::add
void add(const FPGATrackSimMultiTruth::Barcode &code, const FPGATrackSimMultiTruth::Weight &weight)
Definition: FPGATrackSimMultiTruth.cxx:22
FPGATrackSimSpacePointsTool::m_boundsCheck
Gaudi::Property< bool > m_boundsCheck
Definition: FPGATrackSimSpacePointsTool.h:47
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
FPGATrackSimSpacePointsTool::m_coordZPrecision
Gaudi::Property< float > m_coordZPrecision
Definition: FPGATrackSimSpacePointsTool.h:51
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimSpacePointsTool::reduceGlobalCoordPrecision
void reduceGlobalCoordPrecision(FPGATrackSimHit &hit) const
Definition: FPGATrackSimSpacePointsTool.cxx:373
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
FPGATrackSimSpacePointsTool::m_filteredhits
unsigned m_filteredhits
Definition: FPGATrackSimSpacePointsTool.h:56
FPGATrackSimHit::getZ
float getZ() const
Definition: FPGATrackSimHit.h:142
FPGATrackSimSpacePointsTool::m_spacepts_per_hit
TH1I * m_spacepts_per_hit
Definition: FPGATrackSimSpacePointsTool.h:60
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
FPGATrackSimMultiTruth
Definition: FPGATrackSimMultiTruth.h:46
FPGATrackSimSpacePointsTool::m_inputhits
unsigned m_inputhits
Definition: FPGATrackSimSpacePointsTool.h:54
FPGATrackSimSpacePointsTool::m_filter
Gaudi::Property< bool > m_filter
Definition: FPGATrackSimSpacePointsTool.h:44
FPGATrackSimSpacePointsTool::m_coordRPrecision
Gaudi::Property< float > m_coordRPrecision
Definition: FPGATrackSimSpacePointsTool.h:49
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
FPGATrackSimHit::setZ
void setZ(float v)
Definition: FPGATrackSimHit.h:139
FPGATrackSimHit::getR
float getR() const
Definition: FPGATrackSimHit.h:143
y
#define y
FPGATrackSimHit::getCluster1ID
int getCluster1ID() const
Definition: FPGATrackSimHit.h:181
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
FPGATrackSimSpacePointsTool::calcPosition
void calcPosition(FPGATrackSimHit &hit_in, FPGATrackSimHit &hit_out, float &x, float &y, float &z)
Definition: FPGATrackSimSpacePointsTool.cxx:323
FPGATrackSimTowerInputHeader::hits
const std::vector< FPGATrackSimHit > & hits() const
Definition: FPGATrackSimTowerInputHeader.h:46
FPGATrackSimHit::setCluster2ID
void setCluster2ID(int v)
Definition: FPGATrackSimHit.h:185
FPGATrackSimSpacePointsTool::m_adjacent_phi_sp
unsigned m_adjacent_phi_sp
Definition: FPGATrackSimSpacePointsTool.h:58
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
FPGATrackSimSpacePointsTool::addSpacePoints
void addSpacePoints(FPGATrackSimHit hit_in, FPGATrackSimHit hit_out, FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
Definition: FPGATrackSimSpacePointsTool.cxx:252
FPGATrackSimTowerInputHeader
Definition: FPGATrackSimTowerInputHeader.h:18
FPGATrackSimHit::isBarrel
bool isBarrel() const
Definition: FPGATrackSimHit.h:66
FPGATrackSimSpacePointsTool::m_diagonal_sp
unsigned m_diagonal_sp
Definition: FPGATrackSimSpacePointsTool.h:59
FPGATrackSimSpacePointsTool::m_sameModulesOnly
Gaudi::Property< bool > m_sameModulesOnly
Definition: FPGATrackSimSpacePointsTool.h:46
FPGATrackSimSpacePointsTool::m_filterClose
Gaudi::Property< bool > m_filterClose
Definition: FPGATrackSimSpacePointsTool.h:45
FPGATrackSimCluster::push_backHitList
void push_backHitList(const FPGATrackSimHit &input)
Definition: FPGATrackSimCluster.h:38
FPGATrackSimSpacePointsTool::m_adjacent_eta_sp
unsigned m_adjacent_eta_sp
Definition: FPGATrackSimSpacePointsTool.h:57
Generated on Wed Apr 23 2025 21:33:35 for ATLAS Offline Software by   doxygen 1.8.18