d9/d32/ParameterMap_8h_source.html

// Mantid Repository : https://github.com/mantidproject/mantid

//

// Copyright &copy; 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()); }

  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_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 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 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;


    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

name
std::string name
Definition Run.cpp:60

rhs
const std::vector< double > & rhs
Definition ComptonScatteringCountRate.cpp:98

value
double value
The value of the point.
Definition FitMW.cpp:51

IComponent.h

IDTypes.h

IDetector.h

detectorIndex
IntArray detectorIndex
Definition LoadNexusProcessed.cpp:79

NXentrytype::group
@ group

Parameter.h

rotation
Mantid::Kernel::Quat(ComponentInfo::* rotation)(const size_t) const
Definition ComponentInfo.cpp:52

Mantid::Geometry::ComponentInfo
ComponentInfo : Provides a component centric view on to the instrument.
Definition ComponentInfo.h:41

Mantid::Geometry::DetectorInfo
Geometry::DetectorInfo is an intermediate step towards a DetectorInfo that is part of Instrument-2....
Definition DetectorInfo.h:49

Mantid::Geometry::IComponent
base class for Geometric IComponent
Definition IComponent.h:53

Mantid::Geometry::Instrument
Base Instrument Class.
Definition Instrument.h:49

Mantid::Geometry::ParameterMap
ParameterMap class.
Definition ParameterMap.h:43

Mantid::Geometry::ParameterMap::~ParameterMap
~ParameterMap()

Mantid::Geometry::ParameterMap::begin
pmap_it begin()
access iterators. begin;
Definition ParameterMap.h:293

Mantid::Geometry::ParameterMap::clear
void clear()
Clears the map.
Definition ParameterMap.h:88

Mantid::Geometry::ParameterMap::m_detectorInfo
std::unique_ptr< Geometry::DetectorInfo > m_detectorInfo
Pointer to the DetectorInfo wrapper.
Definition ParameterMap.h:336

Mantid::Geometry::ParameterMap::operator=
ParameterMap & operator=(ParameterMap *rhs)
Assignment operator.

Mantid::Geometry::ParameterMap::getV3D
std::vector< Kernel::V3D > getV3D(const std::string &compName, const std::string &name) const
Returns a Kernel::V3D parameter as vector's first element if exists and an empty vector if it doesn't...
Definition ParameterMap.h:262

Mantid::Geometry::ParameterMap::pmap_it
tbb::concurrent_unordered_multimap< ComponentID, std::shared_ptr< Parameter > >::iterator pmap_it
Parameter map iterator typedef.
Definition ParameterMap.h:48

Mantid::Geometry::ParameterMap::empty
bool empty() const
Returns true if the map is empty, false otherwise.
Definition ParameterMap.h:57

Mantid::Geometry::ParameterMap::getType
std::vector< T > getType(const std::string &compName, const std::string &name) const
Get the values of a given parameter of all the components that have the name: compName.
Definition ParameterMap.h:220

Mantid::Geometry::ParameterMap::getString
std::vector< std::string > getString(const std::string &compName, const std::string &name) const
Returns a string parameter as vector's first element if exists and an empty vector if it doesn't.
Definition ParameterMap.h:242

Mantid::Geometry::ParameterMap::begin
pmap_cit begin() const
Definition ParameterMap.h:294

Mantid::Geometry::ParameterMap::size
int size() const
Return the size of the map.
Definition ParameterMap.h:59

Mantid::Geometry::ParameterMap::m_parameterFileNames
std::vector< std::string > m_parameterFileNames
internal list of parameter files loaded
Definition ParameterMap.h:325

Mantid::Geometry::ParameterMap::end
pmap_it end()
access iterators. end;
Definition ParameterMap.h:296

Mantid::Geometry::ParameterMap::m_map
pmap m_map
internal parameter map instance
Definition ParameterMap.h:328

Mantid::Geometry::ParameterMap::m_cacheLocMap
std::unique_ptr< Kernel::Cache< const ComponentID, Kernel::V3D > > m_cacheLocMap
internal cache map instance for cached position values
Definition ParameterMap.h:330

Mantid::Geometry::ParameterMap::add
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")
Method for adding a parameter providing its value of a particular type.
Definition ParameterMap.h:123

Mantid::Geometry::ParameterMap::m_cacheRotMap
std::unique_ptr< Kernel::Cache< const ComponentID, Kernel::Quat > > m_cacheRotMap
internal cache map instance for cached rotation values
Definition ParameterMap.h:332

Mantid::Geometry::ParameterMap::end
pmap_cit end() const
Definition ParameterMap.h:297

Mantid::Geometry::ParameterMap::getDouble
std::vector< double > getDouble(const std::string &compName, const std::string &name) const
Returns a double parameter as vector's first element if exists and an empty vector if it doesn't.
Definition ParameterMap.h:252

Mantid::Geometry::ParameterMap::componentIds
const std::vector< Geometry::ComponentID > & componentIds() const

Mantid::Geometry::ParameterMap::pmap_cit
tbb::concurrent_unordered_multimap< ComponentID, std::shared_ptr< Parameter > >::const_iterator pmap_cit
Parameter map iterator typedef.
Definition ParameterMap.h:50

Mantid::Geometry::ParameterMap::m_componentInfo
std::unique_ptr< Geometry::ComponentInfo > m_componentInfo
Pointer to the ComponentInfo wrapper.
Definition ParameterMap.h:340

Mantid::Geometry::ParameterMap::swap
void swap(ParameterMap &other)
method swaps two parameter maps contents each other.
Definition ParameterMap.h:94

Mantid::Geometry::Parameter
Base class for parameters of an instrument.
Definition Parameter.h:37

Mantid::Kernel::Quat
Class for quaternions.
Definition Quat.h:39

Mantid::Kernel::V3D
Class for 3D vectors.
Definition V3D.h:34

Mantid::DataObjects::create
std::unique_ptr< T > create(const P &parent, const IndexArg &indexArg, const HistArg &histArg)
This is the create() method that all the other create() methods call.
Definition WorkspaceCreation.h:132

Mantid::Geometry::component_map_cit
tbb::concurrent_unordered_multimap< ComponentID, std::shared_ptr< Parameter > >::const_iterator component_map_cit
Definition ParameterMap.h:41

Mantid::Geometry::component_map_it
tbb::concurrent_unordered_multimap< ComponentID, std::shared_ptr< Parameter > >::iterator component_map_it
Parameter map iterator typedef.
Definition ParameterMap.h:40

Mantid::Geometry::ParameterMap_sptr
std::shared_ptr< ParameterMap > ParameterMap_sptr
ParameterMap shared pointer typedef.
Definition ParameterMap.h:350

Mantid::Geometry::ParameterMap_const_sptr
std::shared_ptr< const ParameterMap > ParameterMap_const_sptr
ParameterMap constant shared pointer typedef.
Definition ParameterMap.h:352

Mantid
Helper class which provides the Collimation Length for SANS instruments.
Definition AbsorptionCorrection.h:18

Mantid::detid_t
int32_t detid_t
Typedef for a detector ID.
Definition SpectrumInfo.h:21

pmap
Generate a tableworkspace to store the calibration results.

std::operator==
constexpr bool operator==(const wide_integer< Bits, Signed > &lhs, const wide_integer< Bits2, Signed2 > &rhs)

std::operator!=
constexpr bool operator!=(const wide_integer< Bits, Signed > &lhs, const wide_integer< Bits2, Signed2 > &rhs)