ClusterParamsAlg.h

Go to the documentation of this file.

// ClusterParamsAlg.h
//
// ClusterParamsAlg class
//
// Andrzej Szelc (andrzej.szelc@yale.edu)
//
#ifndef CLUSTERPARAMSALG_H
#define CLUSTERPARAMSALG_H

//--- std/stl include ---//
#include <vector>
//--- ROOT include ---//
#include <TMath.h>
#include <TH2F.h>
#include <TF1.h>
#include <TH1F.h>
#include <TPrincipal.h>
#include <TCanvas.h>
#include <TLegend.h>

//--- LArSoft include ---//
#include "lardata/Utilities/GeometryUtilities.h"
#include "ClusterParams.h"
#include "CRUException.h"

//#include "LArUtilManager.hh"
//#include "FANNService.hh"

//#include "DataFormat-TypeDef.hh"
//#include "LArUtil-TypeDef.hh"
//#include "HoughBaseAlg.hh"

#include "TPrincipal.h"
#include "TStopwatch.h"

// ... more #include in tempimplementation below

namespace cluster {
   
  class ClusterParamsAlg {

  public:

    ClusterParamsAlg();

//    /// Alternative constructor with larlight's hits
//    ClusterParamsAlg(const std::vector<const ::larlite::hit*>&);

    ClusterParamsAlg(const std::vector<util::PxHit>&);

    ~ClusterParamsAlg(){}

    void Initialize();

    //void SetHits(const std::vector<larutil::PxHit*>&);

    void SetMinNHits(size_t nhit) { fMinNHits = nhit; }

    size_t MinNHits() const { return fMinNHits; }
    
   // int SetHits(const std::vector<const ::larlite::hit*> &);

    int SetHits(const std::vector<util::PxHit> &);

    void SetRefineDirectionQMin(double qmin){ fQMinRefDir = qmin; }

    void SetVerbose(bool yes=true){ verbose = yes;}

   // void SetArgoneutGeometry();

    template <typename Stream>
    void Report(Stream& stream) const;

    template <typename Stream>
    void TimeReport(Stream& stream) const;

    void  GetFANNVector(std::vector<float> & data);
    // std::vector<float> & GetFANNVector();

    void  PrintFANNVector();


    void FillParams(bool override_DoGetAverages      =false,
                    bool override_DoGetRoughAxis     =false,
                    bool override_DoGetProfileInfo   =false,
                    bool override_DoRefineStartPointsAndDirection=false,
                            // bool override_DoRefineDirection  =false,
                    bool override_DoGetFinalSlope    =false,
                    bool override_DoTrackShowerSep   =false,
                    bool override_DoEndCharge = false);

    const cluster_params& GetParams() const
    { return fParams;}

    void GetAverages(bool override=false);


    //void GetRoughAxis(bool override=false);
    void GetRoughAxis(bool override=false);


    void GetProfileInfo(bool override=false);


    void RefineStartPoints(bool override=false);

    void GetFinalSlope(bool override=false);

    void GetEndCharges(bool override_ = false);

    void RefineDirection(bool override=false);

    void RefineStartPointAndDirection(bool override=false);

    void TrackShowerSeparation(bool override=false);

    void setNeuralNetPath(std::string s){fNeuralNetPath = s;}

    void FillPolygon();

    void GetOpeningAngle();

    const util::PxPoint& RoughStartPoint() {return fRoughBeginPoint;}
    const util::PxPoint& RoughEndPoint() {return fRoughEndPoint;}

    double RoughSlope() {return fRough2DSlope;}
    double RoughIntercept() {return fRough2DIntercept;}
    
    double StartCharge(float length = 1., unsigned int nbins = 10);
    
    double EndCharge(float length = 1., unsigned int nbins = 10);
    
    float MultipleHitWires();

    float MultipleHitDensity();

    
    void EnableFANN();

    void DisableFANN(){enableFANN = false;}

    size_t GetNHits() const {return fHitVector.size();}
    const std::vector<util::PxHit>& GetHitVector() const {return fHitVector;}
    int Plane() const {return fPlane;}
    void SetPlane(int p);

  protected:
    
    util::GeometryUtilities  *fGSer;

    size_t fMinNHits;

    std::vector<util::PxHit> fHitVector;

    // bool to control debug/verbose mode
    // defaults to off.
    bool verbose;

    //settable parameters:
    std::vector<double> fChargeCutoffThreshold;
    int fPlane;

    //this is required in RefineDirection
    double fQMinRefDir;
    
    std::vector< double > fChargeProfile;
    std::vector< double > fCoarseChargeProfile;
    
    std::vector< double > fChargeProfileNew;
   // double fMaxLinLength;
   // double fLinBins;
    
    int fCoarseNbins;
    int fProfileNbins;
    int fProfileMaximumBin;
    double fProfileIntegralForward;
    double fProfileIntegralBackward;
    double fProjectedLength;
    
    //extreme intercepts using the rough_2d_slope
   // double fInterHigh;
   // double fInterLow;
    double fBeginIntercept;
    double fEndIntercept;
    double fInterHigh_side;
    double fInterLow_side;
    
    // book keeping variables to validate completion of methods:
    bool fFinishedGetAverages;       
    bool fFinishedGetRoughAxis;      
    bool fFinishedGetProfileInfo;    
    bool fFinishedRefineStartPoints; 
    bool fFinishedRefineDirection;   
    bool fFinishedGetFinalSlope;     
    bool fFinishedRefineStartPointAndDirection;
    bool fFinishedTrackShowerSep;
    bool fFinishedGetEndCharges;

    double fRough2DSlope;        // slope 
    double fRough2DIntercept;    // slope 
    util::PxPoint fRoughBeginPoint;
    util::PxPoint fRoughEndPoint;
    bool enableFANN;

    double IntegrateFitCharge(
      double from_length, double to_length,
      unsigned int fit_first_bin, unsigned int fit_end_bin
      );
    
    static double LinearIntegral(double m, double q, double x1, double x2);
    
    public:

    cluster::cluster_params fParams;

    std::string fNeuralNetPath;

    std::vector<std::string> fTimeRecord_ProcName;
    std::vector<double> fTimeRecord_ProcTime;

  }; //class ClusterParamsAlg
  
} //namespace cluster


//------------------------------------------------------------------------------
//--- template implementation
//---

#include <ostream> // std::endl

namespace cluster {
  
  template <typename Stream>
  void ClusterParamsAlg::TimeReport(Stream& stream) const {
    
    stream << "  <<ClusterParamsAlg::TimeReport>> starts..."<<std::endl;
    for(size_t i=0; i<fTimeRecord_ProcName.size(); ++i){
      
      stream << "    Function: " 
        << fTimeRecord_ProcName[i].c_str() 
        << " ... Time = " 
        << fTimeRecord_ProcTime[i]
        << " [s]"
        << std::endl;
      
    }
    stream<< "  <<ClusterParamsAlg::TimeReport>> ends..."<<std::endl;
  }
  
} //namespace cluster

#endif