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

#include <string>
#include <vector>

#include "lardata/Utilities/PxUtils.h"
#include "larreco/RecoAlg/ClusterRecoUtil/ClusterParams.h"

namespace util {
  class GeometryUtilities;
}

namespace cluster {

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

    void Initialize();

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

    size_t MinNHits() const { return fMinNHits; }

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

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

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

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

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

    void PrintFANNVector();

    void FillParams(util::GeometryUtilities const& gser,
                    bool override_DoGetAverages = false,
                    bool override_DoGetRoughAxis = false,
                    bool override_DoGetProfileInfo = false,
                    bool override_DoRefineStartPointsAndDirection = 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 GetProfileInfo(util::GeometryUtilities const& gser, bool override = false);

    void RefineStartPoints(util::GeometryUtilities const& gser);

    void GetFinalSlope(util::GeometryUtilities const& gser, bool override = false);

    void GetEndCharges(util::GeometryUtilities const& gser, bool override_ = false);

    void RefineDirection(bool override = false);

    void RefineStartPointAndDirection(util::GeometryUtilities const& gser, bool override = false);

    void TrackShowerSeparation(bool override = false);

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

    void FillPolygon(util::GeometryUtilities const& gser);

    void GetOpeningAngle();

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

    double RoughSlope() { return fRough2DSlope; }
    double RoughIntercept() { return fRough2DIntercept; }

    double StartCharge(util::GeometryUtilities const& gser,
                       float length = 1.,
                       unsigned int nbins = 10);

    double EndCharge(util::GeometryUtilities const& gser,
                     float length = 1.,
                     unsigned int nbins = 10);

    float MultipleHitWires();

    float MultipleHitDensity(util::GeometryUtilities const& gser);

    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:
    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;

    int fCoarseNbins;
    int fProfileNbins;
    int fProfileMaximumBin;
    double fProfileIntegralForward;
    double fProfileIntegralBackward;
    double fProjectedLength;

    //extreme intercepts using the rough_2d_slope
    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(util::GeometryUtilities const& gser,
                              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
//---

namespace cluster {

  template <typename Stream>
  void ClusterParamsAlg::TimeReport(Stream& stream) const
  {

    stream << "  <<ClusterParamsAlg::TimeReport>> starts...\n";
    for (size_t i = 0; i < fTimeRecord_ProcName.size(); ++i) {

      stream << "    Function: " << fTimeRecord_ProcName[i].c_str()
             << " ... Time = " << fTimeRecord_ProcTime[i] << " [s]\n";
    }
    stream << "  <<ClusterParamsAlg::TimeReport>> ends...\n";
  }

} //namespace cluster

#endif