ISISInstrumentDataCache.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2024 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 +
#include "MantidAPI/ISISInstrumentDataCache.h"
#include "MantidAPI/FileFinder.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/InstrumentInfo.h"
#include "MantidKernel/Logger.h"
#include <algorithm>
#include <fstream>
#include <json/reader.h>
 
using Mantid::API::ISISInstrumentDataCache;
using Mantid::Kernel::InstrumentInfo;
 
namespace {
Mantid::Kernel::Logger g_log("ISISInstrumentDataCache");
} // namespace
 
std::string ISISInstrumentDataCache::getFileParentDirectoryPath(const std::string &fileName) const {
  g_log.debug() << "ISISInstrumentDataCache::getFileParentDirectoryPath(" << fileName << ")" << std::endl;
 
  auto [instrumentInfo, runNumber] = validateInstrumentAndNumber(fileName);
 
  auto const [jsonPath, json] = openCacheJsonFile(instrumentInfo);
 
  std::string relativePath = json[runNumber].asString();
 
  if (relativePath.empty()) {
    throw std::invalid_argument("Run number " + runNumber + " not found in index file " + jsonPath.filename().string() +
                                ".");
  }
 
  std::filesystem::path dirPath = jsonPath.parent_path() / relativePath;
  std::string dirPathString = dirPath.make_preferred().string();
 
  g_log.debug() << "Found path to search: " << dirPathString << std::endl;
  return dirPathString;
}
 
std::vector<std::string> ISISInstrumentDataCache::getRunNumbersInCache(const std::string &instrumentName) const {
  const auto &json = openCacheJsonFile(getInstrumentFromName(instrumentName)).second;
  return json.getMemberNames();
}
 
std::pair<std::filesystem::path, Json::Value>
ISISInstrumentDataCache::openCacheJsonFile(const InstrumentInfo &instrument) const {
  // Open index json file
  std::filesystem::path jsonPath = makeIndexFilePath(instrument.name());
  std::ifstream ifstrm{jsonPath};
  if (!ifstrm.is_open()) { // Try again with shortname
    jsonPath = makeIndexFilePath(instrument.shortName());
    ifstrm.open(jsonPath);
    if (!ifstrm.is_open()) {
      throw std::invalid_argument("Could not open index file: " + jsonPath.string());
    }
  }
  // Read directory path from json file
  Json::Value json;
  ifstrm >> json;
  g_log.debug() << "Opened instrument index file: " << jsonPath << std::endl;
  return {jsonPath, json};
}
 
std::pair<InstrumentInfo, std::string>
ISISInstrumentDataCache::validateInstrumentAndNumber(const std::string &fileName) const {
 
  // Check if suffix eg. -add is present in filename
  std::string fileNameCopy = fileName;
  std::string suffix = FileFinder::Instance().extractAllowedSuffix(fileNameCopy);
  if (!suffix.empty()) {
    throw std::invalid_argument("Unsuported format: Suffix detected: " + suffix);
  }
 
  auto [instrName, runNumber] = splitIntoInstrumentAndNumber(fileName);
 
  if (runNumber.empty() || !std::all_of(runNumber.begin(), runNumber.end(), ::isdigit)) { // Check run number
    throw std::invalid_argument("Filename not in correct format.");
  }
  runNumber.erase(0, runNumber.find_first_not_of('0')); // Remove padding zeros
 
  return std::pair(getInstrumentFromName(instrName), runNumber);
}
 
InstrumentInfo ISISInstrumentDataCache::getInstrumentFromName(const std::string &instName) const {
  try { // Expand instrument name
    auto instrumentInfo = FileFinder::Instance().getInstrument(instName, false);
    return instrumentInfo;
  } catch (const Kernel::Exception::NotFoundError &) {
    throw std::invalid_argument("Instrument name not recognized.");
  }
}
 
std::filesystem::path ISISInstrumentDataCache::makeIndexFilePath(const std::string &instrumentName) const {
  g_log.debug() << "ISISInstrumentDataCache::makeIndexFilePath(" << instrumentName << ")" << std::endl;
  auto const &indexFilePath =
      std::filesystem::path(m_dataCachePath) / instrumentName / (instrumentName + "_index.json");
  return indexFilePath;
}
 
std::pair<std::string, std::string>
ISISInstrumentDataCache::splitIntoInstrumentAndNumber(const std::string &fileName) const {
 
  // Find the last non-digit as the instrument name can contain numbers
  const auto itRev = std::find_if(fileName.rbegin(), fileName.rend(), std::not_fn(isdigit));
  const auto nChars = std::distance(itRev, fileName.rend());
  std::string runNumber = fileName.substr(nChars);
 
  std::string fileNameUpperCase = fileName;
  std::transform(fileNameUpperCase.begin(), fileNameUpperCase.end(), fileNameUpperCase.begin(), toupper);
  std::string instrName = fileNameUpperCase.substr(0, nChars);
 
  return std::pair(instrName, runNumber);
}
 
bool ISISInstrumentDataCache::isIndexFileAvailable(std::string const &instrumentName) const {
  return std::filesystem::exists(makeIndexFilePath(instrumentName));
}