LegacyNexusDescriptor.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 +
#include "MantidKernel/LegacyNexusDescriptor.h"
#include "MantidLegacyNexus/NeXusException.hpp"
#include "MantidLegacyNexus/NeXusFile.hpp"
 
#include <algorithm>
#include <cstring>
#include <filesystem>
#include <string>
 
namespace Mantid::Kernel {
 
//---------------------------------------------------------------------------------------------------------------------------
// NexusDescriptor public methods
//---------------------------------------------------------------------------------------------------------------------------
LegacyNexusDescriptor::LegacyNexusDescriptor(const std::string &filename)
    : m_filename(), m_extension(), m_firstEntryNameType(), m_rootAttrs(), m_pathsToTypes(), m_file(nullptr) {
  if (filename.empty()) {
    throw std::invalid_argument("NexusDescriptor() - Empty filename '" + filename + "'");
  }
  if (!std::filesystem::exists(filename)) {
    throw std::invalid_argument("NexusDescriptor() - File '" + filename + "' does not exist");
  }
  try {
    // this is very expesive as it walk the entire file
    initialize(filename);
  } catch (Mantid::LegacyNexus::Exception &e) {
    throw std::invalid_argument("NexusDescriptor::initialize - File '" + filename +
                                "' does not look like a HDF file.\n Error was: " + e.what());
  }
}
 
LegacyNexusDescriptor::~LegacyNexusDescriptor() = default;
 
const std::pair<std::string, std::string> &LegacyNexusDescriptor::firstEntryNameType() const {
  return m_firstEntryNameType;
}
 
bool LegacyNexusDescriptor::pathExists(const std::string &path) const {
  return (m_pathsToTypes.find(path) != m_pathsToTypes.end());
}
 
//---------------------------------------------------------------------------------------------------------------------------
// NexusDescriptor private methods
//---------------------------------------------------------------------------------------------------------------------------
 
void LegacyNexusDescriptor::initialize(const std::string &filename) {
  m_filename = filename;
  m_extension = std::filesystem::path(filename).extension().string();
 
  m_file = std::make_unique<Mantid::LegacyNexus::File>(this->filename());
 
  m_file->openPath("/");
  m_rootAttrs.clear();
  m_pathsToTypes.clear();
  walkFile(*m_file, "", "", m_pathsToTypes, 0);
}
 
void LegacyNexusDescriptor::walkFile(Mantid::LegacyNexus::File &file, const std::string &rootPath,
                                     const std::string &className, std::map<std::string, std::string> &pmap,
                                     int level) {
  if (!rootPath.empty()) {
    pmap.emplace(rootPath, className);
  }
 
  auto dirents = file.getEntries();
  auto itend = dirents.end();
  for (auto it = dirents.begin(); it != itend; ++it) {
    const std::string &entryName = it->first;
    const std::string &entryClass = it->second;
    const std::string entryPath = std::string(rootPath).append("/").append(entryName);
    if (entryClass == "SDS" || entryClass == "ILL_data_scan_vars" || entryClass == "NXill_data_scan_vars") {
      pmap.emplace(entryPath, entryClass);
    } else if (entryClass == "CDF0.0") {
      // Do nothing with this
    } else {
      if (level == 0)
        m_firstEntryNameType = (*it); // copy first entry name & type
      if (!entryClass.empty()) {      // handles buggy files
        file.openGroup(entryName, entryClass);
        walkFile(file, entryPath, entryClass, pmap, level + 1);
      }
    }
  }
  file.closeGroup();
}
 
} // namespace Mantid::Kernel