diff --git a/Code/Mantid/Framework/API/inc/MantidAPI/WorkspaceOpOverloads.h b/Code/Mantid/Framework/API/inc/MantidAPI/WorkspaceOpOverloads.h
index c9df7c2dd33fa5fe1f75329cf8549fc0fc4323fb..b5ddd06e781b69a97e173706b7c73f63fa2e5e9a 100644
--- a/Code/Mantid/Framework/API/inc/MantidAPI/WorkspaceOpOverloads.h
+++ b/Code/Mantid/Framework/API/inc/MantidAPI/WorkspaceOpOverloads.h
@@ -15,7 +15,7 @@ namespace OperatorOverloads
DLLExport MatrixWorkspace_sptr
executeBinaryOperation(const std::string & algorithmName, const MatrixWorkspace_sptr lhs,
const MatrixWorkspace_sptr rhs, bool lhsAsOutput = false,
- bool child = true, const std::string & name = "");
+ bool child = true, const std::string & name = "", bool rethrow = false);
}
// Workspace operator overloads
diff --git a/Code/Mantid/Framework/API/src/WorkspaceOpOverloads.cpp b/Code/Mantid/Framework/API/src/WorkspaceOpOverloads.cpp
index 6c0e10b5efaa917652976d60ade33f102be6de6e..09529b3af9d3e760278565f68b90828bcec2fab2 100644
--- a/Code/Mantid/Framework/API/src/WorkspaceOpOverloads.cpp
+++ b/Code/Mantid/Framework/API/src/WorkspaceOpOverloads.cpp
@@ -25,12 +25,14 @@ namespace OperatorOverloads
* @param lhsAsOutput If true, indicates that the lhs input is the same workspace as the output one
* @param child If true the algorithm is run as a child
* @param name If child is true and this is not an inplace operation then this name is used as output
+ * @param A flag indicating whether to rethrow exceptions
* @returns The result in a workspace shared pointer
*/
- MatrixWorkspace_sptr executeBinaryOperation(const std::string & algorithmName, const MatrixWorkspace_sptr lhs, const MatrixWorkspace_sptr rhs, bool lhsAsOutput, bool child, const std::string &name)
+ MatrixWorkspace_sptr executeBinaryOperation(const std::string & algorithmName, const MatrixWorkspace_sptr lhs, const MatrixWorkspace_sptr rhs, bool lhsAsOutput, bool child, const std::string &name, bool rethrow)
{
IAlgorithm_sptr alg = AlgorithmManager::Instance().createUnmanaged(algorithmName);
alg->setChild(child);
+ alg->setRethrows(rethrow);
alg->initialize();
if( child )
@@ -78,7 +80,8 @@ namespace OperatorOverloads
}
else
{
- throw std::runtime_error("Error while executing operation algorithm: algorithmName");
+ std::string message = "Error while executing operation: " + algorithmName;
+ throw std::runtime_error(message);
}
throw Kernel::Exception::NotFoundError("Required output workspace property not found on sub algorithm" ,"OutputWorkspace");
diff --git a/Code/Mantid/Framework/Algorithms/src/CommutativeBinaryOperation.cpp b/Code/Mantid/Framework/Algorithms/src/CommutativeBinaryOperation.cpp
index 623c7920631529409082bf247a319c5c49d5e769..4096358a4bacea66cfb5d34bf787d712608203f7 100644
--- a/Code/Mantid/Framework/Algorithms/src/CommutativeBinaryOperation.cpp
+++ b/Code/Mantid/Framework/Algorithms/src/CommutativeBinaryOperation.cpp
@@ -10,13 +10,21 @@ namespace Mantid
/** Performs a simple check to see if the sizes of two workspaces are compatible for a binary operation
* In order to be size compatible then the larger workspace
* must divide be the size of the smaller workspace leaving no remainder
- * @param rhs the first workspace to compare
- * @param lhs the second workspace to compare
+ * @param lhs the workspace treated as the lhs to compare
+ * @param rhs the workspace treated as the rhs to compare
* @retval true The two workspaces are size compatible
* @retval false The two workspaces are NOT size compatible
*/
- bool CommutativeBinaryOperation::checkSizeCompatibility(const API::MatrixWorkspace_const_sptr rhs,const API::MatrixWorkspace_const_sptr lhs) const
+ bool CommutativeBinaryOperation::checkSizeCompatibility(const API::MatrixWorkspace_const_sptr lhs,const API::MatrixWorkspace_const_sptr rhs) const
{
+ // Don't allow this for EventWorkspaces. See for instance Multiply::checkSizeCompatability
+ if( boost::dynamic_pointer_cast<const DataObjects::EventWorkspace>(lhs) ||
+ boost::dynamic_pointer_cast<const DataObjects::EventWorkspace>(rhs) )
+ {
+ //call the base routine
+ return BinaryOperation::checkSizeCompatibility(lhs,rhs);
+ }
+
//get the largest workspace
API::MatrixWorkspace_const_sptr wsLarger;
API::MatrixWorkspace_const_sptr wsSmaller;
diff --git a/Code/Mantid/Framework/Algorithms/src/Multiply.cpp b/Code/Mantid/Framework/Algorithms/src/Multiply.cpp
index 0ced0fdd572e86bd0d1dfdfeab9d9a3eb544153e..ec121b8724b5bfbd5f820b813a8d9af338be9eda 100644
--- a/Code/Mantid/Framework/Algorithms/src/Multiply.cpp
+++ b/Code/Mantid/Framework/Algorithms/src/Multiply.cpp
@@ -132,7 +132,7 @@ namespace Mantid
{
// either or both workspace are "other"
// Use the default behaviour
- BinaryOperation::checkRequirements();
+ CommutativeBinaryOperation::checkRequirements();
}
}
@@ -153,7 +153,7 @@ namespace Mantid
if (!m_keepEventWorkspace)
{
// Fallback on the default checks
- return BinaryOperation::checkSizeCompatibility(lhs, rhs);
+ return CommutativeBinaryOperation::checkSizeCompatibility(lhs, rhs);
}
else
{
diff --git a/Code/Mantid/Framework/Algorithms/src/Plus.cpp b/Code/Mantid/Framework/Algorithms/src/Plus.cpp
index 0fb3bb5171c8e0f11bd0ad9617e2e32f5b5f4c03..de2c81c8296e77f0f89287d8aad2ab607a3c729e 100644
--- a/Code/Mantid/Framework/Algorithms/src/Plus.cpp
+++ b/Code/Mantid/Framework/Algorithms/src/Plus.cpp
@@ -155,7 +155,7 @@ namespace Mantid
return false;
//Keep checking more generally.
- return BinaryOperation::checkCompatibility(lhs,rhs);
+ return CommutativeBinaryOperation::checkCompatibility(lhs,rhs);
}
diff --git a/Code/Mantid/Framework/Algorithms/test/CommutativeBinaryOperationTest.h b/Code/Mantid/Framework/Algorithms/test/CommutativeBinaryOperationTest.h
index a0dc94a6773f07d678f57340b7c12df147fa0bdb..0fb87269e5f96acb023ccbbe352ab5d587bc2d82 100644
--- a/Code/Mantid/Framework/Algorithms/test/CommutativeBinaryOperationTest.h
+++ b/Code/Mantid/Framework/Algorithms/test/CommutativeBinaryOperationTest.h
@@ -93,6 +93,7 @@ public:
MatrixWorkspace_sptr work_in4 = WorkspaceCreationHelper::Create2DWorkspace(5,5);
MatrixWorkspace_sptr work_in5 = WorkspaceCreationHelper::Create2DWorkspace(3,3);
MatrixWorkspace_sptr work_in6 = WorkspaceCreationHelper::Create2DWorkspace(1,100);
+ MatrixWorkspace_sptr work_in7 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(10.0);
MatrixWorkspace_sptr work_event1 = WorkspaceCreationHelper::CreateEventWorkspace(10,1);
MatrixWorkspace_sptr work_event2 = WorkspaceCreationHelper::CreateEventWorkspace(10,10);
CommutativeBinaryOpHelper helper;
@@ -101,11 +102,12 @@ public:
TS_ASSERT(!helper.checkSizeCompatibility(work_in1,work_in4));
TS_ASSERT(!helper.checkSizeCompatibility(work_in1,work_in5));
TS_ASSERT(!helper.checkSizeCompatibility(work_in1,work_in6));
+ TS_ASSERT(helper.checkSizeCompatibility(work_in1,work_in7));
+ TS_ASSERT(helper.checkSizeCompatibility(work_in7,work_in1));
TS_ASSERT(helper.checkSizeCompatibility(work_in1,work_event1));
TS_ASSERT(helper.checkSizeCompatibility(work_in1,work_event2));
}
-
void checkOutputWorkspace(MatrixWorkspace_sptr ws, MatrixWorkspace_sptr wsIn1,MatrixWorkspace_sptr wsIn2 ) const
{
int targetsize = (wsIn1->size()>wsIn2->size())?wsIn1->size():wsIn2->size();
diff --git a/Code/Mantid/Framework/Algorithms/test/MultiplyTest.h b/Code/Mantid/Framework/Algorithms/test/MultiplyTest.h
index 5d1f72ad0b4b2a39501ab52a738aed03e559353a..13519eb72b18e1ff911295feec81ecbca6bc8959 100644
--- a/Code/Mantid/Framework/Algorithms/test/MultiplyTest.h
+++ b/Code/Mantid/Framework/Algorithms/test/MultiplyTest.h
@@ -33,226 +33,229 @@ public:
DO_DIVIDE = false;
}
- void testInit()
- {
- Divide alg;
- TS_ASSERT_THROWS_NOTHING(alg.initialize());
- TS_ASSERT(alg.isInitialized());
- //Setting properties to input workspaces that don't exist throws
- TS_ASSERT_THROWS( alg.setPropertyValue("LHSWorkspace","test_in21"), std::invalid_argument );
- TS_ASSERT_THROWS( alg.setPropertyValue("RHSWorkspace","test_in22"), std::invalid_argument );
- TS_ASSERT_THROWS_NOTHING( alg.setPropertyValue("OutputWorkspace","test_out2") );
- }
-
-
- void testDivideWithMaskedSpectraProducesZeroes()
- {
- doDivideWithMaskedTest(false);
- }
-
- void testDivideWithMaskedSpectraProducesZeroesWhenReplacingInputWorkspace()
- {
- doDivideWithMaskedTest(true);
- }
-
- void testCompoundAssignment()
- {
- MatrixWorkspace_sptr a = WorkspaceCreationHelper::CreateWorkspaceSingleValue(3);
- const Workspace_const_sptr b = a;
- MatrixWorkspace_sptr c = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2);
- a /= 5;
- TS_ASSERT_EQUALS(a->readY(0)[0],0.6);
- TS_ASSERT_EQUALS(a,b);
- a /= c;
- TS_ASSERT_EQUALS(a->readY(0)[0],0.3);
- TS_ASSERT_EQUALS(a,b);
- }
-
-
- //========================================= 2D and 1D Workspaces ==================================
-
- void testExec_1D_1D()
- {
- int sizex = 10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
- performTest(work_in1,work_in2);
- }
-
- void testExec_2D_2D()
- {
- int sizex = 10,sizey=20;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
- performTest(work_in1,work_in2);
- }
-
- void testExec_2D_1D()
- {
- int sizex = 10,sizey=20;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
- performTest(work_in1,work_in2);
- }
-
- void testExec_1D_Rand2D()
- {
- int sizex = 10,sizey=20;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceRand(sizex);
- performTest(work_in1,work_in2);
- }
-
- void testExec_2D_1DVertical()
- {
- int sizex = 10,sizey=20;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace123(1,sizey);
- performTest(work_in1,work_in2);
- }
-
- void testExec_2D_2DSingleSpectrumBiggerSize_fails()
- {
- //In 2D workspaces, the X bins have to match
- int sizex = 10,sizey=10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(1,sizey*2);
- performTest_fails(work_in1, work_in2);
- }
-
- void testExec_2D_2DbyOperatorOverload()
- {
- int sizex = 10,sizey=20;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
- MatrixWorkspace_sptr work_out1;
- if (DO_DIVIDE)
- work_out1 = work_in1/work_in2;
- else
- work_out1 = work_in1*work_in2;
-
- checkData(work_in1, work_in2, work_out1);
- }
-
- void testExec_1D_SingleValue()
- {
- int sizex = 10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2.2);
- performTest(work_in1,work_in2);
- }
-
- void testExec_SingleValue_1D_fails()
- {
- int sizex = 10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2.2);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
- performTest_fails(work_in1,work_in2);
- }
-
- void testExec_2D_SingleValue()
- {
- int sizex = 5,sizey=300;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspaceBinned(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(4.455);
- performTest(work_in1,work_in2);
- }
-
- void testExec_SingleValue_2D_fails()
- {
- int sizex = 5,sizey=300;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(4.455);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspaceBinned(sizex,sizey);
- performTest_fails(work_in1,work_in2);
- }
-
- void testExec_2D_SingleValueNoError()
- {
- int sizex = 5,sizey=300;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspaceBinned(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValueWithError(5.0, 0.0);
- performTest(work_in1,work_in2);
- }
-
-
-
-
- //========================================= EventWorkspaces ==================================
-
- // Equivalent of 2D over 2D, really
- void testExec_2D_Event()
- {
- int sizex = 10,sizey=20;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace(sizex,sizey);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
- performTest(work_in1,work_in2, false);
- }
-
- void testExec_Event_2D()
- {
- int sizex = 10,sizey=10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace(sizex,sizey);
- if (DO_DIVIDE)
- performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
- else
- performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
- }
-
- void testExec_Event_2DSingleSpectrum()
- {
- int sizex = 10,sizey=10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace(1,sizey);
- if (DO_DIVIDE)
- performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
- else
- performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
- }
-
- void testExec_Event_2DSingleSpectrumBiggerSize()
- {
- //Unlike 2D workspaces, you can divide by a single spectrum with different X bins!
- int sizex = 10,sizey=10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace(1,sizey*2);
- if (DO_DIVIDE)
- performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
- else
- performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
- }
-
- void testExec_Event_SingleValue()
- {
- int sizex = 10,sizey=10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2.0);
- if (DO_DIVIDE)
- performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
- else
- performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
- }
-
- void testExec_Event_SingleValueNoError()
- {
- int sizex = 10,sizey=10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValueWithError(2.0, 0.0);
- performTest(work_in1,work_in2, true);
- }
-
- void testExec_Event_Event()
- {
- int sizex = 20,sizey=10;
- MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
- MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
- if (DO_DIVIDE)
- performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
- else
- performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
- }
-
- void testExec_SingleValue_Event_fails()
+ // void testInit()
+ // {
+ // Divide alg;
+ // TS_ASSERT_THROWS_NOTHING(alg.initialize());
+ // TS_ASSERT(alg.isInitialized());
+ // //Setting properties to input workspaces that don't exist throws
+ // TS_ASSERT_THROWS( alg.setPropertyValue("LHSWorkspace","test_in21"), std::invalid_argument );
+ // TS_ASSERT_THROWS( alg.setPropertyValue("RHSWorkspace","test_in22"), std::invalid_argument );
+ // TS_ASSERT_THROWS_NOTHING( alg.setPropertyValue("OutputWorkspace","test_out2") );
+ // }
+
+
+ // void testDivideWithMaskedSpectraProducesZeroes()
+ // {
+ // doDivideWithMaskedTest(false);
+ // }
+
+ // void testDivideWithMaskedSpectraProducesZeroesWhenReplacingInputWorkspace()
+ // {
+ // doDivideWithMaskedTest(true);
+ // }
+
+ // void testCompoundAssignment()
+ // {
+ // MatrixWorkspace_sptr a = WorkspaceCreationHelper::CreateWorkspaceSingleValue(3);
+ // const Workspace_const_sptr b = a;
+ // MatrixWorkspace_sptr c = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2);
+ // a /= 5;
+ // TS_ASSERT_EQUALS(a->readY(0)[0],0.6);
+ // TS_ASSERT_EQUALS(a,b);
+ // a /= c;
+ // TS_ASSERT_EQUALS(a->readY(0)[0],0.3);
+ // TS_ASSERT_EQUALS(a,b);
+ // }
+
+
+ // //========================================= 2D and 1D Workspaces ==================================
+
+ // void testExec_1D_1D()
+ // {
+ // int sizex = 10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+ // performTest(work_in1,work_in2);
+ // }
+
+ // void testExec_2D_2D()
+ // {
+ // int sizex = 10,sizey=20;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+ // performTest(work_in1,work_in2);
+ // }
+
+ // void testExec_2D_1D()
+ // {
+ // int sizex = 10,sizey=20;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+ // performTest(work_in1,work_in2);
+ // }
+
+ // void testExec_1D_Rand2D()
+ // {
+ // int sizex = 10,sizey=20;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceRand(sizex);
+ // performTest(work_in1,work_in2);
+ // }
+
+ // void testExec_2D_1DVertical()
+ // {
+ // int sizex = 10,sizey=20;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace123(1,sizey);
+ // performTest(work_in1,work_in2);
+ // }
+
+ // void testExec_2D_2DSingleSpectrumBiggerSize_fails()
+ // {
+ // //In 2D workspaces, the X bins have to match
+ // int sizex = 10,sizey=10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(1,sizey*2);
+ // performTest_fails(work_in1, work_in2);
+ // }
+
+ // void testExec_2D_2DbyOperatorOverload()
+ // {
+ // int sizex = 10,sizey=20;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+ // MatrixWorkspace_sptr work_out1;
+ // if (DO_DIVIDE)
+ // work_out1 = work_in1/work_in2;
+ // else
+ // work_out1 = work_in1*work_in2;
+
+ // checkData(work_in1, work_in2, work_out1);
+ // }
+
+ // void testExec_1D_SingleValue()
+ // {
+ // int sizex = 10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2.2);
+ // performTest(work_in1,work_in2);
+ // }
+
+ // void testExec_SingleValue_1D()
+ // {
+ // int sizex = 10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2.2);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+ // performTest(work_in1,work_in2);
+ // }
+
+
+ // void testExec_2D_SingleValue()
+ // {
+ // int sizex = 5,sizey=300;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspaceBinned(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(4.455);
+ // performTest(work_in1,work_in2);
+ // }
+
+ // void testExec_SingleValue_2D()
+ // {
+ // int sizex = 5,sizey=300;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(4.455);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspaceBinned(sizex,sizey);
+ // performTest(work_in1,work_in2);
+ // }
+
+ // void testExec_2D_SingleValueNoError()
+ // {
+ // int sizex = 5,sizey=300;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspaceBinned(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValueWithError(5.0, 0.0);
+ // performTest(work_in1,work_in2);
+ // // Test that commuting works
+ // performTest(work_in2, work_in1);
+ // }
+
+
+
+
+ // //========================================= EventWorkspaces ==================================
+
+ // // Equivalent of 2D over 2D, really
+ // void testExec_2D_Event()
+ // {
+ // int sizex = 10,sizey=20;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace(sizex,sizey);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
+ // performTest(work_in1,work_in2, false);
+ // }
+
+ // void testExec_Event_2D()
+ // {
+ // int sizex = 10,sizey=10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace(sizex,sizey);
+ // if (DO_DIVIDE)
+ // performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
+ // else
+ // performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
+ // }
+
+ // void testExec_Event_2DSingleSpectrum()
+ // {
+ // int sizex = 10,sizey=10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace(1,sizey);
+ // if (DO_DIVIDE)
+ // performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
+ // else
+ // performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
+ // }
+
+ // void testExec_Event_2DSingleSpectrumBiggerSize()
+ // {
+ // //Unlike 2D workspaces, you can divide by a single spectrum with different X bins!
+ // int sizex = 10,sizey=10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace(1,sizey*2);
+ // if (DO_DIVIDE)
+ // performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
+ // else
+ // performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
+ // }
+
+ // void testExec_Event_SingleValue()
+ // {
+ // int sizex = 10,sizey=10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2.0);
+ // if (DO_DIVIDE)
+ // performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
+ // else
+ // performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
+ // }
+
+ // void testExec_Event_SingleValueNoError()
+ // {
+ // int sizex = 10,sizey=10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateWorkspaceSingleValueWithError(2.0, 0.0);
+ // performTest(work_in1,work_in2, true);
+ // }
+
+ // void testExec_Event_Event()
+ // {
+ // int sizex = 20,sizey=10;
+ // MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
+ // MatrixWorkspace_sptr work_in2 = WorkspaceCreationHelper::CreateEventWorkspace(sizex,sizey,100,0.0,1.0,2);
+ // if (DO_DIVIDE)
+ // performTest(work_in1,work_in2, true, 1.0, sqrt(0.75));
+ // else
+ // performTest(work_in1,work_in2, true, 4.0, sqrt(12.0));
+ // }
+
+ void testExec_SingleValue_Event()
{
int sizex = 10,sizey=10;
MatrixWorkspace_sptr work_in1 = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2.0);
@@ -286,9 +289,10 @@ private:
else
alg = new Multiply();
- std::string wsName1 = "DivideTest_test_in1";
- std::string wsName2 = "DivideTest_test_in2";
- std::string wsNameOut = "DivideTest_test_out";
+ const std::string prefix = DO_DIVIDE ? "Divide" : "Multiply";
+ std::string wsName1 = prefix + "Test_test_in1";
+ std::string wsName2 = prefix + "Test_test_in2";
+ std::string wsNameOut = prefix + "Test_test_out";
AnalysisDataService::Instance().add(wsName1, work_in1);
AnalysisDataService::Instance().add(wsName2, work_in2);
alg->initialize();
@@ -307,9 +311,14 @@ private:
{
TS_ASSERT( boost::dynamic_pointer_cast<EventWorkspace>(work_out1) );
}
-
- checkData(work_in1, work_in2, work_out1, 0, expectedValue, expectedError);
-
+ if( boost::dynamic_pointer_cast<Mantid::DataObjects::WorkspaceSingleValue>(work_in1) )
+ {
+ checkData(work_in2, work_in1, work_out1, 0, expectedValue, expectedError);
+ }
+ else
+ {
+ checkData(work_in1, work_in2, work_out1, 0, expectedValue, expectedError);
+ }
AnalysisDataService::Instance().remove(wsNameOut);
}
@@ -329,9 +338,11 @@ private:
else
alg = new Multiply();
- std::string wsName1 = "DivideTest_test_in1";
- std::string wsName2 = "DivideTest_test_in2";
- std::string wsNameOut = "DivideTest_test_out";
+ const std::string prefix = DO_DIVIDE ? "Divide" : "Multiply";
+ std::string wsName1 = prefix + "Test_test_in1";
+ std::string wsName2 = prefix + "Test_test_in2";
+ std::string wsNameOut = prefix + "Test_test_out";
+
AnalysisDataService::Instance().add(wsName1, work_in1);
AnalysisDataService::Instance().add(wsName2, work_in2);
alg->initialize();
diff --git a/Code/Mantid/Framework/PythonAPI/src/WorkspaceProxies.cpp b/Code/Mantid/Framework/PythonAPI/src/WorkspaceProxies.cpp
index 27ce78d9efc5772ccc4c17a8d6c1804fe188f180..d316e5ef2d98dd24ce7fbf75223ac58f9c7d5e65 100644
--- a/Code/Mantid/Framework/PythonAPI/src/WorkspaceProxies.cpp
+++ b/Code/Mantid/Framework/PythonAPI/src/WorkspaceProxies.cpp
@@ -78,11 +78,11 @@ namespace Mantid
{
if( reverse )
{
- result = API::OperatorOverloads::executeBinaryOperation(op, rhs, lhs, inplace, false, name);
+ result = API::OperatorOverloads::executeBinaryOperation(op, rhs, lhs, inplace, false, name, true);
}
else
{
- result = API::OperatorOverloads::executeBinaryOperation(op, lhs, rhs, inplace, false, name);
+ result = API::OperatorOverloads::executeBinaryOperation(op, lhs, rhs, inplace, false, name, true);
}
}
catch(std::runtime_error & exc)