Instrument.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidGeometry/Instrument.h"
#include "MantidBeamline/ComponentInfo.h"
#include "MantidBeamline/DetectorInfo.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/ComponentInfoBankHelpers.h"
#include "MantidGeometry/Instrument/DetectorGroup.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Instrument/GridDetectorPixel.h"
#include "MantidGeometry/Instrument/InstrumentVisitor.h"
#include "MantidGeometry/Instrument/ObjCompAssembly.h"
#include "MantidGeometry/Instrument/ObjComponent.h"
#include "MantidGeometry/Instrument/ParComponentFactory.h"
#include "MantidGeometry/Instrument/ParameterFactory.h"
#include "MantidGeometry/Instrument/ParameterInfo.h"
#include "MantidGeometry/Instrument/ParameterMap.h"
#include "MantidGeometry/Instrument/RectangularDetector.h"
#include "MantidGeometry/Instrument/ReferenceFrame.h"
#include "MantidGeometry/Instrument/StructuredDetector.h"
#include "MantidKernel/EigenConversionHelpers.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/PhysicalConstants.h"
#include "MantidKernel/Unit.h"
#include "MantidNexus/NexusFile.h"
 
#include <algorithm>
#include <memory>
#include <queue>
#include <utility>
 
using namespace Mantid::Kernel;
using Mantid::Kernel::Exception::InstrumentDefinitionError;
using Mantid::Kernel::Exception::NotFoundError;
 
