diff --git a/Code/Mantid/Framework/MDEvents/CMakeLists.txt b/Code/Mantid/Framework/MDEvents/CMakeLists.txt
index 3efc105b65fc14e6947143a902c5eac8ac1e7fd1..f8586b93ae1ff2f6b2e5c444b668f598dff87692 100644
--- a/Code/Mantid/Framework/MDEvents/CMakeLists.txt
+++ b/Code/Mantid/Framework/MDEvents/CMakeLists.txt
@@ -6,6 +6,7 @@ set ( SRC_FILES
src/BoxController.cpp
src/CloneMDEventWorkspace.cpp
src/CoordTransform.cpp
+ src/CoordTransformAligned.cpp
src/CoordTransformDistance.cpp
src/CoordTransformDistanceParser.cpp
src/CoordTransformParser.cpp
@@ -49,6 +50,7 @@ set ( INC_FILES
inc/MantidMDEvents/BoxController.h
inc/MantidMDEvents/CloneMDEventWorkspace.h
inc/MantidMDEvents/CoordTransform.h
+ inc/MantidMDEvents/CoordTransformAligned.h
inc/MantidMDEvents/CoordTransformDistance.h
inc/MantidMDEvents/CoordTransformDistanceParser.h
inc/MantidMDEvents/CoordTransformParser.h
@@ -82,6 +84,7 @@ set ( TEST_FILES
test/AffineMatrixParameterTest.h
test/BoxControllerTest.h
test/CloneMDEventWorkspaceTest.h
+ test/CoordTransformAlignedTest.h
test/CoordTransformDistanceParserTest.h
test/CoordTransformDistanceTest.h
test/CoordTransformParserTest.h
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/BinToMDHistoWorkspace.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/BinToMDHistoWorkspace.h
index eb889ed89e8fc81d3089d60298e1c8490f24f8d3..a49c72a88891834ae7930c9cdf66ddd48a9ef84b 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/BinToMDHistoWorkspace.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/BinToMDHistoWorkspace.h
@@ -79,6 +79,9 @@ namespace MDEvents
/// Index of the dimension in the MDEW for the dimension in the output.
std::vector<size_t> dimensionToBinFrom;
+ /// Do we perform a coordinate transformation? NULL if no.
+ CoordTransform * m_transform;
+
/// Cached values for speed up
size_t numBD;
coord_t * min;
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransform.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransform.h
index d1ee8fcb42f2e37040d1a3353a7ef204fc5d7b08..a1b474eb2d14607ab561cd994ac5bcae3546b342 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransform.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransform.h
@@ -32,52 +32,35 @@ namespace MDEvents
*/
class DLLExport CoordTransform
{
- protected:
- /// Input number of dimensions
- InDimParameter inD;
- /// Output number of dimensions
- OutDimParameter outD;
-
- /** Affine Matrix to perform the transformation. The matrix has inD+1 columns, outD+1 rows.
- * By using an affine, translations and rotations (or other linear transforms) can be
- * combined by simply multiplying the matrices.
- */
- AffineMatrixParameter affineMatrixParameter;
public:
CoordTransform(const size_t inD, const size_t outD);
virtual ~CoordTransform();
virtual std::string toXMLString() const;
void addTranslation(const coord_t * translationVector);
- Mantid::Kernel::Matrix<coord_t> getMatrix() const;
- void setMatrix(const Mantid::Kernel::Matrix<coord_t> newMatrix);
+ const Mantid::Kernel::Matrix<coord_t> & getMatrix() const;
+ void setMatrix(const Mantid::Kernel::Matrix<coord_t> & newMatrix);
+
+ virtual void apply(const coord_t * inputVector, coord_t * outVector) const;
- //----------------------------------------------------------------------------------------------
- /** Apply the coordinate transformation
- *
- * @param inputVector :: fixed-size array of input coordinates, of size inD
- * @param outVector :: fixed-size array of output coordinates, of size outD
+ protected:
+ /// Input number of dimensions
+ size_t inD;
+
+ /// Output number of dimensions
+ size_t outD;
+
+ /** Affine Matrix to perform the transformation. The matrix has inD+1 columns, outD+1 rows.
+ * By using an affine, translations and rotations (or other linear transforms) can be
+ * combined by simply multiplying the matrices.
*/
- virtual void apply(const coord_t * inputVector, coord_t * outVector)
- {
- // For each output dimension
- for (size_t out = 0; out < outD.getValue(); ++out)
- {
- //Cache the row pointer to make the matrix access a bit faster
- coord_t * rawMatrixRow = affineMatrixParameter.getRawMatrix()[out];
- coord_t outVal = 0.0;
- size_t in;
- for (in = 0; in < inD.getValue(); ++in)
- outVal += rawMatrixRow[in] * inputVector[in];
+ Mantid::Kernel::Matrix<coord_t> affineMatrix;
- // The last input coordinate is "1" always (made homogenous coordinate out of the input x,y,etc.)
- outVal += rawMatrixRow[in];
- // Save in the output
- outVector[out] = outVal;
- }
- }
+ /// Raw pointer to the same underlying matrix as affineMatrix.
+ coord_t ** rawMatrix;
+ void copyRawMatrix();
};
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransformAligned.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransformAligned.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a7e191fcf1837959626be94c4118466c73f7124
--- /dev/null
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransformAligned.h
@@ -0,0 +1,66 @@
+#ifndef MANTID_MDEVENTS_COORDTRANSFORMALIGNED_H_
+#define MANTID_MDEVENTS_COORDTRANSFORMALIGNED_H_
+
+#include "MantidKernel/System.h"
+#include "MantidMDEvents/CoordTransform.h"
+#include "MantidAPI/VectorParameter.h"
+
+
+namespace Mantid
+{
+namespace MDEvents
+{
+
+ /// Unique type declaration for which dimensions are used in the input workspace
+ DECLARE_VECTOR_PARAMETER(DimensionsToBinFromParam, size_t);
+
+ /** A restricted version of CoordTransform which transforms
+ from one set of dimensions to another, allowing:
+
+ - An offset
+ - A reduction in the number of dimensions
+ - A scaling
+
+ While a normal Affine matrix would handle this case, this special
+ case is used in order to reduce the number of calculation.
+
+ @author Janik Zikovsky
+ @date 2011-08-29
+
+ Copyright © 2011 ISIS Rutherford Appleton Laboratory & NScD Oak Ridge National Laboratory
+
+ 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://svn.mantidproject.org/mantid/trunk/Code/Mantid>
+ Code Documentation is available at: <http://doxygen.mantidproject.org>
+ */
+ class DLLExport CoordTransformAligned : public CoordTransform
+ {
+ public:
+ CoordTransformAligned(const size_t inD, const size_t outD, const size_t * dimensionToBinFrom,
+ const coord_t * min, const coord_t * step);
+ virtual ~CoordTransformAligned();
+
+ protected:
+
+
+ };
+
+
+} // namespace MDEvents
+} // namespace Mantid
+
+#endif /* MANTID_MDEVENTS_COORDTRANSFORMALIGNED_H_ */
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransformDistance.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransformDistance.h
index 25cefdf5706c3c8f6851869af6edaa31ed3c3b5e..488172e3a5da4b1f1dc22b88486553472542ca0c 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransformDistance.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/CoordTransformDistance.h
@@ -33,27 +33,24 @@ namespace MDEvents
class DLLExport CoordTransformDistance : public CoordTransform
{
public:
- typedef boost::scoped_ptr<DimensionsUsedVectorParam> DimensionUsedVec_scptr;
- typedef boost::scoped_ptr<CoordCenterVectorParam> CoodCenterVec_scptr;
-
CoordTransformDistance(const size_t inD, const coord_t * center, const bool * dimensionsUsed);
virtual ~CoordTransformDistance();
virtual std::string toXMLString() const;
- virtual void apply(const coord_t * inputVector, coord_t * outVector);
+ void apply(const coord_t * inputVector, coord_t * outVector) const;
/// Return the center coordinate array
- const coord_t * getCenter() { return m_center->getPointerToStart(); }
+ const coord_t * getCenter() { return m_center; }
/// Return the dimensions used bool array
- const bool * getDimensionsUsed() { return m_dimensionsUsed->getPointerToStart(); }
+ const bool * getDimensionsUsed() { return m_dimensionsUsed; }
protected:
/// Coordinates at the center
- CoodCenterVec_scptr m_center;
+ coord_t * m_center;
/// Parmeter where True is set for those dimensions that are considered when calculating distance
- DimensionUsedVec_scptr m_dimensionsUsed;
+ bool * m_dimensionsUsed;
};
diff --git a/Code/Mantid/Framework/MDEvents/src/BinToMDHistoWorkspace.cpp b/Code/Mantid/Framework/MDEvents/src/BinToMDHistoWorkspace.cpp
index 38a166963fc3662510d89ff54f92e03850612d94..9768363d0d5947aae2b8fac1e2a4629afdf74fe6 100644
--- a/Code/Mantid/Framework/MDEvents/src/BinToMDHistoWorkspace.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/BinToMDHistoWorkspace.cpp
@@ -13,6 +13,10 @@
#include "MantidMDEvents/MDEventWorkspace.h"
#include "MantidMDEvents/MDHistoWorkspace.h"
#include <boost/algorithm/string.hpp>
+#include "MantidMDEvents/CoordTransformParser.h"
+#include <Poco/DOM/Element.h>
+#include <Poco/DOM/Document.h>
+#include <Poco/DOM/DOMParser.h>
using Mantid::Kernel::CPUTimer;
@@ -83,7 +87,12 @@ namespace MDEvents
"This may be faster for workspaces with few events and lots of output bins.");
declareProperty(new PropertyWithValue<bool>("Parallel",false,Direction::Input),
"Temporary parameter: true to run in parallel.");
+
+ declareProperty(new PropertyWithValue<std::string>("TransformationXML","",Direction::Input),
+ "XML string describing the coordinate transformation that converts from the MDEventWorkspace dimensions to the output dimensions.");
+
declareProperty(new WorkspaceProperty<Workspace>("OutputWorkspace","",Direction::Output), "A name for the output MDHistoWorkspace.");
+
}
@@ -216,6 +225,9 @@ namespace MDEvents
// If you get here, you could not determine that the entire box was in the same bin.
// So you need to iterate through events.
+ // An array to hold each event's coordinates, rotated/transformed
+ coord_t * transformedCenter = new coord_t[numBD];
+
const std::vector<MDE> & events = box->getConstEvents();
typename std::vector<MDE>::const_iterator it = events.begin();
typename std::vector<MDE>::const_iterator it_end = events.end();
@@ -258,6 +270,8 @@ namespace MDEvents
}
// Done with the events list
box->releaseEvents();
+
+ delete [] transformedCenter;
}
@@ -310,7 +324,7 @@ namespace MDEvents
// Total number of steps
size_t progNumSteps = 0;
- // Run the chunks in parallel. There is no overal in the output workspace so it is
+ // Run the chunks in parallel. There is no overlap in the output workspace so it is
// thread safe to write to it..
PRAGMA_OMP( parallel for schedule(dynamic,1) if (doParallel) )
for(int chunk=0; chunk < int(binDimensions[chunkDimension]->getNBins()); chunk += chunkNumBins)
@@ -372,7 +386,7 @@ namespace MDEvents
if (prog) prog->report();
}// for each box in the vector
- } // for each chunk
+ } // for each chunk in parallel
@@ -518,10 +532,21 @@ namespace MDEvents
std::string ImplicitFunctionXML = getPropertyValue("ImplicitFunctionXML");
implicitFunction = NULL;
if (!ImplicitFunctionXML.empty())
- {
implicitFunction = Mantid::API::ImplicitFunctionFactory::Instance().createUnwrapped(ImplicitFunctionXML);
+
+ // De-serialize the coordinate transformation XML string
+ std::string TransformationXML = getPropertyValue("TransformationXML");
+ m_transform = NULL;
+ if (!TransformationXML.empty())
+ {
+ Poco::XML::DOMParser pParser;
+ Poco::XML::Document* pDoc = pParser.parseString(TransformationXML);
+ Poco::XML::Element* pRootElem = pDoc->documentElement();
+ CoordTransformParser parser;
+ m_transform = parser.createTransform(pRootElem);
}
+
prog = new Progress(this, 0, 1.0, 1); // This gets deleted by the thread pool; don't delete it in here.
diff --git a/Code/Mantid/Framework/MDEvents/src/CoordTransform.cpp b/Code/Mantid/Framework/MDEvents/src/CoordTransform.cpp
index 884460d256f80147e6d098bd0c9fddccc6a78c90..291a9e98b3389630e3cea85df460c7d406fe999e 100644
--- a/Code/Mantid/Framework/MDEvents/src/CoordTransform.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/CoordTransform.cpp
@@ -4,6 +4,8 @@
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>
+#include "MantidKernel/Matrix.h"
+#include "MantidGeometry/MDGeometry/MDTypes.h"
using namespace Mantid::Geometry;
using namespace Mantid::Kernel;
@@ -14,6 +16,7 @@ namespace MDEvents
{
+
//----------------------------------------------------------------------------------------------
/** Constructor.
* Construct the affine matrix to and initialize to an identity matrix.
@@ -22,7 +25,7 @@ namespace MDEvents
* @throw std::runtime_error if outD > inD
*/
CoordTransform::CoordTransform(const size_t inD, const size_t outD)
- : inD(inD), outD(outD), affineMatrixParameter(outD, inD)
+ : inD(inD), outD(outD), affineMatrix(outD+1, inD+1), rawMatrix(NULL)
{
if (outD > inD)
throw std::runtime_error("CoordTransform: Cannot have more output dimensions than input dimensions!");
@@ -30,6 +33,17 @@ namespace MDEvents
throw std::runtime_error("CoordTransform: invalid number of output dimensions!");
if (inD == 0)
throw std::runtime_error("CoordTransform: invalid number of input dimensions!");
+ affineMatrix.identityMatrix();
+
+ // Allocate the raw matrix
+ size_t nx = affineMatrix.numRows();
+ size_t ny = affineMatrix.numCols();
+ coord_t * tmpX = new coord_t[nx*ny];
+ rawMatrix = new coord_t*[nx];
+ for (size_t i=0;i<nx;i++)
+ rawMatrix[i] = tmpX + (i*ny);
+ // Copy into the raw matrix (for speed)
+ copyRawMatrix();
}
//----------------------------------------------------------------------------------------------
@@ -37,26 +51,51 @@ namespace MDEvents
*/
CoordTransform::~CoordTransform()
{
+ if (rawMatrix)
+ {
+ delete [] *rawMatrix;
+ delete [] rawMatrix;
+ }
+ rawMatrix=NULL;
}
+
+ //----------------------------------------------------------------------------------------------
+ /** Copies the affine matrix into a local raw pointer, for speed.
+ * Call this after any change to affineMatrix
+ */
+ void CoordTransform::copyRawMatrix()
+ {
+ for (size_t x=0; x < affineMatrix.numRows(); ++x)
+ for (size_t y=0; y < affineMatrix.numCols(); ++y)
+ rawMatrix[x][y] = affineMatrix[x][y];
+ }
+
+
//----------------------------------------------------------------------------------------------
/** Directly set the affine matrix to use.
*
* @param newMatrix :: (outD+1 * inD+1) matrix to set.
* @throw runtime_error if the matrix dimensions are incompatible.
*/
- void CoordTransform::setMatrix(const Mantid::Kernel::Matrix<coord_t> newMatrix)
+ void CoordTransform::setMatrix(const Mantid::Kernel::Matrix<coord_t> & newMatrix)
{
- affineMatrixParameter.setMatrix(newMatrix);
+ if (newMatrix.numRows() != outD+1)
+ throw std::runtime_error("setMatrix(): Number of rows must match!");
+ if (newMatrix.numCols() != inD+1)
+ throw std::runtime_error("setMatrix(): Number of columns must match!");
+ affineMatrix = newMatrix;
+ // Copy into the raw matrix (for speed)
+ copyRawMatrix();
}
//----------------------------------------------------------------------------------------------
/** Return the affine matrix in the transform.
*/
- Mantid::Kernel::Matrix<coord_t> CoordTransform::getMatrix() const
+ const Mantid::Kernel::Matrix<coord_t> & CoordTransform::getMatrix() const
{
- return affineMatrixParameter.getAffineMatrix();
+ return affineMatrix;
}
//----------------------------------------------------------------------------------------------
@@ -66,20 +105,47 @@ namespace MDEvents
*/
void CoordTransform::addTranslation(const coord_t * translationVector)
{
- Matrix<coord_t> translationMatrix(outD.getValue()+1, inD.getValue()+1);
+ Matrix<coord_t> translationMatrix(outD+1, inD+1);
// Start with identity
translationMatrix.identityMatrix();
// Fill the last column with the translation value
- for (size_t i=0; i < outD.getValue(); i++)
- translationMatrix[i][inD.getValue()] = translationVector[i];
+ for (size_t i=0; i < outD; i++)
+ translationMatrix[i][inD] = translationVector[i];
// Multiply the affine matrix by the translation affine matrix to combine them
- Matrix<coord_t> currentAffine = affineMatrixParameter.getAffineMatrix();
- currentAffine *= translationMatrix;
+ affineMatrix *= translationMatrix;
- affineMatrixParameter.setMatrix(currentAffine);
+ // Copy into the raw matrix (for speed)
+ copyRawMatrix();
}
+
+ //----------------------------------------------------------------------------------------------
+ /** Apply the coordinate transformation
+ *
+ * @param inputVector :: fixed-size array of input coordinates, of size inD
+ * @param outVector :: fixed-size array of output coordinates, of size outD
+ */
+ void CoordTransform::apply(const coord_t * inputVector, coord_t * outVector) const
+ {
+ // For each output dimension
+ for (size_t out = 0; out < outD; ++out)
+ {
+ //Cache the row pointer to make the matrix access a bit faster
+ coord_t * rawMatrixRow = rawMatrix[out];
+ coord_t outVal = 0.0;
+ size_t in;
+ for (in = 0; in < inD; ++in)
+ outVal += rawMatrixRow[in] * inputVector[in];
+
+ // The last input coordinate is "1" always (made homogenous coordinate out of the input x,y,etc.)
+ outVal += rawMatrixRow[in];
+ // Save in the output
+ outVector[out] = outVal;
+ }
+ }
+
+
//----------------------------------------------------------------------------------------------
/** Serialize the coordinate transform
*
@@ -109,8 +175,14 @@ namespace MDEvents
DOMWriter writer;
writer.writeNode(xmlstream, pDoc);
+ // Convert the members to parameters
+ AffineMatrixParameter affineMatrixParameter(inD, outD);
+ affineMatrixParameter.setMatrix(affineMatrix);
+ InDimParameter inD_param(inD);
+ OutDimParameter outD_param(outD);
+
std::string formattedXMLString = boost::str(boost::format(xmlstream.str().c_str())
- % inD.toXMLString().c_str() % outD.toXMLString().c_str() % affineMatrixParameter.toXMLString().c_str());
+ % inD_param.toXMLString().c_str() % outD_param.toXMLString().c_str() % affineMatrixParameter.toXMLString().c_str());
return formattedXMLString;
}
diff --git a/Code/Mantid/Framework/MDEvents/src/CoordTransformAligned.cpp b/Code/Mantid/Framework/MDEvents/src/CoordTransformAligned.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8777ff430912711f7c01be4443c962dcb801416f
--- /dev/null
+++ b/Code/Mantid/Framework/MDEvents/src/CoordTransformAligned.cpp
@@ -0,0 +1,35 @@
+#include "MantidMDEvents/CoordTransformAligned.h"
+#include "MantidKernel/System.h"
+
+using namespace Mantid::Kernel;
+using namespace Mantid::API;
+
+namespace Mantid
+{
+namespace MDEvents
+{
+
+
+ //----------------------------------------------------------------------------------------------
+ /** Constructor
+ */
+ CoordTransformAligned::CoordTransformAligned(const size_t inD, const size_t outD, const size_t * /*dimensionToBinFrom*/,
+ const coord_t * /*min*/, const coord_t * /*step*/)
+ : CoordTransform(inD, outD)
+ {
+ // TODO Auto-generated constructor stub
+ }
+
+ //----------------------------------------------------------------------------------------------
+ /** Destructor
+ */
+ CoordTransformAligned::~CoordTransformAligned()
+ {
+ // TODO Auto-generated destructor stub
+ }
+
+
+
+} // namespace Mantid
+} // namespace MDEvents
+
diff --git a/Code/Mantid/Framework/MDEvents/src/CoordTransformDistance.cpp b/Code/Mantid/Framework/MDEvents/src/CoordTransformDistance.cpp
index b01b43cc6e8152c3271ba3e863183772230082ac..70858b033c7eef8f2e6376befdc6a454fee4b6ca 100644
--- a/Code/Mantid/Framework/MDEvents/src/CoordTransformDistance.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/CoordTransformDistance.cpp
@@ -26,13 +26,15 @@ namespace MDEvents
* @return
*/
CoordTransformDistance::CoordTransformDistance(const size_t inD, const coord_t * center, const bool * dimensionsUsed)
- : CoordTransform(inD, 1), m_center(new CoordCenterVectorParam(inD)), m_dimensionsUsed(new DimensionsUsedVectorParam(inD))
+ : CoordTransform(inD, 1)
{
// Create and copy the arrays.
+ m_center = new coord_t[inD];
+ m_dimensionsUsed = new bool[inD];
for (size_t d=0; d<inD; d++)
{
- m_center->addValue(d, center[d]);
- m_dimensionsUsed->addValue(d, dimensionsUsed[d]);
+ m_center[d] = center[d];
+ m_dimensionsUsed[d] = dimensionsUsed[d];
}
}
@@ -41,6 +43,8 @@ namespace MDEvents
*/
CoordTransformDistance::~CoordTransformDistance()
{
+ delete m_center;
+ delete m_dimensionsUsed;
}
@@ -53,14 +57,14 @@ namespace MDEvents
* @param inputVector :: fixed-size array of input coordinates, of size inD
* @param outVector :: fixed-size array of output coordinates, of size 1
*/
- void CoordTransformDistance::apply(const coord_t * inputVector, coord_t * outVector)
+ void CoordTransformDistance::apply(const coord_t * inputVector, coord_t * outVector) const
{
coord_t distanceSquared = 0;
- for (size_t d=0; d<inD.getValue(); d++)
+ for (size_t d=0; d<inD; d++)
{
- if (true == m_dimensionsUsed->at(d))
+ if (m_dimensionsUsed[d])
{
- coord_t dist = inputVector[d] - m_center->at(d);
+ coord_t dist = inputVector[d] - m_center[d];
distanceSquared += (dist * dist);
}
}
@@ -96,11 +100,24 @@ namespace MDEvents
DOMWriter writer;
writer.writeNode(xmlstream, pDoc);
+ // Convert the members to parameters
+ InDimParameter inD_param(inD);
+ OutDimParameter outD_param(outD);
+ CoordCenterVectorParam m_center_param(inD);
+ DimensionsUsedVectorParam m_dimensionsUsed_param(inD);
+
+ // Create and copy the arrays.
+ for (size_t d=0; d<inD; d++)
+ {
+ m_center_param.addValue(d, m_center[d]);
+ m_dimensionsUsed_param.addValue(d, m_dimensionsUsed[d]);
+ }
+
std::string formattedXMLString = boost::str(boost::format(xmlstream.str().c_str())
- % inD.toXMLString().c_str()
- % outD.toXMLString().c_str()
- % m_center->toXMLString().c_str()
- % m_dimensionsUsed->toXMLString().c_str());
+ % inD_param.toXMLString().c_str()
+ % outD_param.toXMLString().c_str()
+ % m_center_param.toXMLString().c_str()
+ % m_dimensionsUsed_param.toXMLString().c_str());
return formattedXMLString;
}
diff --git a/Code/Mantid/Framework/MDEvents/test/CoordTransformAlignedTest.h b/Code/Mantid/Framework/MDEvents/test/CoordTransformAlignedTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..da16e8c239adb89ecdf1e9ebe4f1e3acdbc5f0aa
--- /dev/null
+++ b/Code/Mantid/Framework/MDEvents/test/CoordTransformAlignedTest.h
@@ -0,0 +1,29 @@
+#ifndef MANTID_MDEVENTS_COORDTRANSFORMALIGNEDTEST_H_
+#define MANTID_MDEVENTS_COORDTRANSFORMALIGNEDTEST_H_
+
+#include <cxxtest/TestSuite.h>
+#include "MantidKernel/Timer.h"
+#include "MantidKernel/System.h"
+#include <iostream>
+#include <iomanip>
+
+#include "MantidMDEvents/CoordTransformAligned.h"
+
+using namespace Mantid;
+using namespace Mantid::MDEvents;
+using namespace Mantid::API;
+
+class CoordTransformAlignedTest : public CxxTest::TestSuite
+{
+public:
+
+ void test_Something()
+ {
+ }
+
+
+};
+
+
+#endif /* MANTID_MDEVENTS_COORDTRANSFORMALIGNEDTEST_H_ */
+