GridSearch.h

Go to the documentation of this file.

///
/// \file    GridSearch.h
/// \brief   TODO
/// \version $Id: GridSearch.h,v 1.7 2012-10-04 21:23:23 messier Exp $
/// \author  messier@indiana.edu
///
#ifndef EARMS_GRIDSEARCH_H
#define EARMS_GRIDSEARCH_H

#include <vector>

namespace rb    { class HoughResult; }
namespace earms { class ElasticArms; }

namespace earms 
{
  ///
  /// Implement a grid search over a specified range of verticies and
  /// directions
  ///
  class GridSearch 
  {
  public:
    ///
    /// Construct an object to search for a good elastic arms seed
    ///
    /// \param xmn      - Lower edge of vertex box [cm]
    /// \param xmx      - Upper edge of vertex box [cm]
    /// \param ymn      - Lower edge of vertex box [cm]
    /// \param ymx      - Upper edge of vertex box [cm]
    /// \param zmn      - Lower edge of vertex box [cm]
    /// \param zmx      - Upper edge of vertex box [cm]
    /// \param colinear - Cut on dot product to determin colinearity
    /// \param nseeddir - How many seed directions to check
    GridSearch(double xmn, double xmx,
               double ymn, double ymx,
               double zmn, double zmx,
               double colinear,
               unsigned int nseeddir);
    ///
    /// Add a vertex point to the list to be considered
    ///
    /// \param x,y,z - vertex location (cm)
    ///
    void AddVertex(double x, double y, double z);

    ///
    /// Add a collection of vertex seeds near the hit locations
    /// specified by f
    ///
    /// \param f - a list of percentages marking hits to choose
    ///
    void AddVtxPoints(const ElasticArms& arms,
                      const std::vector<double>& mx,
                      const std::vector<double>& bx,
                      const std::vector<double>& my,
                      const std::vector<double>& by,
                      const std::vector<double>& f);
    
    ///
    /// Produce a list of vertex seed locations from the hough
    /// analysis
    ///
    /// \param hrx - Hough results for the x view
    /// \param hry - Hough results for the y view
    /// \param nmx - Maximum number of hough results to use
    /// \param nmh - Number of hough lines to match in other view
    /// \param flipped - Used internally when hrx <-> hry
    ///
    void AddHoughIntersections(const rb::HoughResult& hrx,
                               const rb::HoughResult& hry,
                               unsigned int nmx,
                               unsigned int nmh,
                               bool flipped=false);
    ///
    /// Add a direction in spherical coordinates to the list of arm
    /// directions to be considered.
    ///
    /// \param theta, phi - spherical coordinates of arm direction
    ///
    void AddDirection(double theta, double phi);

    ///
    /// Make a list of some standard direction vectors
    ///
    void SetStandardDirections();
    
    ///
    /// Choose the direction of prong i which gives the least energy
    ///
    /// \return The best energy found in selecting this arm. Leaves
    /// arms in best state found.
    ///
    double ChooseBestProngDir(ElasticArms& arms, unsigned int i);
    
    ///
    /// Loop over vertex and direction seeds looking for the best
    /// choice.
    ///
    /// \return The best energy found. Leaves 'arms' in the best state
    /// found
    ///
    double FindBestVtx(ElasticArms& arms);
    
  public:
    double       fXmin;     ///< Only consider vertex locations inside a box [cm]
    double       fXmax;     ///< Only consider vertex locations inside a box [cm]
    double       fYmin;     ///< Only consider vertex locations inside a box [cm]
    double       fYmax;     ///< Only consider vertex locations inside a box [cm]
    double       fZmin;     ///< Only consider vertex locations inside a box [cm]
    double       fZmax;     ///< Only consider vertex locations inside a box [cm]
    double       fColinear; ///< |dot product|>fColinear means lines are colinear
    unsigned int fNseedDir; ///< How many default seed directoins to check

    std::vector<double> fX;     ///< List of vertex x coordinates
    std::vector<double> fY;     ///< List of vertex y coordinates
    std::vector<double> fZ;     ///< List of vertex z coorfinates
    std::vector<double> fTheta; ///< List of prong directions
    std::vector<double> fPhi;   ///< List of prong directions
  };
}

#endif
////////////////////////////////////////////////////////////////////////