NNbarUtilities.cxx
Go to the documentation of this file.
1 #include "NNbarUtilities.h"
2 
3 //---------------------------------------------------------------------
5  rb::Cluster slice, double &multipleCellFractionXview,
6  double &multipleCellFractionYview) {
7  std::vector<uint16_t> xviewCellNumbers;
8  std::vector<uint16_t> yviewCellNumbers;
9  for (unsigned int j = 0; j < slice.AllCells().size(); j++) {
10  auto hit = slice.AllCells().at(j);
11  if (hit->View() == geo::kX) {
12  xviewCellNumbers.push_back(hit->Cell());
13  } else if (hit->View() == geo::kY) {
14  yviewCellNumbers.push_back(hit->Cell());
15  }
16  }
17 
18  multipleCellFractionXview = getMultipleOccurrenceFraction(xviewCellNumbers);
19  multipleCellFractionYview = getMultipleOccurrenceFraction(yviewCellNumbers);
20 }
21 
22 //---------------------------------------------------------------------
24  std::vector<uint16_t> cellNumbers) {
25  std::map<uint16_t, int> occurrences;
26  for (unsigned int i = 0; i < cellNumbers.size(); ++i)
27  ++occurrences[cellNumbers[i]];
28 
29  int multipleCellCount = 0;
30  using iterator = std::map<uint16_t, int>::iterator;
31  for (iterator iter = occurrences.begin(); iter != occurrences.end(); ++iter) {
32  if (iter->second > 1) {
33  multipleCellCount++;
34  }
35  }
36 
37  return (double)multipleCellCount / occurrences.size();
38 }
39 
40 //---------------------------------------------------------------------
42  double hitCountXView = 0.;
43  double hitCountYView = 0.;
44 
45  for (unsigned int j = 0; j < slice.AllCells().size(); j++) {
46  auto const hit = slice.AllCells().at(j);
47  if (hit->View() == geo::kX) {
48  hitCountXView++;
49  } else if (hit->View() == geo::kY) {
50  hitCountYView++;
51  }
52  }
53 
54  return fabs(hitCountYView - hitCountXView) / (hitCountXView + hitCountYView);
55 }
56 
57 //---------------------------------------------------------------------
59  rb::Cluster slice, double &cellExtentAsymmetry,
60  double &planeExtentAsymmetry) {
61  int minHitCellXview;
62  int maxHitCellXview;
63  int minHitCellYview;
64  int maxHitCellYview;
65  int minHitPlaneXview;
66  int maxHitPlaneXview;
67  int minHitPlaneYview;
68  int maxHitPlaneYview;
69  getSliceBoundary(slice, minHitCellXview, maxHitCellXview, minHitCellYview,
70  maxHitCellYview, minHitPlaneXview, maxHitPlaneXview,
71  minHitPlaneYview, maxHitPlaneYview);
72 
73  int planeExtentXview = 0;
74  int cellExtentXview = 0;
75  if (maxHitPlaneXview != -1) {
76  planeExtentXview = maxHitPlaneXview - minHitPlaneXview + 1;
77  cellExtentXview = maxHitCellXview - minHitCellXview + 1;
78  }
79 
80  int planeExtentYview = 0;
81  int cellExtentYview = 0;
82  if (maxHitPlaneYview != -1) {
83  planeExtentYview = maxHitPlaneYview - minHitPlaneYview + 1;
84  cellExtentYview = maxHitCellYview - minHitCellYview + 1;
85  }
86 
87  cellExtentAsymmetry = fabs(cellExtentXview - cellExtentYview) /
88  (cellExtentXview + cellExtentYview);
89  planeExtentAsymmetry = fabs(planeExtentXview - planeExtentYview) /
90  (planeExtentXview + planeExtentYview);
91 }
92 
93 //---------------------------------------------------------------------
95  double &minHitCellT,
96  double &maxHitCellT,
97  double &avgHitCellT) {
98  minHitCellT = 1E100;
99  maxHitCellT = -1E100;
100  avgHitCellT = 0.;
101  for (unsigned int i = 0; i < slice.AllCells().size(); i++) {
102  auto const hit = slice.AllCells().at(i);
103  auto hitTime = hit->TNS();
104 
105  if (hitTime > maxHitCellT) maxHitCellT = hitTime;
106  if (hitTime < minHitCellT) minHitCellT = hitTime;
107 
108  avgHitCellT += hitTime;
109  }
110  avgHitCellT = avgHitCellT / slice.AllCells().size();
111 }
112 
114  rb::Cluster slice, int &minHitCellXview, int &maxHitCellXview,
115  int &minHitCellYview, int &maxHitCellYview, int &minHitPlaneXview,
116  int &maxHitPlaneXview, int &minHitPlaneYview, int &maxHitPlaneYview) {
117  minHitCellXview = FD_CELL_COUNT_PER_PLANE;
118  maxHitCellXview = 0;
119  minHitCellYview = FD_CELL_COUNT_PER_PLANE;
120  maxHitCellYview = 0;
121 
122  minHitPlaneXview = FD_PLANE_COUNT;
123  maxHitPlaneXview = 0;
124  minHitPlaneYview = FD_PLANE_COUNT;
125  maxHitPlaneYview = 0;
126 
127  int xviewHitCount = 0;
128  for (unsigned int i = 0; i < slice.AllCells().size(); i++) {
129  auto const hit = slice.AllCells().at(i);
130  auto hitPlane = hit->Plane();
131  auto hitCell = hit->Cell();
132 
133  if (hit->View() == geo::kX) {
134  xviewHitCount++;
135 
136  if (hitPlane > maxHitPlaneXview) {
137  maxHitPlaneXview = hitPlane;
138  }
139  if (hitPlane < minHitPlaneXview) {
140  minHitPlaneXview = hitPlane;
141  }
142  if (hitCell > maxHitCellXview) {
143  maxHitCellXview = hitCell;
144  }
145  if (hitCell < minHitCellXview) {
146  minHitCellXview = hitCell;
147  }
148  } else if (hit->View() == geo::kY) {
149  if (hitPlane > maxHitPlaneYview) {
150  maxHitPlaneYview = hitPlane;
151  }
152  if (hitPlane < minHitPlaneYview) {
153  minHitPlaneYview = hitPlane;
154  }
155  if (hitCell > maxHitCellYview) {
156  maxHitCellYview = hitCell;
157  }
158  if (hitCell < minHitCellYview) {
159  minHitCellYview = hitCell;
160  }
161  }
162  }
163 
164  if (xviewHitCount == 0) {
165  minHitCellXview = -1;
166  maxHitCellXview = -1;
167  minHitPlaneXview = -1;
168  maxHitPlaneXview = -1;
169  }
170  if (slice.AllCells().size() - xviewHitCount == 0) {
171  minHitCellYview = -1;
172  maxHitCellYview = -1;
173  minHitPlaneYview = -1;
174  maxHitPlaneYview = -1;
175  }
176 }
177 
178 //---------------------------------------------------------------------
180  int boxXviewMax, int boxYviewMin,
181  int boxYviewMax, int boxZviewMin,
182  int boxZviewMax) {
183  int minHitCellXview;
184  int maxHitCellXview;
185  int minHitCellYview;
186  int maxHitCellYview;
187  int minHitPlaneXview;
188  int maxHitPlaneXview;
189  int minHitPlaneYview;
190  int maxHitPlaneYview;
191 
192  getSliceBoundary(slice, minHitCellXview, maxHitCellXview, minHitCellYview,
193  maxHitCellYview, minHitPlaneXview, maxHitPlaneXview,
194  minHitPlaneYview, maxHitPlaneYview);
195 
196  if (minHitCellXview < 0) {
197  minHitCellXview = boxXviewMin;
198  maxHitCellXview = boxXviewMax;
199  minHitPlaneXview = boxZviewMin;
200  maxHitPlaneXview = boxZviewMax;
201  }
202 
203  if (minHitCellYview < 0) {
204  minHitCellYview = boxYviewMin;
205  maxHitCellYview = boxYviewMax;
206  minHitPlaneYview = boxZviewMin;
207  maxHitPlaneYview = boxZviewMax;
208  }
209 
210  int minHitPlane = std::min(minHitPlaneXview, minHitPlaneYview);
211  int maxHitPlane = std::max(maxHitPlaneXview, maxHitPlaneYview);
212 
213  if (minHitCellXview < boxXviewMin || maxHitCellXview > boxXviewMax ||
214  minHitCellYview < boxYviewMin || maxHitCellYview > boxYviewMax ||
215  minHitPlane < boxZviewMin || maxHitPlane > boxZviewMax) {
216  return false;
217  }
218 
219  return true;
220 }
221 
222 //---------------------------------------------------------------------
224  int &febEdgeCellCount,
225  int &maxHitWidth,
226  double &maxCellCountFraction) {
227  std::map<uint16_t, std::vector<uint16_t>> planeCellsMap;
228 
229  for (unsigned int i = 0; i < slice.AllCells().size(); i++) {
230  auto const hit = slice.AllCells().at(i);
231  uint16_t plane = hit->Plane();
232  uint16_t cell = hit->Cell();
233 
234  if (planeCellsMap.count(plane)) {
235  planeCellsMap.at(plane).push_back(cell);
236  } else {
237  std::vector<uint16_t> newPlaneCell(1, cell);
238  planeCellsMap.insert(
239  std::pair<uint16_t, std::vector<uint16_t>>(plane, newPlaneCell));
240  }
241  }
242 
243  febEdgeCellCount = 0;
244  maxHitWidth = 0;
245  int evenCellCount = 0;
246  int evenMaxCellCount = 0;
247  int oddCellCount = 0;
248  int oddMaxCellCount = 0;
249  for (auto &planeCells : planeCellsMap) {
250  std::vector<uint16_t> cells = planeCells.second;
251  auto minMax = std::minmax_element(cells.begin(), cells.end());
252  uint16_t minCell = *minMax.first;
253  uint16_t maxCell = *minMax.second;
254 
255  if (minCell % CELL_COUNT_PER_FEB == 0) {
256  febEdgeCellCount++;
257  }
258  if (maxCell % CELL_COUNT_PER_FEB == 31) {
259  febEdgeCellCount++;
260  }
261 
262  int hitWidth = maxCell - minCell + 1;
263  if (hitWidth > maxHitWidth) {
264  maxHitWidth = hitWidth;
265  }
266 
267  int cellCount = cells.size();
268  if (planeCells.first % 2 == 0) {
269  evenCellCount += cellCount;
270  if (cellCount > evenMaxCellCount) {
271  evenMaxCellCount = cellCount;
272  }
273  } else {
274  oddCellCount += cellCount;
275  if (cellCount > oddMaxCellCount) {
276  oddMaxCellCount = cellCount;
277  }
278  }
279  }
280 
281  maxCellCountFraction = std::max((double)evenMaxCellCount / evenCellCount,
282  (double)oddMaxCellCount / oddCellCount);
283 
284  if (febEdgeCellCount > 7) {
285  return true;
286  } else if (febEdgeCellCount > 3) {
287  if (maxHitWidth == 32 || maxHitWidth == 64) {
288  return true;
289  }
290  }
291 
292  return false;
293 }
294 
295 //---------------------------------------------------------------------
297  rb::Cluster cluster, int containmentMinX, int containmentMaxX,
298  int containmentMinY, int containmentMaxY, int containmentMinZ,
299  int containmentMaxZ) {
300  bool isShower = true;
301 
302  double multipleCellFractionXview, multipleCellFractionYview;
303  getMultipleCellFraction(cluster, multipleCellFractionXview,
304  multipleCellFractionYview);
305  if (multipleCellFractionYview <
306  0.1 * exp(-multipleCellFractionXview / 0.05) + 0.02) {
307  isShower = false;
308  }
309 
310  if (getXyAsymmetry(cluster) > 0.5) {
311  isShower = false;
312  }
313 
314  int febEdgeCellCount;
315  int maxHitWidth;
316  double maxCellCountFraction;
317  if (isFebFlasher(cluster, febEdgeCellCount, maxHitWidth,
318  maxCellCountFraction)) {
319  isShower = false;
320  }
321 
322  if (!isContainedSlice(cluster, containmentMinX, containmentMaxX,
323  containmentMinY, containmentMaxY, containmentMinZ,
324  containmentMaxZ)) {
325  isShower = false;
326  }
327 
328  if (maxCellCountFraction > 0.8) {
329  isShower = false;
330  }
331 
332  return isShower;
333 }
334 
335 //---------------------------------------------------------------------
337  geo::View_t aView) {
338  double visibleE = 0.;
339 
340  for (unsigned int j = 0; j < cluster.NCell(aView); j++) {
341  rb::RecoHit recoHit = cluster.RecoHit(aView, j);
342  if (recoHit.IsCalibrated()) {
343  visibleE += (double)recoHit.GeV();
344  }
345  }
346 
347  return visibleE;
348 }
349 
350 //---------------------------------------------------------------------
352  geo::View_t aView) {
353  return cluster.NCell(aView);
354 }
355 
356 //---------------------------------------------------------------------
358  std::vector<double> hitTimesInNanoSecond;
359 
360  for (unsigned int j = 0; j < cluster.NCell(); j++) {
361  rb::RecoHit recoHit = cluster.RecoHit(j);
362  if (recoHit.IsCalibrated()) {
363  hitTimesInNanoSecond.push_back(recoHit.T());
364  }
365  }
366 
367  return *std::max_element(hitTimesInNanoSecond.begin(),
368  hitTimesInNanoSecond.end()) -
369  *std::min_element(hitTimesInNanoSecond.begin(),
370  hitTimesInNanoSecond.end());
371 }
372 
373 //---------------------------------------------------------------------
375  geo::View_t aView) {
376  const auto numberOfHits = cluster.NCell(aView);
377 
378  double *cellArray = (double *)malloc(numberOfHits * sizeof(double));
379  double *timeArray = (double *)malloc(numberOfHits * sizeof(double));
380 
381  for (unsigned int j = 0; j < numberOfHits; j++) {
382  rb::RecoHit recoHit = cluster.RecoHit(aView, j);
383  if (recoHit.IsCalibrated()) {
384  *(cellArray + j) = (aView == geo::kX) ? recoHit.X() : recoHit.Y();
385  *(timeArray + j) = recoHit.T();
386  }
387  }
388 
389  return calculateCorrelationFactor(numberOfHits, timeArray, cellArray);
390 }
391 
392 //---------------------------------------------------------------------
394  geo::View_t aView) {
395  const auto numberOfHits = cluster.NCell(aView);
396 
397  double *planeArray = (double *)malloc(numberOfHits * sizeof(double));
398  double *timeArray = (double *)malloc(numberOfHits * sizeof(double));
399 
400  for (unsigned int j = 0; j < numberOfHits; j++) {
401  rb::RecoHit recoHit = cluster.RecoHit(aView, j);
402  if (recoHit.IsCalibrated()) {
403  *(planeArray + j) = recoHit.Z();
404  *(timeArray + j) = recoHit.T();
405  }
406  }
407 
408  return calculateCorrelationFactor(numberOfHits, timeArray, planeArray);
409 }
410 
411 //---------------------------------------------------------------------
413  double *aVar1,
414  double *aVar2) {
415  TGraph *gr = new TGraph(nPoints, aVar1, aVar2);
416  return gr->GetCorrelationFactor();
417 }
418 
419 //---------------------------------------------------------------------
421  double visELowerLim,
422  double visEUpperLim) {
423  double visibleEnergy = totalVisibleEnergyInView(cluster, geo::kX) +
425  return ((visibleEnergy >= visELowerLim) && (visibleEnergy <= visEUpperLim))
426  ? true
427  : false;
428 }
429 
430 //---------------------------------------------------------------------
432  rb::Cluster track) {
433  bool isCoincidence = false;
434 
435  double avgHitTimeShower, avgHitTimeTrack;
436  double minHitTimeShower, minHitTimeTrack;
437  double maxHitTimeShower, maxHitTimeTrack;
438  NNbarUtilities::getSliceTimeWindow(shower, minHitTimeShower, maxHitTimeShower,
439  avgHitTimeShower);
440  NNbarUtilities::getSliceTimeWindow(track, minHitTimeTrack, maxHitTimeTrack,
441  avgHitTimeTrack);
442 
443  // If time difference smaller than 10us than consider this as an coincidence
444  if (TMath::Abs(avgHitTimeShower - avgHitTimeTrack) <= 10000) {
445  isCoincidence = true;
446  }
447 
448  return isCoincidence;
449 }
450 //---------------------------------------------------------------------
452  std::vector<point2d_t> &xview,
453  std::vector<point2d_t> &yview) {
454  art::PtrVector<rb::CellHit> allCells = shower.AllCells();
455  for (art::PtrVector<rb::CellHit>::iterator itrCell = allCells.begin();
456  itrCell != allCells.end(); itrCell++) {
457  if ((*itrCell)->View() == geo::View_t::kXorY) continue;
458 
459  bool _cIsYView = (*itrCell)->View() == geo::View_t::kY ? true : false;
460  rb::RecoHit recoHit = shower.RecoHit(*itrCell);
461  if (!recoHit.IsCalibrated()) continue;
462 
463  double _cX = recoHit.X();
464  double _cY = recoHit.Y();
465  double _cZ = recoHit.Z();
466 
467  if (!_cIsYView) {
468  xview.push_back(std::make_pair(_cZ, _cX));
469  std::cout << "xview.size(): " << xview.size() << std::endl;
470  } else {
471  yview.push_back(std::make_pair(_cZ, _cY));
472  std::cout << "xview.size(): " << xview.size() << std::endl;
473  }
474  }
475 }
476 
477 //---------------------------------------------------------------------
479  double &vertexX,
480  double &vertexY,
481  double &vertexZ) {
482  double totalE = shower.TotalGeV();
483  double totalEX = 0.;
484  double totalEY = 0.;
485 
486  art::PtrVector<rb::CellHit> allCells = shower.AllCells();
487 
488  std::multimap<double, double> HitsZ, HitsX, HitsY;
489  for (art::PtrVector<rb::CellHit>::iterator itrCell = allCells.begin(); itrCell != allCells.end(); itrCell++) {
490  if ((*itrCell)->View() == geo::View_t::kXorY) continue;
491 
492  bool cIsYView = (*itrCell)->View() == geo::View_t::kY ? true : false;
493  rb::RecoHit recoHit = shower.RecoHit(*itrCell);
494  if (!recoHit.IsCalibrated()) continue;
495 
496  double cX = recoHit.X();
497  double cY = recoHit.Y();
498  double cZ = recoHit.Z();
499  // double cT = recoHit.T();
500  double cE = recoHit.GeV();
501  HitsZ.insert(std::pair<double, double>(cZ, cE));
502  if (!cIsYView) {
503  HitsX.insert(std::pair<double, double>(cX, cE));
504  totalEX += cE;
505  } else {
506  HitsY.insert(std::pair<double, double>(cY, cE));
507  totalEY += cE;
508  }
509  }
510 
511  // Compare distance between true vertex and reconstructed vertex
512  double lowerBoundOfMedianZVertex = 0.;
513  double upperBoundOfMedianZVertex = 0.;
514  double halfOfTotalE = 0.;
515  for (auto hit = HitsZ.begin(); hit != HitsZ.end(); hit++) {
516  halfOfTotalE += (*hit).second;
517  if (halfOfTotalE < totalE / 2) {
518  lowerBoundOfMedianZVertex = (*hit).first;
519  upperBoundOfMedianZVertex = (*(hit++)).first;
520  hit--;
521  }
522  }
523  vertexZ = (lowerBoundOfMedianZVertex + upperBoundOfMedianZVertex) / 2.;
524 
525  double lowerBoundOfMedianXVertex = 0.;
526  double upperBoundOfMedianXVertex = 0.;
527  double halfOfTotalEX = 0.;
528  for (auto hit = HitsX.begin(); hit != HitsX.end(); hit++) {
529  halfOfTotalEX += (*hit).second;
530  if (halfOfTotalEX < totalEX / 2) {
531  lowerBoundOfMedianXVertex = (*hit).first;
532  upperBoundOfMedianXVertex = (*(hit++)).first;
533  hit--;
534  }
535  }
536  vertexX = (lowerBoundOfMedianXVertex + upperBoundOfMedianXVertex) / 2.;
537 
538  double lowerBoundOfMedianYVertex = 0.;
539  double upperBoundOfMedianYVertex = 0.;
540  double halfOfTotalEY = 0.;
541  for (auto hit = HitsY.begin(); hit != HitsY.end(); hit++) {
542  halfOfTotalEY += (*hit).second;
543  if (halfOfTotalEY < totalEY / 2) {
544  lowerBoundOfMedianYVertex = (*hit).first;
545  upperBoundOfMedianYVertex = (*(hit++)).first;
546  hit--;
547  }
548  }
549  vertexY = (lowerBoundOfMedianYVertex + upperBoundOfMedianYVertex) / 2.;
550 }
float T() const
Definition: RecoHit.h:39
T max(const caf::Proxy< T > &a, T b)
unsigned int NCell(geo::View_t view) const
Number of cells in view view.
Definition: Cluster.cxx:134
size_t nPoints
fvar< T > fabs(const fvar< T > &x)
Definition: fabs.hpp:15
enum geo::_plane_proj View_t
Enumerate the possible plane projections.
iterator begin()
Definition: PtrVector.h:223
Definition: geo.h:1
static double getXyAsymmetry(rb::Cluster cluster)
Vertical planes which measure X.
Definition: PlaneGeo.h:28
static bool isCoincideWithTrack(rb::Cluster shower, rb::Cluster track)
static void getMultipleCellFraction(rb::Cluster cluster, double &multipleCellFractionXview, double &multipleCellFractionYview)
float Z() const
Definition: RecoHit.h:38
Definition: event.h:19
A collection of associated CellHits.
Definition: Cluster.h:47
static double correlationTPlane(rb::Cluster cluster, geo::View_t aView)
static bool passVisibleEnergyCut(rb::Cluster cluster, double visELowerLim, double visEUpperLim)
static double correlationTCell(rb::Cluster cluster, geo::View_t aView)
static void energyBalancingVertex(rb::Cluster cluster, double &vertexX, double &vertexY, double &vertexZ)
std::pair< Spectrum *, CheatDecomp * > make_pair(SpectrumLoaderBase &loader_data, SpectrumLoaderBase &loader_mc, HistAxis *axis, Cut *cut, const SystShifts &shift, const Var &wei)
Definition: DataMCLoad.C:336
static bool isFebFlasher(rb::Cluster cluster, int &febEdgeCellCount, int &maxHitWidth, double &maxCellCountFraction)
Horizontal planes which measure Y.
Definition: PlaneGeo.h:29
const Var kY([](const caf::SRProxy *sr){float tmp=0.f;if(sr->mc.nu.empty()) return tmp;tmp=sr->mc.nu[0].y;return tmp;})
art::PtrVector< rb::CellHit > AllCells() const
Get all cells from both views.
Definition: Cluster.cxx:180
Calibrated quantities relying on position in the orthogonal view. To generate a rb::CellHit from a rb...
Definition: RecoHit.h:19
static double getMultipleOccurrenceFraction(std::vector< uint16_t > cellNumbers)
static double hitCountInView(rb::Cluster cluster, geo::View_t aView)
static constexpr int FD_PLANE_COUNT
static void getSliceBoundary(rb::Cluster cluster, int &minHitCellXview, int &maxHitCellXview, int &minHitCellYview, int &maxHitCellYview, int &minHitPlaneXview, int &maxHitPlaneXview, int &minHitPlaneYview, int &maxHitPlaneYview)
fvar< T > exp(const fvar< T > &x)
Definition: exp.hpp:10
iterator end()
Definition: PtrVector.h:237
rb::RecoHit RecoHit(const art::Ptr< rb::CellHit > &chit) const
Return calibrated hit based on assumed W coordinate.
Definition: Cluster.cxx:259
static void getCoordinateOfHits(rb::Cluster shower, std::vector< point2d_t > &xview, std::vector< point2d_t > &yview)
bool IsCalibrated() const
You MUST check here before accessing PECorr, MIP or GeV.
Definition: RecoHit.cxx:35
static bool isShowerCluster(rb::Cluster cluster, int containXmin, int containXmax, int containYmin, int containYmax, int containZmin, int containZmax)
const double j
Definition: BetheBloch.cxx:29
reference at(size_type n)
Definition: PtrVector.h:365
data_t::iterator iterator
Definition: PtrVector.h:60
size_type size() const
Definition: PtrVector.h:308
OStream cout
Definition: OStream.cxx:6
static double calculateCorrelationFactor(unsigned int nPoints, double *aVar1, double *aVar2)
float GeV() const
Definition: RecoHit.cxx:69
static constexpr int FD_CELL_COUNT_PER_PLANE
Definition: structs.h:12
float X() const
Definition: RecoHit.h:36
double TotalGeV(EEnergyCalcScheme escheme=kRecomputeEnergy) const
Simple sum of the estimated GeV of all the hits.
Definition: Cluster.cxx:378
static double totalVisibleEnergyInView(rb::Cluster cluster, geo::View_t aView)
static bool isContainedSlice(rb::Cluster cluster, int boxXviewMin, int boxXviewMax, int boxYviewMin, int boxYviewMax, int boxZviewMin, int boxZviewMax)
float Y() const
Definition: RecoHit.h:37
static constexpr int CELL_COUNT_PER_FEB
T min(const caf::Proxy< T > &a, T b)
static void getSliceTimeWindow(rb::Cluster slice, double &minHitCellT, double &macHitCellT, double &avgHitCellT)
static void getHitExtentAsymmetry(rb::Cluster slice, double &cellExtentAsymmetry, double &planeExtentAsymmetry)
static double temporalExpand(rb::Cluster cluster)