cmtool::CMergeManager Class Reference

#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.

{}

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 ( void  )

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:

• larreco/larreco/RecoAlg/CMTool/CMToolBase/CMergeManager.h
• larreco/larreco/RecoAlg/CMTool/CMToolBase/CMergeManager.cxx