cmtool::CMergeBookKeeper Class Reference

#include "CMergeBookKeeper.h"

Inheritance diagram for cmtool::CMergeBookKeeper:

Public Member Functions
	CMergeBookKeeper (unsigned short nclusters=0)
	Default constructor. More...
void	Reset (unsigned short nclusters=0)
	Reset method. More...
void	ProhibitMerge (unsigned short index1, unsigned short index2)
	Method to set a pair of clusters to prohibit from merging. More...
bool	MergeAllowed (unsigned short index1, unsigned short index2)
	Method to inqury if a combination is prohibited to merge. More...
void	Merge (unsigned short index1, unsigned short index2)
	Method to merge 2 clusters via index numbers. More...
std::vector< unsigned short >	GetMergedSet (unsigned short index1) const
bool	IsMerged (unsigned short index1, unsigned short index2) const
void	PassResult (std::vector< std::vector< unsigned short >> &result) const
std::vector< std::vector< unsigned short > >	GetResult () const
void	Combine (const CMergeBookKeeper &another)
void	Report () const

Public Attributes
T	elements
	STL member. More...

Protected Attributes
std::vector< std::vector< bool > >	_prohibit_merge
size_t	_out_cluster_count
	Number of output clusters. More...

Detailed Description

A utility class for CMergeManager which merge clusters using merging algorithms. One of major task for CMergeManager is to keep track of which clusters to be merged in the original input. CMergeBookKeeper handles this part. It works with indexes. The user (primarily CMergeManager) provides number of clusters to CMergeBookKeeper's constructor. Then it can ask CMergeBookKeeper to merge two specific clusters by specifying index number of the cluster which has to be smaller than the previously specified number of clusters. CMergeBookKeeper keeps track of which clusters are asked to merge together, and it can be asked to return a vector of merged cluster indexes.

Definition at line 33 of file CMergeBookKeeper.h.

Constructor & Destructor Documentation

cmtool::CMergeBookKeeper::CMergeBookKeeper

(

unsigned short

nclusters = 0

)

Default constructor.

Definition at line 10 of file CMergeBookKeeper.cxx.

References Reset().

  {
    Reset(nclusters);
  }

Member Function Documentation

void cmtool::CMergeBookKeeper::Combine

(

const CMergeBookKeeper &

another

)

Method to combine with another CMergeBookKeeper instance.

Definition at line 261 of file CMergeBookKeeper.cxx.

References Merge(), PassResult(), and target.

Referenced by cmtool::CMergeManager::EventEnd(), GetResult(), and cmtool::CMergeHelper::Process().

  {
    // Check length compatibility between this instance's result and "another"
    std::vector<std::vector<unsigned short>> my_result;
    this->PassResult(my_result);
    if (my_result.size() != another.size()) {
      throw CMTException(
        Form("Input has an incompatible size (%zu != %zu)", my_result.size(), another.size()));
      return;
    }

    // Check if "another" result is different from input
    std::vector<std::vector<unsigned short>> another_result;
    another.PassResult(another_result);
    if (another_result.size() >= my_result.size())
      throw CMTException(Form("The input has equal or more number of output clusters (%zu>=%zu)",
                              another_result.size(),
                              my_result.size()));

    // Combine
    for (auto const& ares : another_result) {

      if (ares.size() == 1) continue;

      // Get one of cluster to be used for merging
      unsigned short target = my_result.at(ares.at(0)).at(0);

      for (auto const& res_index : ares) {

        for (auto const& orig_index : my_result.at(res_index)) {

          if (target == orig_index)
            continue;

          else
            this->Merge(target, orig_index);
        }
      }
    }
  }

std::vector< unsigned short > cmtool::CMergeBookKeeper::GetMergedSet

(

unsigned short

index1

)

const

Method to retrieve a vector of cluster indexes which is merged with the input cluster index. All indexes here are regarding the original cluster index.

Definition at line 237 of file CMergeBookKeeper.cxx.

