User custom analysis class made by SHELL_USER_NAME. More...

#include <LArImageHit.h>

Inheritance diagram for larlite::LArImageHit:

Public Member Functions
	LArImageHit (const std::string name="LArImageHit")
	Default constructor. More...

virtual	~LArImageHit ()
	Default destructor. More...

bool	initialize ()
	IMPLEMENT in LArImageClusterBase.cc! Initialization method to be called before the analysis event loop. More...

bool	analyze (storage_manager *storage)
	IMPLEMENT in LArImageClusterBase.cc! Analyze a data event-by-event. More...

bool	finalize ()
	IMPLEMENT in LArImageClusterBase.cc! Finalize method to be called after all events processed. More...

larcv::ImageClusterManager &	algo_manager (size_t plane_id)

const std::vector < larcv::ImageClusterManager > &	algo_manager_set () const

const std::string &	producer () const

void	set_config (const std::string cfg_file)

Protected Member Functions
void	store_clusters (storage_manager *storage)

void	extract_image (storage_manager *storage)

void	_Report_ () const

void	_Configure_ (const ::fcllite::PSet &pset)

Protected Attributes
::larcv::ImageManager	_img_mgr

Private Attributes
size_t	_num_stored

double	_charge_to_gray_scale

std::vector< size_t >	_num_clusters_v

std::vector< size_t >	_num_unclustered_hits_v

std::vector< size_t >	_num_clustered_hits_v

Detailed Description

User custom analysis class made by SHELL_USER_NAME.

Definition at line 28 of file LArImageHit.h.

Constructor & Destructor Documentation

larlite::LArImageHit::LArImageHit ( const std::string name = "LArImageHit")

inline

Default constructor.

Definition at line 33 of file LArImageHit.h.

       : LArImageClusterBase(name)
       , _num_stored(0)
       , _charge_to_gray_scale(10)
       , _num_clusters_v()
       , _num_unclustered_hits_v()
       , _num_clustered_hits_v()
     {}

virtual larlite::LArImageHit::~LArImageHit ( )

inlinevirtual

Default destructor.

Definition at line 43 of file LArImageHit.h.

43 {}

Member Function Documentation

void larlite::LArImageHit::_Configure_ ( const ::fcllite::PSet & pset)

protectedvirtual

Implements larlite::LArImageClusterBase.

Definition at line 14 of file LArImageHit.cxx.

References _charge_to_gray_scale.

   {
     _charge_to_gray_scale = pset.get<double>("Q2Gray");
   }

void larlite::LArImageHit::_Report_ ( ) const

protectedvirtual

Implements larlite::LArImageClusterBase.

Definition at line 19 of file LArImageHit.cxx.

References _num_clustered_hits_v, _num_clusters_v, _num_stored, and _num_unclustered_hits_v.

   {
     std::cout << "  # of clusters per plane ......... ";
     for(auto const& num : _num_clusters_v) std::cout << Form("%-6zu ",num);
     std::cout << " ... Average (per-event) ";
     for(size_t plane=0; plane<_num_clustered_hits_v.size(); ++plane) {
       double nclusters = _num_clusters_v[plane];
       std::cout << Form("%g ",nclusters / ((double)(_num_stored)));
     }
     std::cout << std::endl;
 
     std::cout << "  # of clustered hits per plane ... ";
     for(auto const& num : _num_clustered_hits_v) std::cout << Form("%-6zu ",num);
     std::cout << " ... Fractions: ";
     for(size_t plane=0; plane<_num_clustered_hits_v.size(); ++plane) {
       double clustered = _num_clustered_hits_v[plane];
       double unclustered = _num_unclustered_hits_v[plane];
       std::cout << Form("%g%% ",clustered/(clustered+unclustered));
     }
     std::cout << std::endl;
   }

larcv::ImageClusterManager & larlite::LArImageClusterBase::algo_manager ( size_t plane_id)

inherited

Definition at line 21 of file LArImageClusterBase.cxx.

References larlite::LArImageClusterBase::_alg_mgr_v.

   {
     if(plane_id >= _alg_mgr_v.size()) throw ::larcv::larbys("ImageClusterManager not found (invalid plane ID)!");
     return _alg_mgr_v[plane_id];
   }

