#include <CMergeManager.h>

Inheritance diagram for cmtool::CMergeManager:

Public Member Functions
	CMergeManager ()

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

virtual void	Reset ()
	Method to reset itself. More...

void	AddMergeAlgo (CBoolAlgoBase *algo)
	A simple method to add an algorithm for merging. More...

void	AddSeparateAlgo (CBoolAlgoBase *algo)
	A simple method to add an algorithm for separation. More...

const std::vector < cluster::ClusterParamsAlg > &	GetClusters () const
	A method to obtain output clusters. More...

const CMergeBookKeeper &	GetBookKeeper () const
	A method to obtain book keeper. More...

Public Member Functions inherited from cmtool::CMManagerBase
	CMManagerBase ()
	Default constructor. More...

virtual	~CMManagerBase ()=default
	Default destructor. More...

void	DebugMode (CMMSGLevel_t level)
	Method to enable debug mode (lots of couts) More...

void	ReportTimings (bool time_report=true)
	Method to enable timing profile cout. More...

void	Reset ()
	Method to reset itself. More...

void	AddPriorityAlgo (CPriorityAlgoBase *algo)
	Setter to add an algorithm for priority determination. More...

void	MergeTillConverge (bool doit=true)
	Switch to continue merging till converges. More...

void	SetClusters (util::GeometryUtilities const &gser, const std::vector< std::vector< util::PxHit >> &clusters)
	A simple method to add a cluster. More...

void	SetClusters (const std::vector< cluster::ClusterParamsAlg > &clusters)
	A simple method to add a cluster. More...

const std::vector < cluster::ClusterParamsAlg > &	GetInputClusters () const
	A getter for input clusters. More...

void	SetMinNHits (unsigned int n)
	A setter for minimum # of hits ... passed onto ClusterParamsAlg. More...

void	Process (util::GeometryUtilities const &gser)
	A method to execute the main action, to be called per event. More...

void	SetAnaFile (TFile *fout)
	A setter for an analysis output file. More...

Protected Member Functions
virtual void	EventBegin ()
	FMWK function called @ beginning of Process() More...

virtual void	IterationBegin ()
	FMWK function called @ beginning of iterative loop inside Process() More...

virtual bool	IterationProcess (util::GeometryUtilities const &gser)
	FMWK function called @ iterative loop inside Process() More...

virtual void	IterationEnd ()
	FMWK function called @ end of iterative loop inside Process() More...

virtual void	EventEnd ()
	FMWK function called @ end of Process() More...

void	RunMerge (const std::vector< cluster::ClusterParamsAlg > &in_clusters, CMergeBookKeeper &book_keeper) const

void	RunMerge (const std::vector< cluster::ClusterParamsAlg > &in_clusters, const std::vector< bool > &merge_flag, CMergeBookKeeper &book_keeper) const

void	RunSeparate (const std::vector< cluster::ClusterParamsAlg > &in_clusters, CMergeBookKeeper &book_keeper) const

Protected Member Functions inherited from cmtool::CMManagerBase
void	ComputePriority (const std::vector< cluster::ClusterParamsAlg > &clusters)
	Function to compute priority. More...

Protected Attributes
std::vector < cluster::ClusterParamsAlg >	_out_clusters
	Output clusters. More...

CMergeBookKeeper	_book_keeper
	Book keeper instance. More...

::cmtool::CBoolAlgoBase *	_merge_algo
	Merging algorithm. More...

::cmtool::CBoolAlgoBase *	_separate_algo
	Separation algorithm. More...

size_t	_iter_ctr

std::vector< CMergeBookKeeper >	_book_keeper_v

std::vector< std::vector < unsigned short > >	_tmp_merged_indexes

std::vector < cluster::ClusterParamsAlg >	_tmp_merged_clusters

Protected Attributes inherited from cmtool::CMManagerBase
bool	_time_report
	Timing verbosity flag. More...

unsigned int	_min_nhits
	Minimum number of hits: the limit set for ClusterParamsAlg. More...

CMMSGLevel_t	_debug_mode
	Debug mode switch. More...

std::vector < cluster::ClusterParamsAlg >	_in_clusters
	Input clusters. More...

::cmtool::CPriorityAlgoBase *	_priority_algo
	Priority algorithm. More...