namespace Mantid::Geometry {
 
namespace {
Kernel::Logger g_log("Instrument");
 
void raiseDuplicateDetectorError(const size_t detectorId) {
  std::stringstream sstream;
  sstream << "Instrument Definition corrupt. Detector with ID " << detectorId << " already exists.";
  throw Exception::InstrumentDefinitionError(sstream.str());
}
 
size_t componentObjectSize(const IComponent *comp) {
  size_t result;
  if (dynamic_cast<const RectangularDetector *>(comp))
    result = sizeof(RectangularDetector);
  else if (const auto *sd = dynamic_cast<const StructuredDetector *>(comp))
    result = sizeof(StructuredDetector) + sd->getXValues().capacity() * sizeof(double) +
             sd->getYValues().capacity() * sizeof(double);
  else if (dynamic_cast<const GridDetectorPixel *>(comp))
    result = sizeof(GridDetectorPixel);
  else if (dynamic_cast<const GridDetector *>(comp))
    result = sizeof(GridDetector);
  else if (dynamic_cast<const Detector *>(comp))
    result = sizeof(Detector);
  else if (dynamic_cast<const ObjCompAssembly *>(comp))
    result = sizeof(ObjCompAssembly);
  else if (dynamic_cast<const ObjComponent *>(comp))
    result = sizeof(ObjComponent);
  else if (dynamic_cast<const CompAssembly *>(comp))
    result = sizeof(CompAssembly);
  else
    result = sizeof(Component);
  return result;
}
} // namespace
 
Instrument::Instrument()
    : CompAssembly(), m_detectorCache(), m_sourceCache(nullptr), m_sampleCache(nullptr), m_defaultView("3D"),
      m_defaultViewAxis("Z+"), m_referenceFrame(new ReferenceFrame) {}
 
Instrument::Instrument(const std::string &name)
    : CompAssembly(name), m_detectorCache(), m_sourceCache(nullptr), m_sampleCache(nullptr), m_defaultView("3D"),
      m_defaultViewAxis("Z+"), m_referenceFrame(new ReferenceFrame) {}
 
Instrument::Instrument(const std::shared_ptr<const Instrument> &instr, const std::shared_ptr<ParameterMap> &map)
    : CompAssembly(instr.get(), map.get()), m_sourceCache(instr->m_sourceCache), m_sampleCache(instr->m_sampleCache),
      m_defaultView(instr->m_defaultView), m_defaultViewAxis(instr->m_defaultViewAxis), m_instr(instr),
      m_map_nonconst(map), m_ValidFrom(instr->m_ValidFrom), m_ValidTo(instr->m_ValidTo),
      m_referenceFrame(new ReferenceFrame) {
  // Note that we do not copy m_detectorInfo and m_componentInfo into the parametrized instrument since the ParameterMap
  // will make a copy, if applicable.
}
 
Instrument::Instrument(const Instrument &instr)
    : CompAssembly(instr), m_sourceCache(nullptr), m_sampleCache(nullptr), /* Should only be temporarily null */
      m_logfileCache(instr.m_logfileCache), m_logfileUnit(instr.m_logfileUnit), m_defaultView(instr.m_defaultView),
      m_defaultViewAxis(instr.m_defaultViewAxis), m_instr(), m_map_nonconst(), /* Should not be parameterized */
      m_ValidFrom(instr.m_ValidFrom), m_ValidTo(instr.m_ValidTo), m_referenceFrame(instr.m_referenceFrame) {
  // Note that we do not copy m_detectorInfo and m_componentInfo into the new instrument since they are only non-NULL
  // for the base instrument, which should usually not be copied.
 
  // Now we need to fill the detector, source and sample caches with pointers into the new instrument
  std::vector<IComponent_const_sptr> children;
  getChildren(children, true);
  std::vector<IComponent_const_sptr>::const_iterator it;
  for (it = children.begin(); it != children.end(); ++it) {
    // First check if the current component is a detector and add to cache if it is
    if (const IDetector *det = dynamic_cast<const Detector *>(it->get())) {
      if (instr.isMonitor(det->getID()))
        markAsMonitor(det);
      else
        markAsDetector(det);
      continue;
    }
    // Now check whether the current component is the source or sample.
    // As the majority of components will be detectors, we will rarely get to here
    if (const auto *obj = dynamic_cast<const Component *>(it->get())) {
      const std::string objName = obj->getName();
      // This relies on the source and sample having a unique name. I think the way our instrument definition files work
      // ensures this is the case.
      if (objName == instr.m_sourceCache->getName()) {
        markAsSource(obj);
        continue;
      }
      if (objName == instr.m_sampleCache->getName()) {
        markAsSamplePos(obj);
        continue;
      }
    }
  }
}
 
Instrument::Instrument(const Instrument &instr, bool copyCache)
    : CompAssembly(), m_sourceCache(nullptr), m_sampleCache(nullptr), /* Should only be temporarily null */
      m_logfileCache(instr.m_logfileCache), m_logfileUnit(instr.m_logfileUnit), m_defaultView(instr.m_defaultView),
      m_defaultViewAxis(instr.m_defaultViewAxis), m_instr(), m_map_nonconst(), /* Should not be parameterized */
      m_ValidFrom(instr.m_ValidFrom), m_ValidTo(instr.m_ValidTo), m_referenceFrame(instr.m_referenceFrame) {
  UNUSED_ARG(copyCache);
  setName(instr.getName() + "_clone");
  // add in the sample and the source
  auto sampleComp = instr.getSample();
  auto sourceComp = instr.getSource();
  if (!sampleComp || !sourceComp) {
    throw std::runtime_error("Cannot copy instrument: source instrument must have valid sample and source components");
  }
  auto sample = sampleComp->clone();
  auto source = sourceComp->clone();
  add(sample);
  add(source);
  markAsSource(source);
  markAsSamplePos(sample);
  // also add in the monitors
  std::vector<IComponent_const_sptr> children;
  instr.getChildren(children, true);
  for (auto const &child : children) {
    if (IDetector const *det = dynamic_cast<Detector const *>(child.get())) {
      if (instr.isMonitor(det->getID())) {
        auto dclone = dynamic_cast<IDetector *>(det->clone());
        add(dclone);
        markAsMonitor(dclone);
      }
    }
  }
}
 
Instrument *Instrument::clone() const { return new Instrument(*this); }
 
Instrument_const_sptr Instrument::baseInstrument() const {
  if (m_map)
    return m_instr;
  else
    throw std::runtime_error("Instrument::baseInstrument() called for a "
                             "non-parametrized instrument.");
}
 
ParameterMap_sptr Instrument::getParameterMap() const {
  if (m_map)
    return m_map_nonconst;
  else
    throw std::runtime_error("Instrument::getParameterMap() called for a "
                             "non-parametrized instrument.");
}
 
Instrument_const_sptr Instrument::getPhysicalInstrument() const {
  if (m_map) {
    if (m_instr->getPhysicalInstrument()) {
      // A physical instrument should use the same parameter map as the 'main'
      // instrument. This constructor automatically sets the instrument as the
      // owning instrument in the ParameterMap. We need to undo this immediately
      // since the ParameterMap must always be owned by the neutronic
      // instrument.
      return std::make_shared<Instrument>(m_instr->getPhysicalInstrument(), m_map_nonconst);
    } else {
      return Instrument_const_sptr();
    }
  } else {
    return m_physicalInstrument;
  }
}
 
void Instrument::setPhysicalInstrument(std::unique_ptr<Instrument> physInst) {
  if (!m_map) {
    physInst->m_isPhysicalInstrument = true;
    m_physicalInstrument = std::move(physInst);
  } else
    throw std::runtime_error("Instrument::setPhysicalInstrument() called on a "
                             "parametrized instrument.");
}
 
//------------------------------------------------------------------------------------------
void Instrument::getDetectors(detid2det_map &out_map) const {
  out_map.clear();
  auto it = out_map.end();
  if (m_map) {
    // Get the base instrument detectors
    const auto &in_dets = m_instr->m_detectorCache;
    // And turn them into parametrized versions
    for (const auto &in_det : in_dets) {
      it = out_map.emplace_hint(it, in_det.id(), ParComponentFactory::createDetector(in_det.detector().get(), m_map));
    }
  } else {
    // You can just return the detector cache directly.
    for (const auto &in_det : m_detectorCache) {
      it = out_map.emplace_hint(it, in_det.id(), in_det.detector());
    }
  }
}
 
//------------------------------------------------------------------------------------------
std::vector<detid_t> Instrument::getDetectorIDs(bool skipMonitors) const {
  const auto &in_dets = m_map ? m_instr->m_detectorCache : m_detectorCache;
  std::vector<detid_t> out;
  out.reserve(in_dets.size());
  for (const auto &in_det : in_dets) {
    if (!skipMonitors || !in_det.isMonitor()) {
      out.emplace_back(in_det.id());
    }
  }
  return out;
}
 
std::vector<detid_t> Instrument::getMonitorIDs() const {
  // Monitors cannot be parametrized. So just return the base.
  if (m_map)
    return m_instr->getMonitorIDs();
 
  std::vector<detid_t> mons;
  for (const auto &item : m_detectorCache)
    if (item.isMonitor())
      mons.emplace_back(item.id());
  return mons;
}
 
std::size_t Instrument::getNumberDetectors(bool skipMonitors) const {
  const auto &in_dets = m_map ? m_instr->m_detectorCache : m_detectorCache;
 
  if (skipMonitors) {
    const std::size_t monitors =
        std::count_if(in_dets.cbegin(), in_dets.cend(), [](const auto &in_det) { return in_det.isMonitor(); });
    return (in_dets.size() - monitors);
  } else {
    return in_dets.size();
  }
}
 
void Instrument::getMinMaxDetectorIDs(detid_t &min, detid_t &max) const {
  const auto &in_dets = m_map ? m_instr->m_detectorCache : m_detectorCache;
  // ensure there are detectors
  if (in_dets.empty())
    throw std::runtime_error("No detectors on this instrument. Can't find min/max ids");
  // ensure the cache is finalized
  if (!in_dets.isFinalized())
    throw std::runtime_error("Instrument definition is not finalized. Can't find min/max ids");
  min = in_dets.minID();
  max = in_dets.maxID();
}
 
void Instrument::getDetectorsInBank(std::vector<IDetector_const_sptr> &dets, const IComponent &comp) const {
  const auto bank = dynamic_cast<const ICompAssembly *>(&comp);
  if (bank) {
    // Get a vector of children (recursively)
    std::vector<std::shared_ptr<const IComponent>> children;
    bank->getChildren(children, true);
    std::vector<std::shared_ptr<const IComponent>>::iterator it;
    for (it = children.begin(); it != children.end(); ++it) {
      IDetector_const_sptr det = std::dynamic_pointer_cast<const IDetector>(*it);
      if (det) {
        dets.emplace_back(det);
      }
    }
  }
}
 
void Instrument::getDetectorsInBank(std::vector<IDetector_const_sptr> &dets, const std::string &bankName) const {
  std::shared_ptr<const IComponent> comp = this->getComponentByName(bankName);
  if (!comp) {
    throw Kernel::Exception::NotFoundError("Instrument: Could not find component", bankName);
  }
  getDetectorsInBank(dets, *comp);
}
 
std::set<detid_t> Instrument::getDetectorIDsInBank(const std::string &bankName) const {
  std::set<detid_t> detIDs;
  std::vector<IDetector_const_sptr> detectors;
  getDetectorsInBank(detectors, bankName);
 
  for (const auto &det : detectors) {
    detIDs.emplace(det->getID());
  }
  return detIDs;
}
 
bool Instrument::hasSource() const { return m_sourceCache; }
 
bool Instrument::hasSample() const { return m_sampleCache; }
 
IComponent_const_sptr Instrument::getSource() const {
  if (!m_sourceCache) {
    g_log.warning("In Instrument::getSource(). No source has been set.");
    return IComponent_const_sptr(m_sourceCache, NoDeleting());
  } else if (m_map) {
    auto sourceCache = static_cast<const Instrument *>(m_base)->m_sourceCache;
    if (dynamic_cast<const ObjComponent *>(sourceCache))
      return IComponent_const_sptr(new ObjComponent(sourceCache, m_map));
    else if (dynamic_cast<const CompAssembly *>(sourceCache))
      return IComponent_const_sptr(new CompAssembly(sourceCache, m_map));
    else if (dynamic_cast<const Component *>(sourceCache))
      return IComponent_const_sptr(new Component(sourceCache, m_map));
    else {
      g_log.error("In Instrument::getSource(). Source is not a recognised "
                  "component type.");
      g_log.error("Try to assume it is a Component.");
      return IComponent_const_sptr(new ObjComponent(sourceCache, m_map));
    }
  } else {
    return IComponent_const_sptr(m_sourceCache, NoDeleting());
  }
}
 
IComponent_const_sptr Instrument::getSample() const {
  if (!m_sampleCache) {
    g_log.warning("In Instrument::getSamplePos(). No SamplePos has been set.");
    return IComponent_const_sptr(m_sampleCache, NoDeleting());
  } else if (m_map) {
    auto sampleCache = static_cast<const Instrument *>(m_base)->m_sampleCache;
    if (dynamic_cast<const ObjComponent *>(sampleCache))
      return IComponent_const_sptr(new ObjComponent(sampleCache, m_map));
    else if (dynamic_cast<const CompAssembly *>(sampleCache))
      return IComponent_const_sptr(new CompAssembly(sampleCache, m_map));
    else if (dynamic_cast<const Component *>(sampleCache))
      return IComponent_const_sptr(new Component(sampleCache, m_map));
    else {
      g_log.error("In Instrument::getSamplePos(). SamplePos is not a "
                  "recognised component type.");
      g_log.error("Try to assume it is a Component.");
      return IComponent_const_sptr(new ObjComponent(sampleCache, m_map));
    }
  } else {
    return IComponent_const_sptr(m_sampleCache, NoDeleting());
  }
}
 
Kernel::V3D Instrument::getBeamDirection() const { return normalize(getSample()->getPos() - getSource()->getPos()); }
 
//------------------------------------------------------------------------------------------
std::shared_ptr<const IComponent> Instrument::getComponentByID(const IComponent *id) const {
  const auto *base = static_cast<const IComponent *>(id);
  if (m_map)
    return ParComponentFactory::create(std::shared_ptr<const IComponent>(base, NoDeleting()), m_map);
  else
    return std::shared_ptr<const IComponent>(base, NoDeleting());
}
 
std::vector<std::shared_ptr<const IComponent>> Instrument::getAllComponentsWithName(const std::string &cname) const {
  std::shared_ptr<const IComponent> node = std::shared_ptr<const IComponent>(this, NoDeleting());
  std::vector<std::shared_ptr<const IComponent>> retVec;
  // Check the instrument name first
  if (this->getName() == cname) {
    retVec.emplace_back(node);
  }
  // Same algorithm as used in getComponentByName() but searching the full tree
  std::deque<std::shared_ptr<const IComponent>> nodeQueue;
  // Need to be able to enter the while loop
  nodeQueue.emplace_back(node);
  while (!nodeQueue.empty()) {
    node = nodeQueue.front();
    nodeQueue.pop_front();
    int nchildren(0);
    std::shared_ptr<const ICompAssembly> asmb = std::dynamic_pointer_cast<const ICompAssembly>(node);
    if (asmb) {
      nchildren = asmb->nelements();
    }
    for (int i = 0; i < nchildren; ++i) {
      std::shared_ptr<const IComponent> comp = (*asmb)[i];
      if (comp->getName() == cname) {
        retVec.emplace_back(comp);
      } else {
        nodeQueue.emplace_back(comp);
      }
    }
  } // while-end
 
  // If we have reached here then the search failed
  return retVec;
}
 
Instrument::DetectorCache::iterator Instrument::DetectorCache::lower_bound(detid_t id) {
  if (!isFinalized()) {
    throw std::runtime_error("lower_bound() called on non-finalized DetectorCache");
  }
  return std::lower_bound(begin(), end(), id,
                          [](DetectorCacheEntry const &entry, detid_t id) { return entry.id() < id; });
}
 
Instrument::DetectorCache::const_iterator Instrument::DetectorCache::lower_bound(detid_t id) const {
  if (!isFinalized()) {
    throw std::runtime_error("lower_bound() called on non-finalized DetectorCache");
  }
  return std::lower_bound(cbegin(), cend(), id,
                          [](DetectorCacheEntry const &entry, detid_t id) { return entry.id() < id; });
}
 
Instrument::DetectorCache::iterator Instrument::DetectorCache::find(detid_t id) {
  if (!isFinalized()) {
    throw std::runtime_error("find() called on non-finalized DetectorCache");
  }
  auto it = lower_bound(id);
  if (it != end() && it->id() == id) {
    return it;
  } else {
    return end();
  }
}
 
Instrument::DetectorCache::const_iterator Instrument::DetectorCache::find(detid_t id) const {
  if (!isFinalized()) {
    throw std::runtime_error("find() called on non-finalized DetectorCache");
  }
  auto const it = lower_bound(id);
  if (it != cend() && it->id() == id) {
    return it;
  } else {
    return cend();
  }
}
 
IDetector_const_sptr Instrument::getDetector(const detid_t &detector_id) const {
  // ensure instrument is finalized
  if (!isFinalized())
    throw std::runtime_error("Instrument definition is not finalized. Can't search for detector ID " +
                             std::to_string(detector_id));
 
  const auto &in_dets = m_map ? m_instr->m_detectorCache : m_detectorCache;
  const auto it = in_dets.find(detector_id);
  if (it == in_dets.end()) {
    std::stringstream readInt;
    readInt << detector_id;
    throw Kernel::Exception::NotFoundError("Instrument: Detector with ID " + readInt.str() + " not found.", "");
  }
  IDetector_const_sptr baseDet = it->detector();
 
  if (!m_map)
    return baseDet;
 
  auto det = ParComponentFactory::createDetector(baseDet.get(), m_map);
  return det;
}
 
const IDetector *Instrument::getBaseDetector(const detid_t &detector_id) const {
  // ensure instrument is finalized
  if (!m_map)
    throw std::runtime_error("Instrument::getBaseDetector() called on a non-parametrized instrument.");
  if (!isFinalized())
    throw std::runtime_error("Instrument definition is not finalized. Can't find base detector ID " +
                             std::to_string(detector_id));
 
  auto it = m_instr->m_detectorCache.find(detector_id);
  if (it == m_instr->m_detectorCache.end()) {
    return nullptr;
  }
  return it->detector().get();
}
 
bool Instrument::isMonitor(const detid_t &detector_id) const {
  // ensure instrument is finalized
  if (!isFinalized())
    throw std::runtime_error("Instrument definition is not finalized. Can't search for monitor ID " +
                             std::to_string(detector_id));
 
  const auto &in_dets = m_map ? m_instr->m_detectorCache : m_detectorCache;
  const auto it = in_dets.find(detector_id);
  if (it == in_dets.end())
    return false;
  return it->isMonitor();
}
 
bool Instrument::isMonitor(const std::set<detid_t> &detector_ids) const {
  if (detector_ids.empty())
    return false;
 
  return std::any_of(detector_ids.cbegin(), detector_ids.cend(),
                     [this](const auto detector_id) { return isMonitor(detector_id); });
}
 
IDetector_const_sptr Instrument::getDetectorG(const std::set<detid_t> &det_ids) const {
  const size_t ndets(det_ids.size());
  if (ndets == 1) {
    return this->getDetector(*det_ids.begin());
  } else {
    std::shared_ptr<DetectorGroup> det_group = std::make_shared<DetectorGroup>();
    for (const auto detID : det_ids) {
      det_group->addDetector(this->getDetector(detID));
    }
    return det_group;
  }
}
 
std::vector<IDetector_const_sptr> Instrument::getDetectors(const std::vector<detid_t> &det_ids) const {
  std::vector<IDetector_const_sptr> dets_ptr;
  dets_ptr.reserve(det_ids.size());
  std::vector<detid_t>::const_iterator it;
  for (it = det_ids.begin(); it != det_ids.end(); ++it) {
    dets_ptr.emplace_back(this->getDetector(*it));
  }
  return dets_ptr;
}
 
std::vector<IDetector_const_sptr> Instrument::getDetectors(const std::set<detid_t> &det_ids) const {
  std::vector<IDetector_const_sptr> dets_ptr;
  dets_ptr.reserve(det_ids.size());
  std::set<detid_t>::const_iterator it;
  for (it = det_ids.begin(); it != det_ids.end(); ++it) {
    dets_ptr.emplace_back(this->getDetector(*it));
  }
  return dets_ptr;
}
 
void Instrument::markAsSamplePos(const IComponent *comp) {
  if (m_map)
    throw std::runtime_error("Instrument::markAsSamplePos() called on a "
                             "parametrized Instrument object.");
 
  auto objComp = dynamic_cast<const IObjComponent *>(comp);
  if (objComp) {
    throw std::runtime_error("Instrument::markAsSamplePos() called on an IObjComponent "
                             "object that supports shape definition. Sample is prevented from "
                             "being this type because the shape must only be stored in "
                             "ExperimentInfo::m_sample.");
  }
 
  if (!m_sampleCache) {
    if (comp->getName().empty()) {
      throw Exception::InstrumentDefinitionError("The sample component is required to have a name.");
    }
    m_sampleCache = comp;
  } else {
    g_log.warning("Have already added samplePos component to the _sampleCache.");
  }
}
 
void Instrument::markAsSource(const IComponent *comp) {
  if (m_map)
    throw std::runtime_error("Instrument::markAsSource() called on a "
                             "parametrized Instrument object.");
 
  if (!m_sourceCache) {
    if (comp->getName().empty()) {
      throw Exception::InstrumentDefinitionError("The source component is required to have a name.");
    }
    m_sourceCache = comp;
  } else {
    g_log.warning("Have already added source component to the _sourceCache.");
  }
}
 
void Instrument::markAsDetector(const IDetector *det) {
  if (m_map)
    throw std::runtime_error("Instrument::markAsDetector() called on a "
                             "parametrized Instrument object.");
  // ensure instrument is finalized
  if (!isFinalized())
    throw std::runtime_error("Instrument definition is not finalized.  Add detector with markAsDetectorIncomplete, "
                             "then call markAsDetectorFinalized when finished.");
 
  // Duplicate detector ids are forbidden
  auto it = m_detectorCache.lower_bound(det->getID());
  if ((it != m_detectorCache.end()) && (it->id() == det->getID())) {
    raiseDuplicateDetectorError(det->getID());
  }
  // Create a (non-deleting) shared pointer to it
  IDetector_const_sptr det_sptr = IDetector_const_sptr(det, NoDeleting());
  m_detectorCache.emplace(it, det->getID(), det_sptr, false);
}
 
void Instrument::markAsDetectorIncomplete(const IDetector *det) {
  if (m_map)
    throw std::runtime_error("Instrument::markAsDetector() called on a "
                             "parametrized Instrument object.");
 
  m_detectorCache.setIncomplete();
  // Create a (non-deleting) shared pointer to it
  IDetector_const_sptr det_sptr = IDetector_const_sptr(det, NoDeleting());
  m_detectorCache.emplace_back(det->getID(), det_sptr, false);
}
 
void Instrument::markAsDetectorFinalize() {
  // We're already finalized! We can't finalize any further!
  if (isFinalized())
    return;
 
  // Detectors (even when different objects) are NOT allowed to have duplicate
  // ids. This method establishes the presence of duplicates.
  std::sort(m_detectorCache.begin(), m_detectorCache.end(),
            [](DetectorCacheEntry const &a, DetectorCacheEntry const &b) -> bool { return a.id() < b.id(); });
 
  auto resultIt = std::adjacent_find(
      m_detectorCache.begin(), m_detectorCache.end(),
      [](DetectorCacheEntry const &a, DetectorCacheEntry const &b) -> bool { return a.id() == b.id(); });
  if (resultIt != m_detectorCache.end()) {
    raiseDuplicateDetectorError(resultIt->id());
  } else {
    m_detectorCache.setFinalized();
  }
}
 
void Instrument::markAsMonitor(const IDetector *det) {
  if (m_map)
    throw std::runtime_error("Instrument::markAsMonitor() called on a "
                             "parametrized Instrument object.");
  if (!isFinalized()) {
    throw std::runtime_error("Instrument definition is not finalized.  Add monitor with markAsMonitorIncomplete, then "
                             "call markAsDetectorFinalized when finished.");
  }
 
  // attempt to add monitor to instrument detector cache
  markAsDetector(det);
 
  // mark detector as a monitor
  auto it = m_detectorCache.find(det->getID());
  it->setIsMonitor(true);
}
 
void Instrument::markAsMonitorIncomplete(const IDetector *det) {
  if (m_map)
    throw std::runtime_error("Instrument::markAsMonitorIncomplete() called on a "
                             "parametrized Instrument object.");
 
  m_detectorCache.setIncomplete();
  // Create a (non-deleting) shared pointer to it
  IDetector_const_sptr det_sptr = IDetector_const_sptr(det, NoDeleting());
  m_detectorCache.emplace_back(det->getID(), det_sptr, true);
}
 
void Instrument::removeDetector(IDetector *det) {
  if (m_map)
    throw std::runtime_error("Instrument::removeDetector() called on a "
                             "parameterized Instrument object.");
  if (!isFinalized())
    throw std::runtime_error("Instrument definition is not finalized. Can't remove detector with ID " +
                             std::to_string(det->getID()));
 
  const detid_t id = det->getID();
  // Remove the detector from the detector cache
  const auto it = m_detectorCache.find(id);
  // NOTE this operation is O(N) for the vector cache
  m_detectorCache.erase(it);
 
  // Remove it from the parent assembly (and thus the instrument).
  // Evilness required here unfortunately.
  auto *parentAssembly = dynamic_cast<CompAssembly *>(const_cast<IComponent *>(det->getBareParent()));
  if (parentAssembly) // Should always be true, but check just in case
  {
    parentAssembly->remove(det);
  }
}
 
void Instrument::removeDetectorIncomplete(IDetector const *det) {
  if (m_map)
    throw std::runtime_error("Instrument::removeDetectorIncomplete() called on a "
                             "parameterized Instrument object.");
  m_detectorCache.setIncomplete();
  if (m_detectorCache.m_toRemove.empty()) {
    m_detectorCache.m_toRemove.reserve(m_detectorCache.size());
  }
  m_detectorCache.m_toRemove.insert(det);
}
 
void Instrument::removeDetectorFinalize() {
  if (m_map)
    throw std::runtime_error("Instrument::removeDetectorFinalize() called on a "
                             "parameterized Instrument object.");
 
  if (isFinalized()) {
    m_detectorCache.m_toRemove.clear();
    return;
  }
 
  // Remove from the cache all the ones to be removed
  auto newEnd = std::remove_if(m_detectorCache.begin(), m_detectorCache.end(), [this](const auto &entry) {
    return m_detectorCache.m_toRemove.contains(entry.detector().get());
  });
  m_detectorCache.erase(newEnd, m_detectorCache.end());
 
  // clear the removal set and finalize the cache
  m_detectorCache.m_toRemove.clear();
  m_detectorCache.setFinalized();
}
 
void Instrument::getBoundingBox(BoundingBox &assemblyBox) const {
  if (m_map) {
 
    if (m_map->hasComponentInfo(m_instr.get())) {
      assemblyBox = m_map->componentInfo().boundingBox(index(), &assemblyBox);
      return;
    }
 
    // Loop over the children and define a box large enough for all of them
    ComponentID sourceID = getSource()->getComponentID();
    assemblyBox = BoundingBox(); // this makes the instrument BB always axis aligned
    int nchildren = nelements();
    for (int i = 0; i < nchildren; ++i) {
      IComponent_sptr comp = this->getChild(i);
      if (comp && comp->getComponentID() != sourceID) {
        BoundingBox compBox;
        comp->getBoundingBox(compBox);
        assemblyBox.grow(compBox);
      }
    }
  } else {
 
    if (!m_cachedBoundingBox) {
      m_cachedBoundingBox = new BoundingBox();
      ComponentID sourceID = getSource()->getComponentID();
      // Loop over the children and define a box large enough for all of them
      for (const auto component : m_children) {
        BoundingBox compBox;
        if (component && component->getComponentID() != sourceID) {
          component->getBoundingBox(compBox);
          m_cachedBoundingBox->grow(compBox);
        }
      }
    }
    // Use cached box
    assemblyBox = *m_cachedBoundingBox;
  }
}
 
std::shared_ptr<const std::vector<IObjComponent_const_sptr>> Instrument::getPlottable() const {
  if (m_map) {
    // Get the 'base' plottable components
    std::shared_ptr<const std::vector<IObjComponent_const_sptr>> objs = m_instr->getPlottable();
 
    // Get a reference to the underlying vector, casting away the constness so that we
    // can modify it to get our result rather than creating another long vector
    auto &res = const_cast<std::vector<IObjComponent_const_sptr> &>(*objs);
    const std::vector<IObjComponent_const_sptr>::size_type total = res.size();
    for (std::vector<IObjComponent_const_sptr>::size_type i = 0; i < total; ++i) {
      res[i] = std::dynamic_pointer_cast<const Detector>(ParComponentFactory::create(objs->at(i), m_map));
    }
    return objs;
 
  } else {
    // Base instrument
    auto res = std::make_shared<std::vector<IObjComponent_const_sptr>>();
    res->reserve(m_detectorCache.size() + 10);
    appendPlottable(*this, *res);
    return res;
  }
}
 
void Instrument::appendPlottable(const CompAssembly &ca, std::vector<IObjComponent_const_sptr> &lst) const {
  for (int i = 0; i < ca.nelements(); i++) {
    IComponent *c = ca[i].get();
    const auto *a = dynamic_cast<CompAssembly *>(c);
    if (a)
      appendPlottable(*a, lst);
    else {
      auto *d = dynamic_cast<Detector *>(c);
      auto *o = dynamic_cast<ObjComponent *>(c);
      if (d)
        lst.emplace_back(IObjComponent_const_sptr(d, NoDeleting()));
      else if (o)
        lst.emplace_back(IObjComponent_const_sptr(o, NoDeleting()));
      else
        g_log.error() << "Unknown comp type\n";
    }
  }
}
 
//------------------------------------------------------------------------------------------------
void Instrument::getInstrumentParameters(double &l1, Kernel::V3D &beamline, double &beamline_norm,
                                         Kernel::V3D &samplePos) const {
  // Get some positions
  const IComponent_const_sptr sourceObj = this->getSource();
  if (sourceObj == nullptr) {
    throw Exception::InstrumentDefinitionError("Failed to get source component from instrument");
  }
  const Kernel::V3D sourcePos = sourceObj->getPos();
  samplePos = this->getSample()->getPos();
  beamline = samplePos - sourcePos;
  beamline_norm = 2.0 * beamline.norm();
 
  // Get the distance between the source and the sample (assume in metres)
  IComponent_const_sptr sample = this->getSample();
  try {
    l1 = this->getSource()->getDistance(*sample);
  } catch (Exception::NotFoundError &) {
    throw Exception::InstrumentDefinitionError("Unable to calculate source-sample distance ", this->getName());
  }
}
 
//--------------------------------------------------------------------------------------------
void Instrument::setFilename(const std::string &filename) {
  if (m_map)
    m_instr->m_filename = filename;
  else
    m_filename = filename;
}
 
const std::string &Instrument::getFilename() const {
  if (m_map)
    return m_instr->getFilename();
  else
    return m_filename;
}
 
void Instrument::setXmlText(const std::string &XmlText) {
  if (m_map)
    m_instr->m_xmlText = XmlText;
  else
    m_xmlText = XmlText;
}
 
const std::string &Instrument::getXmlText() const {
  if (m_map)
    return m_instr->getXmlText();
  else
    return m_xmlText;
}
 
//--------------------------------------------------------------------------------------------
void Instrument::saveNexus(Nexus::File *file, const std::string &group) const {
  file->makeGroup(group, "NXinstrument", true);
  file->putAttr("version", 1);
 
  file->writeData("name", getName());
 
  // XML contents of instrument, as a NX note
  file->makeGroup("instrument_xml", "NXnote", true);
  const std::string &xmlText = getXmlText();
  if (xmlText.empty())
    g_log.warning() << "Saving Instrument with no XML data. If this was "
                       "instrument data you may not be able to load this data "
                       "back into Mantid, for fitted/analysed data this "
                       "warning can be ignored.\n";
  file->writeData("data", xmlText);
  file->writeData("type", "text/xml"); // mimetype
  file->writeData("description", "XML contents of the instrument IDF file.");
  file->closeGroup();
 
  // Now the parameter map, as a NXnote via its saveNexus method
  if (isParametrized()) {
    // Map with data extracted from DetectorInfo -> legacy compatible files.
    const auto &pmap = *getParameterMap();
    const auto parameters = legacyParameters();
    ParameterMap::saveNexus(file, "instrument_parameter_map",
                            parameters.empty()
                                ? std::string()
                                : ParameterMap::asString(parameters, pmap.componentInfo(), pmap.detectorInfo()));
  }
 
  // Add physical detector data
  auto detectorIDs = getDetectorIDs(true);
  if (!detectorIDs.empty()) {
    // Add detectors group
    file->makeGroup("physical_detectors", "NXdetector", true);
    file->writeData("number_of_detectors", uint64_t(detectorIDs.size()));
    saveDetectorSetInfoToNexus(file, detectorIDs);
    file->closeGroup(); // detectors
  }
 
  // Add monitor data
  auto monitorIDs = getMonitorIDs();
  if (!monitorIDs.empty()) {
    // Add Monitors group
    file->makeGroup("physical_monitors", "NXmonitor", true);
    file->writeData("number_of_monitors", uint64_t(monitorIDs.size()));
    saveDetectorSetInfoToNexus(file, monitorIDs);
    file->closeGroup(); // monitors
  }
 
  file->closeGroup();
}
 
/* A private helper function so save information about a set of detectors to
 * Nexus
 *  @param file :: open Nexus file ready to recieve the info about the set of
 * detectors
 *                 a group must be open that has only one call of this function.
 *  @param detIDs :: the dectector IDs of the detectors belonging to the set
 */
void Instrument::saveDetectorSetInfoToNexus(Nexus::File *file, const std::vector<detid_t> &detIDs) const {
 
  size_t nDets = detIDs.size();
  if (nDets == 0)
    return;
  auto detectors = getDetectors(detIDs);
 
  Geometry::IComponent_const_sptr sample = getSample();
  Kernel::V3D sample_pos;
  if (sample)
    sample_pos = sample->getPos();
 
  std::vector<double> a_angles(nDets);
  std::vector<double> p_angles(nDets);
  std::vector<double> distances(nDets);
 
  for (size_t i = 0; i < nDets; i++) {
    if (sample) {
      Kernel::V3D pos = detectors[i]->getPos() - sample_pos;
      pos.getSpherical(distances[i], p_angles[i], a_angles[i]);
    } else {
      a_angles[i] = detectors[i]->getPhi() * 180.0 / M_PI;
    }
  }
  file->writeData("detector_number", detIDs);
  file->writeData("azimuthal_angle", a_angles);
  file->openData("azimuthal_angle");
  file->putAttr("units", "degree");
  file->closeData();
  if (sample) {
    file->writeData("polar_angle", p_angles);
    file->openData("polar_angle");
    file->putAttr("units", "degree");
    file->closeData();
    file->writeData("distance", distances);
    file->openData("distance");
    file->putAttr("units", "metre");
    file->closeData();
  }
}
 
//--------------------------------------------------------------------------------------------
void Instrument::loadNexus(Nexus::File *file, const std::string &group) {
  file->openGroup(group, "NXinstrument");
  file->closeGroup();
}
 
void Instrument::setReferenceFrame(std::shared_ptr<ReferenceFrame> frame) { m_referenceFrame = std::move(frame); }
 
std::shared_ptr<const ReferenceFrame> Instrument::getReferenceFrame() const {
  if (m_map) {
    return m_instr->getReferenceFrame();
  } else {
    return m_referenceFrame;
  }
}
 
void Instrument::setDefaultView(const std::string &type) {
  std::string typeUC(type);
  std::transform(typeUC.begin(), typeUC.end(), typeUC.begin(), toupper);
  if (typeUC == "3D" || typeUC == "CYLINDRICAL_X" || typeUC == "CYLINDRICAL_Y" || typeUC == "CYLINDRICAL_Z" ||
      typeUC == "SPHERICAL_X" || typeUC == "SPHERICAL_Y" || typeUC == "SPHERICAL_Z") {
    m_defaultView = typeUC;
  } else {
    m_defaultView = "3D";
    g_log.warning() << type << " is not allowed as an instrument view type. Default to \"3D\"" << '\n';
  }
}
 
void Instrument::setValidFromDate(const Types::Core::DateAndTime &val) {
  Types::Core::DateAndTime earliestAllowedDate("1900-01-31 23:59:01");
  if (val < earliestAllowedDate) {
    throw Kernel::Exception::InstrumentDefinitionError(
        "The valid-from <instrument> tag date must be from 1900-01-31 23:59:01 "
        "or later",
        m_filename);
  }
  m_ValidFrom = val;
}
 
Instrument::ContainsState Instrument::containsRectDetectors() const {
  std::queue<IComponent_const_sptr> compQueue; // Search queue
  addInstrumentChildrenToQueue(compQueue);
 
  bool foundRect = false;
  bool foundNonRect = false;
 
  IComponent_const_sptr comp;
 
  while (!compQueue.empty() && !(foundRect && foundNonRect)) {
    comp = compQueue.front();
    compQueue.pop();
 
    if (!validateComponentProperties(comp))
      continue;
 
    if (dynamic_cast<const RectangularDetector *>(comp.get())) {
      foundRect = true;
    } // If component isn't a ComponentAssembly, we know it is a non-rectangular detector. Otherwise check its children
    else if (!addAssemblyChildrenToQueue(compQueue, comp)) {
      foundNonRect = true;
    }
  }
 
  // Found both
  if (foundRect && foundNonRect)
    return Instrument::ContainsState::Partial;
  // Found only rectangular
  else if (foundRect)
    return Instrument::ContainsState::Full;
  // Found only non-rectangular
  else
    return Instrument::ContainsState::None;
}
 
bool Instrument::validateComponentProperties(IComponent_const_sptr component) const {
  // Skip source, if has one
  if (m_sourceCache && m_sourceCache->getComponentID() == component->getComponentID())
    return false;
 
  // Skip sample, if has one
  if (m_sampleCache && m_sampleCache->getComponentID() == component->getComponentID())
    return false;
 
  // Skip monitors
  IDetector_const_sptr detector = std::dynamic_pointer_cast<const IDetector>(component);
  if (detector && isMonitor(detector->getID()))
    return false;
 
  // skip choppers, slits and supermirrors - HACK!
  const auto &name = component->getName();
  if (name == "chopper-position" || name.substr(0, 4) == "slit" || name == "supermirror") {
    return false;
  }
 
  return true;
}
 
void Instrument::addInstrumentChildrenToQueue(std::queue<IComponent_const_sptr> &queue) const {
  // Add all the direct children of the instrument
  for (int i = 0; i < nelements(); i++)
    queue.push(getChild(i));
}
 
bool Instrument::addAssemblyChildrenToQueue(std::queue<IComponent_const_sptr> &queue,
                                            IComponent_const_sptr component) const {
  if (auto const assembly = std::dynamic_pointer_cast<const ICompAssembly>(component)) {
    for (int i = 0; i < assembly->nelements(); i++)
      queue.push(assembly->getChild(i));
    return true;
  }
  return false;
}
 
bool Instrument::isMonitorViaIndex(const size_t index) const {
  const auto &in_dets = m_map ? m_instr->m_detectorCache : m_detectorCache;
  if (!in_dets.isFinalized())
    throw std::runtime_error("Instrument::isMonitorViaIndex: detector cache is not finalized");
  if (index >= in_dets.size())
    throw std::out_of_range("Instrument::isMonitorViaIndex: index out of range");
  return in_dets[index].isMonitor();
}
 
bool Instrument::isEmptyInstrument() const { return this->nelements() == 0; }
 
size_t Instrument::detectorIndex(const detid_t detID) const {
  if (!isFinalized())
    throw std::runtime_error("Instrument definition is not finalized. Can't get detector index for ID " +
                             std::to_string(detID));
 
  const auto &in_dets = m_map ? m_instr->m_detectorCache : m_detectorCache;
  const auto it = in_dets.find(detID);
  return std::distance(in_dets.cbegin(), it);
}
 
std::vector<ParameterMap::Entry> Instrument::legacyParameters() const {
  if (!isFinalized())
    throw std::runtime_error("Instrument definition is not finalized. Can't create legacy parameters.");
 
  const auto &pmap = *getParameterMap();
  const auto &baseInstr = m_map ? *m_instr : *this;
 
  if (!pmap.hasComponentInfo(&baseInstr))
    return pmap.entries();
 
  // Start from a copy of the instrument's parameters. add() replaces a parameter of the same name.
  ParameterInfo legacy(*pmap.sharedParameterInfo());
  auto const makeParameter = [](const std::string &type, const std::string &name, auto const &value) {
    auto parameter = ParameterFactory::create(type, name);
    parameter->set(value);
    return parameter;
  };
 
  // Tolerance 1e-9 m with rotation center at a distance of L = 1000 m as in
  // Beamline::DetectorInfo::isEquivalent.
  constexpr double d_max = 1e-9;
  constexpr double L = 1000.0;
  constexpr double safety_factor = 2.0;
  const double imag_norm_max = sin(d_max / (2.0 * L * safety_factor));
 
  auto transformation = Eigen::Affine3d::Identity();
  int64_t oldParentIndex = -1;
 
  const auto &componentInfo = pmap.componentInfo();
  const auto &detectorInfo = pmap.detectorInfo();
  for (size_t i = 0; i < componentInfo.size(); ++i) {
 
    const int64_t parentIndex = componentInfo.parent(i);
    const bool makeTransform = parentIndex != oldParentIndex;
    bool isDetFixedInBank = false;
 
    if (makeTransform) {
      oldParentIndex = parentIndex;
      const auto parentPos = toVector3d(componentInfo.position(parentIndex));
      const auto invParentRot = toQuaterniond(componentInfo.rotation(parentIndex)).conjugate();
 
      transformation = invParentRot;
      transformation.translate(-parentPos);
    }
 
    if (componentInfo.isDetector(i)) {
      isDetFixedInBank = ComponentInfoBankHelpers::isDetectorFixedInBank(componentInfo, i);
      if (detectorInfo.isMasked(i)) {
        // insert() rather than add(), as ParameterMap::forceUnsafeSetMasked() does
        legacy.insert(i, makeParameter(ParameterMap::pBool(), "masked", true));
      }
 
      if (makeTransform) {
        // Special case: scaling for GridDetectorPixel.
        if (isDetFixedInBank) {
 
          size_t panelIndex = componentInfo.parent(parentIndex);
 
          Eigen::Vector3d scale(1, 1, 1);
          if (auto scalex = legacy.get(panelIndex, "scalex"))
            scale[0] = 1.0 / scalex->value<double>();
          if (auto scaley = legacy.get(panelIndex, "scaley"))
            scale[1] = 1.0 / scaley->value<double>();
          transformation.prescale(scale);
        }
      }
    }
 
    const IComponent *baseComponent = componentInfo.componentID(i)->getBaseComponent();
    // Generic sca scale factors
    const auto newScaleFactor = Kernel::toVector3d(componentInfo.scaleFactor(i));
    if ((newScaleFactor - toVector3d(baseComponent->getScaleFactor())).norm() >= 1e-9) {
      legacy.add(i, makeParameter(ParameterMap::pV3D(), ParameterMap::scale(), componentInfo.scaleFactor(i)));
    }
 
    // Undo parent transformation to obtain relative position/rotation.
    Eigen::Vector3d relPos = transformation * toVector3d(componentInfo.position(i));
    Eigen::Quaterniond relRot = toQuaterniond(componentInfo.relativeRotation(i));
 
    // Tolerance 1e-9 m as in Beamline::DetectorInfo::isEquivalent.
    if ((relPos - toVector3d(baseComponent->getRelativePos())).norm() >= 1e-9) {
      if (isDetFixedInBank) {
        throw std::runtime_error(
            "Cannot create legacy parameters: Position parameters for GridDetectorPixel are not supported");
      }
      legacy.add(i, makeParameter(ParameterMap::pV3D(), ParameterMap::pos(), Kernel::toV3D(relPos)));
    }
    if ((relRot * toQuaterniond(baseComponent->getRelativeRot()).conjugate()).vec().norm() >= imag_norm_max) {
      legacy.add(i, makeParameter(ParameterMap::pQuat(), ParameterMap::rot(), Kernel::toQuat(relRot)));
    }
  }
 
  std::vector<ParameterMap::Entry> result;
  result.reserve(legacy.size());
  for (auto const &[index, parameters] : legacy) {
    for (auto const &[parameterName, parameter] : parameters) {
      static_cast<void>(parameterName);
      result.emplace_back(index, parameter);
    }
  }
  return result;
}
 
void Instrument::parseTreeAndCacheBeamline() {
  if (isParametrized())
    throw std::logic_error(
        "Instrument::parseTreeAndCacheBeamline must be called with the base instrument, not a parametrized instrument");
  std::tie(m_componentInfo, m_detectorInfo) = InstrumentVisitor::makeWrappers(*this);
}
 
std::pair<std::unique_ptr<ComponentInfo>, std::unique_ptr<DetectorInfo>>
Instrument::makeBeamline(ParameterMap &pmap, const ParameterMap *source) const {
  // If we have source and it has Beamline objects just copy them
  if (source && source->hasComponentInfo(this)) {
    return makeWrappers(pmap, source->componentInfo(), source->detectorInfo());
  }
  // If pmap is empty and base instrument has Beamline objects just copy them
  if (pmap.empty() && m_componentInfo) {
    return makeWrappers(pmap, *m_componentInfo, *m_detectorInfo);
  }
  // pmap not empty and/or no cached Beamline objects found
  return InstrumentVisitor::makeWrappers(*this, &pmap);
}
 
std::pair<std::unique_ptr<ComponentInfo>, std::unique_ptr<DetectorInfo>>
Instrument::makeBeamlineNew(ParameterMap &pmap) const {
  return InstrumentVisitor::makeWrappers(*this, &pmap);
}
 
std::pair<std::unique_ptr<ComponentInfo>, std::unique_ptr<DetectorInfo>>
Instrument::makeWrappers(ParameterMap &pmap, const ComponentInfo &componentInfo,
                         const DetectorInfo &detectorInfo) const {
  auto compInfo = componentInfo.cloneWithoutDetectorInfo();
  auto detInfo = std::make_unique<DetectorInfo>(detectorInfo);
  compInfo->m_componentInfo->setDetectorInfo(detInfo->m_detectorInfo.get());
  // Point the clone at THIS map's parameter store, attaching the map to the clone's index domain if
  // it is not already: the map is either empty or a copy of one attached to that domain.
  compInfo->m_parameterInfo = pmap.rekey(compInfo->m_componentIds, compInfo->m_compIDToIndex);
  detInfo->m_parameterInfo = compInfo->m_parameterInfo;
  // Take the frame from the instrument rather than the cached copy, in case it was set after the cache was built.
  compInfo->m_referenceFrame = getReferenceFrame();
  detInfo->m_referenceFrame = compInfo->m_referenceFrame;
  const auto parInstrument = ParComponentFactory::createInstrument(
      std::shared_ptr<const Instrument>(this, NoDeleting()), std::shared_ptr<ParameterMap>(&pmap, NoDeleting()));
  detInfo->m_instrument = parInstrument;
  return {std::move(compInfo), std::move(detInfo)};
}
 
size_t Instrument::getMemorySize() const {
  // A parametrized instrument is a thin wrapper around a base instrument: it holds a shared_ptr to
  // the base (m_instr) but owns none of the component tree, detector cache, or beamline objects.
  // Delegate to the base and add only the ParameterMap overhead.
  if (m_instr) {
    const size_t paramMapMem = m_map_nonconst ? m_map_nonconst->getMemorySize() : 0;
    return sizeof(*this) + m_instr->getMemorySize() + paramMapMem;
  }
 
  // Each std::map node carries ~4 pointers of red-black-tree overhead beyond the stored value_type.
  const size_t mapNodeOverhead = 4 * sizeof(void *);
 
  const size_t logfileCacheMem =
      m_logfileCache.size() * (sizeof(InstrumentParameterCache::value_type) + mapNodeOverhead);
  const size_t logfileUnitMem = m_logfileUnit.size() * (sizeof(decltype(m_logfileUnit)::value_type) + mapNodeOverhead);
 
  const size_t detectorInfoMem = m_detectorInfo ? m_detectorInfo->getMemorySize() : 0;
  const size_t componentInfoMem = m_componentInfo ? m_componentInfo->getMemorySize() : 0;
 
  // BFS over the component tree. The Instrument root is already counted via sizeof(*this),
  // so start the traversal from the root and add each child's type-accurate object size plus
  // the IComponent* slot it occupies in its parent's m_children buffer.
  size_t componentTreeMem = 0;
  std::queue<const ICompAssembly *> bfsQueue;
  bfsQueue.push(this);
  while (!bfsQueue.empty()) {
    const auto *assembly = bfsQueue.front();
    bfsQueue.pop();
    const int n = assembly->nelements();
    componentTreeMem += static_cast<size_t>(n) * sizeof(IComponent *);
    for (int i = 0; i < n; ++i) {
      auto child = assembly->getChild(i);
      const IComponent *raw = child.get();
      componentTreeMem += componentObjectSize(raw);
      if (const auto *sub = dynamic_cast<const ICompAssembly *>(raw))
        bfsQueue.push(sub);
    }
  }
 
  // m_referenceFrame: heap-allocated ReferenceFrame object
  const size_t referenceFrameMem = m_referenceFrame ? sizeof(ReferenceFrame) : 0;
 
  // Indirect-geometry instruments hold a second full instrument for the physical geometry.
  const size_t physicalInstrumentMem = m_physicalInstrument ? m_physicalInstrument->getMemorySize() : 0;
 
  return sizeof(*this) + componentTreeMem + m_detectorCache.capacity() * sizeof(DetectorCacheEntry) + logfileCacheMem +
         logfileUnitMem + m_defaultView.capacity() + m_defaultViewAxis.capacity() + m_xmlText.capacity() +
         m_filename.capacity() + detectorInfoMem + componentInfoMem + referenceFrameMem + physicalInstrumentMem;
}
 
namespace Conversion {
 
double tofToDSpacingFactor(const double l1, const double l2, const double twoTheta, const double offset) {
  return Kernel::Units::tofToDSpacingFactor(l1, l2, twoTheta, offset);
}
 
double calculateDIFCCorrection(const double l1, const double l2, const double twoTheta, const double offset,
                               const double binWidth) {
  return Kernel::Units::calculateDIFCCorrection(l1, l2, twoTheta, offset, binWidth);
}
 
} // namespace Conversion
} // namespace Mantid::Geometry