ParameterMap.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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 +
#pragma once
 
#include "MantidGeometry/DllConfig.h"
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/IDTypes.h" //For specnum_t
#include "MantidGeometry/IDetector.h"
#include "MantidGeometry/Instrument/Parameter.h"
#include "MantidGeometry/Instrument/ParameterInfo.h"
 
#include <cstddef>
#include <memory>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace Mantid {
namespace Kernel {
template <class KEYTYPE, class VALUETYPE> class Cache;
}
namespace Geometry {
class ComponentInfo;
class DetectorInfo;
class Instrument;
class InstrumentMetadata;
 
 
class MANTID_GEOMETRY_DLL ParameterMap {
public:
  using Entry = std::pair<ComponentID, std::shared_ptr<Parameter>>;
 
  ParameterMap();
  ParameterMap(const ParameterMap &other);
  ~ParameterMap();
  inline bool empty() const { return m_parameterInfo->empty(); }
  inline int size() const { return static_cast<int>(m_parameterInfo->size()); }
  size_t getMemorySize() const;
  static const std::string &pos();
  static const std::string &posx();
  static const std::string &posy();
  static const std::string &posz();
  static const std::string &rot();
  static const std::string &rotx();
  static const std::string &roty();
  static const std::string &rotz();
  static const std::string &pDouble(); // p prefix to avoid name clash
  static const std::string &pInt();
  static const std::string &pBool();
  static const std::string &pString();
  static const std::string &pV3D();
  static const std::string &pQuat();
  static const std::string &scale();
 
  const std::string diff(const ParameterMap &rhs, const bool &firstDiffOnly = false, const bool relative = false,
                         const double doubleTolerance = Kernel::Tolerance) const;
 
  bool operator!=(const ParameterMap &rhs) const;
  bool operator==(const ParameterMap &rhs) const;
 
  inline void clear() {
    m_parameterInfo->clear();
    m_idToIndex.clear();
    m_indexToId.clear();
    clearPositionSensitiveCaches();
  }
  void swap(ParameterMap &other) {
    // The translation tables must travel with the store: an index is meaningless without them.
    m_parameterInfo.swap(other.m_parameterInfo);
    m_idToIndex.swap(other.m_idToIndex);
    m_indexToId.swap(other.m_indexToId);
    clearPositionSensitiveCaches();
  }
  void clearParametersByName(const std::string &name);
 
  void clearParametersByName(const std::string &name, const IComponent *comp);
 
  void add(const std::string &type, const IComponent *comp, const std::string &name, const std::string &value,
           const std::string *const pDescription = nullptr, const std::string &visible = "true");
 
  template <class T>
  void add(const std::string &type, const IComponent *comp, const std::string &name, const T &value,
           const std::string *const pDescription = nullptr, const std::string &pVisible = "true") {
    auto param = create(type, name, pVisible);
    auto typedParam = std::dynamic_pointer_cast<ParameterType<T>>(param);
    assert(typedParam); // If not true the factory has created the wrong type
    typedParam->setValue(value);
    this->add(comp, param, pDescription);
  }
  void add(const IComponent *comp, const std::shared_ptr<Parameter> &par,
           const std::string *const pDescription = nullptr);
 
  void addFittingParameter(const IComponent *comp, const std::string &name, const std::string &fittingFunction,
                           const std::string &value, const std::string *const pDescription = nullptr,
                           const std::string &pVisible = "true");
 
