BoxControllerDummyIO.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 +
/*********************************************************************************
 *  PLEASE READ THIS!!!!!!!
 *
 *  This collection of functions MAY NOT be used in any test from a package
 *below
 *  API (e.g. Kernel, Geometry).
 *  Conversely, this file MAY NOT be modified to use anything from a package
 *higher
 *  than API (e.g. any algorithm or concrete workspace), even if via the
 *factory.
 *********************************************************************************/
#include "MantidFrameworkTestHelpers/BoxControllerDummyIO.h"
#include "MantidKernel/Exception.h"
 
#include <string>
 
namespace MantidTestHelpers {
BoxControllerDummyIO::BoxControllerDummyIO(const Mantid::API::BoxController *bc)
    : m_bc(bc), m_CoordSize(4), m_TypeName("MDEvent"), m_ReadOnly(true), m_isOpened(false) {
  m_EventSize = static_cast<unsigned int>(bc->getNDims() + 4);
}
 
void BoxControllerDummyIO::setDataType(const size_t blockSize, const std::string &typeName) {
  if (blockSize == 4 || blockSize == 8) {
    m_CoordSize = static_cast<unsigned int>(blockSize);
  } else
    throw std::invalid_argument("The class currently supports 4(float) and "
                                "8(double) event coordinates only");
  m_TypeName = typeName;
  if (m_TypeName == "MDEvent") {
    m_EventSize = static_cast<unsigned int>(m_bc->getNDims() + 4);
  } else if (m_TypeName == "MDLeanEvent") {
    m_EventSize = static_cast<unsigned int>(m_bc->getNDims() + 2);
  } else {
    throw std::invalid_argument("unsupported event type");
  }
}
 
void BoxControllerDummyIO::getDataType(size_t &CoordSize, std::string &typeName) const {
  CoordSize = m_CoordSize;
  typeName = m_TypeName;
}
 
bool BoxControllerDummyIO::openFile(const std::string &fileName, const std::string &mode) {
  m_fileName = fileName;
  // file already opened
  if (m_isOpened)
    return false;
 
  m_ReadOnly = true;
  ;
  if (mode.find('w') != std::string::npos || mode.find('W') != std::string::npos) {
    m_ReadOnly = false;
  }
 
  // open file if it exists or crate it if not in the mode requested
  // bool fileExists(true);
  if (fileName.find("exist") != std::string::npos) {
    size_t nEvents = 1000;
    fileContents.assign(nEvents * m_EventSize, 0);
    this->setFileLength(nEvents);
    size_t ic(0);
    for (size_t i = 0; i < nEvents; i++) {
      fileContents[ic++] = static_cast<float>(i);
      fileContents[ic++] = static_cast<float>(i * i);
      for (size_t j = 2; j < m_EventSize; j++)
        fileContents[ic++] = static_cast<float>(i + 10 * j);
    }
 
  } else
    this->setFileLength(0);
 
  m_isOpened = true;
 
  return true;
}
void BoxControllerDummyIO::saveBlock(const std::vector<float> &DataBlock, const uint64_t blockPosition) const {
  size_t nEvents = DataBlock.size() / m_EventSize;
  uint64_t position = blockPosition;
  // uint64_t fileLength = this->getFileLength();
  std::lock_guard<std::mutex> lock(m_fileMutex);
 
  if (m_EventSize * (position + nEvents) > fileContents.size()) {
    fileContents.resize((position + nEvents) * m_EventSize);
    this->setFileLength(position + nEvents);
  }
 
  for (size_t i = 0; i < DataBlock.size(); i++) {
    fileContents[blockPosition * m_EventSize + i] = DataBlock[i];
  }
}
void BoxControllerDummyIO::loadBlock(std::vector<float> &Block, const uint64_t blockPosition,
                                     const size_t nPoints) const {
  std::lock_guard<std::mutex> _lock(m_fileMutex);
  if (blockPosition + nPoints > this->getFileLength())
    throw Mantid::Kernel::Exception::FileError("Attemtp to read behind the file end", m_fileName);
 
  Block.resize(nPoints * m_EventSize);
  for (size_t i = 0; i < nPoints * m_EventSize; i++) {
    Block[i] = fileContents[blockPosition * m_EventSize + i];
  }
}
 
BoxControllerDummyIO::~BoxControllerDummyIO() { this->closeFile(); }
} // namespace MantidTestHelpers