WorkspaceGroup.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 "MantidAPI/WorkspaceGroup.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/IPeaksWorkspace.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/Run.h"
#include "MantidKernel/IPropertyManager.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/Strings.h"
 
namespace Mantid::API {
namespace {
size_t MAXIMUM_DEPTH = 100;
Kernel::Logger g_log("WorkspaceGroup");
} // namespace
 
WorkspaceGroup::WorkspaceGroup()
    : Workspace(), m_deleteObserver(*this, &WorkspaceGroup::workspaceDeleteHandle),
      m_beforeReplaceObserver(*this, &WorkspaceGroup::workspaceBeforeReplaceHandle), m_workspaces(),
      m_observingADS(false) {}
 
WorkspaceGroup::~WorkspaceGroup() { observeADSNotifications(false); }
 
const std::string WorkspaceGroup::toString() const {
  const std::string firstLine = this->id() + "\n";
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  const auto descr = std::accumulate(
      m_workspaces.cbegin(), m_workspaces.cend(), firstLine,
      [](const auto &string, const auto &workspace) { return string + " -- " + workspace->getName() + '\n'; });
  return descr;
}
 
void WorkspaceGroup::observeADSNotifications(const bool observeADS) {
  if (observeADS) {
    if (!m_observingADS) {
      AnalysisDataService::Instance().notificationCenter.addObserver(m_deleteObserver);
      AnalysisDataService::Instance().notificationCenter.addObserver(m_beforeReplaceObserver);
      m_observingADS = true;
    }
  } else {
    if (m_observingADS) {
      AnalysisDataService::Instance().notificationCenter.removeObserver(m_deleteObserver);
      AnalysisDataService::Instance().notificationCenter.removeObserver(m_beforeReplaceObserver);
      m_observingADS = false;
    }
  }
}
 
bool WorkspaceGroup::isInChildGroup(const Workspace &workspaceToCheck) const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  for (const auto &workspace : m_workspaces) {
    // check child groups only
    auto const *group = dynamic_cast<WorkspaceGroup *>(workspace.get());
    if (group) {
      if (group->isInGroup(workspaceToCheck))
        return true;
    }
  }
  return false;
}
 
void WorkspaceGroup::sortMembersByName() {
  if (this->size() == 0) {
    return;
  }
  std::sort(m_workspaces.begin(), m_workspaces.end(),
            [](const Workspace_sptr &w1, const Workspace_sptr &w2) { return (w1->getName() < w2->getName()); });
}
 
void WorkspaceGroup::reorderMembersWithIndices(const std::vector<int> &indices) {
  if (indices.size() != this->size()) {
    g_log.warning("Number of indices must match the number of workspace members\n");
    return;
  }
 
  if (!std::all_of(indices.cbegin(), indices.cend(),
                   [&](const int i) { return i >= 0 && i < static_cast<int>(m_workspaces.size()); })) {
    g_log.warning("All indices must be >= 0 and < the number of workspaces in the group\n");
    return;
  }
 
  // check all elements are unique by adding to a set and checking size
  if (std::unordered_set<int>(indices.cbegin(), indices.cend()).size() != indices.size()) {
    g_log.warning("All indices must be unique\n");
    return;
  }
 
  std::vector<Mantid::API::Workspace_sptr> reordered;
  std::transform(indices.cbegin(), indices.cend(), std::back_inserter(reordered),
                 [&](const auto &i) { return m_workspaces[i]; });
  m_workspaces = std::move(reordered);
}
 
void WorkspaceGroup::addWorkspace(const Workspace_sptr &workspace) {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  if (this == workspace.get()) {
    g_log.warning("Can't add a workspace as a child of itself!\n");
    return;
  }
  const auto it = std::find(m_workspaces.begin(), m_workspaces.end(), workspace);
  if (it == m_workspaces.end()) {
    m_workspaces.emplace_back(workspace);
  } else {
    g_log.warning() << "Workspace already exists in a WorkspaceGroup\n";
  }
}
 
bool WorkspaceGroup::containsInChildren(const std::string &wsName) const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
 
  const auto it = std::find_if(m_workspaces.cbegin(), m_workspaces.cend(), [&wsName](const auto &workspace) {
    if (workspace->isGroup()) {
      const auto group = std::dynamic_pointer_cast<WorkspaceGroup>(workspace);
      return group->containsInChildren(wsName);
    }
    return workspace->getName() == wsName;
  });
 
  return it != m_workspaces.cend();
}
 
bool WorkspaceGroup::contains(const std::string &wsName) const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  return std::any_of(m_workspaces.cbegin(), m_workspaces.cend(),
                     [&wsName](const auto &workspace) { return workspace->getName() == wsName; });
}
 
