NexusClasses.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 "MantidNexus/NexusClasses.h"
#include "MantidNexus/NexusException.h"
 
#include <memory>
#include <utility>
 
namespace Mantid::Nexus {
 
static NXDimArray nxdimArray(const DimVector &xd) {
  NXDimArray ret{0};
  for (std::size_t i = 0; i < xd.size(); i++) {
    ret[i] = xd[i];
  }
  return ret;
}
 
NXInfo::NXInfo(Info const &info, std::string const &name)
    : nxname(name), rank(info.dims.size()), dims(nxdimArray(info.dims)), type(info.type), allGood(true) {}
 
std::vector<std::string> NXAttributes::names() const {
  std::vector<std::string> out;
  out.reserve(m_values.size());
  std::transform(m_values.cbegin(), m_values.cend(), std::back_inserter(out),
                 [](auto const &value) -> std::string { return value.first; });
  return out;
}
 
std::vector<std::string> NXAttributes::values() const {
  std::vector<std::string> out;
  out.reserve(m_values.size());
  std::transform(m_values.cbegin(), m_values.cend(), std::back_inserter(out),
                 [](auto const &value) -> std::string { return value.second; });
  return out;
}
 
std::string NXAttributes::operator()(const std::string &name) const {
  auto it = m_values.find(name);
  if (it == m_values.end())
    return "";
  return it->second;
}
 
void NXAttributes::set(const std::string &name, const std::string &value) { m_values[name] = value; }
 
template <typename T> void NXAttributes::set(const std::string &name, T value) {
  m_values[name] = std::to_string(value);
}
 
//---------------------------------------------------------
//          NXObject methods
//---------------------------------------------------------
 
NXObject::NXObject() : m_fileID(nullptr), m_open(false) {}
 
NXObject::NXObject(File *fileID, NXClass const *parent, const std::string &name) : m_fileID(fileID), m_open(false) {
  if (parent && !name.empty()) {
    m_address = parent->address() / name;
  }
}
 
NXObject::NXObject(std::shared_ptr<File> const &fileID, NXClass const *parent, const std::string &name)
    : m_fileID(fileID), m_open(false) {
  if (parent && !name.empty()) {
    m_address = parent->address() / name;
  }
}
 
std::string NXObject::name() const { return m_address.stem(); }
 
void NXDataSet::getAttributes() {
  std::vector<char> buff(128);
  for (AttrInfo const &ainfo : m_fileID->getAttrInfos()) {
    if (ainfo.type != NXnumtype::CHAR && ainfo.length != 1) {
      throw std::runtime_error("Encountered attribute with array value");
    }
 
    switch (ainfo.type) {
    case NXnumtype::CHAR: {
      attributes.set(ainfo.name, m_fileID->getStrAttr(ainfo.name));
      break;
    }
    case NXnumtype::INT16: {
      attributes.set(ainfo.name, m_fileID->getAttr<int16_t>(ainfo.name));
      break;
    }
    case NXnumtype::UINT16: {
      attributes.set(ainfo.name, m_fileID->getAttr<uint16_t>(ainfo.name));
      break;
    }
    case NXnumtype::INT32: {
      attributes.set(ainfo.name, m_fileID->getAttr<int32_t>(ainfo.name));
      break;
    }
    default:
      break;
    }
  };
}
//---------------------------------------------------------
//          NXClass methods
//---------------------------------------------------------
 
NXClass::NXClass(const NXClass &parent, const std::string &name) : NXObject(parent.m_fileID, &parent, name) { clear(); }
 
void NXClass::readAllInfo() {
  clear();
  for (auto const &entry : m_fileID->getEntries()) {
    if (entry.second == "SDS") {
      m_fileID->openData(entry.first);
      NXInfo info(m_fileID->getInfo(), entry.first);
      m_fileID->closeData();
      m_datasets->emplace_back(info);
    } else if (entry.second.starts_with("NX") || entry.second.starts_with("IX")) {
      m_groups->emplace_back(NXClassInfo(entry));
    }
  }
}
 
bool NXClass::isValid(const std::string &address) const { return m_fileID->hasAddress(address); }
 
void NXClass::open() {
  m_fileID->openGroupAddress(m_address);
  m_open = true;
  readAllInfo();
}
 
bool NXClass::openLocal(const std::string &nxclass) {
  std::string className = nxclass.empty() ? NX_class() : nxclass;
  try {
    m_fileID->openGroup(name(), className);
  } catch (Exception const &) {
    return false;
  }
  m_open = true;
  readAllInfo();
  return true;
}
 
void NXClass::close() {
  try {
    m_fileID->closeGroup();
  } catch (Exception const &) {
    throw std::runtime_error("Cannot close group " + name() + " of class " + NX_class() + " (trying to close address " +
                             m_address + ")");
  }
  m_open = false;
}
 
void NXClass::clear() {
  m_groups.reset(new std::vector<NXClassInfo>);
  m_datasets.reset(new std::vector<NXInfo>);
}
 
std::string NXClass::getString(const std::string &name) const {
  NXChar buff = openNXChar(name);
  try {
    buff.load();
    return std::string(buff(), buff.dim0());
  } catch (std::runtime_error &) {
    // deals with reading uninitialized/empty data
    return std::string();
  }
}
 
double NXClass::getDouble(const std::string &name) const {
  NXDouble number = openNXDouble(name);
  number.load();
  return *number();
}
 
float NXClass::getFloat(const std::string &name) const {
  NXFloat number = openNXFloat(name);
  number.load();
  return *number();
}
 
int32_t NXClass::getInt(const std::string &name) const {
  NXInt number = openNXInt(name);
  number.load();
  return *number();
}
bool NXClass::containsGroup(const std::string &query) const {
  return std::any_of(m_groups->cbegin(), m_groups->cend(),
                     [&query](const auto &group) { return group.nxname == query; });
}
 
NXInfo NXClass::getDataSetInfo(const std::string &name) const {
  const auto it = std::find_if(datasets().cbegin(), datasets().cend(),
                               [&name](const auto &dataset) { return dataset.nxname == name; });
  NXInfo info;
  if (it != datasets().cend()) {
    info = *it;
  } else {
    info.allGood = false;
  }
  return info;
}
 
bool NXClass::containsDataSet(const std::string &query) const { return getDataSetInfo(query).allGood; }
 
//---------------------------------------------------------
//          NXRoot methods
//---------------------------------------------------------
 
NXRoot::NXRoot(std::string fname) : m_filename(std::move(fname)) {
  // Open Nexus file
  try {
    m_fileID = std::make_shared<File>(m_filename, NXaccess::READ);
  } catch (Exception const &e) {
    std::cout << "NXRoot: Error loading " << m_filename << "\" in read mode: " << e.what() << "\n";
    throw;
  }
  readAllInfo();
}
 
NXRoot::NXRoot(std::string fname, const std::string &entry) : m_filename(std::move(fname)) {
  UNUSED_ARG(entry);
  // Open Nexus file
  m_fileID = std::make_shared<File>(m_filename, NXaccess::CREATE5);
}
 
NXRoot::~NXRoot() {
  try {
    m_fileID->close();
  } catch (...) {
    // do nothing
  }
}
 
bool NXRoot::isStandard() const { return true; }
 
NXEntry NXRoot::openFirstEntry() {
  if (groups().empty()) {
    throw std::runtime_error("Nexus file has no entries");
  }
  const auto it =
      std::find_if(groups().cbegin(), groups().cend(), [](const auto &group) { return group.nxclass == "NXentry"; });
  if (it != groups().cend()) {
    return openEntry(it->nxname);
  }
  throw std::runtime_error("Nexus file has no entries");
}
 
//---------------------------------------------------------
//          NXDataSet methods
//---------------------------------------------------------
 
NXDataSet::NXDataSet(const NXClass &parent, const std::string &name) : NXObject(parent.m_fileID, &parent, name) {
  size_t i = name.find_last_of('/');
  if (i == std::string::npos)
    m_info.nxname = name;
  else if (name.empty() || i == name.size() - 1)
    throw std::runtime_error("Improper dataset name " + name);
  else
    m_info.nxname = name.substr(i + 1);
}
 
// Opens the data set. Does not read in any data. Call load(...) to load the data
void NXDataSet::open() {
  NexusAddress group_address(m_address.parent_path());
  if (group_address == NexusAddress::root())
    return; // we are in the root group, assume it is open
  m_fileID->openAddress(group_address);
  m_fileID->openData(name());
  m_info = NXInfo(m_fileID->getInfo(), name());
  getAttributes();
  m_fileID->closeData();
}
 
void NXDataSet::openLocal() {
  m_fileID->openData(name());
  m_info = NXInfo(m_fileID->getInfo(), name());
  getAttributes();
  m_fileID->closeData();
}
 
dimsize_t NXDataSet::dim0() const {
  if (m_info.rank == 0UL) {
    throw std::out_of_range("NXDataSet::dim0() - Requested dimension greater than rank.");
  }
  return m_info.dims[0];
}
 
dimsize_t NXDataSet::dim1() const {
  if (m_info.rank < 2) {
    throw std::out_of_range("NXDataSet::dim1() - Requested dimension greater than rank.");
  }
  return m_info.dims[1];
}
 
dimsize_t NXDataSet::dim2() const {
  if (m_info.rank < 3) {
    throw std::out_of_range("NXDataSet::dim2() - Requested dimension greater than rank.");
  }
  return m_info.dims[2];
}
 
dimsize_t NXDataSet::dim3() const {
  if (m_info.rank < 4) {
    throw std::out_of_range("NXDataSet::dim3() - Requested dimension greater than rank.");
  }
  return m_info.dims[3];
}
 
//---------------------------------------------------------
//          NXData methods
//---------------------------------------------------------
 
NXData::NXData(const NXClass &parent, const std::string &name) : NXClass(parent, name) {}
 
} // namespace Mantid::Nexus