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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/Sample.h"
#include "MantidKernel/DateAndTimeHelpers.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidNexus/DllConfig.h"
 
#include <boost/container/vector.hpp>
#include <nexus/napi.h>
 
#include <map>
#include <memory>
#include <string>
#include <vector>
//----------------------------------------------------------------------
// Forward declaration
//----------------------------------------------------------------------
 
namespace Mantid {
namespace NeXus {
 
struct NXInfo {
  NXInfo() : nxname(), rank(0), dims(), type(-1), stat(NX_ERROR) {}
  std::string nxname;                       
  int rank;                                 
  int dims[4];                              
  int type;                                 
  NXstatus stat;                            
  operator bool() { return stat == NX_OK; } 
};
 
struct NXClassInfo {
  NXClassInfo() : nxname(), nxclass(), datatype(-1), stat(NX_ERROR) {}
  std::string nxname;  
  std::string nxclass; 
  int datatype;        
  NXstatus stat;                            
  operator bool() { return stat == NX_OK; } 
};
 
const int g_processed_blocksize = 8;
 
class MANTID_NEXUS_DLL NXAttributes {
public:
  int n() const { return int(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); 
  void set(const std::string &name,
           double value); 
private:
  std::map<std::string, std::string> m_values; 
};
 
class NXClass;
 
class MANTID_NEXUS_DLL NXObject {
  friend class NXDataSet; 
  friend class NXClass;   
  friend class NXRoot;    
public:
  // Constructor
  NXObject(const NXhandle fileID, const NXClass *parent, const std::string &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;
  std::string path() const { return m_path; }
  std::string name() const;
  NXAttributes attributes;
  NXhandle m_fileID;
 
protected:
  std::string m_path; 
  bool m_open;        
private:
  NXObject() : m_fileID(), m_open(false) {} 
  void getAttributes();
};
 
class MANTID_NEXUS_DLL NXDataSet : public NXObject {
public:
  // Constructor
  NXDataSet(const NXClass &parent, const std::string &name);
  std::string NX_class() const override { return "SDS"; }
  void open();
  void openLocal();
  int rank() const { return m_info.rank; }
  int dims(int i) const { return i < 4 ? m_info.dims[i] : 0; }
  int dim0() const;
  int dim1() const;
  int dim2() const;
  int dim3() const;
  std::string name() const { return m_info.nxname; }
  int type() const { return m_info.type; }
  virtual void load(const int blocksize = 1, int i = -1, int j = -1, int k = -1, int l = -1) {
    // Avoid compiler warnings
    (void)blocksize;
    (void)i;
    (void)j;
    (void)k;
    (void)l;
  };
 
protected:
  void getData(void *data);
  void getSlab(void *data, int start[], int size[]);
 
private:
  NXInfo m_info; 
};
 
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(const NXClass &parent, const std::string &name) : NXDataSet(parent, name), m_n(0) {}
  const T *operator()() const {
    if (m_data.empty())
      throw std::runtime_error("Attempt to read uninitialized data from " + path());
    return m_data.data();
  }
 
  T *operator()() {
    if (m_data.empty())
      throw std::runtime_error("Attempt to read uninitialized data from " + path());
    return m_data.data();
  }
 
  const T &operator[](int i) const {
    if (m_data.empty())
      throw std::runtime_error("Attempt to read uninitialized data from " + path());
    if (i < 0 || i >= m_n)
      rangeError();
    return m_data[i];
  }
 
  T &operator[](int i) { return const_cast<T &>(static_cast<const NXDataSetTyped &>(*this)[i]); }
  const T &operator()(int i, int j) const { return this->operator[](i *dim1() + j); }
  T &operator()(int i, int j) { return const_cast<T &>(static_cast<const NXDataSetTyped &>(*this)(i, j)); }
  const T &operator()(int i, int j, int k) const { return this->operator[]((i * dim1() + j) * dim2() + k); }
  T &operator()(int i, int j, int k) { return const_cast<T &>(static_cast<const NXDataSetTyped &>(*this)(i, j, k)); }
 