References util::size().

  {

    if (index1 >= this->size()) throw CMTException(Form("Invalid cluster index: %d ", index1));

    auto out_index = this->at(index1);
    std::vector<unsigned short> result;

    for (size_t i = 0; i < this->size(); ++i)
      if (this->at(i) == out_index) result.push_back(i);

    return result;
  }

std::vector<std::vector<unsigned short> > cmtool::CMergeBookKeeper::GetResult ( ) const

inline

Definition at line 72 of file CMergeBookKeeper.h.

References Combine(), PassResult(), and Report().

Referenced by cluster::ClusterMergeHelper::Process(), and cmtool::CMergeManager::RunMerge().

    {
      std::vector<std::vector<unsigned short>> result;
      PassResult(result);
      return result;
    }

bool cmtool::CMergeBookKeeper::IsMerged	(	unsigned short	index1,
		unsigned short	index2
	)		const

Method to ask if a given 2 clusters are already merged. This method is expected to be much faster than obtaining a merged cluster sets from GetMergedIndexes and check if two clusters are merged.

Definition at line 229 of file CMergeBookKeeper.cxx.

References util::size().

  {
    if (index1 >= this->size() || index2 >= this->size())
      throw CMTException(Form("Invalid cluster index: %d or %d", index1, index2));

    return this->at(index1) == this->at(index2);
  }

void cmtool::CMergeBookKeeper::Merge	(	unsigned short	index1,
		unsigned short	index2
	)

Method to merge 2 clusters via index numbers.

Definition at line 71 of file CMergeBookKeeper.cxx.

References _out_cluster_count, _prohibit_merge, and util::size().

