Instrument.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/IDetector.h"
#include "MantidGeometry/Instrument/CompAssembly.h"
#include "MantidGeometry/Instrument/GridDetector.h"
#include "MantidGeometry/Instrument/RectangularDetector.h"
#include "MantidGeometry/Instrument_fwd.h"
 
#include "MantidTypes/Core/DateAndTime.h"
 
#include <map>
#include <queue>
#include <stdexcept>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
 
namespace Mantid {
using detid2det_map = std::map<detid_t, Geometry::IDetector_const_sptr>;
 
namespace Geometry {
class ComponentInfo;
class DetectorInfo;
class XMLInstrumentParameter;
class ParameterMap;
class ReferenceFrame;
class InstrumentVisitor;
using InstrumentParameterCache =
    std::map<std::pair<std::string, const IComponent *>, std::shared_ptr<XMLInstrumentParameter>>;
 
class MANTID_GEOMETRY_DLL Instrument : public CompAssembly {
public:
  std::string type() const override { return "Instrument"; }
 
  Instrument(const std::shared_ptr<const Instrument> &instr, const std::shared_ptr<ParameterMap> &map);
  Instrument();
  Instrument(const std::string &name);
  Instrument(const Instrument &);
  Instrument(const Instrument &, bool copyCache);
 
  Instrument *clone() const override;
 
  bool hasSource() const;
  bool hasSample() const;
 
  IComponent_const_sptr getSource() const;
  IComponent_const_sptr getSample() const;
  Kernel::V3D getBeamDirection() const;
 
  IDetector_const_sptr getDetector(const detid_t &detector_id) const;
  const IDetector *getBaseDetector(const detid_t &detector_id) const;
  bool isMonitor(const detid_t &detector_id) const;
  bool isMonitor(const std::set<detid_t> &detector_ids) const;
 
  IDetector_const_sptr getDetectorG(const std::set<detid_t> &det_ids) const;
 
  std::vector<IDetector_const_sptr> getDetectors(const std::vector<detid_t> &det_ids) const;
 
  std::vector<IDetector_const_sptr> getDetectors(const std::set<detid_t> &det_ids) const;
 
  void markAsSamplePos(const IComponent *);
 
  void markAsSource(const IComponent *);
 
  void markAsDetector(const IDetector *);
  void markAsDetectorIncomplete(const IDetector *);
  void markAsDetectorFinalize();
 
  void markAsMonitor(IDetector const *);
  void markAsMonitorIncomplete(IDetector const *);
 
  void removeDetector(IDetector *);
  void removeDetectorIncomplete(IDetector const *);
  void removeDetectorFinalize();
 
  void getDetectors(detid2det_map &out_map) const;
 
  std::vector<detid_t> getDetectorIDs(bool skipMonitors = false) const;
  std::vector<detid_t> getMonitorIDs() const;
 
  std::size_t getNumberDetectors(bool skipMonitors = false) const;
 
  void getMinMaxDetectorIDs(detid_t &min, detid_t &max) const;
 
  void getDetectorsInBank(std::vector<IDetector_const_sptr> &dets, const IComponent &comp) const;
  void getDetectorsInBank(std::vector<IDetector_const_sptr> &dets, const std::string &bankName) const;
  std::set<detid_t> getDetectorIDsInBank(const std::string &bankName) const;
 
  void getBoundingBox(BoundingBox &assemblyBox) const override;
 
  std::shared_ptr<const std::vector<IObjComponent_const_sptr>> getPlottable() const;
 
  std::shared_ptr<const IComponent> getComponentByID(const IComponent *id) const;
 
  std::vector<std::shared_ptr<const IComponent>> getAllComponentsWithName(const std::string &cname) const;
 
  InstrumentParameterCache &getLogfileCache() { return m_logfileCache; }
  const InstrumentParameterCache &getLogfileCache() const { return m_logfileCache; }
 
  std::map<std::string, std::string> &getLogfileUnit() { return m_logfileUnit; }
 
  const std::string &getDefaultView() const { return m_defaultView; }
  void setDefaultView(const std::string &type);
  const std::string &getDefaultAxis() const { return m_defaultViewAxis; }
  void setDefaultViewAxis(const std::string &axis) { m_defaultViewAxis = axis; }
  // Allow access by index
  using CompAssembly::getChild;
 
  std::shared_ptr<const Instrument> baseInstrument() const;
 
  std::shared_ptr<ParameterMap> getParameterMap() const;
 
  Types::Core::DateAndTime getValidFromDate() const { return m_ValidFrom; }
 
  Types::Core::DateAndTime getValidToDate() const { return m_ValidTo; }
 
  void setValidFromDate(const Types::Core::DateAndTime &val);
 
  void setValidToDate(const Types::Core::DateAndTime &val) { m_ValidTo = val; }
 
  // Methods for use with indirect geometry instruments,
  // where the physical instrument differs from the 'neutronic' one
  std::shared_ptr<const Instrument> getPhysicalInstrument() const;
  void setPhysicalInstrument(std::unique_ptr<Instrument>);
 
  void getInstrumentParameters(double &l1, Kernel::V3D &beamline, double &beamline_norm, Kernel::V3D &samplePos) const;
 
  void saveNexus(Nexus::File *file, const std::string &group) const;
  void loadNexus(Nexus::File *file, const std::string &group);
 
  void setFilename(const std::string &filename);
  const std::string &getFilename() const;
  void setXmlText(const std::string &XmlText);
  const std::string &getXmlText() const;
 
  void setReferenceFrame(std::shared_ptr<ReferenceFrame> frame);
  std::shared_ptr<const ReferenceFrame> getReferenceFrame() const;
 
  enum ContainsState { Full, Partial, None };
 
  ContainsState containsRectDetectors() const;
 
  std::vector<RectangularDetector_const_sptr> findRectDetectors() const {
    return findDetectorsOfType<RectangularDetector>();
  }
  std::vector<GridDetector_const_sptr> findGridDetectors() const { return findDetectorsOfType<GridDetector>(); }
 
  bool isMonitorViaIndex(const size_t index) const;
  size_t detectorIndex(const detid_t detID) const;
  std::shared_ptr<ParameterMap> makeLegacyParameterMap() const;
 
  bool isEmptyInstrument() const;
 
  void parseTreeAndCacheBeamline();
  std::pair<std::unique_ptr<ComponentInfo>, std::unique_ptr<DetectorInfo>>
  makeBeamline(ParameterMap &pmap, const ParameterMap *source = nullptr) const;
  std::pair<std::unique_ptr<ComponentInfo>, std::unique_ptr<DetectorInfo>> makeBeamlineNew(ParameterMap &pmap) const;
 
  size_t getMemorySize() const;
 
  friend InstrumentVisitor;
 
private:
  void saveDetectorSetInfoToNexus(Nexus::File *file, const std::vector<detid_t> &detIDs) const;
 
  bool validateComponentProperties(IComponent_const_sptr component) const;
 
  void addInstrumentChildrenToQueue(std::queue<IComponent_const_sptr> &queue) const;
  bool addAssemblyChildrenToQueue(std::queue<IComponent_const_sptr> &queue, IComponent_const_sptr component) const;
  template <typename T> std::vector<std::shared_ptr<const T>> findDetectorsOfType() const {
    std::queue<IComponent_const_sptr> compQueue; // Search queue
    addInstrumentChildrenToQueue(compQueue);
 
    std::vector<std::shared_ptr<const T>> detectors;
 
    IComponent_const_sptr comp;
 
    while (!compQueue.empty()) {
      comp = compQueue.front();
      compQueue.pop();
 
      if (!validateComponentProperties(comp))
        continue;
 
      if (auto const detector = std::dynamic_pointer_cast<const T>(comp)) {
        detectors.push_back(detector);
      } else {
        // If component is a ComponentAssembly, we add its children to the queue to check if they're type T
        addAssemblyChildrenToQueue(compQueue, comp);
      }
    }
    return detectors;
  }
 
  Instrument &operator=(const Instrument &);
 
  void appendPlottable(const CompAssembly &ca, std::vector<IObjComponent_const_sptr> &lst) const;
 
  std::pair<std::unique_ptr<ComponentInfo>, std::unique_ptr<DetectorInfo>>
  makeWrappers(ParameterMap &pmap, const ComponentInfo &componentInfo, const DetectorInfo &detectorInfo) const;
 
  struct DetectorCacheEntry : public std::tuple<detid_t, IDetector_const_sptr, bool> {
    DetectorCacheEntry(detid_t id, IDetector_const_sptr det, bool isMonitorFlag)
        : std::tuple<detid_t, IDetector_const_sptr, bool>(id, det, isMonitorFlag) {}
    detid_t const &id() const { return std::get<0>(*this); }
    IDetector_const_sptr const &detector() const { return std::get<1>(*this); }
    bool const &isMonitor() const { return std::get<2>(*this); }
    void setIsMonitor(bool flag) { std::get<2>(*this) = flag; }
  };
 
  struct DetectorCache : public std::vector<DetectorCacheEntry> {
    bool m_isFinalized{true};
    bool isFinalized() const { return m_isFinalized; }
    void setIncomplete() { m_isFinalized = false; }
    void setFinalized(bool const flag = true) { m_isFinalized = flag; }
    detid_t minID() const {
      if (isFinalized() && !empty()) {
        return front().id();
      } else {
        throw std::runtime_error("minID() called on non-finalized or empty DetectorCache");
      }
    }
    detid_t maxID() const {
      if (isFinalized() && !empty()) {
        return back().id();
      } else {
        throw std::runtime_error("maxID() called on non-finalized or empty DetectorCache");
      }
    }
    DetectorCache::iterator lower_bound(detid_t id);
    DetectorCache::const_iterator lower_bound(detid_t id) const;
    DetectorCache::iterator find(detid_t id);
    DetectorCache::const_iterator find(detid_t id) const;
    std::unordered_set<IDetector const *> m_toRemove;
  } m_detectorCache;
 
  bool isFinalized() const {
    if (m_map) {
      return m_instr->isFinalized();
    } else {
      return m_detectorCache.isFinalized();
    }
  }
 
  const IComponent *m_sourceCache = nullptr;
 
  const IComponent *m_sampleCache = nullptr;
 
  InstrumentParameterCache m_logfileCache;
 
  std::map<std::string, std::string> m_logfileUnit;
 
  std::string m_defaultView;
  std::string m_defaultViewAxis;
 
  std::shared_ptr<const Instrument> m_instr;
 
  std::shared_ptr<ParameterMap> m_map_nonconst;
 
  Types::Core::DateAndTime m_ValidFrom;
  Types::Core::DateAndTime m_ValidTo;
 
  mutable std::string m_filename;
 
  mutable std::string m_xmlText;
 
  std::shared_ptr<const Instrument> m_physicalInstrument;
 
  std::shared_ptr<ReferenceFrame> m_referenceFrame;
 
  std::shared_ptr<const DetectorInfo> m_detectorInfo{nullptr};
 
  std::shared_ptr<const ComponentInfo> m_componentInfo{nullptr};
 
  bool m_isPhysicalInstrument{false};
};
namespace Conversion {
 
MANTID_GEOMETRY_DLL double tofToDSpacingFactor(const double l1, const double l2, const double twoTheta,
                                               const double offset);
 
double MANTID_GEOMETRY_DLL tofToDSpacingFactor(const double l1, const double l2, const double twoTheta,
                                               const std::vector<detid_t> &detectors,
                                               const std::map<detid_t, double> &offsets);
 
MANTID_GEOMETRY_DLL double calculateDIFCCorrection(const double l1, const double l2, const double twoTheta,
                                                   const double offset, const double binWidth);
} // namespace Conversion
 
} // namespace Geometry
} // Namespace Mantid