941 append scaling to ws name

src/mslice/cli/_mslice_commands.py

@@ -16,6 +16,7 @@
 from mslice.cli.helperfunctions import (_string_to_integration_axis, _process_axis, _check_workspace_name,
                                         _check_workspace_type, _correct_intensity)
 from mslice.workspace.pixel_workspace import PixelWorkspace
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 from mslice.util.qt.qapp import QAppThreadCall, mainloop
 from six import string_types
 from mslice.workspace.histogram_workspace import HistogramWorkspace
@@ -87,7 +88,7 @@ def Load(Filename, OutputWorkspace=None):
     if OutputWorkspace is not None:
         old_name = ospath.splitext(ospath.basename(Filename))[0]
         if merge:
-            old_name = old_name + '_merged'
+            old_name = WorkspaceNameHandler(old_name).merged()
         name = rename_workspace(workspace=old_name, new_name=OutputWorkspace).name
 
     return get_workspace_handle(name)

src/mslice/models/cut/cut_algorithm.py

@@ -12,6 +12,7 @@
 from mslice.models.units import EnergyUnits
 from mslice.workspace.helperfunctions import attribute_to_log
 from .cut_normalisation import normalize_workspace
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 
 
 class Cut(PythonAlgorithm):
@@ -87,17 +88,17 @@ def _compute_cut_nonPSD(selected_workspace, cut_axis, integration_axis, emode, a
                                       integration_axis.end_meV)))
     idx = 0 if 'Rebin' in algo else 1
     unit = 'DeltaE'
-    name = '__MSL_EnergyTransfer'
+    name = WorkspaceNameHandler('_EnergyTransfer').hideMslInAds()
     if is_momentum(cut_axis.units):
         ws_out = _cut_nonPSD_momentum(cut_binning, int_binning, emode, selected_workspace, algo)
         idx = 1
         unit = 'MomentumTransfer'
-        name = '__MSL_|Q|'
+        name = WorkspaceNameHandler('_|Q|').hideMslInAds()
     elif is_twotheta(cut_axis.units):
         ws_out = _cut_nonPSD_theta(int_binning, cut_binning, selected_workspace, algo)
         idx = 1 if 'Rebin' in algo else 0
         unit = 'Degrees'
-        name = '__MSL_Theta'
+        name = WorkspaceNameHandler('_Theta').hideMslInAds()
     elif integration_axis.units == '|Q|':
         ws_out = _cut_nonPSD_momentum(int_binning, cut_binning, emode, selected_workspace, algo)
     else:

src/mslice/models/intensity_correction_algs.py

@@ -15,6 +15,7 @@
 from mslice.models.cut.cut_algorithm import _cut_nonPSD_general
 from math import trunc, ceil
 
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 
 KB_MEV = constants.value('Boltzmann constant in eV/K') * 1000
 E_TO_K = np.sqrt(2 * constants.neutron_mass * constants.elementary_charge / 1000) / constants.hbar