Referenced by Combine(), and cmtool::CMergeManager::RunMerge().

  {

    if (index1 == index2)

      throw CMTException(Form("<<%s>> Two input clusters identical (%d)", __FUNCTION__, index1));

    if (index1 >= this->size() || index2 >= this->size())

      throw CMTException(Form("Input cluster index (%d and/or %d) out of range", index1, index2));

    auto out_index1 = this->at(index1);
    auto out_index2 = this->at(index2);

    if (out_index1 == out_index2) return;

    if (out_index2 < out_index1) std::swap(out_index1, out_index2);

    if (_prohibit_merge.at(out_index1).at(out_index2 - out_index1))

      throw CMTException(
        Form("Clusters (%d,%d) correspond to output (%d,%d) which is prohibited to merge",
             index1,
             index2,
             out_index1,
             out_index2));

    //
    // Merge cluster indexes
    //
    for (auto& v : (*this)) {

      if (v == out_index1 || v == out_index2)
        v = out_index1;
      else if (v > out_index2)
        v -= 1;
    }

    //
    // Merge prohibit rule
    //
    // (1) handle index < out_index1
    for (size_t index = 0; index < out_index1; ++index) {

      size_t tmp_out_index1 = out_index1 - index;
      size_t tmp_out_index2 = out_index2 - index;

      _prohibit_merge.at(index).at(tmp_out_index1) =
        (_prohibit_merge.at(index).at(tmp_out_index1) ||
         _prohibit_merge.at(index).at(tmp_out_index2));

      for (size_t in_index = tmp_out_index2;
           //in_index < _prohibit_merge.at(index).size() - 1;
           in_index < (_out_cluster_count - index - 1);
           ++in_index) {

        /*
        if(in_index >= (_out_cluster_count - 1 - index))

          _prohibit_merge.at(index).at(in_index) = false;

        else
        */
        _prohibit_merge.at(index).at(in_index) = _prohibit_merge.at(index).at(in_index + 1);
      }

      //(*_prohibit_merge.at(index).rbegin()) = false;
      _prohibit_merge.at(index).at(_out_cluster_count - index - 1) = false;
    }

    // (2) handle index == out_index1
    for (size_t in_index = 1;
         //in_index < _prohibit_merge.at(out_index1).size() - 1;
         in_index < (_out_cluster_count - out_index1 - 1);
         ++in_index) {
      if ((in_index + out_index1) < out_index2) {
        /*
        std::cout<<Form("Inspecting1 : (%d,%zu) to (%zu,%zu)",
                        out_index1,in_index,
                        (in_index + out_index1),(out_index2 - (in_index+out_index1)))
                 << std::endl;
        */
        _prohibit_merge.at(out_index1).at(in_index) =
          (_prohibit_merge.at(out_index1).at(in_index) ||
           _prohibit_merge.at(in_index + out_index1).at(out_index2 - (in_index + out_index1)));
      }
      else {
        /*
        std::cout<<Form("Inspecting2 : (%d,%zu) to (%d,%zu) ...",
                        out_index1,in_index+1,
                        out_index2,(in_index+out_index1-out_index2));
        if(_prohibit_merge.at(out_index1).at(in_index+1)) std::cout<<"T";
        else std::cout<<"F";
        std::cout<<",";
        if(_prohibit_merge.at(out_index2).at(in_index+out_index1-out_index2)) std::cout<<"T";
        else std::cout<<"F";
        std::cout<<std::endl;
        */
        _prohibit_merge.at(out_index1).at(in_index) =
          (_prohibit_merge.at(out_index1).at(in_index + 1) ||
           _prohibit_merge.at(out_index2).at(in_index + 1 + out_index1 - out_index2));
      }
    }
    //(*_prohibit_merge.at(out_index1).rbegin()) = false;
    _prohibit_merge.at(out_index1).at(_out_cluster_count - out_index1 - 1) = false;

    // (3) handle out_index1 < index < out_index2
    for (size_t index = out_index1 + 1; index < out_index2; ++index) {
      for (size_t in_index = (out_index2 - index);
           //in_index < (_prohibit_merge.at(index).size() - 1);
           in_index < (_out_cluster_count - index - 1);
           ++in_index)

        _prohibit_merge.at(index).at(in_index) = _prohibit_merge.at(index).at(in_index + 1);

      //(*_prohibit_merge.at(index).rbegin()) = false;
      _prohibit_merge.at(index).at(_out_cluster_count - index - 1) = false;
    }
    // (4) handle out_index2 <= index
    for (size_t index = out_index2;
         //index < (_prohibit_merge.size() - 1);
         index < (_out_cluster_count - 1);
         ++index) {

      for (size_t in_index = 0; in_index < _prohibit_merge.at(index).size(); ++in_index)

        if (in_index < _prohibit_merge.at(index + 1).size())
          _prohibit_merge.at(index).at(in_index) = _prohibit_merge.at(index + 1).at(in_index);

        else
          _prohibit_merge.at(index).at(in_index) = false;
    }

    _out_cluster_count -= 1;
  }

bool cmtool::CMergeBookKeeper::MergeAllowed	(	unsigned short	index1,
		unsigned short	index2
	)

Method to inqury if a combination is prohibited to merge.

Definition at line 50 of file CMergeBookKeeper.cxx.

References _prohibit_merge, and util::size().

Referenced by cmtool::CMergeManager::RunMerge().

  {

    if (index1 == index2)

      throw CMTException(Form("<<%s>> Two input clusters identical (%d)", __FUNCTION__, index1));

    if (index1 >= this->size() || index2 >= this->size())

      throw CMTException(Form("Input cluster index (%d and/or %d) out of range", index1, index2));

    auto out_index1 = this->at(index1);
    auto out_index2 = this->at(index2);

    if (out_index1 == out_index2) return true;

    if (out_index2 < out_index1) std::swap(out_index1, out_index2);

    return !(_prohibit_merge.at(out_index1).at(out_index2 - out_index1));
  }

void cmtool::CMergeBookKeeper::PassResult

(

std::vector< std::vector< unsigned short >> &

result

)

const

A method to get the full result. The return is a vector of merged cluster indexes (which is a vector of original cluster indexes).

