PHHoughSeeding.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file PHHoughSeeding.h

#ifndef TRACKRECO_PHHOUGHSEEDING_H
#define TRACKRECO_PHHOUGHSEEDING_H

#include "PHTrackSeeding.h"

// Helix Hough includes
#include <HelixHough/SimpleHit3D.h>
#include <HelixHough/SimpleTrack3D.h>
#include <HelixHough/VertexFinder.h>
#include <Eigen/Core>                  // for Matrix


// standard includes
#include <cfloat>
#include <iostream>                    // for operator<<, endl, basic_ostream
#include <map>
#include <string>                      // for string
#include <vector>

// forward declarations
class BbcVertexMap;
class PHCompositeNode;
class PHG4CylinderGeomContainer;
class PHTimer;
class sPHENIXSeedFinder;
class TNtuple;
class TFile;

class PHHoughSeeding : public PHTrackSeeding
{
 public:
  PHHoughSeeding(
      const std::string &name = "PHHoughSeeding",
      unsigned int nlayers_maps = 3,
      unsigned int nlayers_intt = 8,
      unsigned int nlayers_tpc = 60,
      unsigned int seeding_nlayer = 12,
      unsigned int min_seeding_nlayer = 4
);

  ~PHHoughSeeding() override
  {
  }

 protected:
  int Setup(PHCompositeNode *topNode) override;

  int Process(PHCompositeNode *topNode) override;

  int End() override;

 private:
  int GetNodes(PHCompositeNode *topNode);

 public:
  void set_mag_field(float magField)
  {
    _magField = magField;
  }
  float get_mag_field() const
  {
    return _magField;
  }

  void set_chi2_cut_fast(double cut_par0, double cut_par1 = 0.0,
                         double cut_max = FLT_MAX)
  {
    _chi2_cut_fast_par0 = cut_par0;
    _chi2_cut_fast_par1 = cut_par1;
    _chi2_cut_fast_max = cut_max;
  }

  void set_chi2_cut_full(double chi2_cut)
  {
    _chi2_cut_full = chi2_cut;
  }
  double get_chi2_cut_full() const
  {
    return _chi2_cut_full;
  }

  void set_ca_chi2_cut(double chi2_cut)
  {
    _ca_chi2_cut = chi2_cut;
  }
  double get_ca_chi2_cut() const
  {
    return _ca_chi2_cut;
  }

  void set_cos_angle_cut(double cos_angle_cut)
  {
    _cos_angle_cut = cos_angle_cut;
  }
  double get_cos_angle_cut() const
  {
    return _cos_angle_cut;
  }

  void set_min_pT(float pt)
  {
    _min_pt = pt;
  }

  void set_z0_range(float min_z0, float max_z0)
  {
    _min_z0 = min_z0;
    _max_z0 = max_z0;
  }

  void set_r_max(float max_r)
  {
    _max_r = max_r;
  }

  void set_material(int layer, float value);

  void setRejectGhosts(bool rg)
  {
    _reject_ghosts = rg;
  }
  void setRemoveHits(bool rh)
  {
    _remove_hits = rh;
  }

  void setBinScale(float scale)
  {
    _bin_scale = scale;
  }
  void setZBinScale(float scale)
  {
    _z_bin_scale = scale;
  }

  void setCutOnDCA(bool cod)
  {
    _cut_on_dca = cod;
  }
  void setDCACut(float dcut)
  {
    _dcaxy_cut = dcut;
  }
  void setDCAZCut(float dzcut)
  {
    _dcaz_cut = dzcut;
  }

  void setPtRescaleFactor(float pt_rescale)
  {
    _pt_rescale = pt_rescale;
  }