const std::vector< larcv::ImageClusterManager > & larlite::LArImageClusterBase::algo_manager_set ( ) const

inherited

Definition at line 18 of file LArImageClusterBase.cxx.

References larlite::LArImageClusterBase::_alg_mgr_v.

Referenced by store_clusters().

19 { return _alg_mgr_v; }

bool larlite::LArImageClusterBase::analyze ( storage_manager * storage)

inherited

IMPLEMENT in LArImageClusterBase.cc! Analyze a data event-by-event.

Definition at line 52 of file LArImageClusterBase.cxx.

                                                             {
 
     _img_mgr.clear();
     _orig_img_mgr.clear();
 
     ::larcv::Watch watch_all, watch_one;
     watch_all.Start();
     watch_one.Start();
     this->extract_image(storage);
     _process_time_image_extraction += watch_one.WallTime();
       
     if(_store_original_img) {
       for(size_t plane=0; plane<_img_mgr.size(); ++plane) {
     ::cv::Mat img;
     _img_mgr.img_at(plane).copyTo(img);
     _orig_img_mgr.push_back(img,_img_mgr.meta_at(plane));
       }
     }
 
     if(_img_mgr.size() != _alg_mgr_v.size()) throw ::larcv::larbys("# of imaged created != # of planes!");
 
     for(size_t plane = 0; plane < _alg_mgr_v.size(); ++plane) {
 
       auto& alg_mgr = _alg_mgr_v[plane];
       auto const& img = _img_mgr.img_at(plane);
       auto const& meta = _img_mgr.meta_at(plane);
       if(!meta.num_pixel_row() || !meta.num_pixel_column()) continue;
       
       alg_mgr.Process(img,meta);
       
     }
 
     watch_one.Start();
     this->store_clusters(storage);
     _process_time_cluster_storage += watch_one.WallTime();
 
     _process_time_analyze += watch_all.WallTime();
     
     ++_process_count;
 
     return true;
   }

void larlite::LArImageHit::extract_image ( storage_manager * storage)

protectedvirtual

Implements larlite::LArImageClusterBase.

Definition at line 114 of file LArImageHit.cxx.

