---

TMuiRoadFinder.h

Go to the documentation of this file.

//
// Utility class: TMuiRoadFinder
// (based on TMutStubFinder by S. Kelly)
// Description: Encapsulates the road finding algorithm
//              used by the mMuiFindRoad module
//              

#ifndef __TMUIROADFINDER_H__
#define __TMUIROADFINDER_H__

#include <iostream>
#include<list>
#include<set>
#include<TDataType.h>
#include<TMuiClusterMapO.h>
#include<TMutFitPar.hh>
#include<TMutTrackUtil.h>
#include<mMuiFindRoadPar.h>
#include<PHPoint.h>
#include<TNtuple.h>
#include<TFile.h>



class TMuiRoadFinder
{
 public:  
  
  class Road;
  typedef std::list<Road> road_list;
  typedef std::pair<float,float> road_window;
  enum WindowEnum { IN_WINDOW, LOW_WINDOW, HIGH_WINDOW };

  TMuiRoadFinder() {}

  void find(TMuiClusterMapO* cluster_map);
  
  void find(TMuiClusterMapO* cluster_map,
            UShort_t arm, 
            bool use_window = false,
            const road_window& theta_window = std::make_pair(0,0),
            const road_window& phi_window = std::make_pair(0,0));
  
  road_list& get_road_list() { return _road_list; }
  
  void clear_road_list() { _road_list.clear(); }

  std::list<TMuiClusterMapO::value_type> 
    TMuiRoadFinder::get_coords_in_window(TMuiClusterMapO* cluster_map,
                                         UShort_t arm,
                                         const road_window& 
                                         theta_window,
                                         const road_window& 
                                         phi_window);

  void evaluate(PHCompositeNode* top_node);
  static void initialize_evaluation();  
  static void finish_evaluation();
                                                      
  static void set_verbose(bool verbose) { 
    _verbose = verbose;
    Road::set_verbose(verbose);
  }
  
  static void set_reversed_algo(bool reverse_algo) { 
    _reverse_algo = reverse_algo;
  }
  
  static void set_dca_cut(double dca_cut) { 
    Road::set_dca_cut(dca_cut);
  }
  
  static void set_prox_cut(double prox_cut) { 
    Road::set_prox_cut(prox_cut);
  }

  static void set_orient_z_dist(double orient_z_dist) { 
    Road::set_orient_z_dist(orient_z_dist);
  }

  static void set_tube_width(double tube_width) { 
    Road::set_tube_width(tube_width);
  }
  
  static void set_min_cluster(UShort_t min_cluster) { 
    _min_cluster = min_cluster;
  }

  static void set_max_cluster_share(UShort_t max_cluster_share) { 
    _max_cluster_share = max_cluster_share;
  }

  static void set_min_point(UShort_t min_point) { 
    _min_point = min_point;
  }
  
  class Road {
    
  public:    
        
    struct cluster_less_ftor
    {
      bool operator()(TMuiClusterMapO::value_type cluster1, 
                      TMuiClusterMapO::value_type cluster2)
      {
        if(cluster1.get()->get_key().get_obj_key() < 
           cluster2.get()->get_key().get_obj_key()) {
          return true;
        } 
        else {
          return false;
        }
      }
    };   
    
    typedef std::set<TMuiClusterMapO::value_type, cluster_less_ftor> cluster_list;
    typedef std::vector<PHPoint> point_list;
    
    Road(TMuiRoadFinder* finder,
         const TMuiClusterMapO::pointer cluster_ptr,
         bool use_window,
         const road_window& theta_window,
         const road_window& phi_window) :
      _finder(finder),
      _arm(cluster_ptr->get()->get_arm()),
      _theta_window(theta_window),
      _phi_window(phi_window),
      _has_window(use_window),
      _complete(false),
      _status(true)
      {
        _clusters.insert(*cluster_ptr);
      }
    
    Road(TMuiRoadFinder* finder, const TMuiClusterMapO::pointer cluster_ptr):
      _finder(finder),
      _arm(cluster_ptr->get()->get_arm()),
      _theta_window(std::make_pair(0,0)),
      _phi_window(std::make_pair(0,0)),
      _has_window(false),
      _complete(false),
      _status(true)
      {
        _clusters.insert(*cluster_ptr);
      }
    
    const TMutFitPar & get_fit_par() const  {return _fit_par;}
    
    size_t get_n_cluster() const {return _clusters.size();}    
    size_t get_n_point() const {return _points.size();}    
    
    bool add_cluster(TMuiClusterMapO::pointer cluster_ptr);  
    bool bifurcate(TMuiClusterMapO::pointer cluster_ptr);      
    
    UShort_t get_arm() const {return _arm;}
    
    // Non-const so it can be sorted by an external ftor
    //
    cluster_list& get_cluster_list() { return _clusters; }
    point_list& get_point_list() { return _points; }
    road_window get_theta_window() const { return _theta_window; }
    road_window get_phi_window() const { return _phi_window; }
    
    // Return the polar radius of the road extrapolated to requested z
    //
    double get_r_at_z(double z) const {
      PHPoint p = TMutTrackUtil::linear_track_model(&_fit_par,z);
      return std::sqrt(MUIOO::SQUARE(p.getX()) + MUIOO::SQUARE(p.getY()));
    }
    
    double get_theta() const {
      double r = std::sqrt(MUIOO::SQUARE(_fit_par.get_x()) +
                           MUIOO::SQUARE(_fit_par.get_y()));
      return atan2(r,std::fabs(_fit_par.get_z()));
    }
    
    double get_phi() const {
      return atan2(_fit_par.get_y(), _fit_par.get_x());
    }
    