  container_T<T> &vecBuffer() { return m_data; }
  int size() const { return m_n; }
  void load(const int blocksize = 1, int i = -1, int j = -1, int k = -1, int l = -1) override {
    if (rank() > 4) {
      throw std::runtime_error("Cannot load dataset of rank greater than 4");
    }
    int n = 0;
    int start[4];
    if (rank() == 4) {
      if (i < 0) // load all data
      {
        n = dim0() * dim1() * dim2() * dim3();
        alloc(n);
        getData(m_data.data());
        return;
      } else if (j < 0) {
        if (i >= dim0())
          rangeError();
        n = dim1() * dim2() * dim3();
        start[0] = i;
        m_size[0] = 1;
        start[1] = 0;
        m_size[1] = dim1();
        start[2] = 0;
        m_size[2] = dim2();
        start[3] = 0;
        m_size[3] = dim2();
      } else if (k < 0) {
        if (i >= dim0() || j >= dim1())
          rangeError();
        n = dim2() * dim3();
        start[0] = i;
        m_size[0] = 1;
        start[1] = j;
        m_size[1] = 1;
        start[2] = 0;
        m_size[2] = dim2();
        start[3] = 0;
        m_size[3] = dim2();
      } else if (l < 0) {
        if (i >= dim0() || j >= dim1() || k >= dim2())
          rangeError();
        n = dim3();
        start[0] = i;
        m_size[0] = 1;
        start[1] = j;
        m_size[1] = 1;
        start[2] = k;
        m_size[2] = 1;
        start[3] = 0;
        m_size[3] = dim2();
      } else {
        if (i >= dim0() || j >= dim1() || k >= dim2() || l >= dim3())
          rangeError();
        n = dim3();
        start[0] = i;
        m_size[0] = 1;
        start[1] = j;
        m_size[1] = 1;
        start[2] = k;
        m_size[2] = 1;
        start[3] = l;
        m_size[3] = 1;
      }
    } else if (rank() == 3) {
      if (i < 0) {
        n = dim0() * dim1() * dim2();
        alloc(n);
        getData(m_data.data());
        return;
      } else if (j < 0) {
        if (i >= dim0())
          rangeError();
        n = dim1() * dim2();
        start[0] = i;
        m_size[0] = 1;
        start[1] = 0;
        m_size[1] = dim1();
        start[2] = 0;
        m_size[2] = dim2();
      } else if (k < 0) {
        if (i >= dim0() || j >= dim1())
          rangeError();
        int m = blocksize;
        if (j + m > dim1())
          m = dim1() - j;
        n = dim2() * m;
        start[0] = i;
        m_size[0] = 1;
        start[1] = j;
        m_size[1] = m;
        start[2] = 0;
        m_size[2] = dim2();
      } else {
        if (i >= dim0() || j >= dim1() || k >= dim2())
          rangeError();
        n = 1;
        start[0] = i;
        m_size[0] = 1;
        start[1] = j;
        m_size[1] = 1;
        start[2] = k;
        m_size[2] = 1;
      }
    } else if (rank() == 2) {
      if (i < 0) {
        n = dim0() * dim1();
        alloc(n);
        getData(m_data.data());
        return;
      } else if (j < 0) {
        if (i >= dim0())
          rangeError();
        int m = blocksize;
        if (i + m > dim0())
          m = dim0() - i;
        n = dim1() * m;
        start[0] = i;
        m_size[0] = m;
        start[1] = 0;
        m_size[1] = dim1();
      } else {
        if (i >= dim0() || j >= dim1())
          rangeError();
        n = 1;
        start[0] = i;
        m_size[0] = 1;
        start[1] = j;
        m_size[1] = 1;
      }
    } else if (rank() == 1) {
      if (i < 0) {
        n = dim0();
        alloc(n);
        getData(m_data.data());
        return;
      } else {
        if (i >= dim0())
          rangeError();
        n = 1 * blocksize;
        start[0] = i;
        m_size[0] = blocksize;
      }
    }
    alloc(n);
    getSlab(m_data.data(), start, m_size);
  }
 
private:
  void alloc(int n) {
    if (n <= 0) {
      throw std::runtime_error("Attempt to load from an empty dataset " + path());
    }
    try {
      if (m_n != n) {
        m_data.resize(n);
        m_n = n;
      }
    } catch (...) {
      std::ostringstream ostr;
      ostr << "Cannot allocate " << n * 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; 
  int m_size[4];         
  int m_n;               
};
 
using NXInt = NXDataSetTyped<int>;
using NXFloat = NXDataSetTyped<float>;
using NXDouble = NXDataSetTyped<double>;
using NXChar = NXDataSetTyped<char>;
using NXSize = NXDataSetTyped<std::size_t>;
using NXUInt = NXDataSetTyped<unsigned int>;
 
//-------------------- classes --------------------------//
 
class MANTID_NEXUS_DLL NXClass : public NXObject {
  friend class NXRoot;
 
public:
  NXClass(const NXClass &parent, const std::string &name);
  std::string NX_class() const override { return "NXClass"; }
  NXClassInfo getNextEntry();
  // virtual void make(const std::string& path) = 0;
  void reset();
  bool isValid(const std::string &path) 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<int>(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); }
  NXSize openNXSize(const std::string &name) const { return openNXDataSet<std::size_t>(name); }
  std::string getString(const std::string &name) const;
  double getDouble(const std::string &name) const;
  float getFloat(const std::string &name) const;
  int 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(); }
};
 
//------------------- auxiliary classes ----------------------------//
 
class MANTID_NEXUS_DLL NXLog : public NXClass {
public:
  NXLog(const NXClass &parent, const std::string &name) : NXClass(parent, name) {}
  std::string NX_class() const override { return "NXlog"; }
  Kernel::Property *createProperty();
  Kernel::Property *createTimeSeries(const std::string &start_time = "", const std::string &new_name = "");
 
private:
  Kernel::Property *createSingleValueProperty();
  template <class TYPE>
  Kernel::Property *parseTimeSeries(const std::string &logName, const TYPE &times, const std::string &time0 = "") {
    std::string start_time = (!time0.empty()) ? time0 : times.attributes("start");
    if (start_time.empty()) {
      start_time = "2000-01-01T00:00:00";
    }
    auto start_t = Kernel::DateAndTimeHelpers::createFromSanitizedISO8601(start_time);
    NXInfo vinfo = getDataSetInfo("value");
    if (!vinfo)
      return nullptr;
 
    if (vinfo.dims[0] != times.dim0())
      return nullptr;
 
    if (vinfo.type == NX_CHAR) {
      auto logv = new Kernel::TimeSeriesProperty<std::string>(logName);
      NXChar value(*this, "value");
      value.openLocal();
      value.load();
      for (int i = 0; i < value.dim0(); i++) {
        auto t = start_t + boost::posix_time::seconds(int(times[i]));
        for (int j = 0; j < value.dim1(); j++) {
          char *c = &value(i, j);
          if (!isprint(*c))
            *c = ' ';
        }
        logv->addValue(t, std::string(value() + i * value.dim1(), value.dim1()));
      }
      return logv;
    } else if (vinfo.type == NX_FLOAT64) {
      if (logName.find("running") != std::string::npos || logName.find("period ") != std::string::npos) {
        auto logv = new Kernel::TimeSeriesProperty<bool>(logName);
        NXDouble value(*this, "value");
        value.openLocal();
        value.load();
        for (int i = 0; i < value.dim0(); i++) {
          auto t = start_t + boost::posix_time::seconds(int(times[i]));
          logv->addValue(t, (value[i] == 0 ? false : true));
        }
        return logv;
      }
      NXDouble value(*this, "value");
      return loadValues<NXDouble, TYPE>(logName, value, start_t, times);
    } else if (vinfo.type == NX_FLOAT32) {
      NXFloat value(*this, "value");
      return loadValues<NXFloat, TYPE>(logName, value, start_t, times);
    } else if (vinfo.type == NX_INT32) {
      NXInt value(*this, "value");
      return loadValues<NXInt, TYPE>(logName, value, start_t, times);
    }
    return nullptr;
  }
 
