ATLAS Offline Software
FPGATrackSimGenScanBinning.h
Go to the documentation of this file.
1 // Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
2 
3 #ifndef FPGATrackSimGenScanBinning_H
4 #define FPGATrackSimGenScanBinning_H
5 
55 
59 
61 #include "GaudiKernel/StatusCode.h"
62 
63 #include <initializer_list>
64 #include <string>
65 #include <vector>
66 
67 //-------------------------------------------------------------------------------------------------------
68 // Binning base class
69 // Nomenclature:
70 // slice = first larger region binning (z0-eta binning in typical Hough)
71 // scan, row are the independent and dependent variables in a standard Hough ( e.g. pT and phi_track)
72 // slicePar = variables used to slice into overlapping regions (e.g. z0,eta)
73 // sliceVar = variable that slicePars specify a valid range of (e.g. hit_z)
74 // scanPar = scan variables of Hough-like scan (e.g. pT,d0)
75 // rowPar = variable that scanPars specify a valid range of for a given hit (e.g. phi_track)
76 //-------------------------------------------------------------------------------------------------------
77 class FPGATrackSimGenScanBinningBase : virtual public IAlgTool {
78 public:
80 
81  //--------------------------------------------------------------------------------------------------
82  //
83  // These just makes ParSet and IdxSet types that have 5 double or unsigned int
84  // for the 5-track parameters. The point of the structs is that they are fixed
85  // to the right length and can be converted back and forth to std::vector
86  // through cast operators and constructors
87  //
88  //--------------------------------------------------------------------------------------------------
89 
90  struct ParSet : public std::array<double,5> {
92  ParSet(const std::vector<double>& val) {
93  if (val.size() != 5) {
94  throw std::invalid_argument("Not enough parameters in ParSet initialization");
95  }
96  std::copy(val.begin(), val.end(), this->begin());
97  }
98  operator const std::vector<double>() const { return std::vector<double>(this->begin(),this->end());}
99  };
100  struct IdxSet : public std::array<unsigned, 5> {
102  IdxSet(const std::vector<unsigned>& val) {
103  if (val.size() != 5) {
104  throw std::invalid_argument("Not enough parameters in IdxSet initialization");
105  }
106  std::copy(val.begin(), val.end(), this->begin());
107  }
108  operator const std::vector<unsigned>() const { return std::vector<unsigned>(this->begin(),this->end());}
109  };
110 
111  //--------------------------------------------------------------------------------------------------
112  //
113  // Virtual methods that are overloaded to define the binning
114  //
115  //--------------------------------------------------------------------------------------------------
116 
117  // Specification of parameters
118  virtual const std::string &
119  parNames(unsigned i) const = 0;
120 
121  // overloaded to define which parameters are slice, scan, and row
122  // they return vectors which are the numbers of the parameters in the slice or scan
123  // and just an unsigned for row since there can be only one row parmeter
124  virtual std::vector<unsigned> slicePars() const = 0;
125  virtual std::vector<unsigned> scanPars() const = 0;
126  virtual unsigned rowParIdx() const = 0;
127 
128  // convert back and forth from pT, eta, phi, d0, z0 and internal paramater set
129  virtual const ParSet trackParsToParSet(const FPGATrackSimTrackPars &pars) const = 0;
130  virtual const FPGATrackSimTrackPars parSetToTrackPars(const ParSet &parset) const = 0;
131 
132  // calculate the distance in phi or eta from a track defined by parset to a hit
133  // these can be implemented as any variable in the r-phi or r-eta plane (not necessarily eta and phi).
134  virtual double phiResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const = 0;
135  virtual double etaResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const = 0;
136 
137  // Used to scale the histograms binning appropriately (very approximate, but at least the default ranges come up reasonable)
138  virtual double phiHistScale() const = 0;
139  virtual double etaHistScale() const = 0;
140 
141  // To determine if a hit is in a slice or row there are two options
142  // 1) Directly implement hitInSlice and idxsetToRowParBinRange.
143  // 2) Use the default implementaions of those in which case sliceVar, sliceVarExpected, and rowPar should be implemented
144  // Tells if a hit is in a slice
145  virtual bool hitInSlice(const IdxSet &idx, FPGATrackSimHit const *hit) const;
146 
147  // Tells the range of row parameters a hit is conistent with assuming the other parameters (slice and scan)
148  // are set by the given bin idx
149  virtual std::pair<unsigned, unsigned> idxsetToRowParBinRange(const IdxSet &idx, FPGATrackSimHit const *hit) const;
150 
151  private:
152  // Hit variable used in slicing (e.g. for eta-z0 slicing it would be the z of the hit)
153  virtual double sliceVar([[maybe_unused]] FPGATrackSimHit const *hit) const;
154 
155  // Find expected sliceVar for a track with the given parameters (e.g. or eta-z0 slicing this is the expect z for a given hit radius)
156  virtual double sliceVarExpected([[maybe_unused]] const ParSet &pars, [[maybe_unused]] FPGATrackSimHit const *hit) const;
157 
158  // Find the parameter for a given hit and parameters (e.g. given pT and d0 what is track phi)
159  virtual double rowPar([[maybe_unused]] const ParSet &pars, [[maybe_unused]] FPGATrackSimHit const *hit) const;
160 
161 
162  //--------------------------------------------------------------------------------------------------
163  //
164  // Functional Implementation
165  //
166  //--------------------------------------------------------------------------------------------------
167 
168  public:
169  // merge of both slice and scan par lists
170  std::vector<unsigned> sliceAndScanPars() const {
171  std::vector<unsigned> retv = slicePars();
172  std::vector<unsigned> scan = scanPars();
173  retv.insert(retv.end(), scan.begin(), scan.end());
174  return retv;
175  };
176 
177  // Find distance from bin center to hit in either slice direction or the row direction
178  double phiShift(const IdxSet &idx, FPGATrackSimHit const *hit, bool debug=false) const { return phiResidual(binCenter(idx),hit,debug);}
179  double etaShift(const IdxSet &idx, FPGATrackSimHit const *hit, bool debug=false) const { return etaResidual(binCenter(idx),hit,debug);}
180 
181  // accessors to get the numbers of bins in just the slice, scan, sliceAndScan, or row (subset of the 5-d space)
182  virtual std::vector<unsigned> sliceBins() const { return subVec(slicePars(), m_parBins); }
183  virtual std::vector<unsigned> scanBins() const { return subVec(scanPars(), m_parBins); }
184  virtual std::vector<unsigned> sliceAndScanBins() const { return subVec(sliceAndScanPars(), m_parBins); }
185  virtual unsigned rowBin() const { return m_parBins[rowParIdx()]; }
186 
187  // extract just the slice, scan, sliceAndScan, or row part of a 5-d index
188  virtual std::vector<unsigned> sliceIdx(const IdxSet &idx) const { return subVec(slicePars(), idx); }
189  virtual std::vector<unsigned> scanIdx(const IdxSet &idx) const { return subVec(scanPars(), idx); }
190  virtual std::vector<unsigned> sliceAndScanIdx(const IdxSet &idx) const { return subVec(sliceAndScanPars(), idx); }
191  virtual unsigned rowIdx(const IdxSet &idx) const { return idx[rowParIdx()]; }
192 
193  // Bin boundary utilities
194  double binCenter(unsigned par, unsigned bin) const { return m_parMin[par] + m_parStep[par] * (double(bin) + 0.5); }
195  double binLowEdge(unsigned par, unsigned bin) const { return m_parMin[par] + m_parStep[par] * (double(bin)); }
196  double binHighEdge(unsigned par, unsigned bin) const { return m_parMin[par] + m_parStep[par] * (double(bin) + 1.0); }
197  ParSet binLowEdge(const IdxSet &idx) const;
198  ParSet binCenter(const IdxSet &idx) const;
199 
200  // center of whole region
201  ParSet center() const;
202 
203  // get bin value for a specific parameter value
204  unsigned binIdx(unsigned par, double val) const { return (val > m_parMin[par]) ? unsigned(floor((val - m_parMin[par]) / m_parStep[par])) : 0; }
205  unsigned rowParBinIdx(double val) const { return binIdx(rowParIdx(), val); }
206 
207  // check if 1-d or 5-d parameter is within the range of the binning
208  bool inRange(unsigned par, double val) const { return ((val < m_parMax[par]) && (val > m_parMin[par])); }
209  bool inRange(const ParSet &pars) const;
210 
211  // convert parset (the binning parameters) to a 5-d bin
212  IdxSet binIdx(const ParSet &pars) const;
213 
214  // convert FPGATrackSimTrackPars to 5-d bin
215  const IdxSet parsToBin(FPGATrackSimTrackPars &pars) const;
216 
217  // Generic Utility for splitting in vector (e.g. idx or #bins 5-d vectors)
218  // into subvectors (e.g. idx for just the scan parameters). Technically, for
219  // a list of parameter indices (elems) gives the subvector of the invec with just those indices
220  std::vector<unsigned> subVec(const std::vector<unsigned>& elems, const IdxSet& invec) const;
221 
222  // Opposite of above subVec, this sets the subvector
223  StatusCode setIdxSubVec(IdxSet &idx, const std::vector<unsigned>& subvecelems, const std::vector<unsigned>& subvecidx) const;
224 
225  // Makes are set of parameters corresponding to the corners specified by scanpars of the bin specified by idx
226  // e.g. if scan pars is (pT,d0) then the set is (low pT,low d0), (low pT, high d0), (high pT,low d0), (high pT, high d0)
227  std::vector<ParSet> makeVariationSet(const std::vector<unsigned> &scanpars, const IdxSet &idx) const;
228 
229  //
230  // Internal data
231  //
232  static constexpr unsigned NPars = 5;
237 
238  // invalid bin value, there is no way a true bin could be there
241 };
242 
243 
244 
245 //-------------------------------------------------------------------------------------------------------
246 //
247 // Geometry Helpers -- does basic helix calculations
248 //
249 //-------------------------------------------------------------------------------------------------------
251 {
252 public:
253  // This is the constant needed to relate hit phi to track phi due to curvature
254  static constexpr double CurvatureConstant = fpgatracksim::A;
255 
256  // standard eta to theta calculation
257  static double ThetaFromEta(double eta);
258 
259  // standard theta to eta calculation
260  static double EtaFromTheta(double theta);
261 
262  // find the expected z position from the radius and track parameters
263  static double zFromPars(double r, const FPGATrackSimTrackPars &pars);
264 
265  // find the expected z position from the radius and track parameters
266  static double phiFromPars(double r, const FPGATrackSimTrackPars &pars);
267 
268  // find the track phi that would be consistent with the other track parameters and the hit (r,phi)
269  static double parsToTrkPhi(const FPGATrackSimTrackPars &pars, FPGATrackSimHit const *hit);
270 };
271 
272 //-------------------------------------------------------------------------------------------------------
273 //
274 // Standard pT, d0, phi, eta, z0 implmentation of FPGATrackSimGenScanStdTrkBinning
275 // -- this is then effectively a "standard" Hough transform except that it slices
276 // in (z0,eta) and then the accumulator scans is in both pT and d0 with phi_track
277 // as the row of the accumulator
278 //
279 //-------------------------------------------------------------------------------------------------------
280 class FPGATrackSimGenScanStdTrkBinning : public extends<AthAlgTool, FPGATrackSimGenScanBinningBase>
281 {
282 public:
283  FPGATrackSimGenScanStdTrkBinning(const std::string& algname, const std::string &name, const IInterface *ifc) :
284  base_class(algname, name, ifc), m_parNames({"z0", "eta", "qOverPt", "d0", "phi"})
285  {
286  declareInterface<FPGATrackSimGenScanBinningBase>(this);
287  }
288 
289  virtual StatusCode initialize() override { return StatusCode::SUCCESS; }
290 
291  virtual const std::string &parNames(unsigned i) const override { return m_parNames[i]; }
292  virtual unsigned rowParIdx() const override { return 4;}
293 
294  virtual std::vector<unsigned> slicePars() const override { return std::vector<unsigned>({0,1}); }
295  virtual std::vector<unsigned> scanPars() const override { return std::vector<unsigned>({2,3}); }
296 
297  virtual double etaHistScale() const override {return 200.0;}
298  virtual double phiHistScale() const override {return 0.1;}
299 
300  virtual const ParSet trackParsToParSet(const FPGATrackSimTrackPars &pars) const override
301  {
304  }
305  virtual const FPGATrackSimTrackPars parSetToTrackPars(const ParSet &parset) const override
306  {
308  pars[FPGATrackSimTrackPars::IZ0] = parset[0];
309  pars[FPGATrackSimTrackPars::IETA] = parset[1];
310  pars[FPGATrackSimTrackPars::IHIP] = parset[2];
311  pars[FPGATrackSimTrackPars::ID0] = parset[3];
312  pars[FPGATrackSimTrackPars::IPHI] = parset[4];
313  return pars;
314  }
315 
316  virtual double sliceVarExpected(const ParSet &pars, FPGATrackSimHit const *hit) const override
317  {
319  }
320  virtual double sliceVar(FPGATrackSimHit const *hit) const override
321  {
322  return hit->getZ();
323  }
324  virtual double rowPar(const ParSet &pars, FPGATrackSimHit const *hit) const override
325  {
327  }
328 
329  virtual double etaResidual(const ParSet &parset ,FPGATrackSimHit const * hit, [[maybe_unused]] bool debug=false) const override {
330  // this uses a shift in "eta*radius" instead of "z"
331  double theta = FPGATrackSimGenScanGeomHelpers::ThetaFromEta(parset[1]); // 1 = eta
332  return (hit->getZ() - parset[0]) * sin(theta) - hit->getR() * cos(theta); // 0=z0
333  }
334  virtual double phiResidual(const ParSet &parset,FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const override {
336  }
337 
338 private:
339  const std::vector<std::string> m_parNames;
340 };
341 
342 //-------------------------------------------------------------------------------------------------------
343 //
344 // Tool for doing Key Layer Math
345 // -- that is converting be the track parameters set by the standard (pT,eta,phi,d0,z0) and
346 // the "KeyLayer" parametes set by the phi and z at to radii (R1,R2) and a deviation from
347 // straight line between the two points (xm)
348 // -- All the math for the r-phi plane is based finding the rotated coordinate system where
349 // the points (R1,phiR1) and (R2,phiR2) both lie on the x=0 axis. Then the x of a track halfway
350 // between the points (called xm) is the sagitta.
351 //
352 //-------------------------------------------------------------------------------------------------------
354 {
355 public:
356  FPGATrackSimGenScanKeyLyrHelper(double r1, double r2) : m_R1(r1), m_R2(r2) {}
357  FPGATrackSimGenScanKeyLyrHelper() {} // NOTE r1 and r2 must be set before using class
358 
359  struct KeyLyrPars {
362  : z1(parset[0]), z2(parset[1]), phi1(parset[2]), phi2(parset[3]), xm(parset[4]) {}
363  double z1;
364  double z2;
365  double phi1;
366  double phi2;
367  double xm;
368  };
369 
370  // convert (r,phi) to (x,y)
371  std::pair<double, double> getXY(double r, double phi) const;
372 
373  // Get rotation angles need to rotate the two given points to be only seperated in the y direction (both have same x)
374  // results is the sin and cos of rotation
375  std::pair<double, double> getRotationAngles(const std::pair<double, double>& xy1, const std::pair<double, double>& xy2) const;
376 
377  // Apply a rotation angles (sin and cos) to a point xy
378  std::pair<double, double> rotateXY(const std::pair<double, double>& xy, const std::pair<double, double>& ang) const;
379 
380  // Simple struct and function to get the rotation angle and full rotated information in one call
382  {
383  std::pair<double, double> xy1p; // point 1 after rotation
384  std::pair<double, double> xy2p; // point 2 after rotation
385  std::pair<double, double> rotang; // rotation angle
386  double y; // y seperation after rotation
387  };
388  rotatedConfig getRotatedConfig(const KeyLyrPars &keypars) const;
389 
390  // get the x,y coordinates of a hit in the rotated coordinate system specified by rotang
391  std::pair<double, double> getRotatedHit(const std::pair<double, double>& rotang, const FPGATrackSimHit *hit) const;
392 
393  // Convert back and forth to standard track parameters
396 
397  // find expected z hit position given a radius
398  double zExpected(const KeyLyrPars& keypars, double r) const;
399 
400  // find expected x position of a hit at given a radius in the rotated coordinate system
401  double xExpected(const KeyLyrPars& keypars, const FPGATrackSimHit *hit) const;
402 
403  // takes hit position and calculated what xm would be for track going through that hit
404  double xmForHit(const KeyLyrPars& keypars, const FPGATrackSimHit *hit) const;
405 
406  // Find shift from nominal track to hit in the "x" direction
407  double deltaX(const KeyLyrPars& keypars, const FPGATrackSimHit *hit) const;
408 
409  // accessors
410  double R1() const {return m_R1;}
411  double R2() const {return m_R2;}
412  void setR1(const double r1) {m_R1=r1;}
413  void setR2(const double r2) {m_R2=r2;}
414 
415  private:
416  double m_R1;
417  double m_R2;
418 };
419 
420 //-------------------------------------------------------------------------------------------------------
421 //
422 // Key Layer Binning implementation (z slice then phi scan)
423 // -- Using the FPGATrackSimGenScanKeyLyrHelper to implement an instance of
424 // FPGATrackSimGenScanBinningBase which slices in z and then scans in (phiR1,phiR2),
425 // and then uses xm as the final row variable
426 //
427 //-------------------------------------------------------------------------------------------------------
428 class FPGATrackSimGenScanKeyLyrBinning : public extends<AthAlgTool, FPGATrackSimGenScanBinningBase>
429 {
430 public:
431  FPGATrackSimGenScanKeyLyrBinning(const std::string& algname, const std::string &name, const IInterface *ifc) :
432  base_class(algname, name, ifc), m_keylyrtool(m_rin,m_rout), m_parNames({"zR1", "zR2", "phiR1", "phiR2", "xm"})
433  {
434  declareInterface<FPGATrackSimGenScanBinningBase>(this);
435  }
436 
437  virtual StatusCode initialize() override {
440  return StatusCode::SUCCESS;
441  }
442 
443  Gaudi::Property<double> m_rin{this, "rin", {-1.0}, "Radius of inner layer for keylayer definition"};
444  Gaudi::Property<double> m_rout{this, "rout", {-1.0}, "Radius of outer layer for keylayer definition"};
445 
446  virtual const std::string &parNames(unsigned i) const override { return m_parNames[i]; }
447  virtual unsigned rowParIdx() const override { return 4;}
448  virtual std::vector<unsigned> slicePars() const override { return std::vector<unsigned>({0,1}); }
449  virtual std::vector<unsigned> scanPars() const override { return std::vector<unsigned>({2,3}); }
450 
451  virtual double etaHistScale() const override {return 300.0;}
452  virtual double phiHistScale() const override {return 60.0;}
453 
455  return ParSet({keypars.z1,keypars.z2,keypars.phi1,keypars.phi2,keypars.xm});
456  }
457 
460  }
461 
462  virtual const ParSet trackParsToParSet(const FPGATrackSimTrackPars &pars) const override {
464  }
465  virtual const FPGATrackSimTrackPars parSetToTrackPars(const ParSet &parset) const override {
467  }
468  virtual double sliceVarExpected(const ParSet &pars, FPGATrackSimHit const *hit) const override
469  {
471  }
472  virtual double sliceVar(FPGATrackSimHit const *hit) const override {
473  return hit->getZ();
474  }
475  virtual double rowPar(const ParSet &parset, FPGATrackSimHit const *hit) const override
476  {
477  return m_keylyrtool.xmForHit(parSetToKeyPars(parset),hit);
478  }
479  virtual double etaResidual(const ParSet &parset,FPGATrackSimHit const * hit, [[maybe_unused]] bool debug=false) const override {
480  return hit->getZ()- m_keylyrtool.zExpected(parSetToKeyPars(parset),hit->getR());
481  }
482 
483  virtual double phiResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const override {
484  return m_keylyrtool.deltaX(parSetToKeyPars(parset),hit);
485  }
486 
487 private:
489  const std::vector<std::string> m_parNames;
490 
491  };
492 
493 //-------------------------------------------------------------------------------------------------------
494 //
495 // Key Layer Binning Phi Sliced (then z scanned)
496 // -- This scans slices in all phi parameters ("phiR1", "phiR2", "xm")
497 // and then scans in in ("zR1", "zR2")
498 // -- This was used to explore the throughput of inverting these opperations
499 // -- Also the hitInSlice and idxsetToRowParBinRange functions were switched
500 // to be simple windows so that its more like real firmware
501 //
502 //-------------------------------------------------------------------------------------------------------
503 class FPGATrackSimGenScanPhiSlicedKeyLyrBinning : public extends<AthAlgTool, FPGATrackSimGenScanBinningBase>
504 {
505 public:
506  FPGATrackSimGenScanPhiSlicedKeyLyrBinning(const std::string& algname, const std::string &name, const IInterface *ifc) :
507  base_class(algname, name, ifc), m_parNames({"zR1", "zR2", "phiR1", "phiR2", "xm"})
508  {
509  declareInterface<FPGATrackSimGenScanBinningBase>(this);
510  }
511 
512  virtual StatusCode initialize() override {
515  return StatusCode::SUCCESS;
516  }
517 
518  Gaudi::Property<double> m_rin{this, "rin", {-1.0}, "Radius of inner layer for keylayer definition"};
519  Gaudi::Property<double> m_rout{this, "rout", {-1.0}, "Radius of outer layer for keylayer definition"};
520 
521  virtual const std::string &parNames(unsigned i) const override { return m_parNames[i]; }
522  virtual unsigned rowParIdx() const override { return 4;}
523  virtual std::vector<unsigned> slicePars() const override { return std::vector<unsigned>({2,3,4}); }
524  virtual std::vector<unsigned> scanPars() const override { return std::vector<unsigned>({0,1}); }
525 
526  virtual double etaHistScale() const override {return 60.0;}
527  virtual double phiHistScale() const override {return 30.0;}
528 
530  return ParSet({keypars.z1,keypars.z2,keypars.phi1,keypars.phi2,keypars.xm});
531  }
532 
535  }
536 
537  virtual const ParSet
540  }
541  virtual const FPGATrackSimTrackPars
542  parSetToTrackPars(const ParSet &parset) const override {
544  }
545 
546  virtual double phiResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug) const override;
547 
548  virtual double etaResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug) const override
549  {
550  return hit->getZ()- m_keylyrtool.zExpected(parSetToKeyPars(parset),hit->getR());
551  }
552 
553  virtual bool hitInSlice(const IdxSet &idx, FPGATrackSimHit const *hit) const override {
554  double r1 = m_keylyrtool.R1();
555  double r2 = m_keylyrtool.R2();
556  auto keypars = parSetToKeyPars(binCenter(idx));
557  auto tmppars = keypars;
558  tmppars.xm = m_parStep[4] / 2.0;
559  double xrange = m_keylyrtool.xExpected(tmppars, hit) + (r1*m_parStep[2] + (r2*m_parStep[3] - r1*m_parStep[2]) / (r2 - r1) * (hit->getR() - r1))/2.0;
560  return (std::abs(phiShift(idx, hit)) < xrange);
561  }
562 
563  virtual std::pair<unsigned, unsigned> idxsetToRowParBinRange(const IdxSet &idx, [[maybe_unused]] FPGATrackSimHit const *hit) const override
564  {
565  double r1 = m_keylyrtool.R1();
566  double r2 = m_keylyrtool.R2();
567  double lowz_in = binLowEdge(0,idx[0]);
568  double highz_in = binHighEdge(0,idx[0]);
569  double lowz_out = binLowEdge(1,idx[1]);
570  double highz_out = binHighEdge(1,idx[1]);
571 
572 
573  // simple box cut
574  if (hit->getZ() < lowz_in + (lowz_out-lowz_in) * (hit->getR()-r1)/(r2-r1))
575  return std::pair<unsigned, unsigned>(0, 0); // empty range
576 
577  if (hit->getZ() > highz_in + (highz_out-highz_in) * (hit->getR()-r1)/(r2-r1))
578  return std::pair<unsigned, unsigned>(0, 0); // empty range
579 
580  return std::pair<unsigned, unsigned>(rowIdx(idx), rowIdx(idx) + 1); // range covers just 1 row bin
581  }
582 
583 private:
585  const std::vector<std::string> m_parNames;
586 
587  };
588 
589 #endif // FPGATrackSimGenScanBinning_H
FPGATrackSimGenScanKeyLyrHelper::rotatedConfig
Definition: FPGATrackSimGenScanBinning.h:382
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
xrange
void xrange(TH1 *h, bool symmetric)
Definition: computils.cxx:516
FPGATrackSimGenScanGeomHelpers::phiFromPars
static double phiFromPars(double r, const FPGATrackSimTrackPars &pars)
Definition: FPGATrackSimGenScanBinning.cxx:197
FPGATrackSimTrackPars::IHIP
@ IHIP
Definition: FPGATrackSimTrackPars.h:49
beamspotman.r
def r
Definition: beamspotman.py:676
FPGATrackSimGenScanKeyLyrHelper::R1
double R1() const
Definition: FPGATrackSimGenScanBinning.h:410
FPGATrackSimGenScanKeyLyrHelper::rotatedConfig::xy1p
std::pair< double, double > xy1p
Definition: FPGATrackSimGenScanBinning.h:383
FPGATrackSimGenScanKeyLyrHelper::setR1
void setR1(const double r1)
Definition: FPGATrackSimGenScanBinning.h:412
FPGATrackSimGenScanBinningBase::scanBins
virtual std::vector< unsigned > scanBins() const
Definition: FPGATrackSimGenScanBinning.h:183
FPGATrackSimTrackPars::ID0
@ ID0
Definition: FPGATrackSimTrackPars.h:49
FPGATrackSimGenScanBinningBase::IdxSet
Definition: FPGATrackSimGenScanBinning.h:100
FPGATrackSimGenScanStdTrkBinning::slicePars
virtual std::vector< unsigned > slicePars() const override
Definition: FPGATrackSimGenScanBinning.h:294
getMenu.algname
algname
Definition: getMenu.py:54
FPGATrackSimGenScanKeyLyrHelper::rotateXY
std::pair< double, double > rotateXY(const std::pair< double, double > &xy, const std::pair< double, double > &ang) const
Definition: FPGATrackSimGenScanBinning.cxx:233
FPGATrackSimGenScanKeyLyrHelper::xmForHit
double xmForHit(const KeyLyrPars &keypars, const FPGATrackSimHit *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:339
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::FPGATrackSimGenScanPhiSlicedKeyLyrBinning
FPGATrackSimGenScanPhiSlicedKeyLyrBinning(const std::string &algname, const std::string &name, const IInterface *ifc)
Definition: FPGATrackSimGenScanBinning.h:506
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
FPGATrackSimGenScanKeyLyrHelper::R2
double R2() const
Definition: FPGATrackSimGenScanBinning.h:411
FPGATrackSimGenScanBinningBase::setIdxSubVec
StatusCode setIdxSubVec(IdxSet &idx, const std::vector< unsigned > &subvecelems, const std::vector< unsigned > &subvecidx) const
Definition: FPGATrackSimGenScanBinning.cxx:87
FPGATrackSimGenScanKeyLyrBinning::phiHistScale
virtual double phiHistScale() const override
Definition: FPGATrackSimGenScanBinning.h:452
FPGATrackSimGenScanGeomHelpers::CurvatureConstant
static constexpr double CurvatureConstant
Definition: FPGATrackSimGenScanBinning.h:254
FPGATrackSimGenScanBinningBase::rowPar
virtual double rowPar([[maybe_unused]] const ParSet &pars, [[maybe_unused]] FPGATrackSimHit const *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:167
FPGATrackSimGenScanKeyLyrBinning::etaResidual
virtual double etaResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const override
Definition: FPGATrackSimGenScanBinning.h:479
FPGATrackSimGenScanKeyLyrHelper::getXY
std::pair< double, double > getXY(double r, double phi) const
Definition: FPGATrackSimGenScanBinning.cxx:218
FPGATrackSimTrackPars
Definition: FPGATrackSimTrackPars.h:22
FPGATrackSimGenScanBinningBase::inRange
bool inRange(unsigned par, double val) const
Definition: FPGATrackSimGenScanBinning.h:208
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
xAODP4Helpers.h
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::idxsetToRowParBinRange
virtual std::pair< unsigned, unsigned > idxsetToRowParBinRange(const IdxSet &idx, [[maybe_unused]] FPGATrackSimHit const *hit) const override
Definition: FPGATrackSimGenScanBinning.h:563
FPGATrackSimGenScanBinningBase::m_parBins
IdxSet m_parBins
Definition: FPGATrackSimGenScanBinning.h:236
FPGATrackSimGenScanKeyLyrHelper::setR2
void setR2(const double r2)
Definition: FPGATrackSimGenScanBinning.h:413
FPGATrackSimGenScanStdTrkBinning::sliceVar
virtual double sliceVar(FPGATrackSimHit const *hit) const override
Definition: FPGATrackSimGenScanBinning.h:320
FPGATrackSimTrackPars::IZ0
@ IZ0
Definition: FPGATrackSimTrackPars.h:49
FPGATrackSimGenScanGeomHelpers::ThetaFromEta
static double ThetaFromEta(double eta)
Definition: FPGATrackSimGenScanBinning.cxx:176
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars::z1
double z1
Definition: FPGATrackSimGenScanBinning.h:363
FPGATrackSimGenScanKeyLyrHelper::m_R2
double m_R2
Definition: FPGATrackSimGenScanBinning.h:417
FPGATrackSimGenScanKeyLyrBinning::sliceVar
virtual double sliceVar(FPGATrackSimHit const *hit) const override
Definition: FPGATrackSimGenScanBinning.h:472
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
FPGATrackSimGenScanBinningBase::ParSet
Definition: FPGATrackSimGenScanBinning.h:90
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars::xm
double xm
Definition: FPGATrackSimGenScanBinning.h:367
FPGATrackSimGenScanKeyLyrHelper::FPGATrackSimGenScanKeyLyrHelper
FPGATrackSimGenScanKeyLyrHelper(double r1, double r2)
Definition: FPGATrackSimGenScanBinning.h:356
FPGATrackSimGenScanBinningBase::sliceAndScanIdx
virtual std::vector< unsigned > sliceAndScanIdx(const IdxSet &idx) const
Definition: FPGATrackSimGenScanBinning.h:190
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
FPGATrackSimGenScanBinningBase::hitInSlice
virtual bool hitInSlice(const IdxSet &idx, FPGATrackSimHit const *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:122
FPGATrackSimGenScanKeyLyrBinning::trackParsToParSet
virtual const ParSet trackParsToParSet(const FPGATrackSimTrackPars &pars) const override
Definition: FPGATrackSimGenScanBinning.h:462
FPGATrackSimGenScanKeyLyrHelper::keyParsToTrackPars
FPGATrackSimTrackPars keyParsToTrackPars(const KeyLyrPars &keypars) const
Definition: FPGATrackSimGenScanBinning.cxx:286
bin
Definition: BinsDiffFromStripMedian.h:43
FPGATrackSimGenScanKeyLyrBinning::etaHistScale
virtual double etaHistScale() const override
Definition: FPGATrackSimGenScanBinning.h:451
FPGATrackSimGenScanBinningBase::parNames
virtual const std::string & parNames(unsigned i) const =0
FPGATrackSimGenScanBinningBase::center
ParSet center() const
Definition: FPGATrackSimGenScanBinning.cxx:47
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::rowParIdx
virtual unsigned rowParIdx() const override
Definition: FPGATrackSimGenScanBinning.h:522
xAOD::P4Helpers::deltaPhi
double deltaPhi(double phiA, double phiB)
delta Phi in range [-pi,pi[
Definition: xAODP4Helpers.h:69
FPGATrackSimGenScanKeyLyrBinning::m_parNames
const std::vector< std::string > m_parNames
Definition: FPGATrackSimGenScanBinning.h:489
FPGATrackSimGenScanKeyLyrBinning::initialize
virtual StatusCode initialize() override
Definition: FPGATrackSimGenScanBinning.h:437
FPGATrackSimGenScanBinningBase::etaResidual
virtual double etaResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const =0
FPGATrackSimGenScanBinningBase::binIdx
unsigned binIdx(unsigned par, double val) const
Definition: FPGATrackSimGenScanBinning.h:204
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::initialize
virtual StatusCode initialize() override
Definition: FPGATrackSimGenScanBinning.h:512
FPGATrackSimGenScanStdTrkBinning::parNames
virtual const std::string & parNames(unsigned i) const override
Definition: FPGATrackSimGenScanBinning.h:291
FPGATrackSimGenScanKeyLyrBinning::phiResidual
virtual double phiResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const override
Definition: FPGATrackSimGenScanBinning.h:483
FPGATrackSimGenScanBinningBase::idxsetToRowParBinRange
virtual std::pair< unsigned, unsigned > idxsetToRowParBinRange(const IdxSet &idx, FPGATrackSimHit const *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:142
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::m_rin
Gaudi::Property< double > m_rin
Definition: FPGATrackSimGenScanBinning.h:518
FPGATrackSimGenScanBinningBase::m_parMax
ParSet m_parMax
Definition: FPGATrackSimGenScanBinning.h:234
FPGATrackSimGenScanBinningBase::phiHistScale
virtual double phiHistScale() const =0
xAOD::unsigned
unsigned
Definition: RingSetConf_v1.cxx:662
FPGATrackSimGenScanKeyLyrBinning::rowPar
virtual double rowPar(const ParSet &parset, FPGATrackSimHit const *hit) const override
Definition: FPGATrackSimGenScanBinning.h:475
FPGATrackSimGenScanBinningBase::scanIdx
virtual std::vector< unsigned > scanIdx(const IdxSet &idx) const
Definition: FPGATrackSimGenScanBinning.h:189
FPGATrackSimGenScanStdTrkBinning::phiResidual
virtual double phiResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const override
Definition: FPGATrackSimGenScanBinning.h:334
FPGATrackSimGenScanBinningBase::trackParsToParSet
virtual const ParSet trackParsToParSet(const FPGATrackSimTrackPars &pars) const =0
FPGATrackSimGenScanKeyLyrHelper::rotatedConfig::rotang
std::pair< double, double > rotang
Definition: FPGATrackSimGenScanBinning.h:385
FPGATrackSimGenScanStdTrkBinning::etaResidual
virtual double etaResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const override
Definition: FPGATrackSimGenScanBinning.h:329
FPGATrackSimConstants.h
FPGATrackSimGenScanStdTrkBinning::FPGATrackSimGenScanStdTrkBinning
FPGATrackSimGenScanStdTrkBinning(const std::string &algname, const std::string &name, const IInterface *ifc)
Definition: FPGATrackSimGenScanBinning.h:283
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::phiHistScale
virtual double phiHistScale() const override
Definition: FPGATrackSimGenScanBinning.h:527
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars::KeyLyrPars
KeyLyrPars()
Definition: FPGATrackSimGenScanBinning.h:360
FPGATrackSimGenScanBinningBase::sliceVar
virtual double sliceVar([[maybe_unused]] FPGATrackSimHit const *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:165
FPGATrackSimGenScanKeyLyrBinning::parNames
virtual const std::string & parNames(unsigned i) const override
Definition: FPGATrackSimGenScanBinning.h:446
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars::phi2
double phi2
Definition: FPGATrackSimGenScanBinning.h:366
FPGATrackSimGenScanBinningBase::m_invalidBin
const IdxSet m_invalidBin
Definition: FPGATrackSimGenScanBinning.h:239
FPGATrackSimHit::getGPhi
float getGPhi() const
Definition: FPGATrackSimHit.h:141
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars::KeyLyrPars
KeyLyrPars(const FPGATrackSimGenScanBinningBase::ParSet &parset)
Definition: FPGATrackSimGenScanBinning.h:361
FPGATrackSimGenScanBinningBase::rowParBinIdx
unsigned rowParBinIdx(double val) const
Definition: FPGATrackSimGenScanBinning.h:205
FPGATrackSimGenScanBinningBase::sliceAndScanPars
std::vector< unsigned > sliceAndScanPars() const
Definition: FPGATrackSimGenScanBinning.h:170
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::scanPars
virtual std::vector< unsigned > scanPars() const override
Definition: FPGATrackSimGenScanBinning.h:524
FPGATrackSimGenScanBinningBase::etaHistScale
virtual double etaHistScale() const =0
FPGATrackSimGenScanBinningBase::NPars
static constexpr unsigned NPars
Definition: FPGATrackSimGenScanBinning.h:232
FPGATrackSimGenScanBinningBase::sliceIdx
virtual std::vector< unsigned > sliceIdx(const IdxSet &idx) const
Definition: FPGATrackSimGenScanBinning.h:188
FPGATrackSimGenScanKeyLyrBinning::sliceVarExpected
virtual double sliceVarExpected(const ParSet &pars, FPGATrackSimHit const *hit) const override
Definition: FPGATrackSimGenScanBinning.h:468
FPGATrackSimGenScanStdTrkBinning
Definition: FPGATrackSimGenScanBinning.h:281
FPGATrackSimGenScanBinningBase::scanPars
virtual std::vector< unsigned > scanPars() const =0
FPGATrackSimGenScanBinningBase::slicePars
virtual std::vector< unsigned > slicePars() const =0
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::etaResidual
virtual double etaResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug) const override
Definition: FPGATrackSimGenScanBinning.h:548
FPGATrackSimGenScanBinningBase::phiResidual
virtual double phiResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug=false) const =0
FPGATrackSimGenScanBinningBase::IdxSet::IdxSet
IdxSet(const std::vector< unsigned > &val)
Definition: FPGATrackSimGenScanBinning.h:102
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::keyparsToParSet
ParSet keyparsToParSet(const FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars &keypars) const
Definition: FPGATrackSimGenScanBinning.h:529
FPGATrackSimGenScanKeyLyrBinning::m_rout
Gaudi::Property< double > m_rout
Definition: FPGATrackSimGenScanBinning.h:444
FPGATrackSimGenScanKeyLyrBinning::rowParIdx
virtual unsigned rowParIdx() const override
Definition: FPGATrackSimGenScanBinning.h:447
lumiFormat.i
int i
Definition: lumiFormat.py:85
FPGATrackSimGenScanKeyLyrBinning::scanPars
virtual std::vector< unsigned > scanPars() const override
Definition: FPGATrackSimGenScanBinning.h:449
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::m_keylyrtool
FPGATrackSimGenScanKeyLyrHelper m_keylyrtool
Definition: FPGATrackSimGenScanBinning.h:584
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars::phi1
double phi1
Definition: FPGATrackSimGenScanBinning.h:365
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::phiResidual
virtual double phiResidual(const ParSet &parset, FPGATrackSimHit const *hit, [[maybe_unused]] bool debug) const override
Definition: FPGATrackSimGenScanBinning.cxx:391
AthAlgTool.h
FPGATrackSimGenScanKeyLyrHelper::getRotatedHit
std::pair< double, double > getRotatedHit(const std::pair< double, double > &rotang, const FPGATrackSimHit *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:254
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars::z2
double z2
Definition: FPGATrackSimGenScanBinning.h:364
FPGATrackSimGenScanPhiSlicedKeyLyrBinning
Definition: FPGATrackSimGenScanBinning.h:504
FPGATrackSimGenScanBinningBase::DeclareInterfaceID
DeclareInterfaceID(FPGATrackSimGenScanBinningBase, 2, 0)
FPGATrackSimGenScanKeyLyrHelper::rotatedConfig::xy2p
std::pair< double, double > xy2p
Definition: FPGATrackSimGenScanBinning.h:384
FPGATrackSimGenScanBinningBase::rowIdx
virtual unsigned rowIdx(const IdxSet &idx) const
Definition: FPGATrackSimGenScanBinning.h:191
FPGATrackSimGenScanBinningBase::sliceAndScanBins
virtual std::vector< unsigned > sliceAndScanBins() const
Definition: FPGATrackSimGenScanBinning.h:184
FPGATrackSimGenScanKeyLyrBinning::m_rin
Gaudi::Property< double > m_rin
Definition: FPGATrackSimGenScanBinning.h:443
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::m_parNames
const std::vector< std::string > m_parNames
Definition: FPGATrackSimGenScanBinning.h:585
FPGATrackSimGenScanKeyLyrHelper::FPGATrackSimGenScanKeyLyrHelper
FPGATrackSimGenScanKeyLyrHelper()
Definition: FPGATrackSimGenScanBinning.h:357
FPGATrackSimHit::getZ
float getZ() const
Definition: FPGATrackSimHit.h:139
FPGATrackSimGenScanKeyLyrBinning
Definition: FPGATrackSimGenScanBinning.h:429
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars
Definition: FPGATrackSimGenScanBinning.h:359
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::parSetToTrackPars
virtual const FPGATrackSimTrackPars parSetToTrackPars(const ParSet &parset) const override
Definition: FPGATrackSimGenScanBinning.h:542
lumiFormat.array
array
Definition: lumiFormat.py:91
FPGATrackSimGenScanStdTrkBinning::initialize
virtual StatusCode initialize() override
Definition: FPGATrackSimGenScanBinning.h:289
FPGATrackSimGenScanKeyLyrHelper::getRotationAngles
std::pair< double, double > getRotationAngles(const std::pair< double, double > &xy1, const std::pair< double, double > &xy2) const
Definition: FPGATrackSimGenScanBinning.cxx:223
FPGATrackSimGenScanStdTrkBinning::m_parNames
const std::vector< std::string > m_parNames
Definition: FPGATrackSimGenScanBinning.h:339
FPGATrackSimGenScanKeyLyrBinning::m_keylyrtool
FPGATrackSimGenScanKeyLyrHelper m_keylyrtool
Definition: FPGATrackSimGenScanBinning.h:488
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::etaHistScale
virtual double etaHistScale() const override
Definition: FPGATrackSimGenScanBinning.h:526
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
FPGATrackSimGenScanStdTrkBinning::parSetToTrackPars
virtual const FPGATrackSimTrackPars parSetToTrackPars(const ParSet &parset) const override
Definition: FPGATrackSimGenScanBinning.h:305
FPGATrackSimHit.h
: FPGATrackSim-specific class to represent an hit in the detector.
FPGATrackSimGenScanGeomHelpers
Definition: FPGATrackSimGenScanBinning.h:251
FPGATrackSimGenScanGeomHelpers::parsToTrkPhi
static double parsToTrkPhi(const FPGATrackSimTrackPars &pars, FPGATrackSimHit const *hit)
Definition: FPGATrackSimGenScanBinning.cxx:204
FPGATrackSimGenScanKeyLyrHelper::getRotatedConfig
rotatedConfig getRotatedConfig(const KeyLyrPars &keypars) const
Definition: FPGATrackSimGenScanBinning.cxx:239
FPGATrackSimGenScanStdTrkBinning::trackParsToParSet
virtual const ParSet trackParsToParSet(const FPGATrackSimTrackPars &pars) const override
Definition: FPGATrackSimGenScanBinning.h:300
FPGATrackSimGenScanBinningBase::etaShift
double etaShift(const IdxSet &idx, FPGATrackSimHit const *hit, bool debug=false) const
Definition: FPGATrackSimGenScanBinning.h:179
FPGATrackSimTrackPars::IPHI
@ IPHI
Definition: FPGATrackSimTrackPars.h:49
FPGATrackSimGenScanKeyLyrHelper::xExpected
double xExpected(const KeyLyrPars &keypars, const FPGATrackSimHit *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:377
FPGATrackSimGenScanBinningBase::rowBin
virtual unsigned rowBin() const
Definition: FPGATrackSimGenScanBinning.h:185
FPGATrackSimGenScanBinningBase::parsToBin
const IdxSet parsToBin(FPGATrackSimTrackPars &pars) const
Definition: FPGATrackSimGenScanBinning.cxx:37
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::hitInSlice
virtual bool hitInSlice(const IdxSet &idx, FPGATrackSimHit const *hit) const override
Definition: FPGATrackSimGenScanBinning.h:553
FPGATrackSimGenScanKeyLyrBinning::FPGATrackSimGenScanKeyLyrBinning
FPGATrackSimGenScanKeyLyrBinning(const std::string &algname, const std::string &name, const IInterface *ifc)
Definition: FPGATrackSimGenScanBinning.h:431
FPGATrackSimGenScanStdTrkBinning::sliceVarExpected
virtual double sliceVarExpected(const ParSet &pars, FPGATrackSimHit const *hit) const override
Definition: FPGATrackSimGenScanBinning.h:316
FPGATrackSimGenScanBinningBase::m_parMin
ParSet m_parMin
Definition: FPGATrackSimGenScanBinning.h:233
FPGATrackSimHit::getR
float getR() const
Definition: FPGATrackSimHit.h:140
FPGATrackSimGenScanStdTrkBinning::phiHistScale
virtual double phiHistScale() const override
Definition: FPGATrackSimGenScanBinning.h:298
scan
void scan(TDirectory *td=0, int depth=0)
Definition: listroot.cxx:440
FPGATrackSimGenScanStdTrkBinning::scanPars
virtual std::vector< unsigned > scanPars() const override
Definition: FPGATrackSimGenScanBinning.h:295
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::m_rout
Gaudi::Property< double > m_rout
Definition: FPGATrackSimGenScanBinning.h:519
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
FPGATrackSimGenScanBinningBase::parSetToTrackPars
virtual const FPGATrackSimTrackPars parSetToTrackPars(const ParSet &parset) const =0
FPGATrackSimGenScanKeyLyrHelper::deltaX
double deltaX(const KeyLyrPars &keypars, const FPGATrackSimHit *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:363
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
FPGATrackSimGenScanKeyLyrBinning::parSetToTrackPars
virtual const FPGATrackSimTrackPars parSetToTrackPars(const ParSet &parset) const override
Definition: FPGATrackSimGenScanBinning.h:465
FPGATrackSimGenScanBinningBase::binLowEdge
double binLowEdge(unsigned par, unsigned bin) const
Definition: FPGATrackSimGenScanBinning.h:195
FPGATrackSimGenScanKeyLyrHelper::zExpected
double zExpected(const KeyLyrPars &keypars, double r) const
Definition: FPGATrackSimGenScanBinning.cxx:333
FPGATrackSimGenScanBinningBase::rowParIdx
virtual unsigned rowParIdx() const =0
FPGATrackSimGenScanStdTrkBinning::rowParIdx
virtual unsigned rowParIdx() const override
Definition: FPGATrackSimGenScanBinning.h:292
calibdata.copy
bool copy
Definition: calibdata.py:27
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
FPGATrackSimGenScanKeyLyrHelper::rotatedConfig::y
double y
Definition: FPGATrackSimGenScanBinning.h:386
FPGATrackSimGenScanStdTrkBinning::rowPar
virtual double rowPar(const ParSet &pars, FPGATrackSimHit const *hit) const override
Definition: FPGATrackSimGenScanBinning.h:324
FPGATrackSimGenScanBinningBase
Definition: FPGATrackSimGenScanBinning.h:77
FPGATrackSimGenScanStdTrkBinning::etaHistScale
virtual double etaHistScale() const override
Definition: FPGATrackSimGenScanBinning.h:297
FPGATrackSimGenScanBinningBase::ParSet::ParSet
ParSet(const std::vector< double > &val)
Definition: FPGATrackSimGenScanBinning.h:92
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::trackParsToParSet
virtual const ParSet trackParsToParSet(const FPGATrackSimTrackPars &pars) const override
Definition: FPGATrackSimGenScanBinning.h:538
FPGATrackSimGenScanBinningBase::phiShift
double phiShift(const IdxSet &idx, FPGATrackSimHit const *hit, bool debug=false) const
Definition: FPGATrackSimGenScanBinning.h:178
FPGATrackSimGenScanKeyLyrHelper::m_R1
double m_R1
Definition: FPGATrackSimGenScanBinning.h:416
FPGATrackSimGenScanBinningBase::sliceVarExpected
virtual double sliceVarExpected([[maybe_unused]] const ParSet &pars, [[maybe_unused]] FPGATrackSimHit const *hit) const
Definition: FPGATrackSimGenScanBinning.cxx:166
FPGATrackSimGenScanKeyLyrHelper::trackParsToKeyPars
KeyLyrPars trackParsToKeyPars(const FPGATrackSimTrackPars &pars) const
Definition: FPGATrackSimGenScanBinning.cxx:260
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::parNames
virtual const std::string & parNames(unsigned i) const override
Definition: FPGATrackSimGenScanBinning.h:521
FPGATrackSimGenScanBinningBase::makeVariationSet
std::vector< ParSet > makeVariationSet(const std::vector< unsigned > &scanpars, const IdxSet &idx) const
Definition: FPGATrackSimGenScanBinning.cxx:104
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::slicePars
virtual std::vector< unsigned > slicePars() const override
Definition: FPGATrackSimGenScanBinning.h:523
FPGATrackSimGenScanBinningBase::sliceBins
virtual std::vector< unsigned > sliceBins() const
Definition: FPGATrackSimGenScanBinning.h:182
FPGATrackSimGenScanPhiSlicedKeyLyrBinning::parSetToKeyPars
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars parSetToKeyPars(const ParSet &parset) const
Definition: FPGATrackSimGenScanBinning.h:533
FPGATrackSimGenScanBinningBase::binCenter
double binCenter(unsigned par, unsigned bin) const
Definition: FPGATrackSimGenScanBinning.h:194
FPGATrackSimGenScanBinningBase::m_parStep
ParSet m_parStep
Definition: FPGATrackSimGenScanBinning.h:235
FPGATrackSimGenScanKeyLyrBinning::slicePars
virtual std::vector< unsigned > slicePars() const override
Definition: FPGATrackSimGenScanBinning.h:448
FPGATrackSimGenScanKeyLyrHelper
Definition: FPGATrackSimGenScanBinning.h:354
FPGATrackSimGenScanKeyLyrBinning::keyparsToParSet
ParSet keyparsToParSet(const FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars &keypars) const
Definition: FPGATrackSimGenScanBinning.h:454
FPGATrackSimTrackPars.h
Structs that store the 5 track parameters.
FPGATrackSimGenScanGeomHelpers::EtaFromTheta
static double EtaFromTheta(double theta)
Definition: FPGATrackSimGenScanBinning.cxx:181
FPGATrackSimGenScanBinningBase::binHighEdge
double binHighEdge(unsigned par, unsigned bin) const
Definition: FPGATrackSimGenScanBinning.h:196
FPGATrackSimGenScanGeomHelpers::zFromPars
static double zFromPars(double r, const FPGATrackSimTrackPars &pars)
Definition: FPGATrackSimGenScanBinning.cxx:186
FPGATrackSimGenScanBinningBase::subVec
std::vector< unsigned > subVec(const std::vector< unsigned > &elems, const IdxSet &invec) const
Definition: FPGATrackSimGenScanBinning.cxx:77
FPGATrackSimGenScanKeyLyrBinning::parSetToKeyPars
FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars parSetToKeyPars(const ParSet &parset) const
Definition: FPGATrackSimGenScanBinning.h:458
FPGATrackSimTrackPars::IETA
@ IETA
Definition: FPGATrackSimTrackPars.h:49