ExperimentInfo.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 "MantidAPI/ExperimentInfo.h"
#include "MantidAPI/InstrumentDataService.h"
#include "MantidAPI/InstrumentFileFinder.h"
#include "MantidAPI/ResizeRectangularDetectorHelper.h"
#include "MantidAPI/Run.h"
#include "MantidAPI/Sample.h"
#include "MantidAPI/SpectrumInfo.h"
 
#include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidGeometry/ICompAssembly.h"
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/IDetector.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/Detector.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Instrument/InstrumentDefinitionParser.h"
#include "MantidGeometry/Instrument/InstrumentMetadata.h"
#include "MantidGeometry/Instrument/InstrumentVisitor.h"
#include "MantidGeometry/Instrument/ParComponentFactory.h"
#include "MantidGeometry/Instrument/ParameterFactory.h"
#include "MantidGeometry/Instrument/ParameterMap.h"
#include "MantidGeometry/Instrument/PositionAndRotationAccumulator.h"
#include "MantidGeometry/Instrument/XMLInstrumentParameter.h"
 
#include "MantidBeamline/ComponentInfo.h"
#include "MantidBeamline/DetectorInfo.h"
#include "MantidBeamline/SpectrumInfo.h"
 
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/DateAndTime.h"
#include "MantidKernel/EigenConversionHelpers.h"
#include "MantidKernel/IPropertyManager.h"
#include "MantidKernel/InstrumentInfo.h"
#include "MantidKernel/Property.h"
#include "MantidKernel/StringTokenizer.h"
#include "MantidKernel/Strings.h"
#include "MantidNexus/NexusException.h"
 
#include "MantidTypes/SpectrumDefinition.h"
 
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/regex.hpp>
 
#include <Poco/Path.h>
 
#include <algorithm>
#include <map>
#include <memory>
#include <tuple>
 
using namespace Mantid::Geometry;
using namespace Mantid::Kernel;
using namespace Mantid::Types::Core;
 
namespace Mantid::API {
namespace {
Kernel::Logger g_log("ExperimentInfo");
 
} // namespace
 
ExperimentInfo::ExperimentInfo() : m_parmap(new ParameterMap()), sptr_instrument(new Instrument()) {
  m_parmap->setInstrument(sptr_instrument.get());
  adoptBeamline();
}
 
ExperimentInfo::ExperimentInfo(const ExperimentInfo &source) { *this = source; }
 
ExperimentInfo &ExperimentInfo::operator=(const ExperimentInfo &source) {
  this->copyExperimentInfoFrom(&source);
  setSpectrumDefinitions(source.spectrumInfo().sharedSpectrumDefinitions());
  return *this;
}
 
// Defined as default in source for forward declaration with std::unique_ptr.
ExperimentInfo::~ExperimentInfo() = default;
 
void ExperimentInfo::copyExperimentInfoFrom(const ExperimentInfo *other) {
  m_sample = other->m_sample;
  m_run = other->m_run;
  this->setInstrument(other->getInstrument());
  // We do not copy Beamline::SpectrumInfo (which contains detector grouping
  // information) for now:
  // - For MatrixWorkspace, grouping information is still stored in ISpectrum
  //   and should not be overridden (copy is done in ExperimentInfo ctor, but
  //   not here since we just copy the experiment data).
  // - For cached groupings (for MDWorkspaces), grouping was not copied in the
  //   old implementation either.
}
 
ExperimentInfo *ExperimentInfo::cloneExperimentInfo() const { return new ExperimentInfo(*this); }
 
const std::string ExperimentInfo::toString() const {
  try {
    populateIfNotLoaded();
  } catch (std::exception &) {
    // Catch any errors so that the string returned has as much information
    // as possible
  }
 
  std::ostringstream out;
 
  Geometry::Instrument_const_sptr inst = this->getInstrument();
  const auto instName = inst->getName();
  out << "Instrument: ";
  if (!instName.empty()) {
    out << instName << " (" << inst->getValidFromDate().toFormattedString("%Y-%b-%d") << " to "
        << inst->getValidToDate().toFormattedString("%Y-%b-%d") << ")";
    const auto instFilename = inst->getFilename();
    if (!instFilename.empty()) {
      out << "Instrument from: " << instFilename;
      out << "\n";
    }
  } else {
    out << "None";
  }
  out << "\n";
 
  // parameter files loaded
  auto paramFileVector = this->constInstrumentParameters().getParameterFilenames();
  for (auto const &itFilename : paramFileVector) {
    out << "Parameters from: " << itFilename;
    out << "\n";
  }
 
  std::string runStart = getAvailableWorkspaceStartDate();
  std::string runEnd = getAvailableWorkspaceEndDate();
  std::string msgNA = "not available";
  if (runStart.empty())
    runStart = msgNA;
  if (runEnd.empty())
    runEnd = msgNA;
  out << "Run start: " << runStart << "\n";
  out << "Run end:  " << runEnd << "\n"; // note extra space for pseudo/approx-alignment
 
  if (this->sample().hasOrientedLattice()) {
    const Geometry::OrientedLattice &latt = this->sample().getOrientedLattice();
    out << "Sample: a " << std::fixed << std::setprecision(1) << latt.a() << ", b " << latt.b() << ", c " << latt.c();
    out << "; alpha " << std::fixed << std::setprecision(0) << latt.alpha() << ", beta " << latt.beta() << ", gamma "
        << latt.gamma();
    out << "\n";
  }
  return out.str();
}
 
// Helpers for setInstrument and getInstrument
namespace {
void checkDetectorInfoSize(const Instrument &instr, const Geometry::DetectorInfo &detInfo) {
  const auto numDets = instr.getNumberDetectors();
  if (numDets != detInfo.size())
    throw std::runtime_error("ExperimentInfo: size mismatch between "
                             "DetectorInfo and number of detectors in "
                             "instrument: " +
                             std::to_string(detInfo.size()) + " vs " + std::to_string(numDets));
}
} // namespace
 
void ExperimentInfo::setInstrument(const Instrument_const_sptr &instr) {
  m_spectrumInfoWrapper = nullptr;
  {
    std::lock_guard<std::mutex> lock{m_baseComponentInfoMutex};
    m_baseComponentInfo = nullptr;
    m_baseDetectorInfo = nullptr;
  }
 
  // Detector IDs that were previously dropped because they were not part of the
  // instrument may now suddenly be valid, so we have to reinitialize the
  // detector grouping. Also the index corresponding to specific IDs may have
  // changed.
  if (sptr_instrument != (instr->isParametrized() ? instr->baseInstrument() : instr)) {
    invalidateAllSpectrumDefinitions();
  }
  if (instr->isParametrized()) {
    sptr_instrument = instr->baseInstrument();
    // We take a *copy* of the ParameterMap since we are modifying it by setting
    // a pointer to our DetectorInfo, and in case it contains legacy parameters
    // such as positions or rotations.
    const auto &source = *instr->getParameterMap();
    m_parmap = std::make_shared<ParameterMap>(source);
    // The copy carries the source's instrument pointer, so the setInstrument() below sees no
    // change and returns early. The beamline therefore has to be rebuilt explicitly -- this is
    // the copy-on-write of the instrument geometry, and it used to happen implicitly inside
    // ParameterMap's copy constructor.
    m_parmap->rebuildBeamlineFrom(source);
  } else {
    sptr_instrument = instr;
    m_parmap = std::make_shared<ParameterMap>();
  }
  m_parmap->setInstrument(sptr_instrument.get());
  adoptBeamline();
}
 
void ExperimentInfo::adoptBeamline() {
  m_componentInfo = m_parmap->sharedComponentInfo();
  m_detectorInfo = m_parmap->sharedDetectorInfo();
  m_instrumentMetadata = m_parmap->sharedInstrumentMetadata();
}
 
Instrument_const_sptr ExperimentInfo::getInstrument() const {
  populateIfNotLoaded();
  checkDetectorInfoSize(*sptr_instrument, detectorInfo());
  return Geometry::ParComponentFactory::createInstrument(sptr_instrument, m_parmap);
}
 
Geometry::ParameterMap &ExperimentInfo::instrumentParameters() {
  populateIfNotLoaded();
  return *m_parmap;
}
 
const Geometry::ParameterMap &ExperimentInfo::instrumentParameters() const {
  populateIfNotLoaded();
  return *m_parmap;
}
 
const Geometry::ParameterMap &ExperimentInfo::constInstrumentParameters() const {
  populateIfNotLoaded();
  return *m_parmap;
}
 
namespace {
 
struct RTP {
  RTP() : radius(0.0), haveRadius(false), theta(0.0), phi(0.0) {}
  double radius;
  bool haveRadius;
  double theta;
  double phi;
};
 
struct ParameterValue {
  ParameterValue(const Geometry::XMLInstrumentParameter &paramInfo, const API::Run &run)
      : info(paramInfo), runData(run) {}
 