  void setVoteErrorScale(unsigned int layer, float scale)
  {
    if (scale > 0.0)
    {
      _vote_error_scale.at(layer) = scale;
    }
    else
    {
      std::cout << "PHHoughSeeding::setVoteErrorScale : scale must be "
                   "greater than zero ... doing nothing"
                << std::endl;
    }
  }
  void setFitErrorScale(unsigned int layer, float scale)
  {
    if (scale > 0.0)
    {
      _fit_error_scale.at(layer) = scale;
    }
    else
    {
      std::cout << "PHHoughSeeding::setFitErrorScale : scale must be "
                   "greater than zero ... doing nothing"
                << std::endl;
    }
  }

  //---deprecated---------------------------------------------------------------

  void set_use_vertex(bool /*b*/)
  {
  }

  void setInitialResMultiplier(int /*beta*/)
  {
  }
  void setFullResMultiplier(int /*lambda*/)
  {
  }

  void set_min_pT_init(float /*PT*/)
  {
  }

  void setMaxClusterError(float /*max_cluster_error*/)
  {
  }

  void setUseCellSize(bool /*use_cell_size*/)
  {
  }

  void set_chi2_cut_init(double /*chi2_cut*/)
  {
  }

  const std::vector<int> &get_seeding_layer() const
  {
    return _seeding_layer;
  }

  //  void set_seeding_layer(const std::vector<int>& seedingLayer) {
  //    _seeding_layer = seedingLayer;
  //  }

  void set_seeding_layer(const int *seedingLayer, const int n)
  {
    _seeding_layer.clear();
    _seeding_layer.assign(seedingLayer, seedingLayer + n);
  }

  void set_analyzing_mode(bool analyzingMode)
  {
    _analyzing_mode = analyzingMode;
  }

  float get_max_merging_deta() const
  {
    return _max_merging_deta;
  }

  void set_max_merging_deta(float maxMergingDeta)
  {
    _max_merging_deta = maxMergingDeta;
  }

  float get_max_merging_dphi() const
  {
    return _max_merging_dphi;
  }

  void set_max_merging_dphi(float maxMergingDphi)
  {
    _max_merging_dphi = maxMergingDphi;
  }

  float get_max_merging_dr() const
  {
    return _max_merging_dr;
  }

  void set_max_merging_dr(float maxMergingDr)
  {
    _max_merging_dr = maxMergingDr;
  }

  float get_max_merging_dz() const
  {
    return _max_merging_dz;
  }

  void set_max_merging_dz(float maxMergingDz)
  {
    _max_merging_dz = maxMergingDz;
  }

  /*
  void set_vertex_error(const float a)
  {
    _vertex_error.clear();
    _vertex_error.assign(3, a);
  }
  */

  unsigned int get_min_nlayers_seeding() const
  {
    return _min_nlayers_seeding;
  }

  void set_min_nlayers_seeding(unsigned int minNlayersSeeding)
  {
    _min_nlayers_seeding = minNlayersSeeding;
    _min_combo_hits = minNlayersSeeding;
  }


 private:
  //--------------
  // InitRun Calls
  //--------------

  //int CreateNodes(PHCompositeNode *topNode);

  int InitializeGeometry(PHCompositeNode *topNode);

  int InitializePHGenFit(PHCompositeNode *topNode);

  int setup_seed_tracker_objects();

  int setup_initial_tracker_object();

  int setup_tracker_object();

  //--------------------
  // Process Event Calls
  //--------------------

  //int GetNodes(PHCompositeNode *topNode);

  int translate_input();

  int fast_composite_seed();

  int fast_vertex_from_bbc();

  //int fast_vertex_guessing();

  //int initial_vertex_finding();

  int vertexing();

  int full_track_seeding(int ivert);

  int export_output();

  int CleanupSeedsByHitPattern();

  int CleanupTracksByHitPattern();

  int CleanupSeeds();

  void print_timers();

  //------------------
  // Subfunction Calls
  //------------------

  float kappaToPt(float kappa);

  float ptToKappa(float pt);

  void convertHelixCovarianceToEuclideanCovariance(float B, float phi,
                                                   float d, float kappa, float z0, float dzdl,
                                                   Eigen::Matrix<float, 5, 5> const &input,
                                                   Eigen::Matrix<float, 6, 6> &output);