TFile *	_fout
	Output analysis plot TFile. More...

std::multimap< float, size_t >	_priority
	Priority record. More...

bool	_merge_till_converge
	Iteration loop switch. More...

std::set< UChar_t >	_planes
	A holder for # of unique planes in the clusters, computed in ComputePriority() function. More...

Additional Inherited Members
Public Types inherited from cmtool::CMManagerBase
enum	CMMSGLevel_t { kPerMerging, kPerIteration, kPerEvent, kNone }
	Enum to specify message output level. More...

Detailed Description

A class that instantiates merging algorithm(s) and run. The book-keeping of merged cluster sets are done by CMergeBookKeeper.

Definition at line 32 of file CMergeManager.h.

Constructor & Destructor Documentation

cmtool::CMergeManager::CMergeManager ( )

Definition at line 19 of file CMergeManager.cxx.

   {
     _iter_ctr = 0;
     _merge_algo = nullptr;
     _separate_algo = nullptr;
     Reset();
   }

virtual cmtool::CMergeManager::~CMergeManager ( )

inlinevirtual

Default destructor.

Definition at line 37 of file CMergeManager.h.

37 {}

Member Function Documentation

void cmtool::CMergeManager::AddMergeAlgo ( CBoolAlgoBase * algo )

inline

A simple method to add an algorithm for merging.

Definition at line 44 of file CMergeManager.h.

     {
       _merge_algo = algo;
     }

void cmtool::CMergeManager::AddSeparateAlgo ( CBoolAlgoBase * algo )

inline

A simple method to add an algorithm for separation.

Definition at line 51 of file CMergeManager.h.

     {
       _separate_algo = algo;
     }

void cmtool::CMergeManager::EventBegin ( )

protectedvirtual

FMWK function called @ beginning of Process()

Reimplemented from cmtool::CMManagerBase.

Definition at line 43 of file CMergeManager.cxx.

   {
     // Initialization per event
     if (!_merge_algo) throw CMTException("No algorithm to run!");
 
     // Merging algorithm
     _merge_algo->SetAnaFile(_fout);
     _merge_algo->EventBegin(_in_clusters);
 
     // Separation algorithm
     if (_separate_algo) {
       _separate_algo->SetAnaFile(_fout);
       _separate_algo->EventBegin(_in_clusters);
     }
 
     // Priority ordering algorithm
     if (_priority_algo) {
       _priority_algo->SetAnaFile(_fout);
       _priority_algo->EventBegin(_in_clusters);
     }
 
     // Verbosity setting
     if (_debug_mode <= kPerMerging) {
       _merge_algo->SetVerbose(true);
       if (_separate_algo) _separate_algo->SetVerbose(true);
       if (_priority_algo) _priority_algo->SetVerbose(true);
     }
 
     // Book keeper reinitialization
     _book_keeper.Reset(_in_clusters.size());
 
     // Clear temporary variables
     _iter_ctr = 0;
     _tmp_merged_clusters.clear();
     _tmp_merged_indexes.clear();
     _book_keeper_v.clear();
   }

void cmtool::CMergeManager::EventEnd ( )

protectedvirtual

FMWK function called @ end of Process()

Reimplemented from cmtool::CMManagerBase.

Definition at line 147 of file CMergeManager.cxx.

   {
     // Gather the full book keeping result
     for (auto const& bk : _book_keeper_v)
 
       _book_keeper.Combine(bk);
 
     // Call EventEnd for algorithms
     _merge_algo->EventEnd();
     if (_separate_algo) _separate_algo->EventEnd();
     if (_priority_algo) _priority_algo->EventEnd();
 
     _book_keeper_v.clear();
     _tmp_merged_clusters.clear();
     _tmp_merged_indexes.clear();
   }

const CMergeBookKeeper& cmtool::CMergeManager::GetBookKeeper ( ) const

inline

A method to obtain book keeper.

Definition at line 65 of file CMergeManager.h.

     {
       return _book_keeper;
     }

const std::vector<cluster::ClusterParamsAlg>& cmtool::CMergeManager::GetClusters ( ) const

inline

A method to obtain output clusters.

Definition at line 58 of file CMergeManager.h.

     {
       return _out_clusters;
     }

