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
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "art/Framework/Services/Registry/ServiceMacros.h"
#include "art/Framework/Services/Optional/TFileService.h"
#include "art/Framework/Services/Optional/TFileDirectory.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"

// LArSoft
#include "nusimdata/SimulationBase/MCTruth.h"
#include "nusimdata/SimulationBase/MCParticle.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/Cluster.h"
#include "lardataobj/RecoBase/SpacePoint.h"
#include "larreco/RecoAlg/SpacePointAlg.h"
#include "lardata/DetectorInfoServices/DetectorPropertiesService.h"
#include "larcore/Geometry/Geometry.h"
// STL
#include <set>
#include <vector>

// ROOT
#include <TString.h>
#include <TTree.h>

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);
    //ClusterMatchAlg(fhicl::ParameterSet const& pset, art::ActivityRegistry& reg);

    virtual ~ClusterMatchAlg(){};

    void ReportConfig() const;

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

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

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

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

    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();

    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(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