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/IDetector.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Instrument/FitParameter.h"
#include "MantidGeometry/Instrument/ParComponentFactory.h"
#include "MantidGeometry/Instrument/ParameterFactory.h"
#include "MantidKernel/Cache.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_cacheLocMap(std::make_unique<Kernel::Cache<const ComponentID, Kernel::V3D>>()),
      m_cacheRotMap(std::make_unique<Kernel::Cache<const ComponentID, Kernel::Quat>>()) {}
 
ParameterMap::ParameterMap(const ParameterMap &other)
    : m_parameterFileNames(other.m_parameterFileNames), m_map(other.m_map),
      m_cacheLocMap(std::make_unique<Kernel::Cache<const ComponentID, Kernel::V3D>>(*other.m_cacheLocMap)),
      m_cacheRotMap(std::make_unique<Kernel::Cache<const ComponentID, Kernel::Quat>>(*other.m_cacheRotMap)),
      m_instrument(other.m_instrument) {
  if (m_instrument)
    std::tie(m_componentInfo, m_detectorInfo) = m_instrument->makeBeamline(*this, &other);
}
 
// Defined as default in source for forward declaration with std::unique_ptr.
ParameterMap::~ParameterMap() = default;
 
// 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 {
  pmap_cit it;
  std::string result;
  for (it = m_map.begin(); it != m_map.end(); ++it) {
    if (compName == it->first->getName()) {
      std::shared_ptr<Parameter> param = get(it->first, 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 {
  pmap_cit it;
  std::string result;
  for (it = m_map.begin(); it != m_map.end(); ++it) {
    if (compName == it->first->getName()) {
      std::shared_ptr<Parameter> param = get(it->first, 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 ComponentIDs to full-qualified name identifiers
  // so we will use the same approach to compare them
 
  std::unordered_multimap<std::string, Parameter_sptr> thisMap, rhsMap;
  for (auto &mappair : this->m_map) {
    thisMap.emplace(mappair.first->getFullName(), mappair.second);
  }
  for (auto &mappair : rhs.m_map) {
    rhsMap.emplace(mappair.first->getFullName(), mappair.second);
  }
 
  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);
  // Key is component ID so have to search through whole lot
  for (auto itr = m_map.begin(); itr != m_map.end();) {
    if (itr->second->name() == name) {
      PARALLEL_CRITICAL(unsafe_erase) { itr = m_map.unsafe_erase(itr); }
    } else {
      ++itr;
    }
  }
  // Check if the caches need invalidating
  if (name == pos() || name == rot())
    clearPositionSensitiveCaches();
}
 
void ParameterMap::clearParametersByName(const std::string &name, const IComponent *comp) {
  checkIsNotMaskingParameter(name);
  if (!m_map.empty()) {
    const ComponentID id = comp->getComponentID();
    auto itrs = m_map.equal_range(id);
    for (auto it = itrs.first; it != itrs.second;) {
      if (it->second->name() == name) {
        PARALLEL_CRITICAL(unsafe_erase) { it = m_map.unsafe_erase(it); }
      } else {
        ++it;
      }
    }
 
    // Check if the caches need invalidating
    if (name == pos() || name == rot())
      clearPositionSensitiveCaches();
  }
}
 
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) {
  if (!par)
    return;
  checkIsNotMaskingParameter(par->name());
  if (pDescription)
    par->setDescription(*pDescription);
 
  auto existing_par = positionOf(comp, par->name().c_str(), "");
  // 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 be
  // an
  // add/replace-style function
  if (existing_par != m_map.end()) {
    std::atomic_store(&(existing_par->second), par);
  } else {
// When using Clang & Linux, TBB 4.4 doesn't detect C++11 features.
// https://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/641658
#if defined(__clang__) && !defined(__APPLE__)
#define CLANG_ON_LINUX true
#else
#define CLANG_ON_LINUX false
#endif
#if TBB_VERSION_MAJOR >= 4 && TBB_VERSION_MINOR >= 4 && !CLANG_ON_LINUX
    m_map.emplace(comp->getComponentID(), par);
#else
    m_map.insert(std::make_pair(comp->getComponentID(), par));
#endif
  }
}
 
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) {
  checkIsNotMaskingParameter(name);
  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.
  if (!m_map.empty()) {
    const ComponentID id = comp->getComponentID();
    auto it_found = m_map.find(id);
    if (it_found != m_map.end()) {
      auto itrs = m_map.equal_range(id);
      for (auto itr = itrs.first; itr != itrs.second; ++itr) {
        const auto &existing = itr->second;
        if (existing->type() == "fitting" && strcasecmp(existing->nameAsCString(), name.c_str()) == 0) {
          try {
            if (existing->value<FitParameter>().getFunction() == fittingFunction) {
              g_log.debug() << "addFittingParameter: [replace] matched existing (name='" << name << "', function='"
                            << fittingFunction << "') on component '" << comp->getName() << "'; overwriting in place\n";
              std::atomic_store(&(itr->second), param);
              return;
            }
          } catch (...) {
            // Not a FitParameter value despite the type tag
            g_log.debug() << "addFittingParameter: [skip-match] existing 'fitting' entry (name='" << name
                          << "') on component '" << comp->getName()
                          << "' did not hold a FitParameter value; ignoring it and continuing search\n";
          }
        }
      }
    }
  }
 
  g_log.debug() << "addFittingParameter: [insert] no existing match for (name='" << name << "', function='"
                << fittingFunction << "') on component '" << comp->getName() << "'; adding new entry\n";
  m_map.insert({comp->getComponentID(), param});
}
 
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;
  }
 
  // clear the position cache
  clearPositionSensitiveCaches();
  // 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;
  }
 
  // clear the position cache
  clearPositionSensitiveCaches();
 
  // 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);
 
// When using Clang & Linux, TBB 4.4 doesn't detect C++11 features.
// https://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/641658
#if defined(__clang__) && !defined(__APPLE__)
#define CLANG_ON_LINUX true
#else
#define CLANG_ON_LINUX false
#endif
#if TBB_VERSION_MAJOR >= 4 && TBB_VERSION_MINOR >= 4 && !CLANG_ON_LINUX
  m_map.emplace(comp->getComponentID(), param);
#else
  m_map.insert(std::make_pair(comp->getComponentID(), param));
#endif
}
 
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);
  clearPositionSensitiveCaches();
}
 
