MDHistoDimension.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 "MantidGeometry/MDGeometry/MDHistoDimension.h"
#include "MantidKernel/MDUnit.h"
#include "MantidKernel/UnitLabel.h"
#include <memory>
#include <sstream>
#include <stdexcept>
 
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>
 
#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/Text.h>
 
namespace Mantid::Geometry {
 
void MDHistoDimension::setUnits(const Kernel::UnitLabel &units) {
  // Build a replacement unit that preserves the frame's Q-ness. The workspace's
  // special coordinate system is derived from the unit's isQUnit() (see
  // MDFramesToSpecialCoordinateSystem), so a Q frame must keep a Q unit. Discriminate
  // on the frame itself, not the current unit's isQUnit(): a general frame may already
  // carry a Q-like label (e.g. "A^-1") yet must still accept arbitrary relabelling.
  std::unique_ptr<Kernel::MDUnit> newUnit;
  if (m_frame->isQ()) {
    newUnit = std::make_unique<Kernel::ReciprocalLatticeUnit>(units);
  } else {
    newUnit = std::make_unique<Kernel::LabelUnit>(units);
  }
 
  // Snapshot the current unit so we can roll back if the new label is not honoured.
  std::unique_ptr<Kernel::MDUnit> previousUnit(m_frame->getMDUnit().clone());
 
  if (!m_frame->setMDUnit(*newUnit)) {
    throw std::invalid_argument("Cannot set units on dimension '" + m_name + "': its '" + m_frame->name() +
                                "' frame has a fixed unit and does not support relabelling. Use the SetMDFrame "
                                "algorithm to change the frame instead.");
  }
 
  // Some frames (e.g. HKL) silently revert a label they do not accept; reject rather
  // than leave the dimension showing an unexpected label.
  if (m_frame->getUnitLabel().ascii() != units.ascii()) {
    m_frame->setMDUnit(*previousUnit); // roll back so the dimension is unchanged
    throw std::invalid_argument(
        "Cannot set units to '" + units.ascii() + "' on dimension '" + m_name +
        "': an HKL (reciprocal-lattice) dimension only accepts 'r.l.u.' or an inverse-Angstrom-style label of the "
        "form 'in <value> A^-1' (e.g. 'in 2.5 A^-1'), used for non-orthogonal projections. Use the SetMDFrame "
        "algorithm to assign an arbitrary unit label.");
  }
}
 
std::string MDHistoDimension::toXMLString() const {
  using namespace Poco::XML;
 
  // Create the root element for this fragment.
  AutoPtr<Document> pDoc = new Document;
  AutoPtr<Element> pDimensionElement = pDoc->createElement("Dimension");
  pDoc->appendChild(pDimensionElement);
 
  // Set the id.
  AutoPtr<Attr> idAttribute = pDoc->createAttribute("ID");
  idAttribute->setNodeValue(this->getDimensionId());
  pDimensionElement->setAttributeNode(idAttribute);
 
  // Set the name.
  AutoPtr<Element> nameElement = pDoc->createElement("Name");
  AutoPtr<Text> nameText = pDoc->createTextNode(this->getName());
  nameElement->appendChild(nameText);
  pDimensionElement->appendChild(nameElement);
 
  // Set the units.
  AutoPtr<Element> unitsElement = pDoc->createElement("Units");
  AutoPtr<Text> unitsText = pDoc->createTextNode(this->getUnits());
  unitsElement->appendChild(unitsText);
  pDimensionElement->appendChild(unitsElement);
 
  // Set the frame.
  AutoPtr<Element> frameElement = pDoc->createElement("Frame");
  AutoPtr<Text> frameText = pDoc->createTextNode(this->getMDFrame().name());
  frameElement->appendChild(frameText);
  pDimensionElement->appendChild(frameElement);
 
  // Set the upper bounds
  AutoPtr<Element> upperBoundsElement = pDoc->createElement("UpperBounds");
  AutoPtr<Text> upperBoundsText = pDoc->createTextNode(boost::str(boost::format("%.4f") % this->getMaximum()));
  upperBoundsElement->appendChild(upperBoundsText);
  pDimensionElement->appendChild(upperBoundsElement);
 
  // Set the lower bounds
  AutoPtr<Element> lowerBoundsElement = pDoc->createElement("LowerBounds");
  AutoPtr<Text> lowerBoundsText = pDoc->createTextNode(boost::str(boost::format("%.4f") % this->getMinimum()));
  lowerBoundsElement->appendChild(lowerBoundsText);
  pDimensionElement->appendChild(lowerBoundsElement);
 
  // Set the number of bins
  AutoPtr<Element> numberOfBinsElement = pDoc->createElement("NumberOfBins");
  AutoPtr<Text> numberOfBinsText = pDoc->createTextNode(boost::str(boost::format("%.4d") % this->getNBins()));
  numberOfBinsElement->appendChild(numberOfBinsText);
  pDimensionElement->appendChild(numberOfBinsElement);
 
  // Provide upper and lower limits for integrated dimensions.
  if (this->getIsIntegrated()) {
    AutoPtr<Element> integratedElement = pDoc->createElement("Integrated");
    // Set the upper limit
    AutoPtr<Element> upperLimitElement = pDoc->createElement("UpperLimit");
    AutoPtr<Text> upperLimitText =
        pDoc->createTextNode(boost::str(boost::format("%.4f") % this->getMaximum())); // Dimension does not yet
                                                                                      // provide integration
                                                                                      // ranges.
    upperLimitElement->appendChild(upperLimitText);
    integratedElement->appendChild(upperLimitElement);
 
    // Set the lower limit
    AutoPtr<Element> lowerLimitElement = pDoc->createElement("LowerLimit");
    AutoPtr<Text> lowerLimitText =
        pDoc->createTextNode(boost::str(boost::format("%.4f") % this->getMinimum())); // Dimension does not yet
                                                                                      // provide integration
                                                                                      // ranges.
    lowerLimitElement->appendChild(lowerLimitText);
    integratedElement->appendChild(lowerLimitElement);
 
    pDimensionElement->appendChild(integratedElement);
  }
 
  // Create a string representation of the DOM tree.
  std::stringstream xmlstream;
  DOMWriter writer;
  writer.writeNode(xmlstream, pDoc);
 
  return xmlstream.str();
}
} // namespace Mantid::Geometry