BoxController.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 <sstream>
 
#include "MantidAPI/BoxController.h"
#include "MantidKernel/Strings.h"
#include "MantidKernel/VectorHelper.h"
 
#include <Poco/DOM/Attr.h>
#include <Poco/DOM/AutoPtr.h>
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/DOMWriter.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>
#include <Poco/DOM/NodeList.h>
#include <Poco/DOM/Text.h>
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>
#include <optional>
 
using namespace Mantid::Kernel;
using Mantid::Kernel::Strings::convert;
using Mantid::Kernel::VectorHelper::splitStringIntoVector;
 
namespace Mantid::API {
 
//-----------------------------------------------------------------------------------
BoxController *BoxController::clone() const {
  // reset the clone file IO controller to avoid dublicated file based
  // operations for different box controllers
  return new BoxController(*this);
}
 
/*Private Copy constructor used in cloning */
BoxController::BoxController(const BoxController &other)
    : nd(other.nd), m_maxId(other.m_maxId), m_SplitThreshold(other.m_SplitThreshold),
      m_significantEventsNumber(other.m_significantEventsNumber), m_maxDepth(other.m_maxDepth),
      m_numEventsAtMax(other.m_numEventsAtMax), m_splitInto(other.m_splitInto), m_splitTopInto(other.m_splitTopInto),
      m_numSplit(other.m_numSplit), m_numTopSplit(other.m_numTopSplit),
      m_addingEvents_eventsPerTask(other.m_addingEvents_eventsPerTask),
      m_addingEvents_numTasksPerBlock(other.m_addingEvents_numTasksPerBlock), m_numMDBoxes(other.m_numMDBoxes),
      m_numMDGridBoxes(other.m_numMDGridBoxes), m_maxNumMDBoxes(other.m_maxNumMDBoxes),
      m_fileIO(std::shared_ptr<API::IBoxControllerIO>()) {}
 
bool BoxController::operator==(const BoxController &other) const {
  if (nd != other.nd || m_maxId != other.m_maxId || m_SplitThreshold != other.m_SplitThreshold ||
      m_maxDepth != other.m_maxDepth || m_numSplit != other.m_numSplit ||
      m_splitInto.size() != other.m_splitInto.size() || m_numMDBoxes.size() != other.m_numMDBoxes.size() ||
      m_numMDGridBoxes.size() != other.m_numMDGridBoxes.size() ||
      m_maxNumMDBoxes.size() != other.m_maxNumMDBoxes.size())
    return false;
 
  for (size_t i = 0; i < m_splitInto.size(); i++) {
    if (m_splitInto[i] != other.m_splitInto[i])
      return false;
  }
 
  for (size_t i = 0; i < m_numMDBoxes.size(); i++) {
    if (m_numMDBoxes[i] != other.m_numMDBoxes[i])
      return false;
    if (m_numMDGridBoxes[i] != other.m_numMDGridBoxes[i])
      return false;
    if (m_maxNumMDBoxes[i] != other.m_maxNumMDBoxes[i])
      return false;
  }
 
  // Check top level splitting if they are set in both or not
  if ((m_splitTopInto && !other.m_splitTopInto) || (!m_splitTopInto && other.m_splitTopInto)) {
    return false;
  }
 
  if (m_splitTopInto && other.m_splitTopInto) {
    if (m_splitTopInto.value().size() != other.m_splitTopInto.value().size()) {
      return false;
    } else {
      for (size_t i = 0; i < m_splitTopInto.value().size(); i++) {
        if (m_splitTopInto.value()[i] != other.m_splitTopInto.value()[i])
          return false;
      }
    }
  }
 
  // There are number of variables which are
  // 1) derived:
  // Number of events sitting in the boxes which should be split but are already
  // split up to the max depth: volatile size_t m_numEventsAtMax;
  // 2) Dynamical and related to current processor and dynamical jobs
  // allocation:
  // For adding events tasks: size_t m_addingEvents_eventsPerTask;
  // m_addingEvents_numTasksPerBlock;
  // These variables are not compared here but may need to be compared in a
  // future for some purposes.
 
  return true;
}
 
BoxController::~BoxController() {
  if (m_fileIO) {
    m_fileIO->closeFile();
    m_fileIO.reset();
  }
}
size_t BoxController::claimIDRange(size_t range) {
  std::lock_guard<std::mutex> lock(m_idMutex);
  size_t tmp = m_maxId;
  m_maxId += range;
  return tmp;
}
std::string BoxController::toXMLString() const {
  using namespace Poco::XML;
 
  // Create the root element for this fragment.
  AutoPtr<Document> pDoc = new Document;
  AutoPtr<Element> pBoxElement = pDoc->createElement("BoxController");
  pDoc->appendChild(pBoxElement);
 
  AutoPtr<Element> element;
  AutoPtr<Text> text;
  std::string vecStr;
 
  element = pDoc->createElement("NumDims");
  text = pDoc->createTextNode(boost::str(boost::format("%d") % this->getNDims()));
  element->appendChild(text);
  pBoxElement->appendChild(element);
 
  element = pDoc->createElement("MaxId");
  text = pDoc->createTextNode(boost::str(boost::format("%d") % this->getMaxId()));
  element->appendChild(text);
  pBoxElement->appendChild(element);
 
  element = pDoc->createElement("SplitThreshold");
  text = pDoc->createTextNode(boost::str(boost::format("%d") % this->getSplitThreshold()));
  element->appendChild(text);
  pBoxElement->appendChild(element);
 
  element = pDoc->createElement("MaxDepth");
  text = pDoc->createTextNode(boost::str(boost::format("%d") % this->getMaxDepth()));
  element->appendChild(text);
  pBoxElement->appendChild(element);
 
  element = pDoc->createElement("SplitInto");
  vecStr = Kernel::Strings::join(this->m_splitInto.begin(), this->m_splitInto.end(), ",");
  text = pDoc->createTextNode(vecStr);
  element->appendChild(text);
  pBoxElement->appendChild(element);
 
  element = pDoc->createElement("SplitTopInto");
  if (m_splitTopInto) {
    vecStr = Kernel::Strings::join(this->m_splitTopInto.value().begin(), this->m_splitTopInto.value().end(), ",");
  } else {
    vecStr = "";
  }
  text = pDoc->createTextNode(vecStr);
  element->appendChild(text);
  pBoxElement->appendChild(element);
 
  element = pDoc->createElement("NumMDBoxes");
  vecStr = Kernel::Strings::join(this->m_numMDBoxes.begin(), this->m_numMDBoxes.end(), ",");
  text = pDoc->createTextNode(vecStr);
  element->appendChild(text);
  pBoxElement->appendChild(element);
 
  element = pDoc->createElement("NumMDGridBoxes");
  vecStr = Kernel::Strings::join(this->m_numMDGridBoxes.begin(), this->m_numMDGridBoxes.end(), ",");
  text = pDoc->createTextNode(vecStr);
  element->appendChild(text);
  pBoxElement->appendChild(element);
 
  // Create a string representation of the DOM tree.
  std::stringstream xmlstream;
  DOMWriter writer;
  writer.writeNode(xmlstream, pDoc);
 
  return xmlstream.str();
}
std::string BoxController::getFilename() const {
  if (m_fileIO)
    return m_fileIO->getFileName();
  else
    return "";
}
bool BoxController::useWriteBuffer() const { return static_cast<bool>(m_fileIO); }
 
//------------------------------------------------------------------------------------------------------
void BoxController::fromXMLString(const std::string &xml) {
  using namespace Poco::XML;
  Poco::XML::DOMParser pParser;
  Poco::AutoPtr<Poco::XML::Document> pDoc = pParser.parseString(xml);
  Poco::XML::Element *pBoxElement = pDoc->documentElement();
 
  std::string s;
  s = pBoxElement->getChildElement("NumDims")->innerText();
  Strings::convert(s, nd);
  if (nd == 0 || nd > 20)
    throw std::runtime_error("BoxController::fromXMLString(): Bad number of dimensions found.");
 
  size_t ival;
  Strings::convert(pBoxElement->getChildElement("MaxId")->innerText(), ival);
  this->setMaxId(ival);
  Strings::convert(pBoxElement->getChildElement("SplitThreshold")->innerText(), ival);
  this->setSplitThreshold(ival);
  Strings::convert(pBoxElement->getChildElement("MaxDepth")->innerText(), ival);
  this->setMaxDepth(ival);
 
  s = pBoxElement->getChildElement("SplitInto")->innerText();
  this->m_splitInto = splitStringIntoVector<size_t>(s);
 
  // Need to make sure that we handle box controllers which did not have the
  // SplitTopInto
  // attribute
  Poco::AutoPtr<NodeList> nodes = pBoxElement->getElementsByTagName("SplitTopInto");
  if (nodes->length() > 0) {
    s = pBoxElement->getChildElement("SplitTopInto")->innerText();
    if (s.empty()) {
      this->m_splitTopInto = std::nullopt;
    } else {
      this->m_splitTopInto = splitStringIntoVector<size_t>(s);
    }
  } else {
    this->m_splitTopInto = std::nullopt;
  }
 
  s = pBoxElement->getChildElement("NumMDBoxes")->innerText();
  this->m_numMDBoxes = splitStringIntoVector<size_t>(s);
 
  s = pBoxElement->getChildElement("NumMDGridBoxes")->innerText();
  this->m_numMDGridBoxes = splitStringIntoVector<size_t>(s);
 
  this->calcNumSplit();
 
  if (m_splitTopInto) {
    this->calcNumTopSplit();
  }
}
void BoxController::clearFileBacked() {
  if (m_fileIO) {
    // flush DB cache
    m_fileIO->flushCache();
    // close underlying file
    m_fileIO->closeFile();
    // decrease the sp counter by one and nullify this instance of sp.
    m_fileIO.reset(); // = std::shared_ptr<API::IBoxControllerIO>();
  }
}
void BoxController::setFileBacked(const std::shared_ptr<IBoxControllerIO> &newFileIO, const std::string &fileName) {
  if (!newFileIO->isOpened()) {
    bool opened = newFileIO->openFile(fileName, "w");
    if (!opened)
      throw(Kernel::Exception::FileError("Can not open target file for filebased box controller ", fileName));
  }
 
  this->m_fileIO = newFileIO;
}
 
} // namespace Mantid::API