bool WorkspaceGroup::contains(const Workspace_sptr &workspace) const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  auto iend = m_workspaces.end();
  auto it = std::find(m_workspaces.begin(), iend, workspace);
  return (it != iend);
}
 
void WorkspaceGroup::reportMembers(std::set<Workspace_sptr> &memberList) const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  memberList.insert(m_workspaces.begin(), m_workspaces.end());
}
 
std::vector<std::string> WorkspaceGroup::getNames() const {
  std::vector<std::string> out;
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  out.reserve(m_workspaces.size());
 
  std::transform(m_workspaces.begin(), m_workspaces.end(), std::back_inserter(out),
                 [](const auto &ws) { return ws->getName(); });
 
  return out;
}
 
Workspace_sptr WorkspaceGroup::getItem(const size_t index) const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  if (index >= this->size())
    this->throwIndexOutOfRangeError(static_cast<int>(index));
  return m_workspaces[index];
}
 
Workspace_sptr WorkspaceGroup::getItem(const std::string &wsName) const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  const auto found = std::find_if(m_workspaces.cbegin(), m_workspaces.cend(),
                                  [&wsName](const auto &workspace) { return workspace->getName() == wsName; });
  if (found == m_workspaces.cend()) {
    throw std::out_of_range("Workspace " + wsName + " not contained in the group");
  } else {
    return *found;
  }
}
 
std::vector<Workspace_sptr> WorkspaceGroup::getAllItems() const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  return m_workspaces;
}
 
void WorkspaceGroup::removeAll() { m_workspaces.clear(); }
 
void WorkspaceGroup::removeByADS(const std::string &wsName) {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  auto it = m_workspaces.begin();
  for (; it != m_workspaces.end(); ++it) {
    if ((**it).getName() == wsName) {
      m_workspaces.erase(it);
      break;
    }
  }
}
 
void WorkspaceGroup::print() const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  for (const auto &workspace : m_workspaces) {
    g_log.debug() << "Workspace name in group vector =  " << workspace->getName() << '\n';
  }
}
 
/*
 * Throws an out of range error for an out of range index
 * @param index The out of range index to be printed
 * @throws out_of_range error
 */
void WorkspaceGroup::throwIndexOutOfRangeError(int index) const {
  std::ostringstream os;
  os << "WorkspaceGroup - index out of range. Requested=" << index << ", current size=" << this->size();
  throw std::out_of_range(os.str());
}
 
std::vector<Workspace_sptr>::iterator WorkspaceGroup::begin() { return m_workspaces.begin(); }
 
std::vector<Workspace_sptr>::const_iterator WorkspaceGroup::begin() const { return m_workspaces.begin(); }
 
std::vector<Workspace_sptr>::iterator WorkspaceGroup::end() { return m_workspaces.end(); }
 
std::vector<Workspace_sptr>::const_iterator WorkspaceGroup::end() const { return m_workspaces.end(); }
 
void WorkspaceGroup::removeItem(const size_t index) {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  // do not allow this way of removing for groups in the ADS
  if (!this->getName().empty()) {
    throw std::runtime_error("AnalysisDataService must be used to remove a "
                             "workspace from group.");
  }
  if (index >= this->size()) {
    std::ostringstream os;
    os << "WorkspaceGroup - index out of range. Requested=" << index << ", current size=" << this->size();
    throw std::out_of_range(os.str());
  }
  auto it = m_workspaces.begin() + index;
  m_workspaces.erase(it);
}
 
void WorkspaceGroup::workspaceDeleteHandle(Mantid::API::WorkspacePostDeleteNotification_ptr notice) {
  std::unique_lock<std::recursive_mutex> _lock(m_mutex);
  const std::string deletedName = notice->objectName();
  if (!this->contains(deletedName))
    return;
 
  if (deletedName != this->getName()) {
    this->removeByADS(deletedName);
    if (isEmpty()) {
      // We are about to get deleted so we don't want to recieve any
      // notifications
      // The unique lock needs to be unlocked at this point as the workspace
      // is about to destroy itself. We have to make sure that the mutex is
      // not locked.
      _lock.unlock();
      observeADSNotifications(false);
      AnalysisDataService::Instance().remove(this->getName());
    }
  }
}
 
void WorkspaceGroup::workspaceBeforeReplaceHandle(Mantid::API::WorkspaceBeforeReplaceNotification_ptr notice) {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
 
  const auto oldObject = notice->oldObject();
  const auto newObject = notice->newObject();
 
  bool foundOld(false);
  bool foundDuplicate(false);
 
  auto duplicateIter = m_workspaces.end();
 
  for (auto it = m_workspaces.begin(); it != m_workspaces.end(); ++it) {
    auto &workspace = *it;
    if (workspace == oldObject) {
      workspace = newObject;
      foundOld = true;
 
    } else if (workspace == newObject) {
      duplicateIter = it;
      foundDuplicate = true;
    }
 
    if (foundOld && foundDuplicate) {
      break;
    }
  }
 
  if (foundOld && duplicateIter != m_workspaces.end()) {
    m_workspaces.erase(duplicateIter);
  }
}
 
