Fixes SplineSmoothing bugs and executes the Alg faster Refs #13335

Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/SplineSmoothing.h

@@ -61,7 +61,7 @@ private:
   void exec();
 
   /// smooth a single spectrum of the workspace
-  void smoothSpectrum(int index);
+  void smoothSpectrum(int index, int maxBreaks);
 
   /// calculate derivatives for a single spectrum
   void calculateSpectrumDerivatives(int index, int order);
@@ -81,7 +81,7 @@ private:
 
   /// choose points to define a spline and smooth the data
   void selectSmoothingPoints(API::MatrixWorkspace_const_sptr inputWorkspace,
-                             size_t row);
+                             size_t row, int maxBreaks);
 
   /// calculate the spline based on the smoothing points chosen
   void calculateSmoothing(API::MatrixWorkspace_const_sptr inputWorkspace,

Code/Mantid/Framework/CurveFitting/src/SplineSmoothing.cpp

@@ -69,6 +69,11 @@ void SplineSmoothing::init() {
   errorSizeValidator->setLower(0.0);
   declareProperty("Error", 0.05, errorSizeValidator,
                   "The amount of error we wish to tolerate in smoothing");
+
+  auto numOfBreaks = boost::make_shared<BoundedValidator<int>>();
+  numOfBreaks->setLower(M_START_SMOOTH_POINTS);
+  declareProperty("MaxNumberOfBreaks", 0, numOfBreaks,
+                  "To set the positions of the break-points");
 }
 
 //----------------------------------------------------------------------------------------------
@@ -80,6 +85,9 @@ void SplineSmoothing::exec() {
   int histNo = static_cast<int>(m_inputWorkspace->getNumberHistograms());
   int order = static_cast<int>(getProperty("DerivOrder"));
 
+  // retrieving number of breaks
+  int maxBreaks = static_cast<int>(getProperty("MaxNumberOfBreaks"));
+
   m_inputWorkspacePointData = convertBinnedData(m_inputWorkspace);
   m_outputWorkspace = setupOutputWorkspace(m_inputWorkspacePointData, histNo);
 
@@ -90,7 +98,7 @@ void SplineSmoothing::exec() {
 
   Progress pgress(this, 0.0, 1.0, histNo);
   for (int i = 0; i < histNo; ++i) {
-    smoothSpectrum(i);
+    smoothSpectrum(i, maxBreaks);
     calculateSpectrumDerivatives(i, order);
     pgress.report();
   }
@@ -106,12 +114,12 @@ void SplineSmoothing::exec() {
  *
  * @param index :: index of the spectrum to smooth
  */
-void SplineSmoothing::smoothSpectrum(int index) {
+void SplineSmoothing::smoothSpectrum(int index, int maxBreaks) {
   m_cspline = boost::make_shared<BSpline>();
   m_cspline->setAttributeValue("Uniform", false);
 
   // choose some smoothing points from input workspace
-  selectSmoothingPoints(m_inputWorkspacePointData, index);
+  selectSmoothingPoints(m_inputWorkspacePointData, index, maxBreaks);
   performAdditionalFitting(m_inputWorkspacePointData, index);
 
   // compare the data set against our spline
@@ -204,10 +212,9 @@ SplineSmoothing::convertBinnedData(MatrixWorkspace_sptr workspace) {
  * @param outputWorkspace :: The output workspace
  * @param row :: The row of spectra to use
  */
-void
-SplineSmoothing::calculateSmoothing(MatrixWorkspace_const_sptr inputWorkspace,
-                                    MatrixWorkspace_sptr outputWorkspace,
-                                    size_t row) const {
+void SplineSmoothing::calculateSmoothing(
+    MatrixWorkspace_const_sptr inputWorkspace,
+    MatrixWorkspace_sptr outputWorkspace, size_t row) const {
   // define the spline's parameters
   const auto &xIn = inputWorkspace->readX(row);
   size_t nData = xIn.size();
@@ -302,29 +309,41 @@ void SplineSmoothing::addSmoothingPoints(const std::set<int> &points,
  * @param row :: The row of spectra to use
  */
 void SplineSmoothing::selectSmoothingPoints(
-    MatrixWorkspace_const_sptr inputWorkspace, size_t row) {
+    MatrixWorkspace_const_sptr inputWorkspace, size_t row, int maxBreaks) {
   std::set<int> smoothPts;
   const auto &xs = inputWorkspace->readX(row);
   const auto &ys = inputWorkspace->readY(row);
 
   int xSize = static_cast<int>(xs.size());
-
+  // if retrienved value is default zero
+  if (maxBreaks == 0) {
+    setProperty("MaxNumberOfBreaks", xs.size());
+    maxBreaks = static_cast<int>(getProperty("MaxNumberOfBreaks"));
+  }
   // number of points to start with
-  int numSmoothPts(M_START_SMOOTH_POINTS);
+  int numSmoothPts(maxBreaks);
 
   // evenly space initial points over data set
   int delta = xSize / numSmoothPts;
-  for (int i = 0; i < xSize; i += delta) {
+  
+  g_log.information() << "delta is: " << delta << std::endl;
+  
+  for (int i = 0; i < xSize; i+=delta) {
     smoothPts.insert(i);
   }
   smoothPts.insert(xSize - 1);
+  
+  g_log.information() << "smoothPtrs has: " << smoothPts.size() << " elements"
+                      << std::endl;
 
   bool resmooth(true);
   while (resmooth) {
     // if we're using all points then we can't do anything more.
-    if (smoothPts.size() >= xs.size() - 1)
+    if (smoothPts.size() > maxBreaks + 2)
       break;
 
+    g_log.information() << "iteration inside resmooth " << std::endl;
+
     addSmoothingPoints(smoothPts, xs.data(), ys.data());
     resmooth = false;