CompositeImplicitFunction.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 "MantidGeometry/MDGeometry/CompositeImplicitFunction.h"
 
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>
 
#include <Poco/DOM/AutoPtr.h>
#include <Poco/DOM/DOMWriter.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>
#include <Poco/DOM/Text.h>
 
#include <numeric>
 
namespace Mantid::Geometry {
 
bool CompositeImplicitFunction::addFunction(const Mantid::Geometry::MDImplicitFunction_sptr &constituentFunction) {
  bool bSuccess = false;
  if (constituentFunction.get() != nullptr) {
    this->m_Functions.emplace_back(constituentFunction);
    bSuccess = true;
  }
  return bSuccess;
}
 
std::string CompositeImplicitFunction::getName() const { return CompositeImplicitFunction::functionName(); }
 
std::string CompositeImplicitFunction::toXMLString() const {
  using namespace Poco::XML;
  AutoPtr<Document> pDoc = new Document;
  AutoPtr<Element> functionElement = pDoc->createElement("Function");
  pDoc->appendChild(functionElement);
  AutoPtr<Element> typeElement = pDoc->createElement("Type");
  AutoPtr<Text> typeText = pDoc->createTextNode(this->getName());
  typeElement->appendChild(typeText);
  functionElement->appendChild(typeElement);
  AutoPtr<Element> parameterListElement = pDoc->createElement("ParameterList");
  functionElement->appendChild(parameterListElement);
 
  std::string functionXML =
      std::accumulate(m_Functions.cbegin(), m_Functions.cend(), std::string(),
                      [](const auto &lhs, const auto &function) { return lhs + function->toXMLString(); });
  AutoPtr<Text> functionFormatText = pDoc->createTextNode("%s");
  functionElement->appendChild(functionFormatText);
 
  std::stringstream xmlstream;
  DOMWriter writer;
  writer.writeNode(xmlstream, pDoc);
 
  std::string formattedXMLString = boost::str(boost::format(xmlstream.str().c_str()) % functionXML.c_str());
  return formattedXMLString;
}
 
int CompositeImplicitFunction::getNFunctions() const { return static_cast<int>(this->m_Functions.size()); }
 
bool CompositeImplicitFunction::isPointContained(const coord_t *coords) {
  bool evalResult = false;
  std::vector<std::shared_ptr<Mantid::Geometry::MDImplicitFunction>>::const_iterator it;
  for (it = this->m_Functions.begin(); it != this->m_Functions.end(); ++it) {
    evalResult = (*it)->isPointContained(coords);
    if (!evalResult) {
      break;
    }
  }
  return evalResult;
}
 
bool CompositeImplicitFunction::isPointContained(const std::vector<coord_t> &coords) {
  bool evalResult = false;
  std::vector<std::shared_ptr<Mantid::Geometry::MDImplicitFunction>>::const_iterator it;
  for (it = this->m_Functions.begin(); it != this->m_Functions.end(); ++it) {
    evalResult = (*it)->isPointContained(coords);
    if (!evalResult) {
      break;
    }
  }
  return evalResult;
}
} // namespace Mantid::Geometry