ClusterRegister.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidCrystal/ClusterRegister.h"
#include "MantidCrystal/Cluster.h"
#include "MantidCrystal/CompositeCluster.h"
#include <boost/functional/hash.hpp>
#include <list>
#include <memory>
#include <unordered_set>
 
namespace {
template <typename T> std::pair<T, T> ordered_pair(const T &a, const T &b) {
  T min = std::min(a, b);
  T max = std::max(a, b);
  return std::pair<T, T>(min, max);
}
} // namespace
 
namespace Mantid::Crystal {
 
class ImplClusterRegister {
public:
  ClusterRegister::MapCluster m_register;
 
  ClusterRegister::MapCluster m_unique;
 
  using GroupType = std::list<std::unordered_set<size_t>>;
 
  GroupType m_groups;
 
  using LabelHash = std::unordered_set<size_t>;
 
  LabelHash m_labelHash;
 
  boost::hash<std::pair<int, int>> m_labelHasher;
 
  bool insert(const DisjointElement &a, const DisjointElement &b) {
    const size_t &aLabel = a.getRoot();
    const size_t &bLabel = b.getRoot();
    bool newItem = true;
 
    GroupType containingAny;
    GroupType containingNone;
    // ------------- Find equivalent sets
    for (auto &cluster : m_groups) {
      if (cluster.find(aLabel) != cluster.end()) {
        containingAny.emplace_back(cluster);
      } else if (cluster.find(bLabel) != cluster.end()) {
        containingAny.emplace_back(cluster);
      } else {
        containingNone.emplace_back(cluster); // Current iterated set contains
                                              // NEITHER of these labels. It can
                                              // therfore be ignored.
      }
    }
    // ------------ Process equivalent sets
    if (containingAny.empty()) {
      // Neither label is yet known to any set. We must add a new set for these
      GroupType::value_type newSet;
      newSet.insert(aLabel);
      newSet.insert(bLabel);
      m_groups.emplace_back(newSet);
    } else {
      // At least one set already contains at least one label. We merge all such
      // sets into a master set.
 
      // implement copy and swap. Rebuild the sets.
      GroupType temp = containingNone;
      GroupType::value_type masterSet;
      masterSet.insert(aLabel); // Incase it doesn't already contain a
      masterSet.insert(bLabel); // Incase it doesn't already contain b
      for (auto &childSet : containingAny) {
        masterSet.insert(childSet.begin(),
                         childSet.end()); // Build the master set.
      }
      temp.emplace_back(masterSet);
      m_groups = temp; // Swap.
      newItem = false;
    }
    return newItem;
  }
 
  std::list<std::shared_ptr<CompositeCluster>> makeCompositeClusters() {
    std::list<std::shared_ptr<CompositeCluster>> composites;
    for (auto &labelSet : m_groups) {
      auto composite = std::make_shared<CompositeCluster>();
      for (auto j : labelSet) {
        std::shared_ptr<ICluster> &cluster = m_register[j];
        composite->add(cluster);
      }
      composites.emplace_back(composite);
    }
    return composites;
  }
};
 
//----------------------------------------------------------------------------------------------
ClusterRegister::ClusterRegister() : m_Impl(new ImplClusterRegister) {}
 
ClusterRegister::~ClusterRegister() = default;
 
void ClusterRegister::add(const size_t &label, const std::shared_ptr<ICluster> &cluster) {
  m_Impl->m_register.emplace(label, cluster);
  m_Impl->m_unique.emplace(label, cluster);
}
 
void ClusterRegister::merge(const DisjointElement &a, const DisjointElement &b) const {
  if (!a.isEmpty() && !b.isEmpty()) {
    const int &aId = a.getId();
    const int &bId = b.getId();
 
    size_t hash = m_Impl->m_labelHasher(ordered_pair(aId, bId));
    if (m_Impl->m_labelHash.find(hash) == m_Impl->m_labelHash.end()) // Only if this pair combination has not
                                                                     // already been processed
    {
      m_Impl->insert(a, b);
      m_Impl->m_unique.erase(aId);
      m_Impl->m_unique.erase(bId);
      m_Impl->m_labelHash.insert(hash); // So that we don't process this pair again.
    }
  }
}
 
ClusterRegister::MapCluster ClusterRegister::clusters() const {
  MapCluster temp;
  temp.insert(m_Impl->m_unique.begin(), m_Impl->m_unique.end());
  auto mergedClusters = m_Impl->makeCompositeClusters();
  for (const auto &merged : mergedClusters) {
    temp.emplace(merged->getLabel(), merged);
  }
  return temp;
}
 
ClusterRegister::MapCluster ClusterRegister::clusters(std::vector<DisjointElement> &elements) const {
  MapCluster temp;
  temp.insert(m_Impl->m_unique.begin(), m_Impl->m_unique.end());
  auto mergedClusters = m_Impl->makeCompositeClusters();
  for (auto &merged : mergedClusters) {
    merged->toUniformMinimum(elements);
    temp.emplace(merged->getLabel(), merged);
  }
  return temp;
}
 
} // namespace Mantid::Crystal