SaveNexusProcessedHelper.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 +
// NexusFileIO
// @author Ronald Fowler
#include <sstream>
#include <vector>
 
#ifdef _WIN32
#include <io.h>
// Define the MAX_NAME macro for Windows
// Maximum base file name size on modern windows systems is 260 characters
#define NAME_MAX 260
#endif /* _WIN32 */
 
#include "MantidAPI/NumericAxis.h"
#include "MantidDataHandling/SaveNexusProcessedHelper.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/PeaksWorkspace.h"
#include "MantidDataObjects/RebinnedOutput.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidHistogramData/Histogram.h"
 
#include <filesystem>
#include <memory>
 
namespace Mantid::Nexus {
using namespace Kernel;
using namespace API;
using namespace DataObjects;
 
using HistogramData::HistogramDx;
using HistogramData::HistogramE;
using HistogramData::HistogramX;
using HistogramData::HistogramY;
using Mantid::MantidVec; // for `<rebinned output>->readF(size_t index)`
 
namespace {
Logger g_log("NexusFileIO");
} // namespace
 
NexusFileIO::NexusFileIO()
    : m_filehandle(), m_nexuscompression(NXcompression::LZW), m_progress(nullptr), m_filename() {}
 
NexusFileIO::NexusFileIO(Progress *prog)
    : m_filehandle(), m_nexuscompression(NXcompression::LZW), m_progress(prog), m_filename() {}
 
void NexusFileIO::resetProgress(Progress *prog) { m_progress = prog; }
 
//
// Write out the data in a worksvn space in Nexus "Processed" format.
// This *Proposed* standard comprises the fields:
// <NXentry name="{Name of entry}">
//   <title>
//     {Extended title for entry}
//   </title>
//   <definition
//   URL="http://www.nexusformat.org/instruments/xml/NXprocessed.xml"
//       version="1.0">
//     NXprocessed
//   </definition>
//   <NXsample name="{Name of sample}">?
//     {Any relevant sample information necessary to define the data.}
//   </NXsample>
//   <NXdata name="{Name of processed data}">
//     <values signal="1" type="NX_FLOAT[:,:]" axes="axis1:axis2">{Processed
//     values}</values>
//     <axis1 type="NX_FLOAT[:]">{Values of the first dimension's axis}</axis1>
//     <axis2 type="NX_FLOAT[:]">{Values of the second dimension's axis}</axis2>
//   </NXdata>
//   <NXprocess name="{Name of process}">?
//     {Any relevant information about the steps used to process the data.}
//   </NXprocess>
// </NXentry>
 
void NexusFileIO::openNexusWrite(const std::string &fileName, NexusFileIO::optional_size_t entryNumber,
                                 const bool append_to_file) {
  // open named file and entry - file may exist
  // @throw Exception::FileError if cannot open Nexus file for writing
  //
  NXaccess mode(NXaccess::CREATE5);
  std::string mantidEntryName;
  m_filename = fileName;
  //
  // If file to write exists, then open as is else see if the extension is xml,
  // if so open as xml
  // format otherwise as compressed hdf5
  //
  if ((std::filesystem::exists(m_filename) && append_to_file) || m_filehandle)
    mode = NXaccess::RDWR;
 
  else {
    if (fileName.find(".xml") < fileName.size() || fileName.find(".XML") < fileName.size()) {
      throw Kernel::Exception::FileError("Cannot save XML files", fileName);
    }
    mantidEntryName = "mantid_workspace_1";
  }
 
  /*Only create the file handle if needed.*/
  if (!m_filehandle) {
    // The nexus or HDF5 libraries crash when the filename is greater than 255
    // on OSX and Ubuntu.
    std::filesystem::path path(fileName);
    std::string baseName = path.stem().string();
    if (baseName.size() > NAME_MAX) {
      std::string message = "Filename is too long. Unable to open file: ";
      throw Kernel::Exception::FileError(message, fileName);
    }
 
    auto file = new Nexus::File(fileName, mode);
 
    m_filehandle = std::shared_ptr<Nexus::File>(file);
  }
 
  //
  // for existing files, search for any current mantid_workspace_<n> entries and
  // set the
  // new name to be n+1 so that we do not over-write by default. This may need
  // changing.
  //
  if (mode == NXaccess::RDWR) {
    size_t count = 0;
    if (entryNumber.has_value()) {
      // Use the entry number provided.
      count = entryNumber.value();
    } else {
      // Have to figure it our ourselves. Requires opening the exisitng file to
      // get the information via a search.
      count = findMantidWSEntries();
    }
 
    std::stringstream suffix;
    suffix << (count + 1);
    mantidEntryName = "mantid_workspace_" + suffix.str();
  }
  //
  // make and open the new mantid_workspace_<n> group
  // file remains open until explicit close
  //
  const std::string className = "NXentry";
 
  m_filehandle->makeGroup(mantidEntryName, className);
  m_filehandle->openGroup(mantidEntryName, className);
}
 
void NexusFileIO::closeGroup() { m_filehandle->closeGroup(); }
 
//-----------------------------------------------------------------------------------------------
void NexusFileIO::closeNexusFile() {
  if (m_filehandle) {
    m_filehandle.reset();
  }
}
 
//-----------------------------------------------------------------------------------------------
int NexusFileIO::writeNexusProcessedHeader(const std::string &title, const std::string &wsName) const {
 
  const std::string className = "Mantid Processed Workspace";
  std::vector<std::string> attributes, avalues;
  attributes.reserve(2);
  avalues.reserve(2);
  if (!writeNxValue("title", title, attributes, avalues))
    return (3);
 
  // name for workspace if this is a multi workspace nexus file
  if (!wsName.empty()) {
    if (!writeNxValue("workspace_name", wsName, attributes, avalues))
      return (3);
  }
 
  attributes.emplace_back("URL");
  avalues.emplace_back("http://www.nexusformat.org/instruments/xml/NXprocessed.xml");
  attributes.emplace_back("Version");
  avalues.emplace_back("1.0");
  // this may not be the "correct" long term path, but it is valid at present
  if (!writeNxValue("definition", className, attributes, avalues))
    return (3);
  avalues.clear();
  avalues.emplace_back("http://www.isis.rl.ac.uk/xml/IXmantid.xml");
  avalues.emplace_back("1.0");
  if (!writeNxValue("definition_local", className, attributes, avalues))
    return (3);
  return (0);
}
 
//-------------------------------------------------------------------------------------
// Internal constants and template functions, used by `NexusFileIO::writeNexusProcessedData2D`:
 
namespace {
 
const double _DEFAULT_FILL_VALUE(0.0);
 
// Typedef for vector-accessor member functions with signatures like:
//   `const HistogramData::HistogramY & Mantid::API::MatrixWorkspace::y         (       const size_t    index   )
//   const`
template <class V, class WS> using _VAccessor = const V &(WS::*)(size_t) const;
 
// Return the data pointer for a vector:
//   this allows us to work with both  `MantidVec` and `FixedLengthVector`.
template <class V> const double *_dataPointer(const V &v) { return v.rawData().data(); }
 
template <> const double *_dataPointer<MantidVec>(const MantidVec &v) { return v.data(); }
 
// Internal-use method:
//   * Create the dataset and write chunks of double-precision data;
//   * Optionally fill the chunks with a specified fill value;
//   * Optionally close the dataset.
template <class V, class WS>
void _writeChunkedData(std::shared_ptr<Nexus::File> dest, // Must have open group, but NO open dataset
                       const std::string &name,
                       std::shared_ptr<const WS> src, // Do not pass std::shared_ptr<..> by reference!
                       const std::vector<int> &indices, _VAccessor<V, WS> vData, bool raggedSpectra = false,
                       NXcompression compressionType = NXcompression::NONE, double fillValue = _DEFAULT_FILL_VALUE,
                       bool closeData = true) {
 
  const size_t N_chunk = indices.size(); // number of spectra
 
  size_t _chunk_size = ((*src).*vData)(0).size();
  if (raggedSpectra) {
    for (size_t n : indices)
      _chunk_size = std::max(_chunk_size, ((*src).*vData)(n).size());
  }
  const size_t chunk_size = _chunk_size;
 
  const Nexus::DimVector dims = {N_chunk, chunk_size};
  const Nexus::DimVector chunk_dims = {1, chunk_size};
 
  // Create and open the dataset.
  // (If compressionType == NXcompression::NONE, this just creates a non-compressed dataset.)
  dest->makeCompData(name, NXnumtype::FLOAT64, dims, compressionType, chunk_dims, true);
 
  // Prepare a padding vector. (Unfortunately, NeXus-api does not access `setFillValue`.)
  const bool pad_data(fillValue != _DEFAULT_FILL_VALUE);
  const std::vector<double> vFill(pad_data ? chunk_size : 0, fillValue);
 
  // Write the data.
  Nexus::DimVector start{0, 0};
  for (size_t n : indices) {
    const auto &v = ((*src).*vData)(n);
    const Nexus::DimVector data_dims = {1, v.size()};
    dest->putSlab(_dataPointer<V>(v), start, data_dims);
    if (pad_data && data_dims[1] != chunk_size) {
      // Fill the remainder of the slab.
      const Nexus::DimVector fill_dims = {1, chunk_size - data_dims[1]};
      const Nexus::DimVector _start = {start[0], data_dims[1]};
      dest->putSlab(vFill.data(), _start, fill_dims);
    }
 
    ++start[0];
  }
 
  if (closeData)
    dest->closeData();
}
 
} // namespace
 
//-------------------------------------------------------------------------------------
int NexusFileIO::writeNexusProcessedData2D(const API::MatrixWorkspace_const_sptr &localworkspace,
                                           const bool &uniformSpectra, const bool &raggedSpectra,
                                           const std::vector<int> &indices, const std::string &group_name,
                                           bool write2Ddata) const {
 
  // write data entry
  try {
    m_filehandle->makeGroup(group_name, "NXdata", true);
  } catch (Nexus::Exception const &) {
    return 2;
  }
 
  // write workspace data
  const size_t nHist = localworkspace->getNumberHistograms();
  if (nHist < 1)
    return (2);
 
  // Set the axis labels and values
  Mantid::API::Axis *xAxis = localworkspace->getAxis(0);
  Mantid::API::Axis *sAxis = localworkspace->getAxis(1);
  std::string xLabel, sLabel;
  if (xAxis->isSpectra())
    xLabel = "spectraNumber";
  else {
    if (xAxis->unit())
      xLabel = xAxis->unit()->unitID();
    else
      xLabel = "unknown";
  }
  if (sAxis->isSpectra())
    sLabel = "spectraNumber";
  else {
    if (sAxis->unit())
      sLabel = sAxis->unit()->unitID();
    else
      sLabel = "unknown";
  }
  // Get the values on the vertical axis
  std::vector<double> axis2;
  const size_t nSpect = indices.size();
  if (nSpect < nHist)
    for (size_t i = 0; i < nSpect; i++)
      axis2.emplace_back((*sAxis)(indices[i]));
  else
    for (size_t i = 0; i < sAxis->length(); i++)
      axis2.emplace_back((*sAxis)(i));
 
  // -------------- Actually write the 2D data ----------------------------
  if (write2Ddata) {
    _writeChunkedData<HistogramY, MatrixWorkspace>(m_filehandle, "values", localworkspace, indices, &MatrixWorkspace::y,
                                                   raggedSpectra, m_nexuscompression, _DEFAULT_FILL_VALUE,
                                                   false // don't close the dataset
    );
 
    if (m_progress != nullptr)
      m_progress->reportIncrement(1, "Writing data");
    m_filehandle->putAttr("signal", 1);
    // More properties
    m_filehandle->putAttr("axes", "axis2,axis1");
    m_filehandle->putAttr("units", localworkspace->YUnit(), false);
    m_filehandle->putAttr("unit_label", localworkspace->YUnitLabel(), false);
    m_filehandle->closeData();
 
    // errors
    _writeChunkedData<HistogramE, MatrixWorkspace>(m_filehandle, "errors", localworkspace, indices, &MatrixWorkspace::e,
                                                   raggedSpectra, m_nexuscompression);
    if (m_progress != nullptr)
      m_progress->reportIncrement(1, "Writing data");
 
    // Fractional area for RebinnedOutput
    if (localworkspace->id() == "RebinnedOutput") {
      RebinnedOutput_const_sptr rebin_workspace = std::dynamic_pointer_cast<const RebinnedOutput>(localworkspace);
 
      _writeChunkedData<MantidVec, RebinnedOutput>(m_filehandle, "frac_area", rebin_workspace, indices,
                                                   &RebinnedOutput::readF, raggedSpectra, m_nexuscompression,
                                                   _DEFAULT_FILL_VALUE,
                                                   false // don't close the dataset
      );
 
      std::string finalized = (rebin_workspace->isFinalized()) ? "1" : "0";
      m_filehandle->putAttr("finalized", finalized);
      std::string sqrdErrs = (rebin_workspace->hasSqrdErrors()) ? "1" : "0";
      m_filehandle->putAttr("sqrd_errors", sqrdErrs);
 
      if (m_progress != nullptr)
        m_progress->reportIncrement(1, "Writing data");
      m_filehandle->closeData();
    }
 
    // x errors
    if (localworkspace->hasDx(0)) {
      _writeChunkedData<HistogramDx, MatrixWorkspace>(m_filehandle, "xerrors", localworkspace, indices,
                                                      &MatrixWorkspace::dx, raggedSpectra, m_nexuscompression);
    }
  }
 
  // write X data, as single array or all values if "ragged"
  if (uniformSpectra) {
    m_filehandle->makeData("axis1", NXnumtype::FLOAT64, localworkspace->x(0).size(), true);
    m_filehandle->putData(localworkspace->x(0).rawData().data());
 
  } else {
    _writeChunkedData<HistogramX, MatrixWorkspace>(
        m_filehandle, "axis1", localworkspace, indices, &MatrixWorkspace::x, raggedSpectra, NXcompression::NONE,
        raggedSpectra ? std::numeric_limits<double>::quiet_NaN() : _DEFAULT_FILL_VALUE,
        false // don't close the dataset
    );
  }
 
  std::string dist = (localworkspace->isDistribution()) ? "1" : "0";
  m_filehandle->putAttr("distribution", dist);
  m_filehandle->putAttr("units", xLabel);
 
  auto label = std::dynamic_pointer_cast<Mantid::Kernel::Units::Label>(xAxis->unit());
  if (label) {
    m_filehandle->putAttr("caption", label->caption(), false);
    auto unitLbl = label->label();
    m_filehandle->putAttr("label", unitLbl.ascii(), false);
  }
 
  m_filehandle->closeData();
 
  if (!sAxis->isText()) {
    // write axis2, maybe just spectra number
    m_filehandle->makeData("axis2", NXnumtype::FLOAT64, axis2.size(), true);
    m_filehandle->putData(axis2.data());
    m_filehandle->putAttr("units", sLabel, false);
 
    auto unitLabel = std::dynamic_pointer_cast<Mantid::Kernel::Units::Label>(sAxis->unit());
    if (unitLabel) {
      m_filehandle->putAttr("caption", unitLabel->caption(), false);
      auto unitLbl = unitLabel->label();
      m_filehandle->putAttr("label", unitLbl.ascii(), false);
    }
 
    m_filehandle->closeData();
  } else {
    std::string textAxis;
    for (size_t i = 0; i < sAxis->length(); i++) {
      textAxis += sAxis->label(i) + "\n";
    }
    m_filehandle->makeData("axis2", NXnumtype::CHAR, textAxis.size(), true);
    m_filehandle->putData(textAxis.c_str());
    m_filehandle->putAttr("units", "TextAxis");
 
    auto unitLabel = std::dynamic_pointer_cast<Mantid::Kernel::Units::Label>(sAxis->unit());
    if (unitLabel) {
      m_filehandle->putAttr("caption", unitLabel->caption(), false);
      auto unitLbl = unitLabel->label();
      m_filehandle->putAttr("label", unitLbl.ascii(), false);
    }
 
    m_filehandle->closeData();
  }
 
  writeNexusBinMasking(localworkspace);
 
  m_filehandle->closeGroup();
  return 0;
}
 
//-------------------------------------------------------------------------------------
template <typename ColumnT, typename NexusT>
void NexusFileIO::writeTableColumn(NXnumtype type, const std::string &interpret_as, const API::Column &col,
                                   const std::string &columnName) const {
  const auto nRows = col.size();
  const Nexus::DimVector dims_array{nRows};
 
  auto toNexus = new NexusT[nRows];
  for (std::size_t ii = 0; ii < nRows; ii++)
    toNexus[ii] = static_cast<NexusT>(col.cell<ColumnT>(ii));
  writeData(columnName.c_str(), type, dims_array, toNexus, false);
  delete[] toNexus;
 
  // attributes
  m_filehandle->openData(columnName);
  std::string units = "Not known";
  m_filehandle->putAttr("units", units, false);
  m_filehandle->putAttr("interpret_as", interpret_as, false);
  m_filehandle->closeData();
}
 
// Helper templated definitions
namespace {
 
// Get a size of a vector to be used in writeNexusVectorColumn(...)
template <typename VecType> size_t getSizeOf(const VecType &vec) { return vec.size(); }
 
// Special case of V3D
size_t getSizeOf(const Kernel::V3D & /*unused*/) { return 3; }
} // namespace
 
template <typename VecType, typename ElemType>
void NexusFileIO::writeNexusVectorColumn(const Column_const_sptr &col, const std::string &columnName,
                                         NXnumtype nexusType, const std::string &interpret_as) const {
  ConstColumnVector<VecType> column(col);
  size_t rowCount = column.size();
 
  // Search for the longest array amongst the cells
  size_t maxSize(0);
  for (size_t i = 0; i < rowCount; ++i) {
    size_t size = getSizeOf(column[i]);
 
    if (size > maxSize)
      maxSize = size;
  }
 
  // Set-up dimensions
  const Nexus::DimVector dims{rowCount, maxSize};
 
  // Create data array
  boost::scoped_array<ElemType> data(new ElemType[rowCount * maxSize]);
 
  for (size_t i = 0; i < rowCount; ++i) {
    // copy data in a cell to a vector with the same element type
    std::vector<ElemType> values = column[i];
 
    // So that all the arrays are of the size maxSize
    values.resize(maxSize);
 
    // Copy values to the data array
    for (size_t j = 0; j < maxSize; ++j)
      data[i * maxSize + j] = values[j];
  }
 
  // Write data
  writeData(columnName.c_str(), nexusType, dims, data.get(), false);
 
  m_filehandle->openData(columnName);
 
  // Add sizes of rows as attributes. We can't use padding zeroes to determine
  // that because the
  // vector stored might end with zeroes as well.
  for (size_t i = 0; i < rowCount; ++i) {
    auto size = static_cast<int>(getSizeOf(column[i]));
 
    std::ostringstream rowSizeAttrName;
    rowSizeAttrName << "row_size_" << i;
 
    m_filehandle->putAttr(rowSizeAttrName.str(), size);
  }
 
  std::string units = "Not known";
 
  // Write general attributes
  m_filehandle->putAttr("units", units, false);
  m_filehandle->putAttr("interpret_as", interpret_as, false);
 
  m_filehandle->closeData();
}
//-------------------------------------------------------------------------------------
int NexusFileIO::writeNexusTableWorkspace(const API::ITableWorkspace_const_sptr &itableworkspace,
                                          const char *group_name) const {
  std::shared_ptr<const TableWorkspace> tableworkspace =
      std::dynamic_pointer_cast<const TableWorkspace>(itableworkspace);
  std::shared_ptr<const PeaksWorkspace> peakworkspace =
      std::dynamic_pointer_cast<const PeaksWorkspace>(itableworkspace);
 
  if (!tableworkspace && !peakworkspace)
    return 3;
 
  // write data entry
  try {
    m_filehandle->makeGroup(group_name, "NXdata", true);
  } catch (Nexus::Exception const &) {
    return 2;
  }
 
  std::size_t nRows = itableworkspace->rowCount();
 
  for (size_t i = 0; i < itableworkspace->columnCount(); i++) {
    Column_const_sptr col = itableworkspace->getColumn(i);
 
    std::string str = "column_" + std::to_string(i + 1);
 
    if (col->isType<double>()) {
      writeTableColumn<double, double>(NXnumtype::FLOAT64, "", *col, str);
    } else if (col->isType<float>()) {
      writeTableColumn<float, float>(NXnumtype::FLOAT32, "", *col, str);
    } else if (col->isType<int>()) {
      writeTableColumn<int, int32_t>(NXnumtype::INT32, "", *col, str);
    } else if (col->isType<uint32_t>()) {
      writeTableColumn<uint32_t, uint32_t>(NXnumtype::UINT32, "", *col, str);
    } else if (col->isType<int64_t>()) {
      writeTableColumn<int64_t, int64_t>(NXnumtype::INT64, "", *col, str);
    } else if (col->isType<size_t>()) {
      writeTableColumn<size_t, uint64_t>(NXnumtype::UINT64, "", *col, str);
    } else if (col->isType<Boolean>()) {
      writeTableColumn<bool, bool>(NXnumtype::UINT8, "", *col, str);
    } else if (col->isType<std::string>()) {
      // determine max string size
      std::size_t maxStr = 0;
      for (std::size_t ii = 0; ii < nRows; ii++) {
        if (col->cell<std::string>(ii).size() > maxStr)
          maxStr = col->cell<std::string>(ii).size();
      }
      // If the column is empty fill the data with spaces.
      // Strings containing spaces only will be read back in as empty strings.
      if (maxStr == 0) {
        maxStr = 1;
      }
      const Nexus::DimVector dims_array{nRows, maxStr};
      const Nexus::DimVector asize{1, dims_array[1]};
 
      m_filehandle->makeCompData(str, NXnumtype::CHAR, dims_array, NXcompression::LZW, asize);
 
      m_filehandle->openData(str);
      auto toNexus = new char[maxStr * nRows];
      for (std::size_t ii = 0; ii < nRows; ii++) {
        std::string rowStr = col->cell<std::string>(ii);
        for (size_t ic = 0; ic < rowStr.size(); ic++)
          toNexus[ii * maxStr + ic] = rowStr[ic];
        for (size_t ic = rowStr.size(); ic < static_cast<size_t>(maxStr); ic++)
          toNexus[ii * maxStr + ic] = ' ';
      }
 
      m_filehandle->putData(toNexus);
      delete[] toNexus;
 
      // attributes
      std::string units = "N/A";
      std::string interpret_as = "A string";
      m_filehandle->putAttr("units", units);
      m_filehandle->putAttr("interpret_as", interpret_as);
 
      m_filehandle->closeData();
    } else if (col->isType<std::vector<int>>()) {
      writeNexusVectorColumn<std::vector<int>, int>(col, str, NXnumtype::INT32, "");
    } else if (col->isType<std::vector<double>>()) {
      writeNexusVectorColumn<std::vector<double>, double>(col, str, NXnumtype::FLOAT64, "");
    } else if (col->isType<Kernel::V3D>()) {
      writeNexusVectorColumn<Kernel::V3D, double>(col, str, NXnumtype::FLOAT64, "V3D");
    }
 
    // write out title
    m_filehandle->openData(str);
    m_filehandle->putAttr("name", col->name());
    m_filehandle->closeData();
  }
 
  try {
    m_filehandle->closeGroup();
  } catch (Nexus::Exception const &) {
    return 3;
  }
  return 0;
}
 
//-------------------------------------------------------------------------------------
int NexusFileIO::writeNexusProcessedDataEventCombined(const DataObjects::EventWorkspace_const_sptr &ws,
                                                      std::vector<int64_t> const &indices, double const *tofs,
                                                      float const *weights, float const *errorSquareds,
                                                      int64_t const *pulsetimes, bool compress) const {
  m_filehandle->openGroup("event_workspace", "NXdata");
 
  // The array of indices for each event list #
  Nexus::DimVector dims_array = {indices.size()};
  if (!indices.empty()) {
    if (compress)
      m_filehandle->makeCompData("indices", NXnumtype::INT64, dims_array, m_nexuscompression, dims_array);
    else
      m_filehandle->makeData("indices", NXnumtype::INT64, dims_array);
    m_filehandle->openData("indices");
    m_filehandle->putData(indices.data());
    m_filehandle->putAttr("units", ws->YUnit(), false);
    m_filehandle->putAttr("unit_label", ws->YUnitLabel(), false);
    m_filehandle->closeData();
  }
 
  // Write out each field
  dims_array[0] = static_cast<int>(indices.back()); // TODO big truncation error! This is the # of events
  if (tofs)
    writeData("tof", NXnumtype::FLOAT64, dims_array, tofs, compress);
  if (pulsetimes)
    writeData("pulsetime", NXnumtype::INT64, dims_array, pulsetimes, compress);
  if (weights)
    writeData("weight", NXnumtype::FLOAT32, dims_array, weights, compress);
  if (errorSquareds)
    writeData("error_squared", NXnumtype::FLOAT32, std::move(dims_array), errorSquareds, compress);
 
  // Close up the overall group
  m_filehandle->closeGroup();
  return 0;
}
 
//-------------------------------------------------------------------------------------
template <typename NumT>
void NexusFileIO::writeData(const char *name, NXnumtype datatype, Nexus::DimVector dims_array, NumT const *data,
                            bool compress) const {
  if (compress) {
    // We'll use the same slab/buffer size as the size of the array
    m_filehandle->makeCompData(name, datatype, dims_array, m_nexuscompression, dims_array);
  } else {
    // Write uncompressed.
    m_filehandle->makeData(name, datatype, dims_array);
  }
 
  m_filehandle->openData(name);
  m_filehandle->putData(data);
  m_filehandle->closeData();
}
 
int NexusFileIO::findMantidWSEntries() const {
  // search exiting file for entries of form mantid_workspace_<n> and return
  // count
  int count = 0;
  std::map<std::string, std::string> entries = m_filehandle->getEntries();
  for (auto &entrie : entries) {
    if (entrie.second == "NXentry") {
      if (entrie.first.find("mantid_workspace_") == 0)
        count++;
    }
  }
 
  return count;
}
 
bool NexusFileIO::writeNexusBinMasking(const API::MatrixWorkspace_const_sptr &ws) const {
  std::vector<int32_t> spectra;
  std::vector<int64_t> bins;
  std::vector<double> weights;
  std::size_t spectra_count = 0;
  int offset = 0;
  for (std::size_t i = 0; i < ws->getNumberHistograms(); ++i) {
    if (ws->hasMaskedBins(i)) {
      const API::MatrixWorkspace::MaskList &mList = ws->maskedBins(i);
      spectra.emplace_back(static_cast<int32_t>(spectra_count));
      spectra.emplace_back(offset);
      for (const auto &mask : mList) {
        bins.emplace_back(mask.first);
        weights.emplace_back(mask.second);
      }
      ++spectra_count;
      offset += static_cast<int>(mList.size());
    }
  }
 
  if (spectra_count == 0)
    return false;
 
  // save spectra offsets as a 2d array of ints
  Nexus::DimVector dimensions{spectra_count, 2};
 
  m_filehandle->makeData("masked_spectra", NXnumtype::INT32, dimensions, true);
  m_filehandle->putAttr("description", "spectra index,offset in masked_bins and mask_weights");
  m_filehandle->putData(spectra.data());
  m_filehandle->closeData();
 
  // save masked bin indices
  dimensions[0] = bins.size();
  m_filehandle->makeData("masked_bins", NXnumtype::UINT64, dimensions, true);
  m_filehandle->putData(bins.data());
  m_filehandle->closeData();
 
  // save masked bin weights
  dimensions[0] = bins.size();
  m_filehandle->makeData("mask_weights", NXnumtype::FLOAT64, dimensions, true);
  m_filehandle->putData(weights.data());
  m_filehandle->closeData();
 
  return true;
}
 
NexusFileIO::~NexusFileIO() {
  // Close the nexus file if not already closed.
  // this->closeNexusFile();
}
 
} // namespace Mantid::Nexus