References _charge_to_gray_scale, larlite::LArImageClusterBase::_img_mgr, larcv::ImageManager::img_at(), larlite::LArImageClusterBase::producer(), and larcv::ImageManager::push_back().

   {
     
     auto const& geom = ::larutil::Geometry::GetME();
     const size_t nplanes = geom->Nplanes();
 
     auto ev_hit = storage->get_data<event_hit>(producer());
 
     if(ev_hit==nullptr) throw DataFormatException("Could not locate hit data product!");
     
     std::vector< std::pair<size_t,size_t> > wire_range_v(nplanes,std::pair<size_t,size_t>(1e12,0));
     std::vector< std::pair<size_t,size_t> > tick_range_v(nplanes,std::pair<size_t,size_t>(1e12,0));
     
     for(auto const& h : *ev_hit) {
       
       auto const& wid = h.WireID();
       
       auto& wire_range = wire_range_v[wid.Plane];
       if(wire_range.first  > wid.Wire) wire_range.first  = wid.Wire;
       if(wire_range.second < wid.Wire) wire_range.second = wid.Wire;
       
       auto& tick_range = tick_range_v[wid.Plane];
       size_t peak_time = (size_t)(h.PeakTime());
       if(tick_range.first  > peak_time    ) tick_range.first  = ( bool(peak_time) ? peak_time - 1 : 0 );
       if(tick_range.second < (peak_time+1)) tick_range.second = peak_time+1;
     }
     
     for(size_t plane=0; plane<nplanes; ++plane) {
       auto const& wire_range = wire_range_v[plane];
       auto const& tick_range = tick_range_v[plane];
       size_t nticks = tick_range.second - tick_range.first + 2;
       size_t nwires = wire_range.second - wire_range.first + 2;
       ::larcv::ImageMeta meta((double)nwires,(double)nticks,nwires,nticks,wire_range.first,tick_range.first);
       
       //if(!nticks || !nwires)
       //_img_mgr.push_back(cv::Mat(),meta);
       //else
       //_img_mgr.push_back(::cv::Mat(nwires, nticks, CV_32FC1, cvScalar(0.)),meta);
       _img_mgr.push_back(::cv::Mat(nwires, nticks, CV_8UC1, cvScalar(0.)),meta);
       //_img_mgr->emplace_back(std::move(mat));
       /*
       std::cout << "Creating ... " << wire_range.first << " => " << wire_range.second << " ... " << nwires
         << " : " << tick_range.first << " => " << tick_range.second << " ... " << nticks
         << " @ " << plane << std::endl;
       for(size_t x=0; x<nwires; ++x)
     for(size_t y=0; y<nticks; ++y) mat.at<unsigned char>(x,y) = (unsigned char)5;
       */
       //mat.at<unsigned char>(0,0) = (unsigned char)5;
     }
     
     for(auto const& h : *ev_hit) {
       
       auto const& wid = h.WireID();
       
       if(wid.Plane >= wire_range_v.size()) continue;
       
       auto& mat = _img_mgr.img_at(wid.Plane);
       
       //continue;
       auto const& wire_range = wire_range_v[wid.Plane];
       auto const& tick_range = tick_range_v[wid.Plane];
       
       size_t nticks = tick_range.second - tick_range.first + 2;
       size_t nwires = wire_range.second - wire_range.first + 2;
       
       size_t y = (size_t)(h.PeakTime()+0.5) - tick_range.first;
       size_t x = wid.Wire - wire_range.first;
       
       if(y>=nticks || x>=nwires) throw std::exception();
       
       //std::cout<<"Inserting " << x << " " << y << " @ " << wid.Plane << std::endl;
       double charge = h.Integral() / _charge_to_gray_scale;
       charge += (double)(mat.at<unsigned char>(x,y));
 
       if(charge>=255.) charge=255.;
       if(charge<0.) charge=0.;
       
       mat.at<unsigned char>(x,y) = (unsigned char)((int)charge);
     }
     
   }

bool larlite::LArImageClusterBase::finalize ( )

inherited

IMPLEMENT in LArImageClusterBase.cc! Finalize method to be called after all events processed.

Definition at line 113 of file LArImageClusterBase.cxx.

References larlite::LArImageClusterBase::_alg_mgr_v, and larlite::LArImageClusterBase::Report().

                                      {
 
     Report();
     for(size_t plane=0; plane < _alg_mgr_v.size(); ++plane) {
       std::cout << "  \033[95mImageClusterManager\033[00m @ Plane " << plane << std::endl;
       _alg_mgr_v[plane].Report();
       std::cout << std::endl;
     }
     return true;
   }

bool larlite::LArImageClusterBase::initialize ( )

inherited

IMPLEMENT in LArImageClusterBase.cc! Initialization method to be called before the analysis event loop.

Definition at line 27 of file LArImageClusterBase.cxx.

References larlite::LArImageClusterBase::_alg_mgr_v, larlite::LArImageClusterBase::_config_file, larlite::LArImageClusterBase::_Configure_(), larlite::LArImageClusterBase::_process_count, larlite::LArImageClusterBase::_process_time_analyze, larlite::LArImageClusterBase::_process_time_cluster_storage, larlite::LArImageClusterBase::_process_time_image_extraction, larlite::LArImageClusterBase::_producer, larlite::LArImageClusterBase::_profile, and larlite::LArImageClusterBase::_store_original_img.

                                        {
 
     ::fcllite::ConfigManager cfg_mgr(_name);
     
     cfg_mgr.AddCfgFile(_config_file);
 
     auto const& main_cfg = cfg_mgr.Config().get_pset(_name);
 
     _profile = main_cfg.get<bool>("Profile");
     _producer = main_cfg.get<std::string>("Producer");
     _store_original_img = main_cfg.get<bool>("StoreOriginalImage");
     _process_count = 0;
     _process_time_image_extraction = 0;
     _process_time_analyze = 0;
     _process_time_cluster_storage = 0;
 
     this->_Configure_(main_cfg);
 
     if(_producer.empty()) throw ::larcv::larbys("No producer specified...");
 
     for(auto& mgr : _alg_mgr_v) mgr.Configure(cfg_mgr.Config().get_pset(mgr.Name()));
 
     return true;
   }