  void add(const std::string &type, const size_t componentIndex, const std::string &name, const std::string &value,
           const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void add(const size_t componentIndex, const std::shared_ptr<Parameter> &par,
           const std::string *const pDescription = nullptr);
  void addFittingParameter(const size_t componentIndex, const std::string &name, const std::string &fittingFunction,
                           const std::string &value, const std::string *const pDescription = nullptr,
                           const std::string &pVisible = "true");
 
  void addPositionCoordinate(const IComponent *comp, const std::string &name, const double value,
                             const std::string *const pDescription = nullptr);
  void addRotationParam(const IComponent *comp, const std::string &name, const double deg,
                        const std::string *const pDescription = nullptr);
  void addDouble(const IComponent *comp, const std::string &name, const std::string &value,
                 const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addDouble(const IComponent *comp, const std::string &name, double value,
                 const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addInt(const IComponent *comp, const std::string &name, const std::string &value,
              const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addInt(const IComponent *comp, const std::string &name, int value,
              const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addBool(const IComponent *comp, const std::string &name, const std::string &value,
               const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addBool(const IComponent *comp, const std::string &name, bool value,
               const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addString(const IComponent *comp, const std::string &name, const std::string &value,
                 const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addV3D(const IComponent *comp, const std::string &name, const std::string &value,
              const std::string *const pDescription = nullptr);
  void addV3D(const IComponent *comp, const std::string &name, const Kernel::V3D &value,
              const std::string *const pDescription = nullptr);
  void addQuat(const IComponent *comp, const std::string &name, const Kernel::Quat &value,
               const std::string *const pDescription = nullptr);
  void forceUnsafeSetMasked(const IComponent *comp, bool value);
 
  bool contains(const IComponent *comp, const std::string &name, const std::string &type = "") const;
  bool contains(const IComponent *comp, const char *name, const char *type = "") const;
  bool contains(const IComponent *comp, const Parameter &parameter) const;
  std::shared_ptr<Parameter> get(const IComponent *comp, const std::string &name, const std::string &type = "") const;
  std::shared_ptr<Parameter> get(const IComponent *comp, const char *name, const char *type = "") const;
  std::shared_ptr<Parameter> getByType(const IComponent *comp, const std::string &type) const;
  std::shared_ptr<Parameter> getRecursive(const IComponent *comp, const std::string &name,
                                          const std::string &type = "") const;
  std::shared_ptr<Parameter> getRecursive(const IComponent *comp, const char *name, const char *type = "") const;
  std::shared_ptr<Parameter> getRecursiveByType(const IComponent *comp, const std::string &type) const;
 
  std::shared_ptr<Parameter> getRecursiveFittingParameter(const IComponent *comp, const std::string &name,
                                                          const std::string &fittingFunction) const;
 
  template <class T> std::vector<T> getType(const std::string &compName, const std::string &name) const {
    std::vector<T> retval;
    // Iterate every stored parameter because the match is on component name rather than key
    for (auto const &entry : entries()) {
      if (compName == entry.first->getName()) {
        std::shared_ptr<Parameter> const param = get(entry.first, name);
        if (param) {
          retval.emplace_back(param->value<T>());
        }
      }
    }
    return retval;
  }
  const std::string getDescription(const std::string &compName, const std::string &name) const;
  const std::string getShortDescription(const std::string &compName, const std::string &name) const;
 
  std::string getString(const IComponent *comp, const std::string &name, bool recursive = false) const;
  std::vector<std::string> getString(const std::string &compName, const std::string &name) const {
    return getType<std::string>(compName, name);
  }
  std::vector<double> getDouble(const std::string &compName, const std::string &name) const {
    return getType<double>(compName, name);
  }
  std::vector<Kernel::V3D> getV3D(const std::string &compName, const std::string &name) const {
    return getType<Kernel::V3D>(compName, name);
  }
 
  std::set<std::string> names(const IComponent *comp) const;
  std::string asString() const;
 
  void clearPositionSensitiveCaches();
  void setCachedLocation(const IComponent *comp, const Kernel::V3D &location) const;
  bool getCachedLocation(const IComponent *comp, Kernel::V3D &location) const;
  void setCachedRotation(const IComponent *comp, const Kernel::Quat &rotation) const;
  bool getCachedRotation(const IComponent *comp, Kernel::Quat &rotation) const;
  void saveNexus(Nexus::File *file, const std::string &group) const;
  void copyFromParameterMap(const IComponent *oldComp, const IComponent *newComp, const ParameterMap *oldPMap);
 
  const std::vector<std::string> &getParameterFilenames() const;
  void addParameterFilename(const std::string &filename);
 
  std::vector<Entry> entries() const;
 
  bool hasDetectorInfo(const Instrument *instrument) const;
  bool hasComponentInfo(const Instrument *instrument) const;
  const Geometry::DetectorInfo &detectorInfo() const;
  Geometry::DetectorInfo &mutableDetectorInfo();
  const Geometry::ComponentInfo &componentInfo() const;
  Geometry::ComponentInfo &mutableComponentInfo();
  Geometry::InstrumentMetadata const &instrumentMetadata() const;
  size_t detectorIndex(const detid_t detID) const;
  size_t componentIndex(const Geometry::ComponentID componentId) const;
  const std::vector<Geometry::ComponentID> &componentIds() const;
  void setInstrument(const Instrument *instrument);
 
  void rebuildBeamlineFrom(const ParameterMap &source);
 
  const std::shared_ptr<ParameterInfo> &sharedParameterInfo() const { return m_parameterInfo; }
  const std::shared_ptr<Geometry::ComponentInfo> &sharedComponentInfo() const { return m_componentInfo; }
  const std::shared_ptr<Geometry::DetectorInfo> &sharedDetectorInfo() const { return m_detectorInfo; }
  const std::shared_ptr<Geometry::InstrumentMetadata> &sharedInstrumentMetadata() const { return m_instrumentMetadata; }
 
  std::shared_ptr<ParameterInfo> rekey(const std::unordered_map<Geometry::IComponent const *, size_t> &idToIndex);
 
private:
  std::shared_ptr<Parameter> create(const std::string &className, const std::string &name,
                                    const std::string &visible = "true") const;
 
  ParameterMap &operator=(ParameterMap *rhs);
  void buildInstrumentMetadata();
  bool relErr(double x1, double x2, double errorVal) const;
 
  size_t indexOf(const IComponent *comp) const;
  size_t indexForWrite(const IComponent *comp);
  ComponentID componentIdAt(const size_t index) const;
 
  std::vector<std::string> m_parameterFileNames;
 
  std::shared_ptr<ParameterInfo> m_parameterInfo;
 
  std::unordered_map<Geometry::IComponent const *, size_t> m_idToIndex;
  std::vector<ComponentID> m_indexToId;
  std::unique_ptr<Kernel::Cache<const ComponentID, Kernel::V3D>> m_cacheLocMap;
  std::unique_ptr<Kernel::Cache<const ComponentID, Kernel::Quat>> m_cacheRotMap;
 
  std::shared_ptr<Geometry::DetectorInfo> m_detectorInfo;
  std::shared_ptr<Geometry::ComponentInfo> m_componentInfo;
  std::shared_ptr<Geometry::InstrumentMetadata> m_instrumentMetadata;
 
  const Instrument *m_instrument{nullptr};
};
 
using ParameterMap_sptr = std::shared_ptr<ParameterMap>;
using ParameterMap_const_sptr = std::shared_ptr<const ParameterMap>;
 
} // Namespace Geometry
 
} // Namespace Mantid