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 "tbb/concurrent_unordered_map.h"
 
#include <memory>
#include <typeinfo>
#include <vector>
 
namespace Mantid {
namespace Kernel {
template <class KEYTYPE, class VALUETYPE> class Cache;
}
namespace Geometry {
class ComponentInfo;
class DetectorInfo;
class Instrument;
 
using component_map_it = tbb::concurrent_unordered_multimap<ComponentID, std::shared_ptr<Parameter>>::iterator;
using component_map_cit = tbb::concurrent_unordered_multimap<ComponentID, std::shared_ptr<Parameter>>::const_iterator;
 
class MANTID_GEOMETRY_DLL ParameterMap {
public:
  using pmap = tbb::concurrent_unordered_multimap<ComponentID, std::shared_ptr<Parameter>>;
  using pmap_it = tbb::concurrent_unordered_multimap<ComponentID, std::shared_ptr<Parameter>>::iterator;
  using pmap_cit = tbb::concurrent_unordered_multimap<ComponentID, std::shared_ptr<Parameter>>::const_iterator;
  ParameterMap();
  ParameterMap(const ParameterMap &other);
  ~ParameterMap();
  inline bool empty() const { return m_map.empty(); }
  inline int size() const { return static_cast<int>(m_map.size()); }
  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_map.clear();
    clearPositionSensitiveCaches();
  }
  void swap(ParameterMap &other) {
    m_map.swap(other.m_map);
    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 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;
 
  template <class T> std::vector<T> getType(const std::string &compName, const std::string &name) const {
    std::vector<T> retval;
 
    pmap_cit it;
    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)
          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);
 
  pmap_it begin() { return m_map.begin(); }
  pmap_cit begin() const { return m_map.begin(); }
  pmap_it end() { return m_map.end(); }
  pmap_cit end() const { return m_map.end(); }
 
  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();
  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);
 
private:
  std::shared_ptr<Parameter> create(const std::string &className, const std::string &name,
                                    const std::string &visible = "true") const;
 
  ParameterMap &operator=(ParameterMap *rhs);
  component_map_it positionOf(const IComponent *comp, const char *name, const char *type);
  component_map_cit positionOf(const IComponent *comp, const char *name, const char *type) const;
  bool relErr(double x1, double x2, double errorVal) const;
 
  std::vector<std::string> m_parameterFileNames;
 
  pmap m_map;
  std::unique_ptr<Kernel::Cache<const ComponentID, Kernel::V3D>> m_cacheLocMap;
  std::unique_ptr<Kernel::Cache<const ComponentID, Kernel::Quat>> m_cacheRotMap;
 
  std::unique_ptr<Geometry::DetectorInfo> m_detectorInfo;
 
  std::unique_ptr<Geometry::ComponentInfo> m_componentInfo;
 
  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