diff --git a/Code/Mantid/Framework/API/inc/MantidAPI/BoxController.h b/Code/Mantid/Framework/API/inc/MantidAPI/BoxController.h
index ea221a9c2d64699fd4c8fa176e9d0d930b61513f..f7785c82f1fee1559b3183a405b33505feefb5f6 100644
--- a/Code/Mantid/Framework/API/inc/MantidAPI/BoxController.h
+++ b/Code/Mantid/Framework/API/inc/MantidAPI/BoxController.h
@@ -47,7 +47,7 @@ namespace API
BoxController(const BoxController & other );
- ~BoxController();
+ virtual ~BoxController();
/// Serialize
std::string toXMLString() const;
diff --git a/Code/Mantid/Framework/MDEvents/CMakeLists.txt b/Code/Mantid/Framework/MDEvents/CMakeLists.txt
index 0a8bbe2a30243eeaabf3bce196e29d7726e1a7f4..401e79b3ce2fe10cfd337d5a056b17e51c626f05 100644
--- a/Code/Mantid/Framework/MDEvents/CMakeLists.txt
+++ b/Code/Mantid/Framework/MDEvents/CMakeLists.txt
@@ -108,6 +108,7 @@ set ( INC_FILES
inc/MantidMDEvents/MDBin.h
inc/MantidMDEvents/MDBox.h
inc/MantidMDEvents/MDBoxToChange.h
+ inc/MantidMDEvents/BoxCtrlChangesList.h
inc/MantidMDEvents/MDBoxBase.h
inc/MantidMDEvents/MDBoxIterator.h
inc/MantidMDEvents/MDDimensionStats.h
@@ -175,7 +176,6 @@ set ( TEST_FILES
test/LoadSQWTest.h
test/MDBinTest.h
test/MDBoxBaseTest.h
- test/MDBoxToChangeTest.h
test/MDBoxIteratorTest.h
test/MDBoxTest.h
test/MDBoxToChangeTest.h
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/BoxCtrlChangesList.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/BoxCtrlChangesList.h
new file mode 100644
index 0000000000000000000000000000000000000000..e13852965bcbbc0f81838d5e5996ef4ca7d99e5e
--- /dev/null
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/BoxCtrlChangesList.h
@@ -0,0 +1,116 @@
+#ifndef MANTID_BOXCONTROLLER_CHANGELIST_H_
+#define MANTID_BOXCONTROLLER_CHANGELIST_H_
+
+#include "MantidKernel/System.h"
+#include "MantidKernel/ThreadPool.h"
+#include <vector>
+#include "MantidAPI/BoxController.h"
+#include "MantidMDEvents/MDBoxToChange.h"
+
+
+namespace Mantid
+{
+namespace MDEvents
+{
+ /** This class is used to keep list of boxes, which have to be eventually split
+
+ *
+ * @date 27/07/2012
+
+ Copyright © 2010 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>
+
+ */
+ template<class T >
+ class BoxCtrlChangesList: public API::BoxController
+ {
+ //-----------------------------------------------------------------------------------
+ /** Add a MDBox pointer to the list of boxes to split.
+ * Thread-safe for adding.
+ * No duplicate checking is done!
+ *
+ * @param ptr :: void ptr that casts to a particular MDBox<> * type.
+ */
+ public:
+ void addBoxToSplit(const T &theBox)
+ {
+ m_boxesToSplitMutex.lock();
+ m_boxesToSplit.push_back(theBox);
+ m_boxesToSplitMutex.unlock();
+ }
+
+ //-----------------------------------------------------------------------------------
+ /** Get a reference to the vector of boxes that must be split.
+ * Not thread safe!
+ */
+ std::vector<T> getBoxesToSplit()const
+ {
+ return m_boxesToSplit;
+ }
+ //-----------------------------------------------------------------------------------
+ /** Get a reference to the vector of BoxesToSplit that can be split.
+ * thread safe!
+ */
+
+ template<class MDBoxToChange >
+ std::vector< MDBoxToChange > getBoxesToSplit()const
+ {
+ m_boxesToSplitMutex.lock();
+ return m_boxesToSplit;
+ m_boxesToSplitMutex.unlock();
+ }
+ //-----------------------------------------------------------------------------------
+ /** Clears the list of boxes that are big enough to split */
+ void clearBoxesToSplit()
+ {
+ m_boxesToSplitMutex.lock();
+ m_boxesToSplit.clear();
+ m_boxesToSplitMutex.unlock();
+ }
+ /**Copy constructor from a box controller pointer */
+ BoxCtrlChangesList(const API::BoxController & theController):
+ BoxController(theController)
+ {
+ auto *bc = dynamic_cast<const BoxCtrlChangesList<T>* >(&theController);
+ if(bc)m_boxesToSplit.assign(bc->m_boxesToSplit.begin(),bc->m_boxesToSplit.end());
+ }
+
+ /**Copy constructor from a BoxCtrlChangesList, not default as mutex can not be copied */
+ BoxCtrlChangesList(const BoxCtrlChangesList & other):
+ BoxController(other)
+ {
+ m_boxesToSplit.assign(other.m_boxesToSplit.begin(),other.m_boxesToSplit.end());
+ }
+
+ /**constructor with number of dimensions */
+ BoxCtrlChangesList(size_t nd):BoxController(nd){};
+
+ private:
+//
+ /// Mutex for modifying the m_boxesToSplit member
+ Mantid::Kernel::Mutex m_boxesToSplitMutex;
+
+ /// Vector of MDBoxes to change
+ std::vector<T> m_boxesToSplit;
+ };
+
+}
+}
+#endif
\ No newline at end of file
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h
index c990bdd20df1d57e7c57e704defb1e57f9d44854..229c4b0404f0e59f6aaffaf0934f9aa618ca24d1 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h
@@ -170,7 +170,6 @@ namespace MDEvents
void addEvent(const MDE & point);
void addAndTraceEvent(const MDE & point,size_t index);
-
void addEventUnsafe(const MDE & point);
size_t addEventsPart(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at);
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBoxToChange.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBoxToChange.h
index 80f02e1644f58549c74de0e0a7156a80d139e98b..ce1dab04abc8ab144a4329aacf2b094698bd214b 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBoxToChange.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBoxToChange.h
@@ -9,47 +9,110 @@ namespace Mantid
{
namespace MDEvents
{
-/** The class to contain and do operations over the list of MDBox-es which have been changed and need
- * to be split eventually
- *
- * @date 30-07-2012
+ /** The class to contains the information about an MDBox which has to be eventually split and aboul location of this box
+ * in the MDBox structure
+ *
+ * @date 30-07-2012
Copyright © 2010 ISIS Rutherford Appleton Laboratory & NScD Oak Ridge National Laboratory
- This file is part of Mantid.
+ 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 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.
+ 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/>.
+ 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>
-*/
+ File/ change history is stored at: <https://svn.mantidproject.org/mantid/trunk/Code/Mantid>
+ Code Documentation is available at: <http://doxygen.mantidproject.org>
+ */
-//-----------------------------------------------
+ //-----------------------------------------------
template<typename MDE, size_t nd>
- class DLLExport MDBoxToChange
+ class MDBoxToChange
{
public:
MDBoxToChange():m_ParentGridBox(NULL),m_Index(std::numeric_limits<size_t>::max()-1){};
- MDBoxToChange(MDBox<MDE,nd> *box,size_t Index);
-
size_t getIndex()const{return m_Index;}
- MDGridBox<MDE,nd>* splitToGridBox();
-
MDGridBox<MDE,nd>* getParent()const{return m_ParentGridBox;}
+
+ // Below for the time being:
+ //MDGridBox<MDE,nd>* splitToGridBox();
+ //MDBoxToChange(MDBox<MDE,nd> *box,size_t Index);
+
private:
+ /// the pointer to the greedbox, which contains box to split
MDGridBox<MDE,nd>* m_ParentGridBox;
+ /// index of the box to split in the gridbox array
size_t m_Index;
+ public:
+ /**function checks if the containing box has enough data
+ * the definition "enough" is also specified within this function
+ */
+ bool isFull(size_t maxSize=1000)
+ {
+ return true;
+ }
+ /**DESCRIBE */
+ MDBoxToChange(MDBox<MDE,nd> *box,size_t Index)
+ {
+ m_Index = Index;
+ MDGridBox<MDE, nd> * parent = dynamic_cast<MDGridBox<MDE, nd> * >(box->getParent());
+ if(parent)
+ {
+ m_ParentGridBox=parent;
+ }
+ else //HACK! if not parent, it is probably root a box -> such type should be created but meanwhile;
+ {
+ m_ParentGridBox=reinterpret_cast<MDGridBox<MDE,nd> *>(box);
+ m_Index = std::numeric_limits<size_t>::max();
+ }
+
+ }
+
+ /**DESCRIBE */
+ MDGridBox<MDE,nd>* splitToGridBox()
+ {
+ MDBox<MDE, nd> *pMDBox;
+ bool rootBox(false);
+ // get the actual box to split:
+ if(m_Index==std::numeric_limits<size_t>::max())
+ {
+ rootBox = true;
+ pMDBox = reinterpret_cast<MDBox<MDE,nd>*>(m_ParentGridBox);
+ }
+ else pMDBox = dynamic_cast<MDBox<MDE,nd>*>(m_ParentGridBox->getChild(m_Index));
+
+
+ // Construct the grid instead of box. This should take the object out of the disk MRU
+ MDGridBox<MDE, nd> * gridbox = new MDGridBox<MDE, nd>(pMDBox);
+ // Track how many MDBoxes there are in the overall workspace
+ pMDBox->getBoxController()->trackNumBoxes(pMDBox->getDepth());
+
+
+ if(rootBox) // carefull -- root pointer is not redefined here!
+ {
+ // this makes workspace data pointer invalid, but the actual pointer will remain dangling so care should be taken not to dereference it
+ delete pMDBox;
+ m_ParentGridBox = gridbox;
+ }
+ else
+ { // this will delete the old box and set new gridBox instead
+ m_ParentGridBox->setChild(m_Index,gridbox);
+ }
+ // make this grid box undefined again
+ m_Index=std::numeric_limits<size_t>::max()-1;
+
+ return gridbox;
+ }
};
}
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEventWSWrapper.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEventWSWrapper.h
index 7daf8efb55ff1ee0d26c2b333d93567373fe9f7a..384df84c91f623a405c2e755738fadfc644f6eaf 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEventWSWrapper.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEventWSWrapper.h
@@ -65,6 +65,9 @@ namespace Mantid
API::IMDEventWorkspace_sptr createEmptyMDWS(const MDWSDescription &WSD);
/// add the data to the internal workspace. The workspace has to exist and be initiated
void addMDData(std::vector<float> &sig_err,std::vector<uint16_t> &run_index,std::vector<uint32_t> &det_id,std::vector<coord_t> &Coord,size_t data_size)const;
+ /// add the data to the internal workspace and trace boxes which changed. The workspace has to exist and be initiated
+ void addAndTraceMDData(std::vector<float> &sig_err,std::vector<uint16_t> &run_index,std::vector<uint32_t> &det_id,std::vector<coord_t> &Coord,size_t data_size)const;
+
/// releases the shared pointer to the workspace, stored by the class and makes the class instance undefined;
void releaseWorkspace();
/// get access to the internal workspace
@@ -90,7 +93,10 @@ namespace Mantid
/// vector holding function pointers to the code, creating different number of dimension worspace as function of dimensions number
std::vector<fpCreateWS> wsCreator;
/// vector holding function pointers to the code, which adds diffrent dimension number events to the workspace
- std::vector<fpAddData> mdEvSummator;
+ std::vector<fpAddData> mdEvAddAndForget;
+ /// vector holding function pointers to the code, which adds diffrent dimension number events to the workspace and traces the added cells
+ std::vector<fpAddData> mdEvAddAndTrace;
+
/// vector holding function pointers to the code, which refreshes centroid (could it be moved to IMD?)
std::vector<fpVoidMethod> mdCalCentroid;
/// vector holding function pointers to the code, which split list of boxes need splitting
@@ -100,9 +106,13 @@ namespace Mantid
// helper class to generate methaloop on MD workspaces dimensions:
template< size_t i>
friend class LOOP;
+
// internal function tempates to generate as function of dimensions and assightn to function pointers
template<size_t nd>
void addMDDataND(float *sig_err,uint16_t *run_index,uint32_t* det_id,coord_t* Coord,size_t data_size)const;
+ template<size_t nd>
+ void addAndTraceMDDataND(float *sig_err,uint16_t *run_index,uint32_t* det_id,coord_t* Coord,size_t data_size)const;
+
template<size_t nd>
void calcCentroidND(void);
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEventWorkspace.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEventWorkspace.h
index 44c151cb76b3444673e94ec87467df794e17bd7a..7a998d211c3d166eedd103b93cbe3152330e48f7 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEventWorkspace.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEventWorkspace.h
@@ -4,7 +4,8 @@
#include "MantidAPI/IMDEventWorkspace.h"
#include "MantidKernel/ProgressBase.h"
#include "MantidKernel/System.h"
-#include "MantidAPI/BoxController.h"
+//#include "MantidAPI/BoxController.h"
+#include "MantidMDEvents/BoxCtrlChangesList.h"
#include "MantidAPI/CoordTransform.h"
#include "MantidMDEvents/MDBoxBase.h"
#include "MantidMDEvents/MDLeanEvent.h"
@@ -103,7 +104,7 @@ namespace MDEvents
void addEvent(const MDE & event);
- void addAndTraceEvent(const MDE & point,size_t index=0);
+ void addAndTraceEvent(const MDE & point,size_t index);
size_t addEvents(const std::vector<MDE> & events);
@@ -149,7 +150,8 @@ namespace MDEvents
MDBoxBase<MDE, nd> * data;
/// Box controller in use
- Mantid::API::BoxController_sptr m_BoxController;
+ //Mantid::API::BoxController_sptr m_BoxController;
+ boost::shared_ptr<BoxCtrlChangesList<MDBoxToChange<MDE,nd> > > m_BoxController;
public:
/// Typedef for a shared pointer of this kind of event workspace
diff --git a/Code/Mantid/Framework/MDEvents/src/MDBox.cpp b/Code/Mantid/Framework/MDEvents/src/MDBox.cpp
index 5f2ab560c35b5c75af3f641001d86d4268661620..6c92e436a3f864ead5e58b491c6f2e6930e78dd9 100644
--- a/Code/Mantid/Framework/MDEvents/src/MDBox.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/MDBox.cpp
@@ -526,16 +526,19 @@ namespace MDEvents
// Yes, we added some data
this->m_dataAdded = true;
+ dataMutex.unlock();
// When we reach the split threshold exactly, track that the MDBox is too small
// We check on equality and not >= to only add a box once.
if (this->data.size() == this->m_BoxController->getSplitThreshold())
{
-// this->m_BoxController->addBoxToSplit(splitBoxList(this,index));
+ auto BoxCtrl = dynamic_cast<BoxCtrlChangesList<MDBoxToChange<MDE,nd> >*>(m_BoxController.get());
+ BoxCtrl->addBoxToSplit(MDBoxToChange<MDE,nd>(this,index));
+
}
- dataMutex.unlock();
+
}
//-----------------------------------------------------------------------------------------------
diff --git a/Code/Mantid/Framework/MDEvents/src/MDBoxToChange.cpp b/Code/Mantid/Framework/MDEvents/src/MDBoxToChange.cpp
index bce449df4167bc430944662ad3954b50bd5f4dbb..34ae32785932e552bea4f8af09dde009f762d89a 100644
--- a/Code/Mantid/Framework/MDEvents/src/MDBoxToChange.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/MDBoxToChange.cpp
@@ -6,59 +6,59 @@ namespace Mantid
namespace MDEvents
{
- template<typename MDE,size_t nd>
- MDBoxToChange<MDE,nd>::MDBoxToChange(MDBox<MDE,nd> *box,size_t Index)
- {
- m_Index = Index;
- MDGridBox<MDE, nd> * parent = dynamic_cast<MDGridBox<MDE, nd> * >(box->getParent());
- if(parent)
- {
- m_ParentGridBox=parent;
- }
- else //HACK! if not parent, it is probably root a box -> such type should be created but meanwhile;
- {
- m_ParentGridBox=reinterpret_cast<MDGridBox<MDE,nd> *>(box);
- m_Index = std::numeric_limits<size_t>::max();
- }
+ //template<typename MDE,size_t nd>
+ //MDBoxToChange<MDE,nd>::MDBoxToChange(MDBox<MDE,nd> *box,size_t Index)
+ //{
+ // m_Index = Index;
+ // MDGridBox<MDE, nd> * parent = dynamic_cast<MDGridBox<MDE, nd> * >(box->getParent());
+ // if(parent)
+ // {
+ // m_ParentGridBox=parent;
+ // }
+ // else //HACK! if not parent, it is probably root a box -> such type should be created but meanwhile;
+ // {
+ // m_ParentGridBox=reinterpret_cast<MDGridBox<MDE,nd> *>(box);
+ // m_Index = std::numeric_limits<size_t>::max();
+ // }
- }
+ //}
- template<typename MDE,size_t nd>
- MDGridBox<MDE,nd>* MDBoxToChange<MDE,nd>::splitToGridBox()
- {
- MDBox<MDE, nd> *pMDBox;
- bool rootBox(false);
- // get the actual box to split:
- if(m_Index==std::numeric_limits<size_t>::max())
- {
- rootBox = true;
- pMDBox = reinterpret_cast<MDBox<MDE,nd>*>(m_ParentGridBox);
- }
- else pMDBox = dynamic_cast<MDBox<MDE,nd>*>(m_ParentGridBox->getChild(m_Index));
+ //template<typename MDE,size_t nd>
+ //MDGridBox<MDE,nd>* MDBoxToChange<MDE,nd>::splitToGridBox()
+ //{
+ // MDBox<MDE, nd> *pMDBox;
+ // bool rootBox(false);
+ // // get the actual box to split:
+ // if(m_Index==std::numeric_limits<size_t>::max())
+ // {
+ // rootBox = true;
+ // pMDBox = reinterpret_cast<MDBox<MDE,nd>*>(m_ParentGridBox);
+ // }
+ // else pMDBox = dynamic_cast<MDBox<MDE,nd>*>(m_ParentGridBox->getChild(m_Index));
- // Construct the grid instead of box. This should take the object out of the disk MRU
- MDGridBox<MDE, nd> * gridbox = new MDGridBox<MDE, nd>(pMDBox);
- // Track how many MDBoxes there are in the overall workspace
- pMDBox->getBoxController()->trackNumBoxes(pMDBox->getDepth());
+ // // Construct the grid instead of box. This should take the object out of the disk MRU
+ // MDGridBox<MDE, nd> * gridbox = new MDGridBox<MDE, nd>(pMDBox);
+ // // Track how many MDBoxes there are in the overall workspace
+ // pMDBox->getBoxController()->trackNumBoxes(pMDBox->getDepth());
- if(rootBox) // carefull -- root pointer is not redefined here!
- {
- // this makes workspace data pointer invalid, but the actual pointer will remain dangling so care should be taken not to dereference it
- delete pMDBox;
- m_ParentGridBox = gridbox;
- }
- else
- { // this will delete the old box and set new gridBox instead
- m_ParentGridBox->setChild(m_Index,gridbox);
- }
- // make this grid box undefined again
- m_Index=std::numeric_limits<size_t>::max()-1;
+ // if(rootBox) // carefull -- root pointer is not redefined here!
+ // {
+ // // this makes workspace data pointer invalid, but the actual pointer will remain dangling so care should be taken not to dereference it
+ // delete pMDBox;
+ // m_ParentGridBox = gridbox;
+ // }
+ // else
+ // { // this will delete the old box and set new gridBox instead
+ // m_ParentGridBox->setChild(m_Index,gridbox);
+ // }
+ //// make this grid box undefined again
+ // m_Index=std::numeric_limits<size_t>::max()-1;
- return gridbox;
- }
+ // return gridbox;
+ //}
///**convert input box into MDGridBox and split MDGrid box into its children
// *
diff --git a/Code/Mantid/Framework/MDEvents/src/MDEventFactory.cpp b/Code/Mantid/Framework/MDEvents/src/MDEventFactory.cpp
index 38da6d0cfc1921f60ebe4ee344b59272ec721a0e..387dea7dbefb7d70415b00116259543d53b519e1 100644
--- a/Code/Mantid/Framework/MDEvents/src/MDEventFactory.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/MDEventFactory.cpp
@@ -17,6 +17,7 @@
#include "MantidMDEvents/MDBoxIterator.h"
#include "MantidMDEvents/MDEvent.h"
#include "MantidMDEvents/MDLeanEvent.h"
+#include "MantidMDEvents/MDBoxToChange.h"
// We need to include the .cpp files so that the declarations are picked up correctly. Weird, I know.
// See http://www.parashift.com/c++-faq-lite/templates.html#faq-35.13
diff --git a/Code/Mantid/Framework/MDEvents/src/MDEventWSWrapper.cpp b/Code/Mantid/Framework/MDEvents/src/MDEventWSWrapper.cpp
index 089bdbc16d9b066cb9c959ea9215e34e1e39c047..1c51b71b33c7e1409ebb94aeb7ec9505ec1bc709 100644
--- a/Code/Mantid/Framework/MDEvents/src/MDEventWSWrapper.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/MDEventWSWrapper.cpp
@@ -73,7 +73,35 @@ void MDEventWSWrapper::addMDDataND(float *sigErr,uint16_t *runIndex,uint32_t* de
for(size_t i=0;i<dataSize;i++)
{
- pWs->addAndTraceEvent(MDEvents::MDEvent<nd>(*(sigErr+2*i),*(sigErr+2*i+1),*(runIndex+i),*(detId+i),(Coord+i*nd)));
+ pWs->addEvent(MDEvents::MDEvent<nd>(*(sigErr+2*i),*(sigErr+2*i+1),*(runIndex+i),*(detId+i),(Coord+i*nd)));
+ }
+
+
+}
+
+/** templated by number of dimesnions function to add multidimensional data to the workspace and trace the cells, which requested splitting
+* it is expected that all MD coordinates are within the ranges of MD defined workspace, so no checks are performed
+
+ tempate parameter:
+ * nd -- number of dimensions
+
+*@param sigErr -- pointer to the beginning of 2*data_size array containing signal and squared error
+*@param runIndex -- pointer to the beginnign of data_size containing run index
+*@param detId -- pointer to the beginning of dataSize array containing detector id-s
+*@param Coord -- pointer to the beginning of dataSize*nd array containig the coordinates od nd-dimensional events
+*
+*@param dataSize -- the length of the vector of MD events
+*/
+template<size_t nd>
+void MDEventWSWrapper::addAndTraceMDDataND(float *sigErr,uint16_t *runIndex,uint32_t* detId,coord_t* Coord,size_t dataSize)const
+{
+
+ MDEvents::MDEventWorkspace<MDEvents::MDEvent<nd>,nd> *const pWs = dynamic_cast<MDEvents::MDEventWorkspace<MDEvents::MDEvent<nd>,nd> *>(m_Workspace.get());
+ if(!pWs)throw(std::bad_cast());
+
+ for(size_t i=0;i<dataSize;i++)
+ {
+ pWs->addAndTraceEvent(MDEvents::MDEvent<nd>(*(sigErr+2*i),*(sigErr+2*i+1),*(runIndex+i),*(detId+i),(Coord+i*nd)),0);
}
// if there are boxes ready to split -- we have to indicate need for that.
// if(pWs->getBoxController()->getBoxesToSplit().size()>0)m_needSplitting=true;
@@ -198,9 +226,26 @@ void MDEventWSWrapper::addMDData(std::vector<float> &sigErr,std::vector<uint16_
if(dataSize==0)return;
// perform the actual dimension-dependent addition
- (this->*(mdEvSummator[m_NDimensions]))(&sigErr[0],&runIndex[0],&detId[0],&Coord[0],dataSize);
+ (this->*(mdEvAddAndForget[m_NDimensions]))(&sigErr[0],&runIndex[0],&detId[0],&Coord[0],dataSize);
}
+/** method adds the data to the workspace which was initiated before and traces changed cells;
+*@param sigErr -- pointer to the beginning of 2*data_size array containing signal and squared error
+*@param runIndex -- pointer to the beginnign of data_size containing run index
+*@param detId -- pointer to the beginning of dataSize array containing detector id-s
+*@param Coord -- pointer to the beginning of dataSize*nd array containig the coordinates od nd-dimensional events
+*
+*@param dataSize -- the length of the vector of MD events
+*/
+void MDEventWSWrapper::addAndTraceMDData(std::vector<float> &sigErr,std::vector<uint16_t> &runIndex,std::vector<uint32_t> &detId,std::vector<coord_t> &Coord,size_t dataSize)const
+{
+
+ if(dataSize==0)return;
+ // perform the actual dimension-dependent addition
+ (this->*(mdEvAddAndTrace[m_NDimensions]))(&sigErr[0],&runIndex[0],&detId[0],&Coord[0],dataSize);
+
+}
+
/** method should be called at the end of the algorithm, to let the workspace manager know that it has whole responsibility for the workspace
@@ -223,7 +268,8 @@ public:
{
LOOP< i-1 >::EXEC(pH);
pH->wsCreator[i] = &MDEventWSWrapper::createEmptyEventWS<i>;
- pH->mdEvSummator[i] = &MDEventWSWrapper::addMDDataND<i>;
+ pH->mdEvAddAndForget[i]= &MDEventWSWrapper::addMDDataND<i>;
+ pH->mdEvAddAndTrace[i] = &MDEventWSWrapper::addAndTraceMDDataND<i>;
pH->mdCalCentroid[i]= &MDEventWSWrapper::calcCentroidND<i>;
pH->mdBoxListSplitter[i]=&MDEventWSWrapper::splitBoxList<i>;
@@ -236,10 +282,11 @@ class LOOP<0>
public:
static inline void EXEC(MDEventWSWrapper *pH)
{
- pH->wsCreator[0] =&MDEventWSWrapper::createEmptyEventWS<0>;
- pH->mdEvSummator[0] =&MDEventWSWrapper::addMDDataND<0>;
- pH->mdCalCentroid[0]=&MDEventWSWrapper::calcCentroidND<0>;
- pH->mdBoxListSplitter[0]=&MDEventWSWrapper::splitBoxList<0>;
+ pH->wsCreator[0] = &MDEventWSWrapper::createEmptyEventWS<0>;
+ pH->mdEvAddAndForget[0] = &MDEventWSWrapper::addMDDataND<0>;
+ pH->mdEvAddAndTrace[0] = &MDEventWSWrapper::addMDDataND<0>;
+ pH->mdCalCentroid[0]= &MDEventWSWrapper::calcCentroidND<0>;
+ pH->mdBoxListSplitter[0]= &MDEventWSWrapper::splitBoxList<0>;
}
};
@@ -249,7 +296,8 @@ m_NDimensions(0),
m_needSplitting(false)
{
wsCreator.resize(MAX_N_DIM+1);
- mdEvSummator.resize(MAX_N_DIM+1);
+ mdEvAddAndForget.resize(MAX_N_DIM+1);
+ mdEvAddAndTrace.resize(MAX_N_DIM+1);
mdCalCentroid.resize(MAX_N_DIM+1);
mdBoxListSplitter.resize(MAX_N_DIM+1);
LOOP<MAX_N_DIM>::EXEC(this);
diff --git a/Code/Mantid/Framework/MDEvents/src/MDEventWorkspace.cpp b/Code/Mantid/Framework/MDEvents/src/MDEventWorkspace.cpp
index dc8e6083236fb7742f1a4293501aafdbc857fd75..e1406f81df359941712897fc5168ff7c4dce078b 100644
--- a/Code/Mantid/Framework/MDEvents/src/MDEventWorkspace.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/MDEventWorkspace.cpp
@@ -37,7 +37,8 @@ namespace MDEvents
*/
TMDE(
MDEventWorkspace)::MDEventWorkspace()
- : m_BoxController(boost::make_shared<BoxController>(nd))
+ //m_BoxController(boost::make_shared<BoxController>(nd))
+ : m_BoxController(boost::make_shared<BoxCtrlChangesList<MDBoxToChange<MDE,nd> > >(nd))
{
// First box is at depth 0, and has this default boxController
data = new MDBox<MDE, nd>(m_BoxController, 0);
@@ -49,7 +50,7 @@ namespace MDEvents
TMDE(
MDEventWorkspace)::MDEventWorkspace(const MDEventWorkspace<MDE,nd> & other)
: IMDEventWorkspace(other),
- m_BoxController( new BoxController(*other.m_BoxController) )
+ m_BoxController( new BoxCtrlChangesList<MDBoxToChange<MDE,nd> >(*other.m_BoxController) )
{
const MDBox<MDE,nd> * mdbox = dynamic_cast<const MDBox<MDE,nd> *>(other.data);
const MDGridBox<MDE,nd> * mdgridbox = dynamic_cast<const MDGridBox<MDE,nd> *>(other.data);
diff --git a/Code/Mantid/Framework/MDEvents/test/MDEventWSWrapperTest.h b/Code/Mantid/Framework/MDEvents/test/MDEventWSWrapperTest.h
index 4bec9d9c132d3aa97530246710443366bb77527b..78c45dbfdcf8e88b7f283f6374aacb4b57f24e24 100644
--- a/Code/Mantid/Framework/MDEvents/test/MDEventWSWrapperTest.h
+++ b/Code/Mantid/Framework/MDEvents/test/MDEventWSWrapperTest.h
@@ -28,12 +28,12 @@ public:
{
IMDEventWorkspace_sptr pws;
MDWSDescription TWS0;
- MDWSDescription TWS9(9);
+ MDWSDescription TWS10(10);
MDWSDescription TWS5(5);
TSM_ASSERT_THROWS("too few dimensions",pws=pWSWrap->createEmptyMDWS(TWS0),std::invalid_argument);
- TSM_ASSERT_THROWS("too many dimensions",pws=pWSWrap->createEmptyMDWS(TWS9),std::invalid_argument);
+ TSM_ASSERT_THROWS("too many dimensions",pws=pWSWrap->createEmptyMDWS(TWS10),std::invalid_argument);
TSM_ASSERT_THROWS("dimensions have not been defined ",pWSWrap->nDimensions(),std::invalid_argument);
TSM_ASSERT_THROWS_NOTHING("should be fine",pws=pWSWrap->createEmptyMDWS(TWS5));
diff --git a/Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h b/Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h
index 95cabe96aead202ea2a8612ab43df3114a44c040..840730e501fa757530a8cca9ec5fd508bfb1a351 100644
--- a/Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h
+++ b/Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h
@@ -13,13 +13,14 @@
#include "MantidKernel/Timer.h"
#include "MantidKernel/Utils.h"
#include "MantidAPI/BoxController.h"
-#include "MantidMDEvents/CoordTransformDistance.h"
#include "MantidMDEvents/MDBox.h"
#include "MantidMDEvents/MDLeanEvent.h"
#include "MantidMDEvents/MDGridBox.h"
#include "MantidNexusCPP/NeXusFile.hpp"
#include "MantidTestHelpers/MDEventsTestHelper.h"
#include "MDBoxTest.h"
+//#include "MantidMDEvents/../../src/MDGridBox.cpp"
+#include "MantidMDEvents/CoordTransformDistance.h"
#include <boost/random/linear_congruential.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
@@ -64,1622 +65,1624 @@ public:
{
DODEBUG = false;
}
-
- //-------------------------------------------------------------------------------------
- void test_MDBoxConstructor()
+ void testNothing()
{
- MDBox<MDLeanEvent<1>,1> * b = MDEventsTestHelper::makeMDBox1();
- TS_ASSERT_EQUALS( b->getNumDims(), 1);
- TS_ASSERT_EQUALS( b->getNPoints(), 0);
- TS_ASSERT_DELTA( b->getExtents(0).min, 0.0, 1e-5);
- TS_ASSERT_DELTA( b->getExtents(0).max, 10.0, 1e-5);
- TS_ASSERT_DELTA( b->getVolume(), 10.0, 1e-5);
- // Start at ID 0.
- TS_ASSERT_EQUALS( b->getId(), 0);
- delete b;
-
+ }
+// //-------------------------------------------------------------------------------------
+// void test_MDBoxConstructor()
+// {
+// MDBox<MDLeanEvent<1>,1> * b = MDEventsTestHelper::makeMDBox1();
+// TS_ASSERT_EQUALS( b->getNumDims(), 1);
+// TS_ASSERT_EQUALS( b->getNPoints(), 0);
+// TS_ASSERT_DELTA( b->getExtents(0).min, 0.0, 1e-5);
+// TS_ASSERT_DELTA( b->getExtents(0).max, 10.0, 1e-5);
+// TS_ASSERT_DELTA( b->getVolume(), 10.0, 1e-5);
+// // Start at ID 0.
+// TS_ASSERT_EQUALS( b->getId(), 0);
+// delete b;
+//
+//
+//// std::cout << sizeof( MDLeanEvent<3>) << " bytes per MDLeanEvent(3)" << std::endl;
+//// std::cout << sizeof( MDLeanEvent<4>) << " bytes per MDLeanEvent(4)" << std::endl;
+//// std::cout << sizeof( Mantid::Kernel::Mutex ) << " bytes per Mutex" << std::endl;
+//// std::cout << sizeof( MDDimensionExtents) << " bytes per MDDimensionExtents" << std::endl;
+//// std::cout << sizeof( MDBox<MDLeanEvent<3>,3>) << " bytes per MDBox(3)" << std::endl;
+//// std::cout << sizeof( MDBox<MDLeanEvent<4>,4> ) << " bytes per MDBox(4)" << std::endl;
+//// std::cout << sizeof( MDGridBox<MDLeanEvent<3>,3>) << " bytes per MDGridBox(3)" << std::endl;
+//// std::cout << sizeof( MDGridBox<MDLeanEvent<4>,4> ) << " bytes per MDGridBox(4)" << std::endl;
+////
+//// MemoryStats mem;
+//// size_t start = mem.availMem();
+//// std::cout << start << " KB before" << std::endl;
+//// CPUTimer tim;
+//// for (size_t i=0; i<1000000; i++)
+//// {
+//// MDBox<MDLeanEvent<3>,3> * box = new MDBox<MDLeanEvent<3>,3>();
+//// (void) box;
+//// }
+//// std::cout << tim << " to allocate a million boxes" << std::endl;
+//// mem.update();
+//// size_t stop = mem.availMem();
+//// std::cout << stop << " KB after " << std::endl;
+//// std::cout << start-stop << " KB change " << std::endl;
+//// std::cout << (start-stop)*1024 / sizeof( MDBox<MDLeanEvent<3>,3>) << " times the sizeof MDBox3" << std::endl;
+// }
+//
-// std::cout << sizeof( MDLeanEvent<3>) << " bytes per MDLeanEvent(3)" << std::endl;
-// std::cout << sizeof( MDLeanEvent<4>) << " bytes per MDLeanEvent(4)" << std::endl;
-// std::cout << sizeof( Mantid::Kernel::Mutex ) << " bytes per Mutex" << std::endl;
-// std::cout << sizeof( MDDimensionExtents) << " bytes per MDDimensionExtents" << std::endl;
-// std::cout << sizeof( MDBox<MDLeanEvent<3>,3>) << " bytes per MDBox(3)" << std::endl;
-// std::cout << sizeof( MDBox<MDLeanEvent<4>,4> ) << " bytes per MDBox(4)" << std::endl;
-// std::cout << sizeof( MDGridBox<MDLeanEvent<3>,3>) << " bytes per MDGridBox(3)" << std::endl;
-// std::cout << sizeof( MDGridBox<MDLeanEvent<4>,4> ) << " bytes per MDGridBox(4)" << std::endl;
-//
-// MemoryStats mem;
-// size_t start = mem.availMem();
-// std::cout << start << " KB before" << std::endl;
-// CPUTimer tim;
-// for (size_t i=0; i<1000000; i++)
+// void check_MDGridBox(MDGridBox<MDLeanEvent<1>,1> * g)
+// {
+// // The grid box stole the ID of the box it replaces.
+// TS_ASSERT_EQUALS( g->getId(), 0);
+//
+// // Look overall; it has 10 points
+// TS_ASSERT_EQUALS(g->getNumDims(), 1);
+// TS_ASSERT_EQUALS(g->getNPoints(), 10);
+// // Its depth level should be 0 (same as parent)
+// TS_ASSERT_EQUALS(g->getDepth(), 0);
+// // It was split into 10 MDBoxes.
+// TS_ASSERT_EQUALS(g->getNumMDBoxes(), 10);
+// // Same result for non-recursive children
+// TS_ASSERT_EQUALS(g->getNumChildren(), 10);
+// // The volume was set correctly
+// TS_ASSERT_DELTA(g->getVolume(), 10.0, 1e-5);
+//
+// // It has a BoxController
+// TS_ASSERT( g->getBoxController() );
+//
+// // Check the boxes
+// std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes = g->getBoxes();
+// TS_ASSERT_EQUALS( boxes.size(), 10);
+// for (size_t i=0; i<boxes.size(); i++)
// {
-// MDBox<MDLeanEvent<3>,3> * box = new MDBox<MDLeanEvent<3>,3>();
-// (void) box;
+// // The get child method is equivalent
+// TS_ASSERT_EQUALS( boxes[i], g->getChild(i));
+// MDBox<MDLeanEvent<1>,1> * box = dynamic_cast<MDBox<MDLeanEvent<1>,1> *>(boxes[i]);
+//
+// // Sequential ID, starting at 1 since 0 was used by the parent.
+// TS_ASSERT_EQUALS( box->getId(), i+1);
+// // At the right place?
+// TS_ASSERT_DELTA(box->getExtents(0).min, double(i)*1.0, 1e-6);
+// TS_ASSERT_DELTA(box->getExtents(0).max, double(i+1)*1.0, 1e-6);
+// // Look at the single event in there
+// TS_ASSERT_EQUALS(box->getNPoints(), 1);
+// MDLeanEvent<1> ev = box->getEvents()[0];
+// TS_ASSERT_DELTA(ev.getCenter(0), double(i)*1.0 + 0.5, 1e-5);
+// // Its depth level should be 1 (deeper than parent)
+// TS_ASSERT_EQUALS(box->getDepth(), 1);
+// // The volume was set correctly
+// TS_ASSERT_DELTA(box->getVolume(), 1.0, 1e-5);
+// // The parent of the MDBox is the grid box
+// TS_ASSERT_EQUALS(box->getParent(), g);
// }
-// std::cout << tim << " to allocate a million boxes" << std::endl;
-// mem.update();
-// size_t stop = mem.availMem();
-// std::cout << stop << " KB after " << std::endl;
-// std::cout << start-stop << " KB change " << std::endl;
-// std::cout << (start-stop)*1024 / sizeof( MDBox<MDLeanEvent<3>,3>) << " times the sizeof MDBox3" << std::endl;
- }
-
-
- void check_MDGridBox(MDGridBox<MDLeanEvent<1>,1> * g)
- {
- // The grid box stole the ID of the box it replaces.
- TS_ASSERT_EQUALS( g->getId(), 0);
-
- // Look overall; it has 10 points
- TS_ASSERT_EQUALS(g->getNumDims(), 1);
- TS_ASSERT_EQUALS(g->getNPoints(), 10);
- // Its depth level should be 0 (same as parent)
- TS_ASSERT_EQUALS(g->getDepth(), 0);
- // It was split into 10 MDBoxes.
- TS_ASSERT_EQUALS(g->getNumMDBoxes(), 10);
- // Same result for non-recursive children
- TS_ASSERT_EQUALS(g->getNumChildren(), 10);
- // The volume was set correctly
- TS_ASSERT_DELTA(g->getVolume(), 10.0, 1e-5);
-
- // It has a BoxController
- TS_ASSERT( g->getBoxController() );
-
- // Check the boxes
- std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes = g->getBoxes();
- TS_ASSERT_EQUALS( boxes.size(), 10);
- for (size_t i=0; i<boxes.size(); i++)
- {
- // The get child method is equivalent
- TS_ASSERT_EQUALS( boxes[i], g->getChild(i));
- MDBox<MDLeanEvent<1>,1> * box = dynamic_cast<MDBox<MDLeanEvent<1>,1> *>(boxes[i]);
-
- // Sequential ID, starting at 1 since 0 was used by the parent.
- TS_ASSERT_EQUALS( box->getId(), i+1);
- // At the right place?
- TS_ASSERT_DELTA(box->getExtents(0).min, double(i)*1.0, 1e-6);
- TS_ASSERT_DELTA(box->getExtents(0).max, double(i+1)*1.0, 1e-6);
- // Look at the single event in there
- TS_ASSERT_EQUALS(box->getNPoints(), 1);
- MDLeanEvent<1> ev = box->getEvents()[0];
- TS_ASSERT_DELTA(ev.getCenter(0), double(i)*1.0 + 0.5, 1e-5);
- // Its depth level should be 1 (deeper than parent)
- TS_ASSERT_EQUALS(box->getDepth(), 1);
- // The volume was set correctly
- TS_ASSERT_DELTA(box->getVolume(), 1.0, 1e-5);
- // The parent of the MDBox is the grid box
- TS_ASSERT_EQUALS(box->getParent(), g);
- }
-
- }
-
-
-
- //-------------------------------------------------------------------------------------
- void test_MDGridBox_constructor_from_MDBox()
- {
- MDBox<MDLeanEvent<1>,1> * b = MDEventsTestHelper::makeMDBox1();
- // Start at ID 0.
- TS_ASSERT_EQUALS( b->getId(), 0);
- // Give it 10 events
- const std::vector<MDLeanEvent<1> > events = MDEventsTestHelper::makeMDEvents1(10);
- b->addEvents( events );
- TS_ASSERT_EQUALS( b->getNPoints(), 10 );
- TS_ASSERT_DELTA(b->getVolume(), 10.0, 1e-5);
-
- // Build the grid box out of it
- MDGridBox<MDLeanEvent<1>,1> * g = new MDGridBox<MDLeanEvent<1>,1>(b);
-
- // Perform a detailed check
- check_MDGridBox(g);
-
- // Now we add 10 more events
- g->addEvents( MDEventsTestHelper::makeMDEvents1(10) );
-
- // And now there should be 2 events per box
- std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes = g->getBoxes();
- for (size_t i=0; i<10; i++)
- {
- MDBox<MDLeanEvent<1>,1> * box = dynamic_cast<MDBox<MDLeanEvent<1>,1> *>(boxes[i]);
- TS_ASSERT_EQUALS(box->getNPoints(), 2);
- }
- }
-
-
- //-------------------------------------------------------------------------------------
- void test_MDGridBox_copy_constructor()
- {
- MDBox<MDLeanEvent<1>,1> * b = MDEventsTestHelper::makeMDBox1();
- TS_ASSERT_EQUALS( b->getId(), 0);
- const std::vector<MDLeanEvent<1> > events = MDEventsTestHelper::makeMDEvents1(10);
- b->addEvents( events );
- TS_ASSERT_EQUALS( b->getNPoints(), 10 );
- TS_ASSERT_DELTA(b->getVolume(), 10.0, 1e-5);
-
- // Build the grid box out of it
- MDGridBox<MDLeanEvent<1>,1> * g1 = new MDGridBox<MDLeanEvent<1>,1>(b);
- MDGridBox<MDLeanEvent<1>,1> * g2 = new MDGridBox<MDLeanEvent<1>,1>(*g1);
-
- // Perform a detailed check
- check_MDGridBox(g2);
- }
-
-
-
- //-----------------------------------------------------------------------------------------
- /** Test splitting of a MDBox into a MDGridBox when the
- * original box is backed by a file. */
- void test_fileBackEnd_construction()
- {
- // Create a box with a controller for the back-end
- BoxController_sptr bc(new BoxController(3));
- bc->setSplitInto(5);
- // Handle the disk MRU values
- bc->setCacheParameters(sizeof(MDLeanEvent<3>), 10000);
- DiskBuffer & dbuf = bc->getDiskBuffer();
- // Make a box from 0-10 in 3D
- MDBox<MDLeanEvent<3>,3> * c = new MDBox<MDLeanEvent<3>,3>(bc, 0);
- for (size_t d=0; d<3; d++) c->setExtents(d, 0, 10);
-
- // Create and open the test NXS file
- ::NeXus::File * file = MDBoxTest::do_saveAndOpenNexus(*c, "MDGridBoxTest.nxs");
- TSM_ASSERT_EQUALS( "1000 events (on file)", c->getNPoints(), 1000);
-
- // At this point the MDBox is set to be on disk
- TSM_ASSERT_EQUALS( "No free blocks to start with", dbuf.getFreeSpaceMap().size(), 0);
-
- // Construct the grid box by splitting the MDBox
- MDGridBox<MDLeanEvent<3>,3> * gb = new MDGridBox<MDLeanEvent<3>,3>(c);
- TSM_ASSERT_EQUALS( "Grid box also has 1000 points", gb->getNPoints(), 1000);
- TSM_ASSERT_EQUALS( "Grid box has 125 children (5x5x5)", gb->getNumChildren(), 125);
- TSM_ASSERT_EQUALS( "The old spot in the file is now free", dbuf.getFreeSpaceMap().size(), 1);
-
- // Get a child
- MDBox<MDLeanEvent<3>,3> * b = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(gb->getChild(22));
- TSM_ASSERT_EQUALS( "Child has 8 events", b->getNPoints(), 8);
- TSM_ASSERT_EQUALS( "Child is NOT on disk", b->getOnDisk(), false);
-
- file->close();
- MDBoxTest::do_deleteNexusFile("MDGridBoxTest.nxs");
- }
-
-
- //-----------------------------------------------------------------------------------------
- /** Manually setting children of a grid box (for NXS file loading) */
- void test_setChildren()
- {
- // Build the grid box
- MDGridBox<MDLeanEvent<1>,1> * g = MDEventsTestHelper::makeMDGridBox<1>(10,10,0.0, 10.0);
- std::vector<MDBoxBase<MDLeanEvent<1>,1>*> boxes;
- for (size_t i=0; i<15; i++)
- boxes.push_back( MDEventsTestHelper::makeMDBox1() );
- TS_ASSERT_THROWS_NOTHING( g->setChildren(boxes, 2, 12) );
-
- TS_ASSERT_EQUALS( g->getNumChildren(), 10);
- for (size_t i=2; i<12; i++)
- {
- TS_ASSERT_EQUALS( g->getChild(i-2), boxes[i]);
- // Parent was set correctly in child
- TS_ASSERT_EQUALS( g->getChild(i-2)->getParent(), g);
- }
- }
-
- void test_getChildIndexFromID()
- {
- // Build the grid box
- MDGridBox<MDLeanEvent<1>,1> * g = MDEventsTestHelper::makeMDGridBox<1>(10,10,0.0, 10.0);
- TS_ASSERT_EQUALS(g->getChildIndexFromID( g->getChild(0)->getId() ), 0);
- TS_ASSERT_EQUALS(g->getChildIndexFromID( g->getChild(5)->getId() ), 5);
- TS_ASSERT_EQUALS(g->getChildIndexFromID(0), size_t(-1) );
- TS_ASSERT_EQUALS(g->getChildIndexFromID(11), size_t(-1) );
- }
-
-
-
- //-------------------------------------------------------------------------------------
- /** Build a 3D MDGridBox and check that the boxes created within are where you expect */
- void test_MDGridBox3()
- {
- MDBox<MDLeanEvent<3>,3> * b = MDEventsTestHelper::makeMDBox3();
- // Build the grid box out of it
- MDGridBox<MDLeanEvent<3>,3> * g = new MDGridBox<MDLeanEvent<3>,3>(b);
- TS_ASSERT_EQUALS(g->getNumDims(), 3);
-
- // Check the boxes
- std::vector<MDBoxBase<MDLeanEvent<3>,3> *> boxes = g->getBoxes();
- TS_ASSERT_EQUALS( boxes.size(), 10*5*2);
- for (size_t i=0; i<boxes.size(); i++)
- {
- MDBox<MDLeanEvent<3>,3> * box = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(boxes[i]);
- TS_ASSERT( box );
- }
- MDBox<MDLeanEvent<3>,3> * box;
- box = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(boxes[1]);
- MDEventsTestHelper::extents_match(box, 0, 1.0, 2.0);
- MDEventsTestHelper::extents_match(box, 1, 0.0, 2.0);
- MDEventsTestHelper::extents_match(box, 2, 0.0, 5.0);
- box = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(boxes[10]);
- MDEventsTestHelper::extents_match(box, 0, 0.0, 1.0);
- MDEventsTestHelper::extents_match(box, 1, 2.0, 4.0);
- MDEventsTestHelper::extents_match(box, 2, 0.0, 5.0);
- box = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(boxes[53]);
- MDEventsTestHelper::extents_match(box, 0, 3.0, 4.0);
- MDEventsTestHelper::extents_match(box, 1, 0.0, 2.0);
- MDEventsTestHelper::extents_match(box, 2, 5.0, 10.0);
- }
-
-
- //-------------------------------------------------------------------------------------
- /** Start with a grid box, split some of its contents into sub-gridded boxes. */
- void test_splitContents()
- {
- MDGridBox<MDLeanEvent<2>,2> * superbox = MDEventsTestHelper::makeMDGridBox<2>();
- MDGridBox<MDLeanEvent<2>,2> * gb;
- MDBox<MDLeanEvent<2>,2> * b;
-
- std::vector<MDBoxBase<MDLeanEvent<2>,2>*> boxes;
-
- // Start with 100 boxes
- TS_ASSERT_EQUALS( superbox->getNumMDBoxes(), 100);
- // And ID 0
- TS_ASSERT_EQUALS( superbox->getId(), 0 );
-
- // The box is a MDBox at first
- boxes = superbox->getBoxes();
- b = dynamic_cast<MDBox<MDLeanEvent<2>,2> *>(boxes[0]);
- TS_ASSERT( b );
- TS_ASSERT_DELTA( b->getVolume(), 1.0, 1e-5 );
-
- // It is the first child, so ID is 1
- TS_ASSERT_EQUALS( b->getId(), 1 );
- // There were 101 assigned IDs
- TS_ASSERT_EQUALS( b->getBoxController()->getMaxId(), 100+1);
-
- TS_ASSERT_THROWS_NOTHING(superbox->splitContents(0));
-
- // Now, it has turned into a GridBox
- boxes = superbox->getBoxes();
- gb = dynamic_cast<MDGridBox<MDLeanEvent<2>,2> *>(boxes[0]);
- TS_ASSERT( gb );
- TS_ASSERT_DELTA( gb->getVolume(), 1.0, 1e-5 );
-
- // ID of first child remains unchanged at 1
- TS_ASSERT_EQUALS( gb->getId(), 1 );
- // There were 101 assigned IDs
- TS_ASSERT_EQUALS( gb->getBoxController()->getMaxId(), 200+1);
- // The first child of the sub-divided box got 101 as its id
- TS_ASSERT_EQUALS( gb->getBoxes()[0]->getId(), 101 );
-
- // There are now 199 MDBoxes; the 99 at level 1, and 100 at level 2
- TS_ASSERT_EQUALS( superbox->getNumMDBoxes(), 199);
-
- // You can split it again and it does nothing
- TS_ASSERT_THROWS_NOTHING(superbox->splitContents(0));
-
- // Still a grid box
- boxes = superbox->getBoxes();
- gb = dynamic_cast<MDGridBox<MDLeanEvent<2>,2> *>(boxes[0]);
- TS_ASSERT( gb );
- }
-
- //-------------------------------------------------------------------------------------
- /** Adding a single event pushes it as deep as the current grid
- * hierarchy allows
- */
- void test_addEvent_with_recursive_gridding()
- {
- MDGridBox<MDLeanEvent<2>,2> * gb;
- MDBox<MDLeanEvent<2>,2> * b;
- std::vector<MDBoxBase<MDLeanEvent<2>,2>*> boxes;
-
- // 10x10 box, extents 0-10.0
- MDGridBox<MDLeanEvent<2>,2> * superbox = MDEventsTestHelper::makeMDGridBox<2>();
- // And the 0-th box is further split (
- TS_ASSERT_THROWS_NOTHING(superbox->splitContents(0));
-
- TS_ASSERT_EQUALS( superbox->getNPoints(), 0 );
- { // One event in 0th box of the 0th box.
- double centers[2] = {0.05, 0.05};
- superbox->addEvent( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
- { // One event in 1st box of the 0th box.
- double centers[2] = {0.15, 0.05};
- superbox->addEvent( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
- { // One event in 99th box.
- double centers[2] = {9.5, 9.5};
- superbox->addEvent( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
-
- // You must refresh the cache after adding individual events.
- superbox->refreshCache(NULL);
- superbox->refreshCentroid(NULL);
-
- TS_ASSERT_EQUALS( superbox->getNPoints(), 3 );
-
-#ifdef MDBOX_TRACK_CENTROID
- // Check the centroid for these 3 events
- TS_ASSERT_DELTA( superbox->getCentroid(0), 3.233, 0.001);
- TS_ASSERT_DELTA( superbox->getCentroid(1), 3.200, 0.001);
-#endif
-
- // Retrieve the 0th grid box
- boxes = superbox->getBoxes();
- gb = dynamic_cast<MDGridBox<MDLeanEvent<2>,2> *>(boxes[0]);
- TS_ASSERT( gb );
-
- // It has two points
- TS_ASSERT_EQUALS( gb->getNPoints(), 2 );
-
- // Retrieve the MDBox at 0th and 1st indexes in THAT gridbox
- boxes = gb->getBoxes();
- b = dynamic_cast<MDBox<MDLeanEvent<2>,2> *>(boxes[0]);
- TS_ASSERT_EQUALS( b->getNPoints(), 1 );
- b = dynamic_cast<MDBox<MDLeanEvent<2>,2> *>(boxes[1]);
- TS_ASSERT_EQUALS( b->getNPoints(), 1 );
-
- // Get the 99th box at the first level. It is not split
- boxes = superbox->getBoxes();
- b = dynamic_cast<MDBox<MDLeanEvent<2>,2> *>(boxes[99]);
- TS_ASSERT( b ); if (!b) return;
- // And it has only the one point
- TS_ASSERT_EQUALS( b->getNPoints(), 1 );
- }
-
- //-------------------------------------------------------------------------------------
- void test_transformDimensions()
- {
- MDBox<MDLeanEvent<1>,1> * b = MDEventsTestHelper::makeMDBox1();
- // Give it 10 events
- const std::vector<MDLeanEvent<1> > events = MDEventsTestHelper::makeMDEvents1(10);
- b->addEvents( events );
- MDGridBox<MDLeanEvent<1>,1> * g = new MDGridBox<MDLeanEvent<1>,1>(b);
- TSM_ASSERT_EQUALS("MDBoxes start with 1 each.", g->getChild(9)->getNPoints(), 1);
-
- std::vector<double> scaling(1, 3.0);
- std::vector<double> offset(1, 1.0);
- g->transformDimensions(scaling, offset);
-
- TS_ASSERT_DELTA(g->getVolume(), 30.0, 1e-5);
- MDLeanEvent<1> ev;
- ev.setCenter(0, 30.9f);
- g->addEvent(ev);
- TSM_ASSERT_EQUALS("New event was added in the right spot.", g->getChild(9)->getNPoints(), 2);
- }
-
-
-
- //-------------------------------------------------------------------------------------
- /** Recursive getting of a list of MDBoxBase */
- void test_getBoxes()
- {
- MDGridBox<MDLeanEvent<1>,1> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<1>(3,3);
- TS_ASSERT(parent);
- std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes;
-
- boxes.clear();
- parent->getBoxes(boxes, 0, false);
- TS_ASSERT_EQUALS( boxes.size(), 1);
- TS_ASSERT_EQUALS( boxes[0], parent);
-
- boxes.clear();
- parent->getBoxes(boxes, 1, false);
- TS_ASSERT_EQUALS( boxes.size(), 4);
- TS_ASSERT_EQUALS( boxes[0], parent);
- TS_ASSERT_EQUALS( boxes[1]->getDepth(), 1);
-
- boxes.clear();
- parent->getBoxes(boxes, 2, false);
- TS_ASSERT_EQUALS( boxes.size(), 4+9);
- TS_ASSERT_EQUALS( boxes[0], parent);
- TS_ASSERT_EQUALS( boxes[1]->getDepth(), 1);
- TS_ASSERT_EQUALS( boxes[2]->getDepth(), 2);
-
- boxes.clear();
- parent->getBoxes(boxes, 3, false);
- TS_ASSERT_EQUALS( boxes.size(), 4+9+27);
-
- // Leaves only = only report the deepest boxes.
- boxes.clear();
- parent->getBoxes(boxes, 3, true);
- TS_ASSERT_EQUALS( boxes.size(), 27);
- TS_ASSERT_EQUALS( boxes[0]->getDepth(), 3);
-
- // Leaves only, with limited depth = report the max depth if that is the effective 'leaf'
- boxes.clear();
- parent->getBoxes(boxes, 2, true);
- TS_ASSERT_EQUALS( boxes.size(), 9);
- TS_ASSERT_EQUALS( boxes[0]->getDepth(), 2);
- }
-
-
- //-------------------------------------------------------------------------------------
- /** Recursive getting of a list of MDBoxBase, with an implicit function limiting it */
- void test_getBoxes_ImplicitFunction()
- {
-
- MDGridBox<MDLeanEvent<1>,1> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<1>(4,3);
- TS_ASSERT(parent);
- std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes;
-
- // Function of everything x > 1.51
- MDImplicitFunction * function = new MDImplicitFunction;
- coord_t normal[1] = {+1};
- coord_t origin[1] = {1.51f};
- function->addPlane( MDPlane(1, normal, origin) );
-
- boxes.clear();
- parent->getBoxes(boxes, 3, false, function);
- TS_ASSERT_EQUALS( boxes.size(), 54);
- // The boxes extents make sense
- for (size_t i=0; i<boxes.size(); i++)
- {
- TS_ASSERT( boxes[i]->getExtents(0).max >= 1.51);
- }
-
- // --- Now leaf-only ---
- boxes.clear();
- parent->getBoxes(boxes, 3, true, function);
- TS_ASSERT_EQUALS( boxes.size(), 40);
- // The boxes extents make sense
- for (size_t i=0; i<boxes.size(); i++)
- {
- TS_ASSERT( boxes[i]->getExtents(0).max >= 1.51);
- }
-
- // Limit by another plane
- coord_t normal2[1] = {-1};
- coord_t origin2[1] = {2.99f};
- function->addPlane( MDPlane(1, normal2, origin2) );
- boxes.clear();
- parent->getBoxes(boxes, 3, false, function);
- TS_ASSERT_EQUALS( boxes.size(), 33);
- for (size_t i=0; i<boxes.size(); i++)
- {
- TS_ASSERT( boxes[i]->getExtents(0).max >= 1.51);
- TS_ASSERT( boxes[i]->getExtents(0).min <= 2.99);
- }
-
- // Same, leaf only
- boxes.clear();
- parent->getBoxes(boxes, 3, true, function);
- TS_ASSERT_EQUALS( boxes.size(), 24);
- for (size_t i=0; i<boxes.size(); i++)
- {
- TS_ASSERT( boxes[i]->getExtents(0).max >= 1.51);
- TS_ASSERT( boxes[i]->getExtents(0).min <= 2.99);
- }
-
- // ----- Infinitely thin plane for an implicit function ------------
- function = new MDImplicitFunction;
- coord_t normal3[1] = {-1};
- coord_t origin3[1] = {1.51f};
- function->addPlane( MDPlane(1, normal, origin) );
- function->addPlane( MDPlane(1, normal3, origin3) );
-
- boxes.clear();
- parent->getBoxes(boxes, 3, true, function);
- TSM_ASSERT_EQUALS( "Only one box is found by an infinitely thin plane", boxes.size(), 1);
-
- }
-
-
-
- //-------------------------------------------------------------------------------------
- /** Recursive getting of a list of MDBoxBase, with an implicit function limiting it */
- void test_getBoxes_ImplicitFunction_2D()
- {
-
- MDGridBox<MDLeanEvent<2>,2> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<2>(4,1);
- TS_ASSERT(parent);
- std::vector<MDBoxBase<MDLeanEvent<2>,2> *> boxes;
-
- // Function of x,y between 2 and 3
- std::vector<coord_t> min(2, 1.99f);
- std::vector<coord_t> max(2, 3.01f);
- MDImplicitFunction * function = new MDBoxImplicitFunction(min, max);
-
- boxes.clear();
- parent->getBoxes(boxes, 3, false, function);
- TS_ASSERT_EQUALS( boxes.size(), 46);
- // The boxes extents make sense
- for (size_t i=0; i<boxes.size(); i++)
- {
- //std::cout << boxes[i]->getExtentsStr() << std::endl;
- TS_ASSERT( boxes[i]->getExtents(0).max >= 2.00);
- TS_ASSERT( boxes[i]->getExtents(0).min <= 3.00);
- TS_ASSERT( boxes[i]->getExtents(1).max >= 2.00);
- TS_ASSERT( boxes[i]->getExtents(1).min <= 3.00);
- }
-
- // -- Leaf only ---
- boxes.clear();
- parent->getBoxes(boxes, 3, true, function);
- TS_ASSERT_EQUALS( boxes.size(), 16+4*4+4); //16 in the center one + 4x4 at the 4 edges + 4 at the corners
- // The boxes extents make sense
- for (size_t i=0; i<boxes.size(); i++)
- {
- //std::cout << boxes[i]->getExtentsStr() << std::endl;
- TS_ASSERT( boxes[i]->getExtents(0).max >= 2.00);
- TS_ASSERT( boxes[i]->getExtents(0).min <= 3.00);
- TS_ASSERT( boxes[i]->getExtents(1).max >= 2.00);
- TS_ASSERT( boxes[i]->getExtents(1).min <= 3.00);
- }
-
- }
-
-
-
- //-------------------------------------------------------------------------------------
- /** Recursive getting of a list of MDBoxBase, with an implicit function limiting it.
- * This implicit function is a box of size 0. */
- void test_getBoxes_ZeroSizeImplicitFunction_2D()
- {
- MDGridBox<MDLeanEvent<2>,2> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<2>(4,1);
- TS_ASSERT(parent);
- std::vector<MDBoxBase<MDLeanEvent<2>,2> *> boxes;
-
- // Function of x,y with 0 width and height
- std::vector<coord_t> min(2, 1.99f);
- std::vector<coord_t> max(2, 1.99f);
- MDImplicitFunction * function = new MDBoxImplicitFunction(min, max);
-
- boxes.clear();
- parent->getBoxes(boxes, 3, false, function);
- // Returns 3 boxes: the big one with everything, the size 1 under, and the size 0.25 under that
- TS_ASSERT_EQUALS( boxes.size(), 3);
-
- // Leaf only: returns only one box
- boxes.clear();
- parent->getBoxes(boxes, 3, true, function);
- TS_ASSERT_EQUALS( boxes.size(), 1);
- TS_ASSERT_DELTA( boxes[0]->getExtents(0).min, 1.75, 1e-4);
- TS_ASSERT_DELTA( boxes[0]->getExtents(0).max, 2.00, 1e-4);
- }
-
- //-------------------------------------------------------------------------------------
- /** Recursive getting of a list of MDBoxBase, with an implicit function limiting it.
- * This implicit function is a box of size 0. */
- void test_getBoxes_ZeroSizeImplicitFunction_4D()
- {
- MDGridBox<MDLeanEvent<4>,4> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<4>(4,1);
- TS_ASSERT(parent);
- std::vector<MDBoxBase<MDLeanEvent<4>,4> *> boxes;
-
- // Function of x,y with 0 width and height
- std::vector<coord_t> min(4, 1.99f);
- std::vector<coord_t> max(4, 1.99f);
- MDImplicitFunction * function = new MDBoxImplicitFunction(min, max);
-
- boxes.clear();
- parent->getBoxes(boxes, 3, false, function);
- // Returns 3 boxes: the big one with everything, the size 1 under, and the size 0.25 under that
- TS_ASSERT_EQUALS( boxes.size(), 3);
-
- // Leaf only: returns only one box
- boxes.clear();
- parent->getBoxes(boxes, 3, true, function);
- TS_ASSERT_EQUALS( boxes.size(), 1);
- TS_ASSERT_DELTA( boxes[0]->getExtents(0).min, 1.75, 1e-4);
- TS_ASSERT_DELTA( boxes[0]->getExtents(0).max, 2.00, 1e-4);
- }
-
-
-
- //-------------------------------------------------------------------------------------
- /** Gauge how fast addEvent is with several levels of gridding
- * NOTE: DISABLED because it is slow.
- * */
- void xtest_addEvent_with_recursive_gridding_Performance()
- {
- // Make a 2D box split into 4, 4 levels deep. = 4^4^2 boxes at the bottom = 256^2 boxes.
- size_t numSplit = 4;
- for (size_t recurseLevels = 1; recurseLevels < 5; recurseLevels++)
- {
- std::cout << " --- Recursion Level " << recurseLevels << " --- " << std::endl;
- Timer tim1;
- double boxes_per_side = pow(double(numSplit), double(recurseLevels));
- double spacing = double(numSplit)/boxes_per_side;
- // How many times to add the same event
- size_t num_to_repeat = size_t(1e7 / (boxes_per_side*boxes_per_side));
-
- MDGridBox<MDLeanEvent<2>,2> * box = MDEventsTestHelper::makeRecursiveMDGridBox<2>(numSplit, recurseLevels);
- std::cout << tim1.elapsed() << " seconds to generate the " << boxes_per_side << "^2 boxes." << std::endl;
-
- for (double x=0; x < numSplit; x += spacing)
- for (double y=0; y < numSplit; y += spacing)
- {
- for (size_t i=0; i<num_to_repeat; i++)
- {
- coord_t centers[2] = {static_cast<coord_t>(x),static_cast<coord_t>(y)};
- box->addEvent( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
- }
- // You must refresh the cache after adding individual events.
- box->refreshCache(NULL);
-
- double sec = tim1.elapsed();
- std::cout << sec << " seconds to add " << box->getNPoints() << " events. Each box had " << num_to_repeat << " events." << std::endl;
- std::cout << "equals " << 1e6*sec/double(box->getNPoints()) << " seconds per million events." << std::endl;
- }
-
- }
-
-
-
- //-------------------------------------------------------------------------------------
- /** Fill a 10x10 gridbox with events
- *
- * Tests that bad events are thrown out when using addEvents.
- * */
- void test_addEvents_2D()
- {
- MDGridBox<MDLeanEvent<2>,2> * b = MDEventsTestHelper::makeMDGridBox<2>();
- std::vector< MDLeanEvent<2> > events;
-
- // Make an event in the middle of each box
- for (double x=0.5; x < 10; x += 1.0)
- for (double y=0.5; y < 10; y += 1.0)
- {
- coord_t centers[2] = {static_cast<coord_t>(x),static_cast<coord_t>(y)};
- events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
-
- size_t numbad = 0;
- TS_ASSERT_THROWS_NOTHING( numbad = b->addEvents( events ); );
- // Get the right totals again
- b->refreshCache(NULL);
- TS_ASSERT_EQUALS( numbad, 0);
- TS_ASSERT_EQUALS( b->getNPoints(), 100);
- TS_ASSERT_EQUALS( b->getSignal(), 100*2.0);
- TS_ASSERT_EQUALS( b->getErrorSquared(), 100*2.0);
- TS_ASSERT_DELTA( b->getSignalNormalized(), 100*2.0 / 100.0, 1e-5);
- TS_ASSERT_DELTA( b->getErrorSquaredNormalized(), 100*2.0 / 100.0, 1e-5);
-
- // Get all the boxes contained
- std::vector<MDBoxBase<MDLeanEvent<2>,2>*> boxes = b->getBoxes();
- TS_ASSERT_EQUALS( boxes.size(), 100);
- for (size_t i=0; i < boxes.size(); i++)
- {
- TS_ASSERT_EQUALS( boxes[i]->getNPoints(), 1);
- TS_ASSERT_EQUALS( boxes[i]->getSignal(), 2.0);
- TS_ASSERT_EQUALS( boxes[i]->getErrorSquared(), 2.0);
- TS_ASSERT_EQUALS( boxes[i]->getSignalNormalized(), 2.0);
- TS_ASSERT_EQUALS( boxes[i]->getErrorSquaredNormalized(), 2.0);
- }
-
- // Now try to add bad events (outside bounds)
- events.clear();
- for (double x=-5.0; x < 20; x += 20.0)
- for (double y=-5.0; y < 20; y += 20.0)
- {
- double centers[2] = {x,y};
- events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
- // Get the right totals again
- b->refreshCache(NULL);
- // All 4 points get rejected
- TS_ASSERT_THROWS_NOTHING( numbad = b->addEvents( events ); );
- TS_ASSERT_EQUALS( numbad, 4);
- // Number of points and signal is unchanged.
- TS_ASSERT_EQUALS( b->getNPoints(), 100);
- TS_ASSERT_EQUALS( b->getSignal(), 100*2.0);
- TS_ASSERT_EQUALS( b->getErrorSquared(), 100*2.0);
- }
-
-
- //-------------------------------------------------------------------------------------
- /** Tests add_events with limits into the vectorthat bad events are thrown out when using addEvents.
- * */
- void test_addEvents_start_stop()
- {
- MDGridBox<MDLeanEvent<2>,2> * b = MDEventsTestHelper::makeMDGridBox<2>();
- std::vector< MDLeanEvent<2> > events;
-
- // Make an event in the middle of each box
- for (double x=0.5; x < 10; x += 1.0)
- for (double y=0.5; y < 10; y += 1.0)
- {
- double centers[2] = {x,y};
- events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
-
- size_t numbad = 0;
- TS_ASSERT_THROWS_NOTHING( numbad = b->addEventsPart( events, 50, 60 ); );
- // Get the right totals again
- b->refreshCache(NULL);
- TS_ASSERT_EQUALS( numbad, 0);
- TS_ASSERT_EQUALS( b->getNPoints(), 10);
- TS_ASSERT_EQUALS( b->getSignal(), 10*2.0);
- TS_ASSERT_EQUALS( b->getErrorSquared(), 10*2.0);
- }
-
- //-------------------------------------------------------------------------------------
- /** Test that adding events (as vectors) in parallel does not cause
- * segfaults or incorrect totals.
- * */
- void do_test_addEvents_inParallel(ThreadScheduler * ts)
- {
- MDGridBox<MDLeanEvent<2>,2> * b = MDEventsTestHelper::makeMDGridBox<2>();
- int num_repeat = 1000;
-
- PARALLEL_FOR_NO_WSP_CHECK()
- for (int i=0; i < num_repeat; i++)
- {
- std::vector< MDLeanEvent<2> > events;
- // Make an event in the middle of each box
- for (double x=0.5; x < 10; x += 1.0)
- for (double y=0.5; y < 10; y += 1.0)
- {
- double centers[2] = {x,y};
- events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
- TS_ASSERT_THROWS_NOTHING( b->addEvents( events ); );
- }
- // Get the right totals again by refreshing
- b->refreshCache(ts);
- TS_ASSERT_EQUALS( b->getNPoints(), 100*num_repeat);
- TS_ASSERT_EQUALS( b->getSignal(), 100*num_repeat*2.0);
- TS_ASSERT_EQUALS( b->getErrorSquared(), 100*num_repeat*2.0);
- }
-
-
- void test_addEvents_inParallel()
- {
- do_test_addEvents_inParallel(NULL);
- }
-
- /** Disabled because parallel RefreshCache is not implemented. Might not be ever? */
- void xtest_addEvents_inParallel_then_refreshCache_inParallel()
- {
- ThreadScheduler * ts = new ThreadSchedulerFIFO();
- do_test_addEvents_inParallel(ts);
- ThreadPool tp(ts);
- tp.joinAll();
- }
-
-
- //-------------------------------------------------------------------------------------
- /** Get a sub-box at a given coord */
- void test_getBoxAtCoord()
- {
- MDGridBox<MDLeanEvent<2>,2> * b = MDEventsTestHelper::makeMDGridBox<2>();
- coord_t coords[2] = {1.5,1.5};
- const MDBoxBase<MDLeanEvent<2>,2> * c = b->getBoxAtCoord(coords);
- TS_ASSERT_EQUALS(c, b->getChild(11));
- }
-
-
- //-------------------------------------------------------------------------------------
- /** Test the routine that auto-splits MDBoxes into MDGridBoxes recursively.
- * It tests the max_depth of splitting too, because there are numerous
- * repeated events at exactly the same position = impossible to separate further.
- * */
- void test_splitAllIfNeeded()
- {
- typedef MDGridBox<MDLeanEvent<2>,2> gbox_t;
- typedef MDBox<MDLeanEvent<2>,2> box_t;
- typedef MDBoxBase<MDLeanEvent<2>,2> ibox_t;
-
- gbox_t * b = MDEventsTestHelper::makeMDGridBox<2>();
- b->getBoxController()->setSplitThreshold(100);
- b->getBoxController()->setMaxDepth(4);
-
- // Make a 1000 events at exactly the same point
- size_t num_repeat = 1000;
- std::vector< MDLeanEvent<2> > events;
- for (size_t i=0; i < num_repeat; i++)
- {
- // Make an event in the middle of each box
- double centers[2] = {1e-10, 1e-10};
- events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
- }
- TS_ASSERT_THROWS_NOTHING( b->addEvents( events ); );
-
-
- // Split into sub-grid boxes
- TS_ASSERT_THROWS_NOTHING( b->splitAllIfNeeded(NULL); )
-
- // Dig recursively into the gridded box hierarchies
- std::vector<ibox_t*> boxes;
- size_t expected_depth = 0;
- while (b)
- {
- expected_depth++;
- boxes = b->getBoxes();
-
- // Get the 0th box
- b = dynamic_cast<gbox_t*>(boxes[0]);
-
- // The 0-th box is a MDGridBox (it was split)
- // (though it is normal for b to be a MDBox when you reach the max depth)
- if (expected_depth < 4)
- { TS_ASSERT( b ) }
-
- // The 0-th box has all the points
- TS_ASSERT_EQUALS( boxes[0]->getNPoints(), num_repeat);
- // The 0-th box is at the expected_depth
- TS_ASSERT_EQUALS( boxes[0]->getDepth(), expected_depth);
-
- // The other boxes have nothing
- TS_ASSERT_EQUALS( boxes[1]->getNPoints(), 0);
- // The other box is a MDBox (it was not split)
- TS_ASSERT( dynamic_cast<box_t*>(boxes[1]) )
- }
-
- // We went this many levels (and no further) because recursion depth is limited
- TS_ASSERT_EQUALS(boxes[0]->getDepth(), 4);
- }
-
-
- //------------------------------------------------------------------------------------------------
- /** This test splits a large number of events, and uses a ThreadPool
- * to use all cores.
- */
- void test_splitAllIfNeeded_usingThreadPool()
- {
- typedef MDGridBox<MDLeanEvent<2>,2> gbox_t;
- typedef MDBox<MDLeanEvent<2>,2> box_t;
- typedef MDBoxBase<MDLeanEvent<2>,2> ibox_t;
-
- gbox_t * b = MDEventsTestHelper::makeMDGridBox<2>();
- b->getBoxController()->setSplitThreshold(100);
- b->getBoxController()->setMaxDepth(4);
-
- // Make a 1000 events in each sub-box
- size_t num_repeat = 1000;
- if (DODEBUG) num_repeat = 2000;
-
- Timer tim;
- if (DODEBUG) std::cout << "Adding " << num_repeat*100 << " events...\n";
- MDEventsTestHelper::feedMDBox<2>(b, num_repeat, 10, 0.5, 1.0);
- if (DODEBUG) std::cout << "Adding events done in " << tim.elapsed() << "!\n";
-
- // Split those boxes in parallel.
- ThreadSchedulerFIFO * ts = new ThreadSchedulerFIFO();
- ThreadPool tp(ts);
- b->splitAllIfNeeded(ts);
- tp.joinAll();
-
- if (DODEBUG) std::cout << "Splitting events done in " << tim.elapsed() << " sec.\n";
-
- // Now check the results. Each sub-box should be MDGridBox and have that many events
- std::vector<ibox_t*> boxes = b->getBoxes();
- TS_ASSERT_EQUALS(boxes.size(), 100);
- for (size_t i=0; i<boxes.size(); i++)
- {
- ibox_t * box = boxes[i];
- TS_ASSERT_EQUALS( box->getNPoints(), num_repeat );
- TS_ASSERT( dynamic_cast<gbox_t *>(box) );
-
- size_t numChildren = box->getNumChildren();
- if (numChildren > 0)
- {
- size_t lastId = box->getChild(0)->getId();
- for (size_t i = 1; i < numChildren; i++)
- {
- TSM_ASSERT_EQUALS("Children IDs need to be sequential!", box->getChild(i)->getId(), lastId+1);
- lastId = box->getChild(i)->getId();
- }
- }
-
- }
-
- }
-
-
-
-
- //------------------------------------------------------------------------------------------------
- /** This test splits a large number of events,
- * for a workspace that is backed by a file (and thus tries to stay below
- * a certain amount of memory used).
- */
- void test_splitAllIfNeeded_fileBacked()
- {
- typedef MDLeanEvent<2> MDE;
- typedef MDGridBox<MDE,2> gbox_t;
- typedef MDBox<MDE,2> box_t;
- typedef MDBoxBase<MDE,2> ibox_t;
-
- // Make a fake file-backing for the grid box
- std::string filename = "MDGridBoxTest.nxs";
- ::NeXus::File * file = new ::NeXus::File(filename, NXACC_CREATE);
- file->makeGroup("MDEventWorkspaceTest", "NXentry", 1);
- MDE::prepareNexusData(file, 2000);
- file->close();
- file = new ::NeXus::File(filename, NXACC_RDWR);
- file->openGroup("MDEventWorkspaceTest", "NXentry");
- MDE::openNexusData(file);
-
- // Create the grid box and make it file-backed.
- gbox_t * b = MDEventsTestHelper::makeMDGridBox<2>();
- BoxController_sptr bc = b->getBoxController();
- bc->setSplitThreshold(100);
- bc->setMaxDepth(4);
- bc->setCacheParameters(1, 1000);
- bc->setFile(file, filename, 0);
- DiskBuffer & dbuf = bc->getDiskBuffer();
- dbuf.setFileLength(0);
-
- size_t num_repeat = 10;
- if (DODEBUG) num_repeat = 20;
- Timer tim;
- if (DODEBUG) std::cout << "Adding " << num_repeat*10000 << " events...\n";
- MDEventsTestHelper::feedMDBox<2>(b, num_repeat, 100, 0.05f, 0.1f);
- if (DODEBUG) std::cout << "Adding events done in " << tim.elapsed() << "!\n";
-
- // Split those boxes in parallel.
- ThreadSchedulerFIFO * ts = new ThreadSchedulerFIFO();
- ThreadPool tp(ts);
- b->splitAllIfNeeded(ts);
- tp.joinAll();
-
- if (DODEBUG) std::cout << "Splitting events done in " << tim.elapsed() << " sec.\n";
-
- // Get all the MDBoxes created
- std::vector<ibox_t*> boxes;
- b->getBoxes(boxes, 1000, true);
- TS_ASSERT_EQUALS(boxes.size(), 10000);
- size_t numOnDisk = 0;
- uint64_t eventsOnDisk = 0;
- uint64_t maxFilePos = 0;
- for (size_t i=0; i<boxes.size(); i++)
- {
- ibox_t * box = boxes[i];
- TS_ASSERT_EQUALS( box->getNPoints(), num_repeat );
- box_t * mdbox = dynamic_cast<box_t *>(box);
- TS_ASSERT( mdbox);
- if ( mdbox->getOnDisk() ) numOnDisk++;
- eventsOnDisk += mdbox->getFileNumEvents();
- // Track the last point used in the file
- uint64_t fileEnd = mdbox->getFilePosition() + mdbox->getFileNumEvents();
- if (fileEnd > maxFilePos) maxFilePos = fileEnd;
- //std::cout << mdbox->getFilePosition() << " file pos " << i << std::endl;
- }
- TSM_ASSERT_EQUALS("All new boxes were set to be cached to disk.", numOnDisk, 10000);
- uint64_t minimumSaved = 10000*(num_repeat-2);
- TSM_ASSERT_LESS_THAN("Length of the file makes sense", minimumSaved, dbuf.getFileLength());
- TSM_ASSERT_LESS_THAN("Most of the boxes' events were cached to disk (some remain in memory because of the MRU cache)", minimumSaved, eventsOnDisk);
- TSM_ASSERT_LESS_THAN("And the events were properly saved sequentially in the files.", minimumSaved, maxFilePos);
- std::cout << dbuf.getMemoryStr() << std::endl;
- file->close();
- if (Poco::File(filename).exists()) Poco::File(filename).remove();
- }
-
-
-
- //------------------------------------------------------------------------------------------------
- /** Helper to make a 2D MDBin */
- MDBin<MDLeanEvent<2>,2> makeMDBin2(double minX, double maxX, double minY, double maxY)
- {
- MDBin<MDLeanEvent<2>,2> bin;
- bin.m_min[0] = static_cast<coord_t>(minX);
- bin.m_max[0] = static_cast<coord_t>(maxX);
- bin.m_min[1] = static_cast<coord_t>(minY);
- bin.m_max[1] = static_cast<coord_t>(maxY);
- return bin;
- }
-
- //------------------------------------------------------------------------------------------------
- /** Helper to test the binning of a 2D bin */
- void doTestMDBin2(MDGridBox<MDLeanEvent<2>,2> * b,
- const std::string & message,
- double minX, double maxX, double minY, double maxY, double expectedSignal)
- {
-// std::cout << "Bins: X " << std::setw(5) << minX << " to "<< std::setw(5) << maxX << ", Y " << std::setw(5) << minY << " to "<< std::setw(5) << maxY << ". " << message << std::endl;
-
- MDBin<MDLeanEvent<2>,2> bin;
- bin = makeMDBin2(minX, maxX, minY, maxY);
- b->centerpointBin(bin, NULL);
- TSM_ASSERT_DELTA( message, bin.m_signal, expectedSignal, 1e-5);
- }
-
- //------------------------------------------------------------------------------------------------
- /** Test binning in orthogonal axes */
- void test_centerpointBin()
- {
- typedef MDGridBox<MDLeanEvent<2>,2> gbox_t;
- typedef MDBox<MDLeanEvent<2>,2> box_t;
- typedef MDBoxBase<MDLeanEvent<2>,2> ibox_t;
-
- // 10x10 bins, 2 events per bin, each weight of 1.0
- gbox_t * b = MDEventsTestHelper::makeMDGridBox<2>();
- MDEventsTestHelper::feedMDBox<2>(b, 2);
- TS_ASSERT_DELTA( b->getSignal(), 200.0, 1e-5);
-
- MDBin<MDLeanEvent<2>,2> bin;
-
- doTestMDBin2(b, "Bin that is completely off",
- 10.1, 11.2, 1.9, 3.12, 0.0);
-
- doTestMDBin2(b, "Bin that is completely off (2)",
- 2, 3, -0.6, -0.1, 0.0);
-
- doTestMDBin2(b, "Bin that holds one entire MDBox (bigger than it)",
- 0.8, 2.2, 1.9, 3.12, 2.0);
-
- doTestMDBin2(b, "Bin that holds one entire MDBox (going off one edge)",
- -0.2, 1.2, 1.9, 3.12, 2.0);
-
- doTestMDBin2(b, "Bin that holds one entire MDBox (going off the other edge)",
- 8.9, 10.2, 1.9, 3.12, 2.0);
-
- doTestMDBin2(b, "Bin that holds one entire MDBox (going off both edge)",
- -0.2, 1.2, -0.2, 1.2, 2.0);
-
- doTestMDBin2(b, "Bin that holds one entire MDBox and a fraction of at least one more with something",
- 0.8, 2.7, 1.9, 3.12, 4.0);
-
- doTestMDBin2(b, "Bin that holds four entire MDBoxes",
- 0.8, 3.1, 0.9, 3.2, 8.0);
-
- doTestMDBin2(b, "Bin goes off two edges in one direction",
- -0.3, 10.2, 1.9, 3.1, 10*2.0);
-
- doTestMDBin2(b, "Bin that fits all within a single MDBox, and contains the center",
- 0.2, 0.8, 0.2, 0.8, 2.0);
-
- doTestMDBin2(b, "Bin that fits all within a single MDBox, and DOES NOT contain anything",
- 0.2, 0.3, 0.1, 0.2, 0.0);
-
- doTestMDBin2(b, "Bin that fits partially in two MDBox'es, and DOES NOT contain anything",
- 0.8, 1.2, 0.1, 0.2, 0.0);
-
- doTestMDBin2(b, "Bin that fits partially in two MDBox'es, and contains the centers",
- 0.2, 1.8, 0.1, 0.9, 4.0);
-
- doTestMDBin2(b, "Bin that fits partially in one MDBox'es, and goes of the edge",
- -3.2, 0.8, 0.1, 0.9, 2.0);
-
- }
-
-
-
-
-
- //------------------------------------------------------------------------------------------------
- /** For test_integrateSphere
- *
- * @param box
- * @param radius :: radius to integrate
- * @param numExpected :: how many events should be in there
- */
- void do_check_integrateSphere(MDGridBox<MDLeanEvent<2>,2> & box, double x, double y, const double radius, double numExpected, std::string message)
- {
- std::cout << "Sphere of radius " << radius << " at " << x << "," << y << "------" << message << "--\n";
- // The sphere transformation
- bool dimensionsUsed[2] = {true,true};
- coord_t center[2] = {static_cast<coord_t>(x),static_cast<coord_t>(y)};
- CoordTransformDistance sphere(2, center, dimensionsUsed);
-
- signal_t signal = 0;
- signal_t errorSquared = 0;
- box.integrateSphere(sphere, static_cast<coord_t>(radius*radius), signal, errorSquared);
- TSM_ASSERT_DELTA( message, signal, 1.0*numExpected, 1e-5);
- TSM_ASSERT_DELTA( message, errorSquared, 1.0*numExpected, 1e-5);
- }
-
- /** Re-used suite of tests */
- void do_test_integrateSphere(MDGridBox<MDLeanEvent<2>,2> * box_ptr)
- {
- // Events are at 0.5, 1.5, etc.
- MDGridBox<MDLeanEvent<2>,2> & box = *box_ptr;
- TS_ASSERT_EQUALS( box.getNPoints(), 10*10);
-
- do_check_integrateSphere(box, 4.5,4.5, 0.5, 1.0, "Too small to contain any vertices");
- do_check_integrateSphere(box, 4.5, 4.5, 0.001, 1.0, "Tiny but still has an event.");
- do_check_integrateSphere(box, 4.51,4.5, 0.001, 0.0, "Tiny but off the event.");
- do_check_integrateSphere(box, 2.0,2.0, 0.49, 0.0, "At a corner but grabbing nothing");
- do_check_integrateSphere(box, 4.8,4.5, 0.35, 1.0, "Too small to contain any vertices");
- do_check_integrateSphere(box, 5.0,5.0, 1.0, 4.0, "At a corner, containing 4 neighbors");
- do_check_integrateSphere(box, 4.5,4.5, 0.9, 1.0, "Contains one box completely");
- do_check_integrateSphere(box, 0.5,0.5, 0.9, 1.0, "Contains one box completely, at the edges");
- do_check_integrateSphere(box, 9.5,0.5, 0.9, 1.0, "Contains one box completely, at the edges");
- do_check_integrateSphere(box, 0.5,9.5, 0.9, 1.0, "Contains one box completely, at the edges");
- do_check_integrateSphere(box, 4.5,9.5, 0.9, 1.0, "Contains one box completely, at the edges");
- do_check_integrateSphere(box, 9.5,9.5, 0.9, 1.0, "Contains one box completely, at the edges");
- do_check_integrateSphere(box, 1.5,1.5, 1.95, 9.0, "Contains 5 boxes completely, and 4 boxes with a point");
- do_check_integrateSphere(box, -1.0,0.5, 1.55, 1.0, "Off an edge but enough to get an event");
-
- // Now I add an event very near an edge
- double center[2] = {0.001, 0.5};
- box.addEvent(MDLeanEvent<2>(1.0, 1.0, center));
- do_check_integrateSphere(box, -1.0,0.5, 1.01, 1.0, "Off an edge but just barely enough to get an event");
- do_check_integrateSphere(box, 0.0,0.5, 0.01, 1.0, "Tiny, but just barely enough to get an event");
- }
-
- /** Test of sphere integration with even splitting*/
- void test_integrateSphere()
- {
- // 10x10 sized box
- MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>();
- MDEventsTestHelper::feedMDBox<2>(box_ptr, 1);
- do_test_integrateSphere(box_ptr);
- }
-
- void test_integrateSphere_unevenSplit()
- {
- // 10x5 sized box
- MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>(10,5);
- MDEventsTestHelper::feedMDBox<2>(box_ptr, 1);
- do_test_integrateSphere(box_ptr);
- }
-
- void test_integrateSphere_unevenSplit2()
- {
- // Funnier splitting: 3x7 sized box
- MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>(3,7);
- MDEventsTestHelper::feedMDBox<2>(box_ptr, 1);
- do_test_integrateSphere(box_ptr);
- }
-
-
- /** Had a really-hard to find bug where the tests worked only
- * if the extents started at 0.0.
- * This test has a box from -10.0 to +10.0 to check for that
- */
- void test_integrateSphere_dimensionsDontStartAtZero()
- {
- MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>(10,10, -10.0);
- // One event at center of each box
- MDEventsTestHelper::feedMDBox<2>(box_ptr, 1, 10, -9.0, 2.0);
- MDGridBox<MDLeanEvent<2>,2> & box = *box_ptr;
- TS_ASSERT_EQUALS( box.getNPoints(), 10*10);
-
- do_check_integrateSphere(box, 1.0,1.0, 1.45, 1.0, "Contains one box completely");
- do_check_integrateSphere(box, 9.0,9.0, 1.45, 1.0, "Contains one box completely, at the edges");
- }
-
-
- //------------------------------------------------------------------------------------------------
- /** For test_integrateSphere3d
- *
- * @param box
- * @param radius :: radius to integrate
- * @param numExpected :: how many events should be in there
- */
- void do_check_integrateSphere3d(MDGridBox<MDLeanEvent<3>,3> & box, double x, double y, double z,
- const double radius, double numExpected, std::string message)
- {
- std::cout << "Sphere of radius " << radius << " at " << x << "," << y << "," << z << "--- " << message << " ---------\n";
- // The sphere transformation
- bool dimensionsUsed[3] = {true,true, true};
- coord_t center[3] = {static_cast<coord_t>(x),static_cast<coord_t>(y),static_cast<coord_t>(z)};
- CoordTransformDistance sphere(3, center, dimensionsUsed);
-
- signal_t signal = 0;
- signal_t errorSquared = 0;
- box.integrateSphere(sphere, static_cast<coord_t>(radius*radius), signal, errorSquared);
- TSM_ASSERT_DELTA( message, signal, 1.0*numExpected, 1e-5);
- TSM_ASSERT_DELTA( message, errorSquared, 1.0*numExpected, 1e-5);
- }
-
- //------------------------------------------------------------------------------------------------
- void test_integrateSphere3d()
- {
- MDGridBox<MDLeanEvent<3>,3> * box_ptr = MDEventsTestHelper::makeMDGridBox<3>();
- MDEventsTestHelper::feedMDBox<3>(box_ptr, 1);
- MDGridBox<MDLeanEvent<3>,3> & box = *box_ptr;
- TS_ASSERT_EQUALS( box.getNPoints(), 10*10*10);
-
- do_check_integrateSphere3d(box, 0.5,0.5,0.5, 0.9, 1.0, "Contains one box completely, at a corner");
- do_check_integrateSphere3d(box, 9.5,9.5,9.5, 0.9, 1.0, "Contains one box completely, at a corner");
- do_check_integrateSphere3d(box, 9.5,9.5,9.5, 0.85, 1.0, "Does NOT contain one box completely, at a corner");
- do_check_integrateSphere3d(box, 9.0,9.0,9.0, 1.75, 20.0, "Contains 8 boxes completely, at a corner");
- do_check_integrateSphere3d(box, 9.0,9.0,9.0, 1.70, 20.0, "Does NOT contains one box completely, at a corner");
-
- // Now I add an event very near an edge
- double center[3] = {0.001, 0.5, 0.5};
- box.addEvent(MDLeanEvent<3>(2.0, 2.0, center));
+//
+// }
+//
+//
+//
+// //-------------------------------------------------------------------------------------
+// void test_MDGridBox_constructor_from_MDBox()
+// {
+// MDBox<MDLeanEvent<1>,1> * b = MDEventsTestHelper::makeMDBox1();
+// // Start at ID 0.
+// TS_ASSERT_EQUALS( b->getId(), 0);
+// // Give it 10 events
+// const std::vector<MDLeanEvent<1> > events = MDEventsTestHelper::makeMDEvents1(10);
+// b->addEvents( events );
+// TS_ASSERT_EQUALS( b->getNPoints(), 10 );
+// TS_ASSERT_DELTA(b->getVolume(), 10.0, 1e-5);
+//
+// // Build the grid box out of it
+// MDGridBox<MDLeanEvent<1>,1> * g = new MDGridBox<MDLeanEvent<1>,1>(b);
+//
+// // Perform a detailed check
+// check_MDGridBox(g);
+//
+// // Now we add 10 more events
+// g->addEvents( MDEventsTestHelper::makeMDEvents1(10) );
+//
+// // And now there should be 2 events per box
+// std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes = g->getBoxes();
+// for (size_t i=0; i<10; i++)
+// {
+// MDBox<MDLeanEvent<1>,1> * box = dynamic_cast<MDBox<MDLeanEvent<1>,1> *>(boxes[i]);
+// TS_ASSERT_EQUALS(box->getNPoints(), 2);
+// }
+// }
+//
+//
+// //-------------------------------------------------------------------------------------
+// void test_MDGridBox_copy_constructor()
+// {
+// MDBox<MDLeanEvent<1>,1> * b = MDEventsTestHelper::makeMDBox1();
+// TS_ASSERT_EQUALS( b->getId(), 0);
+// const std::vector<MDLeanEvent<1> > events = MDEventsTestHelper::makeMDEvents1(10);
+// b->addEvents( events );
+// TS_ASSERT_EQUALS( b->getNPoints(), 10 );
+// TS_ASSERT_DELTA(b->getVolume(), 10.0, 1e-5);
+//
+// // Build the grid box out of it
+// MDGridBox<MDLeanEvent<1>,1> * g1 = new MDGridBox<MDLeanEvent<1>,1>(b);
+// MDGridBox<MDLeanEvent<1>,1> * g2 = new MDGridBox<MDLeanEvent<1>,1>(*g1);
+//
+// // Perform a detailed check
+// check_MDGridBox(g2);
+// }
+//
+//
+//
+// //-----------------------------------------------------------------------------------------
+// /** Test splitting of a MDBox into a MDGridBox when the
+// * original box is backed by a file. */
+// void test_fileBackEnd_construction()
+// {
+// // Create a box with a controller for the back-end
+// BoxController_sptr bc(new BoxController(3));
+// bc->setSplitInto(5);
+// // Handle the disk MRU values
+// bc->setCacheParameters(sizeof(MDLeanEvent<3>), 10000);
+// DiskBuffer & dbuf = bc->getDiskBuffer();
+// // Make a box from 0-10 in 3D
+// MDBox<MDLeanEvent<3>,3> * c = new MDBox<MDLeanEvent<3>,3>(bc, 0);
+// for (size_t d=0; d<3; d++) c->setExtents(d, 0, 10);
+//
+// // Create and open the test NXS file
+// ::NeXus::File * file = MDBoxTest::do_saveAndOpenNexus(*c, "MDGridBoxTest.nxs");
+// TSM_ASSERT_EQUALS( "1000 events (on file)", c->getNPoints(), 1000);
+//
+// // At this point the MDBox is set to be on disk
+// TSM_ASSERT_EQUALS( "No free blocks to start with", dbuf.getFreeSpaceMap().size(), 0);
+//
+// // Construct the grid box by splitting the MDBox
+// MDGridBox<MDLeanEvent<3>,3> * gb = new MDGridBox<MDLeanEvent<3>,3>(c);
+// TSM_ASSERT_EQUALS( "Grid box also has 1000 points", gb->getNPoints(), 1000);
+// TSM_ASSERT_EQUALS( "Grid box has 125 children (5x5x5)", gb->getNumChildren(), 125);
+// TSM_ASSERT_EQUALS( "The old spot in the file is now free", dbuf.getFreeSpaceMap().size(), 1);
+//
+// // Get a child
+// MDBox<MDLeanEvent<3>,3> * b = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(gb->getChild(22));
+// TSM_ASSERT_EQUALS( "Child has 8 events", b->getNPoints(), 8);
+// TSM_ASSERT_EQUALS( "Child is NOT on disk", b->getOnDisk(), false);
+//
+// file->close();
+// MDBoxTest::do_deleteNexusFile("MDGridBoxTest.nxs");
+// }
+//
+//
+// //-----------------------------------------------------------------------------------------
+// /** Manually setting children of a grid box (for NXS file loading) */
+// void test_setChildren()
+// {
+// // Build the grid box
+// MDGridBox<MDLeanEvent<1>,1> * g = MDEventsTestHelper::makeMDGridBox<1>(10,10,0.0, 10.0);
+// std::vector<MDBoxBase<MDLeanEvent<1>,1>*> boxes;
+// for (size_t i=0; i<15; i++)
+// boxes.push_back( MDEventsTestHelper::makeMDBox1() );
+// TS_ASSERT_THROWS_NOTHING( g->setChildren(boxes, 2, 12) );
+//
+// TS_ASSERT_EQUALS( g->getNumChildren(), 10);
+// for (size_t i=2; i<12; i++)
+// {
+// TS_ASSERT_EQUALS( g->getChild(i-2), boxes[i]);
+// // Parent was set correctly in child
+// TS_ASSERT_EQUALS( g->getChild(i-2)->getParent(), g);
+// }
+// }
+//
+// void test_getChildIndexFromID()
+// {
+// // Build the grid box
+// MDGridBox<MDLeanEvent<1>,1> * g = MDEventsTestHelper::makeMDGridBox<1>(10,10,0.0, 10.0);
+// TS_ASSERT_EQUALS(g->getChildIndexFromID( g->getChild(0)->getId() ), 0);
+// TS_ASSERT_EQUALS(g->getChildIndexFromID( g->getChild(5)->getId() ), 5);
+// TS_ASSERT_EQUALS(g->getChildIndexFromID(0), size_t(-1) );
+// TS_ASSERT_EQUALS(g->getChildIndexFromID(11), size_t(-1) );
+// }
+//
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Build a 3D MDGridBox and check that the boxes created within are where you expect */
+// void test_MDGridBox3()
+// {
+// MDBox<MDLeanEvent<3>,3> * b = MDEventsTestHelper::makeMDBox3();
+// // Build the grid box out of it
+// MDGridBox<MDLeanEvent<3>,3> * g = new MDGridBox<MDLeanEvent<3>,3>(b);
+// TS_ASSERT_EQUALS(g->getNumDims(), 3);
+//
+// // Check the boxes
+// std::vector<MDBoxBase<MDLeanEvent<3>,3> *> boxes = g->getBoxes();
+// TS_ASSERT_EQUALS( boxes.size(), 10*5*2);
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// MDBox<MDLeanEvent<3>,3> * box = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(boxes[i]);
+// TS_ASSERT( box );
+// }
+// MDBox<MDLeanEvent<3>,3> * box;
+// box = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(boxes[1]);
+// MDEventsTestHelper::extents_match(box, 0, 1.0, 2.0);
+// MDEventsTestHelper::extents_match(box, 1, 0.0, 2.0);
+// MDEventsTestHelper::extents_match(box, 2, 0.0, 5.0);
+// box = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(boxes[10]);
+// MDEventsTestHelper::extents_match(box, 0, 0.0, 1.0);
+// MDEventsTestHelper::extents_match(box, 1, 2.0, 4.0);
+// MDEventsTestHelper::extents_match(box, 2, 0.0, 5.0);
+// box = dynamic_cast<MDBox<MDLeanEvent<3>,3> *>(boxes[53]);
+// MDEventsTestHelper::extents_match(box, 0, 3.0, 4.0);
+// MDEventsTestHelper::extents_match(box, 1, 0.0, 2.0);
+// MDEventsTestHelper::extents_match(box, 2, 5.0, 10.0);
+// }
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Start with a grid box, split some of its contents into sub-gridded boxes. */
+// void test_splitContents()
+// {
+// MDGridBox<MDLeanEvent<2>,2> * superbox = MDEventsTestHelper::makeMDGridBox<2>();
+// MDGridBox<MDLeanEvent<2>,2> * gb;
+// MDBox<MDLeanEvent<2>,2> * b;
+//
+// std::vector<MDBoxBase<MDLeanEvent<2>,2>*> boxes;
+//
+// // Start with 100 boxes
+// TS_ASSERT_EQUALS( superbox->getNumMDBoxes(), 100);
+// // And ID 0
+// TS_ASSERT_EQUALS( superbox->getId(), 0 );
+//
+// // The box is a MDBox at first
+// boxes = superbox->getBoxes();
+// b = dynamic_cast<MDBox<MDLeanEvent<2>,2> *>(boxes[0]);
+// TS_ASSERT( b );
+// TS_ASSERT_DELTA( b->getVolume(), 1.0, 1e-5 );
+//
+// // It is the first child, so ID is 1
+// TS_ASSERT_EQUALS( b->getId(), 1 );
+// // There were 101 assigned IDs
+// TS_ASSERT_EQUALS( b->getBoxController()->getMaxId(), 100+1);
+//
+// TS_ASSERT_THROWS_NOTHING(superbox->splitContents(0));
+//
+// // Now, it has turned into a GridBox
+// boxes = superbox->getBoxes();
+// gb = dynamic_cast<MDGridBox<MDLeanEvent<2>,2> *>(boxes[0]);
+// TS_ASSERT( gb );
+// TS_ASSERT_DELTA( gb->getVolume(), 1.0, 1e-5 );
+//
+// // ID of first child remains unchanged at 1
+// TS_ASSERT_EQUALS( gb->getId(), 1 );
+// // There were 101 assigned IDs
+// TS_ASSERT_EQUALS( gb->getBoxController()->getMaxId(), 200+1);
+// // The first child of the sub-divided box got 101 as its id
+// TS_ASSERT_EQUALS( gb->getBoxes()[0]->getId(), 101 );
+//
+// // There are now 199 MDBoxes; the 99 at level 1, and 100 at level 2
+// TS_ASSERT_EQUALS( superbox->getNumMDBoxes(), 199);
+//
+// // You can split it again and it does nothing
+// TS_ASSERT_THROWS_NOTHING(superbox->splitContents(0));
+//
+// // Still a grid box
+// boxes = superbox->getBoxes();
+// gb = dynamic_cast<MDGridBox<MDLeanEvent<2>,2> *>(boxes[0]);
+// TS_ASSERT( gb );
+// }
+//
+// //-------------------------------------------------------------------------------------
+// /** Adding a single event pushes it as deep as the current grid
+// * hierarchy allows
+// */
+// void test_addEvent_with_recursive_gridding()
+// {
+// MDGridBox<MDLeanEvent<2>,2> * gb;
+// MDBox<MDLeanEvent<2>,2> * b;
+// std::vector<MDBoxBase<MDLeanEvent<2>,2>*> boxes;
+//
+// // 10x10 box, extents 0-10.0
+// MDGridBox<MDLeanEvent<2>,2> * superbox = MDEventsTestHelper::makeMDGridBox<2>();
+// // And the 0-th box is further split (
+// TS_ASSERT_THROWS_NOTHING(superbox->splitContents(0));
+//
+// TS_ASSERT_EQUALS( superbox->getNPoints(), 0 );
+// { // One event in 0th box of the 0th box.
+// double centers[2] = {0.05, 0.05};
+// superbox->addEvent( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+// { // One event in 1st box of the 0th box.
+// double centers[2] = {0.15, 0.05};
+// superbox->addEvent( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+// { // One event in 99th box.
+// double centers[2] = {9.5, 9.5};
+// superbox->addEvent( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+//
+// // You must refresh the cache after adding individual events.
+// superbox->refreshCache(NULL);
+// superbox->refreshCentroid(NULL);
+//
+// TS_ASSERT_EQUALS( superbox->getNPoints(), 3 );
+//
+//#ifdef MDBOX_TRACK_CENTROID
+// // Check the centroid for these 3 events
+// TS_ASSERT_DELTA( superbox->getCentroid(0), 3.233, 0.001);
+// TS_ASSERT_DELTA( superbox->getCentroid(1), 3.200, 0.001);
+//#endif
+//
+// // Retrieve the 0th grid box
+// boxes = superbox->getBoxes();
+// gb = dynamic_cast<MDGridBox<MDLeanEvent<2>,2> *>(boxes[0]);
+// TS_ASSERT( gb );
+//
+// // It has two points
+// TS_ASSERT_EQUALS( gb->getNPoints(), 2 );
+//
+// // Retrieve the MDBox at 0th and 1st indexes in THAT gridbox
+// boxes = gb->getBoxes();
+// b = dynamic_cast<MDBox<MDLeanEvent<2>,2> *>(boxes[0]);
+// TS_ASSERT_EQUALS( b->getNPoints(), 1 );
+// b = dynamic_cast<MDBox<MDLeanEvent<2>,2> *>(boxes[1]);
+// TS_ASSERT_EQUALS( b->getNPoints(), 1 );
+//
+// // Get the 99th box at the first level. It is not split
+// boxes = superbox->getBoxes();
+// b = dynamic_cast<MDBox<MDLeanEvent<2>,2> *>(boxes[99]);
+// TS_ASSERT( b ); if (!b) return;
+// // And it has only the one point
+// TS_ASSERT_EQUALS( b->getNPoints(), 1 );
+// }
+//
+// //-------------------------------------------------------------------------------------
+// void test_transformDimensions()
+// {
+// MDBox<MDLeanEvent<1>,1> * b = MDEventsTestHelper::makeMDBox1();
+// // Give it 10 events
+// const std::vector<MDLeanEvent<1> > events = MDEventsTestHelper::makeMDEvents1(10);
+// b->addEvents( events );
+// MDGridBox<MDLeanEvent<1>,1> * g = new MDGridBox<MDLeanEvent<1>,1>(b);
+// TSM_ASSERT_EQUALS("MDBoxes start with 1 each.", g->getChild(9)->getNPoints(), 1);
+//
+// std::vector<double> scaling(1, 3.0);
+// std::vector<double> offset(1, 1.0);
+// g->transformDimensions(scaling, offset);
+//
+// TS_ASSERT_DELTA(g->getVolume(), 30.0, 1e-5);
+// MDLeanEvent<1> ev;
+// ev.setCenter(0, 30.9f);
+// g->addEvent(ev);
+// TSM_ASSERT_EQUALS("New event was added in the right spot.", g->getChild(9)->getNPoints(), 2);
+// }
+//
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Recursive getting of a list of MDBoxBase */
+// void test_getBoxes()
+// {
+// MDGridBox<MDLeanEvent<1>,1> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<1>(3,3);
+// TS_ASSERT(parent);
+// std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes;
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 0, false);
+// TS_ASSERT_EQUALS( boxes.size(), 1);
+// TS_ASSERT_EQUALS( boxes[0], parent);
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 1, false);
+// TS_ASSERT_EQUALS( boxes.size(), 4);
+// TS_ASSERT_EQUALS( boxes[0], parent);
+// TS_ASSERT_EQUALS( boxes[1]->getDepth(), 1);
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 2, false);
+// TS_ASSERT_EQUALS( boxes.size(), 4+9);
+// TS_ASSERT_EQUALS( boxes[0], parent);
+// TS_ASSERT_EQUALS( boxes[1]->getDepth(), 1);
+// TS_ASSERT_EQUALS( boxes[2]->getDepth(), 2);
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 3, false);
+// TS_ASSERT_EQUALS( boxes.size(), 4+9+27);
+//
+// // Leaves only = only report the deepest boxes.
+// boxes.clear();
+// parent->getBoxes(boxes, 3, true);
+// TS_ASSERT_EQUALS( boxes.size(), 27);
+// TS_ASSERT_EQUALS( boxes[0]->getDepth(), 3);
+//
+// // Leaves only, with limited depth = report the max depth if that is the effective 'leaf'
+// boxes.clear();
+// parent->getBoxes(boxes, 2, true);
+// TS_ASSERT_EQUALS( boxes.size(), 9);
+// TS_ASSERT_EQUALS( boxes[0]->getDepth(), 2);
+// }
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Recursive getting of a list of MDBoxBase, with an implicit function limiting it */
+// void test_getBoxes_ImplicitFunction()
+// {
+//
+// MDGridBox<MDLeanEvent<1>,1> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<1>(4,3);
+// TS_ASSERT(parent);
+// std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes;
+//
+// // Function of everything x > 1.51
+// MDImplicitFunction * function = new MDImplicitFunction;
+// coord_t normal[1] = {+1};
+// coord_t origin[1] = {1.51f};
+// function->addPlane( MDPlane(1, normal, origin) );
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 3, false, function);
+// TS_ASSERT_EQUALS( boxes.size(), 54);
+// // The boxes extents make sense
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// TS_ASSERT( boxes[i]->getExtents(0).max >= 1.51);
+// }
+//
+// // --- Now leaf-only ---
+// boxes.clear();
+// parent->getBoxes(boxes, 3, true, function);
+// TS_ASSERT_EQUALS( boxes.size(), 40);
+// // The boxes extents make sense
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// TS_ASSERT( boxes[i]->getExtents(0).max >= 1.51);
+// }
+//
+// // Limit by another plane
+// coord_t normal2[1] = {-1};
+// coord_t origin2[1] = {2.99f};
+// function->addPlane( MDPlane(1, normal2, origin2) );
+// boxes.clear();
+// parent->getBoxes(boxes, 3, false, function);
+// TS_ASSERT_EQUALS( boxes.size(), 33);
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// TS_ASSERT( boxes[i]->getExtents(0).max >= 1.51);
+// TS_ASSERT( boxes[i]->getExtents(0).min <= 2.99);
+// }
+//
+// // Same, leaf only
+// boxes.clear();
+// parent->getBoxes(boxes, 3, true, function);
+// TS_ASSERT_EQUALS( boxes.size(), 24);
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// TS_ASSERT( boxes[i]->getExtents(0).max >= 1.51);
+// TS_ASSERT( boxes[i]->getExtents(0).min <= 2.99);
+// }
+//
+// // ----- Infinitely thin plane for an implicit function ------------
+// function = new MDImplicitFunction;
+// coord_t normal3[1] = {-1};
+// coord_t origin3[1] = {1.51f};
+// function->addPlane( MDPlane(1, normal, origin) );
+// function->addPlane( MDPlane(1, normal3, origin3) );
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 3, true, function);
+// TSM_ASSERT_EQUALS( "Only one box is found by an infinitely thin plane", boxes.size(), 1);
+//
+// }
+//
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Recursive getting of a list of MDBoxBase, with an implicit function limiting it */
+// void test_getBoxes_ImplicitFunction_2D()
+// {
+//
+// MDGridBox<MDLeanEvent<2>,2> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<2>(4,1);
+// TS_ASSERT(parent);
+// std::vector<MDBoxBase<MDLeanEvent<2>,2> *> boxes;
+//
+// // Function of x,y between 2 and 3
+// std::vector<coord_t> min(2, 1.99f);
+// std::vector<coord_t> max(2, 3.01f);
+// MDImplicitFunction * function = new MDBoxImplicitFunction(min, max);
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 3, false, function);
+// TS_ASSERT_EQUALS( boxes.size(), 46);
+// // The boxes extents make sense
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// //std::cout << boxes[i]->getExtentsStr() << std::endl;
+// TS_ASSERT( boxes[i]->getExtents(0).max >= 2.00);
+// TS_ASSERT( boxes[i]->getExtents(0).min <= 3.00);
+// TS_ASSERT( boxes[i]->getExtents(1).max >= 2.00);
+// TS_ASSERT( boxes[i]->getExtents(1).min <= 3.00);
+// }
+//
+// // -- Leaf only ---
+// boxes.clear();
+// parent->getBoxes(boxes, 3, true, function);
+// TS_ASSERT_EQUALS( boxes.size(), 16+4*4+4); //16 in the center one + 4x4 at the 4 edges + 4 at the corners
+// // The boxes extents make sense
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// //std::cout << boxes[i]->getExtentsStr() << std::endl;
+// TS_ASSERT( boxes[i]->getExtents(0).max >= 2.00);
+// TS_ASSERT( boxes[i]->getExtents(0).min <= 3.00);
+// TS_ASSERT( boxes[i]->getExtents(1).max >= 2.00);
+// TS_ASSERT( boxes[i]->getExtents(1).min <= 3.00);
+// }
+//
+// }
+//
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Recursive getting of a list of MDBoxBase, with an implicit function limiting it.
+// * This implicit function is a box of size 0. */
+// void test_getBoxes_ZeroSizeImplicitFunction_2D()
+// {
+// MDGridBox<MDLeanEvent<2>,2> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<2>(4,1);
+// TS_ASSERT(parent);
+// std::vector<MDBoxBase<MDLeanEvent<2>,2> *> boxes;
+//
+// // Function of x,y with 0 width and height
+// std::vector<coord_t> min(2, 1.99f);
+// std::vector<coord_t> max(2, 1.99f);
+// MDImplicitFunction * function = new MDBoxImplicitFunction(min, max);
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 3, false, function);
+// // Returns 3 boxes: the big one with everything, the size 1 under, and the size 0.25 under that
+// TS_ASSERT_EQUALS( boxes.size(), 3);
+//
+// // Leaf only: returns only one box
+// boxes.clear();
+// parent->getBoxes(boxes, 3, true, function);
+// TS_ASSERT_EQUALS( boxes.size(), 1);
+// TS_ASSERT_DELTA( boxes[0]->getExtents(0).min, 1.75, 1e-4);
+// TS_ASSERT_DELTA( boxes[0]->getExtents(0).max, 2.00, 1e-4);
+// }
+//
+// //-------------------------------------------------------------------------------------
+// /** Recursive getting of a list of MDBoxBase, with an implicit function limiting it.
+// * This implicit function is a box of size 0. */
+// void test_getBoxes_ZeroSizeImplicitFunction_4D()
+// {
+// MDGridBox<MDLeanEvent<4>,4> * parent = MDEventsTestHelper::makeRecursiveMDGridBox<4>(4,1);
+// TS_ASSERT(parent);
+// std::vector<MDBoxBase<MDLeanEvent<4>,4> *> boxes;
+//
+// // Function of x,y with 0 width and height
+// std::vector<coord_t> min(4, 1.99f);
+// std::vector<coord_t> max(4, 1.99f);
+// MDImplicitFunction * function = new MDBoxImplicitFunction(min, max);
+//
+// boxes.clear();
+// parent->getBoxes(boxes, 3, false, function);
+// // Returns 3 boxes: the big one with everything, the size 1 under, and the size 0.25 under that
+// TS_ASSERT_EQUALS( boxes.size(), 3);
+//
+// // Leaf only: returns only one box
+// boxes.clear();
+// parent->getBoxes(boxes, 3, true, function);
+// TS_ASSERT_EQUALS( boxes.size(), 1);
+// TS_ASSERT_DELTA( boxes[0]->getExtents(0).min, 1.75, 1e-4);
+// TS_ASSERT_DELTA( boxes[0]->getExtents(0).max, 2.00, 1e-4);
+// }
+//
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Gauge how fast addEvent is with several levels of gridding
+// * NOTE: DISABLED because it is slow.
+// * */
+// void xtest_addEvent_with_recursive_gridding_Performance()
+// {
+// // Make a 2D box split into 4, 4 levels deep. = 4^4^2 boxes at the bottom = 256^2 boxes.
+// size_t numSplit = 4;
+// for (size_t recurseLevels = 1; recurseLevels < 5; recurseLevels++)
+// {
+// std::cout << " --- Recursion Level " << recurseLevels << " --- " << std::endl;
+// Timer tim1;
+// double boxes_per_side = pow(double(numSplit), double(recurseLevels));
+// double spacing = double(numSplit)/boxes_per_side;
+// // How many times to add the same event
+// size_t num_to_repeat = size_t(1e7 / (boxes_per_side*boxes_per_side));
+//
+// MDGridBox<MDLeanEvent<2>,2> * box = MDEventsTestHelper::makeRecursiveMDGridBox<2>(numSplit, recurseLevels);
+// std::cout << tim1.elapsed() << " seconds to generate the " << boxes_per_side << "^2 boxes." << std::endl;
+//
+// for (double x=0; x < numSplit; x += spacing)
+// for (double y=0; y < numSplit; y += spacing)
+// {
+// for (size_t i=0; i<num_to_repeat; i++)
+// {
+// coord_t centers[2] = {static_cast<coord_t>(x),static_cast<coord_t>(y)};
+// box->addEvent( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+// }
+// // You must refresh the cache after adding individual events.
+// box->refreshCache(NULL);
+//
+// double sec = tim1.elapsed();
+// std::cout << sec << " seconds to add " << box->getNPoints() << " events. Each box had " << num_to_repeat << " events." << std::endl;
+// std::cout << "equals " << 1e6*sec/double(box->getNPoints()) << " seconds per million events." << std::endl;
+// }
+//
+// }
+//
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Fill a 10x10 gridbox with events
+// *
+// * Tests that bad events are thrown out when using addEvents.
+// * */
+// void test_addEvents_2D()
+// {
+// MDGridBox<MDLeanEvent<2>,2> * b = MDEventsTestHelper::makeMDGridBox<2>();
+// std::vector< MDLeanEvent<2> > events;
+//
+// // Make an event in the middle of each box
+// for (double x=0.5; x < 10; x += 1.0)
+// for (double y=0.5; y < 10; y += 1.0)
+// {
+// coord_t centers[2] = {static_cast<coord_t>(x),static_cast<coord_t>(y)};
+// events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+//
+// size_t numbad = 0;
+// TS_ASSERT_THROWS_NOTHING( numbad = b->addEvents( events ); );
+// // Get the right totals again
+// b->refreshCache(NULL);
+// TS_ASSERT_EQUALS( numbad, 0);
+// TS_ASSERT_EQUALS( b->getNPoints(), 100);
+// TS_ASSERT_EQUALS( b->getSignal(), 100*2.0);
+// TS_ASSERT_EQUALS( b->getErrorSquared(), 100*2.0);
+// TS_ASSERT_DELTA( b->getSignalNormalized(), 100*2.0 / 100.0, 1e-5);
+// TS_ASSERT_DELTA( b->getErrorSquaredNormalized(), 100*2.0 / 100.0, 1e-5);
+//
+// // Get all the boxes contained
+// std::vector<MDBoxBase<MDLeanEvent<2>,2>*> boxes = b->getBoxes();
+// TS_ASSERT_EQUALS( boxes.size(), 100);
+// for (size_t i=0; i < boxes.size(); i++)
+// {
+// TS_ASSERT_EQUALS( boxes[i]->getNPoints(), 1);
+// TS_ASSERT_EQUALS( boxes[i]->getSignal(), 2.0);
+// TS_ASSERT_EQUALS( boxes[i]->getErrorSquared(), 2.0);
+// TS_ASSERT_EQUALS( boxes[i]->getSignalNormalized(), 2.0);
+// TS_ASSERT_EQUALS( boxes[i]->getErrorSquaredNormalized(), 2.0);
+// }
+//
+// // Now try to add bad events (outside bounds)
+// events.clear();
+// for (double x=-5.0; x < 20; x += 20.0)
+// for (double y=-5.0; y < 20; y += 20.0)
+// {
+// double centers[2] = {x,y};
+// events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+// // Get the right totals again
+// b->refreshCache(NULL);
+// // All 4 points get rejected
+// TS_ASSERT_THROWS_NOTHING( numbad = b->addEvents( events ); );
+// TS_ASSERT_EQUALS( numbad, 4);
+// // Number of points and signal is unchanged.
+// TS_ASSERT_EQUALS( b->getNPoints(), 100);
+// TS_ASSERT_EQUALS( b->getSignal(), 100*2.0);
+// TS_ASSERT_EQUALS( b->getErrorSquared(), 100*2.0);
+// }
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Tests add_events with limits into the vectorthat bad events are thrown out when using addEvents.
+// * */
+// void test_addEvents_start_stop()
+// {
+// MDGridBox<MDLeanEvent<2>,2> * b = MDEventsTestHelper::makeMDGridBox<2>();
+// std::vector< MDLeanEvent<2> > events;
+//
+// // Make an event in the middle of each box
+// for (double x=0.5; x < 10; x += 1.0)
+// for (double y=0.5; y < 10; y += 1.0)
+// {
+// double centers[2] = {x,y};
+// events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+//
+// size_t numbad = 0;
+// TS_ASSERT_THROWS_NOTHING( numbad = b->addEventsPart( events, 50, 60 ); );
+// // Get the right totals again
+// b->refreshCache(NULL);
+// TS_ASSERT_EQUALS( numbad, 0);
+// TS_ASSERT_EQUALS( b->getNPoints(), 10);
+// TS_ASSERT_EQUALS( b->getSignal(), 10*2.0);
+// TS_ASSERT_EQUALS( b->getErrorSquared(), 10*2.0);
+// }
+//
+// //-------------------------------------------------------------------------------------
+// /** Test that adding events (as vectors) in parallel does not cause
+// * segfaults or incorrect totals.
+// * */
+// void do_test_addEvents_inParallel(ThreadScheduler * ts)
+// {
+// MDGridBox<MDLeanEvent<2>,2> * b = MDEventsTestHelper::makeMDGridBox<2>();
+// int num_repeat = 1000;
+//
+// PARALLEL_FOR_NO_WSP_CHECK()
+// for (int i=0; i < num_repeat; i++)
+// {
+// std::vector< MDLeanEvent<2> > events;
+// // Make an event in the middle of each box
+// for (double x=0.5; x < 10; x += 1.0)
+// for (double y=0.5; y < 10; y += 1.0)
+// {
+// double centers[2] = {x,y};
+// events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+// TS_ASSERT_THROWS_NOTHING( b->addEvents( events ); );
+// }
+// // Get the right totals again by refreshing
+// b->refreshCache(ts);
+// TS_ASSERT_EQUALS( b->getNPoints(), 100*num_repeat);
+// TS_ASSERT_EQUALS( b->getSignal(), 100*num_repeat*2.0);
+// TS_ASSERT_EQUALS( b->getErrorSquared(), 100*num_repeat*2.0);
+// }
+//
+//
+// void test_addEvents_inParallel()
+// {
+// do_test_addEvents_inParallel(NULL);
+// }
+//
+// /** Disabled because parallel RefreshCache is not implemented. Might not be ever? */
+// void xtest_addEvents_inParallel_then_refreshCache_inParallel()
+// {
+// ThreadScheduler * ts = new ThreadSchedulerFIFO();
+// do_test_addEvents_inParallel(ts);
+// ThreadPool tp(ts);
+// tp.joinAll();
+// }
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Get a sub-box at a given coord */
+// void test_getBoxAtCoord()
+// {
+// MDGridBox<MDLeanEvent<2>,2> * b = MDEventsTestHelper::makeMDGridBox<2>();
+// coord_t coords[2] = {1.5,1.5};
+// const MDBoxBase<MDLeanEvent<2>,2> * c = b->getBoxAtCoord(coords);
+// TS_ASSERT_EQUALS(c, b->getChild(11));
+// }
+//
+//
+// //-------------------------------------------------------------------------------------
+// /** Test the routine that auto-splits MDBoxes into MDGridBoxes recursively.
+// * It tests the max_depth of splitting too, because there are numerous
+// * repeated events at exactly the same position = impossible to separate further.
+// * */
+// void test_splitAllIfNeeded()
+// {
+// typedef MDGridBox<MDLeanEvent<2>,2> gbox_t;
+// typedef MDBox<MDLeanEvent<2>,2> box_t;
+// typedef MDBoxBase<MDLeanEvent<2>,2> ibox_t;
+//
+// gbox_t * b = MDEventsTestHelper::makeMDGridBox<2>();
+// b->getBoxController()->setSplitThreshold(100);
+// b->getBoxController()->setMaxDepth(4);
+//
+// // Make a 1000 events at exactly the same point
+// size_t num_repeat = 1000;
+// std::vector< MDLeanEvent<2> > events;
+// for (size_t i=0; i < num_repeat; i++)
+// {
+// // Make an event in the middle of each box
+// double centers[2] = {1e-10, 1e-10};
+// events.push_back( MDLeanEvent<2>(2.0, 2.0, centers) );
+// }
+// TS_ASSERT_THROWS_NOTHING( b->addEvents( events ); );
+//
+//
+// // Split into sub-grid boxes
+// TS_ASSERT_THROWS_NOTHING( b->splitAllIfNeeded(NULL); )
+//
+// // Dig recursively into the gridded box hierarchies
+// std::vector<ibox_t*> boxes;
+// size_t expected_depth = 0;
+// while (b)
+// {
+// expected_depth++;
+// boxes = b->getBoxes();
+//
+// // Get the 0th box
+// b = dynamic_cast<gbox_t*>(boxes[0]);
+//
+// // The 0-th box is a MDGridBox (it was split)
+// // (though it is normal for b to be a MDBox when you reach the max depth)
+// if (expected_depth < 4)
+// { TS_ASSERT( b ) }
+//
+// // The 0-th box has all the points
+// TS_ASSERT_EQUALS( boxes[0]->getNPoints(), num_repeat);
+// // The 0-th box is at the expected_depth
+// TS_ASSERT_EQUALS( boxes[0]->getDepth(), expected_depth);
+//
+// // The other boxes have nothing
+// TS_ASSERT_EQUALS( boxes[1]->getNPoints(), 0);
+// // The other box is a MDBox (it was not split)
+// TS_ASSERT( dynamic_cast<box_t*>(boxes[1]) )
+// }
+//
+// // We went this many levels (and no further) because recursion depth is limited
+// TS_ASSERT_EQUALS(boxes[0]->getDepth(), 4);
+// }
+//
+//
+// //------------------------------------------------------------------------------------------------
+// /** This test splits a large number of events, and uses a ThreadPool
+// * to use all cores.
+// */
+// void test_splitAllIfNeeded_usingThreadPool()
+// {
+// typedef MDGridBox<MDLeanEvent<2>,2> gbox_t;
+// typedef MDBox<MDLeanEvent<2>,2> box_t;
+// typedef MDBoxBase<MDLeanEvent<2>,2> ibox_t;
+//
+// gbox_t * b = MDEventsTestHelper::makeMDGridBox<2>();
+// b->getBoxController()->setSplitThreshold(100);
+// b->getBoxController()->setMaxDepth(4);
+//
+// // Make a 1000 events in each sub-box
+// size_t num_repeat = 1000;
+// if (DODEBUG) num_repeat = 2000;
+//
+// Timer tim;
+// if (DODEBUG) std::cout << "Adding " << num_repeat*100 << " events...\n";
+// MDEventsTestHelper::feedMDBox<2>(b, num_repeat, 10, 0.5, 1.0);
+// if (DODEBUG) std::cout << "Adding events done in " << tim.elapsed() << "!\n";
+//
+// // Split those boxes in parallel.
+// ThreadSchedulerFIFO * ts = new ThreadSchedulerFIFO();
+// ThreadPool tp(ts);
+// b->splitAllIfNeeded(ts);
+// tp.joinAll();
+//
+// if (DODEBUG) std::cout << "Splitting events done in " << tim.elapsed() << " sec.\n";
+//
+// // Now check the results. Each sub-box should be MDGridBox and have that many events
+// std::vector<ibox_t*> boxes = b->getBoxes();
+// TS_ASSERT_EQUALS(boxes.size(), 100);
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// ibox_t * box = boxes[i];
+// TS_ASSERT_EQUALS( box->getNPoints(), num_repeat );
+// TS_ASSERT( dynamic_cast<gbox_t *>(box) );
+//
+// size_t numChildren = box->getNumChildren();
+// if (numChildren > 0)
+// {
+// size_t lastId = box->getChild(0)->getId();
+// for (size_t i = 1; i < numChildren; i++)
+// {
+// TSM_ASSERT_EQUALS("Children IDs need to be sequential!", box->getChild(i)->getId(), lastId+1);
+// lastId = box->getChild(i)->getId();
+// }
+// }
+//
+// }
+//
+// }
+//
+//
+//
+//
+// //------------------------------------------------------------------------------------------------
+// /** This test splits a large number of events,
+// * for a workspace that is backed by a file (and thus tries to stay below
+// * a certain amount of memory used).
+// */
+// void test_splitAllIfNeeded_fileBacked()
+// {
+// typedef MDLeanEvent<2> MDE;
+// typedef MDGridBox<MDE,2> gbox_t;
+// typedef MDBox<MDE,2> box_t;
+// typedef MDBoxBase<MDE,2> ibox_t;
+//
+// // Make a fake file-backing for the grid box
+// std::string filename = "MDGridBoxTest.nxs";
+// ::NeXus::File * file = new ::NeXus::File(filename, NXACC_CREATE);
+// file->makeGroup("MDEventWorkspaceTest", "NXentry", 1);
+// MDE::prepareNexusData(file, 2000);
+// file->close();
+// file = new ::NeXus::File(filename, NXACC_RDWR);
+// file->openGroup("MDEventWorkspaceTest", "NXentry");
+// MDE::openNexusData(file);
+//
+// // Create the grid box and make it file-backed.
+// gbox_t * b = MDEventsTestHelper::makeMDGridBox<2>();
+// BoxController_sptr bc = b->getBoxController();
+// bc->setSplitThreshold(100);
+// bc->setMaxDepth(4);
+// bc->setCacheParameters(1, 1000);
+// bc->setFile(file, filename, 0);
+// DiskBuffer & dbuf = bc->getDiskBuffer();
+// dbuf.setFileLength(0);
+//
+// size_t num_repeat = 10;
+// if (DODEBUG) num_repeat = 20;
+// Timer tim;
+// if (DODEBUG) std::cout << "Adding " << num_repeat*10000 << " events...\n";
+// MDEventsTestHelper::feedMDBox<2>(b, num_repeat, 100, 0.05f, 0.1f);
+// if (DODEBUG) std::cout << "Adding events done in " << tim.elapsed() << "!\n";
+//
+// // Split those boxes in parallel.
+// ThreadSchedulerFIFO * ts = new ThreadSchedulerFIFO();
+// ThreadPool tp(ts);
+// b->splitAllIfNeeded(ts);
+// tp.joinAll();
+//
+// if (DODEBUG) std::cout << "Splitting events done in " << tim.elapsed() << " sec.\n";
+//
+// // Get all the MDBoxes created
+// std::vector<ibox_t*> boxes;
+// b->getBoxes(boxes, 1000, true);
+// TS_ASSERT_EQUALS(boxes.size(), 10000);
+// size_t numOnDisk = 0;
+// uint64_t eventsOnDisk = 0;
+// uint64_t maxFilePos = 0;
+// for (size_t i=0; i<boxes.size(); i++)
+// {
+// ibox_t * box = boxes[i];
+// TS_ASSERT_EQUALS( box->getNPoints(), num_repeat );
+// box_t * mdbox = dynamic_cast<box_t *>(box);
+// TS_ASSERT( mdbox);
+// if ( mdbox->getOnDisk() ) numOnDisk++;
+// eventsOnDisk += mdbox->getFileNumEvents();
+// // Track the last point used in the file
+// uint64_t fileEnd = mdbox->getFilePosition() + mdbox->getFileNumEvents();
+// if (fileEnd > maxFilePos) maxFilePos = fileEnd;
+// //std::cout << mdbox->getFilePosition() << " file pos " << i << std::endl;
+// }
+// TSM_ASSERT_EQUALS("All new boxes were set to be cached to disk.", numOnDisk, 10000);
+// uint64_t minimumSaved = 10000*(num_repeat-2);
+// TSM_ASSERT_LESS_THAN("Length of the file makes sense", minimumSaved, dbuf.getFileLength());
+// TSM_ASSERT_LESS_THAN("Most of the boxes' events were cached to disk (some remain in memory because of the MRU cache)", minimumSaved, eventsOnDisk);
+// TSM_ASSERT_LESS_THAN("And the events were properly saved sequentially in the files.", minimumSaved, maxFilePos);
+// std::cout << dbuf.getMemoryStr() << std::endl;
+// file->close();
+// if (Poco::File(filename).exists()) Poco::File(filename).remove();
+// }
+//
+//
+//
+// //------------------------------------------------------------------------------------------------
+// /** Helper to make a 2D MDBin */
+// MDBin<MDLeanEvent<2>,2> makeMDBin2(double minX, double maxX, double minY, double maxY)
+// {
+// MDBin<MDLeanEvent<2>,2> bin;
+// bin.m_min[0] = static_cast<coord_t>(minX);
+// bin.m_max[0] = static_cast<coord_t>(maxX);
+// bin.m_min[1] = static_cast<coord_t>(minY);
+// bin.m_max[1] = static_cast<coord_t>(maxY);
+// return bin;
+// }
+//
+// //------------------------------------------------------------------------------------------------
+// /** Helper to test the binning of a 2D bin */
+// void doTestMDBin2(MDGridBox<MDLeanEvent<2>,2> * b,
+// const std::string & message,
+// double minX, double maxX, double minY, double maxY, double expectedSignal)
+// {
+//// std::cout << "Bins: X " << std::setw(5) << minX << " to "<< std::setw(5) << maxX << ", Y " << std::setw(5) << minY << " to "<< std::setw(5) << maxY << ". " << message << std::endl;
+//
+// MDBin<MDLeanEvent<2>,2> bin;
+// bin = makeMDBin2(minX, maxX, minY, maxY);
+// b->centerpointBin(bin, NULL);
+// TSM_ASSERT_DELTA( message, bin.m_signal, expectedSignal, 1e-5);
+// }
+//
+// //------------------------------------------------------------------------------------------------
+// /** Test binning in orthogonal axes */
+// void test_centerpointBin()
+// {
+// typedef MDGridBox<MDLeanEvent<2>,2> gbox_t;
+// typedef MDBox<MDLeanEvent<2>,2> box_t;
+// typedef MDBoxBase<MDLeanEvent<2>,2> ibox_t;
+//
+// // 10x10 bins, 2 events per bin, each weight of 1.0
+// gbox_t * b = MDEventsTestHelper::makeMDGridBox<2>();
+// MDEventsTestHelper::feedMDBox<2>(b, 2);
+// TS_ASSERT_DELTA( b->getSignal(), 200.0, 1e-5);
+//
+// MDBin<MDLeanEvent<2>,2> bin;
+//
+// doTestMDBin2(b, "Bin that is completely off",
+// 10.1, 11.2, 1.9, 3.12, 0.0);
+//
+// doTestMDBin2(b, "Bin that is completely off (2)",
+// 2, 3, -0.6, -0.1, 0.0);
+//
+// doTestMDBin2(b, "Bin that holds one entire MDBox (bigger than it)",
+// 0.8, 2.2, 1.9, 3.12, 2.0);
+//
+// doTestMDBin2(b, "Bin that holds one entire MDBox (going off one edge)",
+// -0.2, 1.2, 1.9, 3.12, 2.0);
+//
+// doTestMDBin2(b, "Bin that holds one entire MDBox (going off the other edge)",
+// 8.9, 10.2, 1.9, 3.12, 2.0);
+//
+// doTestMDBin2(b, "Bin that holds one entire MDBox (going off both edge)",
+// -0.2, 1.2, -0.2, 1.2, 2.0);
+//
+// doTestMDBin2(b, "Bin that holds one entire MDBox and a fraction of at least one more with something",
+// 0.8, 2.7, 1.9, 3.12, 4.0);
+//
+// doTestMDBin2(b, "Bin that holds four entire MDBoxes",
+// 0.8, 3.1, 0.9, 3.2, 8.0);
+//
+// doTestMDBin2(b, "Bin goes off two edges in one direction",
+// -0.3, 10.2, 1.9, 3.1, 10*2.0);
+//
+// doTestMDBin2(b, "Bin that fits all within a single MDBox, and contains the center",
+// 0.2, 0.8, 0.2, 0.8, 2.0);
+//
+// doTestMDBin2(b, "Bin that fits all within a single MDBox, and DOES NOT contain anything",
+// 0.2, 0.3, 0.1, 0.2, 0.0);
+//
+// doTestMDBin2(b, "Bin that fits partially in two MDBox'es, and DOES NOT contain anything",
+// 0.8, 1.2, 0.1, 0.2, 0.0);
+//
+// doTestMDBin2(b, "Bin that fits partially in two MDBox'es, and contains the centers",
+// 0.2, 1.8, 0.1, 0.9, 4.0);
+//
+// doTestMDBin2(b, "Bin that fits partially in one MDBox'es, and goes of the edge",
+// -3.2, 0.8, 0.1, 0.9, 2.0);
+//
+// }
+//
+//
+//
+//
+//
+// //------------------------------------------------------------------------------------------------
+// /** For test_integrateSphere
+// *
+// * @param box
+// * @param radius :: radius to integrate
+// * @param numExpected :: how many events should be in there
+// */
+// void do_check_integrateSphere(MDGridBox<MDLeanEvent<2>,2> & box, double x, double y, const double radius, double numExpected, std::string message)
+// {
+// std::cout << "Sphere of radius " << radius << " at " << x << "," << y << "------" << message << "--\n";
+// // The sphere transformation
+// bool dimensionsUsed[2] = {true,true};
+// coord_t center[2] = {static_cast<coord_t>(x),static_cast<coord_t>(y)};
+// CoordTransformDistance sphere(2, center, dimensionsUsed);
+//
+// signal_t signal = 0;
+// signal_t errorSquared = 0;
+// box.integrateSphere(sphere, static_cast<coord_t>(radius*radius), signal, errorSquared);
+// TSM_ASSERT_DELTA( message, signal, 1.0*numExpected, 1e-5);
+// TSM_ASSERT_DELTA( message, errorSquared, 1.0*numExpected, 1e-5);
+// }
+//
+// /** Re-used suite of tests */
+// void do_test_integrateSphere(MDGridBox<MDLeanEvent<2>,2> * box_ptr)
+// {
+// // Events are at 0.5, 1.5, etc.
+// MDGridBox<MDLeanEvent<2>,2> & box = *box_ptr;
+// TS_ASSERT_EQUALS( box.getNPoints(), 10*10);
+//
+// do_check_integrateSphere(box, 4.5,4.5, 0.5, 1.0, "Too small to contain any vertices");
+// do_check_integrateSphere(box, 4.5, 4.5, 0.001, 1.0, "Tiny but still has an event.");
+// do_check_integrateSphere(box, 4.51,4.5, 0.001, 0.0, "Tiny but off the event.");
+// do_check_integrateSphere(box, 2.0,2.0, 0.49, 0.0, "At a corner but grabbing nothing");
+// do_check_integrateSphere(box, 4.8,4.5, 0.35, 1.0, "Too small to contain any vertices");
+// do_check_integrateSphere(box, 5.0,5.0, 1.0, 4.0, "At a corner, containing 4 neighbors");
+// do_check_integrateSphere(box, 4.5,4.5, 0.9, 1.0, "Contains one box completely");
+// do_check_integrateSphere(box, 0.5,0.5, 0.9, 1.0, "Contains one box completely, at the edges");
+// do_check_integrateSphere(box, 9.5,0.5, 0.9, 1.0, "Contains one box completely, at the edges");
+// do_check_integrateSphere(box, 0.5,9.5, 0.9, 1.0, "Contains one box completely, at the edges");
+// do_check_integrateSphere(box, 4.5,9.5, 0.9, 1.0, "Contains one box completely, at the edges");
+// do_check_integrateSphere(box, 9.5,9.5, 0.9, 1.0, "Contains one box completely, at the edges");
+// do_check_integrateSphere(box, 1.5,1.5, 1.95, 9.0, "Contains 5 boxes completely, and 4 boxes with a point");
+// do_check_integrateSphere(box, -1.0,0.5, 1.55, 1.0, "Off an edge but enough to get an event");
+//
+// // Now I add an event very near an edge
+// double center[2] = {0.001, 0.5};
+// box.addEvent(MDLeanEvent<2>(1.0, 1.0, center));
// do_check_integrateSphere(box, -1.0,0.5, 1.01, 1.0, "Off an edge but just barely enough to get an event");
// do_check_integrateSphere(box, 0.0,0.5, 0.01, 1.0, "Tiny, but just barely enough to get an event");
- }
-
-
-
-
-
- //------------------------------------------------------------------------------------------------
- /** For test_integrateSphere
- *
- * @param box
- * @param radius :: radius to integrate
- * @param xExpected :: expected centroid
- * @param yExpected :: expected centroid
- */
- void do_check_centroidSphere(MDGridBox<MDLeanEvent<2>,2> & box, double x, double y,
- const double radius,
- double numExpected, double xExpected, double yExpected,
- std::string message)
- {
- std::cout << "Centroid of sphere of radius " << radius << " at " << x << "," << y << "------" << message << "--\n";
- // The sphere transformation
- bool dimensionsUsed[2] = {true,true};
- coord_t center[2] = {static_cast<coord_t>(x),static_cast<coord_t>(y)};
- CoordTransformDistance sphere(2, center, dimensionsUsed);
-
- signal_t signal = 0;
- coord_t centroid[2] = {0., 0.};
- box.centroidSphere(sphere, static_cast<coord_t>(radius*radius), centroid, signal);
- // Normalized
- if (signal != 0.0)
- {
- for (size_t d=0; d<2; d++)
- centroid[d] /= static_cast<coord_t>(signal);
- }
-
- TSM_ASSERT_DELTA( message, signal, 1.0*numExpected, 1e-5);
- TSM_ASSERT_DELTA( message, centroid[0], xExpected, 1e-5);
- TSM_ASSERT_DELTA( message, centroid[1], yExpected, 1e-5);
- }
-
- /** Re-used suite of tests */
- void test_centroidSphere()
- {
- // 10x10 sized box
- MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>();
- MDEventsTestHelper::feedMDBox<2>(box_ptr, 1);
- // Events are at 0.5, 1.5, etc.
- MDGridBox<MDLeanEvent<2>,2> & box = *box_ptr;
- TS_ASSERT_EQUALS( box.getNPoints(), 10*10);
-
- do_check_centroidSphere(box, 4.5,4.5, 0.5, 1.0, 4.5, 4.5, "Too small to contain any vertices");
- do_check_centroidSphere(box, 4.5, 4.5, 0.001, 1.0, 4.5, 4.5, "Tiny but still has an event.");
- do_check_centroidSphere(box, 4.51,4.5, 0.001, 0.0, 0.0, 0.0, "Tiny but off the event.");
- do_check_centroidSphere(box, 2.0,2.0, 0.49, 0.0, 0.0, 0.0, "At a corner but grabbing nothing");
- do_check_centroidSphere(box, 4.8,4.5, 0.35, 1.0, 4.5, 4.5, "Too small to contain any vertices");
- do_check_centroidSphere(box, 5.0,5.0, 1.0, 4.0, 5.0, 5.0, "At a corner, containing 4 neighbors");
- do_check_centroidSphere(box, 4.5,4.5, 0.9, 1.0, 4.5, 4.5, "Contains one box completely");
- do_check_centroidSphere(box, 0.5,0.5, 0.9, 1.0, 0.5, 0.5, "Contains one box completely, at the edges");
- do_check_centroidSphere(box, 9.5,0.5, 0.9, 1.0, 9.5, 0.5, "Contains one box completely, at the edges");
- do_check_centroidSphere(box, 0.5,9.5, 0.9, 1.0, 0.5, 9.5, "Contains one box completely, at the edges");
- do_check_centroidSphere(box, 4.5,9.5, 0.9, 1.0, 4.5, 9.5, "Contains one box completely, at the edges");
- do_check_centroidSphere(box, 9.5,9.5, 0.9, 1.0, 9.5, 9.5, "Contains one box completely, at the edges");
- do_check_centroidSphere(box, 1.5,1.5, 1.95, 9.0, 1.5, 1.5, "Contains 5 boxes completely, and 4 boxes with a point");
- do_check_centroidSphere(box, -1.0,0.5, 1.55, 1.0, 0.5, 0.5, "Off an edge but enough to get an event");
-
- // Now I add an event very near an edge
- double center[2] = {0.001, 0.5};
- box.addEvent(MDLeanEvent<2>(1.0, 1.0, center));
- do_check_integrateSphere(box, -1.0,0.5, 1.01, 1.0, "Off an edge but just barely enough to get an event");
- do_check_integrateSphere(box, 0.0,0.5, 0.01, 1.0, "Tiny, but just barely enough to get an event");
- }
-
- void test_getIsMasked_WhenNoMasking()
- {
- std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
-
- MockMDBox* a = new MockMDBox;
- MockMDBox* b = new MockMDBox;
-
- EXPECT_CALL(*a, getIsMasked()).Times(1).WillOnce(Return(false)); //Not masked
- EXPECT_CALL(*b, getIsMasked()).Times(1).WillOnce(Return(false)); //Not masked
-
- boxes.push_back(a);
- boxes.push_back(b);
-
- MDGridBox<MDLeanEvent<1>,1> g;
- g.setChildren(boxes, 0, 2);
-
- TSM_ASSERT("No inner boxes were masked so the MDGridBox should not report that it is masked", !g.getIsMasked());
- TS_ASSERT(Mock::VerifyAndClearExpectations(a));
- TS_ASSERT(Mock::VerifyAndClearExpectations(b));
- }
-
- void test_getIsMasked_WhenFirstMasked()
- {
- std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
-
- MockMDBox* a = new MockMDBox;
- MockMDBox* b = new MockMDBox;
-
- EXPECT_CALL(*a, getIsMasked()).Times(1).WillOnce(Return(true)); //MASKED
- EXPECT_CALL(*b, getIsMasked()).Times(0); //Not masked, but will never be called.
-
- boxes.push_back(a);
- boxes.push_back(b);
-
- MDGridBox<MDLeanEvent<1>,1> g;
- g.setChildren(boxes, 0, 2);
-
- TSM_ASSERT("First inner box masked, so should return masked", g.getIsMasked());
- TS_ASSERT(Mock::VerifyAndClearExpectations(a));
- TS_ASSERT(Mock::VerifyAndClearExpectations(b));
- }
-
- void test_getIsMasked_WhenLastMasked()
- {
- std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
-
- MockMDBox* a = new MockMDBox;
- MockMDBox* b = new MockMDBox;
-
- EXPECT_CALL(*a, getIsMasked()).Times(1).WillOnce(Return(false)); //NOT MASKED
- EXPECT_CALL(*b, getIsMasked()).Times(1).WillOnce(Return(true)); //MASKED
-
- boxes.push_back(a);
- boxes.push_back(b);
-
- MDGridBox<MDLeanEvent<1>,1> g;
- g.setChildren(boxes, 0, 2);
-
- TSM_ASSERT("Second inner box masked, so should return masked", g.getIsMasked());
- TS_ASSERT(Mock::VerifyAndClearExpectations(a));
- TS_ASSERT(Mock::VerifyAndClearExpectations(b));
- }
-
- void test_mask()
- {
- std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
-
- MockMDBox* a = new MockMDBox;
- MockMDBox* b = new MockMDBox;
-
- EXPECT_CALL(*a, mask()).Times(1);
- EXPECT_CALL(*b, mask()).Times(1);
-
- boxes.push_back(a);
- boxes.push_back(b);
-
- MDGridBox<MDLeanEvent<1>,1> griddedBox;
- griddedBox.setChildren(boxes, 0, 2);
-
- TS_ASSERT_THROWS_NOTHING(griddedBox.mask());//Mask the gridded box
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(a));
- TS_ASSERT(Mock::VerifyAndClearExpectations(b));
- }
-
- void test_unmask()
- {
- std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
-
- MockMDBox* a = new MockMDBox;
- MockMDBox* b = new MockMDBox;
-
- EXPECT_CALL(*a, unmask()).Times(1);
- EXPECT_CALL(*b, unmask()).Times(1);
-
- boxes.push_back(a);
- boxes.push_back(b);
-
- MDGridBox<MDLeanEvent<1>,1> griddedBox;
- griddedBox.setChildren(boxes, 0, 2);
-
- TS_ASSERT_THROWS_NOTHING(griddedBox.unmask());//Un-Mask the gridded box
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(a));
- TS_ASSERT(Mock::VerifyAndClearExpectations(b));
- }
-
-private:
- std::string message;
-};
-
-
-
-
-
-
-
-
-
-
-//=====================================================================================
-//===================================== Performance Test ==============================
-//=====================================================================================
-class MDGridBoxTestPerformance : 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 MDGridBoxTestPerformance *createSuite() { return new MDGridBoxTestPerformance(); }
- static void destroySuite( MDGridBoxTestPerformance *suite ) { delete suite; }
-
- MDGridBox<MDLeanEvent<3>,3> * box3;
- MDGridBox<MDLeanEvent<3>,3> * box3b;
- std::vector<MDLeanEvent<3> > events;
- MDGridBox<MDLeanEvent<1>,1> * recursiveParent;
- MDGridBox<MDLeanEvent<1>,1> * recursiveParent2;
-
- MDGridBoxTestPerformance()
- {
- // Split 5x5x5, 2 deep.
- box3b = MDEventsTestHelper::makeRecursiveMDGridBox<3>(5,1);
-
- // Make the list of fake events, random dist.
- size_t num = 1000000;
- events.clear();
-
- boost::mt19937 rng;
- boost::uniform_real<double> u(0, 5.0); // Range
- boost::variate_generator<boost::mt19937&, boost::uniform_real<double> > gen(rng, u);
- for (size_t i=0; i<num; ++i)
- {
- double centers[3];
- for (size_t d=0; d<3; d++)
- centers[d] = gen();
- // Create and add the event.
- events.push_back( MDLeanEvent<3>( 1.0, 1.0, centers) );
- }
-
- box3b->addEvents(events);
- box3b->refreshCache();
- // Recursively gridded box with 1,111,111 boxes total.
- recursiveParent = MDEventsTestHelper::makeRecursiveMDGridBox<1>(10,6);
- // Recursively gridded box with 111,111 boxes total.
- recursiveParent2 = MDEventsTestHelper::makeRecursiveMDGridBox<1>(10,5);
-
- }
-
- ~MDGridBoxTestPerformance()
- {
- delete box3b;
- }
-
- void setUp()
- {
- // Make a fresh box.
- box3 = MDEventsTestHelper::makeRecursiveMDGridBox<3>(5,1);
- }
-
- void tearDown()
- {
- delete box3;
- }
-
-
- void test_refreshCache()
- {
- box3b->refreshCache();
- }
-
- /** Performance test that adds lots of events to a recursively split box.
- * SINGLE-THREADED!
- */
- void test_addEvents_lots()
- {
- // We built this many MDBoxes
- TS_ASSERT_EQUALS( box3->getBoxController()->getTotalNumMDBoxes(), 125*125+1); // +1 might be a test issue
- TS_ASSERT_EQUALS( events.size(), 1e6);
-
- // Add them!
- for(size_t i=0; i<5; ++i)
- {
- box3->addEvents(events);
- }
- }
-
- //-----------------------------------------------------------------------------
- /** Do a sphere integration
- *
- * @param center :: coordinate of the center
- * @param radius :: radius
- */
- void do_test_sphereIntegrate(coord_t * center, coord_t radius, double expectSignal, double tol)
- {
- // The sphere transformation
- bool dimensionsUsed[3] = {true,true,true};
- CoordTransformDistance sphere(3, center, dimensionsUsed);
-
- // Repeat the integration a lot
- signal_t signal, errorSquared;
- for (size_t i=0; i < 1000; i++)
- {
- signal = 0;
- errorSquared = 0;
- box3b->integrateSphere(sphere, radius*radius, signal, errorSquared);
- }
-
- TS_ASSERT_DELTA(signal, expectSignal, tol);
- TS_ASSERT_DELTA(signal, errorSquared, 1e-3);
- }
-
- /** Smallish sphere in the middle goes partially through lots of boxes */
- void test_sphereIntegrate_inTheMiddle()
- {
- coord_t center[3] = {2.5, 2.5, 2.5};
- do_test_sphereIntegrate(center, 1.0, (1e6/125)*(4.0*3.14159/3.0), 2000.0);
- }
-
- /** Huge sphere containing all within */
- void test_sphereIntegrate_inTheMiddle_largeSphere()
- {
- coord_t center[3] = {2.5, 2.5, 2.5};
- do_test_sphereIntegrate(center, 5.0, 1e6, 1e-3);
- }
-
- /** Peak that is off the box entirely */
- void test_sphereIntegrate_OffTheBox()
- {
- coord_t center[3] = {11., 5., 5.};
- do_test_sphereIntegrate(center, 1.0, 0.0, 1e-3);
- }
-
-
-
-
- //-----------------------------------------------------------------------------
- /** Do a sphere centroiding
- *
- * @param center :: coordinate of the center
- * @param radius :: radius
- */
- void do_test_sphereCentroid(coord_t * center, coord_t radius, double expectSignal, double tol)
- {
- // The sphere transformation
- bool dimensionsUsed[3] = {true,true,true};
- CoordTransformDistance sphere(3, center, dimensionsUsed);
-
- // Repeat the integration a lot
- signal_t signal;
- coord_t centroid[3];
- for (size_t i=0; i < 100; i++)
- {
- signal = 0;
- for (size_t d=0; d<3; d++)
- centroid[d] = 0.0;
- box3b->centroidSphere(sphere, radius*radius, centroid, signal) ;
- if (signal != 0.0)
- {
- for (size_t d=0; d<3; d++)
- centroid[d] /= static_cast<coord_t>(signal);
- }
- }
-
- // The expected number of events, given a sphere of radius "radius"
- TS_ASSERT_DELTA(signal, expectSignal, tol);
-
- if (expectSignal > 0.0)
- {
- // And the centroid should be close to the sphere center
- for (size_t d=0; d<3; d++)
- TS_ASSERT_DELTA(centroid[d], center[d], 1e-2);
- }
- }
-
- /** Smallish sphere in the middle goes partially through lots of boxes */
- void test_sphereCentroid_inTheMiddle()
- {
- coord_t center[3] = {2.5, 2.5, 2.5};
- do_test_sphereCentroid(center, 1.0, (1e6/125)*(4.0*3.14159/3.0), 2000);
- }
-
- /** Huge sphere containing all within */
- void test_sphereCentroid_inTheMiddle_largeSphere()
- {
- coord_t center[3] = {2.5, 2.5, 2.5};
- do_test_sphereCentroid(center, 5.0, 1e6, 1e-3);
- }
-
- /** Peak that is off the box entirely */
- void test_sphereCentroid_OffTheBox()
- {
- coord_t center[3] = {11., 5., 5.};
- do_test_sphereCentroid(center, 1.0, 0.0, 1e-3);
- }
-
-
- /** Recursive getting of a list of MDBoxBase.
- * Gets about 11 million boxes */
- void test_getBoxes()
- {
- CPUTimer tim;
- std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes;
- for (size_t i=0; i<10; i++)
- {
- boxes.clear();
- boxes.reserve(1111111);
- recursiveParent->getBoxes(boxes, 6, false);
- TS_ASSERT_EQUALS( boxes.size(), 1111111);
- TS_ASSERT_EQUALS( boxes[0], recursiveParent);
- }
- std::cout << tim << " to getBoxes() 10 x 1.1 million boxes." << std::endl;
- }
-
+// }
+//
+// /** Test of sphere integration with even splitting*/
+// void test_integrateSphere()
+// {
+// // 10x10 sized box
+// MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>();
+// MDEventsTestHelper::feedMDBox<2>(box_ptr, 1);
+// do_test_integrateSphere(box_ptr);
+// }
+//
+// void test_integrateSphere_unevenSplit()
+// {
+// // 10x5 sized box
+// MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>(10,5);
+// MDEventsTestHelper::feedMDBox<2>(box_ptr, 1);
+// do_test_integrateSphere(box_ptr);
+// }
+//
+// void test_integrateSphere_unevenSplit2()
+// {
+// // Funnier splitting: 3x7 sized box
+// MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>(3,7);
+// MDEventsTestHelper::feedMDBox<2>(box_ptr, 1);
+// do_test_integrateSphere(box_ptr);
+// }
+//
+//
+// /** Had a really-hard to find bug where the tests worked only
+// * if the extents started at 0.0.
+// * This test has a box from -10.0 to +10.0 to check for that
+// */
+// void test_integrateSphere_dimensionsDontStartAtZero()
+// {
+// MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>(10,10, -10.0);
+// // One event at center of each box
+// MDEventsTestHelper::feedMDBox<2>(box_ptr, 1, 10, -9.0, 2.0);
+// MDGridBox<MDLeanEvent<2>,2> & box = *box_ptr;
+// TS_ASSERT_EQUALS( box.getNPoints(), 10*10);
+//
+// do_check_integrateSphere(box, 1.0,1.0, 1.45, 1.0, "Contains one box completely");
+// do_check_integrateSphere(box, 9.0,9.0, 1.45, 1.0, "Contains one box completely, at the edges");
+// }
+//
+//
+// //------------------------------------------------------------------------------------------------
+// /** For test_integrateSphere3d
+// *
+// * @param box
+// * @param radius :: radius to integrate
+// * @param numExpected :: how many events should be in there
+// */
+// void do_check_integrateSphere3d(MDGridBox<MDLeanEvent<3>,3> & box, double x, double y, double z,
+// const double radius, double numExpected, std::string message)
+// {
+// std::cout << "Sphere of radius " << radius << " at " << x << "," << y << "," << z << "--- " << message << " ---------\n";
+// // The sphere transformation
+// bool dimensionsUsed[3] = {true,true, true};
+// coord_t center[3] = {static_cast<coord_t>(x),static_cast<coord_t>(y),static_cast<coord_t>(z)};
+// CoordTransformDistance sphere(3, center, dimensionsUsed);
+//
+// signal_t signal = 0;
+// signal_t errorSquared = 0;
+// box.integrateSphere(sphere, static_cast<coord_t>(radius*radius), signal, errorSquared);
+// TSM_ASSERT_DELTA( message, signal, 1.0*numExpected, 1e-5);
+// TSM_ASSERT_DELTA( message, errorSquared, 1.0*numExpected, 1e-5);
+// }
+//
+// //------------------------------------------------------------------------------------------------
+// void test_integrateSphere3d()
+// {
+// MDGridBox<MDLeanEvent<3>,3> * box_ptr = MDEventsTestHelper::makeMDGridBox<3>();
+// MDEventsTestHelper::feedMDBox<3>(box_ptr, 1);
+// MDGridBox<MDLeanEvent<3>,3> & box = *box_ptr;
+// TS_ASSERT_EQUALS( box.getNPoints(), 10*10*10);
+//
+// do_check_integrateSphere3d(box, 0.5,0.5,0.5, 0.9, 1.0, "Contains one box completely, at a corner");
+// do_check_integrateSphere3d(box, 9.5,9.5,9.5, 0.9, 1.0, "Contains one box completely, at a corner");
+// do_check_integrateSphere3d(box, 9.5,9.5,9.5, 0.85, 1.0, "Does NOT contain one box completely, at a corner");
+// do_check_integrateSphere3d(box, 9.0,9.0,9.0, 1.75, 20.0, "Contains 8 boxes completely, at a corner");
+// do_check_integrateSphere3d(box, 9.0,9.0,9.0, 1.70, 20.0, "Does NOT contains one box completely, at a corner");
+//
+// // Now I add an event very near an edge
+// double center[3] = {0.001, 0.5, 0.5};
+// box.addEvent(MDLeanEvent<3>(2.0, 2.0, center));
+//// do_check_integrateSphere(box, -1.0,0.5, 1.01, 1.0, "Off an edge but just barely enough to get an event");
+//// do_check_integrateSphere(box, 0.0,0.5, 0.01, 1.0, "Tiny, but just barely enough to get an event");
+// }
+//
+//
+//
+//
+//
+// //------------------------------------------------------------------------------------------------
+// /** For test_integrateSphere
+// *
+// * @param box
+// * @param radius :: radius to integrate
+// * @param xExpected :: expected centroid
+// * @param yExpected :: expected centroid
+// */
+// void do_check_centroidSphere(MDGridBox<MDLeanEvent<2>,2> & box, double x, double y,
+// const double radius,
+// double numExpected, double xExpected, double yExpected,
+// std::string message)
+// {
+// std::cout << "Centroid of sphere of radius " << radius << " at " << x << "," << y << "------" << message << "--\n";
+// // The sphere transformation
+// bool dimensionsUsed[2] = {true,true};
+// coord_t center[2] = {static_cast<coord_t>(x),static_cast<coord_t>(y)};
+// CoordTransformDistance sphere(2, center, dimensionsUsed);
+//
+// signal_t signal = 0;
+// coord_t centroid[2] = {0., 0.};
+// box.centroidSphere(sphere, static_cast<coord_t>(radius*radius), centroid, signal);
+// // Normalized
+// if (signal != 0.0)
+// {
+// for (size_t d=0; d<2; d++)
+// centroid[d] /= static_cast<coord_t>(signal);
+// }
+//
+// TSM_ASSERT_DELTA( message, signal, 1.0*numExpected, 1e-5);
+// TSM_ASSERT_DELTA( message, centroid[0], xExpected, 1e-5);
+// TSM_ASSERT_DELTA( message, centroid[1], yExpected, 1e-5);
+// }
+//
+// /** Re-used suite of tests */
+// void test_centroidSphere()
+// {
+// // 10x10 sized box
+// MDGridBox<MDLeanEvent<2>,2> * box_ptr = MDEventsTestHelper::makeMDGridBox<2>();
+// MDEventsTestHelper::feedMDBox<2>(box_ptr, 1);
+// // Events are at 0.5, 1.5, etc.
+// MDGridBox<MDLeanEvent<2>,2> & box = *box_ptr;
+// TS_ASSERT_EQUALS( box.getNPoints(), 10*10);
+//
+// do_check_centroidSphere(box, 4.5,4.5, 0.5, 1.0, 4.5, 4.5, "Too small to contain any vertices");
+// do_check_centroidSphere(box, 4.5, 4.5, 0.001, 1.0, 4.5, 4.5, "Tiny but still has an event.");
+// do_check_centroidSphere(box, 4.51,4.5, 0.001, 0.0, 0.0, 0.0, "Tiny but off the event.");
+// do_check_centroidSphere(box, 2.0,2.0, 0.49, 0.0, 0.0, 0.0, "At a corner but grabbing nothing");
+// do_check_centroidSphere(box, 4.8,4.5, 0.35, 1.0, 4.5, 4.5, "Too small to contain any vertices");
+// do_check_centroidSphere(box, 5.0,5.0, 1.0, 4.0, 5.0, 5.0, "At a corner, containing 4 neighbors");
+// do_check_centroidSphere(box, 4.5,4.5, 0.9, 1.0, 4.5, 4.5, "Contains one box completely");
+// do_check_centroidSphere(box, 0.5,0.5, 0.9, 1.0, 0.5, 0.5, "Contains one box completely, at the edges");
+// do_check_centroidSphere(box, 9.5,0.5, 0.9, 1.0, 9.5, 0.5, "Contains one box completely, at the edges");
+// do_check_centroidSphere(box, 0.5,9.5, 0.9, 1.0, 0.5, 9.5, "Contains one box completely, at the edges");
+// do_check_centroidSphere(box, 4.5,9.5, 0.9, 1.0, 4.5, 9.5, "Contains one box completely, at the edges");
+// do_check_centroidSphere(box, 9.5,9.5, 0.9, 1.0, 9.5, 9.5, "Contains one box completely, at the edges");
+// do_check_centroidSphere(box, 1.5,1.5, 1.95, 9.0, 1.5, 1.5, "Contains 5 boxes completely, and 4 boxes with a point");
+// do_check_centroidSphere(box, -1.0,0.5, 1.55, 1.0, 0.5, 0.5, "Off an edge but enough to get an event");
+//
+// // Now I add an event very near an edge
+// double center[2] = {0.001, 0.5};
+// box.addEvent(MDLeanEvent<2>(1.0, 1.0, center));
+// do_check_integrateSphere(box, -1.0,0.5, 1.01, 1.0, "Off an edge but just barely enough to get an event");
+// do_check_integrateSphere(box, 0.0,0.5, 0.01, 1.0, "Tiny, but just barely enough to get an event");
+// }
+//
+// void test_getIsMasked_WhenNoMasking()
+// {
+// std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
+//
+// MockMDBox* a = new MockMDBox;
+// MockMDBox* b = new MockMDBox;
+//
+// EXPECT_CALL(*a, getIsMasked()).Times(1).WillOnce(Return(false)); //Not masked
+// EXPECT_CALL(*b, getIsMasked()).Times(1).WillOnce(Return(false)); //Not masked
+//
+// boxes.push_back(a);
+// boxes.push_back(b);
+//
+// MDGridBox<MDLeanEvent<1>,1> g;
+// g.setChildren(boxes, 0, 2);
+//
+// TSM_ASSERT("No inner boxes were masked so the MDGridBox should not report that it is masked", !g.getIsMasked());
+// TS_ASSERT(Mock::VerifyAndClearExpectations(a));
+// TS_ASSERT(Mock::VerifyAndClearExpectations(b));
+// }
+//
+// void test_getIsMasked_WhenFirstMasked()
+// {
+// std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
+//
+// MockMDBox* a = new MockMDBox;
+// MockMDBox* b = new MockMDBox;
+//
+// EXPECT_CALL(*a, getIsMasked()).Times(1).WillOnce(Return(true)); //MASKED
+// EXPECT_CALL(*b, getIsMasked()).Times(0); //Not masked, but will never be called.
+//
+// boxes.push_back(a);
+// boxes.push_back(b);
+//
+// MDGridBox<MDLeanEvent<1>,1> g;
+// g.setChildren(boxes, 0, 2);
+//
+// TSM_ASSERT("First inner box masked, so should return masked", g.getIsMasked());
+// TS_ASSERT(Mock::VerifyAndClearExpectations(a));
+// TS_ASSERT(Mock::VerifyAndClearExpectations(b));
+// }
+//
+// void test_getIsMasked_WhenLastMasked()
+// {
+// std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
+//
+// MockMDBox* a = new MockMDBox;
+// MockMDBox* b = new MockMDBox;
+//
+// EXPECT_CALL(*a, getIsMasked()).Times(1).WillOnce(Return(false)); //NOT MASKED
+// EXPECT_CALL(*b, getIsMasked()).Times(1).WillOnce(Return(true)); //MASKED
+//
+// boxes.push_back(a);
+// boxes.push_back(b);
+//
+// MDGridBox<MDLeanEvent<1>,1> g;
+// g.setChildren(boxes, 0, 2);
+//
+// TSM_ASSERT("Second inner box masked, so should return masked", g.getIsMasked());
+// TS_ASSERT(Mock::VerifyAndClearExpectations(a));
+// TS_ASSERT(Mock::VerifyAndClearExpectations(b));
+// }
+//
+// void test_mask()
+// {
+// std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
+//
+// MockMDBox* a = new MockMDBox;
+// MockMDBox* b = new MockMDBox;
+//
+// EXPECT_CALL(*a, mask()).Times(1);
+// EXPECT_CALL(*b, mask()).Times(1);
+//
+// boxes.push_back(a);
+// boxes.push_back(b);
+//
+// MDGridBox<MDLeanEvent<1>,1> griddedBox;
+// griddedBox.setChildren(boxes, 0, 2);
+//
+// TS_ASSERT_THROWS_NOTHING(griddedBox.mask());//Mask the gridded box
+//
+// TS_ASSERT(Mock::VerifyAndClearExpectations(a));
+// TS_ASSERT(Mock::VerifyAndClearExpectations(b));
+// }
+//
+// void test_unmask()
+// {
+// std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes;
+//
+// MockMDBox* a = new MockMDBox;
+// MockMDBox* b = new MockMDBox;
+//
+// EXPECT_CALL(*a, unmask()).Times(1);
+// EXPECT_CALL(*b, unmask()).Times(1);
+//
+// boxes.push_back(a);
+// boxes.push_back(b);
+//
+// MDGridBox<MDLeanEvent<1>,1> griddedBox;
+// griddedBox.setChildren(boxes, 0, 2);
+//
+// TS_ASSERT_THROWS_NOTHING(griddedBox.unmask());//Un-Mask the gridded box
+//
+// TS_ASSERT(Mock::VerifyAndClearExpectations(a));
+// TS_ASSERT(Mock::VerifyAndClearExpectations(b));
+// }
+//
+//private:
+// std::string message;
+//};
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+////=====================================================================================
+////===================================== Performance Test ==============================
+////=====================================================================================
+//class MDGridBoxTestPerformance : 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 MDGridBoxTestPerformance *createSuite() { return new MDGridBoxTestPerformance(); }
+// static void destroySuite( MDGridBoxTestPerformance *suite ) { delete suite; }
+//
+// MDGridBox<MDLeanEvent<3>,3> * box3;
+// MDGridBox<MDLeanEvent<3>,3> * box3b;
+// std::vector<MDLeanEvent<3> > events;
+// MDGridBox<MDLeanEvent<1>,1> * recursiveParent;
+// MDGridBox<MDLeanEvent<1>,1> * recursiveParent2;
+//
+// MDGridBoxTestPerformance()
+// {
+// // Split 5x5x5, 2 deep.
+// box3b = MDEventsTestHelper::makeRecursiveMDGridBox<3>(5,1);
+//
+// // Make the list of fake events, random dist.
+// size_t num = 1000000;
+// events.clear();
+//
+// boost::mt19937 rng;
+// boost::uniform_real<double> u(0, 5.0); // Range
+// boost::variate_generator<boost::mt19937&, boost::uniform_real<double> > gen(rng, u);
+// for (size_t i=0; i<num; ++i)
+// {
+// double centers[3];
+// for (size_t d=0; d<3; d++)
+// centers[d] = gen();
+// // Create and add the event.
+// events.push_back( MDLeanEvent<3>( 1.0, 1.0, centers) );
+// }
+//
+// box3b->addEvents(events);
+// box3b->refreshCache();
+// // Recursively gridded box with 1,111,111 boxes total.
+// recursiveParent = MDEventsTestHelper::makeRecursiveMDGridBox<1>(10,6);
+// // Recursively gridded box with 111,111 boxes total.
+// recursiveParent2 = MDEventsTestHelper::makeRecursiveMDGridBox<1>(10,5);
+//
+// }
+//
+// ~MDGridBoxTestPerformance()
+// {
+// delete box3b;
+// }
+//
+// void setUp()
+// {
+// // Make a fresh box.
+// box3 = MDEventsTestHelper::makeRecursiveMDGridBox<3>(5,1);
+// }
+//
+// void tearDown()
+// {
+// delete box3;
+// }
+//
+//
+// void test_refreshCache()
+// {
+// box3b->refreshCache();
+// }
+//
+// /** Performance test that adds lots of events to a recursively split box.
+// * SINGLE-THREADED!
+// */
+// void test_addEvents_lots()
+// {
+// // We built this many MDBoxes
+// TS_ASSERT_EQUALS( box3->getBoxController()->getTotalNumMDBoxes(), 125*125+1); // +1 might be a test issue
+// TS_ASSERT_EQUALS( events.size(), 1e6);
+//
+// // Add them!
+// for(size_t i=0; i<5; ++i)
+// {
+// box3->addEvents(events);
+// }
+// }
+//
+// //-----------------------------------------------------------------------------
+// /** Do a sphere integration
+// *
+// * @param center :: coordinate of the center
+// * @param radius :: radius
+// */
+// void do_test_sphereIntegrate(coord_t * center, coord_t radius, double expectSignal, double tol)
+// {
+// // The sphere transformation
+// bool dimensionsUsed[3] = {true,true,true};
+// CoordTransformDistance sphere(3, center, dimensionsUsed);
+//
+// // Repeat the integration a lot
+// signal_t signal, errorSquared;
+// for (size_t i=0; i < 1000; i++)
+// {
+// signal = 0;
+// errorSquared = 0;
+// box3b->integrateSphere(sphere, radius*radius, signal, errorSquared);
+// }
+//
+// TS_ASSERT_DELTA(signal, expectSignal, tol);
+// TS_ASSERT_DELTA(signal, errorSquared, 1e-3);
+// }
+//
+// /** Smallish sphere in the middle goes partially through lots of boxes */
+// void test_sphereIntegrate_inTheMiddle()
+// {
+// coord_t center[3] = {2.5, 2.5, 2.5};
+// do_test_sphereIntegrate(center, 1.0, (1e6/125)*(4.0*3.14159/3.0), 2000.0);
+// }
+//
+// /** Huge sphere containing all within */
+// void test_sphereIntegrate_inTheMiddle_largeSphere()
+// {
+// coord_t center[3] = {2.5, 2.5, 2.5};
+// do_test_sphereIntegrate(center, 5.0, 1e6, 1e-3);
+// }
+//
+// /** Peak that is off the box entirely */
+// void test_sphereIntegrate_OffTheBox()
+// {
+// coord_t center[3] = {11., 5., 5.};
+// do_test_sphereIntegrate(center, 1.0, 0.0, 1e-3);
+// }
+//
+//
+//
+//
+// //-----------------------------------------------------------------------------
+// /** Do a sphere centroiding
+// *
+// * @param center :: coordinate of the center
+// * @param radius :: radius
+// */
+// void do_test_sphereCentroid(coord_t * center, coord_t radius, double expectSignal, double tol)
+// {
+// // The sphere transformation
+// bool dimensionsUsed[3] = {true,true,true};
+// CoordTransformDistance sphere(3, center, dimensionsUsed);
+//
+// // Repeat the integration a lot
+// signal_t signal;
+// coord_t centroid[3];
+// for (size_t i=0; i < 100; i++)
+// {
+// signal = 0;
+// for (size_t d=0; d<3; d++)
+// centroid[d] = 0.0;
+// box3b->centroidSphere(sphere, radius*radius, centroid, signal) ;
+// if (signal != 0.0)
+// {
+// for (size_t d=0; d<3; d++)
+// centroid[d] /= static_cast<coord_t>(signal);
+// }
+// }
+//
+// // The expected number of events, given a sphere of radius "radius"
+// TS_ASSERT_DELTA(signal, expectSignal, tol);
+//
+// if (expectSignal > 0.0)
+// {
+// // And the centroid should be close to the sphere center
+// for (size_t d=0; d<3; d++)
+// TS_ASSERT_DELTA(centroid[d], center[d], 1e-2);
+// }
+// }
+//
+// /** Smallish sphere in the middle goes partially through lots of boxes */
+// void test_sphereCentroid_inTheMiddle()
+// {
+// coord_t center[3] = {2.5, 2.5, 2.5};
+// do_test_sphereCentroid(center, 1.0, (1e6/125)*(4.0*3.14159/3.0), 2000);
+// }
+//
+// /** Huge sphere containing all within */
+// void test_sphereCentroid_inTheMiddle_largeSphere()
+// {
+// coord_t center[3] = {2.5, 2.5, 2.5};
+// do_test_sphereCentroid(center, 5.0, 1e6, 1e-3);
+// }
+//
+// /** Peak that is off the box entirely */
+// void test_sphereCentroid_OffTheBox()
+// {
+// coord_t center[3] = {11., 5., 5.};
+// do_test_sphereCentroid(center, 1.0, 0.0, 1e-3);
+// }
+//
+//
+// /** Recursive getting of a list of MDBoxBase.
+// * Gets about 11 million boxes */
+// void test_getBoxes()
+// {
+// CPUTimer tim;
+// std::vector<MDBoxBase<MDLeanEvent<1>,1> *> boxes;
+// for (size_t i=0; i<10; i++)
+// {
+// boxes.clear();
+// boxes.reserve(1111111);
+// recursiveParent->getBoxes(boxes, 6, false);
+// TS_ASSERT_EQUALS( boxes.size(), 1111111);
+// TS_ASSERT_EQUALS( boxes[0], recursiveParent);
+// }
+// std::cout << tim << " to getBoxes() 10 x 1.1 million boxes." << std::endl;
+// }
+//
};