MDGeometryXMLParser.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 <algorithm>
#include <functional>
#include <utility>
 
#include "MantidGeometry/MDGeometry/IMDDimensionFactory.h"
#include "MantidGeometry/MDGeometry/MDGeometryXMLDefinitions.h"
#include "MantidGeometry/MDGeometry/MDGeometryXMLParser.h"
 
#include <Poco/AutoPtr.h>
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>
#include <Poco/DOM/NodeList.h>
 
namespace Mantid::Geometry {
struct findID {
  const std::string m_id;
  explicit findID(std::string id) : m_id(std::move(id)) {}
 
  bool operator()(const Mantid::Geometry::IMDDimension_sptr &obj) const { return m_id == obj->getDimensionId(); }
};
 
struct findIntegrated {
  bool operator()(const Mantid::Geometry::IMDDimension_sptr &obj) const { return obj->getIsIntegrated(); }
};
 
void MDGeometryXMLParser::validate() const {
  if (!m_executed) {
    throw std::runtime_error("Attempting to get dimension information from "
                             "MDGeometryXMLParser, before calling ::execute()");
  }
}
 
void MDGeometryXMLParser::execute() {
  Poco::XML::DOMParser pParser;
  Poco::AutoPtr<Poco::XML::Document> pDoc = pParser.parseString(m_xmlToProcess);
  Poco::XML::Element *pRootElem = pDoc->documentElement();
  // Apply root node checking if supplied.
  Poco::XML::Element *geometryXMLElement = nullptr;
  if (!m_rootNodeName.empty()) {
    Poco::XML::Element *temp = pRootElem->getChildElement(m_rootNodeName);
    geometryXMLElement = temp;
    if (geometryXMLElement == nullptr) {
      std::string message = "Root node was not found to be the expected value of " + m_rootNodeName;
      throw std::runtime_error(message);
    }
  } else {
    // The default is to take the root node to be the geometry xml element.
    geometryXMLElement = pRootElem;
  }
 
  Poco::AutoPtr<Poco::XML::NodeList> dimensionsXML =
      geometryXMLElement->getElementsByTagName(MDGeometryXMLDefinitions::workspaceDimensionElementName());
  size_t nDimensions = dimensionsXML->length();
  VecIMDDimension_sptr vecAllDims(nDimensions);
 
  for (size_t i = 0; i < nDimensions; i++) {
    auto *dimensionXML = static_cast<Poco::XML::Element *>(dimensionsXML->item(static_cast<unsigned long>(i)));
    vecAllDims[i] = createDimension(*dimensionXML);
  }
  VecIMDDimension_sptr vecNonMappedDims = vecAllDims;
  Poco::XML::Element *xDimensionElement =
      geometryXMLElement->getChildElement(MDGeometryXMLDefinitions::workspaceXDimensionElementName());
  std::string xDimId =
      xDimensionElement->getChildElement(MDGeometryXMLDefinitions::workspaceRefDimensionElementName())->innerText();
  if (!xDimId.empty()) {
    auto xDimensionIt = find_if(vecAllDims.begin(), vecAllDims.end(), findID(xDimId));
    if (xDimensionIt == vecAllDims.end()) {
      throw std::invalid_argument("Cannot determine x-dimension mapping.");
    }
    m_xDimension = *xDimensionIt;
    vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(), vecNonMappedDims.end(), findID(xDimId)),
                           vecNonMappedDims.end());
  }
 
  Poco::XML::Element *yDimensionElement =
      geometryXMLElement->getChildElement(MDGeometryXMLDefinitions::workspaceYDimensionElementName());
  std::string yDimId =
      yDimensionElement->getChildElement(MDGeometryXMLDefinitions::workspaceRefDimensionElementName())->innerText();
 
  if (!yDimId.empty()) {
    auto yDimensionIt = find_if(vecAllDims.begin(), vecAllDims.end(), findID(yDimId));
    if (yDimensionIt == vecAllDims.end()) {
      throw std::invalid_argument("Cannot determine y-dimension mapping.");
    }
    m_yDimension = *yDimensionIt;
    vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(), vecNonMappedDims.end(), findID(yDimId)),
                           vecNonMappedDims.end());
  }
 
  Poco::XML::Element *zDimensionElement =
      geometryXMLElement->getChildElement(MDGeometryXMLDefinitions::workspaceZDimensionElementName());
  std::string zDimId =
      zDimensionElement->getChildElement(MDGeometryXMLDefinitions::workspaceRefDimensionElementName())->innerText();
 
  if (!zDimId.empty()) {
    auto zDimensionIt = find_if(vecAllDims.begin(), vecAllDims.end(), findID(zDimId));
    if (zDimensionIt == vecAllDims.end()) {
      throw std::invalid_argument("Cannot determine z-dimension mapping.");
    }
    m_zDimension = *zDimensionIt;
    vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(), vecNonMappedDims.end(), findID(zDimId)),
                           vecNonMappedDims.end());
  }
 
  Poco::XML::Element *tDimensionElement =
      geometryXMLElement->getChildElement(MDGeometryXMLDefinitions::workspaceTDimensionElementName());
  std::string tDimId =
      tDimensionElement->getChildElement(MDGeometryXMLDefinitions::workspaceRefDimensionElementName())->innerText();
  if (!tDimId.empty()) {
    auto tDimensionIt = find_if(vecAllDims.begin(), vecAllDims.end(), findID(tDimId));
    if (tDimensionIt == vecAllDims.end()) {
      throw std::invalid_argument("Cannot determine t-dimension mapping.");
    }
    m_tDimension = *tDimensionIt;
    if (!vecNonMappedDims.empty()) {
      vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(), vecNonMappedDims.end(), findID(tDimId)),
                             vecNonMappedDims.end());
    }
  }
  m_vecNonMappedDims = vecNonMappedDims; // Copy with strong guarantee.
  m_vecAllDims = vecAllDims;
  m_executed = true;
}
 
