Refs #2016: MDGridBox distributes events to child boxes

Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/BoxSplitController.h

@@ -50,6 +50,7 @@ namespace MDEvents
      */
     size_t splitInto(size_t dim)
     {
+      (void) dim; // Ignore dim for now
       return m_splitInto;
     }
 

Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/IMDBox.h

@@ -60,6 +60,27 @@ namespace MDEvents
     /// Add several events
     virtual void addEvents(const std::vector<MDE> & events) = 0;
 
+    //-----------------------------------------------------------------------------------------------
+    /** Set the extents of this box.
+     * @param dim :: index of dimension
+     * @param min :: min edge of the dimension
+     * @param max :: max edge of the dimension
+     */
+    void setExtents(size_t dim, CoordType min, CoordType max)
+    {
+      if (dim >= nd)
+        throw std::invalid_argument("Invalid dimension passed to MDBox::setExtents");
+      this->extents[dim].min = min;
+      this->extents[dim].max = max;
+    }
+
+    //-----------------------------------------------------------------------------------------------
+    /** Get the extents for this box */
+    MDDimensionExtents & getExtents(size_t dim)
+    {
+      return extents[dim];
+    }
+
 
     //-----------------------------------------------------------------------------------------------
     /** Returns the integrated signal from all points within.
@@ -83,7 +104,7 @@ namespace MDEvents
     /** Array of MDDimensionStats giving the extents and
      * other stats on the box dimensions.
      */
-    MDDimensionExtents dimExtents[nd];
+    MDDimensionExtents extents[nd];
 
     /** Cached total signal from all points within */
     double m_signal;

Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h

@@ -43,8 +43,6 @@ namespace MDEvents
 
     size_t getNumDims() const;
 
-    void setExtents(size_t dim, CoordType min, CoordType max);
-
     std::vector< MDE > & getEvents();
 
     std::vector< MDE > * getEventsCopy();
@@ -55,17 +53,16 @@ namespace MDEvents
 
     bool willSplit(size_t num) const;
 
-  private:
+    /// Return the split controller saved.
+    BoxSplitController_sptr getSplitController() const
+    { return m_splitController; }
+
+  protected:
 
     /** Vector of MDEvent's, in no particular order.
      * */
     std::vector< MDE > data;
 
-    /** Array of MDDimensionExtents giving the extents and
-     * in each dimension.
-     */
-    MDDimensionExtents extents[nd];
-
     /// The box splitting controller
     BoxSplitController_sptr m_splitController;
 

Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDGridBox.h

@@ -5,6 +5,7 @@
 #include "MantidKernel/System.h"
 #include "MantidMDEvents/BoxSplitController.h"
 #include "MantidMDEvents/IMDBox.h"
+#include "MantidMDEvents/MDBox.h"
 #include "MantidMDEvents/MDDimensionExtents.h"
 #include "MantidMDEvents/MDEvent.h"
 
@@ -29,7 +30,7 @@ namespace MDEvents
   class DLLExport MDGridBox : public IMDBox<MDE, nd>
   {
   public:
-    MDGridBox();
+    MDGridBox(MDBox<MDE, nd> * box);
 
     void clear();
 
@@ -45,12 +46,32 @@ namespace MDEvents
 
     bool willSplit(size_t num) const;
 
+    // ======================= Testing/Debugging Methods =================
+    /** For testing: get the vector of boxes */
+    std::vector<IMDBox<MDE, nd>*> getBoxes()
+    { return boxes; }
+
   private:
 
     /** Array of MDDimensionExtents giving the extents and
      * in each dimension.
      */
-    MDDimensionExtents dims[nd];
+    MDDimensionExtents extents[nd];
+
+    /// Each dimension is split into this many equally-sized boxes
+    size_t split[nd];
+
+    /** Cumulative dimension splitting: split[n] = 1*split[0]*split[..]*split[n-1]
+     */
+    size_t splitCumul[nd];
+
+    /** 1D array of boxes contained within. These map
+     * to the nd-array.
+     */
+    std::vector<IMDBox<MDE, nd>*> boxes;
+
+    /// Size of each box size in the i^th dimension
+    CoordType boxSize[nd];
 
 
   public:

Code/Mantid/Framework/MDEvents/src/MDBox.cpp

@@ -47,21 +47,6 @@ namespace MDEvents
     return data.size();
   }
 
-  //-----------------------------------------------------------------------------------------------
-  /** Set the extents of this box.
-   * @param dim :: index of dimension
-   * @param min :: min edge of the dimension
-   * @param max :: max edge of the dimension
-   */
-  TMDE(
-  void MDBox)::setExtents(size_t dim, CoordType min, CoordType max)
-  {
-    if (dim >= nd)
-      throw std::invalid_argument("Invalid dimension passed to MDBox::setExtents");
-    this->extents[dim].min = min;
-    this->extents[dim].max = min;
-  }
-
   //-----------------------------------------------------------------------------------------------
   /** Returns a reference to the events vector contained within.
    */

Code/Mantid/Framework/MDEvents/src/MDGridBox.cpp

