NexusClasses.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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 +
#pragma once
 
#include "MantidNexus/DllConfig.h"
#include "MantidNexus/NexusFile.h"
 
#include <algorithm>
#include <array>
#include <boost/container/vector.hpp>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
 
namespace Mantid {
namespace Nexus {
 
typedef std::array<dimsize_t, 4> NXDimArray;
 
struct NXInfo {
  NXInfo() : nxname(), rank(0), dims(), type(NXnumtype::BAD), allGood(false) {}
  NXInfo(Info const &info, std::string const &name);
  std::string nxname;                 
  std::size_t rank;                   
  NXDimArray dims;                    
  NXnumtype type;                     
  bool allGood;                       
  operator bool() { return allGood; } 
};
 
struct NXClassInfo {
  NXClassInfo(Entry e) : nxname(e.first), nxclass(e.second), datatype(NXnumtype::BAD), allGood(true) {}
  NXClassInfo() : nxname(), nxclass(), datatype(NXnumtype::BAD), allGood(false) {}
  std::string nxname;                 
  std::string nxclass;                
  NXnumtype datatype;                 
  bool allGood;                       
  operator bool() { return allGood; } 
};
 
/*
 * LoadNexusProcessed and SaveNexusProcessed need to share some attributes, put them at namespace level here
 */
 
const int g_processed_blocksize = 8;
 
class MANTID_NEXUS_DLL NXAttributes {
public:
  std::size_t n() const { return m_values.size(); }                 
  std::vector<std::string> names() const;                           
  std::vector<std::string> values() const;                          
  std::string operator()(const std::string &name) const;            
  void set(const std::string &name, const std::string &value);      
  template <typename T> void set(const std::string &name, T value); 
private:
  std::map<std::string, std::string> m_values; 
};
 
// Forward declaration
class NXClass;
 
class MANTID_NEXUS_DLL NXObject {
  friend class NXDataSet; 
  friend class NXClass;   
  friend class NXRoot;    
public:
  // Constructor
  NXObject(File *fileID, NXClass const *parent, std::string const &name);
  NXObject(std::shared_ptr<File> const &fileID, NXClass const *parent, std::string const &name);
  virtual ~NXObject() = default;
  virtual std::string NX_class() const = 0;
  // True if complies with our understanding of the www.nexusformat.org
  // definition.
  // virtual bool isStandard()const = 0;
  NexusAddress const &address() const { return m_address; }
  std::string name() const;
  std::shared_ptr<File> m_fileID;
 
protected:
  NexusAddress m_address; 
  bool m_open;            
private:
  NXObject(); 
};
 
class MANTID_NEXUS_DLL NXDataSet : public NXObject {
public:
  // Constructor
  NXDataSet(NXClass const &parent, std::string const &name);
  std::string NX_class() const override { return "SDS"; }
  void open();
  void openLocal();
  std::size_t rank() const { return m_info.rank; }
  dimsize_t dims(std::size_t i) const { return i < 4 ? m_info.dims[i] : 0; }
  dimsize_t dim0() const;
  dimsize_t dim1() const;
  dimsize_t dim2() const;
  dimsize_t dim3() const;
  std::string name() const { return m_info.nxname; } // cppcheck-suppress returnByReference
  NXnumtype type() const { return m_info.type; }
  NXAttributes attributes;
 
protected:
  template <typename NumT> void getData(NumT *data) {
    m_fileID->openData(name());
    m_fileID->getData(data);
    m_fileID->closeData();
  }
 
  template <typename NumT> void getSlab(NumT *data, DimVector const &start, DimVector const &size) {
    m_fileID->openData(name());
    m_fileID->getSlab(data, start, size);
    m_fileID->closeData();
  }
 