MDGeometryXMLParser::MDGeometryXMLParser(std::string xmlToProcess)
    : m_executed(false), m_xmlToProcess(std::move(xmlToProcess)) {}
 
MDGeometryXMLParser::MDGeometryXMLParser() : m_executed(false), m_xmlToProcess("") {}
 
Mantid::Geometry::IMDDimension_sptr MDGeometryXMLParser::getXDimension() const {
  validate();
  return m_xDimension;
}
 
Mantid::Geometry::IMDDimension_sptr MDGeometryXMLParser::getYDimension() const {
  validate();
  return m_yDimension;
}
 
Mantid::Geometry::IMDDimension_sptr MDGeometryXMLParser::getZDimension() const {
  validate();
  return m_zDimension;
}
 
Mantid::Geometry::IMDDimension_sptr MDGeometryXMLParser::getTDimension() const {
  validate();
  return m_tDimension;
}
 
Mantid::Geometry::VecIMDDimension_sptr MDGeometryXMLParser::getNonMappedDimensions() const {
  validate();
  return m_vecNonMappedDims;
}
 
Mantid::Geometry::VecIMDDimension_sptr MDGeometryXMLParser::getNonIntegratedDimensions() const {
  validate();
  Mantid::Geometry::VecIMDDimension_sptr temp = m_vecAllDims;
  temp.erase(std::remove_if(temp.begin(), temp.end(), findIntegrated()), temp.end());
  return temp;
}
 
Mantid::Geometry::VecIMDDimension_sptr MDGeometryXMLParser::getIntegratedDimensions() const {
  validate();
  Mantid::Geometry::VecIMDDimension_sptr temp = m_vecAllDims;
  temp.erase(std::remove_if(temp.begin(), temp.end(), std::not_fn(findIntegrated())), temp.end());
  return temp;
}
 
Mantid::Geometry::VecIMDDimension_sptr MDGeometryXMLParser::getAllDimensions() const {
  validate();
  return m_vecAllDims;
}
 
bool MDGeometryXMLParser::hasXDimension() const {
  validate();
  return nullptr != m_xDimension.get();
}
 
bool MDGeometryXMLParser::hasYDimension() const {
  validate();
  return nullptr != m_yDimension.get();
}
 
bool MDGeometryXMLParser::hasZDimension() const {
  validate();
  return nullptr != m_zDimension.get();
}
 
bool MDGeometryXMLParser::hasTDimension() const {
  validate();
  return nullptr != m_tDimension.get();
}
 
void MDGeometryXMLParser::SetRootNodeCheck(std::string elementName) { m_rootNodeName = std::move(elementName); }
 
MDGeometryXMLParser &MDGeometryXMLParser::operator=(const MDGeometryXMLParser &other) {
  if (this != &other) {
    m_executed = other.m_executed;
    m_rootNodeName = other.m_rootNodeName;
    m_vecNonMappedDims = other.m_vecNonMappedDims;
    m_vecAllDims = other.m_vecAllDims;
    m_xDimension = other.m_xDimension;
    m_yDimension = other.m_yDimension;
    m_zDimension = other.m_zDimension;
    m_tDimension = other.m_tDimension;
  }
  return *this;
}
 
MDGeometryXMLParser::MDGeometryXMLParser(const MDGeometryXMLParser &other)
    : m_executed(other.m_executed), m_rootNodeName(other.m_rootNodeName), m_vecNonMappedDims(other.m_vecNonMappedDims),
      m_vecAllDims(other.m_vecAllDims), m_xDimension(other.m_xDimension), m_yDimension(other.m_yDimension),
      m_zDimension(other.m_zDimension), m_tDimension(other.m_tDimension) {}
 
bool MDGeometryXMLParser::isXDimension(const Mantid::Geometry::IMDDimension_sptr &candidate) const {
  validate();
  bool bResult = false;
  if (hasXDimension()) {
    if (candidate->getDimensionId() == m_xDimension->getDimensionId()) {
      bResult = true;
    }
  }
  return bResult;
}
 
bool MDGeometryXMLParser::isYDimension(const Mantid::Geometry::IMDDimension_sptr &candidate) const {
  validate();
  bool bResult = false;
  if (hasYDimension()) {
    if (candidate->getDimensionId() == m_yDimension->getDimensionId()) {
      bResult = true;
    }
  }
  return bResult;
}
 
bool MDGeometryXMLParser::isZDimension(const Mantid::Geometry::IMDDimension_sptr &candidate) const {
  validate();
  bool bResult = false;
  if (hasZDimension()) {
    if (candidate->getDimensionId() == m_zDimension->getDimensionId()) {
      bResult = true;
    }
  }
  return bResult;
}
 
bool MDGeometryXMLParser::isTDimension(const Mantid::Geometry::IMDDimension_sptr &candidate) const {
  validate();
  bool bResult = false;
  if (hasTDimension()) {
    if (candidate->getDimensionId() == m_tDimension->getDimensionId()) {
      bResult = true;
    }
  }
  return bResult;
}
} // namespace Mantid::Geometry