    static void set_dca_cut(double dca_cut){
      _dca_cut = dca_cut;
    }
    
    static void set_prox_cut(double prox_cut){
      _prox_cut = prox_cut;
    }

    static void set_orient_z_dist(double orient_z_dist) { 
      _orient_z_dist = orient_z_dist;
    }

    static void set_tube_width(double tube_width) { 
      _tube_width = tube_width;
    }
    
    static void set_verbose(bool verbose){
      _verbose = verbose;
    }
    
    bool is_complete() const { return _complete; }
    void set_complete(bool complete) { _complete = complete; }
    bool get_status() const {return _status; }
    void set_status(bool status) {_status = status;}
    
    bool check_theta_window(const road_window& theta_window) const;
    bool check_phi_window(const road_window& theta_window) const;
    
    void print() const { 
      std::cout << "road: " ;
      // clusters
      cluster_list::const_iterator iter = _clusters.begin();
      std::cout << " nclusters " << _clusters.size() << std::endl;
      for(;iter!=_clusters.end();++iter){
        std::cout << " clusterkey " << iter->get()->get_key().get_obj_key() 
                  << std::endl;
        iter->get()->print();
      }
      // points
      point_list::const_iterator piter = _points.begin();
      std::cout << " npoints " << _points.size() << std::endl;
      for(;piter!=_points.end();++piter){
        std::cout << " point " << *piter
                  << std::endl;
        piter->print();
      }
      std::cout << std::endl;
    }

    static void initialize_evaluation();
    static void finish_evaluation();

  private: 
    
    // Private Methods
    //
    PHPoint make_point(const TMuiClusterMapO::pointer) const;
    void update_road(TMuiClusterMapO::pointer);
    void update_road(TMuiClusterMapO::pointer, const PHPoint& point);
    bool test_window(const PHPoint&) const;
    bool check_parallel(const TMuiClusterMapO::pointer) const ;
    PHPoint project(double z) const;
    bool check_proximity(TMuiClusterMapO::pointer cluster_ptr) const;
    bool check_dca(const TMuiClusterMapO::pointer cluster_ptr, const PHPoint&) const;
    bool check_slope() const;
    bool unique_check(TMuiClusterMapO::pointer cluster_ptr) const;
    
    // Pointer to parent algorithm
    //
    TMuiRoadFinder* _finder;
    
    // Locators
    //
    UShort_t _arm;
    
    // Window
    //
    road_window _theta_window;
    road_window _phi_window;
    bool _has_window;
    bool has_window() const { return _has_window; }
    
    // Complete Tag
    //
    bool _complete;
    bool _status;
    
    // Cuts
    //
    static double _dca_cut;
    static double _prox_cut;
    static bool _use_slope_cuts;

    // Offset between orientations in z
    //
    static double _orient_z_dist;

    // Width of tube
    //
    static double _tube_width;
    
    // Road clusters
    //
    cluster_list _clusters;  
    
    // Road points
    //
    point_list _points;  

    // Road parameters
    //
    TMutFitPar _fit_par;      
    
    // Verbosity
    //
    static bool _verbose;

    // Evaluation
    //
    static bool _evaluation;
    static TFile* _file;
    static TNtuple* _ntuple;
    static boost::array<float,20> _eval_data;

  }; 
  
  struct road_print_ftor
  {
    void operator() (const Road& road) {
      road.print();
    }
  };
  
  struct road_bad_status_ftor
  {
    bool operator()(const Road& road) {
      return !road.get_status();
    }
  };   
  
  struct road_equal_ftor
  {
    bool operator()(Road& road1, Road& road2)
    {
      if(road1.get_cluster_list() == road2.get_cluster_list()) {
        return true;
      } 
      else {
        return false;
      }
    }
  };   
  
  
  struct road_less_ftor
  {
    bool operator()(Road& road1, Road& road2)
    {
      if(road1.get_cluster_list() < road2.get_cluster_list()) {
        return true;
      } 
      else {
        return false;
      }
    }
  };   
  
  struct point_less_ftor
  {
    bool operator()(const PHPoint& point1, const PHPoint& point2)
    {
      double r1 = std::sqrt(MUIOO::SQUARE(point1.getX()) +
                            MUIOO::SQUARE(point1.getY()) +
                            MUIOO::SQUARE(point1.getZ()));
      
      double r2 = std::sqrt(MUIOO::SQUARE(point2.getX()) +
                            MUIOO::SQUARE(point2.getY()) +
                            MUIOO::SQUARE(point2.getZ()));
      
      return r1 < r2;
    }
  };
  
  static WindowEnum check_phi_window(const PHPoint& point, 
                                     const TMuiRoadFinder::road_window& 
                                     phi_window);
 
  static WindowEnum check_theta_window(const PHPoint& point, 
                                       const TMuiRoadFinder::road_window&
                                       theta_window);
 private:
  
  friend class Road;
  
  bool append_to_road(TMuiClusterMapO::pointer);
  
  TMuiRoadFinder::Road* start_new_road(TMuiClusterMapO::pointer,
                                       bool use_window,
                                       const road_window& theta_window,
                                       const road_window& phi_window);
  void abort_new_road();
  
  void set_complete_tag();
  
  void remove_includes();
  
  void print_roads() const;
  
  // Storage for road list
  //
  road_list _road_list;
  
  // Verbosity
  //
  static bool _verbose;
  static bool _reverse_algo;
  static UShort_t _min_cluster;
  static UShort_t _min_point;
  static UShort_t _max_cluster_share;

  static bool _evaluation; 
  static TFile* _file; 
  static TNtuple* _ntuple; 
};

#endif

---