void cmtool::CMergeManager::IterationBegin ( )

protectedvirtual

FMWK function called @ beginning of iterative loop inside Process()

Reimplemented from cmtool::CMManagerBase.

Definition at line 83 of file CMergeManager.cxx.

   {
 
     if (!_iter_ctr) {
 
       _merge_algo->IterationBegin(_in_clusters);
       if (_separate_algo) _separate_algo->IterationBegin(_in_clusters);
       if (_priority_algo) _priority_algo->IterationBegin(_in_clusters);
     }
     else {
 
       _merge_algo->IterationBegin(_in_clusters);
       if (_separate_algo) _separate_algo->IterationBegin(_out_clusters);
       if (_priority_algo) _priority_algo->IterationBegin(_out_clusters);
     }
 
     if (_debug_mode <= kPerIteration) {
 
       size_t nclusters = _tmp_merged_clusters.size();
 
       if (!_iter_ctr) nclusters = _in_clusters.size();
 
       std::cout << std::endl
                 << Form("  Merging iteration %zu: processing %zu clusters...", _iter_ctr, nclusters)
                 << std::endl;
     }
   }

void cmtool::CMergeManager::IterationEnd ( )

protectedvirtual

FMWK function called @ end of iterative loop inside Process()

Reimplemented from cmtool::CMManagerBase.

Definition at line 113 of file CMergeManager.cxx.

   {
 
     _merge_algo->IterationEnd();
     if (_separate_algo) _separate_algo->IterationEnd();
     if (_priority_algo) _priority_algo->IterationEnd();
 
     if (_debug_mode <= kPerIteration) {
 
       _merge_algo->Report();
       if (_separate_algo) _separate_algo->Report();
       if (_priority_algo) _priority_algo->Report();
 
       std::cout << Form("  Input / Output cluster length: %zu/%zu",
                         _tmp_merged_clusters.size(),
                         _out_clusters.size())
                 << std::endl;
 
       if (_tmp_merged_clusters.size() == _out_clusters.size())
 
         std::cout << "  Did not find any newly merged clusters..." << std::endl;
 
       if (_out_clusters.size() == 1)
 
         std::cout << "  Output cluster length is 1 (= no more merging needed)" << std::endl;
 
       if (!_merge_till_converge) std::cout << "  Non-iterative option: terminating..." << std::endl;
     }
 
     _iter_ctr++;
   }

bool cmtool::CMergeManager::IterationProcess ( util::GeometryUtilities const & gser )

protectedvirtual

FMWK function called @ iterative loop inside Process()

Implements cmtool::CMManagerBase.

Definition at line 165 of file CMergeManager.cxx.

   {
     // Configure input for RunMerge
     CMergeBookKeeper bk;
 
     if (!_iter_ctr)
       _tmp_merged_clusters = _in_clusters;
     else
       _tmp_merged_clusters = _out_clusters;
     _out_clusters.clear();
 
     bk.Reset(_tmp_merged_clusters.size());
 
     std::vector<bool> merge_switch(_tmp_merged_clusters.size(), true);
 
     for (size_t i = 0; i < _tmp_merged_indexes.size(); ++i)
       if (_tmp_merged_indexes.at(i).size() == 1) merge_switch.at(i) = false;
 
     ComputePriority(_tmp_merged_clusters);
 
     // Run separation algorithm
     if (_separate_algo) RunSeparate(_tmp_merged_clusters, bk);
 
     // Run merging algorithm
     RunMerge(_tmp_merged_clusters, merge_switch, bk);
     if (_debug_mode <= kPerIteration) _merge_algo->Report();
 
     // Save output
     bk.PassResult(_tmp_merged_indexes);
 
     if (bk.size() == _tmp_merged_indexes.size())
       _out_clusters = _tmp_merged_clusters;
     else {
       _out_clusters.reserve(_tmp_merged_indexes.size());
       for (auto const& indexes_v : _tmp_merged_indexes) {
 
         if (indexes_v.size() == 1) {
           _out_clusters.push_back(_tmp_merged_clusters.at(indexes_v.at(0)));
           continue;
         }
 
         size_t tmp_hit_counts = 0;
         for (auto const& index : indexes_v)
           tmp_hit_counts += _tmp_merged_clusters.at(index).GetHitVector().size();
         //std::vector<larutil::PxHit> tmp_hits;
         std::vector<util::PxHit> tmp_hits;
         tmp_hits.reserve(tmp_hit_counts);
 
         for (auto const& index : indexes_v) {
           for (auto const& hit : _tmp_merged_clusters.at(index).GetHitVector())
             tmp_hits.push_back(hit);
         }
         _out_clusters.push_back(::cluster::ClusterParamsAlg());
         (*_out_clusters.rbegin()).SetVerbose(false);
         (*_out_clusters.rbegin()).DisableFANN();
 
         if ((*_out_clusters.rbegin()).SetHits(tmp_hits) < 1) continue;
         (*_out_clusters.rbegin()).FillParams(gser, true, true, true, true, true, false);
         (*_out_clusters.rbegin()).FillPolygon(gser);
       }
       _book_keeper_v.push_back(bk);
     }
 
     // Break if no more merging occurred
     if (_tmp_merged_clusters.size() == _out_clusters.size()) return false;
 
     if (_out_clusters.size() == _planes.size()) return false;
 
     return true;
   }

