Re #10684 chop_ws_part method and unit test for it

Code/Mantid/scripts/Inelastic/Direct/RunDescriptor.py

@@ -3,6 +3,7 @@
 
 from mantid.simpleapi import *
 from PropertiesDescriptors import *
+import re
 
 
 class RunDescriptor(PropDescriptor):
@@ -42,9 +43,9 @@ def __get__(self,instance,owner):
        """ return current run number or workspace if it is loaded""" 
        if not RunDescriptor._PropMan:
           RunDescriptor._PropMan = owner
-
        if instance is None:
            return self
+
        if self._ws_name and self._ws_name in mtd:
            return mtd[self._ws_name]
        else:
@@ -284,7 +285,7 @@ def get_workspace(self):
               return None
 #--------------------------------------------------------------------------------------------------------------------
     def get_ws_clone(self,clone_name='ws_clone'):
-        """ Get unbounded clone of existing Run workspace """
+        """ Get unbounded clone of eisting Run workspace """
         ws = self.get_workspace()
         CloneWorkspace(InputWorkspace=ws,OutputWorkspace=clone_name)
         mon_ws_name = self.get_ws_name() + '_monitors'
@@ -304,22 +305,35 @@ def _set_ws_as_source(self,value):
 #--------------------------------------------------------------------------------------------------------------------
     def chop_ws_part(self,origin,tof_range,rebin,chunk_num,n_chunks):
         """ chop part of the original workspace and sets it up as new original. 
-            Return the old one""" 
+            Return the old one """ 
         if not(origin):
            origin = self.get_workspace()
+
         origin_name = origin.name()
-        if chunk_num == n_chungs:
-           target_name = origin_name
+        target_name = '#{0}/{1}#'.format(chunk_num,n_chunks)+origin_name
+        if chunk_num == n_chunks:
+           RenameWorkspace(InputWorkspace=origin_name,OutputWorkspace=target_name)
+           if self.is_monws_separate():
+              mon_ws=self.get_monitors_ws()
+              RenameWorkspace(InputWorkspace=mon_ws,OutputWorkspace=target_name+'_monitors')
+           origin_name = target_name
+           origin_invalidated=True
         else:
-           target_name = '#{0}/{1}_'.format(chunk_num,n_chunks)+origin_name
+           if self.is_monws_separate():
+              mon_ws=self.get_monitors_ws()
+              CloneWorkspace(InputWorkspace=mon_ws,OutputWorkspace=target_name+'_monitors')
+           origin_invalidated=False
 
         if rebin: # debug and compatibility mode with old reduction
            Rebin(origin_name,OutputWorkspace=target_name,Params=[tof_range[0],tof_range[1],tof_range[2]],PreserveEvents=False)
         else:
-           CropWorkspace(origin,OutputWorkspace=target_name,XMin=tof_range[0],XMax=tof_range[2])
+           CropWorkspace(origin_name,OutputWorkspace=target_name,XMin=tof_range[0],XMax=tof_range[2])
 
         self._set_ws_as_source(mtd[target_name])
-        return mtd[origin_name]
+        if origin_invalidated:
+            return self.get_workspace()
+        else:
+            return origin
 
 #--------------------------------------------------------------------------------------------------------------------
     def get_monitors_ws(self,monitor_ID=None):
@@ -599,13 +613,20 @@ def _split_ws_name(self,ws_name):
             name = self.rremove(ws_name,sumExt)
         # remove _prop_name:
         name = name.replace(self._prop_name,'',1)
+
+        try:
+           part_ind = re.search('#(.+?)#', name).group(0)
+           name     =name.replace(part_ind,'',1)
+        except AttributeError:
+           part_ind=''
+
         if self._run_number:
             instr_name = self._instr_name()
             name = name.replace(instr_name,'',1)
-            self._ws_cname = filter(lambda c: not c.isdigit(), name)
+            self._ws_cname = part_ind+filter(lambda c: not c.isdigit(), name)
 
         else:
-            self._ws_cname = name
+            self._ws_cname = part_ind+name
     #
     def _instr_name(self):
        if RunDescriptor._holder:

Code/Mantid/scripts/test/RunDescriptorTest.py

@@ -1,11 +1,9 @@
-import os
+import os,sys,inspect
 #os.environ["PATH"] = r"c:/Mantid/Code/builds/br_master/bin/Release;"+os.environ["PATH"]
 from mantid.simpleapi import *
 from mantid import api
 import unittest
-import inspect
 import numpy as np
-import sys
 from Direct.PropertyManager import PropertyManager
 from Direct.RunDescriptor   import RunDescriptor
 
@@ -283,14 +281,42 @@ def test_get_run_list(self):
         self.assertEqual(runs[0],10011)
         self.assertFalse(propman.sum_runs)
 
+    def test_chop_ws_part(self):
+        propman  = self.prop_man
+        ws=CreateSampleWorkspace(Function='Multiple Peaks', NumBanks=4, BankPixelWidth=1, NumEvents=100, XUnit='TOF',
+                                                     XMin=2000, XMax=20000, BinWidth=1)
+
+        ws_monitors=CreateSampleWorkspace(Function='Multiple Peaks', NumBanks=4, BankPixelWidth=1, NumEvents=100, XUnit='TOF',
+                                                    XMin=2000, XMax=20000, BinWidth=1)
+
+        propman.sample_run = ws
+
+        ws1 = PropertyManager.sample_run.chop_ws_part(None,(2000,1,5000),False,1,2)
+
+        rez=CheckWorkspacesMatch('SR_ws',ws1)
+        self.assertEqual(rez,'Success!')
 
+        wsc=PropertyManager.sample_run.get_workspace()
+        x =wsc.readX(0)
+        self.assertAlmostEqual(x[0],2000)
+        self.assertAlmostEqual(x[-1],5000)
 
+        self.assertEqual(wsc.name(),'SR_#1/2#ws')
+        self.assertTrue('SR_#1/2#ws_monitors' in mtd)
 
 
 
+        ws1 = PropertyManager.sample_run.chop_ws_part(ws1,(10000,100,20000),True,2,2)
+        x =ws1.readX(0)
+        self.assertAlmostEqual(x[0],10000)
+        self.assertAlmostEqual(x[-1],20000)
 
+        self.assertEqual(ws1.name(),'SR_#2/2#ws')
+        self.assertTrue('SR_#2/2#ws_monitors' in mtd)
 
+        api.AnalysisDataService.clear()
 
+
 
 if __name__=="__main__":
     unittest.main()