@@ -8,12 +8,73 @@ namespace MDEvents
 {
 
   //-----------------------------------------------------------------------------------------------
-  /** Empty constructor */
-  TMDE(MDGridBox)::MDGridBox() :
+  /** Constructor
+   * @param box :: MDBox containing the events to split */
+  TMDE(MDGridBox)::MDGridBox(MDBox<MDE, nd> * box) :
     IMDBox<MDE, nd>()
   {
+    if (!box)
+      throw std::runtime_error("MDGridBox::ctor(): box is NULL.");
+    BoxSplitController_sptr sc = box->getSplitController();
+    if (!sc)
+      throw std::runtime_error("MDGridBox::ctor(): No BoxSplitController specified in box.");
+
+    // Copy the extents
+    for (size_t d=0; d<nd; d++)
+      extents[d] = box->getExtents(d);
+
+    // Do some computation based on how many splits per each dim.
+    size_t tot = 1;
+    for (size_t d=0; d<nd; d++)
+    {
+      // Cumulative multiplier, for indexing
+      splitCumul[d] = tot;
+      // How many is it split?
+      split[d] = sc->splitInto(d);
+      tot *= split[d];
+      // Length of the side of a box in this dimension
+      boxSize[d] = (extents[d].max - extents[d].min) / split[d];
+    }
+
+    if (tot == 0)
+      throw std::runtime_error("MDGridBox::ctor(): Invalid splitting criterion (one was zero).");
+
+    // Create the array of MDBox contents.
+    boxes.clear();
+    boxes.reserve(tot);
+
+    size_t indices[nd];
+    for (size_t d=0; d<nd; d++) indices[d] = 0;
+    for (size_t i=0; i<tot; i++)
+    {
+      // Create the box
+      MDBox<MDE,nd> * myBox = new MDBox<MDE,nd>(sc);
+      // Set the extents of this box.
+      for (size_t d=0; d<nd; d++)
+      {
+        CoordType min = extents[d].min + boxSize[d] * indices[d];
+        myBox->setExtents(d, min, min + boxSize[d]);
+      }
+      boxes.push_back(myBox);
+
+      // Increment the indices, rolling back as needed
+      indices[0]++;
+      for (size_t d=0; d<nd-1; d++)
+      {
+        if (indices[d] > splitCumul[d])
+        {
+          indices[d] = 0;
+          indices[d+1]++;
+        }
+      }
+    } // for each box
+
+    // Now distribute the events that were in the box before
+    this->addEvents(box->getEvents());
   }
 
+
+
   //-----------------------------------------------------------------------------------------------
   /** Clear any points contained. */
   TMDE(
@@ -35,9 +96,14 @@ namespace MDEvents
   /** Returns the total number of points (events) in this box */
   TMDE(size_t MDGridBox)::getNPoints() const
   {
-    return 0;
+    //TODO: Cache the value!
+    size_t tot = 0;
+    for (size_t i=0; i<boxes.size(); i++)
+      tot += boxes[i]->getNPoints();
+    return tot;
   }
 
+
   //-----------------------------------------------------------------------------------------------
   /** Allocate and return a vector with a copy of all events contained
    */
@@ -80,13 +146,40 @@ namespace MDEvents
 
 
   //-----------------------------------------------------------------------------------------------
-  /** Add several events
+  /** Add several events. For the grid box, this one needs to
+   * parcel out which box receives which event.
+   *
    * @param events :: vector of events to be copied.
    */
   TMDE(
   void MDGridBox)::addEvents(const std::vector<MDE> & events)
   {
-    //this->data.insert(this->data.end(), events.begin(), events.end());
+    //TODO: Does it make sense to collect vectors to add, in the event that it is a HUGE list?
+
+    // --- Go event by event and add them ----
+    typename std::vector<MDE>::const_iterator it;
+    typename std::vector<MDE>::const_iterator it_end = events.end();
+    for (it = events.begin(); it != it_end; it++)
+    {
+      bool badEvent = false;
+      size_t index = 0;
+      for (size_t d=0; d<nd; d++)
+      {
+        CoordType x = it->getCenter(d);
+        int i = (x - extents[d].min) / boxSize[d];
+        if (i < 0 || i >= int(split[d]))
+        {
+          badEvent=true;
+          break;
+        }
+        // Accumulate the index
+        index += (i * splitCumul[d]);
+      }
+      if (!badEvent)
+      {
+        boxes[index]->addEvent( *it );
+      }
+    }
   }
 
 
@@ -99,12 +192,12 @@ namespace MDEvents
   template DLLExport class MDGridBox<MDEvent<1>, 1>;
   template DLLExport class MDGridBox<MDEvent<2>, 2>;
   template DLLExport class MDGridBox<MDEvent<3>, 3>;
-  template DLLExport class MDGridBox<MDEvent<4>, 4>;
-  template DLLExport class MDGridBox<MDEvent<5>, 5>;
-  template DLLExport class MDGridBox<MDEvent<6>, 6>;
-  template DLLExport class MDGridBox<MDEvent<7>, 7>;
-  template DLLExport class MDGridBox<MDEvent<8>, 8>;
-  template DLLExport class MDGridBox<MDEvent<9>, 9>;
+//  template DLLExport class MDGridBox<MDEvent<4>, 4>;
+//  template DLLExport class MDGridBox<MDEvent<5>, 5>;
+//  template DLLExport class MDGridBox<MDEvent<6>, 6>;
+//  template DLLExport class MDGridBox<MDEvent<7>, 7>;
+//  template DLLExport class MDGridBox<MDEvent<8>, 8>;
+//  template DLLExport class MDGridBox<MDEvent<9>, 9>;
 
 
 }//namespace MDEvents

Code/Mantid/Framework/MDEvents/test/MDBoxTest.h

@@ -29,7 +29,13 @@ public:
   {
     MDBox<MDEvent<2>,2> b;
     b.setExtents(0, -10.0, 10.0);
-    b.setExtents(1, -4.0, 4.0);
+    TS_ASSERT_DELTA(b.getExtents(0).min, -10.0, 1e-6);
+    TS_ASSERT_DELTA(b.getExtents(0).max, +10.0, 1e-6);
+
+    b.setExtents(1, -4.0, 6.0);
+    TS_ASSERT_DELTA(b.getExtents(1).min, -4.0, 1e-6);
+    TS_ASSERT_DELTA(b.getExtents(1).max, +6.0, 1e-6);
+
     TS_ASSERT_THROWS( b.setExtents(2, 0, 1.0), std::invalid_argument);
   }
 
@@ -130,6 +136,8 @@ public:
     for(int i=0; i < 12; i++) vec.push_back(ev);
     b3.addEvents( vec );
 
+    TS_ASSERT_EQUALS( b3.getSplitController(), sc);
+
   }
 };
 

Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h

