ClusterMatchAlg.h

Go to the documentation of this file.

// \file ClusterMatchAlg.h
//
// \brief ClusterMatchAlg header file
//
// \author kazuhiro@nevis.columbia.edu
//

#ifndef CLUSTERMATCHALG_H
#define CLUSTERMATCHALG_H

// ART includes
namespace art {
  class Event;
}

#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"

namespace fhicl {
  class ParameterSet;
}

// LArSoft
namespace recob {
  class Cluster;
}
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/SpacePoint.h"

namespace detinfo {
  class DetectorClocksData;
  class DetectorPropertiesData;
}
namespace trkf {
  class SpacePointAlg;
}

// STL
#include <string>
#include <vector>

class TTree;

namespace cluster {
  class ClusterMatchAlg {

  public:
    enum MatchMethod_t {
      kRoughZ = 0,      
      kRoughT,          
      kSpacePoint,      
      kSumCharge,       
      kMATCH_METHOD_MAX 
    };

    struct cluster_match_info {

      unsigned short cluster_index; 
      geo::View_t view;             
      unsigned int nhits;           
      unsigned short wire_max;      
      unsigned short wire_min;      
      double start_time_max;        
      double peak_time_max;         
      double end_time_max;          
      double start_time_min;        
      double peak_time_min;         
      double end_time_min;          
      double sum_charge;            

      cluster_match_info(unsigned short index)
      {
        cluster_index = index;
        view = geo::kUnknown;
        wire_max = 0;
        wire_min = 0xffff;
        start_time_max = peak_time_max = end_time_max = -1.;
        start_time_min = peak_time_min = end_time_min = 1.e9;
        sum_charge = -1.;
      };

      cluster_match_info() { cluster_match_info(0xffff); };
    };

  public:
    ClusterMatchAlg(fhicl::ParameterSet const& pset);

    void ReportConfig() const;

    void SetMCTruthModName(std::string name) { _ModName_MCTruth = name; }

    void FillMCInfo(const art::Event& evt);

    void AppendClusterInfo(detinfo::DetectorPropertiesData const& det_prop,
                           const recob::Cluster& in_cluster,
                           const std::vector<art::Ptr<recob::Hit>>& in_hit_v);

    void MatchThreePlanes(detinfo::DetectorClocksData const& clock_data,
                          detinfo::DetectorPropertiesData const& det_prop);

    void MatchTwoPlanes(detinfo::DetectorClocksData const& clock_data,
                        detinfo::DetectorPropertiesData const& det_prop);

    std::vector<std::vector<unsigned int>> GetMatchedClusters() const;

    const std::vector<std::vector<recob::SpacePoint>>& GetMatchedSpacePoints() const
    {
      return _matched_sps_v;
    };

    bool StoreSpacePoints() const { return _store_sps; }

    void ClearEventInfo();

  protected:
    void ClearMatchInputInfo();

    void ClearMatchOutputInfo();

    void ClearTTreeInfo();

    void PrepareDetParams(detinfo::DetectorPropertiesData const& clockData);

    void PrepareTTree();

    void FillHitInfo(cluster_match_info& ci,
                     art::PtrVector<recob::Hit>& out_hit_v,
                     const std::vector<art::Ptr<recob::Hit>>& in_hit_v);

    void AppendClusterTreeVariables(const cluster_match_info& ci);

    bool Match_RoughZ(const cluster_match_info& ci1,
                      const cluster_match_info& ci2,
                      const geo::View_t v1,
                      const geo::View_t v2) const;

    bool Match_RoughTime(const cluster_match_info& ci1, const cluster_match_info& ci2);

    //bool Match_RoughTime(const cluster_match_info &ci1, const cluster_match_info &ci2, const cluster_match_info &ci3);

    bool Match_SumCharge(const cluster_match_info& uc, const cluster_match_info& vc);

    bool Match_SpacePoint(detinfo::DetectorClocksData const& clockData,
                          detinfo::DetectorPropertiesData const& detProp,
                          const size_t uindex,
                          const size_t vindex,
                          const size_t windex,
                          std::vector<recob::SpacePoint>& sps_v);

    //
    // Cut parameter values
    //
    size_t _num_sps_cut;        
    double _overlay_tratio_cut; 
    double _qratio_cut;         

    //
    // Resulting data holder for matched cluster indexes
    //
    std::vector<unsigned int> _matched_uclusters_v; 
    std::vector<unsigned int> _matched_vclusters_v; 
    std::vector<unsigned int> _matched_wclusters_v; 
    std::vector<std::vector<recob::SpacePoint>>
      _matched_sps_v; 

    //
    // Run control variables
    //
    bool _match_methods[kMATCH_METHOD_MAX]; 
    bool _det_params_prepared;
    bool _debug_mode; 
    bool _store_sps;  
    unsigned int _tot_planes;
    double _time_offset_uplane;
    double _time_offset_vplane;
    double _time_offset_wplane;

    std::string _ModName_MCTruth; 

    std::vector<art::PtrVector<recob::Hit>>
      _uhits_v; 
    std::vector<art::PtrVector<recob::Hit>>
      _vhits_v; 
    std::vector<art::PtrVector<recob::Hit>>
      _whits_v; 

    std::vector<cluster_match_info> _ucluster_v; 
    std::vector<cluster_match_info> _vcluster_v; 
    std::vector<cluster_match_info> _wcluster_v; 

    trkf::SpacePointAlg* _sps_algo; 

    //
    // Quality control parameters to be saved in the TTree
    //
    TTree* _match_tree;
    // Event-wise variables
    double _mc_E;
    double _mc_Px;
    double _mc_Py;
    double _mc_Pz;
    double _mc_Vx;
    double _mc_Vy;
    double _mc_Vz;
    int _pdgid;
    unsigned short _tot_u;
    unsigned short _tot_v;
    unsigned short _tot_w;
    unsigned short _tot_pass_qsum;
    unsigned short _tot_pass_t;
    unsigned short _tot_pass_z;
    unsigned short _tot_pass_sps;

    // Cluster-combination-wise variable
    std::vector<uint16_t> _u_nhits_v;
    std::vector<uint16_t> _v_nhits_v;
    std::vector<uint16_t> _w_nhits_v;
    std::vector<uint16_t> _nsps;
    std::vector<double> _qratio_v;
    std::vector<double> _uv_tratio_v;
    std::vector<double> _vw_tratio_v;
    std::vector<double> _wu_tratio_v;

    // Cluster-wise variable
    bool _save_cluster_info;
    TTree* _cluster_tree;
    std::vector<uint16_t> _view_v;
    std::vector<double> _charge_v;
    std::vector<uint16_t> _nhits_v;
    std::vector<double> _tstart_min_v;
    std::vector<double> _tstart_max_v;
    std::vector<double> _tpeak_min_v;
    std::vector<double> _tpeak_max_v;
    std::vector<double> _tend_min_v;
    std::vector<double> _tend_max_v;

  }; // class ClusterMatchAlg

} //namespace cluster
#endif