Definition at line 251 of file CMergeBookKeeper.cxx.

References _out_cluster_count, and util::size().

Referenced by Combine(), GetResult(), and cmtool::CMergeManager::IterationProcess().

  {

    result.clear();
    result.resize(_out_cluster_count, std::vector<unsigned short>());

    for (size_t i = 0; i < this->size(); ++i)
      result.at(this->at(i)).push_back(i);
  }

void cmtool::CMergeBookKeeper::ProhibitMerge	(	unsigned short	index1,
		unsigned short	index2
	)

Method to set a pair of clusters to prohibit from merging.

Definition at line 29 of file CMergeBookKeeper.cxx.

References _prohibit_merge, and util::size().

Referenced by cmtool::CMergeManager::RunSeparate().

  {
    if (index1 == index2)

      throw CMTException(Form("<<%s>> Two input clusters identical (%d)", __FUNCTION__, index1));

    if (index1 >= this->size() || index2 >= this->size())

      throw CMTException(Form("Input cluster index (%d and/or %d) out of range", index1, index2));

    auto out_index1 = this->at(index1);
    auto out_index2 = this->at(index2);

    if (out_index1 == out_index2)
      throw CMTException(Form("Cluster %d and %d already merged!", index1, index2));

    if (out_index2 < out_index1) std::swap(out_index1, out_index2);

    _prohibit_merge.at(out_index1).at(out_index2 - out_index1) = true;
  }

void cmtool::CMergeBookKeeper::Report

(

)

const

Definition at line 207 of file CMergeBookKeeper.cxx.

References _prohibit_merge.

Referenced by GetResult().

  {
    std::cout << "Merge Result:" << std::endl;
    for (auto const& v : *this)
      std::cout << v << " ";
    std::cout << std::endl << std::endl;

    std::cout << "Prohibit Status:" << std::endl;
    for (auto const& bs : _prohibit_merge) {

      for (auto const& b : bs) {

        if (b)
          std::cout << "\033[93mT\033[00m ";
        else
          std::cout << "\033[95mF\033[00m ";
      }
      std::cout << std::endl;
    }
    std::cout << std::endl;
  }

void cmtool::CMergeBookKeeper::Reset

(

unsigned short

nclusters = 0

)

Reset method.

Definition at line 15 of file CMergeBookKeeper.cxx.

References _out_cluster_count, _prohibit_merge, and clear().

Referenced by CMergeBookKeeper(), cmtool::CMergeManager::EventBegin(), cmtool::CMergeManager::IterationProcess(), and cmtool::CMergeManager::Reset().

  {
    _prohibit_merge.clear();
    _prohibit_merge.reserve(nclusters);
    std::vector<unsigned short>::clear();
    std::vector<unsigned short>::reserve(nclusters);

    for (size_t i = 0; i < nclusters; ++i) {
      this->push_back(i);
      _prohibit_merge.push_back(std::vector<bool>(nclusters - i, false));
    }
    _out_cluster_count = nclusters;
  }

Member Data Documentation

size_t cmtool::CMergeBookKeeper::_out_cluster_count

protected

Number of output clusters.

Definition at line 94 of file CMergeBookKeeper.h.

Referenced by Merge(), PassResult(), and Reset().

std::vector<std::vector<bool> > cmtool::CMergeBookKeeper::_prohibit_merge

protected

A 2D-map vector that stores pair of clusters for which merging is prohibited

Definition at line 91 of file CMergeBookKeeper.h.

Referenced by Merge(), MergeAllowed(), ProhibitMerge(), Report(), and Reset().

T std::vector< T >::elements

inherited

STL member.

---

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

• larreco/v09_25_00/source/larreco/RecoAlg/CMTool/CMToolBase/CMergeBookKeeper.h
• larreco/v09_25_00/source/larreco/RecoAlg/CMTool/CMToolBase/CMergeBookKeeper.cxx