BoxControllerNeXusIO.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2008 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/BoxController.h"
#include "MantidAPI/IBoxControllerIO.h"
#include "MantidDataObjects/DllConfig.h"
#include "MantidKernel/DiskBuffer.h"
#include <nexus/NeXusFile.hpp>
 
#include <mutex>
 
namespace Mantid {
namespace DataObjects {
 
//===============================================================================================
class MANTID_DATAOBJECTS_DLL BoxControllerNeXusIO : public API::IBoxControllerIO {
public:
  BoxControllerNeXusIO(API::BoxController *const bc);
 
  bool isOpened() const override { return m_File.get() != nullptr; }
  const std::string &getFileName() const override { return m_fileName; }
  void copyFileTo(const std::string &destFilename) override;
 
  size_t getDataChunk() const override { return m_dataChunk; }
 
  bool openFile(const std::string &fileName, const std::string &mode) override;
 
  void saveBlock(const std::vector<float> & /* DataBlock */, const uint64_t /*blockPosition*/) const override;
  void loadBlock(std::vector<float> & /* Block */, const uint64_t /*blockPosition*/,
                 const size_t /*BlockSize*/) const override;
  void saveBlock(const std::vector<double> & /* DataBlock */, const uint64_t /*blockPosition*/) const override;
  void loadBlock(std::vector<double> & /* Block */, const uint64_t /*blockPosition*/,
                 const size_t /*BlockSize*/) const override;
 
  void flushData() const override;
  void closeFile() override;
 
  ~BoxControllerNeXusIO() override;
  // Auxiliary functions. Used to change default state of this object which is
  // not fully supported. Should be replaced by some IBoxControllerIO factory
  void setDataType(const size_t blockSize, const std::string &typeName) override;
  void getDataType(size_t &CoordSize, std::string &typeName) const override;
  //------------------------------------------------------------------------------------------------------------------------
  // Auxiliary functions (non-virtual, used for testing)
  int64_t getNDataColums() const { return m_BlockSize[1]; }
  // get pointer to the Nexus file --> compatribility testing only.
  ::NeXus::File *getFile() { return m_File.get(); }
 
  enum class EventDataVersion : size_t { EDVLean = 2, EDVOriginal = 4, EDVGoniometer = 5 };
 
  EventDataVersion getEventDataVersion() const { return m_EventDataVersion; }
 
  void setEventDataVersion(const EventDataVersion &version);
 
  void setEventDataVersion(const size_t &traitsCount);
 
  int64_t dataEventCount(void) const;
 
  template <typename FloatOrDouble>
  void adjustEventDataBlock(std::vector<FloatOrDouble> &Block, const std::string &accessMode) const;
 
private:
  enum { DATA_CHUNK = 10000 };
 
  std::string m_fileName;
  std::unique_ptr<::NeXus::File> m_File;
  bool m_ReadOnly;
  size_t m_dataChunk;
  API::BoxController *const m_bc;
  //------
  std::vector<int64_t> m_BlockStart;
  std::vector<int64_t> m_BlockSize;
  mutable std::mutex m_fileMutex;
 
  // Mainly static information which may be split into different IO classes
  // selected through chein of responsibility.
  unsigned int m_CoordSize;
  enum EventType {
    LeanEvent = 0, //< the event consisting of signal error and event coordinate
    FatEvent = 1   //< the event having the same as lean event plus RunID and detID
  } m_EventType;
 
  std::string m_EventsVersion;
 
  EventDataVersion m_EventDataVersion;
 
  std::vector<std::string> m_EventsTypesSupported;
  std::vector<std::string> m_EventsTypeHeaders;
 
  static std::string g_EventGroupName;
  static std::string g_DBDataName;
 
  // helper functions:
  // prepare to write event nexus data in current data version format
  void CreateEventGroup();
  void OpenAndCheckEventGroup();
  void getDiskBufferFileData();
  void prepareNxSToWrite_CurVersion();
  void prepareNxSdata_CurVersion();
  // get the event type from event name
  static EventType TypeFromString(const std::vector<std::string> &typesSupported, const std::string &typeName);
  enum CoordConversion {
    noConversion,
    floatToDouble,
    doubleToFolat
  } m_ReadConversion;
 
  template <typename Type>
  void saveGenericBlock(const std::vector<Type> &DataBlock, const uint64_t blockPosition) const;
 
  template <typename Type>
  void loadGenericBlock(std::vector<Type> &Block, const uint64_t blockPosition, const size_t nPoints) const;
};
} // namespace DataObjects
} // namespace Mantid