  template <class NX_TYPE, class TIME_TYPE>
  Kernel::Property *loadValues(const std::string &logName, NX_TYPE &value, Types::Core::DateAndTime start_t,
                               const TIME_TYPE &times) {
    value.openLocal();
    auto logv = new Kernel::TimeSeriesProperty<double>(logName);
    value.load();
    for (int i = 0; i < value.dim0(); i++) {
      if (i == 0 || value[i] != value[i - 1] || times[i] != times[i - 1]) {
        auto t = start_t + boost::posix_time::seconds(int(times[i]));
        logv->addValue(t, value[i]);
      }
    }
    return logv;
  }
};
 
class MANTID_NEXUS_DLL NXNote : public NXClass {
public:
  NXNote(const NXClass &parent, const std::string &name)
      : NXClass(parent, name), m_author_ok(), m_data_ok(), m_description_ok() {}
  std::string NX_class() const override { return "NXnote"; }
  std::string author();
  std::vector<std::string> &data();
  std::string description();
 
protected:
  std::string m_author;            
  std::vector<std::string> m_data; 
  std::string m_description;       
  bool m_author_ok;                
  bool m_data_ok;                  
  bool m_description_ok;           
};
 
class MANTID_NEXUS_DLL NXBinary : public NXNote {
public:
  NXBinary(const NXClass &parent, const std::string &name) : NXNote(parent, name) {}
  std::vector<char> &binary();
 
private:
  std::vector<char> m_binary; 
};
 
//-------------------- main classes -------------------------------//
 
class MANTID_NEXUS_DLL NXMainClass : public NXClass {
public:
  NXMainClass(const NXClass &parent, const std::string &name) : NXClass(parent, name) {}
  NXLog openNXLog(const std::string &name) { return openNXClass<NXLog>(name); }
  NXNote openNXNote(const std::string &name) { return openNXClass<NXNote>(name); }
};
 
class MANTID_NEXUS_DLL NXData : public NXMainClass {
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();
      // std::cerr << "NXData signal of " << it->nxname << " = " <<
      // dset.attributes("signal") << "\n";
      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");
    // throw std::runtime_error("NXData does not seem to contain the data");
    // return NXDataSetTyped<T>(*this,"");
  }
  NXDouble openDoubleData() { return openData<double>(); }
  NXFloat openFloatData() { return openData<float>(); }
  NXInt openIntData() { return openData<int>(); }
  NXSize openSizeData() { return openData<std::size_t>(); }
  NXUInt openUIntData() { return openData<unsigned int>(); }
};
 
class MANTID_NEXUS_DLL NXDetector : public NXMainClass {
public:
  NXDetector(const NXClass &parent, const std::string &name) : NXMainClass(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 NXDiskChopper : public NXMainClass {
public:
  NXDiskChopper(const NXClass &parent, const std::string &name) : NXMainClass(parent, name) {}
  std::string NX_class() const override { return "NXdisk_chopper"; }
  NXFloat openRotationSpeed() { return openNXFloat("rotation_speed"); }
};
 
class MANTID_NEXUS_DLL NXInstrument : public NXMainClass {
public:
  NXInstrument(const NXClass &parent, const std::string &name) : NXMainClass(parent, name) {}
  std::string NX_class() const override { return "NXinstrument"; }
  NXDetector openNXDetector(const std::string &name) { return openNXClass<NXDetector>(name); }
 
  NXDiskChopper openNXDiskChopper(const std::string &name) { return openNXClass<NXDiskChopper>(name); }
};
 
class MANTID_NEXUS_DLL NXEntry : public NXMainClass {
public:
  NXEntry(const NXClass &parent, const std::string &name) : NXMainClass(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