  void shift_coordinate_system(double dx, double dy, double dz, int ivertex);

  int _event;
  PHTimer *_t_seeding;
  PHTimer *_t_seed_init1;
  PHTimer *_t_seed_init2;
  PHTimer *_t_seed_init3;
  PHTimer *_t_seeds_cleanup;
  PHTimer *_t_translate_to_PHGenFitTrack;
  PHTimer *_t_translate1;
  PHTimer *_t_translate2;
  PHTimer *_t_translate3;
  PHTimer *_t_kalman_pat_rec;
  PHTimer *_t_search_clusters;
  PHTimer *_t_search_clusters_encoding;
  PHTimer *_t_search_clusters_map_iter;
  PHTimer *_t_track_propagation;
  PHTimer *_t_full_fitting;
  PHTimer *_t_output_io;

  std::vector<int> _seeding_layer;  //layer numbers that are used for seeding

  unsigned int _nlayers_seeding;        
  unsigned int _min_nlayers_seeding;    
  std::vector<float> _radii;            
  std::vector<float> _material;         
  std::map<int, float> _user_material;  

  float _magField;  

  bool _reject_ghosts;
  bool _remove_hits;

  float _min_pt;
  float _min_z0;
  float _max_z0;
  float _max_r;

  bool _cut_on_dca;
  float _dcaxy_cut;
  float _dcaz_cut;

  double _chi2_cut_fast_par0;  
  double _chi2_cut_fast_par1;  
  double _chi2_cut_fast_max;   
  double _chi2_cut_full;       
  double _ca_chi2_cut;         
  double _cos_angle_cut;       

  float _bin_scale;
  float _z_bin_scale;

  unsigned int _min_combo_hits;  
  unsigned int _max_combo_hits;  

  float _pt_rescale;
  std::vector<float> _fit_error_scale;
  std::vector<float> _vote_error_scale;

  std::map<int, unsigned int> _layer_ilayer_map;

  // object storage
  std::vector<SimpleHit3D> _clusters;  

  std::vector<SimpleTrack3D> _tracks;                      
  std::vector<double> _track_errors;                       
  std::vector<Eigen::Matrix<float, 5, 5> > _track_covars;  

  std::vector<SimpleTrack3D> _all_tracks;                      
  std::vector<double> _all_track_errors;                       
  std::vector<Eigen::Matrix<float, 5, 5> > _all_track_covars;  

  std::vector<std::vector<float>> _vertex;        
  std::vector<std::vector<float>> _vertex_error;  
  std::vector<int> _vertex_tracks;  

  // track finding routines
  sPHENIXSeedFinder *_tracker;            
  sPHENIXSeedFinder *_tracker_vertex;     
  sPHENIXSeedFinder *_tracker_etap_seed;  
  sPHENIXSeedFinder *_tracker_etam_seed;  
  VertexFinder _vertexFinder;             

  // node pointers
  BbcVertexMap *_bbc_vertexes;
  //SvtxTrackMap* _track_map;
  //SvtxVertexMap* _vertex_map;

  //nodes to get norm vector
  //SvtxHitMap *_svtxhitsmap;

  int *_hit_used_map;
  int _hit_used_map_size;

  PHG4CylinderGeomContainer *_geom_container_intt;
  PHG4CylinderGeomContainer *_geom_container_maps;

  bool _analyzing_mode;
  TFile *_analyzing_file;
  TNtuple *_analyzing_ntuple;

  float _max_merging_dphi;
  float _max_merging_deta;
  float _max_merging_dr;
  float _max_merging_dz;

  unsigned int _max_share_hits;

  double _cut_min_pT;

  unsigned int _nlayers_maps;
  unsigned int _nlayers_intt;
  unsigned int _nlayers_tpc;

  int _nlayers_all;

  std::map<int, unsigned int> _layer_ilayer_map_all;
  std::vector<float> _radii_all;

};

#endif