InstrumentRayTracer.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 +
//-------------------------------------------------------------
// Includes
//-------------------------------------------------------------
#include "MantidGeometry/Objects/InstrumentRayTracer.h"
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Instrument/InstrumentVisitor.h"
#include "MantidGeometry/Instrument/ParameterMap.h"
#include "MantidGeometry/Objects/Track.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/V3D.h"
#include <deque>
#include <iterator>
#include <utility>
 
namespace Mantid::Geometry {
 
using Kernel::V3D;
 
//-------------------------------------------------------------
// Public member functions
//-------------------------------------------------------------
 
InstrumentRayTracer::InstrumentRayTracer(Instrument_const_sptr instrument) : m_instrument(std::move(instrument)) {
  if (!m_instrument) {
    std::ostringstream lexer;
    lexer << "Cannot create a InstrumentRayTracer, invalid instrument given. "
             "Input = "
          << m_instrument.get() << "\n";
    throw std::invalid_argument(lexer.str());
  }
  if (!m_instrument->getSource()) {
    std::string errorMsg = "Cannot create InstrumentRayTracer, instrument has "
                           "no defined source.\n";
    throw std::invalid_argument(errorMsg);
  }
}
 
InstrumentRayTracer::~InstrumentRayTracer() = default;
 
void InstrumentRayTracer::trace(const V3D &dir) const {
  // Define the track with the source position and the given direction.
  m_resultsTrack.reset(m_instrument->getSource()->getPos(), dir);
  // m_resultsTrack.reset(m_instrument->getSample()->getPos() +
  // V3D(1.0,0.0,0.0), dir);
  // The intersection results are accumulated within the ray object
  fireRay(m_resultsTrack);
}
 
void InstrumentRayTracer::traceFromSample(const V3D &dir) const {
  // Define the track with the sample position and the given direction.
  m_resultsTrack.reset(m_instrument->getSample()->getPos(), dir);
  // The intersection results are accumulated within the ray object
  fireRay(m_resultsTrack);
}
 
Links InstrumentRayTracer::getResults() const {
  Links results(m_resultsTrack.cbegin(), m_resultsTrack.cend());
  m_resultsTrack.clearIntersectionResults();
  return results;
}
 
//----------------------------------------------------------------------------------
IDetector_const_sptr InstrumentRayTracer::getDetectorResult() const {
  Links results = this->getResults();
  const auto &compInfo = componentInfo();
  const auto &detInfo = detectorInfo();
 
  // Go through all results
  Links::const_iterator resultItr = results.begin();
  for (; resultItr != results.end(); ++resultItr) {
    const size_t index = compInfo.indexOf(resultItr->componentID);
    if (compInfo.isDetector(index) && !detInfo.isMonitor(index)) {
      return m_instrument->getDetector(detInfo.detid(index));
    } // (is a detector)
  } // each ray tracer result
  return IDetector_const_sptr();
}
 
//-------------------------------------------------------------
// Private member functions
//-------------------------------------------------------------
 
void InstrumentRayTracer::ensureOwnedInfoIsBuilt() const {
  if (!m_ownedComponentInfo)
    std::tie(m_ownedComponentInfo, m_ownedDetectorInfo) = InstrumentVisitor::makeWrappers(*m_instrument);
}
 
const ComponentInfo &InstrumentRayTracer::componentInfo() const {
  if (m_instrument->isParametrized())
    return m_instrument->getParameterMap()->componentInfo();
  ensureOwnedInfoIsBuilt();
  return *m_ownedComponentInfo;
}
 
const DetectorInfo &InstrumentRayTracer::detectorInfo() const {
  if (m_instrument->isParametrized())
    return m_instrument->getParameterMap()->detectorInfo();
  ensureOwnedInfoIsBuilt();
  return *m_ownedDetectorInfo;
}
 
void InstrumentRayTracer::fireRay(Track &testRay) const {
  // Go through the instrument tree and see if we get any hits by
  // (a) first testing the bounding box and if we're inside that then
  // (b) test the lower components.
  std::deque<IComponent_const_sptr> nodeQueue;
 
  // Start at the root of the tree
  nodeQueue.emplace_back(m_instrument);
 
  IComponent_const_sptr node;
  while (!nodeQueue.empty()) {
    node = nodeQueue.front();
    nodeQueue.pop_front();
    BoundingBox bbox;
    auto it = m_boxCache.find(node->getComponentID());
    if (it != m_boxCache.end()) {
      bbox = it->second;
    } else {
      node->getBoundingBox(bbox);
      std::lock_guard<std::mutex> lock(m_mutex);
      m_boxCache[node->getComponentID()] = bbox;
    }
 
    // Quick test. If this suceeds moved on to test the children
    if (bbox.doesLineIntersect(testRay)) {
      if (ICompAssembly_const_sptr assembly = std::dynamic_pointer_cast<const ICompAssembly>(node)) {
        assembly->testIntersectionWithChildren(testRay, nodeQueue);
      } else {
        throw Kernel::Exception::NotImplementedError("Implement non-comp assembly interactions");
      }
    }
  }
}
 
// * Perform a quick check as to whether the ray passes through the component
// * @param component :: The test component
// */
// bool InstrumentRayTracer::quickIntersectCheck(std::shared_ptr<IComponent>
// component, const Track & testRay) const
// {
//
// }
//
// /**
//  * Perform a proper intersection test of the physical object and accumulate
//  the results if necessary
//  * @param testRay :: An input/output parameter that defines the track and
//  accumulates the
//  * intersection results
//  */
// void slowIntersectCheck(std::shared_ptr<IComponent> component, Track &
// testRay) const;
} // namespace Mantid::Geometry