Re #9423. Added new domain class.

Code/Mantid/Framework/API/inc/MantidAPI/FunctionDomain1D.h

@@ -110,6 +110,25 @@ class MANTID_API_DLL FunctionDomain1DView: public FunctionDomain1D
   FunctionDomain1DView& operator=(const FunctionDomain1DView&);
 };
 
+/**
+ * Specialization of FunctionDomain1DVector for spectra of MatrixWorkspaces.
+ * The domain holds the workspace index allowing functions to use spectra-specific
+ * information.
+ */
+class MANTID_API_DLL FunctionDomain1DSpectrum: public FunctionDomain1DVector
+{
+public:
+  /// Constructor.
+  FunctionDomain1DSpectrum(size_t wi, const std::vector<double>& xvalues);
+  /// Constructor.
+  FunctionDomain1DSpectrum(size_t wi, std::vector<double>::const_iterator from, std::vector<double>::const_iterator to);
+  /// Get the workspace index
+  size_t getWorkspaceIndex() const {return m_workspaceIndex;}
+private:
+  /// The workspace index
+  size_t m_workspaceIndex;
+};
+
 /// typedef for a shared pointer to a FunctionDomain1D
 typedef boost::shared_ptr<FunctionDomain1D> FunctionDomain1D_sptr;
 /// typedef for a shared pointer to a const FunctionDomain1D

Code/Mantid/Framework/API/src/FunctionDomain1D.cpp

@@ -107,5 +107,26 @@ FunctionDomain1DVector& FunctionDomain1DVector::operator=(const FunctionDomain1D
   return *this;
 }
 
+/**
+  * Create a domain from a vector.
+  * @param wi :: The workspace index of a spectrum the xvalues come from.
+  * @param xvalues :: Vector with function arguments to be copied from.
+  */
+FunctionDomain1DSpectrum::FunctionDomain1DSpectrum(size_t wi, const std::vector<double>& xvalues):
+FunctionDomain1DVector(xvalues), m_workspaceIndex(wi)
+{
+}
+
+/**
+  * Create a domain from a part of a vector.
+  * @param wi :: The workspace index of a spectrum the x-values come from.
+  * @param from :: Iterator to start copying values from.
+  * @param to :: Iterator to the end of the data.
+  */
+FunctionDomain1DSpectrum::FunctionDomain1DSpectrum(size_t wi, std::vector<double>::const_iterator from, std::vector<double>::const_iterator to):
+FunctionDomain1DVector(from,to), m_workspaceIndex(wi)
+{
+}
+
 } // namespace API
 } // namespace Mantid

Code/Mantid/Framework/API/test/FunctionDomainTest.h

@@ -2,6 +2,8 @@
 #define FUNCTIONDOMAINTEST_H_
 
 #include "MantidAPI/FunctionDomain1D.h"
+#include "MantidAPI/MatrixWorkspace.h"
+#include "MantidAPI/WorkspaceFactory.h"
 
 #include <cxxtest/TestSuite.h>
 #include <iostream>
@@ -13,22 +15,79 @@ class FunctionDomainTest : public CxxTest::TestSuite
 {
 public:
 
-  void testDomain1D()
+  static FunctionDomainTest *createSuite() { return new FunctionDomainTest(); }
+  static void destroySuite( FunctionDomainTest *suite ) { delete suite; }
+
+  FunctionDomainTest()
   {
-    std::vector<double> x(10);
-    for(size_t i = 0; i < x.size(); ++i)
+    data.resize(10);
+    for(size_t i = 0; i < data.size(); ++i)
     {
-      x[i] = 1.0 + 0.1 * double(i);
+      data[i] = 1.0 + 0.1 * double(i);
     }
-    FunctionDomain1DVector domain(x);
-    TS_ASSERT_EQUALS(domain.size(), x.size());
-    for(size_t i = 0; i < x.size(); ++i)
+  }
+
+  void testDomain1D()
+  {
+    FunctionDomain1DVector domain(data);
+    checkDomainVector( domain );
+
+    FunctionDomain1DVector domainCopy( domain );
+    checkDomainVector( domainCopy );
+
+    FunctionDomain1DVector domainCopy1( 1.0 );
+    domainCopy1 = domain;
+    checkDomainVector( domainCopy1 );
+  }
+
+  void testDomain1D_part()
+  {
+    FunctionDomain1DVector domain( data.begin() + 2, data.begin() + 8 );
+    checkDomainVector( domain, 2, 8 );
+
+    FunctionDomain1DVector domainCopy( domain );
+    checkDomainVector( domainCopy, 2, 8 );
+
+    FunctionDomain1DVector domainCopy1( 1.0 );
+    domainCopy1 = domain;
+    checkDomainVector( domainCopy1, 2, 8 );
+  }
+
+  void test_Domain1DView()
+  {
+    FunctionDomain1DView domain( data.data(), data.size() );
+    checkDomainVector( domain );
+  }
+
+  void test_Domain1DSpectra()
+  {
+    FunctionDomain1DSpectrum domain( 12, data );
+    checkDomainVector( domain );
+    TS_ASSERT_EQUALS( domain.getWorkspaceIndex(), 12 );
+  }
+
+  void test_Domain1DSpectra_part()
+  {
+    FunctionDomain1DSpectrum domain( 14, data.begin() + 3, data.begin() + 7 );
+    checkDomainVector( domain, 3, 7 );
+    TS_ASSERT_EQUALS( domain.getWorkspaceIndex(), 14 );
+  }
+
+private:
+
+  void checkDomainVector(const FunctionDomain1D& domain, size_t start = 0, size_t end = 0)
+  {
+    if ( end == 0 ) end = data.size();
+    TS_ASSERT_EQUALS( domain.size(), end - start );
+    for(size_t i = start; i < end; ++i)
     {
-      TS_ASSERT_EQUALS(domain[i], x[i]);
-      TS_ASSERT_EQUALS(domain[i], *domain.getPointerAt(i));
+      TS_ASSERT_EQUALS(domain[i - start], data[i]);
+      TS_ASSERT_EQUALS(domain[i - start], *domain.getPointerAt(i - start));
     }
   }
 
+  std::vector<double> data;
+
 };
 
 #endif /*FUNCTIONDOMAINTEST_H_*/

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

@@ -214,12 +214,12 @@ namespace
       {
         x[i] = (*it + *(it+1)) / 2;
       }
-      domain.reset(new API::FunctionDomain1DVector(x));
+      domain.reset(new API::FunctionDomain1DSpectrum(m_workspaceIndex, x));
       x.clear();
     }
     else
     {
-      domain.reset(new API::FunctionDomain1DVector(from,to));
+      domain.reset(new API::FunctionDomain1DSpectrum(m_workspaceIndex,from,to));
     }
 
     if (!values)