MaterialXMLParser.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 "MantidKernel/MaterialXMLParser.h"
#include "MantidKernel/MaterialBuilder.h"
 
#include "Poco/DOM/AutoPtr.h"
#include "Poco/DOM/DOMParser.h"
#include "Poco/DOM/Document.h"
#include "Poco/DOM/NamedNodeMap.h"
#include "Poco/DOM/NodeFilter.h"
#include "Poco/DOM/NodeIterator.h"
#include "Poco/SAX/InputSource.h"
#include "Poco/SAX/SAXException.h"
 
#include <boost/lexical_cast.hpp>
 
#include <sstream>
#include <type_traits>
#include <unordered_map>
 
namespace Mantid::Kernel {
 
// -----------------------------------------------------------------------------
// Anonymous methods
// -----------------------------------------------------------------------------
namespace {
 
/*
 * Define the list of known attributes along with a map to the relevant
 * MaterialBuilder method to call. This avoids a long list of if/else
 * statements when parsing the xml.
 *
 * The mapping uses a template type, TypedBuilderHandle, to store the method
 * on the MaterialBuilder that should be called and the template type indicates
 * the argument type of the method call. The struct automatically extracts
 * the expected value type from the given string based on the template type.
 */
 
// Known attributes
const char *ID_ATT = "id";
const char *FORMULA_ATT = "formula";
const char *ATOMNUM_ATT = "atomicnumber";
const char *MASSNUM_ATT = "massnumber";
const char *NDENSITY_ATT = "numberdensity";
const char *ZPARAM_ATT = "zparameter";
const char *CELLVOL_ATT = "unitcellvol";
const char *MASSDENS_ATT = "massdensity";
const char *TOTSC_ATT = "totalscatterxsec";
const char *COHSC_ATT = "cohscatterxsec";
const char *INCOHSC_ATT = "incohscatterxsec";
const char *ABSORB_ATT = "absorptionxsec";
const char *ATTENPROF_ATT = "attenuationprofile";
const char *ATTENPROFX_ATT = "xrayattenuationprofile";
 
// Base type to put in a hash
struct BuilderHandle {
  virtual ~BuilderHandle() = default;
  virtual void operator()(MaterialBuilder &builder, const std::string &value) const = 0;
};
using BuilderHandle_uptr = std::unique_ptr<BuilderHandle>;
 
// Pointer to member function on MaterialBuilder
template <typename ArgType> using BuilderMethod = MaterialBuilder &(MaterialBuilder::*)(ArgType);
 
// Template type where ArgType indicates the expected argument type including
// const & ref qualifiers
template <typename ArgType> struct TypedBuilderHandle final : public BuilderHandle {
  // Remove const/reference qualifiers from ArgType
  using ValueType = typename std::remove_const<typename std::remove_reference<ArgType>::type>::type;
 
  explicit TypedBuilderHandle(BuilderMethod<ArgType> m) : BuilderHandle(), m_method(m) {}
 
  void operator()(MaterialBuilder &builder, const std::string &value) const override {
    auto typedVal = boost::lexical_cast<ValueType>(value);
    (builder.*m_method)(typedVal);
  }
 
private:
  BuilderMethod<ArgType> m_method;
};
 
using Handlers = std::unordered_map<std::string, BuilderHandle_uptr>;
 
// Insert a handle into the given map
template <typename ArgType> void insertHandle(Handlers *hash, const std::string &name, BuilderMethod<ArgType> m) {
  hash->insert(std::make_pair(name, BuilderHandle_uptr(new TypedBuilderHandle<ArgType>(m))));
}
 
// Find the appropriate handler for a given attribute
const BuilderHandle &findHandle(const std::string &name) {
  static Handlers handles;
  if (handles.empty()) {
    insertHandle(&handles, ID_ATT, &MaterialBuilder::setName);
    insertHandle(&handles, FORMULA_ATT, &MaterialBuilder::setFormula);
    insertHandle(&handles, ATOMNUM_ATT, &MaterialBuilder::setAtomicNumber);
    insertHandle(&handles, MASSNUM_ATT, &MaterialBuilder::setMassNumber);
    insertHandle(&handles, NDENSITY_ATT, &MaterialBuilder::setNumberDensity);
    insertHandle(&handles, ZPARAM_ATT, &MaterialBuilder::setZParameter);
    insertHandle(&handles, CELLVOL_ATT, &MaterialBuilder::setUnitCellVolume);
    insertHandle(&handles, MASSDENS_ATT, &MaterialBuilder::setMassDensity);
    insertHandle(&handles, TOTSC_ATT, &MaterialBuilder::setTotalScatterXSection);
    insertHandle(&handles, COHSC_ATT, &MaterialBuilder::setCoherentXSection);
    insertHandle(&handles, INCOHSC_ATT, &MaterialBuilder::setIncoherentXSection);
    insertHandle(&handles, ABSORB_ATT, &MaterialBuilder::setAbsorptionXSection);
    insertHandle(&handles, ATTENPROF_ATT, &MaterialBuilder::setAttenuationProfileFilename);
    insertHandle(&handles, ATTENPROFX_ATT, &MaterialBuilder::setXRayAttenuationProfileFilename);
  }
  auto iter = handles.find(name);
  if (iter != handles.end())
    return *(iter->second);
  else
    throw std::runtime_error("Unknown material attribute '" + name + "'");
}
 
void addToBuilder(MaterialBuilder *builder, const std::string &attr, const std::string &value) {
  // Find the appropriate member function on the builder and set the value
  // We need 3 maps for the 3 allowable value types for the builder member
  // functions
  const auto &setter = findHandle(attr);
  setter(*builder, value);
}
} // namespace
 
// -----------------------------------------------------------------------------
// Public methods
// -----------------------------------------------------------------------------
 
Material MaterialXMLParser::parse(std::istream &istr) const {
  using namespace Poco::XML;
  using DocumentPtr = AutoPtr<Document>;
 
  InputSource src(istr);
  DOMParser parser;
  // Do not use auto here or anywhereas the Poco API returns raw pointers
  // but in some circumstances requires AutoPtrs to manage the memory
  DocumentPtr doc;
  try {
    doc = parser.parse(&src);
  } catch (SAXParseException &exc) {
    std::ostringstream os;
    os << "MaterialXMLReader::read() - Error parsing stream as XML: " << exc.what();
    throw std::invalid_argument(os.str());
  }
 
  Element *rootElement = doc->documentElement();
 
  // Iterating is apparently much faster than getElementsByTagName
  NodeIterator nodeIter(rootElement, NodeFilter::SHOW_ELEMENT);
  Node *node = nodeIter.nextNode();
  Material matr;
  bool found(false);
  while (node) {
    if (node->nodeName() == MATERIAL_TAG) {
      matr = parse(static_cast<Element *>(node));
      found = true;
      break;
    }
    node = nodeIter.nextNode();
  }
  if (!found) {
    throw std::invalid_argument("MaterialXMLReader::read() - No material tags found.");
  }
  return matr;
}
 
Material MaterialXMLParser::parse(Poco::XML::Element *element, const std::string &XMLFilePath) const {
  using namespace Poco::XML;
  using NamedNodeMapPtr = AutoPtr<NamedNodeMap>;
  NamedNodeMapPtr attrs = element->attributes();
  const auto id = attrs->getNamedItem(ID_ATT);
  if (!id || id->nodeValue().empty()) {
    throw std::invalid_argument("MaterialXMLReader::read() - No 'id' tag found "
                                "or emptry string provided.");
  }
  attrs->removeNamedItem(ID_ATT);
 
  MaterialBuilder builder;
  builder.setName(id->nodeValue());
  builder.setAttenuationSearchPath(XMLFilePath);
  const auto nattrs = attrs->length();
  for (unsigned long i = 0; i < nattrs; ++i) {
    Node *node = attrs->item(i);
    addToBuilder(&builder, node->nodeName(), node->nodeValue());
  }
  return builder.build();
}
 
} // namespace Mantid::Kernel