void ParameterMap::addV3D(const IComponent *comp, const std::string &name, const V3D &value,
                          const std::string *const pDescription) {
  add(pV3D(), comp, name, value, pDescription);
  clearPositionSensitiveCaches();
}
 
void ParameterMap::addQuat(const IComponent *comp, const std::string &name, const Quat &value,
                           const std::string *const pDescription) {
  add(pQuat(), comp, name, value, pDescription);
  clearPositionSensitiveCaches();
}
 
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);
  if (m_map.empty())
    return false;
  const ComponentID id = comp->getComponentID();
  std::pair<pmap_cit, pmap_cit> components = m_map.equal_range(id);
  bool anytype = (strlen(type) == 0);
  for (auto itr = components.first; itr != components.second; ++itr) {
    const auto &param = itr->second;
    if (strcasecmp(param->nameAsCString(), name) == 0 && (anytype || param->type() == type)) {
      return true;
    }
  }
  return false;
}
 
bool ParameterMap::contains(const IComponent *comp, const Parameter &parameter) const {
  checkIsNotMaskingParameter(parameter.name());
  if (m_map.empty() || !comp)
    return false;
 
  const ComponentID id = comp->getComponentID();
  auto it_found = m_map.find(id);
  if (it_found != m_map.end()) {
    auto itrs = m_map.equal_range(id);
    for (auto itr = itrs.first; itr != itrs.second; ++itr) {
      const Parameter_sptr &param = itr->second;
      if (*param == parameter)
        return true;
    }
    return false;
  } else
    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);
  Parameter_sptr result;
  if (!comp)
    return result;
 
  auto itr = positionOf(comp, name, type);
  if (itr != m_map.end())
    result = std::atomic_load(&itr->second);
  return result;
}
 
