.. _program_listing_file_larflow_CRTMatch_CRTHitMatch.h:

Program Listing for File CRTHitMatch.h
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_larflow_CRTMatch_CRTHitMatch.h>` (``larflow/CRTMatch/CRTHitMatch.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef __LARFLOW_RECO_CRTHITMATCH_H__
   #define __LARFLOW_RECO_CRTHITMATCH_H__
   
   #include <vector>
   #include "larcv/core/Base/larcv_base.h"
   #include "larcv/core/DataFormat/IOManager.h"
   #include "DataFormat/storage_manager.h"
   #include "DataFormat/crthit.h"
   #include "DataFormat/crttrack.h"
   #include "DataFormat/opflash.h"
   #include "DataFormat/pcaxis.h"
   #include "DataFormat/larflowcluster.h"
   
   #include "larflow/Reco/cluster_functions.h"
   
   namespace larflow {
   namespace crtmatch {
   
     class CRTHitMatch : public larcv::larcv_base {
   
     public:
   
       struct match_t {
         int hitidx;   
         int trackidx; 
         // variables to rank matches
         float dist2hit; 
         float tracklen; 
   
         bool operator<( const match_t& rhs ) {
           // for distances over 10 cm, we rank by distance
           if ( dist2hit<rhs.dist2hit )
             return true;
           return false;
         };
   
       };
       
       CRTHitMatch()
         : larcv::larcv_base("CRTHitMatch"),
         _input_cluster_treename("pcacluster"),
         _input_pcaxis_treename("pcacluster")
         {};
       virtual ~CRTHitMatch() {};
       
       void addIntimeOpFlashes( const larlite::event_opflash& opflash_v );
       void addCosmicOpFlashes( const larlite::event_opflash& opflash_v );
       void addCRThits( const larlite::event_crthit& crthit_v );
       void addCRTtracks( const larlite::event_crttrack& crttrack_v );
       void addLArFlowClusters( const larlite::event_larflowcluster& lfcluster_v, const larlite::event_pcaxis& pcaxis );
   
       void clear();
       bool process( larcv::IOManager& iocv, larlite::storage_manager& ioll );
       void save_to_file( larlite::storage_manager& outll, bool remove_if_no_flash=true );
       
       bool makeMatches();
       void compilematches();
       void printHitInfo();
   
       float makeOneMatch( const larlite::pcaxis& lfcluster_axis, const larlite::crthit& hit, std::vector<float>& panel_pos );
       float getLength( const larlite::pcaxis& pca );
   
       bool was_cluster_used( int idx );
   
       // data stores   
       std::vector<larlite::opflash> _intime_opflash_v;  
       std::vector<larlite::opflash> _outtime_opflash_v; 
       std::vector< const larlite::opflash* > _flash_v;  
       
       // crt hits
       std::vector<larlite::crthit>   _crthit_v;    
       std::vector<larlite::crttrack> _crttrack_v;  
       
       // clusters
       std::string _input_cluster_treename; 
       std::string _input_pcaxis_treename;  
   
       void setInputClusterTreename( std::string name ) { _input_cluster_treename = name; };
       void setInputPCAxisTreename( std::string name ) { _input_pcaxis_treename = name; };
       std::vector< const larlite::larflowcluster* > _lfcluster_v;   
       std::vector< const larlite::pcaxis* >         _pcaxis_v;      
   
   
       std::vector< std::vector< match_t > >         _hit2track_rank_v; 
       std::vector< match_t >                        _all_rank_v;       
   
   
       void _matchOpflashes( const std::vector< const larlite::opflash* >& flash_v,
                             const std::vector< const larlite::crthit* >&  hit_v,
                             const std::vector< larlite::larflowcluster >& cluster_v,
                             std::vector< larlite::opflash >& matched_opflash_v );
       
       
       larlite::larflowcluster _merge_matched_cluster( const std::vector< CRTHitMatch::match_t >& hit_match_v,
                                                       std::vector<int>& used_in_merge,
                                                       bool& merged );
   
       // output containers
       std::vector<int>                       _matched_hitidx;    
       std::vector< const larlite::crthit* >  _match_hit_v;       
       std::vector<larlite::larflowcluster>   _matched_cluster;   
       std::vector<larflow::reco::cluster_t>  _matched_cluster_t; 
       std::vector< larlite::opflash >        _matched_opflash_v; 
       std::vector<int>                       _used_tracks_v;     
       
     };
     
   }
   }
   
   #endif