changes from comments

Author: rboston628

Framework/DataHandling/src/LoadBankFromDiskTask.cpp

@@ -97,7 +97,7 @@ void LoadBankFromDiskTask::loadPulseTimes(Nexus::File &file) {
   }
 
   // Not found? Need to load and add it
-  thisBankPulseTimes = std::make_shared<BankPulseTimes>(boost::ref(file), m_framePeriodNumbers);
+  thisBankPulseTimes = std::make_shared<BankPulseTimes>(file, m_framePeriodNumbers);
   m_loader.m_bankPulseTimes.emplace_back(thisBankPulseTimes);
 }
 
@@ -190,7 +190,7 @@ std::unique_ptr<std::vector<uint32_t>> LoadBankFromDiskTask::loadEventId(Nexus::
 
     // determine the range of pixel ids
     {
-      const auto [min_id, max_id] = Mantid::Kernel::parallel_minmax<uint32_t>(event_id.get(), 1);
+      const auto [min_id, max_id] = Mantid::Kernel::parallel_minmax<uint32_t>(event_id.get());
       m_min_id = min_id;
       m_max_id = max_id;
     }
@@ -470,14 +470,13 @@ void LoadBankFromDiskTask::run() {
     // this method is for unweighted events that the user wants compressed on load
 
     // TODO should this be created elsewhere?
-    const auto [tof_min, tof_max] =
-        std::minmax_element(event_time_of_flight_shrd->cbegin(), event_time_of_flight_shrd->cend());
+    const auto [tof_min, tof_max] = Mantid::Kernel::parallel_minmax(event_time_of_flight.get());
 
     const bool log_compression = (m_loader.alg->compressTolerance < 0);
 
     // reduce tof range if filtering was requested
-    auto tof_min_fixed = *tof_min;
-    auto tof_max_fixed = *tof_max;
+    auto tof_min_fixed = tof_min;
+    auto tof_max_fixed = tof_max;
     if (m_loader.alg->filter_tof_range) {
       if (m_loader.alg->filter_tof_max != EMPTY_DBL())
         tof_max_fixed = std::min<float>(tof_max_fixed, static_cast<float>(m_loader.alg->filter_tof_max));

Framework/DataHandling/src/ProcessBankData.cpp

@@ -235,6 +235,11 @@ void ProcessBankData::run() {
   if (alg->getLogger().isDebug())
     alg->getLogger().debug() << "Time to ProcessBankData " << entry_name << " " << timer << "\n";
 #endif
+  event_detid.reset();
+  event_time_of_flight.reset();
+  event_index.reset();
+  event_weight.reset();
+  thisBankPulseTimes.reset();
 } // END-OF-RUN()
 
 /**

Framework/Kernel/inc/MantidKernel/ParallelMinMax.h

@@ -31,8 +31,8 @@ template <typename T> class MANTID_KERNEL_DLL MinMaxFinder {
 
 /** parallel_minmax
  * @param vec -- a pointer to a vector of values of type T, to search for a min and max
- * @param grainsize -- the grainsize for use in tbb::parallel_reduce.  Default = 2
+ * @param grainsize -- the grainsize for use in tbb::parallel_reduce.  Default = 1000
  * @return a std::pair<T,T> with the min (first) and max (second)
  */
-template <typename T> std::pair<T, T> parallel_minmax(std::vector<T> const *const vec, size_t const grainsize = 2);
+template <typename T> std::pair<T, T> parallel_minmax(std::vector<T> const *const vec, size_t const grainsize = 1000);
 } // namespace Mantid::Kernel

Framework/Kernel/inc/MantidKernel/ThreadScheduler.h

@@ -57,10 +57,7 @@ class MANTID_KERNEL_DLL ThreadScheduler {
    * @param task :: the Task that was completed.
    * @param threadnum :: Thread ID that launched the task
    */
-  virtual void finished(Task *task, size_t threadnum) {
-    UNUSED_ARG(task);
-    UNUSED_ARG(threadnum);
-  }
+  virtual void finished(Task *, size_t) {}
 
   //-----------------------------------------------------------------------------------
   /** Signal to the scheduler that a task is complete. The

Framework/Kernel/src/ParallelMinMax.cpp

@@ -34,6 +34,7 @@ template <typename T> std::pair<T, T> parallel_minmax(std::vector<T> const *cons
 #define EXPORTPARALLELMINMAX(type)                                                                                     \
   template std::pair<type, type> MANTID_KERNEL_DLL parallel_minmax(std::vector<type> const *const, size_t);
 
+EXPORTPARALLELMINMAX(float)
 EXPORTPARALLELMINMAX(double)
 EXPORTPARALLELMINMAX(uint32_t)