diff --git a/Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MergeMDFiles.h b/Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MergeMDFiles.h
index 188bbae8ebdb43a7314cfff0b35a742e241f43bd..41a468eb756e7d33cbc60ce184dc94c47f7d2c29 100644
--- a/Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MergeMDFiles.h
+++ b/Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MergeMDFiles.h
@@ -62,21 +62,21 @@ namespace MDAlgorithms
template<typename MDE, size_t nd>
void loadBoxData();
- template<typename MDE, size_t nd>
- typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr createOutputWS(typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr ws);
-
template<typename MDE, size_t nd>
typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr createOutputWSbyCloning(typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr ws);
- template<typename MDE, size_t nd>
- void doExec(typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr ws);
-
template<typename MDE, size_t nd>
void doExecByCloning(typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr ws);
template<typename MDE, size_t nd>
void finalizeOutput(typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr outWS);
+// template<typename MDE, size_t nd>
+// typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr createOutputWS(typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr ws);
+//
+// template<typename MDE, size_t nd>
+// void doExec(typename Mantid::MDEvents::MDEventWorkspace<MDE, nd>::sptr ws);
+
public:
/// Files to load
diff --git a/Code/Mantid/Framework/MDAlgorithms/src/MergeMDFiles.cpp b/Code/Mantid/Framework/MDAlgorithms/src/MergeMDFiles.cpp
index ac8b61ea92daa042aae1d34b40777f8715e5101f..2add40e13ba64af72da40c38667d17dd1a2717d8 100644
--- a/Code/Mantid/Framework/MDAlgorithms/src/MergeMDFiles.cpp
+++ b/Code/Mantid/Framework/MDAlgorithms/src/MergeMDFiles.cpp
@@ -12,6 +12,8 @@ Then, enter the path to all of the files created previously. The algorithm avoid
keeping the events from ONE box from ALL the files in memory at once to further process and refine it.
This is why it requires a common box structure.
+See also: [[MergeMD]], for merging any MDWorkspaces in system memory (faster, but needs more memory).
+
*WIKI*/
#include "MantidAPI/FileProperty.h"
@@ -80,78 +82,198 @@ namespace MDAlgorithms
}
- //======================================================================================
- /** Task that loads all of the events from a particular block from a file
- * that is being merged and then adds them onto the output workspace.
- */
- TMDE_CLASS
- class MergeMDLoadTask : public Mantid::Kernel::Task
- {
- public:
- /** Constructor
- *
- * @param alg :: MergeMDFiles Algorithm - used to pass parameters etc. around
- * @param blockNum :: Which block to load?
- * @param outWS :: Output workspace
- */
- MergeMDLoadTask(MergeMDFiles * alg, size_t blockNum, typename MDEventWorkspace<MDE, nd>::sptr outWS)
- : m_alg(alg), m_blockNum(blockNum), outWS(outWS)
- {
- }
-
- //---------------------------------------------------------------------------------------------
- /** Main method that performs the work for the task. */
- void run()
- {
- // Vector of events accumulated from ALL files to merge.
- std::vector<MDE> events;
-
- // Go through each file
- this->m_alg->fileMutex.lock();
- for (size_t iw=0; iw<m_alg->files.size(); iw++)
- {
- // The file and the indexes into that file
- ::NeXus::File * file = this->m_alg->files[iw];
- std::vector<uint64_t> & box_event_index = this->m_alg->box_indexes[iw];
-
- uint64_t indexStart = box_event_index[this->m_blockNum*2+0];
- uint64_t numEvents = box_event_index[this->m_blockNum*2+1];
- // This will APPEND the events to the one vector
- MDE::loadVectorFromNexusSlab(events, file, indexStart, numEvents);
- } // For each file
- this->m_alg->fileMutex.unlock();
-
- if (!events.empty())
- {
- // Add all the events from the same box
- outWS->addEvents( events );
-
- // Track the total number of added events
- m_alg->statsMutex.lock();
- m_alg->totalLoaded += uint64_t(events.size());
- m_alg->getLogger().debug() << "Box " << m_blockNum << ". Total events " << m_alg->totalLoaded << ". This one added " << events.size() << ". "<< std::endl;
- // Report the progress
- m_alg->prog->reportIncrement(events.size(), "Loading Box");
- m_alg->statsMutex.unlock();
- } // there was something loaded
-
- }
-
-
- protected:
- /// MergeMDFiles Algorithm - used to pass parameters etc. around
- MergeMDFiles * m_alg;
- /// Which block to load?
- size_t m_blockNum;
- /// Output workspace
- typename MDEventWorkspace<MDE, nd>::sptr outWS;
- };
-
-
-
-
-
+//
+// //======================================================================================
+// /** Task that loads all of the events from a particular block from a file
+// * that is being merged and then adds them onto the output workspace.
+// */
+// TMDE_CLASS
+// class MergeMDLoadTask : public Mantid::Kernel::Task
+// {
+// public:
+// /** Constructor
+// *
+// * @param alg :: MergeMDFiles Algorithm - used to pass parameters etc. around
+// * @param blockNum :: Which block to load?
+// * @param outWS :: Output workspace
+// */
+// MergeMDLoadTask(MergeMDFiles * alg, size_t blockNum, typename MDEventWorkspace<MDE, nd>::sptr outWS)
+// : m_alg(alg), m_blockNum(blockNum), outWS(outWS)
+// {
+// }
+//
+// //---------------------------------------------------------------------------------------------
+// /** Main method that performs the work for the task. */
+// void run()
+// {
+// // Vector of events accumulated from ALL files to merge.
+// std::vector<MDE> events;
+//
+// // Go through each file
+// this->m_alg->fileMutex.lock();
+// for (size_t iw=0; iw<m_alg->files.size(); iw++)
+// {
+// // The file and the indexes into that file
+// ::NeXus::File * file = this->m_alg->files[iw];
+// std::vector<uint64_t> & box_event_index = this->m_alg->box_indexes[iw];
+//
+// uint64_t indexStart = box_event_index[this->m_blockNum*2+0];
+// uint64_t numEvents = box_event_index[this->m_blockNum*2+1];
+// // This will APPEND the events to the one vector
+// MDE::loadVectorFromNexusSlab(events, file, indexStart, numEvents);
+// } // For each file
+// this->m_alg->fileMutex.unlock();
+//
+// if (!events.empty())
+// {
+// // Add all the events from the same box
+// outWS->addEvents( events );
+//
+// // Track the total number of added events
+// m_alg->statsMutex.lock();
+// m_alg->totalLoaded += uint64_t(events.size());
+// m_alg->getLogger().debug() << "Box " << m_blockNum << ". Total events " << m_alg->totalLoaded << ". This one added " << events.size() << ". "<< std::endl;
+// // Report the progress
+// m_alg->prog->reportIncrement(events.size(), "Loading Box");
+// m_alg->statsMutex.unlock();
+// } // there was something loaded
+//
+// }
+//
+//
+// protected:
+// /// MergeMDFiles Algorithm - used to pass parameters etc. around
+// MergeMDFiles * m_alg;
+// /// Which block to load?
+// size_t m_blockNum;
+// /// Output workspace
+// typename MDEventWorkspace<MDE, nd>::sptr outWS;
+// };
+//
+//
+//
+//
+//
+// //----------------------------------------------------------------------------------------------
+// /** Create the output workspace using the input as a guide
+// *
+// * @param ws :: first workspace from the inputs
+// * @return the MDEventWorkspace sptr.
+// */
+// template<typename MDE, size_t nd>
+// typename MDEventWorkspace<MDE, nd>::sptr MergeMDFiles::createOutputWS(typename MDEventWorkspace<MDE, nd>::sptr ws)
+// {
+// // Use the copy constructor to get the same dimensions etc.
+// typename MDEventWorkspace<MDE, nd>::sptr outWS(new MDEventWorkspace<MDE, nd>(*ws));
+// this->outIWS = outWS;
+//
+// std::string outputFile = getProperty("OutputFilename");
+//
+// // Fix the box controller settings in the output workspace so that it splits normally
+// BoxController_sptr bc = outWS->getBoxController();
+// // TODO: Specify these split parameters some smarter way?
+// bc->setMaxDepth(20);
+// bc->setSplitInto(4);
+// bc->setSplitThreshold(10000);
+//
+// // Perform the initial box splitting.
+// IMDBox<MDE,nd> * box = outWS->getBox();
+// for (size_t d=0; d<nd; d++)
+// box->setExtents(d, outWS->getDimension(d)->getMinimum(), outWS->getDimension(d)->getMaximum());
+// box->setBoxController(bc);
+// outWS->splitBox();
+//
+// // Save the empty WS and turn it into a file-backed MDEventWorkspace
+// if (!outputFile.empty())
+// {
+// IAlgorithm_sptr saver = this->createSubAlgorithm("SaveMD" ,0.01, 0.05);
+// saver->setProperty("InputWorkspace", outIWS);
+// saver->setPropertyValue("Filename", outputFile);
+// saver->setProperty("MakeFileBacked", true);
+// saver->executeAsSubAlg();
+// }
+//
+// // Complete the file-back-end creation.
+// DiskBuffer & dbuf = bc->getDiskBuffer(); UNUSED_ARG(dbuf);
+// g_log.notice() << "Setting cache to 400 MB write." << std::endl;
+// bc->setCacheParameters(sizeof(MDE), 400000000/sizeof(MDE));
+//
+//
+// return outWS;
+// }
+//
+//
+// //----------------------------------------------------------------------------------------------
+// /** Perform the merging, with generalized output workspace
+// *
+// * @param ws :: first MDEventWorkspace in the list to merge
+// */
+// template<typename MDE, size_t nd>
+// void MergeMDFiles::doExec(typename MDEventWorkspace<MDE, nd>::sptr ws)
+// {
+// // First, load all the box data
+// this->loadBoxData<MDE,nd>();
+//
+// // Now create the output workspace
+// typename MDEventWorkspace<MDE, nd>::sptr outWS = this->createOutputWS<MDE,nd>(ws);
+//
+// // Progress report based on events processed.
+// this->prog = new Progress(this, 0.1, 0.9, size_t(totalEvents));
+// this->prog->setNotifyStep(0.1);
+//
+// // For tracking progress
+// uint64_t totalEventsInTasks = 0;
+// this->totalLoaded = 0;
+//
+// // Prepare thread pool
+// CPUTimer overallTime;
+// ThreadSchedulerFIFO * ts = new ThreadSchedulerFIFO();
+// ThreadPool tp(ts);
+//
+// for (size_t ib=0; ib<numBoxes; ib++)
+// {
+// // Add a task for each box that actually has some events
+// if (this->eventsPerBox[ib] > 0)
+// {
+// totalEventsInTasks += eventsPerBox[ib];
+// MergeMDLoadTask<MDE,nd> * task = new MergeMDLoadTask<MDE,nd>(this, ib, outWS);
+// ts->push(task);
+// }
+//
+// // You've added enough tasks that will fill up some memory.
+// if (totalEventsInTasks > 10000000)
+// {
+// // Run all the tasks
+// tp.joinAll();
+//
+// // Occasionally release free memory (has an effect on Linux only).
+// MemoryManager::Instance().releaseFreeMemory();
+//
+// // Now do all the splitting tasks
+// g_log.information() << "Splitting boxes since we have added " << totalEventsInTasks << " events." << std::endl;
+// outWS->splitAllIfNeeded(ts);
+// if (ts->size() > 0)
+// prog->doReport("Splitting Boxes");
+// tp.joinAll();
+//
+// totalEventsInTasks = 0;
+// }
+// } // for each box
+//
+// // Run any final tasks
+// tp.joinAll();
+//
+// // Final splitting
+// g_log.debug() << "Final splitting of boxes. " << totalEventsInTasks << " events." << std::endl;
+// outWS->splitAllIfNeeded(ts);
+// tp.joinAll();
+// g_log.information() << overallTime << " to do all the adding." << std::endl;
+//
+// // Finish things up
+// this->finalizeOutput<MDE,nd>(outWS);
+// }
+//
@@ -231,137 +353,6 @@ namespace MDAlgorithms
- //----------------------------------------------------------------------------------------------
- /** Create the output workspace using the input as a guide
- *
- * @param ws :: first workspace from the inputs
- * @return the MDEventWorkspace sptr.
- */
- template<typename MDE, size_t nd>
- typename MDEventWorkspace<MDE, nd>::sptr MergeMDFiles::createOutputWS(typename MDEventWorkspace<MDE, nd>::sptr ws)
- {
- // Use the copy constructor to get the same dimensions etc.
- typename MDEventWorkspace<MDE, nd>::sptr outWS(new MDEventWorkspace<MDE, nd>(*ws));
- this->outIWS = outWS;
-
- std::string outputFile = getProperty("OutputFilename");
-
- // Fix the box controller settings in the output workspace so that it splits normally
- BoxController_sptr bc = outWS->getBoxController();
- // TODO: Specify these split parameters some smarter way?
- bc->setMaxDepth(20);
- bc->setSplitInto(4);
- bc->setSplitThreshold(10000);
-
- // Perform the initial box splitting.
- IMDBox<MDE,nd> * box = outWS->getBox();
- for (size_t d=0; d<nd; d++)
- box->setExtents(d, outWS->getDimension(d)->getMinimum(), outWS->getDimension(d)->getMaximum());
- box->setBoxController(bc);
- outWS->splitBox();
-
- // Save the empty WS and turn it into a file-backed MDEventWorkspace
- if (!outputFile.empty())
- {
- IAlgorithm_sptr saver = this->createSubAlgorithm("SaveMD" ,0.01, 0.05);
- saver->setProperty("InputWorkspace", outIWS);
- saver->setPropertyValue("Filename", outputFile);
- saver->setProperty("MakeFileBacked", true);
- saver->executeAsSubAlg();
- }
-
- // Complete the file-back-end creation.
- DiskBuffer & dbuf = bc->getDiskBuffer(); UNUSED_ARG(dbuf);
- g_log.notice() << "Setting cache to 400 MB write." << std::endl;
- bc->setCacheParameters(sizeof(MDE), 400000000/sizeof(MDE));
-
-
- return outWS;
- }
-
-
- //----------------------------------------------------------------------------------------------
- /** Perform the merging, with generalized output workspace
- *
- * @param ws :: first MDEventWorkspace in the list to merge
- */
- template<typename MDE, size_t nd>
- void MergeMDFiles::doExec(typename MDEventWorkspace<MDE, nd>::sptr ws)
- {
- // First, load all the box data
- this->loadBoxData<MDE,nd>();
-
- // Now create the output workspace
- typename MDEventWorkspace<MDE, nd>::sptr outWS = this->createOutputWS<MDE,nd>(ws);
-
- // Progress report based on events processed.
- this->prog = new Progress(this, 0.1, 0.9, size_t(totalEvents));
- this->prog->setNotifyStep(0.1);
-
- // For tracking progress
- uint64_t totalEventsInTasks = 0;
- this->totalLoaded = 0;
-
- // Prepare thread pool
- CPUTimer overallTime;
- ThreadSchedulerFIFO * ts = new ThreadSchedulerFIFO();
- ThreadPool tp(ts);
-
- for (size_t ib=0; ib<numBoxes; ib++)
- {
- // Add a task for each box that actually has some events
- if (this->eventsPerBox[ib] > 0)
- {
- totalEventsInTasks += eventsPerBox[ib];
- MergeMDLoadTask<MDE,nd> * task = new MergeMDLoadTask<MDE,nd>(this, ib, outWS);
- ts->push(task);
- }
-
- // You've added enough tasks that will fill up some memory.
- if (totalEventsInTasks > 10000000)
- {
- // Run all the tasks
- tp.joinAll();
-
- // Occasionally release free memory (has an effect on Linux only).
- MemoryManager::Instance().releaseFreeMemory();
-
- // Now do all the splitting tasks
- g_log.information() << "Splitting boxes since we have added " << totalEventsInTasks << " events." << std::endl;
- outWS->splitAllIfNeeded(ts);
- if (ts->size() > 0)
- prog->doReport("Splitting Boxes");
- tp.joinAll();
-
- totalEventsInTasks = 0;
- }
- } // for each box
-
- // Run any final tasks
- tp.joinAll();
-
- // Final splitting
- g_log.debug() << "Final splitting of boxes. " << totalEventsInTasks << " events." << std::endl;
- outWS->splitAllIfNeeded(ts);
- tp.joinAll();
- g_log.information() << overallTime << " to do all the adding." << std::endl;
-
- // Finish things up
- this->finalizeOutput<MDE,nd>(outWS);
- }
-
-
-
-
-
-
-
-
-
-
-
-
-
//----------------------------------------------------------------------------------------------
/** Create the output workspace by cloning the first one
*
@@ -501,7 +492,7 @@ namespace MDAlgorithms
if (!events.empty())
{
// Add all the events from the same box
- outBox->addEvents( events );
+ outBox->addEventsUnsafe( events );
events.clear();
std::vector<MDE>().swap(events); // really free the data
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/IMDBox.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/IMDBox.h
index 51d6071f9737fd949860ab7eb8a2a7ae7454b050..2fcd5f4f2c8ff9efdf59c96052c7c9c9321ea02c 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/IMDBox.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/IMDBox.h
@@ -174,17 +174,16 @@ namespace MDEvents
/// Add a single event
virtual void addEvent(const MDE & point) = 0;
- /** Add several events from a vector
- * @param events :: vector of MDEvents to add (all of it)
- * @return the number of events that were rejected (because of being out of bounds)
- */
- virtual size_t addEvents(const std::vector<MDE> & events)
- {
- return addEvents(events, 0, events.size());
- }
+ /// Add a single event, with no mutex locking
+ virtual void addEventUnsafe(const MDE & point) = 0;
/// Add several events, within a given range
- virtual size_t addEvents(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at);
+ virtual size_t addEventsPart(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at);
+ size_t addEvents(const std::vector<MDE> & events);
+
+ /// Add several events, within a given range, with no bounds checking
+ virtual size_t addEventsPartUnsafe(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at);
+ size_t addEventsUnsafe(const std::vector<MDE> & events);
/** Perform centerpoint binning of events
* @param bin :: MDBin object giving the limits of events to accept.
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h
index ba1ff1b5706151089f426aa98d93e3bb65ffe7c4..7e93ff9fd50e5b05c89aaf635ee7a54d21f192e3 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDBox.h
@@ -162,12 +162,11 @@ namespace MDEvents
void addEvent(const MDE & point);
- size_t addEvents(const std::vector<MDE> & events)
- {
- return this->addEvents(events, 0, events.size());
- }
+ void addEventUnsafe(const MDE & point);
- size_t addEvents(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at);
+ size_t addEventsPart(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at);
+
+ size_t addEventsPartUnsafe(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at);
void centerpointBin(MDBin<MDE,nd> & bin, bool * fullyContained) const;
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEvent.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEvent.h
index 28c462530dff516b32fc159b27db49d7e1d136a2..514b3e77f4a37e053647ecf4e9d611b2d5090ad0 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEvent.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDEvent.h
@@ -310,7 +310,12 @@ namespace MDEvents
coord_t * data = new coord_t[dataSize];
#ifdef COORDT_IS_FLOAT
- if (file->getInfo().type == ::NeXus::FLOAT64)
+ // C-style call is much faster than the C++ call.
+ int dims[NX_MAXRANK];
+ int type = ::NeXus::FLOAT32;
+ int rank = 0;
+ NXgetinfo(file->getHandle(), &rank, dims, &type);
+ if (type == ::NeXus::FLOAT64)
{
// Handle old files that are recorded in DOUBLEs to load as FLOATS
double * dblData = new double[dataSize];
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDGridBox.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDGridBox.h
index 46d885d6e5c2a08aa4448c47d65a4013e2f1669d..2a9af713b78a718c5694433c2bd0b093b2c1d77d 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDGridBox.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDGridBox.h
@@ -78,6 +78,8 @@ namespace MDEvents
void addEvent(const MDE & point);
+ void addEventUnsafe(const MDE & point);
+
void centerpointBin(MDBin<MDE,nd> & bin, bool * fullyContained) const;
void generalBin(MDBin<MDE,nd> & /*bin*/, Mantid::Geometry::MDImplicitFunction & /*function*/) const {};
@@ -192,7 +194,7 @@ namespace MDEvents
/// Add the events in the MDGridBox.
void run()
{
- box->addEvents(events, start_at, stop_at);
+ box->addEventsPart(events, start_at, stop_at);
if (prog)
{
std::ostringstream out;
diff --git a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDLeanEvent.h b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDLeanEvent.h
index 25c8f5276cea44628c500ad46fb75f0f4fd43a4b..f967ef0daa04b6be2728c6e9c4e10c2815804db9 100644
--- a/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDLeanEvent.h
+++ b/Code/Mantid/Framework/MDEvents/inc/MantidMDEvents/MDLeanEvent.h
@@ -7,6 +7,7 @@
#include "MantidGeometry/MDGeometry/MDTypes.h"
#include <numeric>
#include <cmath>
+#include <napi.h>
namespace Mantid
{
@@ -411,7 +412,12 @@ namespace MDEvents
coord_t * data = new coord_t[dataSize];
#ifdef COORDT_IS_FLOAT
- if (file->getInfo().type == ::NeXus::FLOAT64)
+ // C-style call is much faster than the C++ call.
+ int dims[NX_MAXRANK];
+ int type = ::NeXus::FLOAT32;
+ int rank = 0;
+ NXgetinfo(file->getHandle(), &rank, dims, &type);
+ if (type == ::NeXus::FLOAT64)
{
// Handle old files that are recorded in DOUBLEs to load as FLOATS
double * dblData = new double[dataSize];
diff --git a/Code/Mantid/Framework/MDEvents/src/IMDBox.cpp b/Code/Mantid/Framework/MDEvents/src/IMDBox.cpp
index ccc7332c7baeff2cda14c04dd83b98aec8babb97..078aa75d9c56b770d795f80cc832316689de5d08 100644
--- a/Code/Mantid/Framework/MDEvents/src/IMDBox.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/IMDBox.cpp
@@ -93,7 +93,7 @@ namespace MDEvents
* @return the number of events that were rejected (because of being out of bounds)
*/
TMDE(
- size_t IMDBox)::addEvents(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at)
+ size_t IMDBox)::addEventsPart(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at)
{
size_t numBad = 0;
// --- Go event by event and add them ----
@@ -124,6 +124,63 @@ namespace MDEvents
return numBad;
}
+ //-----------------------------------------------------------------------------------------------
+ /** Add several events, starting and stopping at particular point in a vector.
+ * This is the fastest way to add many events because:
+ * - Bounds checking is NOT performed.
+ * - This call is NOT thread-safe (no locking is made while adding).
+ *
+ * NOTE: You must call refreshCache() after you are done, to calculate the
+ * nPoints, signal and error.
+ *
+ * @param events :: vector of events to be copied.
+ * @param start_at :: begin at this index in the array
+ * @param stop_at :: stop at this index in the array
+ * @return 0 (since no events were rejected)
+ */
+ TMDE(
+ size_t IMDBox)::addEventsPartUnsafe(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at)
+ {
+ // --- Go event by event and add them ----
+ typename std::vector<MDE>::const_iterator it = events.begin() + start_at;
+ typename std::vector<MDE>::const_iterator it_end = events.begin() + stop_at;
+ for (; it != it_end; ++it)
+ {
+ //Check out-of-bounds-ness
+ // Event was in bounds; add it
+ addEventUnsafe(*it);
+ }
+
+ return 0;
+ }
+
+ //---------------------------------------------------------------------------------------------------
+ /** Add all of the events contained in a vector, with:
+ * - No bounds checking.
+ * - No thread-safety.
+ *
+ * @param events :: Vector of MDEvent
+ */
+ TMDE(
+ size_t IMDBox)::addEventsUnsafe(const std::vector<MDE> & events)
+ {
+ return this->addEventsPartUnsafe(events, 0, events.size());
+ }
+
+ //---------------------------------------------------------------------------------------------------
+ /** Add all of the events contained in a vector, with:
+ * - Bounds checking.
+ * - Thread-safety.
+ *
+ * @param events :: Vector of MDEvent
+ */
+ TMDE(
+ size_t IMDBox)::addEvents(const std::vector<MDE> & events)
+ {
+ return this->addEventsPart(events, 0, events.size());
+ }
+
+
//---------------------------------------------------------------------------------------------------
/** Transform the dimensions contained in this box
* x' = x*scaling + offset
diff --git a/Code/Mantid/Framework/MDEvents/src/MDBox.cpp b/Code/Mantid/Framework/MDEvents/src/MDBox.cpp
index ebf0caf0e70ec28621d152b6d03fa6c39d510b2c..1359dda95230646572cae70684571213d4ecfe89 100644
--- a/Code/Mantid/Framework/MDEvents/src/MDBox.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/MDBox.cpp
@@ -464,7 +464,7 @@ namespace MDEvents
//-----------------------------------------------------------------------------------------------
/** Add a MDLeanEvent to the box.
- * @param event :: reference to a MDLeanEvent to add.
+ * @param event :: reference to a MDEvent to add.
* */
TMDE(
void MDBox)::addEvent( const MDE & event)
@@ -491,6 +491,33 @@ namespace MDEvents
dataMutex.unlock();
}
+ //-----------------------------------------------------------------------------------------------
+ /** Add a MDLeanEvent to the box, in a NON-THREAD-SAFE manner.
+ * No lock is performed. This is only safe if no 2 threads will
+ * try to add to the same box at the same time.
+ *
+ * @param event :: reference to a MDEvent to add.
+ * */
+ TMDE(
+ void MDBox)::addEventUnsafe( const MDE & event)
+ {
+ this->data.push_back(event);
+ this->m_dataAdded = true;
+
+#ifdef MDBOX_TRACK_SIGNAL_WHEN_ADDING
+ // Keep the running total of signal and error
+ double signal = event.getSignal();
+ this->m_signal += signal;
+ this->m_errorSquared += event.getErrorSquared();
+#endif
+
+#ifdef MDBOX_TRACKCENTROID_WHENADDING
+ // Running total of the centroid
+ for (size_t d=0; d<nd; d++)
+ this->m_centroid[d] += event.getCenter(d) * signal;
+#endif
+ }
+
//-----------------------------------------------------------------------------------------------
/** Add several events. No bounds checking is made!
*
@@ -500,7 +527,7 @@ namespace MDEvents
* @return the number of events that were rejected (because of being out of bounds)
*/
TMDE(
- size_t MDBox)::addEvents(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at)
+ size_t MDBox)::addEventsPart(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at)
{
dataMutex.lock();
typename std::vector<MDE>::const_iterator start = events.begin()+start_at;
@@ -531,6 +558,24 @@ namespace MDEvents
return 0;
}
+
+ //-----------------------------------------------------------------------------------------------
+ /** Add several events, within a given range, with no bounds checking,
+ * and not in a thread-safe way
+ *
+ * @param events :: vector of events to be copied.
+ * @param start_at :: index to start at in vector
+ * @param stop_at :: index to stop at in vector (exclusive)
+ * @return the number of events that were rejected (because of being out of bounds)
+ */
+ TMDE(
+ size_t MDBox)::addEventsPartUnsafe(const std::vector<MDE> & events, const size_t start_at, const size_t stop_at)
+ {
+ // The regular MDBox is just as safe/unsafe
+ return this->addEventsPart(events, start_at, stop_at);
+ }
+
+
//-----------------------------------------------------------------------------------------------
/** Perform centerpoint binning of events.
* @param bin :: MDBin object giving the limits of events to accept.
diff --git a/Code/Mantid/Framework/MDEvents/src/MDGridBox.cpp b/Code/Mantid/Framework/MDEvents/src/MDGridBox.cpp
index 0df3226e5ec673b640657467c7389af3a4d80b7d..00be1c18f49fc32e250a53cb360e6730b69824d3 100644
--- a/Code/Mantid/Framework/MDEvents/src/MDGridBox.cpp
+++ b/Code/Mantid/Framework/MDEvents/src/MDGridBox.cpp
@@ -867,12 +867,10 @@ namespace MDEvents
TMDE(
inline void MDGridBox)::addEvent( const MDE & event)
{
-// std::cout << "\n nd " << nd << "; boxSize[d] " << boxSize[0] << "; min " << this->extents[0].min << "." << std::endl;
size_t index = 0;
for (size_t d=0; d<nd; d++)
{
coord_t x = event.getCenter(d);
-// std::cout << x << ":" << ((x - this->extents[d].min) / boxSize[d]) << ",";
int i = int((x - this->extents[d].min) / boxSize[d]);
// NOTE: No bounds checking is done (for performance).
//if (i < 0 || i >= int(split[d])) return;
@@ -884,11 +882,39 @@ namespace MDEvents
// Add it to the contained box
if (index < numBoxes) // avoid segfaults for floating point round-off errors.
boxes[index]->addEvent(event);
- else
+ }
+
+ //-----------------------------------------------------------------------------------------------
+ /** Add a single MDLeanEvent to the grid box. If the boxes
+ * contained within are also gridded, this will recursively push the event
+ * down to the deepest level.
+ *
+ * Warning! No bounds checking is done (for performance). It must
+ * be known that the event is within the bounds of the grid box before adding.
+ *
+ * Warning! Call is NOT thread-safe. Only 1 thread should be writing to this
+ * box (or any child boxes) at a time
+ *
+ * Note! nPoints, signal and error must be re-calculated using refreshCache()
+ * after all events have been added.
+ *
+ * @param event :: reference to a MDEvent to add.
+ * */
+ TMDE(
+ inline void MDGridBox)::addEventUnsafe(const MDE & event)
+ {
+ size_t index = 0;
+ for (size_t d=0; d<nd; d++)
{
- //std::cout << "\nEvent at " << event.getCenter(0) << " is skipped because index is " << index << "\n";
+ coord_t x = event.getCenter(d);
+ int i = int((x - this->extents[d].min) / boxSize[d]);
+ // Accumulate the index
+ index += (i * splitCumul[d]);
}
+ // Add it to the contained box
+ if (index < numBoxes) // avoid segfaults for floating point round-off errors.
+ boxes[index]->addEventUnsafe(event);
}
diff --git a/Code/Mantid/Framework/MDEvents/test/IMDBoxTest.h b/Code/Mantid/Framework/MDEvents/test/IMDBoxTest.h
index ab969fee4a2729c48c9a13d3fe8c054979c163c5..248aceda5e50118a5fc2c1b72ab8e0c2d6f97cf3 100644
--- a/Code/Mantid/Framework/MDEvents/test/IMDBoxTest.h
+++ b/Code/Mantid/Framework/MDEvents/test/IMDBoxTest.h
@@ -68,6 +68,10 @@ public:
virtual void addEvent(const MDE & /*point*/)
{}
+ /// Add a single event
+ virtual void addEventUnsafe(const MDE & /*point*/)
+ {}
+
/** Perform centerpoint binning of events
* @param bin :: MDBin object giving the limits of events to accept.
*/
diff --git a/Code/Mantid/Framework/MDEvents/test/MDBoxTest.h b/Code/Mantid/Framework/MDEvents/test/MDBoxTest.h
index caa2b18bd32602b93291318ff60a5cc533b89a52..edfee59db607c422d8920c439c627267f375869d 100644
--- a/Code/Mantid/Framework/MDEvents/test/MDBoxTest.h
+++ b/Code/Mantid/Framework/MDEvents/test/MDBoxTest.h
@@ -108,6 +108,22 @@ public:
TS_ASSERT_DELTA( b.getSignal(), 1.2*1, 1e-5);
TS_ASSERT_DELTA( b.getErrorSquared(), 3.4*1, 1e-5);
}
+ /** Adding events in unsafe way also works */
+ void test_addEventUnsafe()
+ {
+ MDBox<MDLeanEvent<2>,2> b;
+ MDLeanEvent<2> ev(1.2, 3.4);
+ ev.setCenter(0, 2.0);
+ ev.setCenter(1, 3.0);
+ b.addEventUnsafe(ev);
+ TS_ASSERT_EQUALS( b.getNPoints(), 1)
+#ifndef MDBOX_TRACK_SIGNAL_WHEN_ADDING
+ b.refreshCache();
+#endif
+ // Did it keep a running total of the signal and error?
+ TS_ASSERT_DELTA( b.getSignal(), 1.2*1, 1e-5);
+ TS_ASSERT_DELTA( b.getErrorSquared(), 3.4*1, 1e-5);
+ }
/** Add a vector of events */
@@ -143,7 +159,7 @@ public:
for (size_t i=0; i<10; i++)
vec.push_back(ev);
- b.addEvents(vec, 5, 8);
+ b.addEventsPart(vec, 5, 8);
#ifndef MDBOX_TRACK_SIGNAL_WHEN_ADDING
b.refreshCache();
#endif
diff --git a/Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h b/Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h
index 09ba88decd6d584125595efc2236279573c97cde..ca15672316665a583e5fc6f2bcbafae9f850cf2f 100644
--- a/Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h
+++ b/Code/Mantid/Framework/MDEvents/test/MDGridBoxTest.h
@@ -773,7 +773,7 @@ public:
}
size_t numbad = 0;
- TS_ASSERT_THROWS_NOTHING( numbad = b->addEvents( events, 50, 60 ); );
+ TS_ASSERT_THROWS_NOTHING( numbad = b->addEventsPart( events, 50, 60 ); );
// Get the right totals again
b->refreshCache(NULL);
TS_ASSERT_EQUALS( numbad, 0);
diff --git a/Code/Mantid/Framework/NexusCPP/inc/MantidNexusCPP/NeXusFile.hpp b/Code/Mantid/Framework/NexusCPP/inc/MantidNexusCPP/NeXusFile.hpp
index 9c7cfe6d29d632f6ab18b3f8cd3d128d65a2d3d6..400d9e639e731ab476ce122f750f42e297ef9453 100644
--- a/Code/Mantid/Framework/NexusCPP/inc/MantidNexusCPP/NeXusFile.hpp
+++ b/Code/Mantid/Framework/NexusCPP/inc/MantidNexusCPP/NeXusFile.hpp
@@ -175,6 +175,12 @@ namespace NeXus {
template<typename NumT>
void free(NumT*& data);
+ /** Return the C-API handle to the open file */
+ NXhandle getHandle()
+ {
+ return m_file_id;
+ }
+
/**
* Create a new group.
*