component_map_it ParameterMap::positionOf(const IComponent *comp, const char *name, const char *type) {
  auto result = m_map.end();
  if (!comp)
    return result;
  const bool anytype = (strlen(type) == 0);
  if (!m_map.empty()) {
    const ComponentID id = comp->getComponentID();
    auto it_found = m_map.find(id);
    if (it_found != m_map.end()) {
      auto itrs = m_map.equal_range(id);
      for (auto itr = itrs.first; itr != itrs.second; ++itr) {
        const auto &param = itr->second;
        if (strcasecmp(param->nameAsCString(), name) == 0 && (anytype || param->type() == type)) {
          result = itr;
          break;
        }
      }
    }
  }
  return result;
}
 
component_map_cit ParameterMap::positionOf(const IComponent *comp, const char *name, const char *type) const {
  auto result = m_map.end();
  if (!comp)
    return result;
  const bool anytype = (strlen(type) == 0);
  if (!m_map.empty()) {
    const ComponentID id = comp->getComponentID();
    auto it_found = m_map.find(id);
    if (it_found != m_map.end()) {
      auto itrs = m_map.equal_range(id);
      for (auto itr = itrs.first; itr != itrs.second; ++itr) {
        const auto &param = itr->second;
        if (strcasecmp(param->nameAsCString(), name) == 0 && (anytype || param->type() == type)) {
          result = itr;
          break;
        }
      }
    }
  }
  return result;
}
 
Parameter_sptr ParameterMap::getByType(const IComponent *comp, const std::string &type) const {
  Parameter_sptr result;
  if (!m_map.empty()) {
    const ComponentID id = comp->getComponentID();
    auto it_found = m_map.find(id);
    if (it_found != m_map.end() && it_found->first) {
      auto itrs = m_map.equal_range(id);
      for (auto itr = itrs.first; itr != itrs.second; ++itr) {
        const auto &param = itr->second;
        if (strcasecmp(param->type().c_str(), type.c_str()) == 0) {
          result = std::atomic_load(&param);
          break;
        }
      } // found->firdst
    } // it_found != m_map.end()
  } 
  return result;
}
 
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_map.empty())
    return Parameter_sptr();
 
  std::shared_ptr<const IComponent> compInFocus(comp, NoDeleting());
  while (compInFocus != nullptr) {
    const ComponentID id = compInFocus->getComponentID();
    auto it_found = m_map.find(id);
    if (it_found != m_map.end()) {
      auto itrs = m_map.equal_range(id);
      for (auto itr = itrs.first; itr != itrs.second; ++itr) {
        const auto &param = itr->second;
        if (param->type() == "fitting" && strcasecmp(param->nameAsCString(), name.c_str()) == 0) {
          try {
            if (param->value<FitParameter>().getFunction() == fittingFunction) {
              return std::atomic_load(&itr->second);
            }
          } catch (...) {
            // Not a FitParameter value despite the type tag, keep looking.
          }
        }
      }
    }
    compInFocus = compInFocus->getParent();
  }
  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 {
  std::set<std::string> paramNames;
  const ComponentID id = comp->getComponentID();
  auto it_found = m_map.find(id);
  if (it_found == m_map.end()) {
    return paramNames;
  }
 
  auto itrs = m_map.equal_range(id);
  for (auto it = itrs.first; it != itrs.second; ++it) {
    paramNames.insert(it->second->name());
  }
 
  return paramNames;
}
 
std::string ParameterMap::asString() const {
  std::stringstream out;
  for (const auto &mappair : m_map) {
    const std::shared_ptr<Parameter> &p = mappair.second;
    if (p && mappair.first) {
      const auto *comp = dynamic_cast<const IComponent *>(mappair.first);
      const auto *det = dynamic_cast<const IDetector *>(comp);
      if (det) {
        out << "detID:" << det->getID();
      } else if (comp) {
        out << comp->getFullName(); // Use full path name to ensure unambiguous
                                    // naming
      }
      const auto paramVisible = "visible:" + std::string(p->visible() == 1 ? "true" : "false");
      out << ';' << p->type() << ';' << p->name() << ';' << p->asString() << ';' << paramVisible << '|';
    }
  }
  return out.str();
}
 
