ParameterMap.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 "MantidGeometry/Instrument/ParameterMap.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Instrument/FitParameter.h"
#include "MantidGeometry/Instrument/InstrumentMetadata.h"
#include "MantidGeometry/Instrument/InstrumentVisitor.h"
#include "MantidGeometry/Instrument/ParComponentFactory.h"
#include "MantidGeometry/Instrument/ParameterFactory.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/MultiThreaded.h"
#include "MantidNexus/NexusFile.h"
#include <boost/algorithm/string.hpp>
#include <cstring>
#include <numeric>
 
#ifdef _WIN32
#define strcasecmp _stricmp
#else
#include "strings.h"
#endif
 
namespace Mantid::Geometry {
using Kernel::Quat;
using Kernel::V3D;
 
namespace {
// names of common parameter types
const std::string POS_PARAM_NAME = "pos";
const std::string POSX_PARAM_NAME = "x";
const std::string POSY_PARAM_NAME = "y";
const std::string POSZ_PARAM_NAME = "z";
 
const std::string ROT_PARAM_NAME = "rot";
const std::string ROTX_PARAM_NAME = "rotx";
const std::string ROTY_PARAM_NAME = "roty";
const std::string ROTZ_PARAM_NAME = "rotz";
 
const std::string DOUBLE_PARAM_NAME = "double";
const std::string INT_PARAM_NAME = "int";
const std::string BOOL_PARAM_NAME = "bool";
const std::string STRING_PARAM_NAME = "string";
const std::string V3D_PARAM_NAME = "V3D";
const std::string QUAT_PARAM_NAME = "Quat";
 
const std::string SCALE_PARAM_NAME = "sca";
 
// static logger reference
Kernel::Logger g_log("ParameterMap");
 
void checkIsNotMaskingParameter(const std::string &name) {
  if (name == std::string("masked"))
    throw std::runtime_error("Masking data (\"masked\") cannot be stored in "
                             "ParameterMap. Use DetectorInfo instead");
}
} // namespace
ParameterMap::ParameterMap() : m_parameterInfo(std::make_shared<ParameterInfo>()) {}
 
ParameterMap::ParameterMap(const ParameterMap &other)
    // The store is deep-copied, not shared: a copied ParameterMap is an independent map, and
    // sharing would make a write through either one visible to the other.
    : m_parameterFileNames(other.m_parameterFileNames),
      m_parameterInfo(std::make_shared<ParameterInfo>(*other.m_parameterInfo)), m_domainIds(other.m_domainIds),
      m_domainIndices(other.m_domainIndices), m_stagedIndices(other.m_stagedIndices), m_stagedIds(other.m_stagedIds),
      m_instrument(other.m_instrument) {
  // Deliberately does NOT rebuild the beamline. That is now ExperimentInfo's job, via rebuildBeamlineFrom()
}
 
void ParameterMap::rebuildBeamlineFrom(const ParameterMap &source) {
  if (!m_instrument) {
    return;
  }
  auto [newComponentInfo, newDetectorInfo] = m_instrument->makeBeamline(*this, &source);
  m_componentInfo = std::move(newComponentInfo);
  m_detectorInfo = std::move(newDetectorInfo);
  // Deliberately does NOT adopt m_componentInfo's store here, unlike setInstrument().
  // This map was copy-constructed and therefore already holds its own deep copy of the parameters
  // The metadata is read-only and refers to nothing in the source map, so it can be shared rather
  // than rebuilt, which would walk the physical instrument again on every workspace copy.
  if (source.m_instrumentMetadata) {
    m_instrumentMetadata = source.m_instrumentMetadata;
  } else {
    buildInstrumentMetadata();
  }
}
 
// Defined as default in source for forward declaration with std::unique_ptr.
ParameterMap::~ParameterMap() = default;
 
//--------------------------------------------------------------------------------------------
// Component pointer <-> component index translation
//--------------------------------------------------------------------------------------------
 
size_t ParameterMap::indexOf(const IComponent *comp) const {
  size_t result = ComponentInfo::invalidIndex;
  if (comp) {
    // An attached map is keyed by component index, a detached one by staging index
    const auto &indices = m_domainIndices ? *m_domainIndices : m_stagedIndices;
    auto const found = indices.find(comp->getComponentID());
    if (found != indices.end()) {
      result = found->second;
    }
  }
  return result;
}
 
size_t ParameterMap::indexForWrite(const IComponent *comp) {
  size_t result = indexOf(comp);
  if (comp && result == ComponentInfo::invalidIndex) {
    if (m_domainIndices) {
      throw std::invalid_argument("ParameterMap: cannot add a parameter to component '" + comp->getFullName() +
                                  "', which is not part of the instrument this map belongs to");
    }
    // First time this component has been written to
    const ComponentID id = comp->getComponentID();
    result = m_stagedIds.size();
    m_stagedIds.emplace_back(id);
    m_stagedIndices.emplace(id, result);
  }
  return result;
}
 
std::string ParameterMap::componentName(const size_t index) const { return componentInfo().name(index); }
 
std::string ParameterMap::componentFullName(const size_t index) const { return componentInfo().fullName(index); }
 
std::vector<ParameterMap::Entry> ParameterMap::entries() const {
  if (!m_domainIds) {
    throw std::logic_error("ParameterMap::entries: the map is not attached to an instrument, so its components "
                           "have no component indices");
  }
  std::vector<Entry> result;
  result.reserve(m_parameterInfo->size());
  for (auto const &[index, parameters] : *m_parameterInfo) {
    for (auto const &[parameterName, parameter] : parameters) {
      static_cast<void>(parameterName);
      result.emplace_back(index, parameter);
    }
  }
  return result;
}
 
//--------------------------------------------------------------------------------------------
 
std::shared_ptr<ParameterInfo> ParameterMap::rekey(std::shared_ptr<const ComponentIDs> componentIds,
                                                   std::shared_ptr<const ComponentIndices> componentIndices) {
  if (componentIds == m_domainIds) {
    return m_parameterInfo;
  }
  // The components the current indices refer to
  const auto &oldIds = m_domainIds ? *m_domainIds : m_stagedIds;
  auto rekeyed = std::make_shared<ParameterInfo>();
  for (auto const &[oldIndex, parameters] : *m_parameterInfo) {
    auto const found = componentIndices->find(oldIds[oldIndex]);
    if (found == componentIndices->end()) {
      continue;
    }
    for (auto const &[parameterName, parameter] : parameters) {
      static_cast<void>(parameterName);
      // insert() rather than add(): this map's contents have already had the legacy
      // deduplication applied
      rekeyed->insert(found->second, parameter);
    }
  }
  for (auto const &[key, parameter] : m_parameterInfo->logfileParameters()) {
    auto const found = componentIndices->find(oldIds[key.first]);
    if (found != componentIndices->end()) {
      rekeyed->addLogfileParameter(found->second, key.second, parameter);
    }
  }
 
  // Adopt the rekeyed store and the instrument's index domain, so that this map and the
  // ComponentInfo built alongside it share one set of parameters from here on.
  m_parameterInfo = rekeyed;
  m_domainIds = std::move(componentIds);
  m_domainIndices = std::move(componentIndices);
  m_stagedIndices.clear();
  m_stagedIds.clear();
  return m_parameterInfo;
}
 
// Position
const std::string &ParameterMap::pos() { return POS_PARAM_NAME; }
 
const std::string &ParameterMap::posx() { return POSX_PARAM_NAME; }
 
const std::string &ParameterMap::posy() { return POSY_PARAM_NAME; }
 
const std::string &ParameterMap::posz() { return POSZ_PARAM_NAME; }
 
// Rotation
const std::string &ParameterMap::rot() { return ROT_PARAM_NAME; }
 
const std::string &ParameterMap::rotx() { return ROTX_PARAM_NAME; }
 
const std::string &ParameterMap::roty() { return ROTY_PARAM_NAME; }
 
const std::string &ParameterMap::rotz() { return ROTZ_PARAM_NAME; }
 
// Other types
const std::string &ParameterMap::pDouble() { return DOUBLE_PARAM_NAME; }
 
const std::string &ParameterMap::pInt() { return INT_PARAM_NAME; }
 
const std::string &ParameterMap::pBool() { return BOOL_PARAM_NAME; }
 
const std::string &ParameterMap::pString() { return STRING_PARAM_NAME; }
 
const std::string &ParameterMap::pV3D() { return V3D_PARAM_NAME; }
 
const std::string &ParameterMap::pQuat() { return QUAT_PARAM_NAME; }
 
// Scale
const std::string &ParameterMap::scale() { return SCALE_PARAM_NAME; }
 
bool ParameterMap::operator!=(const ParameterMap &rhs) const { return !(this->operator==(rhs)); }
 
bool ParameterMap::operator==(const ParameterMap &rhs) const { return diff(rhs, true, false, 0.).empty(); }
 
const std::string ParameterMap::getDescription(const std::string &compName, const std::string &name) const {
  std::string result;
  for (auto const &[index, parameters] : *m_parameterInfo) {
    static_cast<void>(parameters);
    if (compName == componentName(index)) {
      std::shared_ptr<Parameter> const param = m_parameterInfo->get(index, name);
      if (param) {
        result = param->getDescription();
        if (!result.empty())
          return result;
      }
    }
  }
  return result;
}
const std::string ParameterMap::getShortDescription(const std::string &compName, const std::string &name) const {
  std::string result;
  for (auto const &[index, parameters] : *m_parameterInfo) {
    static_cast<void>(parameters);
    if (compName == componentName(index)) {
      std::shared_ptr<Parameter> const param = m_parameterInfo->get(index, name);
      if (param) {
        result = param->getShortDescription();
        if (!result.empty())
          return result;
      }
    }
  }
  return result;
}
 
//------------------------------------------------------------------------------------------------
bool ParameterMap::relErr(double x1, double x2, double errorVal) const {
  double num = std::fabs(x1 - x2);
  // how to treat x1<0 and x2 > 0 ?  probably this way
  double den = 0.5 * (std::fabs(x1) + std::fabs(x2));
  if (den < errorVal)
    return (num > errorVal);
 
  return (num / den > errorVal);
}
 
const std::string ParameterMap::diff(const ParameterMap &rhs, const bool &firstDiffOnly, const bool relative,
                                     const double doubleTolerance) const {
  if (this == &rhs)
    return std::string(""); // True for the same object
 
  // Quick size check
  if (this->size() != rhs.size()) {
    return std::string("Number of parameters does not match: ") + std::to_string(this->size()) + " not equal to " +
           std::to_string(rhs.size());
  }
 
  // The map is unordered and the key is only valid at runtime. The
  // asString method turns the components to full-qualified name identifiers
  // so we will use the same approach to compare them
 
  std::unordered_multimap<std::string, Parameter_sptr> thisMap, rhsMap;
  auto const byFullName = [](ParameterMap const &map, std::unordered_multimap<std::string, Parameter_sptr> &result) {
    for (auto const &[index, parameters] : *map.m_parameterInfo) {
      auto const fullName = map.componentFullName(index);
      for (auto const &[parameterName, parameter] : parameters) {
        static_cast<void>(parameterName);
        result.emplace(fullName, parameter);
      }
    }
  };
  byFullName(*this, thisMap);
  byFullName(rhs, rhsMap);
 
  std::stringstream strOutput;
  for (auto thisIt = thisMap.cbegin(); thisIt != thisMap.cend(); ++thisIt) {
    const std::string fullName = thisIt->first;
    const auto &param = thisIt->second;
    bool match(false);
    for (auto rhsIt = rhsMap.cbegin(); rhsIt != rhsMap.cend(); ++rhsIt) {
      const std::string rhsFullName = rhsIt->first;
      const auto &rhsParam = rhsIt->second;
      if ((fullName == rhsFullName) && (param->name() == (rhsParam->name()))) {
        if ((param->type() == rhsParam->type()) && (rhsParam->type() == "double")) {
          if (relative) {
            if (!relErr(param->value<double>(), rhsParam->value<double>(), doubleTolerance))
              match = true;
          } else if (std::abs(param->value<double>() - rhsParam->value<double>()) <= doubleTolerance)
            match = true;
        } else if (param->asString() == rhsParam->asString()) {
          match = true;
        }
        if (match)
          break;
      }
    }
 
    if (!match) {
      // output some information that helps with understanding the mismatch
      strOutput << "Parameter mismatch LHS=RHS for LHS parameter in component "
                   "with name: "
                << fullName << ". Parameter name is: " << (*param).name() << " and value: " << (*param).asString()
                << '\n';
      bool componentWithSameNameRHS = false;
      bool parameterWithSameNameRHS = false;
      for (auto rhsIt = rhsMap.cbegin(); rhsIt != rhsMap.cend(); ++rhsIt) {
        const std::string rhsFullName = rhsIt->first;
        if (fullName == rhsFullName) {
          componentWithSameNameRHS = true;
          if ((*param).name() == (*rhsIt->second).name()) {
            parameterWithSameNameRHS = true;
            strOutput << "RHS param with same name has value: " << (*rhsIt->second).asString() << '\n';
          }
        }
      }
      if (!componentWithSameNameRHS) {
        strOutput << "No matching RHS component name\n";
      }
      if (componentWithSameNameRHS && !parameterWithSameNameRHS) {
        strOutput << "Found matching RHS component name but not parameter name\n";
      }
      if (firstDiffOnly)
        return strOutput.str();
    }
  }
  return strOutput.str();
}
 
void ParameterMap::clearParametersByName(const std::string &name) {
  checkIsNotMaskingParameter(name);
  // The erase is guarded at whole operation granularity rather than per element.
  PARALLEL_CRITICAL(unsafe_erase) { m_parameterInfo->clearParametersByName(name); }
}
 
void ParameterMap::clearParametersByName(const std::string &name, const IComponent *comp) {
  checkIsNotMaskingParameter(name);
  const size_t index = indexOf(comp);
  if (index != ComponentInfo::invalidIndex) {
    PARALLEL_CRITICAL(unsafe_erase) { m_parameterInfo->clearParametersByName(index, name); }
  }
}
 
void ParameterMap::add(const std::string &type, const IComponent *comp, const std::string &name,
                       const std::string &value, const std::string *const pDescription, const std::string &pVisible) {
  auto param = ParameterFactory::create(type, name, pVisible);
  param->fromString(value);
  this->add(comp, param, pDescription);
}
 
void ParameterMap::add(const IComponent *comp, const std::shared_ptr<Parameter> &par,
                       const std::string *const pDescription) {
  // indexForWrite() allocates an index for a component this map has not seen before; everything
  // else is the index-addressed overload's job.
  add(indexForWrite(comp), par, pDescription);
}
 
void ParameterMap::add(const size_t componentIndex, const std::shared_ptr<Parameter> &par,
                       const std::string *const pDescription) {
  if (!par || componentIndex == ComponentInfo::invalidIndex)
    return;
  checkIsNotMaskingParameter(par->name());
  if (pDescription)
    par->setDescription(*pDescription);
 
  // As this is only an add method it should really throw if it already exists. However, this
  // is old behavior and many things rely on this actually being an add/replace-style function
  // -- ParameterInfo::add() implements exactly that, including the case-insensitive name match.
  m_parameterInfo->add(componentIndex, par);
}
 
void ParameterMap::add(const std::string &type, const size_t componentIndex, const std::string &name,
                       const std::string &value, const std::string *const pDescription, const std::string &pVisible) {
  auto param = ParameterFactory::create(type, name, pVisible);
  param->fromString(value);
  add(componentIndex, param, pDescription);
}
 
void ParameterMap::addFittingParameter(const IComponent *comp, const std::string &name,
                                       const std::string &fittingFunction, const std::string &value,
                                       const std::string *const pDescription, const std::string &pVisible) {
  addFittingParameter(indexForWrite(comp), name, fittingFunction, value, pDescription, pVisible);
}
 
void ParameterMap::addFittingParameter(const size_t componentIndex, const std::string &name,
                                       const std::string &fittingFunction, const std::string &value,
                                       const std::string *const pDescription, const std::string &pVisible) {
  checkIsNotMaskingParameter(name);
  if (componentIndex == ComponentInfo::invalidIndex)
    return;
  auto param = ParameterFactory::create("fitting", name, pVisible);
  param->fromString(value);
  if (pDescription)
    param->setDescription(*pDescription);
 
  // Look for an existing fitting parameter on this component with the same name AND the same
  // embedded function; only that one should be replaced.
  // ParameterInfo applies that rule and reports which of the two happened.
  const bool replaced = m_parameterInfo->addFittingParameter(componentIndex, param, fittingFunction);
  g_log.debug() << "addFittingParameter: [" << (replaced ? "replace" : "insert") << "] (name='" << name
                << "', function='" << fittingFunction << "') on component index " << componentIndex << '\n';
}
 
void ParameterMap::addPositionCoordinate(const IComponent *comp, const std::string &name, const double value,
                                         const std::string *const pDescription) {
  Parameter_sptr param = get(comp, pos());
  V3D position;
  if (param) {
    // so "pos" already defined
    position = param->value<V3D>();
  } else {
    // so "pos" is not defined - therefore get position from component
    position = comp->getPos();
  }
 
  // adjust position
 
  if (name == posx())
    position.setX(value);
  else if (name == posy())
    position.setY(value);
  else if (name == posz())
    position.setZ(value);
  else {
    g_log.warning() << "addPositionCoordinate() called with unrecognized "
                       "coordinate symbol: "
                    << name;
    // set description if one is provided
    if (pDescription) {
      param->setDescription(*pDescription);
    }
    return;
  }
 
  // finally add or update "pos" parameter
  addV3D(comp, pos(), position, pDescription);
}
 
void ParameterMap::addRotationParam(const IComponent *comp, const std::string &name, const double deg,
                                    const std::string *const pDescription) {
  Parameter_sptr paramRotX = get(comp, rotx());
  Parameter_sptr paramRotY = get(comp, roty());
  Parameter_sptr paramRotZ = get(comp, rotz());
  double rotX, rotY, rotZ;
 
  if (paramRotX)
    rotX = paramRotX->value<double>();
  else
    rotX = 0.0;
 
  if (paramRotY)
    rotY = paramRotY->value<double>();
  else
    rotY = 0.0;
 
  if (paramRotZ)
    rotZ = paramRotZ->value<double>();
  else
    rotZ = 0.0;
 
  // adjust rotation
  Quat quat;
  if (name == rotx()) {
    addDouble(comp, rotx(), deg);
    quat = Quat(deg, V3D(1, 0, 0)) * Quat(rotY, V3D(0, 1, 0)) * Quat(rotZ, V3D(0, 0, 1));
  } else if (name == roty()) {
    addDouble(comp, roty(), deg);
    quat = Quat(rotX, V3D(1, 0, 0)) * Quat(deg, V3D(0, 1, 0)) * Quat(rotZ, V3D(0, 0, 1));
  } else if (name == rotz()) {
    addDouble(comp, rotz(), deg);
    quat = Quat(rotX, V3D(1, 0, 0)) * Quat(rotY, V3D(0, 1, 0)) * Quat(deg, V3D(0, 0, 1));
  } else {
    g_log.warning() << "addRotationParam() called with unrecognized coordinate symbol: " << name;
    return;
  }
 
  // finally add or update "pos" parameter
  addQuat(comp, rot(), quat, pDescription);
}
 
void ParameterMap::addDouble(const IComponent *comp, const std::string &name, const std::string &value,
                             const std::string *const pDescription, const std::string &pVisible) {
  add(pDouble(), comp, name, value, pDescription, pVisible);
}
 
void ParameterMap::addDouble(const IComponent *comp, const std::string &name, double value,
                             const std::string *const pDescription, const std::string &pVisible) {
  add(pDouble(), comp, name, value, pDescription, pVisible);
}
 
void ParameterMap::addInt(const IComponent *comp, const std::string &name, const std::string &value,
                          const std::string *const pDescription, const std::string &pVisible) {
  add(pInt(), comp, name, value, pDescription, pVisible);
}
 
void ParameterMap::addInt(const IComponent *comp, const std::string &name, int value,
                          const std::string *const pDescription, const std::string &pVisible) {
  add(pInt(), comp, name, value, pDescription, pVisible);
}
 
void ParameterMap::addBool(const IComponent *comp, const std::string &name, const std::string &value,
                           const std::string *const pDescription, const std::string &pVisible) {
  add(pBool(), comp, name, value, pDescription, pVisible);
}
void ParameterMap::addBool(const IComponent *comp, const std::string &name, bool value,
                           const std::string *const pDescription, const std::string &pVisible) {
  add(pBool(), comp, name, value, pDescription, pVisible);
}
 
void ParameterMap::forceUnsafeSetMasked(const IComponent *comp, bool value) {
  const std::string name("masked");
  auto param = create(pBool(), name);
  auto typedParam = std::dynamic_pointer_cast<ParameterType<bool>>(param);
  typedParam->setValue(value);
 
  // insert() rather than add(): "masked" is rejected by checkIsNotMaskingParameter() on every
  // normal path, so this bypasses the add/replace lookup exactly as the raw insert did before.
  m_parameterInfo->insert(indexForWrite(comp), param);
}
 
void ParameterMap::addString(const IComponent *comp, const std::string &name, const std::string &value,
                             const std::string *const pDescription, const std::string &pVisible) {
  add<std::string>(pString(), comp, name, value, pDescription, pVisible);
}
 
void ParameterMap::addV3D(const IComponent *comp, const std::string &name, const std::string &value,
                          const std::string *const pDescription) {
  add(pV3D(), comp, name, value, pDescription);
}
 
void ParameterMap::addV3D(const IComponent *comp, const std::string &name, const V3D &value,
                          const std::string *const pDescription) {
  add(pV3D(), comp, name, value, pDescription);
}
 
void ParameterMap::addQuat(const IComponent *comp, const std::string &name, const Quat &value,
                           const std::string *const pDescription) {
  add(pQuat(), comp, name, value, pDescription);
}
 
bool ParameterMap::contains(const IComponent *comp, const std::string &name, const std::string &type) const {
  return contains(comp, name.c_str(), type.c_str());
}
 
bool ParameterMap::contains(const IComponent *comp, const char *name, const char *type) const {
  checkIsNotMaskingParameter(name);
  const size_t index = indexOf(comp);
  return index != ComponentInfo::invalidIndex && m_parameterInfo->contains(index, name, type);
}
 
bool ParameterMap::contains(const IComponent *comp, const Parameter &parameter) const {
  checkIsNotMaskingParameter(parameter.name());
  const size_t index = indexOf(comp);
  if (index == ComponentInfo::invalidIndex)
    return false;
 
  // Compares whole Parameter objects (name, type and value), not just the name, so every
  // parameter on the component has to be examined rather than looked up by name.
  for (auto const &[storedName, param] : m_parameterInfo->parameters(index)) {
    static_cast<void>(storedName);
    if (param && *param == parameter)
      return true;
  }
  return false;
}
 
Parameter_sptr ParameterMap::get(const IComponent *comp, const std::string &name, const std::string &type) const {
  return get(comp, name.c_str(), type.c_str());
}
 
std::shared_ptr<Parameter> ParameterMap::get(const IComponent *comp, const char *name, const char *type) const {
  checkIsNotMaskingParameter(name);
  const size_t index = indexOf(comp);
  return index == ComponentInfo::invalidIndex ? Parameter_sptr() : m_parameterInfo->get(index, name, type);
}
 
Parameter_sptr ParameterMap::getByType(const IComponent *comp, const std::string &type) const {
  const size_t index = indexOf(comp);
  return index == ComponentInfo::invalidIndex ? Parameter_sptr() : m_parameterInfo->getByType(index, type);
}
 
Parameter_sptr ParameterMap::getRecursiveByType(const IComponent *comp, const std::string &type) const {
  std::shared_ptr<const IComponent> compInFocus(comp, NoDeleting());
  while (compInFocus != nullptr) {
    Parameter_sptr param = getByType(compInFocus.get(), type);
    if (param) {
      return param;
    }
    compInFocus = compInFocus->getParent();
  }
  // Nothing was found!
  return Parameter_sptr();
}
 
Parameter_sptr ParameterMap::getRecursive(const IComponent *comp, const std::string &name,
                                          const std::string &type) const {
  return getRecursive(comp, name.c_str(), type.c_str());
}
 
Parameter_sptr ParameterMap::getRecursive(const IComponent *comp, const char *name, const char *type) const {
  checkIsNotMaskingParameter(name);
  Parameter_sptr result = this->get(comp->getComponentID(), name, type);
  if (result)
    return result;
 
  auto parent = comp->getParent();
  while (parent) {
    result = this->get(parent->getComponentID(), name, type);
    if (result)
      return result;
    parent = parent->getParent();
  }
  return result;
}
 
Parameter_sptr ParameterMap::getRecursiveFittingParameter(const IComponent *comp, const std::string &name,
                                                          const std::string &fittingFunction) const {
  checkIsNotMaskingParameter(name);
  if (!comp || m_parameterInfo->empty())
    return Parameter_sptr();
 
  // Walk up the component tree using a raw pointer. Wrapping the externally-owned
  // component in a shared_ptr (even with NoDeleting) makes Coverity flag it as being
  // managed by two smart pointers; the parent shared_ptr keeps each level alive.
  const IComponent *current = comp;
  std::shared_ptr<const IComponent> parent;
  while (current != nullptr) {
    const size_t index = indexOf(current);
    if (index != ComponentInfo::invalidIndex) {
      for (auto const &[storedName, param] : m_parameterInfo->parameters(index)) {
        static_cast<void>(storedName);
        if (param->type() == "fitting" && strcasecmp(param->nameAsCString(), name.c_str()) == 0) {
          try {
            if (param->value<FitParameter>().getFunction() == fittingFunction) {
              return param;
            }
          } catch (...) {
            // Not a FitParameter value despite the type tag, keep looking.
          }
        }
      }
    }
    parent = current->getParent();
    current = parent.get();
  }
  return Parameter_sptr();
}
 
std::string ParameterMap::getString(const IComponent *comp, const std::string &name, bool recursive) const {
  Parameter_sptr param;
  if (recursive) {
    param = getRecursive(comp, name);
  } else {
    param = get(comp, name);
  }
  if (!param)
    return "";
  return param->asString();
}
 
std::set<std::string> ParameterMap::names(const IComponent *comp) const {
  const size_t index = indexOf(comp);
  return index == ComponentInfo::invalidIndex ? std::set<std::string>() : m_parameterInfo->names(index);
}
 
std::string ParameterMap::asString() const {
  if (m_parameterInfo->empty()) {
    return std::string();
  }
  return asString(entries(), componentInfo(), detectorInfo());
}
 
std::string ParameterMap::asString(const std::vector<Entry> &entries, const ComponentInfo &componentInfo,
                                   const DetectorInfo &detectorInfo) {
  std::stringstream out;
  for (auto const &[index, p] : entries) {
    if (p) {
      // Identify the component: a detector by its ID, anything else by its full path name, which
      // is unambiguous
      const std::string component = componentInfo.isDetector(index)
                                        ? "detID:" + std::to_string(detectorInfo.detectorIDs()[index])
                                        : componentInfo.fullName(index);
      out << asStringEntry(component, *p);
    }
  }
  return out.str();
}
 
std::string ParameterMap::asStringEntry(const std::string &component, const Parameter &parameter) {
  const auto paramVisible = "visible:" + std::string(parameter.visible() == 1 ? "true" : "false");
  return component + ';' + parameter.type() + ';' + parameter.name() + ';' + parameter.asString() + ';' + paramVisible +
         '|';
}
 
void ParameterMap::copyFromParameterMap(const IComponent *oldComp, const IComponent *newComp,
                                        const ParameterMap *oldPMap) {
 
  auto const oldParameterNames = oldPMap->names(oldComp);
  const size_t newIndex = indexForWrite(newComp);
  for (const auto &oldParameterName : oldParameterNames) {
    // insert() rather than add(), matching the raw insert this replaced: names() has already
    // deduplicated, so no add/replace lookup is wanted here.
    m_parameterInfo->insert(newIndex, oldPMap->get(oldComp, oldParameterName));
  }
}
 
//--------------------------------------------------------------------------------------------
void ParameterMap::saveNexus(Nexus::File *file, const std::string &group, const std::string &contents) {
  file->makeGroup(group, "NXnote", true);
  file->putAttr("version", 1);
  file->writeData("author", "");
  file->writeData("date", Types::Core::DateAndTime::getCurrentTime().toISO8601String());
  file->writeData("description", "A string representation of the parameter "
                                 "map. The format is either: "
                                 "|detID:id-value;param-type;param-name;param-"
                                 "value| for a detector or  "
                                 "|comp-name;param-type;param-name;param-value|"
                                 " for other components.");
  file->writeData("type", "text/plain");
  file->writeData("data", contents);
  file->closeGroup();
}
 
const std::vector<std::string> &ParameterMap::getParameterFilenames() const { return m_parameterFileNames; }
 
void ParameterMap::addParameterFilename(const std::string &filename) { m_parameterFileNames.emplace_back(filename); }
 
std::shared_ptr<Parameter> ParameterMap::create(const std::string &className, const std::string &name,
                                                const std::string &visible) const {
  return ParameterFactory::create(className, name, visible);
}
 
bool ParameterMap::hasDetectorInfo(const Instrument *instrument) const {
  if (instrument != m_instrument)
    return false;
  return static_cast<bool>(m_detectorInfo);
}
 
bool ParameterMap::hasComponentInfo(const Instrument *instrument) const {
  if (instrument != m_instrument)
    return false;
  return static_cast<bool>(m_componentInfo);
}
 
const Geometry::DetectorInfo &ParameterMap::detectorInfo() const {
  if (!hasDetectorInfo(m_instrument))
    throw std::runtime_error("Cannot return reference to NULL DetectorInfo");
  return *m_detectorInfo;
}
 
Geometry::DetectorInfo &ParameterMap::mutableDetectorInfo() {
  if (!hasDetectorInfo(m_instrument))
    throw std::runtime_error("Cannot return reference to NULL DetectorInfo");
  return *m_detectorInfo;
}
 
const Geometry::ComponentInfo &ParameterMap::componentInfo() const {
  if (!hasComponentInfo(m_instrument)) {
    throw std::runtime_error("Cannot return reference to NULL ComponentInfo");
  }
  return *m_componentInfo;
}
 
Geometry::ComponentInfo &ParameterMap::mutableComponentInfo() {
  if (!hasComponentInfo(m_instrument)) {
    throw std::runtime_error("Cannot return reference to NULL ComponentInfo");
  }
  return *m_componentInfo;
}
 
const Geometry::InstrumentMetadata &ParameterMap::instrumentMetadata() const {
  if (!m_instrumentMetadata) {
    throw std::runtime_error("Cannot return reference to NULL InstrumentMetadata");
  }
  return *m_instrumentMetadata;
}
 
size_t ParameterMap::detectorIndex(const detid_t detID) const { return m_instrument->detectorIndex(detID); }
 
size_t ParameterMap::componentIndex(const ComponentID componentId) const {
  return m_componentInfo->indexOf(componentId);
}
 
void ParameterMap::setInstrument(const Instrument *instrument) {
  if (instrument == m_instrument)
    return;
  if (!instrument) {
    m_componentInfo = nullptr;
    m_detectorInfo = nullptr;
    m_instrumentMetadata = nullptr;
    return;
  }
  if (m_instrument)
    throw std::logic_error("ParameterMap::setInstrument: Cannot change "
                           "instrument once it has been set.");
  if (instrument->isParametrized())
    throw std::logic_error("ParameterMap::setInstrument must be called with "
                           "base instrument, not a parametrized instrument");
  m_instrument = instrument;
  // Assigned one at a time rather than through std::tie: the members are shared_ptr while
  // makeBeamline returns unique_ptr, and the conversion is clearer spelled out.
  auto [newComponentInfo, newDetectorInfo] =
      m_parameterInfo->empty() ? m_instrument->makeBeamlineNew(*this) : m_instrument->makeBeamline(*this);
  m_componentInfo = std::move(newComponentInfo);
  m_detectorInfo = std::move(newDetectorInfo);
  // The visitor called rekey() while building the beamline, so this map and the new
  // ComponentInfo now share one store. Re-point at it to be certain of that even on the
  // makeBeamlineNew() path, where there were no parameters to rekey.
  if (m_componentInfo) {
    m_parameterInfo = m_componentInfo->sharedParameterInfo();
    seedLogfileParameters();
  }
  buildInstrumentMetadata();
}
 
void ParameterMap::seedLogfileParameters() {
  for (auto const &[key, parameter] : m_instrument->getLogfileCache()) {
    auto const index = m_componentInfo->indexOfOrInvalid(key.second);
    if (index != ComponentInfo::invalidIndex) {
      m_parameterInfo->addLogfileParameter(index, key.first, parameter);
    }
  }
}
 
void ParameterMap::buildInstrumentMetadata() {
  std::shared_ptr<const ComponentInfo> physicalComponentInfo;
  std::shared_ptr<const DetectorInfo> physicalDetectorInfo;
  if (const auto &basePhysicalInstrument = m_instrument->getPhysicalInstrument()) {
    // This map's parameters are keyed by the neutronic instrument's components, so none apply to the
    // physical one and it is walked unparametrized. The visitor keeps it alive inside the DetectorInfo.
    InstrumentVisitor visitor(basePhysicalInstrument);
    visitor.walkInstrument();
    std::tie(physicalComponentInfo, physicalDetectorInfo) = visitor.makeWrappers();
  }
  m_instrumentMetadata = std::make_shared<InstrumentMetadata>(
      m_instrument->getValidFromDate(), m_instrument->getValidToDate(), m_instrument->getFilename(),
      m_instrument->getXmlText(), m_instrument->getDefaultView(), m_instrument->getDefaultAxis(), physicalComponentInfo,
      physicalDetectorInfo);
}
 
size_t ParameterMap::getMemorySize() const {
  // The parameters themselves, including the Parameter objects on the heap. Note that the
  // store may be shared with the owning ComponentInfo, which reports it too, so summing this
  // with ComponentInfo::getMemorySize() double-counts it.
  const size_t mapMem = m_parameterInfo->getMemorySize();
  // The staging tables, which exist only here. The index domain is shared with ComponentInfo,
  // which reports it.
  const size_t translationMem =
      m_stagedIndices.size() * (sizeof(std::pair<const ComponentID, size_t>) + sizeof(void *)) +
      m_stagedIds.capacity() * sizeof(ComponentID);
  // m_parameterFileNames: vector of strings; sizeof(*this) covers the vector object, count the heap buffer
  const size_t fileNamesMem = m_parameterFileNames.size() * sizeof(std::string) +
                              std::accumulate(m_parameterFileNames.cbegin(), m_parameterFileNames.cend(), size_t{0},
                                              [](size_t acc, const auto &s) { return acc + s.capacity(); });
  // m_detectorInfo and m_componentInfo: owned by ParameterMap for parametrized instruments
  const size_t detectorInfoMem = m_detectorInfo ? m_detectorInfo->getMemorySize() : 0;
  const size_t componentInfoMem = m_componentInfo ? m_componentInfo->getMemorySize() : 0;
  // m_instrument is a non-owning raw pointer to the base Instrument; its memory is counted in
  // Instrument::getMemorySize() and excluded here to avoid double-counting.
  return sizeof(*this) + mapMem + translationMem + fileNamesMem + detectorInfoMem + componentInfoMem;
}
 
} // namespace Mantid::Geometry