@@ -36,13 +36,13 @@ public:
 
 
   //-------------------------------------------------------------------------------------
-  /** Return a vector with this many MDEvents, spaced evenly from 0.0, 1.0, etc. */
+  /** Return a vector with this many MDEvents, spaced evenly from 0.5, 1.5, etc. */
   std::vector<MDEvent<1> > makeMDEvents1(size_t num)
   {
     std::vector<MDEvent<1> > out;
     for (size_t i=0; i<num; i++)
     {
-      CoordType coords[1] = {i*1.0};
+      CoordType coords[1] = {i*1.0+0.5};
       out.push_back( MDEvent<1>(1.0, 1.0, coords) );
     }
     return out;
@@ -50,16 +50,47 @@ public:
 
 
   //-------------------------------------------------------------------------------------
-  void test_Constructor()
+  void test_MDBoxConstructor()
   {
     MDBox<MDEvent<1>,1> * b = makeMDBox1();
     TS_ASSERT_EQUALS( b->getNumDims(), 1);
     TS_ASSERT_EQUALS( b->getNPoints(), 0);
+    TS_ASSERT( b->willSplit(10) );
+    TS_ASSERT_DELTA( b->getExtents(0).min, 0.0,  1e-5);
+    TS_ASSERT_DELTA( b->getExtents(0).max, 10.0, 1e-5);
+    delete b;
+  }
+
+
+  //-------------------------------------------------------------------------------------
+  void test_MDGridBox_Construction()
+  {
+    MDBox<MDEvent<1>,1> * b = makeMDBox1();
+    // Give it 10 events
+    b->addEvents( makeMDEvents1(10) );
+    TS_ASSERT_EQUALS( b->getNPoints(), 10 );
+
+    // Build the grid box out of it
+    MDGridBox<MDEvent<1>,1> * g = new MDGridBox<MDEvent<1>,1>(b);
+
+    // Look overall; it has 10 points
+    TS_ASSERT_EQUALS(g->getNumDims(), 1);
+    TS_ASSERT_EQUALS(g->getNPoints(), 10);
+
+    // Check the boxes
+    std::vector<IMDBox<MDEvent<1>,1> *> boxes = g->getBoxes();
+    TS_ASSERT_EQUALS( boxes.size(), 10.0);
+    for (size_t i=0; i<10; i++)
+    {
+      MDBox<MDEvent<1>,1> * box = dynamic_cast<MDBox<MDEvent<1>,1> *>(boxes[i]);
+      TS_ASSERT_DELTA(box->getExtents(0).min, i*1.0, 1e-6);
+      TS_ASSERT_DELTA(box->getExtents(0).max, (i+1)*1.0, 1e-6);
+      // Look at the single event in there
+      TS_ASSERT_EQUALS(box->getNPoints(), 1);
+      MDEvent<1> ev = box->getEvents()[0];
+      TS_ASSERT_DELTA(ev.getCenter(0), i*1.0 + 0.5, 1e-5);
+    }
 
-    // Construct it
-//    MDGridBox<MDEvent<1>,1> g(*b);
-//    TS_ASSERT_EQUALS( g->getNumDims(), 1);
-//    TS_ASSERT_EQUALS( g->getNPoints(), 0);
   }
 
 };