void ParameterMap::clearPositionSensitiveCaches() {
  m_cacheLocMap->clear();
  m_cacheRotMap->clear();
}
 
void ParameterMap::setCachedLocation(const IComponent *comp, const V3D &location) const {
  m_cacheLocMap->setCache(comp->getComponentID(), location);
}
 
bool ParameterMap::getCachedLocation(const IComponent *comp, V3D &location) const {
  return m_cacheLocMap->getCache(comp->getComponentID(), location);
}
 
void ParameterMap::setCachedRotation(const IComponent *comp, const Quat &rotation) const {
  m_cacheRotMap->setCache(comp->getComponentID(), rotation);
}
 
bool ParameterMap::getCachedRotation(const IComponent *comp, Quat &rotation) const {
  return m_cacheRotMap->getCache(comp->getComponentID(), rotation);
}
 
void ParameterMap::copyFromParameterMap(const IComponent *oldComp, const IComponent *newComp,
                                        const ParameterMap *oldPMap) {
 
  auto oldParameterNames = oldPMap->names(oldComp);
  for (const auto &oldParameterName : oldParameterNames) {
    Parameter_sptr thisParameter = oldPMap->get(oldComp, oldParameterName);
// Insert the fetched parameter in the m_map
#if TBB_VERSION_MAJOR >= 4 && TBB_VERSION_MINOR >= 4 && !CLANG_ON_LINUX
    m_map.emplace(newComp->getComponentID(), std::move(thisParameter));
#else
    m_map.insert(std::make_pair(newComp->getComponentID(), std::move(thisParameter)));
#endif
  }
}
 
//--------------------------------------------------------------------------------------------
void ParameterMap::saveNexus(Nexus::File *file, const std::string &group) const {
  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");
  std::string s = this->asString();
  file->writeData("data", s);
  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;
}
 
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;
    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;
  if (m_map.empty()) {
    std::tie(m_componentInfo, m_detectorInfo) = m_instrument->makeBeamlineNew(*this);
  } else {
    std::tie(m_componentInfo, m_detectorInfo) = m_instrument->makeBeamline(*this);
  }
}
 
size_t ParameterMap::getMemorySize() const {
  // m_map: tbb::concurrent_unordered_multimap<ComponentID, shared_ptr<Parameter>>
  // Each node: key + value + ~2 pointers for chaining and bucket slot
  const size_t n = m_map.size();
  const size_t mapMem = n * (sizeof(pmap::value_type) + 2 * sizeof(void *));
  // Count the heap-allocated Parameter objects the shared_ptrs point to.
  // ParameterMap is a friend of Parameter so private string members are accessible.
  size_t parameterObjectsMem = 0;
  for (const auto &entry : m_map) {
    const auto &param = entry.second;
    if (param) {
      parameterObjectsMem += sizeof(Parameter);
      parameterObjectsMem += param->m_name.capacity();
      parameterObjectsMem += param->m_type.capacity();
      parameterObjectsMem += param->m_str_value.capacity();
      parameterObjectsMem += param->m_description.capacity();
    }
  }
  // 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_cacheLocMap and m_cacheRotMap: count the heap Cache objects; the internal std::map entries are not
  // counted because Kernel::Cache::size() is non-const and cannot be called here.
  const size_t cacheLocMem = m_cacheLocMap ? sizeof(*m_cacheLocMap) : 0;
  const size_t cacheRotMem = m_cacheRotMap ? sizeof(*m_cacheRotMap) : 0;
  // 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 + parameterObjectsMem + fileNamesMem + cacheLocMem + cacheRotMem + detectorInfoMem +
         componentInfoMem;
}
 
} // namespace Mantid::Geometry