@@ -141,7 +142,7 @@ def _cut_compute_gdos(scattering_data, sample_temp, q_axis, e_axis, rotated, nor
 def _cut_compute_gdos_pixel(scattering_data, sample_temp, q_axis, e_axis, rotated, norm_to_one, algorithm, is_icut):
     pixel_ws = get_workspace_handle(scattering_data.parent)
     if is_icut:
-        slice_ws = get_workspace_handle("__" + scattering_data.parent)
+        slice_ws = get_workspace_handle(WorkspaceNameHandler(scattering_data.parent).hideInAds())
         slice_rotated = not _is_momentum_or_two_theta(slice_ws.raw_ws.getXDimension().getUnits())  # fn arg rotated refers to cut.
     else:
         slice_rotated = not _is_momentum_or_two_theta(pixel_ws.raw_ws.getXDimension().getUnits())  # no pre existing slice, use pixel ws.

src/mslice/models/slice/slice_functions.py

@@ -11,11 +11,12 @@
 
 from mslice.workspace.pixel_workspace import PixelWorkspace
 from mslice.workspace.workspace import Workspace
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 
 
 def compute_slice(selected_workspace, x_axis, y_axis, norm_to_one, store_in_ADS=True):
     workspace = get_workspace_handle(selected_workspace)
-    slice = mantid_algorithms.Slice(OutputWorkspace='__' + workspace.name, InputWorkspace=workspace,
+    slice = mantid_algorithms.Slice(OutputWorkspace=WorkspaceNameHandler(workspace.name).hideInAds(), InputWorkspace=workspace,
                                     XAxis=x_axis.to_dict(), YAxis=y_axis.to_dict(), PSD=workspace.is_PSD,
                                     EMode=workspace.e_mode, NormToOne=norm_to_one, StoreInADS=store_in_ADS)
     propagate_properties(workspace, slice)

src/mslice/models/workspacemanager/workspace_algorithms.py

@@ -25,6 +25,7 @@
 from mslice.workspace.pixel_workspace import PixelWorkspace
 from mslice.workspace.histogram_workspace import HistogramWorkspace
 from mslice.workspace.workspace import Workspace
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 
 from .file_io import save_ascii, save_matlab, save_nexus, save_nxspe
 
@@ -198,27 +199,27 @@ def combine_workspace(selected_workspaces, new_name):
 
 
 def add_workspace_runs(selected_ws):
-    out_ws_name = selected_ws[0] + '_sum'
-    sum_ws = MergeRuns(OutputWorkspace=out_ws_name, InputWorkspaces=selected_ws)
+    sum_ws = MergeRuns(OutputWorkspace=WorkspaceNameHandler(selected_ws[0]).summed(),
+                       InputWorkspaces=selected_ws)
     propagate_properties(get_workspace_handle(selected_ws[0]), sum_ws)
 
 
 def subtract(workspaces, background_ws, ssf):
-    scaled_bg_ws = Scale(OutputWorkspace=str(background_ws) + '_scaled',
+    scaled_bg_ws = Scale(OutputWorkspace=WorkspaceNameHandler(background_ws).scaled(ssf),
                          InputWorkspace=str(background_ws), Factor=ssf, store=False)
     try:
         for ws_name in workspaces:
-            result = Minus(OutputWorkspace=ws_name + '_subtracted', LHSWorkspace=ws_name,
-                           RHSWorkspace=scaled_bg_ws)
+            result = Minus(OutputWorkspace=WorkspaceNameHandler(ws_name).subtracted(ssf),
+                           LHSWorkspace=ws_name, RHSWorkspace=scaled_bg_ws)
             propagate_properties(get_workspace_handle(ws_name), result)
     except ValueError as e:
         raise ValueError(e)
 
 
 def rebose_single(ws, from_temp, to_temp):
     ws = get_workspace_handle(ws)
-    results = Rebose(InputWorkspace=ws, CurrentTemperature=from_temp, TargetTemperature=to_temp,
-                     OutputWorkspace=ws.name+'_bosed')
+    results = Rebose(OutputWorkspace=WorkspaceNameHandler(ws.name).rebosed(),
+                     InputWorkspace=ws, CurrentTemperature=from_temp, TargetTemperature=to_temp)
     propagate_properties(ws, results)
     return results
 
@@ -232,7 +233,8 @@ def scale_workspaces(workspaces, scale_factor=None, from_temp=None, to_temp=None
     else:
         for ws_name in workspaces:
             ws = get_workspace_handle(ws_name)
-            result = Scale(InputWorkspace=ws.raw_ws, Factor=scale_factor, OutputWorkspace=ws_name+'_scaled')
+            result = Scale(OutputWorkspace=WorkspaceNameHandler(ws_name).scaled(scale_factor),
+                           InputWorkspace=ws.raw_ws, Factor=scale_factor)
             propagate_properties(ws, result)
 
 

src/mslice/presenters/data_loader_presenter.py

@@ -8,6 +8,7 @@
 from mslice.presenters.interfaces.data_loader_presenter import DataLoaderPresenterInterface
 from mslice.presenters.presenter_utility import PresenterUtility
 from mslice.models.workspacemanager.file_io import load_from_ascii
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 
 
 def apply_fixed_final_energy_to_a_valid_workspace(workspace_name, fixed_final_energy: float):
@@ -39,7 +40,7 @@ def load_workspace(self, file_paths, merge=False, force_overwrite=False):
                 if not self.file_types_match(file_paths):
                     self._view.error_merge_different_file_formats()
                     return
-                ws_names = [ws_names[0] + '_merged']
+                ws_names = [WorkspaceNameHandler(ws_names[0]).merged()]
                 file_paths = ['+'.join(file_paths)]
             self._load_ws(file_paths, ws_names, force_overwrite)
 

src/mslice/presenters/slice_plotter_presenter.py

@@ -10,6 +10,7 @@
 from mslice.models.workspacemanager.workspace_provider import get_workspace_handle
 from mslice.plotting.plot_window.overplot_interface import plot_overplot_line, remove_line
 from mslice.presenters.presenter_utility import PresenterUtility
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 
 
 class SlicePlotterPresenter(PresenterUtility):
@@ -31,19 +32,19 @@ def create_slice(self, selected_ws, x_axis, y_axis, intensity_start, intensity_e
         return slice
 
     def plot_from_cache(self, workspace):
-        ws_name = workspace.name.lstrip('__')
+        ws_name = WorkspaceNameHandler(workspace.name).makeVisibleInAds()
         create_slice_figure(ws_name, self)
         self.show_scattering_function(ws_name)
 
     def change_intensity(self, workspace_name, intensity_start, intensity_end):
-        workspace_name = workspace_name.lstrip('__')
+        workspace_name = WorkspaceNameHandler(workspace_name).makeVisibleInAds()
         intensity_start, intensity_end = self.validate_intensity(intensity_start, intensity_end)
         norm = Normalize(vmin=intensity_start, vmax=intensity_end)
         self._slice_cache[workspace_name].norm = norm
 
     def change_colourmap(self, workspace_name, colourmap):
         if colourmap in ALLOWED_CMAPS:
-            workspace_name = workspace_name.lstrip('__')
+            workspace_name = WorkspaceNameHandler(workspace_name).makeVisibleInAds()
             self._slice_cache[workspace_name].colourmap = colourmap
         else:
             raise ValueError('colourmap not recognised')

src/mslice/presenters/workspace_manager_presenter.py

@@ -2,6 +2,7 @@
 from six import string_types
 
 from .busy import show_busy
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 from mslice.widgets.workspacemanager.command import Command
 from mslice.widgets.workspacemanager import TAB_2D, TAB_NONPSD
 from mslice.models.workspacemanager.file_io import get_save_directory
@@ -141,7 +142,7 @@ def _combine_workspace(self):
             return
         elif len(selected_workspaces) == 1:
             selected_workspaces.append(str(self._workspace_manager_view.add_workspace_dialog()))
-        new_workspace = selected_workspaces[0] + '_combined'
+        new_workspace = WorkspaceNameHandler(selected_workspaces[0]).combined()
         if all([is_pixel_workspace(workspace) for workspace in selected_workspaces]):
             combine_workspace(selected_workspaces, new_workspace)
         else:

src/mslice/scripting/__init__.py

@@ -2,6 +2,7 @@
 from mslice.models.workspacemanager.workspace_provider import get_workspace_handle
 from mslice.scripting.helperfunctions import add_plot_statements, replace_ws_special_chars
 from mslice.app.presenters import get_cut_plotter_presenter
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 from six import string_types
 
 
@@ -76,12 +77,14 @@ def _parse_prop(prop):
     pname = prop.name()
     hidden = False
     output_ws = None
+
     if isinstance(pval, string_types):
-        pval = pval.replace("__MSL", "").replace("_HIDDEN", "")
+        pval = WorkspaceNameHandler(pval).removeHideFlags()
+
     if prop.name() == "OutputWorkspace":
         output_ws = replace_ws_special_chars(pval)
-        if "_HIDDEN" in prop.value():
-            hidden = True
+        hidden = WorkspaceNameHandler(prop.value()).isHiddenFromMsl()
+
     return pname, pval, output_ws, hidden
 
 

src/mslice/util/mantid/_workspace_ops.py

@@ -4,6 +4,7 @@
 from mantid.api._workspaceops import _do_binary_operation
 from mantid.kernel.funcinspect import lhs_info
 from mslice.workspace.workspace import WorkspaceOperatorMixin
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 
 _binary_operator_map = {
     "Plus": operator.add,
@@ -65,7 +66,7 @@ def op_wrapper(self, other):
             result_info = lhs_info()
             # Replace output workspace name with a unique temporary name hidden in ADS
             if result_info[0] > 0:
-                result_info = (result_info[0], ('__MSLTMP' + str(uuid4())[:8],) + result_info[1][1:])
+                result_info = (result_info[0], (WorkspaceNameHandler(str(uuid4())[:8]).hideTmpMslInAds(),) + result_info[1][1:])
             return _binary_op(self, other, algorithm, result_info, inplace, reverse)
 
         op_wrapper.__name__ = attr

src/mslice/util/mantid/algorithm_wrapper.py

@@ -10,6 +10,8 @@
 from mslice.workspace.base import WorkspaceBase as MsliceWorkspace
 from mslice.workspace.workspace import Workspace as MsliceWorkspace2D
 
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
+
 
 def _parse_ws_names(args, kwargs):
     input_workspace = kwargs.get('InputWorkspace', None)
@@ -20,9 +22,7 @@ def _parse_ws_names(args, kwargs):
             input_workspace = get_workspace_handle(args[0])
         args = (_name_or_wrapper_to_workspace(args[0]),) + args[1:]
 
-    output_name = ''
-    if 'OutputWorkspace' in kwargs:
-        output_name = kwargs.pop('OutputWorkspace')
+    output_name = kwargs.pop('OutputWorkspace', '')
 
     for key in kwargs.keys():
         if input_workspace is None and 'LHS' in key:
@@ -49,14 +49,18 @@ def alg_wrapper(*args, **kwargs):
             kwargs['InputWorkspaces'] = [_name_or_wrapper_to_workspace(arg) for arg in kwargs['InputWorkspaces']]
 
         for ky in [k for k in kwargs.keys() if 'Workspace' in k]:
-            if isinstance(kwargs[ky], string_types) and '__MSL' not in kwargs[ky]:
+            if isinstance(kwargs[ky], string_types) and not WorkspaceNameHandler(kwargs[ky]).isMslHiddenInAds():
                 kwargs[ky] = _name_or_wrapper_to_workspace(kwargs[ky])
 
         if _alg_has_outputws(algorithm):
-            ads_name = '__MSL' + output_name if output_name else '__MSLTMP' + str(uuid4())[:8]
+            if output_name:
+                ads_name = WorkspaceNameHandler(output_name).hideMslInAds()
+            else:
+                ads_name = WorkspaceNameHandler(str(uuid4())[:8]).hideTmpMslInAds()
+
             store = kwargs.pop('store', True)
             if not store:
-                ads_name += '_HIDDEN'
+                ads_name = WorkspaceNameHandler(ads_name).hideFromMsl()
             result = algorithm(*args, OutputWorkspace=ads_name, **kwargs)
         else:
             result = algorithm(*args, **kwargs)
@@ -93,5 +97,5 @@ def add_to_ads(workspaces):
     except TypeError:
         workspaces = [workspaces]
     for workspace in workspaces:
-        startid = (5 if workspace.name.startswith('__mat') else 2) if workspace.name.startswith('__') else 0
+        startid = (5 if workspace.name.startswith('__mat') else 2) if WorkspaceNameHandler(workspace.name).isHiddenInAds() else 0
         AnalysisDataService.Instance().addOrReplace(workspace.name[startid:], workspace.raw_ws)

src/mslice/workspace/helperfunctions.py

@@ -1,6 +1,5 @@
 import pickle
 import codecs
-
 from mantid.simpleapi import DeleteWorkspace, RenameWorkspace
 
 
@@ -85,7 +84,7 @@ def attribute_to_log(attrdict, raw_ws, append=False):
 
 def delete_workspace(workspace, ws):
     try:
-        if hasattr(workspace, str(ws)) and ws is not None and ws.name().endswith('_HIDDEN'):
+        if hasattr(workspace, str(ws)) and ws is not None and WorkspaceNameHandler(ws.name()).isHiddenFromMsl():
             DeleteWorkspace(ws)
             ws = None
     except RuntimeError:
@@ -116,3 +115,60 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         if self.workspace:
             self.workspace.remove_saved_attributes()
         return True
+
+
+class WorkspaceNameHandler:
+
+    def __init__(self, ws_name: str):
+        self.ws_name = ws_name
+
+    def add_prefix(self, prefix) -> str:
+        return prefix + self.ws_name
+
+    def add_sufix(self, sufix) -> str:
+        return self.ws_name + sufix
+
+    def scaled(self, scaling_factor: float) -> str:
+        return self.add_sufix("_ssf_" + f"{scaling_factor:.2f}".replace('.', '_'))
+
+    def subtracted(self, scaling_factor: float) -> str:
+        return self.add_sufix("_minus_ssf_" + f"{scaling_factor:.2f}".replace('.', '_'))
+
+    def summed(self) -> str:
+        return self.add_sufix("_sum")
+
+    def rebosed(self) -> str:
+        return self.add_sufix('_bosed')
+
+    def combined(self) -> str:
+        return self.add_sufix('_combined')
+
+    def merged(self) -> str:
+        return self.add_sufix('_merged')
+
+    def isHiddenFromMsl(self) -> bool:
+        return '_HIDDEN' in self.ws_name
+
+    def hideFromMsl(self) -> str:
+        return self.add_sufix('_HIDDEN')
+
+    def removeHideFlags(self) -> str:
+        return self.ws_name.replace('__MSL', '').replace('_HIDDEN', '')
+
+    def hideMslInAds(self) -> str:
+        return self.add_prefix('__MSL')
+
+    def isMslHiddenInAds(self) -> bool:
+        return '__MSL' in self.ws_name
+
+    def hideTmpMslInAds(self) -> str:
+        return self.add_prefix('__MSLTMP')
+
+    def hideInAds(self) -> str:
+        return self.add_prefix('__')
+
+    def isHiddenInAds(self) -> bool:
+        return self.ws_name.startswith('__')
+
+    def makeVisibleInAds(self) -> str:
+        return self.ws_name.lstrip('__')

tests/workspace_provider_test.py

@@ -13,6 +13,7 @@
 from mslice.widgets.workspacemanager.command import Command
 from mantid.simpleapi import AddSampleLog
 from mslice.views.interfaces.workspace_view import WorkspaceView
+from mslice.workspace.helperfunctions import WorkspaceNameHandler
 
 
 class MantidWorkspaceProviderTest(unittest.TestCase):
@@ -44,16 +45,16 @@ def test_delete_workspace(self):
 
     def test_subtract_workspace(self):
         subtract(['test_ws_2d'], 'test_ws_2d', 0.95)
-        result = get_workspace_handle('test_ws_2d_subtracted')
+        result = get_workspace_handle(WorkspaceNameHandler('test_ws_2d').subtracted(0.95))
         np.testing.assert_array_almost_equal(result.raw_ws.dataY(0), [0.05] * 20)
         np.testing.assert_array_almost_equal(self.test_ws_2d.raw_ws.dataY(0), [1] * 20)
-        self.assertFalse('test_ws_2d_scaled' in get_visible_workspace_names())
+        self.assertFalse(WorkspaceNameHandler('test_ws_2d').scaled(0.95) in get_visible_workspace_names())
         self.assertRaises(ValueError, subtract, ['test_ws_2d'], 'test_ws_md', 1.0)
 
     def test_add_workspace(self):
         original_data = self.test_ws_2d.raw_ws.dataY(0)
         add_workspace_runs(['test_ws_2d', 'test_ws_2d'])
-        result = get_workspace_handle('test_ws_2d_sum')
+        result = get_workspace_handle(WorkspaceNameHandler('test_ws_2d').summed())
         np.testing.assert_array_almost_equal(result.raw_ws.dataY(0), [2.0] * 20)
         np.testing.assert_array_almost_equal(original_data, [1] * 20)