const std::string& larlite::LArImageClusterBase::producer ( ) const

inlineinherited

Definition at line 58 of file LArImageClusterBase.h.

References larlite::LArImageClusterBase::_producer.

Referenced by larlite::LArImageWire::extract_image(), extract_image(), and store_clusters().

58 { return _producer; }

void larlite::LArImageClusterBase::set_config ( const std::string cfg_file)

inlineinherited

Definition at line 60 of file LArImageClusterBase.h.

References larlite::LArImageClusterBase::_config_file.

60 {_config_file=cfg_file;}

void larlite::LArImageHit::store_clusters ( storage_manager * storage)

protectedvirtual

Implements larlite::LArImageClusterBase.

Definition at line 41 of file LArImageHit.cxx.

References _num_clustered_hits_v, _num_clusters_v, _num_stored, _num_unclustered_hits_v, larlite::LArImageClusterBase::algo_manager_set(), larcv::kINVALID_CLUSTER_ID, and larlite::LArImageClusterBase::producer().

   {
     ++_num_stored;
     
     auto geom = ::larutil::Geometry::GetME();
     if(_num_clusters_v.empty()){
       _num_clusters_v.resize(geom->Nplanes(),0);
       _num_clustered_hits_v.resize(geom->Nplanes(),0);
       _num_unclustered_hits_v.resize(geom->Nplanes(),0);
     }
     
     auto ev_hit = storage->get_data<event_hit>(producer());
     
     if(!ev_hit) throw DataFormatException("Could not locate hit data product!");
 
     auto const& alg_mgr_v = algo_manager_set();
 
     std::vector<size_t> nclusters_v(alg_mgr_v.size(),0);
     size_t nclusters_total=0;
     for(size_t plane=0; plane<alg_mgr_v.size(); ++plane) {
       nclusters_v[plane] = alg_mgr_v[plane].Clusters().size();
       _num_clusters_v[plane] += nclusters_v[plane];
       nclusters_total += nclusters_v[plane];
     }
 
     AssSet_t ass_set;
     ass_set.resize(nclusters_total);
     for(auto& ass_unit : ass_set) ass_unit.reserve(100);
     
     for(size_t hindex=0; hindex<ev_hit->size(); ++hindex) {
 
       auto const& h = (*ev_hit)[hindex];
 
       auto const& wid = h.WireID();
 
       auto const& alg_mgr = alg_mgr_v[wid.Plane];
 
       auto const& cid = alg_mgr.ClusterID(wid.Wire,h.PeakTime());
 
       if(cid == ::larcv::kINVALID_CLUSTER_ID) {
     _num_unclustered_hits_v[wid.Plane] += 1;
     continue;
       }
 
       _num_clustered_hits_v[wid.Plane] += 1;
       
       size_t cindex = cid;
       for(size_t plane=0; plane<wid.Plane; ++plane) cindex += nclusters_v[plane];
 
       ass_set[cindex].push_back(hindex);
     }
 
     auto ev_cluster = storage->get_data<event_cluster>("ImageClusterHit");
     auto ev_ass     = storage->get_data<event_ass>("ImageClusterHit");
     if(ev_cluster) {
       ev_cluster->reserve(nclusters_total);
       for(size_t plane=0; plane<nclusters_v.size(); ++plane) {
     
     for(size_t cid=0; cid<nclusters_v[plane]; ++cid) {
 
       ::larlite::cluster c;
       c.set_view(geom->PlaneToView(plane));
       c.set_planeID(geo::PlaneID(0,0,plane));
       c.set_id(ev_cluster->size());
 
       ev_cluster->push_back(c);
     }
       }
     }
     if(ev_ass)
       ev_ass->set_association(ev_cluster->id(),ev_ass->id(),ass_set);
   }