Program Listing for File PrepKeypointData.h

↰ Return to documentation for file (larflow/KeyPoints/PrepKeypointData.h)

#ifndef __PREP_KEYPOINT_DATA_H__
#define __PREP_KEYPOINT_DATA_H__

#include <Python.h>
#include "bytesobject.h"

#include <vector>
#include <string>

#include "larflow/LArFlowConstants/LArFlowConstants.h"
#include "larflow/PrepFlowMatchData/PrepMatchTriplets.h"

#include "KPdata.h"

class TH1F;
class TH2D;

namespace larcv {
  class Image2D;
  class IOManager;
}

namespace larlite {
  class event_mctrack;
  class event_mcshower;
  class event_mctruth;
  class storage_manager;
}

namespace larutil {
  class SpaceChargeMicroBooNE;
}

namespace ublarcvapp {
namespace mctools {
  class MCPixelPGraph;
}
}

namespace larflow {
namespace keypoints {


  class PrepKeypointData {
  public:

    PrepKeypointData();
    virtual ~PrepKeypointData();

    void process( larcv::IOManager& iolcv,
                  larlite::storage_manager& ioll );

    void process( const std::vector<larcv::Image2D>&    adc_v,
                  const std::vector<larcv::Image2D>&    badch_v,
                  const std::vector<larcv::Image2D>&    segment_v,
                  const std::vector<larcv::Image2D>&    instance_v,
                  const std::vector<larcv::Image2D>&    ancestor_v,
                  const larlite::event_mctrack&  mctrack_v,
                  const larlite::event_mcshower& mcshower_v,
                  const larlite::event_mctruth&  mctruth_v );

    void make_proposal_labels( const larflow::prep::PrepMatchTriplets& match_proposals );

  protected:

    std::string _adc_image_treename;


    std::vector<KPdata> _kpd_v;

    std::vector<KPdata>
      getMuonEndpoints( ublarcvapp::mctools::MCPixelPGraph& mcpg,
                        const std::vector<larcv::Image2D>& adc_v,
                        const larlite::event_mctrack& mctrack_v,
                        larutil::SpaceChargeMicroBooNE* psce );

    std::vector<KPdata>
      getShowerStarts( ublarcvapp::mctools::MCPixelPGraph& mcpg,
                       const std::vector<larcv::Image2D>& adc_v,
                       const larlite::event_mcshower& mcshower_v,
                       larutil::SpaceChargeMicroBooNE* psce );

    void _label_nu_keypoints( const larlite::event_mctruth& mctruth_v,
                              const std::vector<larcv::Image2D>& adc_v,
                              larutil::SpaceChargeMicroBooNE* psce,
                              std::vector<KPdata>& kpdata_v  );

    void filter_duplicates();

  public:

    void setADCimageTreeName(std::string treename) { _adc_image_treename=treename; };

    const std::vector<KPdata>& getKPdata() const { return _kpd_v; };

    void printKeypoints() const;

  public:

    PyObject* get_keypoint_array(int ikpclass ) const;
    PyObject* get_triplet_score_array( float sig ) const;


  protected:

    // PROPOSAL LABELS
    // ----------------

    std::vector< std::vector<float> > _match_proposal_labels_v[3];

    // Ana Tree
    int _run;
    int _subrun;
    int _event;
    TTree* _label_tree;
    std::vector< std::vector<float> > _kppos_v[3];
    //< we need to keep a list of primary pixels to limit the neutrino score field
    //std::vector< std::set<std::pair<int,int> > >  _primarypixels_v;

  public:

    void defineAnaTree();
    void writeAnaTree();

    void fillAnaTree() { if (_label_tree) _label_tree->Fill(); };

  public:

    // statistics variables
    TH1F* hdist[3];
    TH1F* hdpix[4];
    int _nclose;
    int _nfar;
    void writeHists();

    std::vector<TH2D> makeScoreImage( const int ikpclass, const float sigma,
                                      const std::string histname,
                                      const larflow::prep::PrepMatchTriplets& tripmaker,
                                      const std::vector<larcv::Image2D>& adc_v ) const;

  private:

    static bool _setup_numpy;

  };

}
}

#endif