.. _program_listing_file_larflow_CRTMatch_CRTTrackMatch.h:

Program Listing for File CRTTrackMatch.h
========================================

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

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

.. code-block:: cpp

   #ifndef __LARFLOW_CRTTRACK_MATCH_H__
   #define __LARFLOW_CRTTRACK_MATCH_H__
   
   #include <vector>
   
   #include "larcv/core/Base/larcv_base.h"
   #include "larcv/core/DataFormat/Image2D.h"
   #include "larcv/core/DataFormat/IOManager.h"
   #include "larlite/core/DataFormat/storage_manager.h"
   #include "larlite/core/DataFormat/crttrack.h"
   #include "larlite/core/DataFormat/opflash.h"
   #include "larlite/core/DataFormat/larflowcluster.h"
   #include "larlite/core/LArUtil/SpaceChargeMicroBooNE.h"
   
   #include "larflow/Reco/cluster_functions.h"
   
   namespace larflow {
   namespace crtmatch {
   
     class CRTTrackMatch : public larcv::larcv_base {
   
     public:
   
       CRTTrackMatch();
       virtual ~CRTTrackMatch();
   
       void process( larcv::IOManager& iolcv, larlite::storage_manager& ioll );
   
   
       void set_max_iters( int tries ) { _max_iters = tries; };
   
       void set_col_neighborhood( int cols )   { _col_neighborhood = cols; };
   
       void set_max_fit_step_size( float cm )  { _max_fit_step_size = cm; };
   
       void set_max_last_step_size( float cm ) { _max_last_step_size = cm; };
   
       void make_debug_images( bool make_debug ) { _make_debug_images = make_debug; };
       
       void save_to_file( larlite::storage_manager& ioll, bool remove_if_no_flash=true );
       void clear_output_containers();
   
       struct crttrack_t {
   
         int crt_track_index;                 
         const larlite::crttrack* pcrttrack;  
   
         std::vector< std::vector<double> >   hit_pos_vv;      
         std::vector< std::vector< int > >    pixellist_vv[3]; 
         std::vector< float >                 pixelrad_vv[3];  
         std::vector< std::vector< double > > pixelpos_vv;     
         std::vector< std::vector<int> >      pixelcoord_vv;   
         std::vector< float >                 totalq_v;        
         std::vector< float >                 toterr_v;        
         float                                len_intpc_sce;   
         float                                t0_usec;         
   
         int opflash_index;                                    
         const larlite::opflash*  opflash;                     
   
         crttrack_t()
         : crt_track_index(-1),
           pcrttrack( nullptr ),
           totalq_v( {0,0,0} ),
           toterr_v( {0,0,0} ),
           len_intpc_sce(0.0)
         {};
         crttrack_t( int idx, const larlite::crttrack* ptrack )
         : crt_track_index(idx),
           pcrttrack( ptrack ),
           totalq_v( {0,0,0} ),
           toterr_v( {0,0,0} ),
           len_intpc_sce(0.0)
         {};
         
       };
   
       // methods
       crttrack_t _find_optimal_track( const larlite::crttrack& crt,
                                       const std::vector<larcv::Image2D>& adc_v );
   
       
       crttrack_t _collect_chargepixels_for_track( const std::vector<double>& hit1_pos,
                                                   const std::vector<double>& hit2_pos,
                                                   const float t0_usec,
                                                   const std::vector<larcv::Image2D>& adc_v,
                                                   const float max_step_size,
                                                   const int col_neighborhood );
       
       bool _propose_corrected_track( const CRTTrackMatch::crttrack_t& old,
                                      std::vector< double >& hit1_new,
                                      std::vector< double >& hit2_new );
   
       bool _crt_intersections( larflow::reco::cluster_t& track_cluster,
                                const larlite::crttrack& orig_crttrack,
                                std::vector< std::vector<double> >& panel_pos_v,
                                std::vector< double >& dist2_original_hits );
       
   
   
       std::string _str( const CRTTrackMatch::crttrack_t& data );
   
       void _matchOpflashes( std::vector< const larlite::event_opflash* > flash_vv,
                             const std::vector<CRTTrackMatch::crttrack_t>& tracks_v,
                             std::vector< larlite::opflash >& matched_opflash_v );
       
       larlite::larflowcluster _crttrack2larflowcluster( const CRTTrackMatch::crttrack_t& fitdata );    
   
       larutil::SpaceChargeMicroBooNE* _sce;          
       larutil::SpaceChargeMicroBooNE* _reverse_sce;  
   
       
       int _max_iters;            
       int _col_neighborhood;     
       float _max_fit_step_size;  
       float _max_last_step_size; 
       float _max_dt_flash_crt;   
       std::string _adc_producer; 
       std::string _crttrack_producer; 
       std::vector<std::string> _opflash_producer_v;  
       bool _make_debug_images;   
   
     public:
   
       void setADCtreename( std::string treename ) { _adc_producer=treename; }; 
   
     protected:
       
       
       std::vector< crttrack_t >        _fitted_crttrack_v;   
       std::vector< larlite::opflash >  _matched_opflash_v;   
       std::vector< larlite::crttrack > _modified_crttrack_v; 
       std::vector< larlite::larflowcluster > _cluster_v;     
   
     public:
   
       const std::vector< larlite::larflowcluster >& getClusters() { return _cluster_v; }; 
   
     };
     
   }
   }
   
   #endif