  NXInfo m_info; 
 
private:
  void getAttributes();
};
 
template <typename T>
using container_T = std::conditional_t<std::is_same<T, bool>{}, boost::container::vector<bool>, std::vector<T>>;
 
template <class T> class NXDataSetTyped : public NXDataSet {
 
public:
  NXDataSetTyped(NXClass const &parent, std::string const &name) : NXDataSet(parent, name), m_size(0UL) {}
  const T *operator()() const {
    if (m_data.empty())
      throw std::runtime_error("Attempt to read uninitialized data from " + address());
    return m_data.data();
  }
 
  T *operator()() {
    if (m_data.empty())
      throw std::runtime_error("Attempt to read uninitialized data from " + address());
    return m_data.data();
  }
 
  const T &operator[](std::size_t i) const {
    if (m_data.empty())
      throw std::runtime_error("Attempt to read uninitialized data from " + address());
    if (i >= m_size)
      rangeError();
    return m_data[i];
  }
 
  T &operator[](std::size_t i) { return const_cast<T &>(static_cast<const NXDataSetTyped &>(*this)[i]); }
  const T &operator()(std::size_t i, std::size_t j) const { return this->operator[](i * dim1() + j); }
  T &operator()(std::size_t i, std::size_t j) {
    return const_cast<T &>(static_cast<const NXDataSetTyped &>(*this)(i, j));
  }
  const T &operator()(std::size_t i, std::size_t j, std::size_t k) const {
    return this->operator[]((i * dim1() + j) * dim2() + k);
  }
  T &operator()(std::size_t i, std::size_t j, std::size_t k) {
    return const_cast<T &>(static_cast<const NXDataSetTyped &>(*this)(i, j, k));
  }
 
  container_T<T> &vecBuffer() { return m_data; }
  std::size_t size() const { return m_size; }
 
  void load() {
    const auto rank_local = this->rank();
    if (rank_local > 4) {
      throw std::runtime_error("Cannot load dataset of rank greater than 4");
    }
    // determine total size in memory and allocate it
    std::size_t num_ele = std::accumulate(this->m_info.dims.cbegin(), this->m_info.dims.cbegin() + rank_local,
                                          static_cast<std::size_t>(1), std::multiplies<std::size_t>());
    if constexpr (std::is_same_v<T, char>) {
      // For char type we need to add one for the null terminator
      num_ele += 1;
    }
    this->alloc(static_cast<std::size_t>(num_ele));
 
    // do the actual load
    getData(m_data.data());
 
    if constexpr (std::is_same_v<T, char>) {
      // For char type we need to add a null terminator
      m_data.push_back('\0');
    }
  }
 
  void load(dimsize_t const blocksize, dimsize_t const i) {
    if (rank() > 4) {
      throw std::runtime_error("Cannot load dataset of rank greater than 4");
    }
    dimsize_t n = 0;
    DimVector datastart, datasize;
    if (rank() == 4) {
      if (i >= dim0())
        rangeError();
      n = dim1() * dim2() * dim3();
      datastart = {i, 0, 0, 0};
      datasize = {1, dim1(), dim2(), dim2()};
    } else if (rank() == 3) {
      if (i >= dim0())
        rangeError();
      n = dim1() * dim2();
      datastart = {i, 0, 0};
      datasize = {1, dim1(), dim2()};
    } else if (rank() == 2) {
      if (i >= dim0())
        rangeError();
      dimsize_t m = blocksize;
      if (i + m > dim0())
        m = dim0() - i;
      n = dim1() * m;
      datastart = {i, 0};
      datasize = {m, dim1()};
    } else if (rank() == 1) {
      if (i >= dim0())
        rangeError();
      n = 1 * blocksize;
      datastart = {i};
      datasize = {blocksize};
    }
    alloc(n);
    getSlab(m_data.data(), datastart, datasize);
  }
 
  void load(dimsize_t const blocksize, dimsize_t const i, dimsize_t const j) {
    if (rank() > 4) {
      throw std::runtime_error("Cannot load dataset of rank greater than 4");
    }
    dimsize_t n = 0;
    DimVector datastart, datasize;
    if (rank() == 4) {
      if (i >= dim0() || j >= dim1())
        rangeError();
      n = dim2() * dim3();
      datastart = {i, j, 0, 0};
      datasize = {1, 1, dim2(), dim2()};
    } else if (rank() == 3) {
      if (i >= dim0() || j >= dim1())
        rangeError();
      dimsize_t m = blocksize;
      if (j + m > dim1())
        m = dim1() - j;
      n = dim2() * m;
      datastart = {i, j, 0};
      datasize = {1, m, dim2()};
    } else if (rank() == 2) {
      if (i >= dim0() || j >= dim1())
        rangeError();
      n = 1;
      datastart = {i, j};
      datasize = {1, 1};
    } else if (rank() == 1) {
      if (i >= dim0())
        rangeError();
      n = 1 * blocksize;
      datastart = {i};
      datasize = {blocksize};
    }
    alloc(n);
    getSlab(m_data.data(), datastart, datasize);
  }
 
private:
  void alloc(dimsize_t new_size) {
    if (new_size == 0) {
      throw std::runtime_error("Attempt to load from an empty dataset " + address());
    }
    try {
      if (new_size != m_size) {
        m_data.resize(new_size);
        m_size = new_size;
      }
    } catch (...) {
      std::ostringstream ostr;
      ostr << "Cannot allocate " << new_size * sizeof(T) << " bytes of memory to load the data";
      throw std::runtime_error(ostr.str());
    }
  }
  void rangeError() const { throw std::range_error("Nexus dataset range error"); }
  // We cannot use an STL vector due to the dreaded std::vector<bool>
  container_T<T> m_data; 
  std::size_t m_size;    
};
 
using NXInt = NXDataSetTyped<int32_t>;
using NXInt64 = NXDataSetTyped<int64_t>;
using NXUInt32 = NXDataSetTyped<int32_t>;
using NXUInt64 = NXDataSetTyped<uint64_t>;
using NXFloat = NXDataSetTyped<float>;
using NXDouble = NXDataSetTyped<double>;
using NXChar = NXDataSetTyped<char>;
 
//-------------------- classes --------------------------//
 
class MANTID_NEXUS_DLL NXClass : public NXObject {
  friend class NXRoot;
 
public:
  NXClass(NXClass const &parent, std::string const &name);
  std::string NX_class() const override { return "NXClass"; }
 
