CompAssembly.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/CompAssembly.h"
#include "MantidGeometry/IObjComponent.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/ComponentVisitor.h"
#include "MantidGeometry/Instrument/ParComponentFactory.h"
#include "MantidGeometry/Instrument/RectangularDetector.h"
#include "MantidGeometry/Instrument/StructuredDetector.h"
#include "MantidGeometry/Objects/BoundingBox.h"
#include <algorithm>
#include <ostream>
#include <stdexcept>
 
namespace Mantid::Geometry {
 
using Kernel::Quat;
using Kernel::V3D;
 
CompAssembly::CompAssembly() : Component(), m_children(), m_cachedBoundingBox(nullptr) {}
 
CompAssembly::CompAssembly(const IComponent *base, const ParameterMap *map)
    : Component(base, map), m_children(), m_cachedBoundingBox(nullptr) {}
 
CompAssembly::CompAssembly(const std::string &n, IComponent *reference)
    : Component(n, reference), m_children(), m_cachedBoundingBox(nullptr) {
  if (reference) {
    auto *test = dynamic_cast<ICompAssembly *>(reference);
    if (test) {
      test->add(this);
    }
  }
}
 
CompAssembly::CompAssembly(const CompAssembly &assem) : ICompAssembly(assem), Component(assem) { *this = assem; }
 
CompAssembly &CompAssembly::operator=(const CompAssembly &assem) {
  m_children = assem.m_children;
  m_cachedBoundingBox = assem.m_cachedBoundingBox;
 
  // Need to do a deep copy
  comp_it it;
  for (it = m_children.begin(); it != m_children.end(); ++it) {
    *it = (*it)->clone();
    // Move copied component object's parent from old to new CompAssembly
    (*it)->setParent(this);
  }
 
  return *this;
}
 
CompAssembly::~CompAssembly() {
  if (m_cachedBoundingBox)
    delete m_cachedBoundingBox;
  // Iterate over pointers in m_children, deleting them
  for (auto &child : m_children) {
    delete child;
  }
  m_children.clear();
}
 
IComponent *CompAssembly::clone() const { return new CompAssembly(*this); }
 
int CompAssembly::add(IComponent *comp) {
  if (m_map)
    throw std::runtime_error("CompAssembly::add() called for a parametrized CompAssembly.");
 
  if (comp) {
    comp->setParent(this);
    m_children.emplace_back(comp);
  }
  return static_cast<int>(m_children.size());
}
 
int CompAssembly::addCopy(IComponent *comp) {
  if (m_map)
    throw std::runtime_error("CompAssembly::addCopy() called for a parametrized CompAssembly.");
 
  if (comp) {
    IComponent *newcomp = comp->clone();
    newcomp->setParent(this);
    m_children.emplace_back(newcomp);
  }
  return static_cast<int>(m_children.size());
}
 
int CompAssembly::addCopy(IComponent *comp, const std::string &n) {
  if (m_map)
    throw std::runtime_error("CompAssembly::addCopy() called for a parametrized CompAssembly.");
 
  if (comp) {
    IComponent *newcomp = comp->clone();
    newcomp->setParent(this);
    newcomp->setName(n);
    m_children.emplace_back(newcomp);
  }
  return static_cast<int>(m_children.size());
}
 
int CompAssembly::remove(IComponent *comp) {
  if (m_map)
    throw std::runtime_error("CompAssembly::remove() called for a parameterized CompAssembly.");
 
  // Look for the passed in component in the list of children
  auto it = std::find(m_children.begin(), m_children.end(), comp);
  if (it != m_children.end()) {
    // If it's found, remove it from the list and then delete it
    m_children.erase(it);
    delete comp;
  } else {
    throw std::runtime_error("Component " + comp->getName() + " is not a child of this assembly.");
  }
 
  return static_cast<int>(m_children.size());
}
 
int CompAssembly::nelements() const {
  if (m_map) {
    auto compAss = dynamic_cast<const CompAssembly *>(m_base);
    if (!compAss) {
      throw std::logic_error("Failed to cast base component to CompAssembly");
    }
    return compAss->nelements();
  } else
    return static_cast<int>(m_children.size());
}
 
std::shared_ptr<IComponent> CompAssembly::getChild(const int i) const {
  if (m_map) {
    // Get the child of the base (unparametrized) assembly
    auto child_base = dynamic_cast<const CompAssembly *>(m_base);
    if (!child_base) {
      throw std::logic_error("Failed to cast base component to CompAssembly");
    }
    // And build up a parametrized version of it using the factory, and return
    // that
    return ParComponentFactory::create(child_base->getChild(i), m_map);
  } else {
    if (i < 0 || i > static_cast<int>(m_children.size() - 1)) {
      throw std::runtime_error("CompAssembly::getChild() range not valid");
    }
    return std::shared_ptr<IComponent>(m_children[i], NoDeleting());
  }
}
 
std::shared_ptr<IComponent> CompAssembly::operator[](int i) const { return this->getChild(i); }
 
//------------------------------------------------------------------------------------------------
void CompAssembly::getChildren(std::vector<IComponent_const_sptr> &outVector, bool recursive) const {
  for (int i = 0; i < this->nelements(); i++) {
    std::shared_ptr<IComponent> comp = this->getChild(i);
    if (comp) {
      outVector.emplace_back(comp);
      // Look deeper, on option.
      if (recursive) {
        std::shared_ptr<ICompAssembly> assemb = std::dynamic_pointer_cast<ICompAssembly>(comp);
        if (assemb)
          assemb->getChildren(outVector, recursive);
      }
    }
  }
}
 
std::shared_ptr<const IComponent> CompAssembly::getComponentByName(const std::string &cname, int nlevels) const {
  std::shared_ptr<const ICompAssembly> thisNode = std::shared_ptr<const ICompAssembly>(this, NoDeleting());
 
  // If name has '/' in it, it is taken as part of a path name of the component.
  // Steps may be skipped at a '/' from the path name,
  // but if what follows the skip is not unique within what precedes it, only
  // the first found is returned.
  size_t cut = cname.find('/');
  if (cut < cname.length()) {
    auto otherNode = this->getComponentByName(cname.substr(0, cut), nlevels);
    if (otherNode) {
      std::shared_ptr<const ICompAssembly> asmb = std::dynamic_pointer_cast<const ICompAssembly>(otherNode);
      return asmb->getComponentByName(cname.substr(cut + 1, std::string::npos), nlevels);
    } else {
      return std::shared_ptr<const IComponent>(); // Search failed
    }
  }
 
  // Check the instrument name first
  if (this->getName() == cname) {
    return std::dynamic_pointer_cast<const ICompAssembly>(thisNode);
  }
  // Otherwise Search the instrument tree using a breadth-first search algorithm
  // since most likely candidates
  // are higher-level components
  // I found some useful info here
  // http://www.cs.bu.edu/teaching/c/tree/breadth-first/
  std::deque<std::shared_ptr<const ICompAssembly>> nodeQueue{thisNode};
  const bool limitSearch(nlevels > 0);
  while (!nodeQueue.empty()) {
    // get the next node in the queue
    std::shared_ptr<const ICompAssembly> node = nodeQueue.front();
    nodeQueue.pop_front();
 
    // determine the depth
    int depth(1);
    if (limitSearch) {
      auto parent = node->getParent();
      while (parent && (this->getName() != parent->getName())) {
        parent = parent->getParent();
        depth++;
      }
    }
 
    auto rectDet = std::dynamic_pointer_cast<const RectangularDetector>(node);
    auto structDet = std::dynamic_pointer_cast<const StructuredDetector>(node);
 
    if (bool(rectDet) && (node != thisNode)) {
      // for rectangular detectors search the depth rather than siblings
      // as there
      // is a specific naming convention to speed things along
      auto child = rectDet->getComponentByName(cname, nlevels);
      if (child)
        return child;
    } else if (bool(structDet) && (node != thisNode)) {
      auto child = rectDet->getComponentByName(cname, nlevels);
      if (child != nullptr)
        return child;
    } else {
      // loop over the children
      int nchildren = node->nelements();
      for (int i = 0; i < nchildren; ++i) {
        std::shared_ptr<const IComponent> comp = (*node)[i];
        if (comp->getName() == cname) {
          return comp;
        } else {
          // only add things if max-recursion depth hasn't been reached
          if ((!limitSearch) || (depth + 1 < nlevels)) {
            // don't bother adding things to the queue that aren't
            // assemblies
            std::shared_ptr<const ICompAssembly> compAssembly = std::dynamic_pointer_cast<const ICompAssembly>(comp);
            if (bool(compAssembly)) {
              nodeQueue.emplace_back(compAssembly);
            }
          }
        }
      }
    }
  } // while-end
 
  // If we have reached here then the search failed
  return std::shared_ptr<const IComponent>();
}
 
//------------------------------------------------------------------------------------------------
void CompAssembly::getBoundingBox(BoundingBox &assemblyBox) const {
  if (m_map) {
 
    if (hasComponentInfo()) {
      assemblyBox = m_map->componentInfo().boundingBox(index(), &assemblyBox);
      return;
    }
 
    // Loop over the children and define a box large enough for all of them
    assemblyBox = BoundingBox(); // this makes assembly box always axis alighned
    int nchildren = nelements();
    for (int i = 0; i < nchildren; ++i) {
      IComponent_sptr comp = this->operator[](i);
      BoundingBox compBox;
      comp->getBoundingBox(compBox);
      assemblyBox.grow(compBox);
    }
  }
 
  else {
    // Not parametrized
    if (!m_cachedBoundingBox) {
      m_cachedBoundingBox = new BoundingBox();
      // Loop over the children and define a box large enough for all of them
      for (auto child : m_children) {
        BoundingBox compBox;
        if (child) {
          child->getBoundingBox(compBox);
          m_cachedBoundingBox->grow(compBox);
        }
      }
    }
    // Use cached box
    assemblyBox = *m_cachedBoundingBox;
  }
}
 
//------------------------------------------------------------------------------------------------
void CompAssembly::testIntersectionWithChildren(Track &testRay, std::deque<IComponent_const_sptr> &searchQueue) const {
  int nchildren = this->nelements();
  for (int i = 0; i < nchildren; ++i) {
    std::shared_ptr<Geometry::IComponent> comp = this->getChild(i);
    if (std::dynamic_pointer_cast<ICompAssembly>(comp)) {
      searchQueue.emplace_back(comp);
    }
    // Check the physical object intersection
    else if (auto *physicalObject = dynamic_cast<IObjComponent *>(comp.get())) {
      physicalObject->interceptSurface(testRay);
    } else {
    }
  }
}
 
//------------------------------------------------------------------------------------------------
void CompAssembly::printChildren(std::ostream &os) const {
  for (int i = 0; i < nelements(); i++) {
    std::shared_ptr<IComponent> it = (*this)[i];
    os << "Component " << i << " : **********\n";
    it->printSelf(os);
  }
}
 
void CompAssembly::printTree(std::ostream &os) const {
  for (int i = 0; i < nelements(); i++) {
    std::shared_ptr<IComponent> it = (*this)[i];
    const CompAssembly *test = dynamic_cast<CompAssembly *>(it.get());
    os << "Element " << i << " from " << nelements() << " in the assembly : ";
    if (test) {
      os << test->getName() << '\n';
      os << "Children :******** \n";
      test->printTree(os);
    } else
      os << it->getName() << '\n';
  }
}
 
V3D CompAssembly::getPos() const {
  if (!m_map || hasComponentInfo())
    return Component::getPos();
  else {
    V3D pos;
    if (!m_map->getCachedLocation(m_base, pos)) {
      pos = Component::getPos();
      m_map->setCachedLocation(m_base, pos);
    }
    return pos;
  }
}
 
Quat CompAssembly::getRotation() const {
  if (!m_map || hasComponentInfo())
    return Component::getRotation();
  else {
    Quat rot;
    if (!m_map->getCachedRotation(m_base, rot)) {
      rot = Component::getRotation();
      m_map->setCachedRotation(m_base, rot);
    }
    return rot;
  }
}
 
size_t CompAssembly::registerContents(ComponentVisitor &visitor) const {
  // Generic Assembly registration call.
  return visitor.registerComponentAssembly(*this);
}
 
std::ostream &operator<<(std::ostream &os, const CompAssembly &ass) {
  ass.printSelf(os);
  os << "************************\n";
  os << "Number of children :" << ass.nelements() << '\n';
  ass.printChildren(os);
  return os;
}
 
} // namespace Mantid::Geometry