refs #5532. Manual scaling factor handled properly

Code/Mantid/Framework/PythonAPI/PythonAlgorithms/Stitch1D.py

@@ -145,7 +145,7 @@ def PyInit(self):
         self.declareProperty(name="ScaleWorkspace1", defaultValue=True, doc="Scaling either with respect to workspace 1 or workspace 2.")
         self.declareProperty(name="UseManualScaleFactor", defaultValue=False, doc="True to use a provided value for the scale factor.")
         self.declareProperty(name="ManualScaleFactor", defaultValue=1.0, doc="Provided value for the scale factor.")
-        self.declareProperty(name="AppliedScaleFactor", defaultValue=-2.0, direction = Direction.Output, doc="The actual used value for the scaling factor.");
+        self.declareProperty(name="OutScaleFactor", defaultValue=-2.0, direction = Direction.Output, doc="The actual used value for the scaling factor.");
 
     def PyExec(self):
 
@@ -172,16 +172,24 @@ def PyExec(self):
         scaled_workspace_2 = None
         if b_manual_scale_factor == True:
             scale_factor = self.getProperty("ManualScaleFactor").value
+            if b_scale_workspace1 == True:
+                scaled_workspace_1 = ws1_flattened * scale_factor
+                scaled_workspace_2 = ws2_flattened * 1
+            else:
+                scaled_workspace_1 = ws1_flattened * 1
+                scaled_workspace_2 = ws2_flattened * scale_factor
         else:
             if b_scale_workspace1 == True:
                 scale_factor = (ws2_overlap / ws1_overlap)
             else:
                 scale_factor = (ws1_overlap / ws2_overlap)
-        self.setProperty("AppliedScaleFactor", scale_factor)
+            scaled_workspace_1 = ws1_flattened * 1
+            scaled_workspace_2 = ws2_flattened * 1
+        self.setProperty("OutScaleFactor", scale_factor)
 
         #use the start and end positions to 'sum' over the appropriate region in the input workspaces
-        workspace1_overlap = self.__extract_overlap_as_workspace(ws1_flattened, start_overlap, end_overlap)
-        workspace2_overlap = self.__extract_overlap_as_workspace(ws2_flattened, start_overlap, end_overlap)
+        workspace1_overlap = self.__extract_overlap_as_workspace(scaled_workspace_1, start_overlap, end_overlap)
+        workspace2_overlap = self.__extract_overlap_as_workspace(scaled_workspace_2, start_overlap, end_overlap)
         weighted_mean_overlap = api.WeightedMeanMD(LHSWorkspace=workspace1_overlap,RHSWorkspace=workspace2_overlap)
 
         mtd.remove('sum')

Code/Mantid/Framework/PythonInterface/test/python/Stitch1DTest.py

@@ -220,7 +220,7 @@ def test_calculates_scaling_factor_correctly(self):
         b_use_manual_scaling = alg.getProperty("UseManualScaleFactor").value
         self.assertEqual(False, b_use_manual_scaling)
 
-        scale_factor = float(alg.getPropertyValue("AppliedScaleFactor"))
+        scale_factor = float(alg.getPropertyValue("OutScaleFactor"))
 
         # 1 * ((2 + 3)/( 1 + 1)) = 2.5
         self.assertEqual(2.5, scale_factor)
@@ -233,11 +233,36 @@ def test_calculates_scaling_factor_correctly_inverted(self):
 
         alg = run_algorithm("Stitch1D", Workspace1='flat_signal', Workspace2='rising_signal',OutputWorkspace='converted',StartOverlap=0.5,EndOverlap=1,ScaleWorkspace1=False,rethrow=True) 
         self.assertTrue(alg.isExecuted())
-        scale_factor = float(alg.getPropertyValue("AppliedScaleFactor"))
+        scale_factor = float(alg.getPropertyValue("OutScaleFactor"))
 
         # 1 * (( 1 + 1) / (2 + 3)) = 0.4
         self.assertEqual(0.4, scale_factor)
 