  operator double() {
    if (info.m_logfileID.empty())
      return boost::lexical_cast<double>(info.m_value);
    else {
      const TimeROI *roi = &runData.getTimeROI();
      return info.createParamValue(runData.getTimeSeriesProperty<double>(info.m_logfileID), roi);
    }
  }
  operator int() { return boost::lexical_cast<int>(info.m_value); }
  operator bool() {
    if (boost::iequals(info.m_value, "true"))
      return true;
    else if (boost::iequals(info.m_value, "yes"))
      return true;
    else
      return false;
  }
  const Geometry::XMLInstrumentParameter &info;
  const Run &runData;
};
} // namespace
 
namespace {
bool isPositionParameter(const std::string &name) { return ParameterMap::pos() == name; }
 
bool isRotationParameter(const std::string &name) { return ParameterMap::rot() == name; }
 
bool isScaleParameter(const std::string &name) { return (name == "scalex" || name == "scaley"); }
 
bool isRedundantPosOrRot(const std::string &name) {
  // Check size first as a small optimization.
  return (name.size() == 4) &&
         (name == "posx" || name == "posy" || name == "posz" || name == "rotx" || name == "roty" || name == "rotz");
}
 
template <class T> T getParam(const std::string &paramType, const std::string &paramValue) {
  const std::string name = "dummy";
  auto param = ParameterFactory::create(paramType, name);
  param->fromString(paramValue);
  return param->value<T>();
}
 
void updatePosition(ComponentInfo &componentInfo, const size_t compIndex, const V3D &newRelPos) {
  V3D position = newRelPos;
  if (componentInfo.hasParent(compIndex)) {
    const auto parentIndex = componentInfo.parent(compIndex);
    componentInfo.rotation(parentIndex).rotate(position);
    position += componentInfo.position(parentIndex);
  }
  componentInfo.setPosition(compIndex, position);
}
 
void updateRotation(ComponentInfo &componentInfo, const size_t compIndex, const Quat &newRelRot) {
  auto rotation = newRelRot;
  if (componentInfo.hasParent(compIndex)) {
    const auto parentIndex = componentInfo.parent(compIndex);
    rotation = componentInfo.rotation(parentIndex) * newRelRot;
  }
  componentInfo.setRotation(compIndex, rotation);
}
 
void adjustPositionsFromScaleFactor(ComponentInfo &componentInfo, const size_t compIndex, const std::string &paramName,
                                    double factor) {
  double ScaleX = 1.0;
  double ScaleY = 1.0;
  if (paramName == "scalex")
    ScaleX = factor;
  else
    ScaleY = factor;
  applyRectangularDetectorScaleToComponentInfo(componentInfo, compIndex, ScaleX, ScaleY);
}
} // namespace
 
void ExperimentInfo::populateInstrumentParameters() {
  populateIfNotLoaded();
 
  // Reference to the run
  const auto &runData = run();
 
  // Get pointer to parameter map that we may add parameters to and information
  // about
  // the parameters that my be specified in the instrument definition file (IDF)
  Geometry::ParameterMap &paramMap = instrumentParameters();
  Geometry::PositionAndRotationAccumulator posAndRot;
 
  auto &compInfo = mutableComponentInfo();
  // The logfile parameters of this workspace: those of the instrument definition, plus any added
  // since from parameter files
  const auto &paramInfoFromIDF = compInfo.logfileParameters();
 
  std::map<size_t, RTP> rtpParams;
 
  // In this loop position and rotation parameters are inserted into the
  // temporary map paramMapForPosAndRot. In the subsequent loop, after all
  // parameters have been parsed, we update positions and rotations in
  // DetectorInfo and the temporary map goes out of scope. The main reason for
  // this is that ParameterMap will then take care of assembling parameters for
  // individual position or rotation components into a vector or quaternion. In
  // particular, we cannot directly change DetectorInfo since the order of
  // rotation components is not guaranteed.
  for (const auto &[key, paramInfo] : paramInfoFromIDF) {
    const auto compIndex = key.first;
    // Use the parameter's short name (e.g. "Alpha0"), not the cache key. The cache key may be
    // function-qualified (e.g. "IkedaCarpenterPV:Alpha0") to keep two functions on the same
    // component from clobbering each other, but downstream consumers always look up by short name.
    const std::string &paramN = paramInfo->m_paramName;
 
    try {
      // Special case where user has specified r-position,t-position, and/or
      // p-position.
      // We need to know all three first to calculate a set of X,Y,Z
      if (paramN.compare(1, 9, "-position") == 0) {
        auto &rtpValues = rtpParams[compIndex]; // If not found, constructs default
        double value = ParameterValue(*paramInfo, runData);
        if (paramN.compare(0, 1, "r") == 0) {
          rtpValues.radius = value;
          rtpValues.haveRadius = true;
        } else if (paramN.compare(0, 1, "t") == 0)
          rtpValues.theta = value;
        else if (paramN.compare(0, 1, "p") == 0)
          rtpValues.phi = value;
        if (rtpValues.haveRadius) {
          V3D pos;
          pos.spherical(rtpValues.radius, rtpValues.theta, rtpValues.phi);
          posAndRot.setPosition(compIndex, pos);
        }
      } else {
        populateWithParameter(compInfo, posAndRot, compIndex, paramN, *paramInfo, runData);
      }
    } catch (std::exception &exc) {
      g_log.information() << "Unable to add component parameter '" << paramN << "'. Error: " << exc.what();
      continue;
    }
  }
  // Each component's position and rotation is applied once, complete. The accumulator has
  // already folded the individual x/y/z coordinates and rotx/roty/rotz angles together, so
  // there are no partial values left to ignore here.
  for (const auto &[compIndex, newRelPos] : posAndRot.positions()) {
    updatePosition(compInfo, compIndex, newRelPos);
  }
  for (const auto &[compIndex, newRelRot] : posAndRot.rotations()) {
    updateRotation(compInfo, compIndex, newRelRot);
  }
  // Special case RectangularDetector: Parameters scalex and scaley affect pixel
  // positions.
  for (const auto &item : paramMap.entries()) {
    if (isScaleParameter(item.second->name())) {
      adjustPositionsFromScaleFactor(compInfo, item.first, item.second->name(), item.second->value<double>());
    }
  }
  // paramMapForPosAndRot goes out of scope, dropping all position and rotation
  // parameters of detectors (parameters for non-detector components have been
  // inserted into paramMap via DetectorInfo::setPosition(IComponent *)).
}
 
void ExperimentInfo::setNumberOfDetectorGroups(const size_t count) const {
  populateIfNotLoaded();
  if (m_spectrumInfo)
    m_spectrumDefinitionNeedsUpdate.clear();
  m_spectrumDefinitionNeedsUpdate.resize(count, 1);
  m_spectrumInfo = std::make_unique<Beamline::SpectrumInfo>(count);
  m_spectrumInfoWrapper = nullptr;
}
 
size_t ExperimentInfo::numberOfDetectorGroups() const { return m_spectrumDefinitionNeedsUpdate.size(); }
 
void ExperimentInfo::setDetectorGrouping(const size_t index, const std::set<detid_t> &detIDs) const {
  SpectrumDefinition specDef;
  for (const auto detID : detIDs) {
    try {
      const size_t detIndex = detectorInfo().indexOf(detID);
      specDef.add(detIndex);
    } catch (std::out_of_range &) {
      // Silently strip bad detector IDs
    }
  }
  m_spectrumInfo->setSpectrumDefinition(index, std::move(specDef));
  m_spectrumDefinitionNeedsUpdate.at(index) = 0;
}
 
void ExperimentInfo::updateCachedDetectorGrouping(const size_t /*unused*/) const {
  throw std::runtime_error("ExperimentInfo::updateCachedDetectorGrouping: "
                           "Cannot update -- grouping information not "
                           "available");
}
 
const Sample &ExperimentInfo::sample() const {
  populateIfNotLoaded();
  return *m_sample;
}
 
Sample &ExperimentInfo::mutableSample() {
  populateIfNotLoaded();
  return m_sample.access();
}
 
const Run &ExperimentInfo::run() const {
  populateIfNotLoaded();
  return *m_run;
}
 
Run &ExperimentInfo::mutableRun() {
  populateIfNotLoaded();
  return m_run.access();
}
 
void ExperimentInfo::setSharedRun(Kernel::cow_ptr<Run> run) { m_run = std::move(run); }
 
Kernel::cow_ptr<Run> ExperimentInfo::sharedRun() { return m_run; }
 
Kernel::Property *ExperimentInfo::getLog(const std::string &log) const {
  populateIfNotLoaded();
  try {
    return run().getProperty(log);
  } catch (Kernel::Exception::NotFoundError &) {
    // No log with that name
  }
  // If the instrument has a parameter with that name then take the value as a
  // log name
  const auto &compInfo = componentInfo();
  const std::string logName = compInfo.getParameterAsString(compInfo.root(), log, false);
  if (logName.empty()) {
    throw std::invalid_argument("ExperimentInfo::getLog - No instrument parameter named \"" + log +
                                "\". Cannot access full log name");
  }
  return run().getProperty(logName);
}
 
double ExperimentInfo::getLogAsSingleValue(const std::string &log) const {
  populateIfNotLoaded();
  try {
    return run().getPropertyAsSingleValue(log);
  } catch (Kernel::Exception::NotFoundError &) {
    // No log with that name
  }
  // If the instrument has a parameter with that name then take the value as a
  // log name
  const auto &compInfo = componentInfo();
  const std::string logName = compInfo.getParameterAsString(compInfo.root(), log, false);
  if (logName.empty()) {
    throw std::invalid_argument("ExperimentInfo::getLog - No instrument parameter named \"" + log +
                                "\". Cannot access full log name");
  }
  return run().getPropertyAsSingleValue(logName);
}
 
int ExperimentInfo::getRunNumber() const {
  populateIfNotLoaded();
  const Run &thisRun = run();
  if (!thisRun.hasProperty("run_number")) {
    // No run_number property, default to 0
    return 0;
  } else {
    Property const *prop = m_run->getProperty("run_number");
    if (prop) {
      // Use the string representation. That way both a string and a number
      // property will work.
      int val;
      if (Strings::convert(prop->value(), val))
        return val;
      else
        return 0;
    }
  }
  return 0;
}
 
Kernel::DeltaEMode::Type ExperimentInfo::getEMode() const {
  populateIfNotLoaded();
  static const char *emodeTag = "deltaE-mode";
  std::string emodeStr;
  if (run().hasProperty(emodeTag)) {
    emodeStr = run().getPropertyValueAsType<std::string>(emodeTag);
  } else if (sptr_instrument && componentInfo().hasParameter(componentInfo().root(), emodeTag, false)) {
    emodeStr = componentInfo().getParameterAsString(componentInfo().root(), emodeTag, false);
  } else {
    return Kernel::DeltaEMode::Elastic;
  }
  return Kernel::DeltaEMode::fromString(emodeStr);
}
 
double ExperimentInfo::getEFixed(const detid_t detID) const {
  populateIfNotLoaded();
  IDetector_const_sptr det = getInstrument()->getDetector(detID);
  return getEFixed(det);
}
 
double ExperimentInfo::getEFixed(const std::shared_ptr<const Geometry::IDetector> &detector) const {
  populateIfNotLoaded();
  Kernel::DeltaEMode::Type emode = getEMode();
  return getEFixedGivenEMode(detector, emode);
}
 
double ExperimentInfo::getEFixedForIndirect(const std::shared_ptr<const Geometry::IDetector> &detector,
                                            const std::vector<std::string> &parameterNames) const {
  double efixed = 0.;
  for (auto &parameterName : parameterNames) {
    Parameter_sptr par = constInstrumentParameters().getRecursive(detector.get(), parameterName);
    if (par) {
      efixed = par->value<double>();
    } else {
      std::vector<double> efixedVec = detector->getNumberParameter(parameterName);
      if (efixedVec.empty()) {
        int detid = detector->getID();
        IDetector_const_sptr detectorSingle = getInstrument()->getDetector(detid);
        efixedVec = detectorSingle->getNumberParameter(parameterName);
      }
      if (!efixedVec.empty()) {
        efixed = efixedVec.at(0);
      }
    }
  }
  if (efixed == 0.) {
    std::ostringstream os;
    os << "ExperimentInfo::getEFixed - Indirect mode efixed requested but "
          "detector has no Efixed parameter attached. ID="
       << detector->getID();
    throw std::runtime_error(os.str());
  }
  return efixed;
}
 
double ExperimentInfo::getEFixedGivenEMode(const std::shared_ptr<const Geometry::IDetector> &detector,
                                           const Kernel::DeltaEMode::Type emode) const {
  if (emode == Kernel::DeltaEMode::Direct) {
    double efixed = 0.;
    for (auto &parameterName : {"Ei", "EnergyRequested", "EnergyEstimate"}) {
      if (run().hasProperty(parameterName)) {
        efixed = run().getPropertyValueAsType<double>(parameterName);
        break;
      }
    }
    if (efixed == 0.) {
      throw std::runtime_error("Experiment logs do not contain an Ei "
                               "value. Have you run GetEi?");
    }
    return efixed;
  } else if (emode == Kernel::DeltaEMode::Indirect) {
    if (!detector)
      throw std::runtime_error("ExperimentInfo::getEFixed - Indirect mode "
                               "efixed requested without a valid detector.");
    return getEFixedForIndirect(detector, {"Efixed", "EFixed-val"});
  } else {
    throw std::runtime_error("ExperimentInfo::getEFixed - EFixed requested for "
                             "elastic mode, don't know what to do!");
  }
}
 
void ExperimentInfo::setEFixed(const detid_t detID, const double value) {
  populateIfNotLoaded();
  size_t detIndex;
  try {
    detIndex = detectorInfo().indexOf(detID);
  } catch (const std::out_of_range &) {
    throw Kernel::Exception::NotFoundError("Instrument: Detector with ID " + std::to_string(detID) + " not found.", "");
  }
  // Detector indices are also component indices
  mutableComponentInfo().addDouble(detIndex, "Efixed", value);
}
 
std::string ExperimentInfo::getWorkspaceStartDate() const {
  populateIfNotLoaded();
  std::string date;
  try {
    date = run().startTime().toISO8601String();
  } catch (std::runtime_error &) {
    g_log.information("run_start/start_time not stored in workspace. Default "
                      "to current date.");
    date = Types::Core::DateAndTime::getCurrentTime().toISO8601String();
  }
  return date;
}
 
std::string ExperimentInfo::getAvailableWorkspaceStartDate() const {
  populateIfNotLoaded();
  std::string date;
  try {
    date = run().startTime().toFormattedString();
  } catch (std::runtime_error &) {
    g_log.information("Note: run_start/start_time not stored in workspace.");
  }
  return date;
}
 
std::string ExperimentInfo::getAvailableWorkspaceEndDate() const {
  populateIfNotLoaded();
  std::string date;
  try {
    date = run().endTime().toFormattedString();
  } catch (std::runtime_error &) {
    g_log.information("Note: run_start/start_time not stored in workspace.");
  }
  return date;
}
 
//-----------------------------------------------------------------------------------------------------------------------
 
const Geometry::DetectorInfo &ExperimentInfo::detectorInfo() const {
  populateIfNotLoaded();
  if (!m_detectorInfo) {
    throw std::runtime_error("Cannot return reference to NULL DetectorInfo");
  }
  return *m_detectorInfo;
}
 
Geometry::DetectorInfo &ExperimentInfo::mutableDetectorInfo() {
  populateIfNotLoaded();
  if (!m_detectorInfo) {
    throw std::runtime_error("Cannot return reference to NULL DetectorInfo");
  }
  return *m_detectorInfo;
}
 
const SpectrumInfo &ExperimentInfo::spectrumInfo() const {
  populateIfNotLoaded();
  if (!m_spectrumInfoWrapper) {
    std::lock_guard<std::mutex> lock{m_spectrumInfoMutex};
    if (!m_spectrumInfo) // this should happen only if not MatrixWorkspace
      cacheDefaultDetectorGrouping();
    if (!m_spectrumInfoWrapper) {
      static_cast<void>(detectorInfo());
      m_spectrumInfoWrapper = std::make_unique<SpectrumInfo>(*m_spectrumInfo, *this, m_parmap->mutableDetectorInfo());
    }
  }
  // Rebuild any spectrum definitions that are out of date. Accessing
  // `API::SpectrumInfo` will rebuild invalid spectrum definitions as it
  // encounters them (if detector IDs in an `ISpectrum` are changed), however we
  // need to deal with one special case here:
  // If two algorithms (or two threads in the same algorithm) access the same
  // workspace for reading at the same time, calls to
  // `updateSpectrumDefinitionIfNecessary` done by `API::SpectrumInfo` break
  // thread-safety. `Algorithm` sets a read-lock, but this lazy update method is
  // `const` and will modify internals of the workspace nevertheless. We thus
  // need explicit locking here. Note that we do not need extra locking in the
  // case of `ExperimentInfo::mutableSpectrumInfo` or other calls to
  // `updateSpectrumDefinitionIfNecessary` done by `API::SpectrumInfo`: If the
  // workspace is only read-locked, this update will ensure that no updates will
  // be triggered by SpectrumInfo, since changing detector IDs in an `ISpectrum`
  // is not possible for a read-only workspace. If the workspace is write-locked
  // detector IDs in ISpectrum may change, but the write-lock by `Algorithm`
  // guarantees that there is no concurrent reader and thus updating is safe.
  if (std::any_of(m_spectrumDefinitionNeedsUpdate.cbegin(), m_spectrumDefinitionNeedsUpdate.cend(),
                  [](char i) { return i == 1; })) {
    std::lock_guard<std::mutex> lock{m_spectrumInfoMutex};
    if (std::any_of(m_spectrumDefinitionNeedsUpdate.cbegin(), m_spectrumDefinitionNeedsUpdate.cend(),
                    [](char i) { return i == 1; })) {
      auto size = static_cast<int64_t>(m_spectrumInfoWrapper->size());
#pragma omp parallel for
      for (int64_t i = 0; i < size; ++i) {
        updateSpectrumDefinitionIfNecessary(i);
      }
    }
  }
  return *m_spectrumInfoWrapper;
}
 
SpectrumInfo &ExperimentInfo::mutableSpectrumInfo() {
  return const_cast<SpectrumInfo &>(static_cast<const ExperimentInfo &>(*this).spectrumInfo());
}
 
const Geometry::ComponentInfo &ExperimentInfo::componentInfo() const {
  populateIfNotLoaded();
  if (!m_componentInfo) {
    throw std::runtime_error("Cannot return reference to NULL ComponentInfo");
  }
  return *m_componentInfo;
}
 
ComponentInfo &ExperimentInfo::mutableComponentInfo() {
  populateIfNotLoaded();
  if (!m_componentInfo) {
    throw std::runtime_error("Cannot return reference to NULL ComponentInfo");
  }
  return *m_componentInfo;
}
 
Geometry::ComponentInfo const &ExperimentInfo::baseComponentInfo() const {
  populateIfNotLoaded();
  std::lock_guard<std::mutex> lock{m_baseComponentInfoMutex};
  if (!m_baseComponentInfo) {
    // The wrappers refer to sptr_instrument without owning it. That is safe because setInstrument() resets them
    // before replacing sptr_instrument, and they are declared after it, so are destroyed before it.
    std::tie(m_baseComponentInfo, m_baseDetectorInfo) = InstrumentVisitor::makeWrappers(*sptr_instrument);
  }
  return *m_baseComponentInfo;
}
 
Geometry::InstrumentMetadata const &ExperimentInfo::instrumentMetadata() const {
  populateIfNotLoaded();
  if (!m_instrumentMetadata) {
    throw std::runtime_error("Cannot return reference to NULL InstrumentMetadata");
  }
  return *m_instrumentMetadata;
}
 
void ExperimentInfo::setSpectrumDefinitions(Kernel::cow_ptr<std::vector<SpectrumDefinition>> spectrumDefinitions) {
  if (spectrumDefinitions) {
    m_spectrumInfo = std::make_unique<Beamline::SpectrumInfo>(std::move(spectrumDefinitions));
    m_spectrumDefinitionNeedsUpdate.resize(0);
    m_spectrumDefinitionNeedsUpdate.resize(m_spectrumInfo->size(), 0);
  } else {
    // Keep the old m_spectrumInfo which should have the correct size, but
    // invalidate all definitions.
    invalidateAllSpectrumDefinitions();
  }
  m_spectrumInfoWrapper = nullptr;
}
 
std::string ExperimentInfo::getInstrumentName() const {
  populateIfNotLoaded();
  Geometry::ComponentInfo const &compInfo = componentInfo();
  return compInfo.name(compInfo.root());
}
 
void ExperimentInfo::invalidateSpectrumDefinition(const size_t index) {
  // This uses a vector of char, such that flags for different indices can be
  // set from different threads (std::vector<bool> is not thread-safe).
  m_spectrumDefinitionNeedsUpdate.at(index) = 1;
}
 
void ExperimentInfo::updateSpectrumDefinitionIfNecessary(const size_t index) const {
  if (m_spectrumDefinitionNeedsUpdate.at(index) != 0)
    updateCachedDetectorGrouping(index);
}
 
void ExperimentInfo::cacheDefaultDetectorGrouping() const {
  if (m_spectrumInfo && (m_spectrumInfo->size() != 0))
    return;
  const auto &detIDs = sptr_instrument->getDetectorIDs();
  setNumberOfDetectorGroups(detIDs.size());
  size_t specIndex = 0;
  for (const auto detID : detIDs) {
    m_det2group[detID] = specIndex;
    const size_t detIndex = detectorInfo().indexOf(detID);
    SpectrumDefinition specDef;
    specDef.add(detIndex);
    // cppcheck-suppress nullPointerRedundantCheck
    m_spectrumInfo->setSpectrumDefinition(specIndex, std::move(specDef));
    m_spectrumDefinitionNeedsUpdate.at(specIndex) = 0;
    specIndex++;
  }
}
 
void ExperimentInfo::invalidateAllSpectrumDefinitions() {
  std::fill(m_spectrumDefinitionNeedsUpdate.begin(), m_spectrumDefinitionNeedsUpdate.end(), 1);
}
 
void ExperimentInfo::saveExperimentInfoNexus(Nexus::File *file, bool saveLegacyInstrument) const {
  Instrument_const_sptr instrument = getInstrument();
  if (saveLegacyInstrument) {
    instrument->saveNexus(file, "instrument");
  }
  sample().saveNexus(file, "sample");
  run().saveNexus(file, "logs");
}
 
void ExperimentInfo::saveExperimentInfoNexus(Nexus::File *file, bool saveInstrument, bool saveSample,
                                             bool saveLogs) const {
  Instrument_const_sptr instrument = getInstrument();
 
  if (saveInstrument)
    instrument->saveNexus(file, "instrument");
  if (saveSample)
    sample().saveNexus(file, "sample");
  if (saveLogs)
    run().saveNexus(file, "logs");
}
 
void ExperimentInfo::loadSampleAndLogInfoNexus(Nexus::File *file, std::string const &prefix) {
  // First, the sample and then the logs
  int sampleVersion = mutableSample().loadNexus(file, "sample");
  if (sampleVersion == 0) {
    // Old-style (before Sep-9-2011) NXS processed
    // sample field contains both the logs and the sample details
    file->openGroup("sample", "NXsample");
    this->mutableRun().loadNexus(file, "", prefix);
    file->closeGroup();
  } else {
    // Newer style: separate "logs" field for the Run object
    this->mutableRun().loadNexus(file, "logs", prefix);
  }
}
 
void ExperimentInfo::loadSampleAndLogInfoNexus(Nexus::File *file) {
  // First, the sample and then the logs
  int sampleVersion = mutableSample().loadNexus(file, "sample");
  if (sampleVersion == 0) {
    // Old-style (before Sep-9-2011) NXS processed
    // sample field contains both the logs and the sample details
    file->openGroup("sample", "NXsample");
    this->mutableRun().loadNexus(file, "");
    file->closeGroup();
  } else {
    // Newer style: separate "logs" field for the Run object
    this->mutableRun().loadNexus(file, "logs");
  }
}
 
void ExperimentInfo::loadExperimentInfoNexus(const std::string &nxFilename, Nexus::File *file,
                                             std::string &parameterStr, const std::string &prefix) {
  // TODO load sample and log info
  loadSampleAndLogInfoNexus(file, prefix);
  loadInstrumentInfoNexus(nxFilename, file, parameterStr);
}
 
void ExperimentInfo::loadExperimentInfoNexus(const std::string &nxFilename, Nexus::File *file,
                                             std::string &parameterStr) {
  // load sample and log info
  loadSampleAndLogInfoNexus(file);
 
  loadInstrumentInfoNexus(nxFilename, file, parameterStr);
}
 
void ExperimentInfo::loadInstrumentInfoNexus(const std::string &nxFilename, Nexus::File *file,
                                             std::string &parameterStr) {
 
  // Open instrument group
  file->openGroup("instrument", "NXinstrument");
 
  // Try to get the instrument embedded in the Nexus file
  std::string instrumentName;
  std::string instrumentXml;
  loadEmbeddedInstrumentInfoNexus(file, instrumentName, instrumentXml);
 
  // load parameters if found
  loadInstrumentParametersNexus(file, parameterStr);
 
  // Close the instrument group
  file->closeGroup();
 
  // Set the instrument given the name and and XML obtained
  setInstumentFromXML(nxFilename, instrumentName, instrumentXml);
}
 
void ExperimentInfo::loadInstrumentInfoNexus(const std::string &nxFilename, Nexus::File *file) {
 
  // Open instrument group
  file->openGroup("instrument", "NXinstrument");
 
  // Try to get the instrument embedded in the Nexus file
  std::string instrumentName;
  std::string instrumentXml;
  loadEmbeddedInstrumentInfoNexus(file, instrumentName, instrumentXml);
 
  // Close the instrument group
  file->closeGroup();
 
  // Set the instrument given the name and and XML obtained
  setInstumentFromXML(nxFilename, instrumentName, instrumentXml);
}
 
void ExperimentInfo::loadEmbeddedInstrumentInfoNexus(Nexus::File *file, std::string &instrumentName,
                                                     std::string &instrumentXml) {
 
  file->readData("name", instrumentName);
 
  try {
    file->openGroup("instrument_xml", "NXnote");
    file->readData("data", instrumentXml);
    file->closeGroup();
  } catch (Nexus::Exception const &ex) {
    g_log.debug(std::string("Unable to load instrument_xml: ") + ex.what());
  }
}
 
void ExperimentInfo::setInstumentFromXML(const std::string &nxFilename, std::string &instrumentName,
                                         std::string &instrumentXml) {
 
  instrumentXml = Strings::strip(instrumentXml);
  instrumentName = Strings::strip(instrumentName);
  std::string instrumentFilename;
  if (!instrumentXml.empty()) {
    // instrument xml is being loaded from the nxs file, set the
    // instrumentFilename
    // to identify the Nexus file as the source of the data
    instrumentFilename = nxFilename;
    g_log.debug() << "Using instrument IDF XML text contained in nexus file.\n";
  } else {
    // XML was not included or was empty
    // Use the instrument name to find the file
    instrumentFilename = InstrumentFileFinder::getInstrumentFilename(instrumentName, getWorkspaceStartDate());
    // And now load the contents
    instrumentXml = loadInstrumentXML(instrumentFilename);
  }
 
  // ---------- Now parse that XML to make the instrument -------------------
  if (!instrumentXml.empty() && !instrumentName.empty()) {
    InstrumentDefinitionParser parser(instrumentFilename, instrumentName, instrumentXml);
 
    std::string instrumentNameMangled = parser.getMangledName();
    Instrument_sptr instr;
    // Check whether the instrument is already in the InstrumentDataService
    if (InstrumentDataService::Instance().doesExist(instrumentNameMangled)) {
      // If it does, just use the one from the one stored there
      instr = InstrumentDataService::Instance().retrieve(instrumentNameMangled);
    } else {
      // Really create the instrument
      instr = parser.parseXML(nullptr);
      // Parse the instrument tree (internally create ComponentInfo and
      // DetectorInfo). This is an optimization that avoids duplicate parsing
      // of the instrument tree when loading multiple workspaces with the same
      // instrument. As a consequence less time is spent and less memory is
      // used. Note that this is only possible since the tree in `instrument`
      // will not be modified once we add it to the IDS.
      instr->parseTreeAndCacheBeamline();
 
      // Add to data service for later retrieval
      InstrumentDataService::Instance().add(instrumentNameMangled, instr);
    }
    // Now set the instrument
    this->setInstrument(instr);
  }
}
 
std::string ExperimentInfo::loadInstrumentXML(const std::string &filename) {
  try {
    return Strings::loadFile(filename);
  } catch (std::exception &e) {
    g_log.error() << "Error loading instrument IDF file: " << filename << ".\n";
    g_log.debug() << e.what() << '\n';
    throw;
  }
}
 
void ExperimentInfo::loadInstrumentParametersNexus(Nexus::File *file, std::string &parameterStr) {
  try {
    file->openGroup("instrument_parameter_map", "NXnote");
    file->readData("data", parameterStr);
    file->closeGroup();
  } catch (Nexus::Exception const &ex) {
    g_log.debug(std::string("Unable to load instrument_parameter_map: ") + ex.what());
    g_log.information("Parameter map entry missing from NeXus file. Continuing without it.");
  }
}
 
void ExperimentInfo::readParameterMap(const std::string &parameterStr) {
  Geometry::ParameterMap &pmap = this->instrumentParameters();
  auto &compInfo = mutableComponentInfo();
  auto &detInfo = mutableDetectorInfo();
 
  int options = Mantid::Kernel::StringTokenizer::TOK_IGNORE_EMPTY;
  options += Mantid::Kernel::StringTokenizer::TOK_TRIM;
  Mantid::Kernel::StringTokenizer splitter(parameterStr, "|", options);
 
  auto iend = splitter.end();
 
  Mantid::Kernel::StringTokenizer tokens;
  const std::string visibilityKey = "visible:"; // if visibility is defined, the value will follow this key
  // std::string prev_name;
  for (auto itr = splitter.begin(); itr != iend; ++itr) {
    tokens = Mantid::Kernel::StringTokenizer(*itr, ";");
    if (tokens.count() < 4)
      continue;
    std::string comp_name = tokens[0];
    // if( comp_name == prev_name ) continue; this blocks reading in different
    // parameters of the same component. RNT
    // prev_name = comp_name;
    // Resolve the component once, to an index. Both forms written by ParameterMap::asString()
    // are resolvable without consulting the legacy instrument tree: "detID:<id>" through
    // DetectorInfo, and a full path through ComponentInfo::indexOfFullName().
    size_t compIndex = Geometry::ComponentInfo::invalidIndex;
    if (comp_name.find("detID:") != std::string::npos) {
      const auto detID = static_cast<detid_t>(std::stoi(comp_name.substr(6)));
      try {
        // Detectors occupy the leading component indices, so a detector index is also its
        // component index.
        compIndex = detInfo.indexOf(detID);
      } catch (std::out_of_range &) {
        g_log.warning() << "Cannot find detector " << detID << '\n';
        continue;
      }
    } else {
      compIndex = compInfo.indexOfFullName(comp_name);
      if (compIndex == Geometry::ComponentInfo::invalidIndex) {
        // indexOfFullName() resolves only exact, fully-rooted paths. getComponentByName() is
        // more lenient -- it accepts a bare name anywhere in the tree and lets path segments be
        // skipped -- so fall back to it rather than rejecting strings the old code accepted.
        // Reproducing that leniency on ComponentInfo is its own piece of work.
        const auto *comp = sptr_instrument->getComponentByName(comp_name).get();
        if (comp) {
          compIndex = compInfo.indexOfOrInvalid(comp->getComponentID());
        }
        if (compIndex == Geometry::ComponentInfo::invalidIndex) {
          g_log.warning() << "Cannot find component " << comp_name << '\n';
          continue;
        }
      }
    }
 
    // create parameter's value as a sum of all tokens with index 3 or larger
    // this allow a parameter's value to contain ";"
    std::string paramValue = tokens[3];
    auto size = static_cast<int>(tokens.count());
    for (int i = 4; i < size; i++)
      paramValue += ";" + tokens[i];
    const auto &paramType = tokens[1];
    const auto &paramName = tokens[2];
    auto &paramVisibility = tokens[size - 1]; // parameter visibility, if defined, is the last token
    if (paramVisibility.find(visibilityKey) > paramVisibility.size())
      paramVisibility = "true"; // visibility not defined: default to visible
    else {                      // defined, the paramValue has one too many entries, -1 to remove also the semicolon
      paramVisibility =
          paramVisibility.substr(paramVisibility.find(visibilityKey) + visibilityKey.size(), paramVisibility.size());
      paramValue.erase(paramValue.find(visibilityKey) - 1, paramValue.size());
    }
    const auto paramDescr = std::string("");
    if (paramName == "masked") {
      auto value = getParam<bool>(paramType, paramValue);
      if (value) {
        // Do not add masking to ParameterMap, it is stored in DetectorInfo
        const auto componentIndex = compIndex;
        if (!compInfo.isDetector(componentIndex)) {
          throw std::runtime_error("Found masking for a non-detector "
                                   "component. This is not possible");
        } else
          detInfo.setMasked(componentIndex, value); // all detector indexes
                                                    // have same component
                                                    // index (guarantee)
      }
    } else if (isPositionParameter(paramName)) {
      // We are parsing a string obtained from a ParameterMap. The map may
      // contain posx, posy, and posz (in addition to pos). However, when these
      // component wise positions are set, 'pos' is updated accordingly. We are
      // thus ignoring position components below.
      const auto newRelPos = getParam<V3D>(paramType, paramValue);
      updatePosition(compInfo, compIndex, newRelPos);
    } else if (isRotationParameter(paramName)) {
      // We are parsing a string obtained from a ParameterMap. The map may
      // contain rotx, roty, and rotz (in addition to rot). However, when these
      // component wise rotations are set, 'rot' is updated accordingly. We are
      // thus ignoring rotation components below.
      const auto newRelRot = getParam<Quat>(paramType, paramValue);
      updateRotation(compInfo, compIndex, newRelRot);
    } else if (!isRedundantPosOrRot(paramName)) {
      // Special case RectangularDetector: Parameters scalex and scaley affect
      // pixel positions, but we must also add the parameter below.
      if (isScaleParameter(paramName))
        adjustPositionsFromScaleFactor(compInfo, compIndex, paramName, getParam<double>(paramType, paramValue));
      // For fitting parameters, route through addFittingParameter so that two functions on the same
      // component sharing a parameter short name (e.g. IkedaCarpenterPV:Gamma and
      // Bk2BkExpConvPV:Gamma) both survive a NeXus save/load round-trip. ParameterMap::add only
      // dedupes by (component, name) and would silently overwrite the first entry with the second.
      // The fitting-function name is embedded as the second comma-separated field of the value
      // string written by populateWithParameter().
 
      // string from populateWithParameter() is expected to be " , " (space-comma-space) separated:
      // "m_value , m_fittingFunction , name , constraint[0] , constraint[1] , penaltyFactor , tie ,
      // formula , formulaUnit , resultUnit , interpolation"
      if (paramType == "fitting") {
        std::string fittingFunction;
        // Locate the second field by finding the first two commas; the fitting function is the
        // text between them. If there are fewer than two commas the value is malformed and
        // fittingFunction stays empty, falling back to the plain add() below.
        const auto firstComma = paramValue.find(',');
        if (firstComma != std::string::npos) {
          const auto secondComma = paramValue.find(',', firstComma + 1);
          if (secondComma != std::string::npos) {
            // Take the raw second field, e.g. " IkedaCarpenterPV " from "3.5 , IkedaCarpenterPV , ...".
            fittingFunction = paramValue.substr(firstComma + 1, secondComma - firstComma - 1);
            // Trim the surrounding spaces/tabs introduced by the " , " separator.
            const auto firstNonSpace = fittingFunction.find_first_not_of(" \t");
            if (firstNonSpace != std::string::npos) {
              const auto lastNonSpace = fittingFunction.find_last_not_of(" \t");
              fittingFunction = fittingFunction.substr(firstNonSpace, lastNonSpace - firstNonSpace + 1);
            } else
              // Field was entirely whitespace (e.g. "3.5 ,  , ..."): treat as no fitting function.
              fittingFunction.clear();
          }
        }
        if (!fittingFunction.empty()) {
          pmap.addFittingParameter(compIndex, paramName, fittingFunction, paramValue, &paramDescr, paramVisibility);
        } else {
          pmap.add(paramType, compIndex, paramName, paramValue, &paramDescr, paramVisibility);
        }
      } else {
        pmap.add(paramType, compIndex, paramName, paramValue, &paramDescr, paramVisibility);
      }
    }
  }
}
 
void ExperimentInfo::populateWithParameter(Geometry::ComponentInfo &compInfo,
                                           Geometry::PositionAndRotationAccumulator &posAndRot, const size_t compIndex,
                                           const std::string &name, const Geometry::XMLInstrumentParameter &paramInfo,
                                           const Run &runData) {
  const std::string &category = paramInfo.m_type;
  ParameterValue paramValue(paramInfo,
                            runData); // Defines implicit conversion operator
 
  const std::string *pDescription = nullptr;
  if (!paramInfo.m_description.empty())
    pDescription = &paramInfo.m_description;
  std::string pVisible = "true";
  if (!paramInfo.m_visible.empty())
    pVisible = paramInfo.m_visible;
 
  // Some names are special. Values should be convertible to double
  if (name == "masked") {
    bool value(paramValue);
    if (value) {
      // Do not add masking to ParameterMap, it is stored in DetectorInfo
      if (!compInfo.isDetector(compIndex))
        throw std::runtime_error("Found masking for a non-detector component. This is not possible");
      mutableDetectorInfo().setMasked(compIndex,
                                      paramValue); // all detector indexes have
                                                   // same component index
                                                   // (guarantee)
    }
  } else if (name == "x" || name == "y" || name == "z") {
    // Seeded from the component's current position relative to its parent, so specifying one
    // coordinate leaves the other two alone. It must be the relative position: the accumulated
    // value is applied as a parent-relative one, so seeding with the absolute position would
    // re-apply the parent's rotation and translation on every call.
    posAndRot.setCoordinate(compIndex, name, paramValue, compInfo.relativePosition(compIndex));
  } else if (name == "rot" || name == "rotx" || name == "roty" || name == "rotz") {
    if (!posAndRot.setRotationAngle(compIndex, name, paramValue)) {
      // "rot" itself names no axis and is deliberately dropped, as it always has been.
      g_log.warning() << "Ignoring instrument parameter '" << name << "': it does not name a rotation axis.\n";
    }
  } else if (category == "fitting") {
    std::ostringstream str;
    // read parameter map relies on extracting m_fittingFunction from this string - edit with care
    str << paramInfo.m_value << " , " << paramInfo.m_fittingFunction << " , " << name << " , "
        << paramInfo.m_constraint[0] << " , " << paramInfo.m_constraint[1] << " , " << paramInfo.m_penaltyFactor
        << " , " << paramInfo.m_tie << " , " << paramInfo.m_formula << " , " << paramInfo.m_formulaUnit << " , "
        << paramInfo.m_resultUnit << " , " << (*(paramInfo.m_interpolation));
    // Dedupe by (name, fitting function) — otherwise two functions on the same component sharing
    // a parameter short name (e.g. Bk2BkExpConvPV:Gamma and IkedaCarpenterPV:Gamma) would clobber
    // each other in the map.
    compInfo.addFittingParameter(compIndex, name, paramInfo.m_fittingFunction, str.str(), pDescription, pVisible);
  } else if (category == "string") {
    compInfo.addString(compIndex, name, paramInfo.m_value, pDescription, pVisible);
  } else if (category == "bool") {
    compInfo.addBool(compIndex, name, paramValue, pDescription, pVisible);
  } else if (category == "int") {
    compInfo.addInt(compIndex, name, paramValue, pDescription, pVisible);
  } else { // assume double
    compInfo.addDouble(compIndex, name, paramValue, pDescription, pVisible);
  }
}
 
void ExperimentInfo::populateIfNotLoaded() const {
  // The default implementation does nothing. Used by subclasses
  // (FileBackedExperimentInfo) to load content from files upon access.
}
 
} // namespace Mantid::API
 
namespace Mantid::Kernel {
 
template <>
MANTID_API_DLL Mantid::API::ExperimentInfo_sptr
IPropertyManager::getValue<Mantid::API::ExperimentInfo_sptr>(const std::string &name) const {
  auto *prop = dynamic_cast<PropertyWithValue<Mantid::API::ExperimentInfo_sptr> *>(getPointerToProperty(name));
  if (prop) {
    return *prop;
  } else {
    std::string message =
        "Attempt to assign property " + name + " to incorrect type. Expected shared_ptr<ExperimentInfo>.";
    throw std::runtime_error(message);
  }
}
 
template <>
MANTID_API_DLL Mantid::API::ExperimentInfo_const_sptr
IPropertyManager::getValue<Mantid::API::ExperimentInfo_const_sptr>(const std::string &name) const {
  auto const *prop = dynamic_cast<PropertyWithValue<Mantid::API::ExperimentInfo_sptr> *>(getPointerToProperty(name));
  if (prop) {
    return prop->operator()();
  } else {
    std::string message =
        "Attempt to assign property " + name + " to incorrect type. Expected const shared_ptr<ExperimentInfo>.";
    throw std::runtime_error(message);
  }
}
 
} // namespace Mantid::Kernel