ATLAS Offline Software
FPGATrackSimSpacePointsTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3  */
4 
5 
6 
11 #include "TH1.h"
12 #include <array>
13 #include <vector>
14 
15 
16 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
18 {
19  ATH_MSG_INFO("Using spacepoints default tool");
20  if (m_duplicate) ATH_MSG_INFO("Duplicating spacepoint to layer on the other side of the stave");
21  if (m_filter) ATH_MSG_INFO("Filtering out incomplete spacepoints");
22  if (m_filterClose) ATH_MSG_INFO("Filtering out single hits close to spacepoints");
23 
24  m_spacepts_per_hit = new TH1I("spacepts_per_hit","",20,0,20);
25 
26  return StatusCode::SUCCESS;
27 }
28 
30 {
31  ATH_MSG_INFO("Spacepoints report");
32  ATH_MSG_INFO("-----------------------------------------");
33  ATH_MSG_INFO("Strip Hits Input " << m_inputhits);
34  ATH_MSG_INFO("Spacepoints Ouput " << m_spacepts);
35  ATH_MSG_INFO("Filtered Hits " << m_filteredhits);
36  ATH_MSG_INFO("Adjacent Eta Module SPs " << m_adjacent_eta_sp);
37  ATH_MSG_INFO("Adjacent Phi Module SPs " << m_adjacent_phi_sp);
38  ATH_MSG_INFO("Diagonal Module SPs " << m_diagonal_sp);
39  ATH_MSG_INFO("Spacepoints per hit " << m_spacepts_per_hit->GetMean());
40  ATH_MSG_INFO("-----------------------------------------");
41  return StatusCode::SUCCESS;
42 }
43 
45 {
46  for (int i = 0; i < header.nTowers(); ++i)
47  {
48  FPGATrackSimTowerInputHeader &tower = *header.getTower(i);
49  std::vector<FPGATrackSimHit> hits = tower.hits();
50  if (hits.empty()) continue;
51 
52  m_inputhits += hits.size();
54  ATH_CHECK(makeSpacePoints(tower,spacepoints));
55  }
56 
57  return StatusCode::SUCCESS;
58 }
59 
60 
62 {
63  m_map.clear();
64  m_pixel.clear();
65 
66  int strip_hits = 0;
67  for (const auto & hit : hits) {
68 
69  if (hit.isPixel()) {
70  // just save them so we can put them back
71  m_pixel.push_back(hit);
72  ATH_MSG_DEBUG("Pixel hit z = " << hit.getZ() << ", r = " << hit.getR() << ", phi = " << hit.getGPhi());
73  continue;
74  }
75  strip_hits += 1;
76 
77  std::vector<int> module_desc(4);
78 
79  module_desc[0] = (int)hit.getDetectorZone();
80  module_desc[1] = hit.getPhysLayer()/2; //div 2 gives layer as part of pair
81  unsigned side = hit.getPhysLayer()%2; // even/odd layer
82  module_desc[2] = hit.getPhiModule();
83  module_desc[3] = hit.getEtaModule();
84 
85  if (side==0)
86  m_map[module_desc].first.push_back(hit);
87  else
88  m_map[module_desc].second.push_back(hit);
89  }
90 
91  ATH_MSG_DEBUG("Running spacepoints default tool over " << strip_hits << " strip hits.");
92 
93  return StatusCode::SUCCESS;
94 }
95 
96 StatusCode FPGATrackSimSpacePointsTool::makeSpacePoints(FPGATrackSimTowerInputHeader &tower, std::vector<FPGATrackSimCluster> &spacepoints)
97 {
98 
99  // delete the old clusters, this will be replaced by the spacepoints
100  tower.clearHits();
101 
102  for (auto entry : m_map)
103  {
104  // std::vector<int> const & module_desc = entry.first;
105  std::vector<FPGATrackSimHit>& hits_inner = entry.second.first;
106  std::vector<FPGATrackSimHit>& hits_outer = entry.second.second;
107 
108  for (auto hit_in : hits_inner) {
109  int startsize = spacepoints.size();
110  bool foundPair = searchForMatch(hit_in,hits_outer,tower,spacepoints);
111 
112  if (!foundPair && !m_sameModulesOnly) {
113  // search in +1 eta direction
114  std::vector<int> nextmod = entry.first;
115  nextmod[3]+=1; // increment eta module counter
116  auto entry2 = m_map.find(nextmod);
117  if (entry2!=m_map.end()) {
118  foundPair = searchForMatch(hit_in,entry2->second.second,tower,spacepoints);
119  if (foundPair) m_adjacent_eta_sp++;
120  }
121  }
122 
123  // Also seek in +1 phi direction.
124  if (!foundPair && !m_sameModulesOnly) {
125  // search in +1 eta direction
126  std::vector<int> nextphimod = entry.first;
127  nextphimod[2]+=1; // increment phi module counter
128  auto entry3 = m_map.find(nextphimod);
129  if (entry3!=m_map.end()) {
130  foundPair = searchForMatch(hit_in,entry3->second.second,tower,spacepoints);
131  if (foundPair) m_adjacent_phi_sp++;
132  }
133  }
134 
135  // If all else fails, seek in +1 eta, +1 phi direction.
136  if (!foundPair && !m_sameModulesOnly) {
137  // search in +1 eta direction
138  std::vector<int> next2mod = entry.first;
139  next2mod[3]+=1; // increment eta module counter
140  next2mod[2]+=1; // increment phi module counter
141  auto entry4 = m_map.find(next2mod);
142  if (entry4!=m_map.end()) {
143  foundPair = searchForMatch(hit_in,entry4->second.second,tower,spacepoints);
144  if (foundPair) m_diagonal_sp++;
145  }
146  }
147 
148  if (!foundPair) {
149  if (m_filter) m_filteredhits++;
150  else {
151  tower.addHit(hit_in); // add unpaired hit_in
152  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());
153  }
154  }
155 
156  m_spacepts_per_hit->Fill(spacepoints.size()-startsize);
157  }
158 
159  // add unpaired outer hits TODO use the hit type instead of another loop
160  for (const FPGATrackSimHit& hit_out : hits_outer) {
161  bool foundPair=false;
162  for (const FPGATrackSimHit& hit_in : hits_inner) {
163  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
164  foundPair=true;
165  break;
166  }
167  }
168 
169  // search in -1 eta direction
170  std::vector<int> nextmod = entry.first;
171  nextmod[3]-=1; // increment eta module counter
172  auto entry2 = m_map.find(nextmod);
173  if (entry2!=m_map.end()) {
174  for (auto hit_in : entry2->second.first) {
175  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
176  foundPair=true;
178  break;
179  }
180  }
181  }
182 
183  // Also seek in -1 phi direction.
184  if (!foundPair) {
185  // search in +1 eta direction
186  std::vector<int> nextphimod = entry.first;
187  nextphimod[2]-=1; // increment phi module counter
188  auto entry3 = m_map.find(nextphimod);
189  if (entry3!=m_map.end()) {
190  for (const auto & hit_in : entry3->second.first) {
191  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
192  foundPair=true;
194  break;
195  }
196  }
197  }
198  }
199 
200  // If all else fails, seek in -1 eta, -1 phi direction.
201  if (!foundPair) {
202  // search in +1 eta direction
203  std::vector<int> next2mod = entry.first;
204  next2mod[3]-=1; // increment eta module counter
205  next2mod[2]-=1; // increment phi module counter
206  auto entry4 = m_map.find(next2mod);
207  if (entry4!=m_map.end()) {
208  for (auto hit_in : entry4->second.first) {
209  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
210  foundPair=true;
211  m_diagonal_sp++;
212  break;
213  }
214  }
215  }
216  }
217 
218  if (!foundPair) {
219  if (m_filter) m_filteredhits++;
220  else {
221  tower.addHit(hit_out);
222  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());
223  }
224  }
225  }
226  }
227 
228  // add back the pixles
229  for (const FPGATrackSimHit& hit: m_pixel) tower.addHit(hit);
230 
231  m_inputhits -= m_pixel.size(); // so count is just input strips
232  m_spacepts += spacepoints.size();
233 
234 
235  return StatusCode::SUCCESS;
236 }
237 
238 
239 bool FPGATrackSimSpacePointsTool::searchForMatch(FPGATrackSimHit& hit_in,std::vector<FPGATrackSimHit>& hits_outer,FPGATrackSimTowerInputHeader &tower, std::vector<FPGATrackSimCluster> &spacepoints)
240 {
241  bool foundPair = false;
242  for (const FPGATrackSimHit& hit_out : hits_outer)
243  {
244  // Too far apart to be from same track
245  if (abs(hit_in.getGPhi()-hit_out.getGPhi()) < m_phiwindow) {
246  addSpacePoints(hit_in,hit_out,tower,spacepoints);
247  foundPair=true;
248  }
249  }
250  return foundPair;
251 }
252 
253 void FPGATrackSimSpacePointsTool::addSpacePoints(FPGATrackSimHit hit_in, FPGATrackSimHit hit_out ,FPGATrackSimTowerInputHeader &tower, std::vector<FPGATrackSimCluster> &spacepoints)
254 {
255  // Make a spacepoint
256  //------------------
257  float x{},y{},z{};
258  calcPosition(hit_in, hit_out, x, y, z);
259 
260  float phi_window = abs(hit_in.getGPhi()-hit_out.getGPhi());
261 
262  // Let's print out the coords of the spacepoints we identify.
263  float r = TMath::Sqrt(x*x + y*y);
264  ATH_MSG_DEBUG("Spacepoint x = " << x << ", y = " << y << ", z = " << z << ", r = " << r);
265  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());
266  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());
267 
268  // We need to merge the truth information for the hits together in order
269  // to use them in matrix generation.
270 
271  const FPGATrackSimMultiTruth truth_in = hit_in.getTruth();
272  const FPGATrackSimMultiTruth truth_out = hit_out.getTruth();
273 
274  FPGATrackSimMultiTruth new_truth;
275  new_truth.add(truth_in);
276  new_truth.add(truth_out);
277  //hit_in.setTruth(new_truth);
278 
279  //hit_in.setX(x);
280  //hit_in.setY(y);
281  //hit_in.setZ(z);
282 
283  // TODO this is probably no longer necessary, we should just overwrite the local coordinates
284  // of both hit, I think?
285  //hit_in.setPairedHit(hit_in);
286 
287  // This function now does everything (I think) including storing the correct
288  // local coordinates for later retrieval.
289  // Maybe it should return a new FPGATrackSimHit rather than modifying in place.
290  hit_in.makeSpacepoint(x, y, z, phi_window, hit_out, new_truth);
291  hit_in.setCluster2ID(hit_out.getCluster1ID());
292 
295 
296  // abusing hit type 'guessed' to be able to indentify it as spacepoint later on
297  // Guessed is ambiguous with an actual guessed hit-- there is a spacepoint type which
298  // should be used instead.
299  // hit_in.setHitType(HitType::guessed);
300  // hit_in.setHitType(HitType::spacepoint);
301  tower.addHit(hit_in);
302 
303  if (m_duplicate) {
304  hit_out.makeSpacepoint(x, y, z, phi_window, hit_in, new_truth);
305  hit_out.setCluster2ID(hit_in.getCluster1ID());
306 
309 
310  tower.addHit(hit_out);
311  }
312 
313  // push back a copy for monitoring
315  sp.setClusterEquiv(hit_in);
316  sp.push_backHitList(hit_in);
317  sp.push_backHitList(hit_out);
318  spacepoints.push_back(sp);
319 
320 }
321 
322 
323 
324 void FPGATrackSimSpacePointsTool::calcPosition(FPGATrackSimHit &hit_in, FPGATrackSimHit &hit_out, float &x, float &y, float &z)
325 {
326  float phi_sp = (hit_in.getGPhi() + hit_out.getGPhi()) / 2.0;
327  float r_sp = (hit_in.getR() + hit_out.getR()) / 2.0;;
328  float z_sp = (hit_in.getZ() + hit_out.getZ()) / 2.0;;
329 
330  float delta_phi_local = (hit_in.getGPhi() - hit_out.getGPhi()) * r_sp; // distance in phi dir in mm
331 
332  if (hit_in.isBarrel())
333  {
334  static const float stereo_angle = 0.026; // barrel
335  z_sp += delta_phi_local/tan(stereo_angle)/2.0;
336  }
337  else
338  {
339  static const float stereo_angle = 0.020; // endcap
340  r_sp += delta_phi_local/tan(stereo_angle)/2.0;
341 
342  // don't let r_sp out of range of edge of module TODO fix hardcode
343  // Allow for the bounds check to be disabled, since it may mess up a linear fit.
344  if (m_boundsCheck) {
345  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};
346 
347  if (hit_in.getEtaModule()==hit_in.getEtaModule()) {
348  float r_limited = std::max(r_sp,r_bounds[hit_in.getEtaModule()]);
349  r_limited = std::min(r_sp,r_bounds[hit_in.getEtaModule()+1]);
350  if (r_sp!=r_limited) {
351  ATH_MSG_WARNING("Spacepoint location not in module boundary: r_sp=" << r_sp
352  << " not in [" << r_bounds[hit_in.getEtaModule()] << "," << r_bounds[hit_in.getEtaModule()+1] << "]");
353  r_sp=r_limited;
354  }
355  } else if (hit_in.getEtaModule()==hit_in.getEtaModule()+1) {
356  float window = 3; //mm, max possible distance between hits from same track with reasonable incline to module
357  float r_limited = std::max(r_sp,r_bounds[hit_in.getEtaModule()+1]-window);
358  r_limited = std::min(r_sp,r_bounds[hit_in.getEtaModule()+1]+window);
359  if (r_sp!=r_limited) {
360  ATH_MSG_WARNING("Crossing spacepoint location too far from module boundary: r_sp=" << r_sp
361  << " not in [" << r_bounds[hit_in.getEtaModule()+1]-window << "," << r_bounds[hit_in.getEtaModule()+1]+window << "]");
362  r_sp=r_limited;
363  }
364  }
365  }
366  }
367 
368  // insert new values
369  x = r_sp*cos(phi_sp);
370  y = r_sp*sin(phi_sp);
371  z = z_sp;
372 }
373 
375  float pos[3] = { hit.getR(), hit.getGPhi(), hit.getZ() };
376 
377  pos[0] = std::trunc(pos[0] / m_coordRPrecision) * m_coordRPrecision;
378  pos[1] = std::trunc(pos[1] / m_coordPhiPrecision) * m_coordPhiPrecision;
379  pos[2] = std::trunc(pos[2] / m_coordZPrecision) * m_coordZPrecision;
380 
381  hit.setX(pos[0] * std::cos(pos[1]));
382  hit.setY(pos[0] * std::sin(pos[1]));
383  hit.setZ(pos[2]);
384 }
FPGATrackSimSpacePointsTool::fillMaps
StatusCode fillMaps(std::vector< FPGATrackSimHit > &hits)
Definition: FPGATrackSimSpacePointsTool.cxx:61
beamspotman.r
def r
Definition: beamspotman.py:672
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.h
FPGATrackSimLogicalEventInputHeader
Definition: FPGATrackSimLogicalEventInputHeader.h:21
FPGATrackSimSpacePointsTool::makeSpacePoints
StatusCode makeSpacePoints(FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
Definition: FPGATrackSimSpacePointsTool.cxx:96
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:98
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:147
FPGATrackSimSpacePointsTool::DoSpacePoints
virtual StatusCode DoSpacePoints(FPGATrackSimLogicalEventInputHeader &, std::vector< FPGATrackSimCluster > &) override
Definition: FPGATrackSimSpacePointsTool.cxx:44
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:153
TRT::Hit::side
@ side
Definition: HitInfo.h:83
FPGATrackSimHit::getTruth
const FPGATrackSimMultiTruth & getTruth() const
Definition: FPGATrackSimHit.h:170
FPGATrackSimSpacePointsTool::searchForMatch
bool searchForMatch(FPGATrackSimHit &hit_in, std::vector< FPGATrackSimHit > &hits_outer, FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
Definition: FPGATrackSimSpacePointsTool.cxx:239
FPGATrackSimHit::setX
void setX(float v)
Definition: FPGATrackSimHit.h:146
FPGATrackSimSpacePointsTool::m_pixel
std::vector< FPGATrackSimHit > m_pixel
Definition: FPGATrackSimSpacePointsTool.h:40
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
FPGATrackSimSpacePointsTool::finalize
virtual StatusCode finalize() override
Definition: FPGATrackSimSpacePointsTool.cxx:29
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
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
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:374
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:151
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
FPGATrackSimHit.h
: FPGATrackSim-specific class to represent an hit in the detector.
FPGATrackSimSpacePointsTool::m_coordRPrecision
Gaudi::Property< float > m_coordRPrecision
Definition: FPGATrackSimSpacePointsTool.h:49
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
FPGATrackSimHit::setZ
void setZ(float v)
Definition: FPGATrackSimHit.h:148
FPGATrackSimHit::getR
float getR() const
Definition: FPGATrackSimHit.h:152
y
#define y
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
FPGATrackSimHit::getCluster1ID
int getCluster1ID() const
Definition: FPGATrackSimHit.h:190
FPGATrackSimSpacePointsTool::initialize
virtual StatusCode initialize() override
Definition: FPGATrackSimSpacePointsTool.cxx:17
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:324
FPGATrackSimTowerInputHeader::hits
const std::vector< FPGATrackSimHit > & hits() const
Definition: FPGATrackSimTowerInputHeader.h:46
FPGATrackSimHit::setCluster2ID
void setCluster2ID(int v)
Definition: FPGATrackSimHit.h:194
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:253
FPGATrackSimTowerInputHeader
Definition: FPGATrackSimTowerInputHeader.h:18
FPGATrackSimLogicalEventInputHeader.h
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
FPGATrackSimCluster.h
FPGATrackSimSpacePointsTool::m_adjacent_eta_sp
unsigned m_adjacent_eta_sp
Definition: FPGATrackSimSpacePointsTool.h:57