+    def test_calculates_scaling_factor_correctly_inverted(self):
+        # Signal = 1, 1, 1, but only the middle to the end of the range is marked as overlap, so only 1, 1 used.
+        alg_a = run_algorithm("CreateMDHistoWorkspace",SignalInput='1,1,1',ErrorInput='1,1,1',Dimensionality='2',Extents='-1,1,-1,1',NumberOfBins='3,1',Names='A,B',Units='U1,U2',OutputWorkspace='flat_signal')
+        # Signal = 1, 2, 3, but only the middle to the end of the range is marked as overlap, so only 2, 3 used.
+        alg_b = run_algorithm("CreateMDHistoWorkspace",SignalInput='1,2,3',ErrorInput='1,1,1',Dimensionality='2',Extents='-1,1,-1,1',NumberOfBins='3,1',Names='A,B',Units='U1,U2',OutputWorkspace='rising_signal')
+
+        alg = run_algorithm("Stitch1D", Workspace1='flat_signal', Workspace2='rising_signal',OutputWorkspace='converted',StartOverlap=0.5,EndOverlap=1,ScaleWorkspace1=False,rethrow=True) 
+        self.assertTrue(alg.isExecuted())
+        scale_factor = float(alg.getPropertyValue("OutScaleFactor"))
+
+        # 1 * (( 1 + 1) / (2 + 3)) = 0.4
+        self.assertEqual(0.4, scale_factor)
+
+    def test_manual_scaling_factor(self):
+        alg_a = run_algorithm("CreateMDHistoWorkspace",SignalInput='1',ErrorInput='1',Dimensionality='2',Extents='-1,1,-1,1',NumberOfBins='3,1',Names='A,B',Units='U1,U2',OutputWorkspace='flat_signal')
+        alg_b = run_algorithm("CreateMDHistoWorkspace",SignalInput='1',ErrorInput='1',Dimensionality='2',Extents='-1,1,-1,1',NumberOfBins='3,1',Names='A,B',Units='U1,U2',OutputWorkspace='rising_signal')
+
+        expected_manual_scale_factor = 2.2
+
+        alg = run_algorithm("Stitch1D", Workspace1='flat_signal', Workspace2='rising_signal',OutputWorkspace='converted',StartOverlap=0.5,EndOverlap=1,ScaleWorkspace1=False,UseManualScaleFactor=True,ManualScaleFactor=expected_manual_scale_factor,rethrow=True) 
+        self.assertTrue(alg.isExecuted())
+        scale_factor = float(alg.getPropertyValue("OutScaleFactor"))
+
+        self.assertEqual(expected_manual_scale_factor, scale_factor)
+
     def test_flat_offsetting_schenario(self):
         errors = [1,1,1,1,1,1,1,1,1,1] # Errors for both input ws1 and ws2
         s1 = [1,1,1,1,1,1,1,1,1,1] # Signal values for ws1
@@ -253,7 +278,27 @@ def test_flat_offsetting_schenario(self):
         for i in range(0, len(errors)):
             self.assertEqual(expected_output_signal[i], ws.signalAt(i))
             self.assertEqual(expected_output_error_sq[i], ws.errorSquaredAt(i))
-
+
+    def test_flat_offsetting_schenario_with_scaling(self):
+        errors = [1,1,1,1,1,1,1,1,1,1] # Errors for both input ws1 and ws2
+        s1 = [1,1,1,1,1,1,1,1,1,1] # Signal values for ws1
+        s2 = [3,3,3,3,3,3,3,3,3,3] # Signal values for ws2
+        expected_output_signal =[2.8,2.8,2.8,2.8,2.8,4,4,4,4,4]
+        expected_output_error_sq = [0.8, 0.8, 0.8, 0.8, 0.8, 2, 2, 2, 2, 2]
+        alg_a = run_algorithm("CreateMDHistoWorkspace",SignalInput=s1,ErrorInput=errors,Dimensionality='2',Extents='-1,1,-1,1',NumberOfBins=[len(errors),1],Names='A,B',Units='U1,U2',OutputWorkspace='flat_signal_a',rethrow=True)
+        alg_b = run_algorithm("CreateMDHistoWorkspace",SignalInput=s2,ErrorInput=errors,Dimensionality='2',Extents='-1,1,-1,1',NumberOfBins=[len(errors),1],Names='A,B',Units='U1,U2',OutputWorkspace='flat_signal_b',rethrow=True)
+        # Supply a manual scale factor, this will mean that Workspace 1 is scaled by this amount.
+        manual_scale_factor = 2
+        # Specify that overlap goes from start to half way along workspace
+        alg = run_algorithm("Stitch1D", Workspace1='flat_signal_a', Workspace2='flat_signal_b',OutputWorkspace='converted',StartOverlap=0.0,EndOverlap=0.5,UseManualScaleFactor=True,ManualScaleFactor=manual_scale_factor,rethrow=True)    
+        # Verify the calculated output values.
+        ws = mtd.retrieve(alg.getPropertyValue("OutputWorkspace"))
+        for i in range(0, len(errors)):
+            self.assertEqual(round(expected_output_signal[i], 5), round(ws.signalAt(i), 5))
+            self.assertEqual(round(expected_output_error_sq[i], 5), round(ws.errorSquaredAt(i),5))#
+        # Sanity check that the applied scale factor is also the same as the value instructed.
+        scale_factor = float(alg.getPropertyValue("OutScaleFactor"))
+        self.assertEqual(manual_scale_factor, scale_factor)
 
     #def test_does_something(self):
         # Algorithm isn't complete at this point, but we need to have one success case to verify that all the previous failure cases are genuine failures (i.e. there is a way to get the algorithm to run properly)