void cmtool::CMergeManager::Reset ( )

virtual

Method to reset itself.

Definition at line 28 of file CMergeManager.cxx.

   {
     CMManagerBase::Reset();
     _tmp_merged_clusters.clear();
     _tmp_merged_indexes.clear();
     _out_clusters.clear();
     _book_keeper.Reset();
     _book_keeper_v.clear();
     if (_merge_algo) _merge_algo->Reset();
     if (_separate_algo) _separate_algo->Reset();
     _iter_ctr = 0;
   }

void cmtool::CMergeManager::RunMerge	(	const std::vector< cluster::ClusterParamsAlg > &	in_clusters,
		CMergeBookKeeper &	book_keeper
	)		const

protected

Definition at line 237 of file CMergeManager.cxx.

   {
     RunMerge(in_clusters, std::vector<bool>(in_clusters.size(), true), book_keeper);
   }

void cmtool::CMergeManager::RunMerge	(	const std::vector< cluster::ClusterParamsAlg > &	in_clusters,
		const std::vector< bool > &	merge_flag,
		CMergeBookKeeper &	book_keeper
	)		const

protected

Definition at line 244 of file CMergeManager.cxx.

   {
     if (merge_flag.size() != in_clusters.size())
       throw CMTException(
         Form("in_clusters (%zu) and merge_flag (%zu) vectors must be of same length!",
              in_clusters.size(),
              merge_flag.size()));
     if (_debug_mode <= kPerIteration) {
 
       std::cout << Form("  Calling %s with %zu clusters...", __FUNCTION__, in_clusters.size())
                 << std::endl;
     }
 
     //
     // Merging
     //
 
     // Run over clusters and execute merging algorithms
     for (auto citer1 = _priority.rbegin(); citer1 != _priority.rend(); ++citer1) {
 
       auto citer2 = citer1;
 
       UChar_t plane1 = in_clusters.at((*citer1).second).Plane();
 
       while (1) {
         citer2++;
         if (citer2 == _priority.rend()) break;
 
         // Skip if not on the same plane
         UChar_t plane2 = in_clusters.at((*citer2).second).Plane();
         if (plane1 != plane2) continue;
 
         // Skip if this combination is not meant to be compared
         if (!(merge_flag.at((*citer2).second)) && !(merge_flag.at((*citer1).second))) continue;
 
         // Skip if this combination is not allowed to merge
         if (!(book_keeper.MergeAllowed((*citer1).second, (*citer2).second))) continue;
 
         if (_debug_mode <= kPerMerging) {
 
           std::cout << Form("    \033[93mInspecting a pair (%zu, %zu) for merging... \033[00m",
                             (*citer1).second,
                             (*citer2).second)
                     << std::endl;
         }
 
         bool merge =
           _merge_algo->Bool(in_clusters.at((*citer1).second), in_clusters.at((*citer2).second));
 
         if (_debug_mode <= kPerMerging) {
 
           if (merge)
             std::cout << "    \033[93mfound to be merged!\033[00m " << std::endl << std::endl;
 
           else
             std::cout << "    \033[93mfound NOT to be merged...\033[00m" << std::endl << std::endl;
 
         } // end looping over all sets of algorithms
 
         if (merge) book_keeper.Merge((*citer1).second, (*citer2).second);
 
       } // end looping over all cluster pairs for citer1
 
     } // end looping over clusters
 
     if (_debug_mode <= kPerIteration && book_keeper.GetResult().size() != in_clusters.size()) {
 
       std::cout << "  Found following clusters to be merged..." << std::endl;
       for (auto const& indexes_v : book_keeper.GetResult()) {
 
         if (indexes_v.size() == 1) continue;
         std::cout << "    ";
         for (auto index : indexes_v)
 
           std::cout << index << " ";
         std::cout << " ... indexes to be merged!" << std::endl;
       }
     }
   }

