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 Geometry {
class ComponentInfo;
class DetectorInfo;
class Instrument;
class InstrumentMetadata;
 
 
class MANTID_GEOMETRY_DLL ParameterMap {
public:
  using Entry = std::pair<size_t, 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() {
    // The translation tables are kept: they describe the instrument, not the parameters, and an
    // attached map shares its index domain with ComponentInfo, which may still write by index.
    m_parameterInfo->clear();
  }
  void swap(ParameterMap &other) {
    // The index domain and staging tables must travel with the store: an index is meaningless without them.
    m_parameterInfo.swap(other.m_parameterInfo);
    m_domainIds.swap(other.m_domainIds);
    m_domainIndices.swap(other.m_domainIndices);
    m_stagedIndices.swap(other.m_stagedIndices);
    m_stagedIds.swap(other.m_stagedIds);
  }
  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 component with parameters because the match is on component name rather than key
    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) {
          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;
  static std::string asString(const std::vector<Entry> &entries, const ComponentInfo &componentInfo,
                              const DetectorInfo &detectorInfo);
  static std::string asStringEntry(const std::string &component, const Parameter &parameter);
 
  static void saveNexus(Nexus::File *file, const std::string &group, const std::string &contents);
  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; }
 
  using ComponentIDs = std::vector<Geometry::IComponent *>;
  using ComponentIndices = std::unordered_map<Geometry::IComponent const *, size_t>;
 
  std::shared_ptr<ParameterInfo> rekey(std::shared_ptr<const ComponentIDs> componentIds,
                                       std::shared_ptr<const ComponentIndices> componentIndices);
 
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();
  void seedLogfileParameters();
  bool relErr(double x1, double x2, double errorVal) const;
 
  size_t domainSize() const { return m_domainIds ? m_domainIds->size() : 0; }
  size_t indexOf(const IComponent *comp) const;
  size_t indexForWrite(const IComponent *comp);
  std::string componentName(const size_t index) const;
  std::string componentFullName(const size_t index) const;
 
  std::vector<std::string> m_parameterFileNames;
 
  std::shared_ptr<ParameterInfo> m_parameterInfo;
 
  std::shared_ptr<const ComponentIDs> m_domainIds;
  std::shared_ptr<const ComponentIndices> m_domainIndices;
 
  std::unordered_map<Geometry::IComponent const *, size_t> m_stagedIndices;
  std::vector<ComponentID> m_stagedIds;
 
  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