bool WorkspaceGroup::isEmpty() const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  return m_workspaces.empty();
}
 
//------------------------------------------------------------------------------
bool WorkspaceGroup::areNamesSimilar() const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  if (m_workspaces.empty())
    return false;
 
  // Check all the members are of similar names
  return std::all_of(m_workspaces.cbegin(), m_workspaces.cend(), [this](const auto &workspace) {
    const std::string &wsName = workspace->getName();
    // Find the last underscore _
    std::size_t pos = wsName.find_last_of('_');
    // No underscore = not similar
    if (pos == std::string::npos)
      return false;
    // The part before the underscore has to be the same
    // as the group name to be similar
    std::string commonpart(wsName.substr(0, pos));
    if (this->getName() != commonpart)
      return false;
    return true;
  });
}
 
//------------------------------------------------------------------------------
bool WorkspaceGroup::isMultiperiod() const {
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  if (m_workspaces.empty()) {
    g_log.debug("Not a multiperiod-group with < 1 nested workspace.");
    return false;
  }
  // Loop through all inner workspaces, checking each one in turn.
  for (const auto &workspace : m_workspaces) {
    if (MatrixWorkspace_sptr ws = std::dynamic_pointer_cast<MatrixWorkspace>(workspace)) {
      try {
        const Kernel::Property *nPeriodsProp = ws->run().getLogData("nperiods");
        int num = -1;
        Kernel::Strings::convert(nPeriodsProp->value(), num);
        if (num < 1) {
          g_log.debug("Not a multiperiod-group with nperiods log < 1.");
          return false;
        }
      } catch (Kernel::Exception::NotFoundError &) {
        g_log.debug("Not a multiperiod-group without nperiods log on all "
                    "nested workspaces.");
        return false;
      }
    } else {
      g_log.debug("Not a multiperiod-group unless all inner workspaces are "
                  "Matrix Workspaces.");
      return false;
    }
  }
  return true;
}
 
bool WorkspaceGroup::isGroupPeaksWorkspaces() const {
  return std::all_of(m_workspaces.begin(), m_workspaces.end(),
                     [](auto ws) { return dynamic_cast<IPeaksWorkspace *>(ws.get()) != nullptr; });
}
 
bool WorkspaceGroup::isInGroup(const Workspace &workspaceToCheck, size_t level) const {
  // Check for a cycle.
  if (level > MAXIMUM_DEPTH) {
    throw std::runtime_error("WorkspaceGroup nesting level is too deep.");
  }
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  for (const auto &workspace : m_workspaces) {
    if (workspace.get() == &workspaceToCheck)
      return true;
    const auto *group = dynamic_cast<WorkspaceGroup *>(workspace.get());
    if (group) {
      if (group->isInGroup(workspaceToCheck, level + 1))
        return true;
    }
  }
  return false;
}
 
size_t WorkspaceGroup::getMemorySize() const {
  auto total = std::size_t(0);
  // Go through each workspace
  for (auto workspace : m_workspaces) {
    // If the workspace is a group
    if (workspace->getMemorySize() == 0) {
      total = total + std::dynamic_pointer_cast<WorkspaceGroup>(workspace)->getMemorySize();
      continue;
    }
    total = total + workspace->getMemorySize();
  }
  return total;
}
 
} // namespace Mantid::API
 
 
namespace Mantid::Kernel {
 
template <>
MANTID_API_DLL Mantid::API::WorkspaceGroup_sptr
IPropertyManager::getValue<Mantid::API::WorkspaceGroup_sptr>(const std::string &name) const {
  const auto *prop = dynamic_cast<PropertyWithValue<Mantid::API::WorkspaceGroup_sptr> *>(getPointerToProperty(name));
  if (prop) {
    return *prop;
  } else {
    std::string message =
        "Attempt to assign property " + name + " to incorrect type. Expected shared_ptr<WorkspaceGroup>.";
    throw std::runtime_error(message);
  }
}
 
template <>
MANTID_API_DLL Mantid::API::WorkspaceGroup_const_sptr
IPropertyManager::getValue<Mantid::API::WorkspaceGroup_const_sptr>(const std::string &name) const {
  const auto *prop = dynamic_cast<PropertyWithValue<Mantid::API::WorkspaceGroup_sptr> *>(getPointerToProperty(name));
  if (prop) {
    return prop->operator()();
  } else {
    std::string message =
        "Attempt to assign property " + name + " to incorrect type. Expected const shared_ptr<WorkspaceGroup>.";
    throw std::runtime_error(message);
  }
}
 
} // namespace Mantid::Kernel