void cmtool::CMergeManager::RunSeparate	(	const std::vector< cluster::ClusterParamsAlg > &	in_clusters,
		CMergeBookKeeper &	book_keeper
	)		const

protected

Definition at line 327 of file CMergeManager.cxx.

   {
     /*
     if(separate_flag.size() != in_clusters.size())
       throw CMTException(Form("in_clusters (%zu) and separate_flag (%zu) vectors must be of same length!",
                                    in_clusters.size(),
                                    separate_flag.size()
                                    )
                               );
     */
     if (_debug_mode <= kPerIteration) {
 
       std::cout << Form("  Calling %s with %zu clusters...", __FUNCTION__, in_clusters.size())
                 << std::endl;
     }
 
     //
     // Separation
     //
 
     // Run over clusters and execute merging algorithms
     for (size_t cindex1 = 0; cindex1 < in_clusters.size(); ++cindex1) {
 
       UChar_t plane1 = in_clusters.at(cindex1).Plane();
 
       for (size_t cindex2 = cindex1 + 1; cindex2 < in_clusters.size(); ++cindex2) {
 
         // Skip if not on the same plane
         UChar_t plane2 = in_clusters.at(cindex2).Plane();
         if (plane1 != plane2) continue;
 
         // Skip if this combination is not meant to be compared
         //if(!(separate_flag.at(cindex2))) continue;
 
         if (_debug_mode <= kPerMerging) {
 
           std::cout << Form("    \033[93mInspecting a pair (%zu, %zu) for separation... \033[00m",
                             cindex1,
                             cindex2)
                     << std::endl;
         }
 
         bool separate = _separate_algo->Bool(in_clusters.at(cindex1), in_clusters.at(cindex2));
 
         if (_debug_mode <= kPerMerging) {
 
           if (separate)
             std::cout << "    \033[93mfound to be separated!\033[00m " << std::endl << std::endl;
 
           else
             std::cout << "    \033[93mfound NOT to be separated...\033[00m" << std::endl
                       << std::endl;
 
         } // end looping over all sets of algorithms
 
         if (separate) book_keeper.ProhibitMerge(cindex1, cindex2);
 
       } // end looping over all cluster pairs for citer1
 
     } // end looping over clusters
   }

Member Data Documentation

CMergeBookKeeper cmtool::CMergeManager::_book_keeper

protected

Book keeper instance.

Definition at line 106 of file CMergeManager.h.

std::vector<CMergeBookKeeper> cmtool::CMergeManager::_book_keeper_v

protected

Definition at line 116 of file CMergeManager.h.

size_t cmtool::CMergeManager::_iter_ctr

protected

Definition at line 114 of file CMergeManager.h.

::cmtool::CBoolAlgoBase* cmtool::CMergeManager::_merge_algo

protected

Merging algorithm.

Definition at line 109 of file CMergeManager.h.

std::vector<cluster::ClusterParamsAlg> cmtool::CMergeManager::_out_clusters

protected

Output clusters.

Definition at line 103 of file CMergeManager.h.

::cmtool::CBoolAlgoBase* cmtool::CMergeManager::_separate_algo

protected

Separation algorithm.

Definition at line 112 of file CMergeManager.h.

std::vector<cluster::ClusterParamsAlg> cmtool::CMergeManager::_tmp_merged_clusters

protected

Definition at line 120 of file CMergeManager.h.

std::vector<std::vector<unsigned short> > cmtool::CMergeManager::_tmp_merged_indexes

protected

Definition at line 118 of file CMergeManager.h.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation