DetectorInfo.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2016 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 <memory>
#include <mutex>
#include <unordered_map>
#include <vector>
 
#include "MantidGeometry/DllConfig.h"
#include "MantidGeometry/Instrument/DetectorInfoIterator.h"
#include "MantidKernel/Quat.h"
#include "MantidKernel/V3D.h"
#include "MantidTypes/Core/DateAndTime.h"
 
namespace Mantid {
using detid_t = int32_t;
namespace Beamline {
class DetectorInfo;
}
namespace API {
class SpectrumInfo;
}
namespace Geometry {
class IDetector;
class Instrument;
 
class MANTID_GEOMETRY_DLL DetectorInfo {
public:
  DetectorInfo(std::unique_ptr<Beamline::DetectorInfo> detectorInfo,
               std::shared_ptr<const Geometry::Instrument> instrument,
               std::shared_ptr<const std::vector<detid_t>> detectorIds,
               std::shared_ptr<const std::unordered_map<detid_t, size_t>> detIdToIndexMap);
  DetectorInfo(const DetectorInfo &other);
  DetectorInfo &operator=(const DetectorInfo &rhs);
  ~DetectorInfo();
 
  bool isEquivalent(const DetectorInfo &other) const;
 
  size_t size() const;
  size_t scanSize() const;
  size_t getMemorySize() const;
  bool isScanning() const;
 
  bool isMonitor(const size_t index) const;
  bool isMonitor(const std::pair<size_t, size_t> &index) const;
  bool isMasked(const size_t index) const;
  bool isMasked(const std::pair<size_t, size_t> &index) const;
  bool hasMaskedDetectors() const;
  double l2(const size_t index) const;
  double l2(const std::pair<size_t, size_t> &index) const;
  double twoTheta(const size_t index) const;
  double twoTheta(const std::pair<size_t, size_t> &index) const;
  double signedTwoTheta(const size_t index) const;
  double signedTwoTheta(const std::pair<size_t, size_t> &index) const;
  double azimuthal(const size_t index) const;
  double azimuthal(const std::pair<size_t, size_t> &index) const;
  std::tuple<double, double, double> diffractometerConstants(const size_t index, std::vector<detid_t> &calibratedDets,
                                                             std::vector<detid_t> &uncalibratedDets) const;
  double difcUncalibrated(const size_t index) const;
  std::pair<double, double> geographicalAngles(const size_t index) const;
  std::pair<double, double> geographicalAngles(const std::pair<size_t, size_t> &index) const;
  Kernel::V3D position(const size_t index) const;
  Kernel::V3D position(const std::pair<size_t, size_t> &index) const;
  std::vector<Kernel::V3D> allPositions() const;
  Kernel::Quat rotation(const size_t index) const;
  Kernel::Quat rotation(const std::pair<size_t, size_t> &index) const;
  std::vector<Kernel::Quat> allRotations() const;
  std::vector<Kernel::V3D> allScaleFactors() const;
 
  void setMasked(const size_t index, bool masked);
  void setMasked(const std::pair<size_t, size_t> &index, bool masked);
  void clearMaskFlags();
 
  void setPosition(const size_t index, const Kernel::V3D &position);
  void setPosition(const std::pair<size_t, size_t> &index, const Kernel::V3D &position);
  void setRotation(const size_t index, const Kernel::Quat &rotation);
  void setRotation(const std::pair<size_t, size_t> &index, const Kernel::Quat &rotation);
 
  const Geometry::IDetector &detector(const size_t index) const;
 
  // This does not really belong into DetectorInfo, but it seems to be useful
  // while Instrument-2.0 does not exist.
  Kernel::V3D sourcePosition() const;
  Kernel::V3D samplePosition() const;
  double l1() const;
 
  const std::vector<detid_t> &detectorIDs() const;
  size_t indexOf(const detid_t id) const;
  detid_t detid(const size_t index) const;
 
  size_t scanCount() const;
  const std::vector<std::pair<Types::Core::DateAndTime, Types::Core::DateAndTime>> scanIntervals() const;
 
  friend class API::SpectrumInfo;
  friend class Instrument;
 
  DetectorInfoIterator<DetectorInfo> begin();
  DetectorInfoIterator<DetectorInfo> end();
  const DetectorInfoIterator<const DetectorInfo> cbegin() const;
  const DetectorInfoIterator<const DetectorInfo> cend() const;
 
private:
  const Geometry::IDetector &getDetector(const size_t index) const;
  std::shared_ptr<const Geometry::IDetector> getDetectorPtr(const size_t index) const;
  void clearPositionDependentParameters(const size_t index);
 
  std::unique_ptr<Beamline::DetectorInfo> m_detectorInfo;
 
  std::shared_ptr<const Geometry::Instrument> m_instrument;
  std::shared_ptr<const std::vector<detid_t>> m_detectorIDs;
  std::shared_ptr<const std::unordered_map<detid_t, size_t>> m_detIDToIndex;
 
  mutable std::vector<std::shared_ptr<const Geometry::IDetector>> m_lastDetector;
  mutable std::vector<size_t> m_lastIndex;
};
 
using DetectorInfoIt = DetectorInfoIterator<DetectorInfo>;
using DetectorInfoConstIt = DetectorInfoIterator<const DetectorInfo>;
 
} // namespace Geometry
} // namespace Mantid