SaveNexusProcessedHelper.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 "MantidAPI/Column.h"
#include "MantidAPI/ITableWorkspace_fwd.h"
#include "MantidAPI/MatrixWorkspace_fwd.h"
#include "MantidAPI/Progress.h"
#include "MantidDataHandling/DllConfig.h"
#include "MantidDataObjects/EventList.h"
#include "MantidDataObjects/EventWorkspace_fwd.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidKernel/cow_ptr.h"
#include "MantidNexus/NexusException.h"
#include "MantidNexus/NexusFile.h"
 
#include <boost/date_time/c_local_time_adjustor.hpp>
#include <boost/date_time/local_time_adjustor.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/scoped_array.hpp>
 
#include <climits>
#include <memory>
#include <optional>
 
namespace Mantid {
namespace Nexus {
class MANTID_DATAHANDLING_DLL NexusFileIO {
 
public:
  // Helper typedef
  using optional_size_t = std::optional<size_t>;
 
  NexusFileIO();
 
  NexusFileIO(API::Progress *prog);
 
  ~NexusFileIO();
 
  void openNexusWrite(const std::string &fileName, optional_size_t entryNumber = optional_size_t(),
                      const bool append_to_file = true);
  int writeNexusProcessedHeader(const std::string &title, const std::string &wsName = "") const;
  void closeNexusFile();
  void closeGroup();
  int 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;
 
  int writeNexusTableWorkspace(const API::ITableWorkspace_const_sptr &itableworkspace, const char *group_name) const;
 
  int 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;
 
  template <typename NumT>
  void writeData(const char *name, NXnumtype datatype, Nexus::DimVector dims_array, NumT const *data,
                 bool compress = false) const;
 
  bool writeNexusBinMasking(const API::MatrixWorkspace_const_sptr &ws) const;
 
  void resetProgress(Mantid::API::Progress *prog);
 
  std::shared_ptr<Nexus::File> filehandle() const { return m_filehandle; }
 
private:
  std::shared_ptr<Nexus::File> m_filehandle;
  NXcompression m_nexuscompression;
  API::Progress *m_progress;
  bool writeNxValue(const std::string &name, const std::string &value, const std::vector<std::string> &attributes,
                    const std::vector<std::string> &avalues) const;
  int findMantidWSEntries() const;
 
  std::string m_filename;
 
  template <typename VecType, typename ElemType>
  void writeNexusVectorColumn(const API::Column_const_sptr &col, const std::string &columnName, NXnumtype nexusType,
                              const std::string &interpret_as) const;
 
  template <typename ColumnT, typename NexusT>
  void writeTableColumn(NXnumtype type, const std::string &interpret_as, const API::Column &col,
                        const std::string &columnName) const;
};
 
inline bool NexusFileIO::writeNxValue(const std::string &name, const std::string &value,
                                      const std::vector<std::string> &attributes,
                                      const std::vector<std::string> &avalues) const {
  try {
    m_filehandle->writeData(name, value);
 
    // open it again to add attributes
    m_filehandle->openData(name);
    for (unsigned int it = 0; it < attributes.size(); ++it) {
      m_filehandle->putAttr(attributes[it], avalues[it]);
    }
    m_filehandle->closeData();
  } catch (Nexus::Exception const &) {
    return false;
  }
 
  return true;
}
 
using NexusFileIO_sptr = std::shared_ptr<NexusFileIO>;
 
} // namespace Nexus
} // namespace Mantid