  bool isValid(const std::string &address) const;
  template <class NX> NX openNXClass(const std::string &name) const {
    NX nxc(*this, name);
    nxc.open();
    return nxc;
  }
 
  NXClass openNXGroup(const std::string &name) const { return openNXClass<NXClass>(name); }
 
  template <class T> NXDataSetTyped<T> openNXDataSet(const std::string &name) const {
    NXDataSetTyped<T> data(*this, name);
    data.open();
    return data;
  }
 
  NXInt openNXInt(const std::string &name) const { return openNXDataSet<int32_t>(name); }
  NXFloat openNXFloat(const std::string &name) const { return openNXDataSet<float>(name); }
  NXDouble openNXDouble(const std::string &name) const { return openNXDataSet<double>(name); }
  NXChar openNXChar(const std::string &name) const { return openNXDataSet<char>(name); }
  NXUInt64 openNXSize(const std::string &name) const { return openNXDataSet<uint64_t>(name); }
  std::string getString(const std::string &name) const;
  double getDouble(const std::string &name) const;
  float getFloat(const std::string &name) const;
  int32_t getInt(const std::string &name) const;
 
  std::vector<NXClassInfo> &groups() const { return *m_groups; }
  bool containsGroup(const std::string &query) const;
  std::vector<NXInfo> &datasets() const { return *m_datasets; }
  NXInfo getDataSetInfo(const std::string &name) const;
  bool containsDataSet(const std::string &query) const;
  void close();
  void open();
  bool openLocal(const std::string &nxclass = "");
 
protected:
  std::shared_ptr<std::vector<NXClassInfo>> m_groups; 
  std::shared_ptr<std::vector<NXInfo>> m_datasets;    
  void readAllInfo();                                 
  void clear();                                       
private:
  NXClass() : NXObject() { clear(); }
};
 
//-------------------- main classes -------------------------------//
 
class MANTID_NEXUS_DLL NXData : public NXClass {
public:
  NXData(const NXClass &parent, const std::string &name);
  std::string NX_class() const override { return "NXdata"; }
  template <typename T> NXDataSetTyped<T> openData() {
    for (std::vector<NXInfo>::const_iterator it = datasets().begin(); it != datasets().end(); ++it) {
      NXDataSet dset(*this, it->nxname);
      dset.open();
      if (dset.attributes("signal") == "1") {
        return openNXDataSet<T>(it->nxname);
      }
    }
    // You failed to find the signal.
    // So try to just open the "data" entry directly
    return openNXDataSet<T>("data");
  }
  NXDouble openDoubleData() { return openData<double>(); }
  NXFloat openFloatData() { return openData<float>(); }
  NXInt openIntData() { return openData<int32_t>(); }
};
 
class MANTID_NEXUS_DLL NXDetector : public NXClass {
public:
  NXDetector(const NXClass &parent, const std::string &name) : NXClass(parent, name) {}
  std::string NX_class() const override { return "NXdetector"; }
  NXFloat openDistance() { return openNXFloat("distance"); }
  NXFloat openAzimuthalAngle() { return openNXFloat("azimuthal_angle"); }
  NXFloat openPolarAngle() { return openNXFloat("polar_angle"); }
};
 
class MANTID_NEXUS_DLL NXInstrument : public NXClass {
public:
  NXInstrument(const NXClass &parent, const std::string &name) : NXClass(parent, name) {}
  std::string NX_class() const override { return "NXinstrument"; }
  NXDetector openNXDetector(const std::string &name) { return openNXClass<NXDetector>(name); }
};
 
class MANTID_NEXUS_DLL NXEntry : public NXClass {
public:
  NXEntry(const NXClass &parent, const std::string &name) : NXClass(parent, name) {}
  std::string NX_class() const override { return "NXentry"; }
  NXData openNXData(const std::string &name) const { return openNXClass<NXData>(name); }
  NXInstrument openNXInstrument(const std::string &name) const { return openNXClass<NXInstrument>(name); }
};
 
class MANTID_NEXUS_DLL NXRoot : public NXClass {
public:
  // Constructor
  NXRoot(std::string fname);
  // Constructor
  NXRoot(std::string fname, const std::string &entry);
  ~NXRoot() override;
  std::string NX_class() const override { return "NXroot"; }
  bool isStandard() const;
  NXEntry openEntry(const std::string &name) { return openNXClass<NXEntry>(name); }
  NXEntry openFirstEntry();
 
private:
  const std::string m_filename; 
};
 
} // namespace Nexus
} // namespace Mantid