From cd8c18f10ca81ac379dc767085fda5b9d2d5de6d Mon Sep 17 00:00:00 2001
From: Owen Arnold <owen.arnold@stfc.ac.uk>
Date: Mon, 20 Apr 2015 09:35:12 +0100
Subject: [PATCH] refs #11573. One failing test.
New algorithm added
Some tests implemented
MDBoxImplicitFunction updated and tested
MDIterator updated to give bounding box extents
Last change should be key to fixing current failing test.
---
.../MDHistoWorkspaceIterator.h | 9 +-
.../src/MDHistoWorkspaceIterator.cpp | 24 +-
.../test/MDHistoWorkspaceIteratorTest.h | 85 ++++++
.../Framework/MDAlgorithms/CMakeLists.txt | 3 +
.../IntegrateMDHistoWorkspace.h | 60 ++++
.../Framework/MDAlgorithms/src/CutMD.cpp | 2 -
.../src/IntegrateMDHistoWorkspace.cpp | 258 +++++++++++++++++
.../test/IntegrateMDHistoWorkspaceTest.h | 264 ++++++++++++++++++
.../IntegrateMDHistoWorkspace-v1.rst | 44 +++
9 files changed, 745 insertions(+), 4 deletions(-)
create mode 100644 Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/IntegrateMDHistoWorkspace.h
create mode 100644 Code/Mantid/Framework/MDAlgorithms/src/IntegrateMDHistoWorkspace.cpp
create mode 100644 Code/Mantid/Framework/MDAlgorithms/test/IntegrateMDHistoWorkspaceTest.h
create mode 100644 Code/Mantid/docs/source/algorithms/IntegrateMDHistoWorkspace-v1.rst
diff --git a/Code/Mantid/Framework/DataObjects/inc/MantidDataObjects/MDHistoWorkspaceIterator.h b/Code/Mantid/Framework/DataObjects/inc/MantidDataObjects/MDHistoWorkspaceIterator.h
index 5a914cbb28f..c575ef0800c 100644
--- a/Code/Mantid/Framework/DataObjects/inc/MantidDataObjects/MDHistoWorkspaceIterator.h
+++ b/Code/Mantid/Framework/DataObjects/inc/MantidDataObjects/MDHistoWorkspaceIterator.h
@@ -8,12 +8,17 @@
#include "MantidDataObjects/SkippingPolicy.h"
#include <map>
#include <vector>
+#include <boost/tuple/tuple.hpp>
namespace Mantid {
namespace DataObjects {
-// Typdef for a map for mapping width of neighbours (key) to permutations needed in the calcualtion.
+// Typedef for a map for mapping width of neighbours (key) to permutations needed in the calcualtion.
typedef std::map<std::vector<int>, std::vector<int64_t> > PermutationsMap;
+// Typedef for extents
+typedef boost::tuple<Mantid::coord_t, Mantid::coord_t> MDExtentPair; // Min/Max pair
+// Typedef for vector of extents
+typedef std::vector<MDExtentPair> VecMDExtents;
/** An implementation of IMDIterator that iterates through
a MDHistoWorkspace. It treats the bin in the workspace as
@@ -94,6 +99,8 @@ public:
virtual Mantid::Kernel::VMD getCenter() const;
+ virtual VecMDExtents getBoxExtents() const;
+
virtual size_t getNumEvents() const;
virtual uint16_t getInnerRunIndex(size_t index) const;
diff --git a/Code/Mantid/Framework/DataObjects/src/MDHistoWorkspaceIterator.cpp b/Code/Mantid/Framework/DataObjects/src/MDHistoWorkspaceIterator.cpp
index c3040561489..9b2c7f4b1f8 100644
--- a/Code/Mantid/Framework/DataObjects/src/MDHistoWorkspaceIterator.cpp
+++ b/Code/Mantid/Framework/DataObjects/src/MDHistoWorkspaceIterator.cpp
@@ -323,11 +323,33 @@ Mantid::Kernel::VMD MDHistoWorkspaceIterator::getCenter() const {
Utils::NestedForLoop::GetIndicesFromLinearIndex(m_nd, m_pos, m_indexMaker,
m_indexMax, m_index);
// Find the center
- for (size_t d = 0; d < m_nd; d++)
+ for (size_t d = 0; d < m_nd; ++d) {
m_center[d] = m_origin[d] + (coord_t(m_index[d]) + 0.5f) * m_binWidth[d];
+ }
return VMD(m_nd, m_center);
}
+/**
+ * Get the extents in n-dimensions corresponding to the position of the box of the current iterator.
+ * @return pairs of min/max extents.
+ */
+VecMDExtents MDHistoWorkspaceIterator::getBoxExtents() const
+{
+
+ // Get the indexes.
+ Utils::NestedForLoop::GetIndicesFromLinearIndex(m_nd, m_pos, m_indexMaker,
+ m_indexMax, m_index);
+ VecMDExtents extents(m_nd);
+ // Find the extents.
+ for (size_t d = 0; d < m_nd; ++d) {
+ const coord_t min = m_origin[d] + coord_t(m_index[d]) * m_binWidth[d]; // Min in d
+ const coord_t max = min + m_binWidth[d]; // Max in d
+ extents[d] = MDExtentPair(min, max);
+ }
+
+ return extents;
+}
+
//----------------------------------------------------------------------------------------------
/// Returns the number of events/points contained in this box
/// @return 1 always: e.g. there is one (fake) event in the middle of the box.
diff --git a/Code/Mantid/Framework/DataObjects/test/MDHistoWorkspaceIteratorTest.h b/Code/Mantid/Framework/DataObjects/test/MDHistoWorkspaceIteratorTest.h
index e39b618a815..d4551f0866e 100644
--- a/Code/Mantid/Framework/DataObjects/test/MDHistoWorkspaceIteratorTest.h
+++ b/Code/Mantid/Framework/DataObjects/test/MDHistoWorkspaceIteratorTest.h
@@ -109,6 +109,7 @@ public:
it->jumpTo(i);
TS_ASSERT_DELTA( it->getNormalizedSignal(), double(i) / 1.0, 1e-5);
}
+ delete it;
}
void test_iterator_1D()
@@ -163,6 +164,7 @@ public:
it->next();
TS_ASSERT_EQUALS(it->getNormalizedSignal(), 30.);
TS_ASSERT( !it->next());
+ delete it;
}
void test_iterator_2D_implicitFunction_thatExcludesTheStart()
@@ -192,6 +194,7 @@ public:
TS_ASSERT_EQUALS(it->getNormalizedSignal(), 13.);
it->next();
// And so forth....
+ delete it;
}
void test_iterator_2D_implicitFunction_thatExcludesEverything()
@@ -206,6 +209,8 @@ public:
MDHistoWorkspaceIterator * it = new MDHistoWorkspaceIterator(ws, function);
TSM_ASSERT( "This iterator is not valid at the start.", !it->valid());
+
+ delete it;
}
/** Create several parallel iterators */
@@ -240,6 +245,7 @@ public:
TS_ASSERT_DELTA( it->getInnerPosition(0,0), 6.5, 1e-5);
TS_ASSERT_DELTA( it->getInnerPosition(0,1), 6.5, 1e-5);
+ delete it;
}
void test_predictable_steps()
@@ -254,6 +260,7 @@ public:
expected = current + 1;
histoIt->next();
}
+ delete histoIt;
}
void test_skip_masked_detectors()
@@ -278,6 +285,8 @@ public:
histoIt->next();
TSM_ASSERT_EQUALS("The first index hit should be 2 since that is the first unmasked one", 5,
histoIt->getLinearIndex());
+
+ delete histoIt;
}
//template<typename ContainerType, typename ElementType>
@@ -350,6 +359,7 @@ public:
neighbourIndexes = findNeighbourMemberFunction(it);
TSM_ASSERT( "Neighbour at index 9 is 8", doesContainIndex(neighbourIndexes, 8));
+ delete it;
}
void test_neighbours_1d_face_touching()
@@ -436,6 +446,8 @@ public:
// Is on an edge
TSM_ASSERT( "Neighbour at index 15 is 11", doesContainIndex(neighbourIndexes, 11));
TSM_ASSERT( "Neighbour at index 15 is 14", doesContainIndex(neighbourIndexes, 14));
+
+ delete it;
}
void test_neighbours_2d_vertex_touching()
@@ -516,6 +528,8 @@ public:
TSM_ASSERT( "Neighbour at index 15 is 10", doesContainIndex(neighbourIndexes, 10));
TSM_ASSERT( "Neighbour at index 15 is 11", doesContainIndex(neighbourIndexes, 11));
TSM_ASSERT( "Neighbour at index 15 is 14", doesContainIndex(neighbourIndexes, 14));
+
+ delete it;
}
void test_neighbours_3d_face_touching()
@@ -592,6 +606,7 @@ public:
TS_ASSERT(doesContainIndex(neighbourIndexes, *i));
}
+ delete it;
}
void test_neighbours_3d_vertex_touching()
@@ -673,6 +688,8 @@ public:
TS_ASSERT(doesContainIndex(neighbourIndexes, *i));
}
+ delete it;
+
}
void test_neighbours_1d_with_width()
@@ -730,6 +747,8 @@ public:
TS_ASSERT_EQUALS(2, neighbourIndexes.size());
TSM_ASSERT( "Neighbours at index 9 includes 8", doesContainIndex(neighbourIndexes, 8));
TSM_ASSERT( "Neighbours at index 9 includes 7", doesContainIndex(neighbourIndexes, 7));
+
+ delete it;
}
void test_neighbours_2d_vertex_touching_by_width()
@@ -808,6 +827,8 @@ public:
TSM_ASSERT( "Neighbour at index is 11", doesContainIndex(neighbourIndexes, 11));
TSM_ASSERT( "Neighbour at index is 13", doesContainIndex(neighbourIndexes, 13));
TSM_ASSERT( "Neighbour at index is 14", doesContainIndex(neighbourIndexes, 14));
+
+ delete it;
}
void test_neighbours_2d_vertex_touching_by_width_vector()
@@ -884,6 +905,8 @@ public:
TSM_ASSERT( "Neighbour at index is 11", doesContainIndex(neighbourIndexes, 11));
TSM_ASSERT( "Neighbour at index is 13", doesContainIndex(neighbourIndexes, 13));
TSM_ASSERT( "Neighbour at index is 14", doesContainIndex(neighbourIndexes, 14));
+
+ delete it;
}
@@ -939,6 +962,8 @@ public:
TS_ASSERT(doesContainIndex(neighbourIndexes, 24));
TS_ASSERT(doesContainIndex(neighbourIndexes, 25));
TS_ASSERT(doesContainIndex(neighbourIndexes, 26));
+
+ delete it;
}
void test_cache()
@@ -960,6 +985,62 @@ public:
TSM_ASSERT_EQUALS("One cache item expected", 1, it->permutationCacheSize()); // Same item, no change to cache
it->findNeighbourIndexesByWidth(5);
TSM_ASSERT_EQUALS("Two cache entries expected", 2, it->permutationCacheSize());
+
+ delete it;
+ }
+
+ void test_getBoxExtents_1d() {
+ const size_t nd = 1;
+ MDHistoWorkspace_sptr ws = MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0 /*signal*/, nd, 3 /*3 bins*/); // Dimension length defaults to 10
+ MDHistoWorkspaceIterator * it = new MDHistoWorkspaceIterator(ws);
+
+ // At zeroth position
+ VecMDExtents extents = it->getBoxExtents();
+ TSM_ASSERT_EQUALS("Wrong number of extents pairs. This is 1D.", 1, extents.size());
+ TS_ASSERT_DELTA(extents[0].get<0>(), 0, 1e-4);
+ TS_ASSERT_DELTA(extents[0].get<1>(), 10.0 * 1.0/3.0, 1e-4);
+
+ // At middle position
+ it->next();
+ extents = it->getBoxExtents();
+ TS_ASSERT_DELTA(extents[0].get<0>(), 10.0 * 1.0/3.0, 1e-4);
+ TS_ASSERT_DELTA(extents[0].get<1>(), 10.0 * 2.0/3.0, 1e-4);
+
+ // At end position
+ it->next();
+ extents = it->getBoxExtents();
+ TS_ASSERT_DELTA(extents[0].get<0>(), 10.0 * 2.0/3.0, 1e-4);
+ TS_ASSERT_DELTA(extents[0].get<1>(), 10.0 * 3.0/3.0, 1e-4);
+
+ delete it;
+ }
+
+ void test_getBoxExtents_3d() {
+ MDHistoWorkspace_sptr ws = MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0 /*signal*/, 3 /*nd*/, 4 /*nbins per dim*/, 6 /*max*/, 1.0 /*error sq*/);
+ MDHistoWorkspaceIterator * it = new MDHistoWorkspaceIterator(ws);
+
+ // At zeroth position
+ VecMDExtents extents = it->getBoxExtents();
+ TSM_ASSERT_EQUALS("Wrong number of extents pairs. This is 3D.", 3, extents.size());
+ TS_ASSERT_DELTA(extents[0].get<0>(), 0, 1e-4);
+ TS_ASSERT_DELTA(extents[0].get<1>(), 6.0/4.0, 1e-4);
+ TS_ASSERT_DELTA(extents[1].get<0>(), 0, 1e-4);
+ TS_ASSERT_DELTA(extents[1].get<1>(), 6.0/4.0, 1e-4);
+ TS_ASSERT_DELTA(extents[2].get<0>(), 0, 1e-4);
+ TS_ASSERT_DELTA(extents[2].get<1>(), 6.0/4.0, 1e-4);
+
+ // At last position
+ it->jumpTo((4*4*4) - 1);
+ extents = it->getBoxExtents();
+ TSM_ASSERT_EQUALS("Wrong number of extents pairs. This is 3D.", 3, extents.size());
+ TS_ASSERT_DELTA(extents[0].get<0>(), 3.0/4 * 6.0, 1e-4);
+ TS_ASSERT_DELTA(extents[0].get<1>(), 4.0/4 * 6.0, 1e-4);
+ TS_ASSERT_DELTA(extents[1].get<0>(), 3.0/4 * 6.0, 1e-4);
+ TS_ASSERT_DELTA(extents[1].get<1>(), 4.0/4 * 6.0, 1e-4);
+ TS_ASSERT_DELTA(extents[2].get<0>(), 3.0/4 * 6.0, 1e-4);
+ TS_ASSERT_DELTA(extents[2].get<1>(), 4.0/4 * 6.0, 1e-4);
+
+ delete it;
}
@@ -1001,6 +1082,7 @@ public:
UNUSED_ARG(sig);
UNUSED_ARG(err);
} while (it->next());
+ delete it;
}
/** ~Two million iterations */
@@ -1017,6 +1099,7 @@ public:
UNUSED_ARG(sig);
UNUSED_ARG(err);
} while (it->next());
+ delete it;
}
/** ~Two million iterations */
@@ -1031,6 +1114,7 @@ public:
UNUSED_ARG(sig);
UNUSED_ARG(err);
} while (it->next());
+ delete it;
}
/** Use jumpTo() */
@@ -1047,6 +1131,7 @@ public:
UNUSED_ARG(sig);
UNUSED_ARG(err);
}
+ delete it;
}
void test_masked_get_vertexes_call_throws()
diff --git a/Code/Mantid/Framework/MDAlgorithms/CMakeLists.txt b/Code/Mantid/Framework/MDAlgorithms/CMakeLists.txt
index 7cb309bcc7d..794a66a7018 100644
--- a/Code/Mantid/Framework/MDAlgorithms/CMakeLists.txt
+++ b/Code/Mantid/Framework/MDAlgorithms/CMakeLists.txt
@@ -48,6 +48,7 @@ set ( SRC_FILES
src/Integrate3DEvents.cpp
src/IntegrateEllipsoids.cpp
src/IntegrateFlux.cpp
+ src/IntegrateMDHistoWorkspace.cpp
src/IntegratePeaksMD.cpp
src/IntegratePeaksMD2.cpp
src/InvalidParameter.cpp
@@ -165,6 +166,7 @@ set ( INC_FILES
inc/MantidMDAlgorithms/Integrate3DEvents.h
inc/MantidMDAlgorithms/IntegrateEllipsoids.h
inc/MantidMDAlgorithms/IntegrateFlux.h
+ inc/MantidMDAlgorithms/IntegrateMDHistoWorkspace.h
inc/MantidMDAlgorithms/IntegratePeaksMD.h
inc/MantidMDAlgorithms/IntegratePeaksMD2.h
inc/MantidMDAlgorithms/InvalidParameter.h
@@ -279,6 +281,7 @@ set ( TEST_FILES
Integrate3DEventsTest.h
IntegrateEllipsoidsTest.h
IntegrateFluxTest.h
+ IntegrateMDHistoWorkspaceTest.h
IntegratePeaksMD2Test.h
IntegratePeaksMDTest.h
InvalidParameterParserTest.h
diff --git a/Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/IntegrateMDHistoWorkspace.h b/Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/IntegrateMDHistoWorkspace.h
new file mode 100644
index 00000000000..b967666e189
--- /dev/null
+++ b/Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/IntegrateMDHistoWorkspace.h
@@ -0,0 +1,60 @@
+#ifndef MANTID_MDALGORITHMS_INTEGRATEMDHISTOWORKSPACE_H_
+#define MANTID_MDALGORITHMS_INTEGRATEMDHISTOWORKSPACE_H_
+
+#include "MantidKernel/System.h"
+#include "MantidAPI/Algorithm.h"
+
+#include <vector>
+
+namespace Mantid
+{
+namespace MDAlgorithms
+{
+
+ /** IntegrateMDHistoWorkspace : Algorithm to perform axis aligned integration of an MDHistoWorkspace.
+
+ Copyright © 2015 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge National Laboratory & European Spallation Source
+
+ This file is part of Mantid.
+
+ Mantid is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ Mantid is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ File change history is stored at: <https://github.com/mantidproject/mantid>
+ Code Documentation is available at: <http://doxygen.mantidproject.org>
+ */
+ class DLLExport IntegrateMDHistoWorkspace : public API::Algorithm
+ {
+ public:
+ IntegrateMDHistoWorkspace();
+ virtual ~IntegrateMDHistoWorkspace();
+
+ virtual const std::string name() const;
+ virtual int version() const;
+ virtual const std::string category() const;
+ virtual const std::string summary() const;
+ virtual std::map<std::string, std::string> validateInputs();
+
+ private:
+
+ void init();
+ void exec();
+
+
+ };
+
+
+} // namespace MDAlgorithms
+} // namespace Mantid
+
+#endif /* MANTID_MDALGORITHMS_INTEGRATEMDHISTOWORKSPACE_H_ */
diff --git a/Code/Mantid/Framework/MDAlgorithms/src/CutMD.cpp b/Code/Mantid/Framework/MDAlgorithms/src/CutMD.cpp
index 3deac2121df..09f1818940a 100644
--- a/Code/Mantid/Framework/MDAlgorithms/src/CutMD.cpp
+++ b/Code/Mantid/Framework/MDAlgorithms/src/CutMD.cpp
@@ -220,8 +220,6 @@ void CutMD::init() {
"as output. True to create an "
"MDHistoWorkspace as output. This is DND "
"only in Horace terminology.");
- declareProperty("CheckAxes", true,
- "Check that the axis look to be correct, and abort if not.");
}
void CutMD::exec() {
diff --git a/Code/Mantid/Framework/MDAlgorithms/src/IntegrateMDHistoWorkspace.cpp b/Code/Mantid/Framework/MDAlgorithms/src/IntegrateMDHistoWorkspace.cpp
new file mode 100644
index 00000000000..c3c44eadec3
--- /dev/null
+++ b/Code/Mantid/Framework/MDAlgorithms/src/IntegrateMDHistoWorkspace.cpp
@@ -0,0 +1,258 @@
+#include "MantidMDAlgorithms/IntegrateMDHistoWorkspace.h"
+#include "MantidKernel/ArrayProperty.h"
+
+#include "MantidAPI/IMDHistoWorkspace.h"
+#include "MantidAPI/IMDIterator.h"
+
+#include "MantidGeometry/MDGeometry/MDHistoDimension.h"
+#include "MantidGeometry/MDGeometry/MDBoxImplicitFunction.h"
+#include "MantidDataObjects/MDHistoWorkspace.h"
+#include "MantidDataObjects/MDHistoWorkspaceIterator.h"
+
+#include <algorithm>
+#include <map>
+#include <utility>
+
+#include <boost/make_shared.hpp>
+#include <boost/scoped_ptr.hpp>
+
+
+using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Geometry;
+using namespace Mantid::DataObjects;
+
+namespace {
+
+/**
+ * Check for empty binning
+ * @param binning : binning
+ * @return : true if binning is empty
+ */
+bool emptyBinning(const std::vector<double>& binning) {
+ return binning.empty();
+}
+
+/**
+ * Determine whether the binning provided is any good.
+ * @param binning : Binning property
+ * @return : string containing error. Or empty for no error.
+ */
+std::string checkBinning(const std::vector<double>& binning)
+{
+ std::string error; // No error.
+ if(!emptyBinning(binning) && binning.size() != 2)
+ {
+ error = "You may only integrate out dimensions between limits.";
+ }
+ else if(binning.size() == 2)
+ {
+ auto min = binning[0];
+ auto max = binning[1];
+ if(min >= max) {
+ error = "min must be < max limit for binning";
+ }
+ }
+ return error;
+}
+
+/**
+ * Create the output workspace in the right shape.
+ * @param inWS : Input workspace for dimensionality
+ * @param pbins : User provided binning
+ * @return
+ */
+MDHistoWorkspace_sptr createShapedOutput(IMDHistoWorkspace const * const inWS, std::vector<std::vector<double>> pbins)
+{
+ const size_t nDims = inWS->getNumDims();
+ std::vector<Mantid::Geometry::IMDDimension_sptr> dimensions(nDims);
+ for(size_t i = 0; i < nDims; ++i) {
+
+ IMDDimension_const_sptr inDim = inWS->getDimension(i);
+ auto outDim = boost::make_shared<MDHistoDimension>(inDim.get());
+ // Apply dimensions as inputs.
+ if(i < pbins.size() && !emptyBinning(pbins[i]))
+ {
+ auto binning = pbins[i];
+ outDim->setRange(1 /*single bin*/, static_cast<Mantid::coord_t>(binning.front()) /*min*/, static_cast<Mantid::coord_t>(binning.back()) /*max*/); // Set custom min, max and nbins.
+ }
+ dimensions[i] = outDim;
+ }
+ return MDHistoWorkspace_sptr(new MDHistoWorkspace(dimensions));
+}
+
+}
+
+namespace Mantid
+{
+namespace MDAlgorithms
+{
+
+ using Mantid::Kernel::Direction;
+ using Mantid::API::WorkspaceProperty;
+
+ // Register the algorithm into the AlgorithmFactory
+ DECLARE_ALGORITHM(IntegrateMDHistoWorkspace)
+
+
+
+ //----------------------------------------------------------------------------------------------
+ /** Constructor
+ */
+ IntegrateMDHistoWorkspace::IntegrateMDHistoWorkspace()
+ {
+ }
+
+ //----------------------------------------------------------------------------------------------
+ /** Destructor
+ */
+ IntegrateMDHistoWorkspace::~IntegrateMDHistoWorkspace()
+ {
+ }
+
+
+ //----------------------------------------------------------------------------------------------
+
+ /// Algorithms name for identification. @see Algorithm::name
+ const std::string IntegrateMDHistoWorkspace::name() const { return "IntegrateMDHistoWorkspace"; }
+
+ /// Algorithm's version for identification. @see Algorithm::version
+ int IntegrateMDHistoWorkspace::version() const { return 1;};
+
+ /// Algorithm's category for identification. @see Algorithm::category
+ const std::string IntegrateMDHistoWorkspace::category() const { return "MDAlgorithms";}
+
+ /// Algorithm's summary for use in the GUI and help. @see Algorithm::summary
+ const std::string IntegrateMDHistoWorkspace::summary() const { return "Performs axis aligned integration of MDHistoWorkspaces";}
+
+ //----------------------------------------------------------------------------------------------
+ /** Initialize the algorithm's properties.
+ */
+ void IntegrateMDHistoWorkspace::init()
+ {
+ declareProperty(new WorkspaceProperty<IMDHistoWorkspace>("InputWorkspace","",Direction::Input), "An input workspace.");
+
+ const std::vector<double> defaultBinning;
+ declareProperty(new ArrayProperty<double>("P1Bin", defaultBinning), "Projection 1 binning.");
+ declareProperty(new ArrayProperty<double>("P2Bin", defaultBinning), "Projection 2 binning.");
+ declareProperty(new ArrayProperty<double>("P3Bin", defaultBinning), "Projection 3 binning.");
+ declareProperty(new ArrayProperty<double>("P4Bin", defaultBinning), "Projection 4 binning.");
+ declareProperty(new ArrayProperty<double>("P5Bin", defaultBinning), "Projection 5 binning.");
+
+ declareProperty(new WorkspaceProperty<IMDHistoWorkspace>("OutputWorkspace","",Direction::Output), "An output workspace.");
+ }
+
+ //----------------------------------------------------------------------------------------------
+ /** Execute the algorithm.
+ */
+ void IntegrateMDHistoWorkspace::exec()
+ {
+ IMDHistoWorkspace_sptr inWS = this->getProperty("InputWorkspace");
+ const size_t nDims = inWS->getNumDims();
+ std::vector<std::vector<double>> pbins(5);
+ pbins[0] = this->getProperty("P1Bin");
+ pbins[1] = this->getProperty("P2Bin");
+ pbins[2] = this->getProperty("P3Bin");
+ pbins[3] = this->getProperty("P4Bin");
+ pbins[4] = this->getProperty("P5Bin");
+
+ IMDHistoWorkspace_sptr outWS;
+ const size_t emptyCount = std::count_if(pbins.begin(), pbins.end(), emptyBinning);
+ if (emptyCount == pbins.size()) {
+ // No work to do.
+ g_log.information(this->name() + " Direct clone of input.");
+ outWS = inWS->clone();
+ }
+ else {
+
+ // Create the output workspace in the right shape. Required for iteration.
+ outWS = createShapedOutput(inWS.get(), pbins);
+
+ auto temp = outWS->getDimension(0)->getNBins();
+ auto temp1 = inWS->getDimension(0)->getNBins();
+
+ // Store in each dimension
+ std::vector<Mantid::coord_t> binWidths(nDims);
+ for(size_t i = 0; i < nDims; ++i) {
+ binWidths[i] = outWS->getDimension(i)->getBinWidth();
+ }
+
+ boost::scoped_ptr<MDHistoWorkspaceIterator> outIterator(
+ dynamic_cast<MDHistoWorkspaceIterator *>(outWS->createIterator()));
+
+ boost::scoped_ptr<MDHistoWorkspaceIterator> inIterator(
+ dynamic_cast<MDHistoWorkspaceIterator *>(inWS->createIterator()));
+
+ do {
+ // Getting the center will allow us to calculate only local neighbours to consider.
+ Mantid::Kernel::VMD iteratorCenter = outIterator->getCenter();
+
+ std::vector<Mantid::coord_t> mins(nDims);
+ std::vector<Mantid::coord_t> maxs(nDims);
+ for(size_t i = 0; i < nDims; ++i) {
+ const coord_t delta = binWidths[i]/2;
+ mins[i] = iteratorCenter[i] - delta;
+ maxs[i] = iteratorCenter[i] + delta;
+ }
+ MDBoxImplicitFunction box(mins, maxs);
+
+ /* TODO a better approach to the nested loop would be to
+ 1) Find the closest inIterator position to the outIterator position.
+ 2) Move the inIterator to that position
+ 3) Using the ratio of outWidth[d]/inWidth[2] calculate the width in pixels of neighbours the inIterator would need to look at to cover the same region in n-d
+ space as the outIterator.
+ 4) use inIterator->findNeighboursByWidth to get those indexes
+ 5) Apply the MDBoxImplicitFunction ONLY over those bins of the input workspace rather that the whole workspace.
+ */
+
+ double sumSignal = 0;
+ double sumSQErrors = 0;
+ const size_t iteratorIndex = outIterator->getLinearIndex();
+ do {
+ size_t numVertices;
+ Mantid::coord_t* const vertexes = inIterator->getVertexesArray(numVertices);
+ const double weight = box.fraction(vertexes, numVertices); // TODO not ideal because vertices need to be sorted to get min max in this function. could we calculate this better?
+ sumSignal += weight * inIterator->getSignal();
+ sumSQErrors += weight * (inIterator->getError() * inIterator->getError());
+ std::cout << "index " << inIterator->getLinearIndex() << " x " << weight << std::endl;
+ } while(inIterator->next());
+
+ std::cout << "outer index " << iteratorIndex << std::endl << std::endl;
+
+
+ outWS->setSignalAt(iteratorIndex, sumSignal);
+ outWS->setErrorSquaredAt(iteratorIndex, sumSQErrors);
+
+ } while(outIterator->next());
+
+ }
+
+ this->setProperty("OutputWorkspace", outWS);
+ }
+
+ /**
+ * Overriden validate inputs
+ * @return map of property names to problems for bad inputs
+ */
+ std::map<std::string, std::string> Mantid::MDAlgorithms::IntegrateMDHistoWorkspace::validateInputs()
+ {
+ // Check binning parameters
+ std::map<std::string, std::string> errors;
+
+ for(int i = 1; i < 6; ++i) {
+ std::stringstream propBuffer;
+ propBuffer << "P" << i << "Bin";
+ std::string propertyName = propBuffer.str();
+ std::vector<double> binning = this->getProperty(propertyName);
+ std::string result = checkBinning(binning);
+ if(!result.empty()) {
+ errors.insert(std::make_pair(propertyName, result));
+ }
+ }
+ return errors;
+ }
+
+
+
+} // namespace MDAlgorithms
+} // namespace Mantid
diff --git a/Code/Mantid/Framework/MDAlgorithms/test/IntegrateMDHistoWorkspaceTest.h b/Code/Mantid/Framework/MDAlgorithms/test/IntegrateMDHistoWorkspaceTest.h
new file mode 100644
index 00000000000..caf4bf3c2c7
--- /dev/null
+++ b/Code/Mantid/Framework/MDAlgorithms/test/IntegrateMDHistoWorkspaceTest.h
@@ -0,0 +1,264 @@
+#ifndef MANTID_MDALGORITHMS_INTEGRATEMDHISTOWORKSPACETEST_H_
+#define MANTID_MDALGORITHMS_INTEGRATEMDHISTOWORKSPACETEST_H_
+
+#include <cxxtest/TestSuite.h>
+#include <boost/assign/list_of.hpp>
+
+#include "MantidMDAlgorithms/IntegrateMDHistoWorkspace.h"
+#include "MantidDataObjects/MDEventWorkspace.h"
+#include "MantidTestHelpers/MDEventsTestHelper.h"
+
+using Mantid::MDAlgorithms::IntegrateMDHistoWorkspace;
+using namespace Mantid::API;
+
+//=====================================================================================
+// Functional Tests
+//=====================================================================================
+class IntegrateMDHistoWorkspaceTest : 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 IntegrateMDHistoWorkspaceTest *createSuite() { return new IntegrateMDHistoWorkspaceTest(); }
+ static void destroySuite( IntegrateMDHistoWorkspaceTest *suite ) { delete suite; }
+
+
+ void test_Init()
+ {
+ IntegrateMDHistoWorkspace alg;
+ TS_ASSERT_THROWS_NOTHING( alg.initialize() );
+ TS_ASSERT( alg.isInitialized() );
+ }
+
+ void test_throw_if_new_steps_in_binning()
+ {
+ using namespace Mantid::DataObjects;
+ MDHistoWorkspace_sptr ws = MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0, 1 /*nd*/, 10);
+
+ IntegrateMDHistoWorkspace alg;
+ alg.setChild(true);
+ alg.setRethrows(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", ws);
+ const double step = 0.1;
+ alg.setProperty("P1Bin", boost::assign::list_of(0)(step)(1).convert_to_container<std::vector<double> >());
+ alg.setPropertyValue("OutputWorkspace", "dummy");
+ TSM_ASSERT("Expect validation errors", alg.validateInputs().size() > 0);
+ TSM_ASSERT_THROWS("No new steps allowed", alg.execute(), std::runtime_error&);
+ }
+
+ void test_throw_if_incorrect_binning_limits()
+ {
+ using namespace Mantid::DataObjects;
+ MDHistoWorkspace_sptr ws = MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0, 1 /*nd*/, 10);
+
+ IntegrateMDHistoWorkspace alg;
+ alg.setChild(true);
+ alg.setRethrows(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", ws);
+ alg.setPropertyValue("OutputWorkspace", "dummy");
+
+ const double min = 3;
+
+ // Test equal to
+ double max = min;
+ alg.setProperty("P1Bin", boost::assign::list_of(min)(max).convert_to_container<std::vector<double> >());
+ TSM_ASSERT("Expect validation errors", alg.validateInputs().size() > 0);
+ TSM_ASSERT_THROWS("Incorrect limits", alg.execute(), std::runtime_error&);
+
+ // Test less than
+ max = min - 0.01;
+ alg.setProperty("P1Bin", boost::assign::list_of(min)(max).convert_to_container<std::vector<double> >());
+ TSM_ASSERT("Expect validation errors", alg.validateInputs().size() > 0);
+ TSM_ASSERT_THROWS("Incorrect limits", alg.execute(), std::runtime_error&);
+ }
+
+ // Users may set all binning parameter to [] i.e. direct copy, no integration.
+ void xtest_exec_do_nothing_but_clone()
+ {
+ using namespace Mantid::DataObjects;
+ MDHistoWorkspace_sptr ws = MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0, 1 /*nd*/, 10);
+
+ IntegrateMDHistoWorkspace alg;
+ alg.setChild(true);
+ alg.setRethrows(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", ws);
+ alg.setPropertyValue("OutputWorkspace", "dummy");
+ alg.execute();
+ IMDHistoWorkspace_sptr outWS=alg.getProperty("OutputWorkspace");
+
+ // Quick check that output seems to be a copy of input.
+ TS_ASSERT_EQUALS(outWS->getNPoints(), ws->getNPoints());
+ TS_ASSERT_EQUALS(outWS->getNumDims(), ws->getNumDims());
+ TS_ASSERT_EQUALS(outWS->getSignalAt(0), ws->getSignalAt(0));
+ TS_ASSERT_EQUALS(outWS->getSignalAt(1), ws->getSignalAt(1));
+ }
+
+ void xtest_1D_integration_exact_binning()
+ {
+
+ /*
+
+ input
+ (x = 0) *|--|--|--|--|--|--|--|--|--|--|* (x = 10)
+ 1 1 1 1 1 1 1 1 1 1
+
+ output requested
+
+ (x = 0) *|--------------|* (x = 5)
+ 1 + 1 + 1 + 1 + 1 = 5 counts
+
+ */
+
+ using namespace Mantid::DataObjects;
+ MDHistoWorkspace_sptr ws = MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0 /*signal*/, 1 /*nd*/, 10 /*nbins*/, 10 /*max*/, 1.0 /*error sq*/);
+
+ IntegrateMDHistoWorkspace alg;
+ alg.setChild(true);
+ alg.setRethrows(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", ws);
+ const double min = 0;
+ const double max = 5;
+ alg.setProperty("P1Bin", boost::assign::list_of(min)(max).convert_to_container<std::vector<double> >());
+ alg.setPropertyValue("OutputWorkspace", "dummy");
+ alg.execute();
+ IMDHistoWorkspace_sptr outWS=alg.getProperty("OutputWorkspace");
+
+ // Quick check that output seems to have the right shape.
+ TSM_ASSERT_EQUALS("All integrated", 1, outWS->getNPoints());
+ auto dim = outWS->getDimension(0);
+ TS_ASSERT_EQUALS(min, dim->getMinimum());
+ TS_ASSERT_EQUALS(max, dim->getMaximum());
+
+ // Check the data.
+ TSM_ASSERT_DELTA("Wrong integrated value", 5.0, outWS->getSignalAt(0), 1e-4);
+ TSM_ASSERT_DELTA("Wrong error value", std::sqrt(5 * (ws->getErrorAt(0) * ws->getErrorAt(0))), outWS->getErrorAt(0), 1e-4);
+ }
+
+ void xtest_1D_integration_partial_binning_complex(){
+
+ /*
+
+ input
+ (x = 0) *|--|--|--|--|--|--|--|--|--|--|* (x = 10)
+ 1 1 1 1 1 1 1 1 1 1
+
+ output requested
+
+ (x = 0.75) *|--------------|* (x = 4.25)
+ 1/4 + 1 + + 1 + 1/4 = 3.5 counts
+
+ */
+
+
+ using namespace Mantid::DataObjects;
+ MDHistoWorkspace_sptr ws = MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0 /*signal*/, 1 /*nd*/, 10 /*nbins*/, 10 /*max*/, 1.0 /*error sq*/);
+
+ IntegrateMDHistoWorkspace alg;
+ alg.setChild(true);
+ alg.setRethrows(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", ws);
+ const double min = 0.75;
+ const double max = 4.25;
+ alg.setProperty("P1Bin", boost::assign::list_of(min)(max).convert_to_container<std::vector<double> >());
+ alg.setPropertyValue("OutputWorkspace", "dummy");
+ alg.execute();
+ IMDHistoWorkspace_sptr outWS=alg.getProperty("OutputWorkspace");
+
+ // Quick check that output seems to have the right shape.
+ TSM_ASSERT_EQUALS("All integrated", 1, outWS->getNPoints());
+ auto dim = outWS->getDimension(0);
+ TS_ASSERT_EQUALS(min, dim->getMinimum());
+ TS_ASSERT_EQUALS(max, dim->getMaximum());
+
+ // Check the data.
+ TSM_ASSERT_DELTA("Wrong integrated value", 3.5, outWS->getSignalAt(0), 1e-4);
+ TSM_ASSERT_DELTA("Wrong error value", std::sqrt(3.5 * (ws->getErrorAt(0) * ws->getErrorAt(0))), outWS->getErrorAt(0), 1e-4);
+ }
+
+ void test_2d_partial_binning() {
+
+ /*
+
+ Input filled with 1's binning = 1 in each dimension
+ ----------------------------- (10, 10)
+ | |
+ | |
+ | |
+ | |
+ | |
+ | |
+ | |
+ | |
+ | |
+ | |
+ -----------------------------
+ (0, 0)
+
+
+ Slice. Two vertical columns. Each 1 in width.
+
+ ----------------------------- (10, 10)
+ | |
+ | |
+ |__________________________ | (10, 7.1)
+ | | | ... |
+ | | | |
+ | | | |
+ | | | |
+ | | | |
+ |__________________________ | (10, 1.1)
+ | |
+ -----------------------------
+ (0, 0)
+
+ */
+
+ using namespace Mantid::DataObjects;
+ MDHistoWorkspace_sptr ws = MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0 /*signal*/, 2 /*nd*/, 10 /*nbins*/, 10 /*max*/, 1.0 /*error sq*/);
+
+ IntegrateMDHistoWorkspace alg;
+ alg.setChild(true);
+ alg.setRethrows(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", ws);
+ const double min = 1.1;
+ const double max = 7.1; // 7.1 - 1.1 = 6
+ alg.setProperty("P1Bin", std::vector<double>(0)); // Pass through. Do not change binning.
+ alg.setProperty("P2Bin", boost::assign::list_of(min)(max).convert_to_container<std::vector<double> >());
+ alg.setPropertyValue("OutputWorkspace", "dummy");
+ alg.execute();
+ IMDHistoWorkspace_sptr outWS=alg.getProperty("OutputWorkspace");
+
+ // Quick check that output seems to have the right shape.
+ TSM_ASSERT_EQUALS("All integrated", 10, outWS->getNPoints()); // one dimension unchanged the other integrated
+ auto intdim = outWS->getDimension(1);
+ TS_ASSERT_DELTA(min, intdim->getMinimum(), 1e-4);
+ TS_ASSERT_DELTA(max, intdim->getMaximum(), 1e-4);
+ TS_ASSERT_EQUALS(1, intdim->getNBins());
+ auto dim = outWS->getDimension(0);
+ TS_ASSERT_DELTA(0, dim->getMinimum(), 1e-4);
+ TS_ASSERT_DELTA(10, dim->getMaximum(), 1e-4);
+ TS_ASSERT_EQUALS(1, dim->getNBins());
+
+ // Check the data.
+ TSM_ASSERT_DELTA("Wrong integrated value", 6.0, outWS->getSignalAt(0), 1e-4);
+ TSM_ASSERT_DELTA("Wrong error value", std::sqrt(6.0 * (ws->getErrorAt(0) * ws->getErrorAt(0))), outWS->getErrorAt(0), 1e-4);
+
+ }
+
+
+
+
+};
+
+//=====================================================================================
+// Performance Tests
+//=====================================================================================
+
+
+#endif /* MANTID_MDALGORITHMS_INTEGRATEMDHISTOWORKSPACETEST_H_ */
diff --git a/Code/Mantid/docs/source/algorithms/IntegrateMDHistoWorkspace-v1.rst b/Code/Mantid/docs/source/algorithms/IntegrateMDHistoWorkspace-v1.rst
new file mode 100644
index 00000000000..159b0d5dbb7
--- /dev/null
+++ b/Code/Mantid/docs/source/algorithms/IntegrateMDHistoWorkspace-v1.rst
@@ -0,0 +1,44 @@
+
+.. algorithm::
+
+.. summary::
+
+.. alias::
+
+.. properties::
+
+Description
+-----------
+
+TODO: Enter a full rst-markup description of your algorithm here.
+
+
+Usage
+-----
+.. Try not to use files in your examples,
+ but if you cannot avoid it then the (small) files must be added to
+ autotestdata\UsageData and the following tag unindented
+ .. include:: ../usagedata-note.txt
+
+**Example - IntegrateMDHistoWorkspace**
+
+.. testcode:: IntegrateMDHistoWorkspaceExample
+
+ # Create a host workspace
+ ws = CreateWorkspace(DataX=range(0,3), DataY=(0,2))
+ or
+ ws = CreateSampleWorkspace()
+
+ wsOut = IntegrateMDHistoWorkspace()
+
+ # Print the result
+ print "The output workspace has %i spectra" % wsOut.getNumberHistograms()
+
+Output:
+
+.. testoutput:: IntegrateMDHistoWorkspaceExample
+
+ The output workspace has ?? spectra
+
+.. categories::
+
--
GitLab