diff --git a/Framework/Geometry/CMakeLists.txt b/Framework/Geometry/CMakeLists.txt
index d161a89ad980432a7ccc2be639d08ab73589e763..6ff724752f42acb983bdd53c9e4d6e2dc9a059f9 100644
--- a/Framework/Geometry/CMakeLists.txt
+++ b/Framework/Geometry/CMakeLists.txt
@@ -49,6 +49,7 @@ set ( SRC_FILES
src/Instrument/ComponentHelper.cpp
src/Instrument/ComponentInfo.cpp
src/Instrument/ComponentInfoBankHelpers.cpp
+ src/Instrument/ComponentInfoIterator.cpp
src/Instrument/Container.cpp
src/Instrument/Detector.cpp
src/Instrument/DetectorGroup.cpp
@@ -106,8 +107,8 @@ set ( SRC_FILES
src/Objects/BoundingBox.cpp
src/Objects/CSGObject.cpp
src/Objects/InstrumentRayTracer.cpp
- src/Objects/MeshObject2D.cpp
src/Objects/MeshObject.cpp
+ src/Objects/MeshObject2D.cpp
src/Objects/MeshObjectCommon.cpp
src/Objects/RuleItems.cpp
src/Objects/Rules.cpp
@@ -198,6 +199,8 @@ set ( INC_FILES
inc/MantidGeometry/Instrument/ComponentHelper.h
inc/MantidGeometry/Instrument/ComponentInfo.h
inc/MantidGeometry/Instrument/ComponentInfoBankHelpers.h
+ inc/MantidGeometry/Instrument/ComponentInfoItem.h
+ inc/MantidGeometry/Instrument/ComponentInfoIterator.h
inc/MantidGeometry/Instrument/ComponentVisitor.h
inc/MantidGeometry/Instrument/Container.h
inc/MantidGeometry/Instrument/Detector.h
@@ -207,9 +210,10 @@ set ( INC_FILES
inc/MantidGeometry/Instrument/DetectorInfoIterator.h
inc/MantidGeometry/Instrument/FitParameter.h
inc/MantidGeometry/Instrument/Goniometer.h
- inc/MantidGeometry/Instrument/GridDetector.h
+ inc/MantidGeometry/Instrument/GridDetector.h
inc/MantidGeometry/Instrument/GridDetectorPixel.h
inc/MantidGeometry/Instrument/IDFObject.h
+ inc/MantidGeometry/Instrument/InfoIteratorBase.h
inc/MantidGeometry/Instrument/InstrumentDefinitionParser.h
inc/MantidGeometry/Instrument/InstrumentVisitor.h
inc/MantidGeometry/Instrument/ObjCompAssembly.h
@@ -307,6 +311,7 @@ set ( TEST_FILES
CenteringGroupTest.h
CompAssemblyTest.h
ComponentInfoBankHelpersTest.h
+ ComponentInfoIteratorTest.h
ComponentInfoTest.h
ComponentParserTest.h
ComponentTest.h
@@ -327,8 +332,8 @@ set ( TEST_FILES
GeneralFrameTest.h
GeneralTest.h
GoniometerTest.h
- GridDetectorTest.h
GridDetectorPixelTest.h
+ GridDetectorTest.h
GroupTest.h
GroupTransformationTest.h
HKLFilterTest.h
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfo.h b/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfo.h
index fcfc5e8c1e21f76be3dc73c7260a286cfe4ca6c4..15fefd005c235c0769389b66b7d49d69437ca8a2 100644
--- a/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfo.h
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfo.h
@@ -9,6 +9,7 @@
#include "MantidBeamline/ComponentType.h"
#include "MantidGeometry/DllConfig.h"
+#include "MantidGeometry/Instrument/ComponentInfoIterator.h"
#include "MantidGeometry/Objects/BoundingBox.h"
#include "MantidKernel/DateAndTime.h"
#include <boost/shared_ptr.hpp>
@@ -140,9 +141,18 @@ public:
Types::Core::DateAndTime> &interval);
size_t scanCount() const;
void merge(const ComponentInfo &other);
+
+ ComponentInfoIterator<ComponentInfo> begin();
+ ComponentInfoIterator<ComponentInfo> end();
+ const ComponentInfoIterator<const ComponentInfo> cbegin();
+ const ComponentInfoIterator<const ComponentInfo> cend();
+
friend class Instrument;
};
+using ComponentInfoIt = ComponentInfoIterator<ComponentInfo>;
+using ComponentInfoConstIt = ComponentInfoIterator<const ComponentInfo>;
+
} // namespace Geometry
} // namespace Mantid
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoItem.h b/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoItem.h
new file mode 100644
index 0000000000000000000000000000000000000000..2814998359dec3a106e87d7b00b3ed97c2c2a611
--- /dev/null
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoItem.h
@@ -0,0 +1,55 @@
+// 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
+// SPDX - License - Identifier: GPL - 3.0 +
+#ifndef MANTID_GEOMETRY_COMPONENTINFOITEM_H_
+#define MANTID_GEOMETRY_COMPONENTINFOITEM_H_
+
+#include <MantidKernel/Quat.h>
+#include <MantidKernel/V3D.h>
+#include <vector>
+
+namespace Mantid {
+namespace Geometry {
+
+/** ComponentInfoItem
+ * Return type for ComponentInfoIterators. Provides AOS type access to
+ * ComponentInfo
+ */
+template <typename T> class ComponentInfoItem {
+public:
+ ComponentInfoItem(T &componentInfo, const size_t index)
+ : m_componentInfo(&componentInfo), m_index(index) {}
+
+ bool isDetector() const { return m_componentInfo->isDetector(m_index); }
+ std::vector<size_t> detectorsInSubtree() const {
+ return m_componentInfo->detectorsInSubtree(m_index);
+ }
+ std::vector<size_t> componentsInSubtree() const {
+ return m_componentInfo->componentsInSubtree(m_index);
+ }
+ const std::vector<size_t> &children() const {
+ return m_componentInfo->children(m_index);
+ }
+ Kernel::V3D position() const { return m_componentInfo->position(m_index); }
+ Kernel::Quat rotation() const { return m_componentInfo->rotation(m_index); }
+ size_t parent() const { return m_componentInfo->parent(m_index); }
+ bool hasParent() const { return m_componentInfo->hasParent(m_index); }
+ Kernel::V3D scaleFactor() const {
+ return m_componentInfo->scaleFactor(m_index);
+ }
+ std::string name() const { return m_componentInfo->name(m_index); }
+ size_t index() const { return m_index; }
+
+ // Non-owning pointer. A reference makes the class unable to define an
+ // assignment operator that we need.
+ T *m_componentInfo;
+ size_t m_index;
+};
+
+} // namespace Geometry
+} // namespace Mantid
+
+#endif /* MANTID_GEOMETRY_COMPONENTINFOITEM_H_ */
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoIterator.h b/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoIterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..949bc55a7c59844d2678a93b4638ccef09b0bea0
--- /dev/null
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoIterator.h
@@ -0,0 +1,26 @@
+// 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
+// SPDX - License - Identifier: GPL - 3.0 +
+#ifndef MANTID_GEOMETRY_COMPONENTINFOITERATOR_H_
+#define MANTID_GEOMETRY_COMPONENTINFOITERATOR_H_
+
+#include "MantidGeometry/Instrument/ComponentInfoItem.h"
+#include "MantidGeometry/Instrument/InfoIteratorBase.h"
+
+namespace Mantid {
+namespace Geometry {
+
+/** ComponentInfoIterator for random access iteration over ComponentInfo
+ */
+template <typename T>
+class ComponentInfoIterator : public InfoIteratorBase<T, ComponentInfoItem> {
+public:
+ using InfoIteratorBase<T, ComponentInfoItem>::InfoIteratorBase;
+};
+} // namespace Geometry
+} // namespace Mantid
+
+#endif /* MANTID_GEOMETRY_COMPONENTINFOITERATOR_H_ */
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfoItem.h b/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfoItem.h
index 3699f43492230bf8f19cd3c5a948a755f55ce83e..659fa2804a03d28b3456400e7f45bdcf308f366a 100644
--- a/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfoItem.h
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfoItem.h
@@ -53,6 +53,10 @@ public:
return m_detectorInfo->rotation(m_index);
}
+ double l2() const { return m_detectorInfo->l2(m_index); }
+
+ size_t index() const { return m_index; }
+
DetectorInfoItem(T &detectorInfo, const size_t index)
: m_detectorInfo(&detectorInfo), m_index(index) {}
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfoIterator.h b/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfoIterator.h
index 3b40de2d809b94523fa02e271e7fc506ab2ff450..4c604e26da0a9274ca2cf762263056baa4665e0a 100644
--- a/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfoIterator.h
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfoIterator.h
@@ -8,80 +8,22 @@
#define MANTID_GEOMETRY_DETECTORINFOITERATOR_H_
#include "MantidGeometry/Instrument/DetectorInfoItem.h"
-#include <boost/iterator/iterator_facade.hpp>
-
-using Mantid::Geometry::DetectorInfoItem;
+#include "MantidGeometry/Instrument/InfoIteratorBase.h"
namespace Mantid {
namespace Geometry {
-/** DetectorInfoIterator
-
-DetectorInfoIterator allows users of the DetectorInfo object access to data
-via an iterator. The iterator works as a slice view in that the index is
-incremented and all items accessible at that index are made available via the
-iterator.
+/** DetectorInfoIterator for random access iteration over DetectorInfo
+Random access iterator for iteration over DetectorInfo
@author Bhuvan Bezawada, STFC
@date 2018
*/
template <typename T>
-class DetectorInfoIterator
- : public boost::iterator_facade<DetectorInfoIterator<T>,
- DetectorInfoItem<T> &,
- boost::random_access_traversal_tag> {
-
+class DetectorInfoIterator : public InfoIteratorBase<T, DetectorInfoItem> {
public:
- DetectorInfoIterator(T &detectorInfo, const size_t index)
- : m_item(detectorInfo, index) {}
-
-private:
- // Allow boost iterator access
- friend class boost::iterator_core_access;
-
- // Iterator methods
- void advance(int64_t delta) {
- m_item.m_index =
- delta < 0 ? std::max(static_cast<uint64_t>(0),
- static_cast<uint64_t>(m_item.m_index) + delta)
- : std::min(m_item.m_detectorInfo->size(),
- m_item.m_index + static_cast<size_t>(delta));
- }
-
- // This could cause a segmentation fault if a user goes past the end of the
- // iterator and tries to index into the n+1 th element (which would not
- // exist). Adding range checks to all the above methods may slow down
- // performance though.
- void increment() {
- if (m_item.m_index < m_item.m_detectorInfo->size()) {
- ++m_item.m_index;
- }
- }
-
- void decrement() {
- if (m_item.m_index > 0) {
- --m_item.m_index;
- }
- }
-
- size_t getIndex() const { return m_item.m_index; }
-
- void setIndex(const size_t index) { m_item.m_index = index; }
-
- bool equal(const DetectorInfoIterator<T> &other) const {
- return getIndex() == other.getIndex();
- }
-
- DetectorInfoItem<T> &dereference() const { return m_item; }
-
- uint64_t distance_to(const DetectorInfoIterator<T> &other) const {
- return static_cast<uint64_t>(other.getIndex()) -
- static_cast<uint64_t>(getIndex());
- }
-
- mutable DetectorInfoItem<T> m_item;
+ using InfoIteratorBase<T, DetectorInfoItem>::InfoIteratorBase;
};
-
} // namespace Geometry
} // namespace Mantid
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/InfoIteratorBase.h b/Framework/Geometry/inc/MantidGeometry/Instrument/InfoIteratorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e82ae163573aab3475489607d36f0635601af1a
--- /dev/null
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/InfoIteratorBase.h
@@ -0,0 +1,90 @@
+// 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
+// SPDX - License - Identifier: GPL - 3.0 +
+#ifndef MANTID_GEOMETRY_INFOITERATORBASE_H_
+#define MANTID_GEOMETRY_INFOITERATORBASE_H_
+
+#include <algorithm>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace Mantid {
+namespace Geometry {
+
+/** InfoIterator
+
+Base to allow users of the Info objects (DetectorInfo etc) access to data
+via a random access iterator.
+
+Note that the reference type (InfoItem<T>) causes the iterator to be treated as
+std::input_iterator for the purposes of many std algorithms such as
+std::advance. See https://en.cppreference.com/w/cpp/iterator/advance for example
+*/
+template <typename T, template <typename> class InfoItem>
+class InfoIteratorBase
+ : public boost::iterator_facade<InfoIteratorBase<T, InfoItem>, InfoItem<T>,
+ boost::random_access_traversal_tag,
+ InfoItem<T>> {
+
+public:
+ /**
+ * Constructor for base iterator
+ * @param info : Info object (T) to provide iterator ontop of.
+ * @param index : start point of iterator
+ * @param totalSize : Represents maximum length of info. i.e. total number of
+ * items that can be iterated over.
+ */
+ InfoIteratorBase(T &info, const size_t index, const size_t totalSize)
+ : m_item(info, index), m_totalSize(totalSize) {
+ if (index > totalSize)
+ throw std::invalid_argument(
+ "Iterator start point cannot be greater than maximum size");
+ }
+
+private:
+ // Allow boost iterator access
+ friend class boost::iterator_core_access;
+
+ void advance(int64_t delta) {
+ m_item.m_index =
+ delta < 0 ? std::max(static_cast<uint64_t>(0),
+ static_cast<uint64_t>(m_item.m_index) + delta)
+ : std::min(m_totalSize,
+ m_item.m_index + static_cast<size_t>(delta));
+ }
+
+ bool equal(const InfoIteratorBase<T, InfoItem> &other) const {
+ return getIndex() == other.getIndex();
+ }
+
+ void increment() {
+ if (m_item.m_index < m_totalSize) {
+ ++m_item.m_index;
+ }
+ }
+
+ void decrement() {
+ if (m_item.m_index > 0) {
+ --m_item.m_index;
+ }
+ }
+
+ size_t getIndex() const { return m_item.m_index; }
+
+ void setIndex(const size_t index) { m_item.m_index = index; }
+
+ InfoItem<T> dereference() const { return m_item; }
+
+ uint64_t distance_to(const InfoIteratorBase<T, InfoItem> &other) const {
+ return static_cast<uint64_t>(other.getIndex()) -
+ static_cast<uint64_t>(getIndex());
+ }
+
+ InfoItem<T> m_item;
+ size_t m_totalSize;
+};
+} // namespace Geometry
+} // namespace Mantid
+#endif /* MANTID_GEOMETRY_INFOITERATORBASE_H_ */
diff --git a/Framework/Geometry/src/Instrument/ComponentInfo.cpp b/Framework/Geometry/src/Instrument/ComponentInfo.cpp
index d15a38008cd0c609daeadae94a40d2276683bb66..c7506abf23c33126be0e6da6925a033d5b0fac8a 100644
--- a/Framework/Geometry/src/Instrument/ComponentInfo.cpp
+++ b/Framework/Geometry/src/Instrument/ComponentInfo.cpp
@@ -440,5 +440,21 @@ void ComponentInfo::merge(const ComponentInfo &other) {
m_componentInfo->merge(*other.m_componentInfo);
}
+ComponentInfoIt ComponentInfo::begin() {
+ return ComponentInfoIt(*this, 0, size());
+}
+
+ComponentInfoIt ComponentInfo::end() {
+ return ComponentInfoIt(*this, size(), size());
+}
+
+const ComponentInfoConstIt ComponentInfo::cbegin() {
+ return ComponentInfoConstIt(*this, 0, size());
+}
+
+const ComponentInfoConstIt ComponentInfo::cend() {
+ return ComponentInfoConstIt(*this, size(), size());
+}
+
} // namespace Geometry
} // namespace Mantid
diff --git a/Framework/Geometry/src/Instrument/ComponentInfoIterator.cpp b/Framework/Geometry/src/Instrument/ComponentInfoIterator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6f836773d1a5ecea63d909ff291c8e7b872c0006
--- /dev/null
+++ b/Framework/Geometry/src/Instrument/ComponentInfoIterator.cpp
@@ -0,0 +1,5 @@
+#include "MantidGeometry/Instrument/ComponentInfoIterator.h"
+
+namespace Mantid {
+namespace Geometry {} // namespace Geometry
+} // namespace Mantid
diff --git a/Framework/Geometry/src/Instrument/DetectorInfo.cpp b/Framework/Geometry/src/Instrument/DetectorInfo.cpp
index 5f8d6656a1816f61b8f526c02ff6807c87e8a67a..d09e3c348a6001232aa0ecd68ae9aa448004ae16 100644
--- a/Framework/Geometry/src/Instrument/DetectorInfo.cpp
+++ b/Framework/Geometry/src/Instrument/DetectorInfo.cpp
@@ -332,11 +332,11 @@ DetectorInfo::scanIntervals() const {
}
const DetectorInfoConstIt DetectorInfo::cbegin() const {
- return DetectorInfoConstIt(*this, 0);
+ return DetectorInfoConstIt(*this, 0, size());
}
const DetectorInfoConstIt DetectorInfo::cend() const {
- return DetectorInfoConstIt(*this, size());
+ return DetectorInfoConstIt(*this, size(), size());
}
const Geometry::IDetector &DetectorInfo::getDetector(const size_t index) const {
@@ -358,10 +358,14 @@ DetectorInfo::getDetectorPtr(const size_t index) const {
}
// Begin method for iterator
-DetectorInfoIt DetectorInfo::begin() { return DetectorInfoIt(*this, 0); }
+DetectorInfoIt DetectorInfo::begin() {
+ return DetectorInfoIt(*this, 0, size());
+}
// End method for iterator
-DetectorInfoIt DetectorInfo::end() { return DetectorInfoIt(*this, size()); }
+DetectorInfoIt DetectorInfo::end() {
+ return DetectorInfoIt(*this, size(), size());
+}
} // namespace Geometry
} // namespace Mantid
diff --git a/Framework/Geometry/test/ComponentInfoIteratorTest.h b/Framework/Geometry/test/ComponentInfoIteratorTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..f978dac916f5ee1692e8755a9127d48f09fe1e00
--- /dev/null
+++ b/Framework/Geometry/test/ComponentInfoIteratorTest.h
@@ -0,0 +1,89 @@
+// 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
+// SPDX - License - Identifier: GPL - 3.0 +
+#ifndef MANTID_GEOMETRY_COMPONENTINFOITERATORTEST_H_
+#define MANTID_GEOMETRY_COMPONENTINFOITERATORTEST_H_
+
+#include <cxxtest/TestSuite.h>
+
+#include "MantidGeometry/Instrument/ComponentInfo.h"
+#include "MantidGeometry/Instrument/ComponentInfoItem.h"
+#include "MantidGeometry/Instrument/ComponentInfoIterator.h"
+#include "MantidGeometry/Instrument/Detector.h"
+#include "MantidGeometry/Instrument/DetectorInfo.h"
+#include "MantidGeometry/Instrument/InstrumentVisitor.h"
+#include "MantidTestHelpers/ComponentCreationHelper.h"
+#include <iterator>
+
+using namespace ComponentCreationHelper;
+using namespace Mantid::Geometry;
+
+class ComponentInfoIteratorTest : public CxxTest::TestSuite {
+public:
+ // This pair of boilerplate methods prevent the suite being created statically
+ // This means the constructor isn't called when running other tests
+ static ComponentInfoIteratorTest *createSuite() {
+ return new ComponentInfoIteratorTest();
+ }
+ static void destroySuite(ComponentInfoIteratorTest *suite) { delete suite; }
+
+ std::unique_ptr<Mantid::Geometry::ComponentInfo>
+ create_component_info_object() {
+
+ // Create a very basic instrument to visit
+ auto visitee = createMinimalInstrument(V3D(0, 0, 0), // Source position
+ V3D(10, 0, 0), // Sample position
+ V3D(11, 0, 0)); // Detector position
+
+ // Create the instrument visitor
+ InstrumentVisitor visitor(visitee);
+
+ // Return the DetectorInfo object
+ return InstrumentVisitor::makeWrappers(*visitee, nullptr).first;
+ }
+
+ void test_iterator_cbegin() {
+ auto componentInfo = create_component_info_object();
+ auto iter = componentInfo->cbegin();
+ // Check we start at the correct place
+ TS_ASSERT(iter != componentInfo->cend());
+ TS_ASSERT_EQUALS(iter->m_index, 0);
+ }
+ void test_iterator_cend() {
+ auto componentInfo = create_component_info_object();
+ auto iter = componentInfo->cend();
+ // Check we end at the correct place
+ TS_ASSERT(iter != componentInfo->cbegin());
+ TS_ASSERT_EQUALS(iter->m_index, componentInfo->size());
+ }
+ void test_increment_upwards() {
+ // Iterator starts at component index 0 (detectors usually) and finishes at
+ // root.
+ auto componentInfo = create_component_info_object();
+ ComponentInfoConstIt it(*componentInfo, 0, componentInfo->size());
+ TS_ASSERT(it->isDetector());
+ std::advance(it, componentInfo->size() - 1);
+ TS_ASSERT(!it->isDetector()); // Root is not a detector
+ }
+
+ void test_detector_components_behave_as_expected() {
+
+ auto componentInfo = create_component_info_object();
+ size_t detectorCount = 0;
+ for (auto item : *componentInfo) {
+ if (item.isDetector()) {
+ ++detectorCount;
+ TS_ASSERT_EQUALS(item.detectorsInSubtree().size(), 1); // Self
+ TS_ASSERT_EQUALS(item.componentsInSubtree().size(), 1); // Self
+ TS_ASSERT_EQUALS(item.children().size(),
+ 0); // Detectors have no children
+ }
+ }
+ TS_ASSERT_EQUALS(detectorCount, 1); // See instrument description above
+ }
+};
+
+#endif /* MANTID_GEOMETRY_COMPONENTINFOITERATORTEST_H_ */
diff --git a/Framework/Geometry/test/DetectorInfoIteratorTest.h b/Framework/Geometry/test/DetectorInfoIteratorTest.h
index bcf5aadeaa39594ba2f03c25317cf64ebda3ee8e..4626086642ea537c7a47e42aa1102194d2d80123 100644
--- a/Framework/Geometry/test/DetectorInfoIteratorTest.h
+++ b/Framework/Geometry/test/DetectorInfoIteratorTest.h
@@ -14,8 +14,10 @@
#include "MantidGeometry/Instrument/DetectorInfoIterator.h"
#include "MantidGeometry/Instrument/InstrumentVisitor.h"
#include "MantidTestHelpers/ComponentCreationHelper.h"
-
#include <cxxtest/TestSuite.h>
+#include <iterator>
+#include <type_traits>
+#include <typeinfo>
using namespace ComponentCreationHelper;
using namespace Mantid::Geometry;
@@ -146,6 +148,26 @@ public:
TS_ASSERT(iter == detectorInfo->cbegin());
}
+ void test_iterator_catagory() {
+ // Characterisation tests
+ using ItTag =
+ typename std::iterator_traits<DetectorInfoConstIt>::iterator_category;
+ using InputItTag = std::input_iterator_tag;
+ using BidirectionalItTag = std::bidirectional_iterator_tag;
+ const static bool inputit = std::is_convertible<ItTag, InputItTag>::value;
+ const static bool bidirectionalit =
+ std::is_convertible<ItTag, BidirectionalItTag>::value;
+ TSM_ASSERT("Iterator expected to be treated as input_iterator", inputit);
+ // Assert below. Iterator not bidirectional. This is why decrement via
+ // std::advance is not supported. Iterator reference must be true reference
+ // to support this.
+ TSM_ASSERT(
+ "Iterator expected not to be treated as legacy bidirectional iterator",
+ !bidirectionalit);
+
+ // see https://en.cppreference.com/w/cpp/iterator/advance
+ }
+
void test_iterator_advance_and_positions() {
// Get the DetectorInfo object
auto detectorInfo = create_detector_info_object();
@@ -161,12 +183,12 @@ public:
// Go backwards 2 places
xValue = 15.0;
- std::advance(iter, -2);
+ iter -= 2;
TS_ASSERT_EQUALS(iter->position().X(), xValue)
// Go to the start
- std::advance(iter, -4);
- TS_ASSERT(iter == detectorInfo->cbegin());
+ iter -= 4;
+ TS_ASSERT_EQUALS(iter, detectorInfo->cbegin());
}
void test_copy_iterator_and_positions() {
diff --git a/Framework/PythonInterface/inc/MantidPythonInterface/api/ComponentInfoPythonIterator.h b/Framework/PythonInterface/inc/MantidPythonInterface/api/ComponentInfoPythonIterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1cc280bf4e2339b6ee7cb0b9d0af83ca739994c
--- /dev/null
+++ b/Framework/PythonInterface/inc/MantidPythonInterface/api/ComponentInfoPythonIterator.h
@@ -0,0 +1,57 @@
+// 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
+// SPDX - License - Identifier: GPL - 3.0 +
+#ifndef MANTID_PYTHONINTERFACE_COMPONENTINFOPYTHONITERATOR_H_
+#define MANTID_PYTHONINTERFACE_COMPONENTINFOPYTHONITERATOR_H_
+
+#include "MantidGeometry/Instrument/ComponentInfo.h"
+#include "MantidGeometry/Instrument/ComponentInfoItem.h"
+#include "MantidGeometry/Instrument/ComponentInfoIterator.h"
+
+#include <boost/python/iterator.hpp>
+
+using Mantid::Geometry::ComponentInfo;
+using Mantid::Geometry::ComponentInfoItem;
+using Mantid::Geometry::ComponentInfoIterator;
+using namespace boost::python;
+
+namespace Mantid {
+namespace PythonInterface {
+
+/** ComponentInfoPythonIterator
+
+ComponentInfoPythonIterator is used to expose ComponentInfoIterator to the
+Python side.
+*/
+
+class ComponentInfoPythonIterator {
+public:
+ explicit ComponentInfoPythonIterator(ComponentInfo &detectorInfo)
+ : m_begin(detectorInfo.begin()), m_end(detectorInfo.end()),
+ m_firstOrDone(true) {}
+
+ ComponentInfoItem<ComponentInfo> next() {
+ if (!m_firstOrDone)
+ ++m_begin;
+ else
+ m_firstOrDone = false;
+ if (m_begin == m_end) {
+ m_firstOrDone = true;
+ objects::stop_iteration_error();
+ }
+ return *m_begin;
+ }
+
+private:
+ ComponentInfoIterator<ComponentInfo> m_begin;
+ ComponentInfoIterator<ComponentInfo> m_end;
+ bool m_firstOrDone;
+};
+
+} // namespace PythonInterface
+} // namespace Mantid
+
+#endif /* MANTID_PYTHONINTERFACE_COMPONENTINFOPYTHONITERATOR_H_ */
diff --git a/Framework/PythonInterface/inc/MantidPythonInterface/api/DetectorInfoPythonIterator.h b/Framework/PythonInterface/inc/MantidPythonInterface/api/DetectorInfoPythonIterator.h
index ee194aaaa3ef3a5aa5332263cead2f8c3fe64e1a..42c10470115f524c45e8e5c5b70a513c7dafbdca 100644
--- a/Framework/PythonInterface/inc/MantidPythonInterface/api/DetectorInfoPythonIterator.h
+++ b/Framework/PythonInterface/inc/MantidPythonInterface/api/DetectorInfoPythonIterator.h
@@ -42,7 +42,7 @@ public:
: m_begin(detectorInfo.begin()), m_end(detectorInfo.end()),
m_firstOrDone(true) {}
- const DetectorInfoItem<DetectorInfo> &next() {
+ DetectorInfoItem<DetectorInfo> next() {
if (!m_firstOrDone)
++m_begin;
else
diff --git a/Framework/PythonInterface/mantid/api/CMakeLists.txt b/Framework/PythonInterface/mantid/api/CMakeLists.txt
index 150e26d0eff5cf17a35ff524553e88461d9b2244..1158ba9e36554d939c067c406c435c0a95102f39 100644
--- a/Framework/PythonInterface/mantid/api/CMakeLists.txt
+++ b/Framework/PythonInterface/mantid/api/CMakeLists.txt
@@ -118,6 +118,7 @@ set ( INC_FILES
${HEADER_DIR}/api/WorkspacePropertyExporter.h
${HEADER_DIR}/api/SpectrumInfoPythonIterator.h
${HEADER_DIR}/api/DetectorInfoPythonIterator.h
+ ${HEADER_DIR}/api/ComponentInfoPythonIterator.h
)
set ( PY_FILES
diff --git a/Framework/PythonInterface/mantid/geometry/CMakeLists.txt b/Framework/PythonInterface/mantid/geometry/CMakeLists.txt
index 35bd59965e7a75d9d7752d48eba55b1be29de45b..afb043288b4f5f15a53dd6c39e201b2aa6edd191 100644
--- a/Framework/PythonInterface/mantid/geometry/CMakeLists.txt
+++ b/Framework/PythonInterface/mantid/geometry/CMakeLists.txt
@@ -41,9 +41,10 @@ set ( EXPORT_FILES
src/Exports/ReflectionGenerator.cpp
src/Exports/DetectorInfo.cpp
src/Exports/DetectorInfoItem.cpp
- src/Exports/DetectorInfoIterator.cpp
src/Exports/DetectorInfoPythonIterator.cpp
src/Exports/ComponentInfo.cpp
+ src/Exports/ComponentInfoItem.cpp
+ src/Exports/ComponentInfoPythonIterator.cpp
)
#############################################################################################
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfo.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfo.cpp
index a9b068b3b2e427ea26ecb5857d3562d8d53fe3c4..9ecf5d49229f3a623be9caf3d091ffc866f6dd63 100644
--- a/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfo.cpp
+++ b/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfo.cpp
@@ -8,6 +8,7 @@
#include "MantidGeometry/Objects/IObject.h"
#include "MantidKernel/Quat.h"
#include "MantidKernel/V3D.h"
+#include "MantidPythonInterface/api/ComponentInfoPythonIterator.h"
#include "MantidPythonInterface/core/Converters/WrapWithNDArray.h"
#include "MantidPythonInterface/kernel/Policies/VectorToNumpy.h"
@@ -19,10 +20,17 @@
using Mantid::Geometry::ComponentInfo;
using Mantid::Kernel::Quat;
using Mantid::Kernel::V3D;
+using Mantid::PythonInterface::ComponentInfoPythonIterator;
using namespace Mantid::PythonInterface::Converters;
using namespace Mantid::PythonInterface::Policies;
using namespace boost::python;
+namespace {
+ComponentInfoPythonIterator make_pyiterator(ComponentInfo &componentInfo) {
+ return ComponentInfoPythonIterator(componentInfo);
+}
+} // namespace
+
// Function pointers to help resolve ambiguity
Mantid::Kernel::V3D (ComponentInfo::*position)(const size_t) const =
&ComponentInfo::position;
@@ -40,6 +48,8 @@ void (ComponentInfo::*setRotation)(const size_t, const Mantid::Kernel::Quat &) =
void export_ComponentInfo() {
class_<ComponentInfo, boost::noncopyable>("ComponentInfo", no_init)
+ .def("__iter__", make_pyiterator)
+
.def("__len__", &ComponentInfo::size, arg("self"),
"Returns the number of components.")
@@ -138,5 +148,12 @@ void export_ComponentInfo() {
.def("shape", &ComponentInfo::shape, (arg("self"), arg("index")),
return_value_policy<reference_existing_object>(),
- "Returns the shape of the component identified by 'index'.");
+ "Returns the shape of the component identified by 'index'.")
+
+ .def("indexOfAny", &ComponentInfo::indexOfAny, (arg("self"), arg("name")),
+ "Returns the index of any component matching name. Raises "
+ "ValueError if name not found")
+
+ .def("root", &ComponentInfo::root, arg("self"),
+ "Returns the index of the root component");
}
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfoItem.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfoItem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e9feba6251bcaf2b671d0689524eed4d0147e36
--- /dev/null
+++ b/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfoItem.cpp
@@ -0,0 +1,50 @@
+// 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
+// SPDX - License - Identifier: GPL - 3.0 +
+#include "MantidGeometry/Instrument/ComponentInfoItem.h"
+#include "MantidGeometry/Instrument/ComponentInfo.h"
+#include "MantidKernel/Quat.h"
+#include "MantidKernel/V3D.h"
+#include "MantidPythonInterface/core/Converters/WrapWithNDArray.h"
+#include "MantidPythonInterface/kernel/Policies/VectorToNumpy.h"
+#include <boost/python/class.hpp>
+#include <boost/python/make_function.hpp>
+#include <boost/python/module.hpp>
+
+using Mantid::Geometry::ComponentInfo;
+using Mantid::Geometry::ComponentInfoItem;
+using Mantid::Kernel::V3D;
+using namespace boost::python;
+using namespace Mantid::PythonInterface::Converters;
+using namespace Mantid::PythonInterface::Policies;
+
+// Export DetectorInfoItem
+void export_ComponentInfoItem() {
+
+ // Export to Python
+ class_<ComponentInfoItem<ComponentInfo>>("ComponentInfoItem", no_init)
+ .add_property("isDetector", &ComponentInfoItem<ComponentInfo>::isDetector)
+ .add_property(
+ "componentsInSubtree",
+ make_function(&ComponentInfoItem<ComponentInfo>::componentsInSubtree,
+ return_value_policy<VectorToNumpy>()))
+ .add_property(
+ "detectorsInSubtree",
+ make_function(&ComponentInfoItem<ComponentInfo>::detectorsInSubtree,
+ return_value_policy<VectorToNumpy>()))
+ .add_property("position", &ComponentInfoItem<ComponentInfo>::position)
+ .add_property("rotation", &ComponentInfoItem<ComponentInfo>::rotation)
+ .add_property("parent", &ComponentInfoItem<ComponentInfo>::parent)
+ .add_property("hasParent", &ComponentInfoItem<ComponentInfo>::hasParent)
+ .add_property("scaleFactor",
+ &ComponentInfoItem<ComponentInfo>::scaleFactor)
+ .add_property("name", &ComponentInfoItem<ComponentInfo>::name)
+ .add_property(
+ "children",
+ make_function(&ComponentInfoItem<ComponentInfo>::children,
+ return_value_policy<VectorRefToNumpy<WrapReadOnly>>()))
+ .add_property("index", &ComponentInfoItem<ComponentInfo>::index);
+}
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfoPythonIterator.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfoPythonIterator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a07add6f07db2fe2d3be67a1ff3d89cdfe8735b5
--- /dev/null
+++ b/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfoPythonIterator.cpp
@@ -0,0 +1,28 @@
+// 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
+// SPDX - License - Identifier: GPL - 3.0 +
+#include "MantidPythonInterface/api/ComponentInfoPythonIterator.h"
+#include "MantidPythonInterface/core/VersionCompat.h"
+#include <boost/python/class.hpp>
+#include <boost/python/iterator.hpp>
+#include <boost/python/module.hpp>
+
+using Mantid::PythonInterface::ComponentInfoPythonIterator;
+using namespace boost::python;
+
+// Export ComponentInfoPythonIterator
+void export_ComponentInfoPythonIterator() {
+
+ // Export to Python
+ class_<ComponentInfoPythonIterator>("ComponentInfoPythonIterator", no_init)
+ .def("__iter__", objects::identity_function())
+#ifdef IS_PY3K
+ .def("__next__", &ComponentInfoPythonIterator::next)
+#else
+ .def("next", &ComponentInfoPythonIterator::next)
+#endif
+ ;
+}
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfo.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfo.cpp
index f348ac26520887c9dfb1adfeeaa6fc775b4fba08..d8e57ebe670007cc40614fa290b53457a2a40c84 100644
--- a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfo.cpp
+++ b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfo.cpp
@@ -62,6 +62,8 @@ void export_DetectorInfo() {
void (DetectorInfo::*setMasked)(const size_t, bool) =
&DetectorInfo::setMasked;
+ double (DetectorInfo::*l2)(const size_t) const = &DetectorInfo::l2;
+
// Export to Python
class_<DetectorInfo, boost::noncopyable>("DetectorInfo", no_init)
@@ -105,5 +107,9 @@ void export_DetectorInfo() {
"Returns the absolute rotation of the detector where the detector "
"is identified by 'index'.")
.def("detectorIDs", &DetectorInfo::detectorIDs, return_readonly_numpy(),
- "Returns all detector ids sorted by detector index");
+ "Returns all detector ids sorted by detector index")
+ .def("l2", l2, (arg("self"), arg("index")),
+ "Returns the l2 scattering distance")
+ .def("l1", &DetectorInfo::l1, arg("self"),
+ "Returns the l1 scattering distance");
}
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoItem.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoItem.cpp
index 09445dbb303b113314cbe711cb0ce91842e914d3..e9b2a2d346105485f89134f4bb554b0ae5c5a4c9 100644
--- a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoItem.cpp
+++ b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoItem.cpp
@@ -27,6 +27,8 @@ void export_DetectorInfoItem() {
.add_property("twoTheta", &DetectorInfoItem<DetectorInfo>::twoTheta)
.add_property("position", &DetectorInfoItem<DetectorInfo>::position)
.add_property("rotation", &DetectorInfoItem<DetectorInfo>::rotation)
+ .add_property("l2", &DetectorInfoItem<DetectorInfo>::l2)
+ .add_property("index", &DetectorInfoItem<DetectorInfo>::index)
.def("setMasked", &DetectorInfoItem<DetectorInfo>::setMasked,
(arg("self"), arg("masked")), "Set the mask flag for the detector");
}
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoIterator.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoIterator.cpp
deleted file mode 100644
index 9f099aff92a1c60986ba11c48adce3fca83d8d2f..0000000000000000000000000000000000000000
--- a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoIterator.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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
-// SPDX - License - Identifier: GPL - 3.0 +
-#include "MantidGeometry/Instrument/DetectorInfoIterator.h"
-#include "MantidGeometry/Instrument/DetectorInfo.h"
-
-#include <boost/python/class.hpp>
-#include <boost/python/module.hpp>
-
-using Mantid::Geometry::DetectorInfo;
-using Mantid::Geometry::DetectorInfoIterator;
-using namespace boost::python;
-
-// Export DetectorInfoIterator
-void export_DetectorInfoIterator() {
-
- // Export to Python
- class_<DetectorInfoIterator<DetectorInfo>>("DetectorInfoIterator", no_init);
-}
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoPythonIterator.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoPythonIterator.cpp
index 2f104addd520e52c1b02cd755003388571e59bf8..0c7db21d73591acce9aea5acdf57eb8a0651edef 100644
--- a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoPythonIterator.cpp
+++ b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfoPythonIterator.cpp
@@ -5,9 +5,8 @@
// & Institut Laue - Langevin
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidPythonInterface/api/DetectorInfoPythonIterator.h"
-
+#include "MantidPythonInterface/core/VersionCompat.h"
#include <boost/python/class.hpp>
-#include <boost/python/copy_const_reference.hpp>
#include <boost/python/iterator.hpp>
#include <boost/python/module.hpp>
@@ -20,22 +19,10 @@ void export_DetectorInfoPythonIterator() {
// Export to Python
class_<DetectorInfoPythonIterator>("DetectorInfoPythonIterator", no_init)
.def("__iter__", objects::identity_function())
- .def(
-#if PY_VERSION_HEX >= 0x03000000
- "__next__"
+#ifdef IS_PY3K
+ .def("__next__", &DetectorInfoPythonIterator::next)
#else
- "next"
+ .def("next", &DetectorInfoPythonIterator::next)
#endif
- ,
- &DetectorInfoPythonIterator::next,
- return_value_policy<copy_const_reference>());
- /*
- Return value policy for next is to copy the const reference. Copy by value is
- essential for python 2.0 compatibility because items (DetectorInfoItem) will
- outlive their iterators if declared as part of for loops. There is no good
- way to deal with this other than to force a copy so that internals of the
- item are not also corrupted. Future developers may wish to choose a separte
- policy for python 3.0 where this is not a concern, and const ref returns
- would be faster.
- */
+ ;
}
diff --git a/Framework/PythonInterface/test/python/mantid/geometry/ComponentInfoTest.py b/Framework/PythonInterface/test/python/mantid/geometry/ComponentInfoTest.py
index a3de637b28bed02faa035813f5bb0a4fc450f8ce..6ac48ff2ca9019af362b1cf84c3b9d275cb93fbb 100644
--- a/Framework/PythonInterface/test/python/mantid/geometry/ComponentInfoTest.py
+++ b/Framework/PythonInterface/test/python/mantid/geometry/ComponentInfoTest.py
@@ -14,6 +14,7 @@ from mantid.kernel import V3D
from mantid.kernel import Quat
from mantid.geometry import CSGObject
from mantid.simpleapi import *
+from itertools import islice
class ComponentInfoTest(unittest.TestCase):
@@ -185,7 +186,16 @@ class ComponentInfoTest(unittest.TestCase):
info = workspace.componentInfo()
self.assertEquals(info.size(), 1)
-
+ def test_indexOfAny(self):
+ info = self._ws.componentInfo()
+ index = info.indexOfAny(info.name(info.root()))
+ # Root index and the discovered index should be the same
+ self.assertEquals(index, info.root())
+
+ def test_indexOfAny_throws(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(ValueError):
+ info.indexOfAny('fictitious')
"""
----------------------------------------------------------------------------
Extreme Tests
@@ -474,5 +484,66 @@ class ComponentInfoTest(unittest.TestCase):
with self.assertRaises(TypeError):
info.shape(11.32)
+ def test_basic_iterator(self):
+ info = self._ws.componentInfo()
+ expected_iterations = len(info)
+ actual_iterations = len(list(iter(info)))
+ self.assertEquals(expected_iterations, actual_iterations)
+ it = iter(info)
+ self.assertEquals(next(it).index, 0)
+ self.assertEquals(next(it).index, 1)
+
+ def test_isDetector_via_iterator(self):
+ comp_info = self._ws.componentInfo()
+ n_detectors = len(self._ws.detectorInfo())
+ it = iter(comp_info)
+ self.assertEquals(next(it).isDetector, True)
+ self.assertEquals(next(it).isDetector, True)
+ self.assertEquals(next(it).isDetector, False)
+ self.assertEquals(next(it).isDetector, False)
+
+ def test_position_via_iterator(self):
+ comp_info = self._ws.componentInfo()
+ source_pos = comp_info.sourcePosition()
+ it = iter(comp_info)
+ # basic check on first detector position
+ self.assertTrue(next(it).position.distance(source_pos) > 0)
+
+ def test_children_via_iterator(self):
+ info = self._ws.componentInfo()
+ it = iter(info)
+ first_det = next(it)
+ self.assertEquals(type(first_det.children), np.ndarray)
+ self.assertEquals(len(first_det.children), 0)
+ root = next(it)
+ for root in it:
+ continue
+ self.assertEquals(root.index, info.root()) # sanity check
+ self.assertTrue(np.array_equal(root.children, np.array([0,1,2,3,4], dtype='uint64')))
+
+ def test_detectorsInSubtree_via_iterator(self):
+ info = self._ws.componentInfo()
+ it = iter(info)
+ first_det = next(it)
+ self.assertEquals(type(first_det.detectorsInSubtree), np.ndarray)
+ # For detectors, only contain own index
+ self.assertTrue(np.array_equal(first_det.detectorsInSubtree,np.array([0], dtype='uint64')))
+ root = next(it)
+ for root in it:
+ continue
+ self.assertTrue(np.array_equal(root.detectorsInSubtree, np.array([0,1], dtype='uint64')))
+
+ def test_componentsInSubtree_via_iterator(self):
+ info = self._ws.componentInfo()
+ it = iter(info)
+ first_det = next(it)
+ self.assertEquals(type(first_det.detectorsInSubtree), np.ndarray)
+ # For detectors, only contain own index
+ self.assertTrue(np.array_equal(first_det.componentsInSubtree,np.array([0], dtype='uint64')))
+ root = next(it)
+ for root in it:
+ continue
+ # All component indices expected including self
+ self.assertTrue(np.array_equal(root.componentsInSubtree, np.array([0,1,2,3,4,5], dtype='uint64')))
if __name__ == '__main__':
unittest.main()
diff --git a/Framework/PythonInterface/test/python/mantid/geometry/DetectorInfoTest.py b/Framework/PythonInterface/test/python/mantid/geometry/DetectorInfoTest.py
index a9ca56956b6369c20a6f475597f0fd513c4dd91c..2419c714d0e4a9b2bf33901030542b94d1759203 100644
--- a/Framework/PythonInterface/test/python/mantid/geometry/DetectorInfoTest.py
+++ b/Framework/PythonInterface/test/python/mantid/geometry/DetectorInfoTest.py
@@ -109,7 +109,19 @@ class DetectorInfoTest(unittest.TestCase):
self.assertEquals(type(info.rotation(0)), Quat)
self.assertEquals(type(info.rotation(1)), Quat)
-
+ def test_l2(self):
+ det_info = self._ws.detectorInfo()
+ sample_pos = self._ws.componentInfo().samplePosition()
+ l2_calc = det_info.position(0).distance(sample_pos)
+ self.assertEquals(det_info.l2(0), l2_calc)
+
+ def test_l1(self):
+ source_pos = self._ws.componentInfo().sourcePosition()
+ sample_pos = self._ws.componentInfo().samplePosition()
+ l1_calc = sample_pos.distance(source_pos)
+ det_info = self._ws.detectorInfo()
+ self.assertEquals(det_info.l1(), l1_calc)
+
"""
---------------
Iteration
@@ -121,6 +133,9 @@ class DetectorInfoTest(unittest.TestCase):
expected_iterations = len(info)
actual_iterations = len(list(iter(info)))
self.assertEquals(expected_iterations, actual_iterations)
+ it = iter(info)
+ self.assertEquals(next(it).index, 0)
+ self.assertEquals(next(it).index, 1)
def test_iterator_for_monitors(self):
info = self._ws.detectorInfo()
@@ -155,6 +170,10 @@ class DetectorInfoTest(unittest.TestCase):
self.assertTrue(pos.Y() > lastY)
lastY = pos.Y()
+ def test_iterator_for_l2(self):
+ info = self._ws.detectorInfo()
+ for item in info:
+ self.assertTrue(item.l2 > 0)
"""
----------------------------------------------------------------------------
diff --git a/docs/source/concepts/ComponentInfo.rst b/docs/source/concepts/ComponentInfo.rst
index 80ce4b8f77f7d0230210e6eb3f9afe5fae3778a6..5aa5257c45e70e8cbddc993c29df10203163e9a6 100644
--- a/docs/source/concepts/ComponentInfo.rst
+++ b/docs/source/concepts/ComponentInfo.rst
@@ -9,7 +9,26 @@ ComponentInfo
Introduction
------------
-``ComponentInfo`` provides faster and simpler access to instrument/beamline geometry as required by Mantid :ref:`Algorithms <Algorithm>` than was possible using :ref:`Instrument`. ``ComponentInfo`` and :ref:`DetectorInfo` are designed as full replacements to :ref:`Instrument`. At the time of writing, `ComponentInfo` is incomplete.
+``ComponentInfo`` provides faster and simpler access to instrument/beamline geometry as required by Mantid :ref:`Algorithms <Algorithm>` than was possible using :ref:`Instrument`. ``ComponentInfo`` and :ref:`DetectorInfo` are designed as full replacements to :ref:`Instrument`.
-Until complete, :ref:`Instrument Access Layers <InstrumentAccessLayers>` provides the best details on how `ComponentInfo` can be used in it's current state of implementation.
+:ref:`Instrument Access Layers <InstrumentAccessLayers>` provides details on how `DetectorInfo` interacts with other geometry access layers.
+
+Python Interface
+----------------
+
+Examples of using ``ComponentInfo`` in python
+
+Print indices of detectors in "bank1" that are masked
+
+.. code-block:: python
+
+ from mantid.simpleapi import CreateSampleWorkspace
+
+ ws = CreateSampleWorkspace()
+ comp_info = ws.componentInfo()
+ det_info = ws.detectorInfo()
+ bank_index compinfo.indexOfAny('bank1')
+ for det_index in compinfo.detectorsInSubtree(bank_index):
+ if det_info.isMasked(int(det_index)):
+ print('Masked detector of bank1, ', det_index)
diff --git a/docs/source/concepts/DetectorInfo.rst b/docs/source/concepts/DetectorInfo.rst
index 9af68a98968c52cbe8d17ea303e5fa9c72ada3f9..a7e6783b04c445f992e6565ddc7c6f74a62cd3fb 100644
--- a/docs/source/concepts/DetectorInfo.rst
+++ b/docs/source/concepts/DetectorInfo.rst
@@ -9,6 +9,37 @@ DetectorInfo
Introduction
------------
-``DetectorInfo`` provides faster and simpler access to instrument/beamline detector geometry and metadata as required by Mantid :ref:`Algorithms <Algorithm>` than was possible using :ref:`Instrument`. ``DetectorInfo`` and :ref:`ComponentInfo` are designed as full replacements to :ref:`Instrument`. At the time of writing, `DetectorInfo` is incomplete.
+``DetectorInfo`` provides faster and simpler access to instrument/beamline detector geometry and metadata as required by Mantid :ref:`Algorithms <Algorithm>` than was possible using :ref:`Instrument`. ``DetectorInfo`` and :ref:`ComponentInfo` are designed as full replacements to :ref:`Instrument`.
-Until complete, :ref:`Instrument Access Layers <InstrumentAccessLayers>` provides the best details on how `DetectorInfo` can be used in it's current state of implementation.
+:ref:`Instrument Access Layers <InstrumentAccessLayers>` provides details on how `DetectorInfo` interacts with other geometry access layers.
+
+Python Interface
+----------------
+
+Examples of using ``DetectorInfo`` in python
+
+Mask detectors at some distance from the source
+
+.. code-block:: python
+
+ from mantid.simpleapi import CreateSampleWorkspace
+
+ # Test workspace with instrument
+ ws = CreateSampleWorkspace()
+ det_info = ws.detectorInfo();
+ for item in det_info:
+ if not item.isMonitor and item.l2 > 2.0:
+ item.setMasked(True)
+
+Print detectors with scattering angle
+
+.. code-block:: python
+
+ from mantid.simpleapi import CreateSampleWorkspace
+
+ # Test workspace with instrument
+ ws = CreateSampleWorkspace()
+ det_info = ws.detectorInfo()
+ for item in det_info:
+ if item.l2 > 0.01:
+ print(item.index)
diff --git a/docs/source/concepts/InstrumentAccessLayers.rst b/docs/source/concepts/InstrumentAccessLayers.rst
index 65543664651ed6df60ae362c3e608b141c585e92..7161ca559b38b64f7c4f8b0704ced739cd6f4eac 100644
--- a/docs/source/concepts/InstrumentAccessLayers.rst
+++ b/docs/source/concepts/InstrumentAccessLayers.rst
@@ -37,12 +37,20 @@ There is also a near-complete implementation of the "real" ``DetectorInfo`` clas
``ExperimentInfo`` now also provides a method ``mutableDetectorInfo()`` so that non-const access to the DetectorInfo is possible for purposes of writing detector related information such as positions or rotations.
+The python interface to ``DetectorInfo`` has matured, and includes widespread immutable access via iterators. The iterators can also be used to set masking flags.
+
+See :ref:`DetectorInfo <DetectorInfo>` for more information.
+
ComponentInfo
______________
``ComponentInfo`` can be obtatined from a call to ``ExperimentInfo::componentInfo()`` (usually this method would be called on ``MatrixWorkspace``). Much like ``DetectorInfo``, the ``ComponentInfo`` yielded from this method call is a wrapper, which contains shape and index information, that cannot yet be moved in to the real ``Beamline::ComponentInfo``. However, replacing existing usage of ``IComponent`` and ``IObjComponent`` wherever possible with ``ComponentInfo`` across the framework will represent a major step forwards.
For writing to the component tree. You can extract a non-const ``ComponentInfo`` via ``ExperimentInfo::mutableComponentInfo``.
+The python interface to ``ComponentInfo`` has matured, and now provides equal, if not better support than the ``Instrument`` API for navigating the high-level instrument. Iterator support has also been provided for ``ComponentInfo``.
+
+See :ref:`ComponentInfo <ComponentInfo>` for more information.
+
Changes for Rollout
-------------------
diff --git a/docs/source/release/v3.14.0/framework.rst b/docs/source/release/v3.14.0/framework.rst
index b307c9daf7d01f1c7f7169f05960c942fb115c87..9aac202867f903faf57ca6d1b3f1b22fe7b4048d 100644
--- a/docs/source/release/v3.14.0/framework.rst
+++ b/docs/source/release/v3.14.0/framework.rst
@@ -126,8 +126,8 @@ New
* :class:`mantid.geometry.DetectorInfo`
* :class:`mantid.api.SpectrumInfo`
-- :class:`mantid.geometry.ComponentInfo` is exposed to allow the user to access geometric information about the components which are part of a beamline.
-- :class:`mantid.geometry.DetectorInfo` offers the user the ability to access geometric information about the detector(s) which are part of a beamline. ``DetectorInfo`` has also been given an iterator to allow users to write more Pythonic loops rather than normal index based loops.
+- :class:`mantid.geometry.ComponentInfo` is exposed to allow the user to access geometric information about the components which are part of a beamline. Iterator support is also provided via python.
+- :class:`mantid.geometry.DetectorInfo` offers the user the ability to access geometric information about the detector(s) which are part of a beamline. ``DetectorInfo`` has also been given a python iterator.
- :class:`mantid.api.SpectrumInfo` allows the user to access information about the spectra being used in a beamline. ``SpectrumInfo`` has also been given an iterator to allow users to write more Pythonic loops rather than normal index based loops. In addition to this ``SpectrumDefinition`` objects can also be accessed via a :class:`mantid.api.SpectrumInfo` object. The ``SpectrumDefinition`` object can be used to obtain information about the spectrum to detector mapping and provides a definition of what a spectrum comprises, i.e. indices of all detectors that contribute to the data stored in the spectrum.
- Added new :ref:`unit <Unit Factory>` called ``Temperature`` which has units of Kelvin.
- Importing ``mantid`` no longer initializes the ``FrameworkManager``. This allows separate classes to be imported without requiring a long delay in waiting for the framework to start. Amongst other things this allows the application name to be set correctly: