EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PHHoughSeeding.h
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file PHHoughSeeding.h
1 
8 #ifndef TRACKRECO_PHHOUGHSEEDING_H
9 #define TRACKRECO_PHHOUGHSEEDING_H
10 
11 #include "PHTrackSeeding.h"
12 
13 // Helix Hough includes
14 #include <HelixHough/SimpleHit3D.h>
15 #include <HelixHough/SimpleTrack3D.h>
16 #include <HelixHough/VertexFinder.h>
17 #include <Eigen/Core> // for Matrix
18 
19 
20 // standard includes
21 #include <cfloat>
22 #include <iostream> // for operator<<, endl, basic_ostream
23 #include <map>
24 #include <string> // for string
25 #include <vector>
26 
27 // forward declarations
28 class BbcVertexMap;
29 class PHCompositeNode;
31 class PHTimer;
32 class sPHENIXSeedFinder;
33 class TNtuple;
34 class TFile;
35 
45 {
46  public:
48  const std::string &name = "PHHoughSeeding",
49  unsigned int nlayers_maps = 3,
50  unsigned int nlayers_intt = 8,
51  unsigned int nlayers_tpc = 60,
52  unsigned int seeding_nlayer = 12,
53  unsigned int min_seeding_nlayer = 4
54 );
55 
56  ~PHHoughSeeding() override
57  {
58  }
59 
60  protected:
61  int Setup(PHCompositeNode *topNode) override;
62 
63  int Process(PHCompositeNode *topNode) override;
64 
65  int End() override;
66 
67  private:
69  int GetNodes(PHCompositeNode *topNode);
70 
71  public:
72  void set_mag_field(float magField)
73  {
74  _magField = magField;
75  }
76  float get_mag_field() const
77  {
78  return _magField;
79  }
80 
82  void set_chi2_cut_fast(double cut_par0, double cut_par1 = 0.0,
83  double cut_max = FLT_MAX)
84  {
85  _chi2_cut_fast_par0 = cut_par0;
86  _chi2_cut_fast_par1 = cut_par1;
87  _chi2_cut_fast_max = cut_max;
88  }
89 
91  void set_chi2_cut_full(double chi2_cut)
92  {
93  _chi2_cut_full = chi2_cut;
94  }
96  double get_chi2_cut_full() const
97  {
98  return _chi2_cut_full;
99  }
100 
102  void set_ca_chi2_cut(double chi2_cut)
103  {
104  _ca_chi2_cut = chi2_cut;
105  }
107  double get_ca_chi2_cut() const
108  {
109  return _ca_chi2_cut;
110  }
111 
113  void set_cos_angle_cut(double cos_angle_cut)
114  {
115  _cos_angle_cut = cos_angle_cut;
116  }
118  double get_cos_angle_cut() const
119  {
120  return _cos_angle_cut;
121  }
122 
123  void set_min_pT(float pt)
124  {
125  _min_pt = pt;
126  }
127 
129  void set_z0_range(float min_z0, float max_z0)
130  {
131  _min_z0 = min_z0;
132  _max_z0 = max_z0;
133  }
134 
136  void set_r_max(float max_r)
137  {
138  _max_r = max_r;
139  }
140 
142  void set_material(int layer, float value);
143 
145  void setRejectGhosts(bool rg)
146  {
147  _reject_ghosts = rg;
148  }
150  void setRemoveHits(bool rh)
151  {
152  _remove_hits = rh;
153  }
154 
156  void setBinScale(float scale)
157  {
158  _bin_scale = scale;
159  }
161  void setZBinScale(float scale)
162  {
163  _z_bin_scale = scale;
164  }
165 
167  void setCutOnDCA(bool cod)
168  {
169  _cut_on_dca = cod;
170  }
172  void setDCACut(float dcut)
173  {
174  _dcaxy_cut = dcut;
175  }
177  void setDCAZCut(float dzcut)
178  {
179  _dcaz_cut = dzcut;
180  }
181 
184  void setPtRescaleFactor(float pt_rescale)
185  {
186  _pt_rescale = pt_rescale;
187  }
188 
190  void setVoteErrorScale(unsigned int layer, float scale)
191  {
192  if (scale > 0.0)
193  {
194  _vote_error_scale.at(layer) = scale;
195  }
196  else
197  {
198  std::cout << "PHHoughSeeding::setVoteErrorScale : scale must be "
199  "greater than zero ... doing nothing"
200  << std::endl;
201  }
202  }
204  void setFitErrorScale(unsigned int layer, float scale)
205  {
206  if (scale > 0.0)
207  {
208  _fit_error_scale.at(layer) = scale;
209  }
210  else
211  {
212  std::cout << "PHHoughSeeding::setFitErrorScale : scale must be "
213  "greater than zero ... doing nothing"
214  << std::endl;
215  }
216  }
217 
218  //---deprecated---------------------------------------------------------------
219 
221  void set_use_vertex(bool /*b*/)
222  {
223  }
224 
225  void setInitialResMultiplier(int /*beta*/)
226  {
227  }
228  void setFullResMultiplier(int /*lambda*/)
229  {
230  }
231 
233  void set_min_pT_init(float /*PT*/)
234  {
235  }
236 
238  void setMaxClusterError(float /*max_cluster_error*/)
239  {
240  }
241 
243  void setUseCellSize(bool /*use_cell_size*/)
244  {
245  }
246 
248  void set_chi2_cut_init(double /*chi2_cut*/)
249  {
250  }
251 
252  const std::vector<int> &get_seeding_layer() const
253  {
254  return _seeding_layer;
255  }
256 
257  // void set_seeding_layer(const std::vector<int>& seedingLayer) {
258  // _seeding_layer = seedingLayer;
259  // }
260 
261  void set_seeding_layer(const int *seedingLayer, const int n)
262  {
263  _seeding_layer.clear();
264  _seeding_layer.assign(seedingLayer, seedingLayer + n);
265  }
266 
267  void set_analyzing_mode(bool analyzingMode)
268  {
269  _analyzing_mode = analyzingMode;
270  }
271 
272  float get_max_merging_deta() const
273  {
274  return _max_merging_deta;
275  }
276 
277  void set_max_merging_deta(float maxMergingDeta)
278  {
279  _max_merging_deta = maxMergingDeta;
280  }
281 
282  float get_max_merging_dphi() const
283  {
284  return _max_merging_dphi;
285  }
286 
287  void set_max_merging_dphi(float maxMergingDphi)
288  {
289  _max_merging_dphi = maxMergingDphi;
290  }
291 
292  float get_max_merging_dr() const
293  {
294  return _max_merging_dr;
295  }
296 
297  void set_max_merging_dr(float maxMergingDr)
298  {
299  _max_merging_dr = maxMergingDr;
300  }
301 
302  float get_max_merging_dz() const
303  {
304  return _max_merging_dz;
305  }
306 
307  void set_max_merging_dz(float maxMergingDz)
308  {
309  _max_merging_dz = maxMergingDz;
310  }
311 
312  /*
313  void set_vertex_error(const float a)
314  {
315  _vertex_error.clear();
316  _vertex_error.assign(3, a);
317  }
318  */
319 
320  unsigned int get_min_nlayers_seeding() const
321  {
322  return _min_nlayers_seeding;
323  }
324 
325  void set_min_nlayers_seeding(unsigned int minNlayersSeeding)
326  {
327  _min_nlayers_seeding = minNlayersSeeding;
328  _min_combo_hits = minNlayersSeeding;
329  }
330 
331 
332  private:
333  //--------------
334  // InitRun Calls
335  //--------------
336 
338  //int CreateNodes(PHCompositeNode *topNode);
339 
341  int InitializeGeometry(PHCompositeNode *topNode);
342 
344  int InitializePHGenFit(PHCompositeNode *topNode);
345 
348 
351 
353  int setup_tracker_object();
354 
355  //--------------------
356  // Process Event Calls
357  //--------------------
358 
360  //int GetNodes(PHCompositeNode *topNode);
361 
363  int translate_input();
364 
366  int fast_composite_seed();
367 
369  int fast_vertex_from_bbc();
370 
372  //int fast_vertex_guessing();
373 
375  //int initial_vertex_finding();
376 
378  int vertexing();
379 
381  int full_track_seeding(int ivert);
382 
384  int export_output();
385 
388 
391 
393  int CleanupSeeds();
394 
396  void print_timers();
397 
398  //------------------
399  // Subfunction Calls
400  //------------------
401 
403  float kappaToPt(float kappa);
404 
406  float ptToKappa(float pt);
407 
410  float d, float kappa, float z0, float dzdl,
411  Eigen::Matrix<float, 5, 5> const &input,
412  Eigen::Matrix<float, 6, 6> &output);
413 
415  void shift_coordinate_system(double dx, double dy, double dz, int ivertex);
416 
417  int _event;
434 
435  std::vector<int> _seeding_layer; //layer numbers that are used for seeding
436 
437  unsigned int _nlayers_seeding;
438  unsigned int _min_nlayers_seeding;
439  std::vector<float> _radii;
440  std::vector<float> _material;
441  std::map<int, float> _user_material;
442 
443  float _magField;
444 
447 
448  float _min_pt;
449  float _min_z0;
450  float _max_z0;
451  float _max_r;
452 
454  float _dcaxy_cut;
455  float _dcaz_cut;
456 
460  double _chi2_cut_full;
461  double _ca_chi2_cut;
462  double _cos_angle_cut;
463 
464  float _bin_scale;
466 
467  unsigned int _min_combo_hits;
468  unsigned int _max_combo_hits;
469 
470  float _pt_rescale;
471  std::vector<float> _fit_error_scale;
472  std::vector<float> _vote_error_scale;
473 
475  std::map<int, unsigned int> _layer_ilayer_map;
476 
477  // object storage
478  std::vector<SimpleHit3D> _clusters;
479 
480  std::vector<SimpleTrack3D> _tracks;
481  std::vector<double> _track_errors;
482  std::vector<Eigen::Matrix<float, 5, 5> > _track_covars;
483 
484  std::vector<SimpleTrack3D> _all_tracks;
485  std::vector<double> _all_track_errors;
486  std::vector<Eigen::Matrix<float, 5, 5> > _all_track_covars;
487 
488  std::vector<std::vector<float>> _vertex;
489  std::vector<std::vector<float>> _vertex_error;
490  std::vector<int> _vertex_tracks;
491 
492  // track finding routines
498 
499  // node pointers
501  //SvtxTrackMap* _track_map;
502  //SvtxVertexMap* _vertex_map;
503 
504  //nodes to get norm vector
505  //SvtxHitMap *_svtxhitsmap;
506 
509 
512 
516 
522 
524  unsigned int _max_share_hits;
525 
526  double _cut_min_pT;
527 
528  unsigned int _nlayers_maps;
529  unsigned int _nlayers_intt;
530  unsigned int _nlayers_tpc;
531 
533 
534  std::map<int, unsigned int> _layer_ilayer_map_all;
535  std::vector<float> _radii_all;
536 
537 };
538 
539 #endif