fuzzyClusterAlg.h

Go to the documentation of this file.

#ifndef fuzzyClusterALG_H
#define fuzzyClusterALG_H

// Standard C/C++ libraries
#include <vector>
#include <set>
#include <stdint.h> // uint32_t

// ART and support libraries
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Persistency/Common/Ptr.h"

// LArSoft libraries
#include "larcore/Geometry/Geometry.h"
#include "larreco/RecoAlg/HoughBaseAlg.h"
#include "larreco/RecoAlg/DBScanAlg.h"

namespace fhicl { class ParameterSet; }

namespace recob { class Hit; }

namespace cluster {
  
  //--------------------------------------------------------------- 
  class fuzzyClusterAlg {
  public:
    
    
    fuzzyClusterAlg(fhicl::ParameterSet const& pset);
    virtual ~fuzzyClusterAlg();
    
    void reconfigure(fhicl::ParameterSet const& p);
    void InitFuzzy(std::vector<art::Ptr<recob::Hit> >& allhits, std::set<uint32_t> badChannels);
    // Three differnt version of the clustering code
    void run_fuzzy_cluster(const std::vector<art::Ptr<recob::Hit> >& allhits);
   

    std::vector<std::vector<unsigned int> > fclusters;               
    std::vector<std::vector<double> >       fps;                     
    std::vector<unsigned int>               fpointId_to_clusterId;   
    std::vector<std::vector<double> >       fsim;                    
    std::vector<std::vector<double> >       fsim2;                   
    std::vector<std::vector<double> >       fsim3;                   
    double fMaxWidth;

    // Get functions and structures from HoughBaseAlg
    //friend class HoughBaseAlg;

   

   //double **data = NULL;
   std::vector<std::vector<double>> data;




  private:
    
    // privately defined
    class baseCluster;
    class trackCluster;
    class showerCluster;


    double  fNumberTimeBoundaries;          
    double  fNumberWireBoundaries;          

    // Run the Hough line finder?
    bool    fRunHough;
    bool    fGenerateHoughLinesOnly;            

    bool    fDoFuzzyRemnantMerge;           
    double  fFuzzyRemnantMergeCutoff;       

    bool    fDoTrackClusterMerge;           
    double  fTrackClusterMergeCutoff;          
    double  fChargeAsymAngleCut;            
    double  fSigmaChargeAsymAngleCut;       
  
    bool    fDoShowerClusterMerge;          
    double  fShowerClusterMergeAngle;       
    double  fShowerClusterMergeCutoff;    

    bool    fDoShowerTrackClusterMerge;     
    double  fShowerTrackClusterMergeCutoff;    
    double  fShowerTrackClusterMergeAngle;  
    
    double  fShowerLikenessCut;             

    int    fMaxVertexLines;                
    double  fVertexLinesCutoff;             







    void mergeHoughLinesBySegment(unsigned int k,
        std::vector<protoTrack> *protoTracks, 
        double xyScale,
        int mergeStyle,
        double wire_dist,
        double tickToDist);

    bool mergeTrackClusters(unsigned int k,
        std::vector<trackCluster> *trackClusters, 
        double xyScale,
        double wire_dist,
        double tickToDist);

    bool mergeShowerClusters(unsigned int k,
        std::vector<showerCluster> *showerClusters, 
        double xyScale,
        double wire_dist,
        double tickToDist);
    
    bool mergeShowerTrackClusters(showerCluster *showerClusterI, 
        trackCluster *trackClusterJ, 
        double xyScale,
        double wire_dist,
        double tickToDist);

    //std::vector<lineSlope> linesFound;
    double HoughLineDistance(double p0MinLine1, 
        double p1MinLine1, 
        double p0MaxLine1, 
        double p1MaxLine1, 
        double p0MinLine2, 
        double p1MinLine2, 
        double p0MaxLine2, 
        double p1MaxLine2);
    bool   HoughLineIntersect(double x11,
        double  y11,
        double  x12,
        double  y12,
        double  x21,
        double  y21,
        double  x22,
        double  y22);
    double PointSegmentDistance(double px,
        double  py,
        double  x1,
        double  y1,
        double  x2,
        double  y2);

    double DistanceBetweenHits(
        art::Ptr<recob::Hit> hit0,
        art::Ptr<recob::Hit> hit1,
        double wire_dist,
        double tickToDist);

    // noise vector
    std::vector<bool>      fnoise;      
    std::vector<bool>      fvisited;                                         
    std::vector<double>    fWirePitch;     
    std::set<uint32_t>     fBadChannels;   
    std::vector<uint32_t>  fBadWireSum;    

    


    //void IntArray_Push( IntArray *self, int value );


    // Object used for Hough transforms
    HoughBaseAlg fHBAlg;

    // Object used for DBScan
    DBScanAlg fDBScan;

    art::ServiceHandle<geo::Geometry> fGeom; 

  }; // class fuzzyClusterAlg
    




} // namespace

#endif // ifndef fuzzyClusterALG_H