ATLAS Offline Software
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

 FPGATrackSimSpacePointsTool (const std::string &, const std::string &, const IInterface *)
 
virtual ~FPGATrackSimSpacePointsTool ()
 
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.

Constructor & Destructor Documentation

◆ FPGATrackSimSpacePointsTool()

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

Definition at line 14 of file FPGATrackSimSpacePointsTool.cxx.

15  : base_class(algname, name, ifc)
16 {
17  declareInterface<FPGATrackSimSpacePointsToolI>(this);
18 }

◆ ~FPGATrackSimSpacePointsTool()

virtual FPGATrackSimSpacePointsTool::~FPGATrackSimSpacePointsTool ( )
inlinevirtual

Definition at line 22 of file FPGATrackSimSpacePointsTool.h.

22 {}

Member Function Documentation

◆ addSpacePoints()

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

Definition at line 257 of file FPGATrackSimSpacePointsTool.cxx.

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

◆ calcPosition()

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

Definition at line 333 of file FPGATrackSimSpacePointsTool.cxx.

334 {
335  float phi_sp = (hit_in.getGPhi() + hit_out.getGPhi()) / 2.0;
336  float r_sp = (hit_in.getR() + hit_out.getR()) / 2.0;;
337  float z_sp = (hit_in.getZ() + hit_out.getZ()) / 2.0;;
338 
339  float delta_phi_local = (hit_in.getGPhi() - hit_out.getGPhi()) * r_sp; // distance in phi dir in mm
340 
341  if (hit_in.isBarrel())
342  {
343  static const float stereo_angle = 0.026; // barrel
344  z_sp += delta_phi_local/tan(stereo_angle)/2.0;
345  }
346  else
347  {
348  static const float stereo_angle = 0.020; // endcap
349  r_sp += delta_phi_local/tan(stereo_angle)/2.0;
350 
351  // don't let r_sp out of range of edge of module TODO fix hardcode
352  // Allow for the bounds check to be disabled, since it may mess up a linear fit.
353  if (m_boundsCheck) {
354  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};
355 
356  if (hit_in.getEtaModule()==hit_in.getEtaModule()) {
357  float r_limited = std::max(r_sp,r_bounds[hit_in.getEtaModule()]);
358  r_limited = std::min(r_sp,r_bounds[hit_in.getEtaModule()+1]);
359  if (r_sp!=r_limited) {
360  ATH_MSG_WARNING("Spacepoint location not in module boundary: r_sp=" << r_sp
361  << " not in [" << r_bounds[hit_in.getEtaModule()] << "," << r_bounds[hit_in.getEtaModule()+1] << "]");
362  r_sp=r_limited;
363  }
364  } else if (hit_in.getEtaModule()==hit_in.getEtaModule()+1) {
365  float window = 3; //mm, max possible distance between hits from same track with reasonable incline to module
366  float r_limited = std::max(r_sp,r_bounds[hit_in.getEtaModule()+1]-window);
367  r_limited = std::min(r_sp,r_bounds[hit_in.getEtaModule()+1]+window);
368  if (r_sp!=r_limited) {
369  ATH_MSG_WARNING("Crossing spacepoint location too far from module boundary: r_sp=" << r_sp
370  << " not in [" << r_bounds[hit_in.getEtaModule()+1]-window << "," << r_bounds[hit_in.getEtaModule()+1]+window << "]");
371  r_sp=r_limited;
372  }
373  }
374  }
375  }
376 
377  // insert new values
378  x = r_sp*cos(phi_sp);
379  y = r_sp*sin(phi_sp);
380  z = z_sp;
381 }

◆ DoSpacePoints()

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

Definition at line 48 of file FPGATrackSimSpacePointsTool.cxx.

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

◆ fillMaps()

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

Definition at line 65 of file FPGATrackSimSpacePointsTool.cxx.

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

◆ finalize()

StatusCode FPGATrackSimSpacePointsTool::finalize ( )
overridevirtual

Definition at line 33 of file FPGATrackSimSpacePointsTool.cxx.

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

◆ initialize()

StatusCode FPGATrackSimSpacePointsTool::initialize ( )
overridevirtual

Definition at line 21 of file FPGATrackSimSpacePointsTool.cxx.

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

◆ makeSpacePoints()

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

Definition at line 100 of file FPGATrackSimSpacePointsTool.cxx.

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

◆ reduceGlobalCoordPrecision()

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

Definition at line 383 of file FPGATrackSimSpacePointsTool.cxx.

383  {
384  float pos[3] = { hit.getR(), hit.getGPhi(), hit.getZ() };
385 
386  pos[0] = std::trunc(pos[0] / m_coordRPrecision) * m_coordRPrecision;
387  pos[1] = std::trunc(pos[1] / m_coordPhiPrecision) * m_coordPhiPrecision;
388  pos[2] = std::trunc(pos[2] / m_coordZPrecision) * m_coordZPrecision;
389 
390  hit.setX(pos[0] * std::cos(pos[1]));
391  hit.setY(pos[0] * std::sin(pos[1]));
392  hit.setZ(pos[2]);
393 }

◆ searchForMatch()

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

Definition at line 243 of file FPGATrackSimSpacePointsTool.cxx.

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

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:65
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
getMenu.algname
algname
Definition: getMenu.py:54
FPGATrackSimSpacePointsTool::makeSpacePoints
StatusCode makeSpacePoints(FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
Definition: FPGATrackSimSpacePointsTool.cxx:100
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
header
Definition: hcg.cxx:526
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FPGATrackSimCluster
Definition: FPGATrackSimCluster.h:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py: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:89
FPGATrackSimHit::getEtaModule
int getEtaModule() const
Definition: FPGATrackSimHit.h:87
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:135
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:141
TRT::Hit::side
@ side
Definition: HitInfo.h:83
FPGATrackSimHit::getTruth
const FPGATrackSimMultiTruth & getTruth() const
Definition: FPGATrackSimHit.h:158
FPGATrackSimSpacePointsTool::searchForMatch
bool searchForMatch(FPGATrackSimHit &hit_in, std::vector< FPGATrackSimHit > &hits_outer, FPGATrackSimTowerInputHeader &tower, std::vector< FPGATrackSimCluster > &spacepoints)
Definition: FPGATrackSimSpacePointsTool.cxx:243
FPGATrackSimHit::setX
void setX(float v)
Definition: FPGATrackSimHit.h:134
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
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:383
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:139
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
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
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:136
FPGATrackSimHit::getR
float getR() const
Definition: FPGATrackSimHit.h:140
y
#define y
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:333
FPGATrackSimTowerInputHeader::hits
const std::vector< FPGATrackSimHit > & hits() const
Definition: FPGATrackSimTowerInputHeader.h:46
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:257
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 Sun Dec 22 2024 21:33:32 for ATLAS Offline Software by   doxygen 1.8.18