diff --git a/Framework/PythonInterface/plugins/algorithms/CompareSampleLogs.py b/Framework/PythonInterface/plugins/algorithms/CompareSampleLogs.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a1aeb82e7fd2ae991abb41d68e1c14661f544c0
--- /dev/null
+++ b/Framework/PythonInterface/plugins/algorithms/CompareSampleLogs.py
@@ -0,0 +1,157 @@
+from mantid.api import PythonAlgorithm, AlgorithmFactory, WorkspaceGroup, MatrixWorkspace
+from mantid.kernel import Direction, StringArrayLengthValidator, StringArrayProperty, FloatBoundedValidator
+import mantid.simpleapi as api
+
+
+class CompareSampleLogs(PythonAlgorithm):
+ """
+ Compares specified sample logs for a given list of workspaces
+ """
+
+ def __init__(self):
+ """
+ Init
+ """
+ PythonAlgorithm.__init__(self)
+
+ def category(self):
+ """
+ Returns category
+ """
+ return "PythonAlgorithms;Utility\\Workspaces"
+
+ def name(self):
+ """
+ Returns name
+ """
+ return "CompareSampleLogs"
+
+ def summary(self):
+ return "Compares specified sample logs for a given list of workspaces."
+
+ def PyInit(self):
+ validator = StringArrayLengthValidator()
+ validator.setLengthMin(1) # one group may be given
+ self.declareProperty(StringArrayProperty(name="InputWorkspaces", direction=Direction.Input, validator=validator),
+ doc="Comma separated list of workspaces or groups of workspaces.")
+
+ self.declareProperty(StringArrayProperty(name="SampleLogs", direction=Direction.Input, validator=validator),
+ doc="Comma separated list of sample logs to compare.")
+ self.declareProperty("Tolerance", 1e-3, validator=FloatBoundedValidator(lower=1e-7, upper=1.0),
+ doc="Tolerance for comparison of double values.")
+ self.declareProperty("Result", "A string that will be empty if all the logs match, "
+ "otherwise will contain a comma separated list of not matching logs", Direction.Output)
+
+ return
+
+ def validateInputs(self):
+ # given workspaces must exist
+ # and must be public of ExperimentInfo
+ issues = dict()
+ workspaces = self.getProperty("InputWorkspaces").value
+ for wsname in workspaces:
+ if not api.AnalysisDataService.doesExist(wsname):
+ issues["InputWorkspaces"] = "Workspace " + wsname + " does not exist."
+ else:
+ wks = api.AnalysisDataService.retrieve(wsname)
+ if isinstance(wks, WorkspaceGroup):
+ for idx in range(wks.getNumberOfEntries()):
+ if not isinstance(wks.getItem(idx), MatrixWorkspace):
+ issues["InputWorkspaces"] = "Group " + wsname + " contains workspaces of unsupported type."
+ elif not isinstance(wks, MatrixWorkspace):
+ issues["InputWorkspaces"] = "Type of workspace " + wsname + " is not supported by this algorithm."
+
+ return issues
+
+ def _expand_groups(self):
+ workspaces = self.getProperty("InputWorkspaces").value
+ input_workspaces = []
+ for wsname in workspaces:
+ wks = api.AnalysisDataService.retrieve(wsname)
+ if isinstance(wks, WorkspaceGroup):
+ input_workspaces.extend(wks.getNames())
+ else:
+ input_workspaces.append(wsname)
+
+ return input_workspaces
+
+ def compare_properties(self, wslist, plist, tolerance):
+ """
+ Compares properties which are required to be the same.
+ Produces error message and throws exception if difference is observed
+ or if one of the sample logs is not found.
+ Important: exits after the first difference is observed. No further check is performed.
+ @param wslist List of workspaces
+ @param plist List of properties to compare
+ @param tolerance Tolerance for comparison of the double values.
+ """
+ # retrieve the workspaces, form dictionary {wsname: run}
+ runs = {}
+ does_not_match = []
+ for wsname in wslist:
+ wks = api.AnalysisDataService.retrieve(wsname)
+ runs[wsname] = wks.getRun()
+
+ for prop in plist:
+ properties = []
+ isnum = False
+ for wsname in wslist:
+ run = runs[wsname]
+ if not run.hasProperty(prop):
+ message = "Workspace " + wsname + " does not have sample log " + prop
+ self.log().warning(message)
+ else:
+ curprop = run.getProperty(prop)
+ if curprop.type == 'string':
+ properties.append(curprop.value)
+ elif curprop.type == 'number':
+ properties.append(int(curprop.value/tolerance))
+ isnum = True
+ else:
+ message = "Comparison of " + str(curprop.type) + " properties is not yes supported. Property " +\
+ prop + " in the workspace " + wsname
+ self.log().warning(message)
+
+ # check whether number of properties and workspaces match
+ nprop = len(properties)
+ if nprop != len(wslist):
+ message = "Number of properties " + str(nprop) + " for property " + prop +\
+ " is not equal to number of workspaces " + str(len(wslist))
+ self.log().warning(message)
+ does_not_match.append(prop)
+
+ else:
+ pvalue = properties[0]
+ if properties.count(pvalue) != nprop:
+ if isnum:
+ properties = [tolerance*value for value in properties]
+ message = "Sample log " + prop + " is not identical in the given list of workspaces. \n" +\
+ "Workspaces: " + ", ".join(wslist) + "\n Values: " + str(properties)
+ self.log().warning(message)
+ does_not_match.append(prop)
+ return does_not_match
+
+ def PyExec(self):
+ wslist = self._expand_groups()
+
+ # no sence to compare sample logs for one workspace
+ if len(wslist) < 2:
+ message = "At least 2 workspaces must be given as an input."
+ self.log().error(message)
+ raise RuntimeError(message)
+
+ lognames = self.getProperty("SampleLogs").value
+ tolerance = self.getProperty("Tolerance").value
+ result = ''
+ do_not_match = self.compare_properties(wslist, lognames, tolerance)
+
+ # return list of not matching properties
+ if len(do_not_match) > 0:
+ result = ",".join(do_not_match)
+
+ self.setProperty("Result", result)
+ return
+
+
+# Register algorithm with Mantid
+AlgorithmFactory.subscribe(CompareSampleLogs)
diff --git a/Framework/PythonInterface/plugins/algorithms/DNSDetEffCorrVana.py b/Framework/PythonInterface/plugins/algorithms/DNSDetEffCorrVana.py
index 0a714e79702e1ead2791a14d1d477198e6425634..b94cf353e6953cdcf826960b3db96a59594044d5 100644
--- a/Framework/PythonInterface/plugins/algorithms/DNSDetEffCorrVana.py
+++ b/Framework/PythonInterface/plugins/algorithms/DNSDetEffCorrVana.py
@@ -141,15 +141,14 @@ class DNSDetEffCorrVana(PythonAlgorithm):
wslist = [self.dataws.getName(), self.vanaws.getName(), self.bkgws.getName()]
mlzutils.same_dimensions(wslist)
# check if the _NORM workspaces exist
- wslist = [self.vanaws.getName() + '_NORM', self.bkgws.getName() + '_NORM']
- mlzutils.ws_exist(wslist, self.log())
+ wslist_norm = [self.vanaws.getName() + '_NORM', self.bkgws.getName() + '_NORM']
+ mlzutils.ws_exist(wslist_norm, self.log())
# check sample logs, produce warnings if different
- drun = self.dataws.getRun()
- vrun = self.vanaws.getRun()
- brun = self.bkgws.getRun()
- mlzutils.compare_properties(drun, vrun, self.properties_to_compare, self.log())
- mlzutils.compare_properties(vrun, brun, self.properties_to_compare, self.log())
+ result = api.CompareSampleLogs(wslist, self.properties_to_compare, 5e-3)
+ if len(result) > 0:
+ self.log().warning("Sample logs " + result + " do not match!")
+
# apply correction
outws = self._vana_correct()
if not outws:
diff --git a/Framework/PythonInterface/plugins/algorithms/DNSFlippingRatioCorr.py b/Framework/PythonInterface/plugins/algorithms/DNSFlippingRatioCorr.py
index 61bd99d66338390349d057afbb5720c0007c629c..5f9c25cacca7caf814328c6d6703727162300195 100644
--- a/Framework/PythonInterface/plugins/algorithms/DNSFlippingRatioCorr.py
+++ b/Framework/PythonInterface/plugins/algorithms/DNSFlippingRatioCorr.py
@@ -148,12 +148,9 @@ class DNSFlippingRatioCorr(PythonAlgorithm):
self._flipper_valid()
# algorithm must warn if some properties_to_compare are different
- ws1 = api.AnalysisDataService.retrieve(self.input_workspaces.values()[0])
- run1 = ws1.getRun()
- for wsname in self.input_workspaces.values()[1:]:
- wks = api.AnalysisDataService.retrieve(wsname)
- run = wks.getRun()
- mlzutils.compare_properties(run1, run, self.properties_to_compare, self.log())
+ result = api.CompareSampleLogs(self.input_workspaces.values(), self.properties_to_compare, 5e-3)
+ if len(result) > 0:
+ self.log().warning("Sample logs " + result + " do not match!")
return True
def _fr_correction(self):
diff --git a/Framework/PythonInterface/plugins/algorithms/DNSMergeRuns.py b/Framework/PythonInterface/plugins/algorithms/DNSMergeRuns.py
index 381a06e4037c319e11edec0b4ba79c87dbb43868..de2877c6dada0ed8ccea42ecc9ddafdb105764d6 100644
--- a/Framework/PythonInterface/plugins/algorithms/DNSMergeRuns.py
+++ b/Framework/PythonInterface/plugins/algorithms/DNSMergeRuns.py
@@ -84,12 +84,10 @@ class DNSMergeRuns(PythonAlgorithm):
self._same_wavelength()
# algorithm must warn if some properties_to_compare are different
- ws1 = api.AnalysisDataService.retrieve(self.workspace_names[0])
- run1 = ws1.getRun()
- for wsname in self.workspace_names[1:]:
- wks = api.AnalysisDataService.retrieve(wsname)
- run = wks.getRun()
- mlzutils.compare_properties(run1, run, self.properties_to_compare, self.log())
+ result = api.CompareSampleLogs(self.workspace_names, self.properties_to_compare, 5e-3)
+ if len(result) > 0:
+ self.log().warning("Sample logs " + result + " do not match!")
+
return True
def _same_wavelength(self):
diff --git a/Framework/PythonInterface/plugins/algorithms/TOFTOFMergeRuns.py b/Framework/PythonInterface/plugins/algorithms/TOFTOFMergeRuns.py
index 443a8249b46b60ca036b0bec1e6482e55d983c88..e2bb3ed542238e9846fbf4162e5dfcfe274e4c1e 100644
--- a/Framework/PythonInterface/plugins/algorithms/TOFTOFMergeRuns.py
+++ b/Framework/PythonInterface/plugins/algorithms/TOFTOFMergeRuns.py
@@ -71,7 +71,9 @@ class TOFTOFMergeRuns(PythonAlgorithm):
Checks whether given workspaces can be merged
"""
# mandatory properties must be identical
- mlzutils.compare_mandatory(wsnames, self.mandatory_properties, self.log())
+ result = api.CompareSampleLogs(wsnames, self.mandatory_properties, 0.01)
+ if len(result) > 0:
+ raise RuntimeError("Sample logs " + result + " do not match!")
# timing (x-axis binning) must match
# is it possible to use WorkspaceHelpers::matchingBins from python?
@@ -89,12 +91,10 @@ class TOFTOFMergeRuns(PythonAlgorithm):
raise RuntimeError(message)
# warnig if optional properties are not identical must be given
- ws1 = api.AnalysisDataService.retrieve(wsnames[0])
- run1 = ws1.getRun()
- for wsname in wsnames[1:]:
- wks = api.AnalysisDataService.retrieve(wsname)
- run = wks.getRun()
- mlzutils.compare_properties(run1, run, self.optional_properties, self.log(), tolerance=0.01)
+ result = api.CompareSampleLogs(wsnames, self.optional_properties, 0.01)
+ if len(result) > 0:
+ self.log().warning("Sample logs " + result + " do not match!")
+
return True
def PyExec(self):
diff --git a/Framework/PythonInterface/plugins/algorithms/mlzutils.py b/Framework/PythonInterface/plugins/algorithms/mlzutils.py
index d0e47dbdc7891c084a714360e66ae6daf3b60f81..dbb2b90239d744b4dd18b4bee7cf77d55b1e1f37 100644
--- a/Framework/PythonInterface/plugins/algorithms/mlzutils.py
+++ b/Framework/PythonInterface/plugins/algorithms/mlzutils.py
@@ -57,107 +57,6 @@ def ws_exist(wslist, logger):
return True
-def compare_properties(lhs_run, rhs_run, plist, logger, tolerance=5e-3):
- """
- checks whether properties match in the given runs, produces warnings
- @param lhs_run Left-hand-side run
- @param rhs_run Right-hand-side run
- @param plist List of properties to compare
- @param logger Logger self.log()
- """
- lhs_title = ""
- rhs_title = ""
- if lhs_run.hasProperty('run_title') and rhs_run.hasProperty('run_title'):
- lhs_title = lhs_run.getProperty('run_title').value
- rhs_title = rhs_run.getProperty('run_title').value
-
- # for TOFTOF run_titles can be identical
- if lhs_title == rhs_title:
- if lhs_run.hasProperty('run_number') and rhs_run.hasProperty('run_number'):
- lhs_title = str(lhs_run.getProperty('run_number').value)
- rhs_title = str(rhs_run.getProperty('run_number').value)
-
- for property_name in plist:
- if lhs_run.hasProperty(property_name) and rhs_run.hasProperty(property_name):
- lhs_property = lhs_run.getProperty(property_name)
- rhs_property = rhs_run.getProperty(property_name)
- if lhs_property.type == rhs_property.type:
- if lhs_property.type == 'string':
- if lhs_property.value != rhs_property.value:
- message = "Property " + property_name + " does not match! " + \
- lhs_title + ": " + lhs_property.value + ", but " + \
- rhs_title + ": " + rhs_property.value
- logger.warning(message)
- elif lhs_property.type == 'number':
- if abs(lhs_property.value - rhs_property.value) > tolerance:
- message = "Property " + property_name + " does not match! " + \
- lhs_title + ": " + str(lhs_property.value) + ", but " + \
- rhs_title + ": " + str(rhs_property.value)
- logger.warning(message)
- else:
- message = "Property " + property_name + " does not match! " + \
- lhs_title + ": " + str(lhs_property.value) + " has type " + \
- str(lhs_property.type) + ", but " + rhs_title + ": " + \
- str(rhs_property.value) + " has type " + str(rhs_property.type)
- logger.warning(message)
- else:
- message = "Property " + property_name + " is not present in " +\
- lhs_title + " or " + rhs_title + " - skipping comparison."
- logger.warning(message)
- return
-
-
-def compare_mandatory(wslist, plist, logger, tolerance=0.01):
- """
- Compares properties which are required to be the same.
- Produces error message and throws exception if difference is observed
- or if one of the sample logs is not found.
- Important: exits after the first difference is observed. No further check is performed.
- @param wslist List of workspaces
- @param plist List of properties to compare
- @param logger Logger self.log()
- @param tolerance Tolerance for comparison of the double values.
- """
- # retrieve the workspaces, form dictionary {wsname: run}
- runs = {}
- for wsname in wslist:
- wks = api.AnalysisDataService.retrieve(wsname)
- runs[wsname] = wks.getRun()
-
- for prop in plist:
- properties = []
- for wsname in wslist:
- run = runs[wsname]
- if not run.hasProperty(prop):
- message = "Workspace " + wsname + " does not have sample log " + prop
- logger.error(message)
- raise RuntimeError(message)
-
- curprop = run.getProperty(prop)
- if curprop.type == 'string':
- properties.append(curprop.value)
- elif curprop.type == 'number':
- properties.append(int(curprop.value/tolerance))
- else:
- message = "Unknown type " + str(curprop.type) + " for the sample log " +\
- prop + " in the workspace " + wsname
- logger.error(message)
- raise RuntimeError(message)
- # this should never happen, but lets check
- nprop = len(properties)
- if nprop != len(wslist):
- message = "Error. Number of properties " + str(nprop) + " for property " + prop +\
- " is not equal to number of workspaces " + str(len(wslist))
- logger.error(message)
- raise RuntimeError(message)
- pvalue = properties[0]
- if properties.count(pvalue) != nprop:
- message = "Sample log " + prop + " is not identical in the given list of workspaces. \n" +\
- "Workspaces: " + ", ".join(wslist) + "\n Values: " + str(properties)
- logger.error(message)
- raise RuntimeError(message)
-
-
def do_fit_gaussian(workspace, index, logger):
"""
Calculates guess values on peak centre, sigma and peak height.
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt b/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
index caeeaa2c49450ee0c7764664d0e5c337dde9e5e6..03417633bf870e93d1837c7664601047df0d3738 100644
--- a/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
+++ b/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
@@ -8,6 +8,7 @@ set ( TEST_PY_FILES
CalculateSampleTransmissionTest.py
CheckForSampleLogsTest.py
ConjoinSpectraTest.py
+ CompareSampleLogsTest.py
ComputeCalibrationCoefVanTest.py
CorrectLogTimesTest.py
CreateLeBailFitInputTest.py
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/CompareSampleLogsTest.py b/Framework/PythonInterface/test/python/plugins/algorithms/CompareSampleLogsTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbbcb73d8a2b1899e8e1a6e853b91323eae1bdae
--- /dev/null
+++ b/Framework/PythonInterface/test/python/plugins/algorithms/CompareSampleLogsTest.py
@@ -0,0 +1,45 @@
+import unittest
+from testhelpers import run_algorithm
+from mantid.api import AnalysisDataService
+from mantid.simpleapi import CreateSampleWorkspace, AddSampleLogMultiple, DeleteWorkspace, GroupWorkspaces
+
+
+class CompareSampleLogsTest(unittest.TestCase):
+ def setUp(self):
+ ws1 = CreateSampleWorkspace()
+ self.ws1 = ws1
+ ws2 = CreateSampleWorkspace()
+ self.ws2 = ws2
+ lognames = 'run_title,deterota,wavelength,polarisation,flipper'
+ logvalues = 'ws1,-10.0,4.2,x,ON'
+ AddSampleLogMultiple(Workspace=ws1, LogNames=lognames, LogValues=logvalues, ParseType=True)
+ logvalues = 'ws2,-12.0,4.2,x,OFF'
+ AddSampleLogMultiple(Workspace=ws2, LogNames=lognames, LogValues=logvalues, ParseType=True)
+
+ def test_workspaces_different_logs(self):
+ wslist = [self.ws1, self.ws2]
+ lognames = 'deterota,wavelength,polarisation,flipper,qqq'
+ alg_test = run_algorithm("CompareSampleLogs", InputWorkspaces=wslist, SampleLogs=lognames,
+ Tolerance=0.01)
+ self.assertTrue(alg_test.isExecuted())
+ # check for the returned value
+ result = alg_test.getProperty('Result').value
+ self.assertEqual('deterota,flipper,qqq', result)
+
+ def test_groups_same_logs(self):
+ GroupWorkspaces([self.ws1, self.ws2], OutputWorkspace='group')
+ lognames = 'wavelength,polarisation'
+ alg_test = run_algorithm("CompareSampleLogs", InputWorkspaces='group', SampleLogs=lognames,
+ Tolerance=0.01)
+ self.assertTrue(alg_test.isExecuted())
+ result = alg_test.getProperty('Result').value
+ self.assertEqual('', result)
+
+ def tearDown(self):
+ if AnalysisDataService.doesExist('ws1'):
+ DeleteWorkspace('ws1')
+ if AnalysisDataService.doesExist('ws2'):
+ DeleteWorkspace('ws2')
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/docs/source/algorithms/CompareSampleLogs-v1.rst b/docs/source/algorithms/CompareSampleLogs-v1.rst
new file mode 100644
index 0000000000000000000000000000000000000000..3e6e08820848e649ec0bd8dd0ded51eabf055844
--- /dev/null
+++ b/docs/source/algorithms/CompareSampleLogs-v1.rst
@@ -0,0 +1,91 @@
+.. algorithm::
+
+.. summary::
+
+.. alias::
+
+.. properties::
+
+Description
+-----------
+
+Utility algorithm. Compares specified sample logs for a given list of workspaces or workspace groups. If sample logs match, no output will be produced. If sample logs do not match or do not exist, comma separated list of these sample logs will be returned. This list can be used as an input for :ref:`algm-CreateLogPropertyTable` algorithm to get a TableWorkspace with not identical properties.
+
+For the moment, algorithm does not support comparison of the time series logs.
+
+
+Usage
+-----
+
+**Example 1: compare identical sample logs**
+
+.. testcode:: ExCompareSampleLogs
+
+ # create workspaces with some sample logs
+ ws1 = CreateSampleWorkspace()
+ ws2 = CreateSampleWorkspace()
+
+ lognames = 'omega,wavelength,polarisation,flipper'
+ logvalues = '10.0,4.2,x,ON'
+ AddSampleLogMultiple(Workspace=ws1, LogNames=lognames, LogValues=logvalues, ParseType=True)
+ logvalues = '10.0,4.2,x,ON'
+ AddSampleLogMultiple(Workspace=ws2, LogNames=lognames, LogValues=logvalues, ParseType=True)
+
+ # compare sample logs
+ result = CompareSampleLogs('ws1,ws2', 'omega,wavelength,polarisation,flipper' , 0.01)
+ if result == '':
+ print "All sample logs match!"
+
+.. testcleanup:: ExCompareSampleLogs
+
+ DeleteWorkspace('ws1')
+ DeleteWorkspace('ws2')
+
+Output:
+
+.. testoutput:: ExCompareSampleLogs
+
+ All sample logs match!
+
+
+**Example 2: create a table of not identical sample logs**
+
+.. testcode:: ExCompareSampleLogs2
+
+ # create workspaces with some sample logs
+ ws1 = CreateSampleWorkspace()
+ ws2 = CreateSampleWorkspace()
+
+ lognames = 'run_title,omega,wavelength,polarisation,flipper'
+ logvalues = 'ws1,10.0,4.2,x,ON'
+ AddSampleLogMultiple(Workspace=ws1, LogNames=lognames, LogValues=logvalues, ParseType=True)
+ logvalues = 'ws2,12.0,4.2,x,OFF'
+ AddSampleLogMultiple(Workspace=ws2, LogNames=lognames, LogValues=logvalues, ParseType=True)
+
+ # compare sample logs
+ result = CompareSampleLogs('ws1,ws2', lognames , 0.01)
+ print "Following sample logs do not match: ", result
+
+ # create a table
+ table = CreateLogPropertyTable('ws1,ws2', result, GroupPolicy='All')
+ print "Column names are: ", table.getColumnNames()
+ print "The omega values are:", table.column(1)
+ print "The flipper values are:", table.column(2)
+
+.. testcleanup:: ExCompareSampleLogs2
+
+ DeleteWorkspace('ws1')
+ DeleteWorkspace('ws2')
+
+Output:
+
+.. testoutput:: ExCompareSampleLogs2
+
+ Following sample logs do not match: run_title,omega,flipper
+ Column names are: ['run_title', 'omega', 'flipper']
+ The omega values are: ['10', '12']
+ The flipper values are: ['ON', 'OFF']
+
+.. categories::
+
+.. sourcelink::
diff --git a/docs/source/algorithms/TOFTOFMergeRuns-v1.rst b/docs/source/algorithms/TOFTOFMergeRuns-v1.rst
index 25aec61d5f1324450adf5eb51a07564d619897ff..f129e9ba5cc83599b4d5e6241ae41c75b9d0ed35 100644
--- a/docs/source/algorithms/TOFTOFMergeRuns-v1.rst
+++ b/docs/source/algorithms/TOFTOFMergeRuns-v1.rst
@@ -55,8 +55,9 @@ Usage
ws2 = LoadMLZ(Filename='TOFTOFTestdata.nxs')
# change sample logs for a second workspace, not needed for real workspaces
+ AddSampleLog(ws1, 'temperature', str(294.14), 'Number')
lognames = 'temperature,run_start,run_end,monitor_counts,run_number'
- logvalues = '296.15,2013-07-28T11:32:19+0053,2013-07-28T12:32:19+0053,145145,TOFTOFTestdata2'
+ logvalues = '296.16,2013-07-28T11:32:19+0053,2013-07-28T12:32:19+0053,145145,TOFTOFTestdata2'
AddSampleLogMultiple(ws2, lognames, logvalues)
# Input = list of workspaces
@@ -97,9 +98,9 @@ Output:
.. testoutput:: ExTOFTOFMergeRuns2ws
- Temperature of experiment for 1st workspace (in K): 294.149414
- Temperature of experiment for 2nd workspace (in K): 296.15
- Temperature of experiment for merged workspaces = average over workspaces (in K): 295.149707
+ Temperature of experiment for 1st workspace (in K): 294.14
+ Temperature of experiment for 2nd workspace (in K): 296.16
+ Temperature of experiment for merged workspaces = average over workspaces (in K): 295.15
Duration of experiment for 1st workspace (in s): 3601
Duration of experiment for 2nd workspace (in s): 3601
Duration of experiment for merged workspaces = sum of all durations (in s): 7202
@@ -114,7 +115,7 @@ Output:
Run number for merged workspaces = list of all workspaces: ['TOFTOFTestdata', 'TOFTOFTestdata2']
Monitor counts for 1st workspace: 136935
Monitor counts for 2nd workspace: 145145
- Monitor counts for merged workspaces = sum over all workspaces: 282080
+ Monitor counts for merged workspaces = sum over all workspaces: 282080
**Example - Merge group of workspaces**
@@ -124,8 +125,9 @@ Output:
ws2 = LoadMLZ(Filename='TOFTOFTestdata.nxs')
# change sample logs for a second workspace, not needed for real workspaces
+ AddSampleLog(ws1, 'temperature', str(294.14), 'Number')
lognames = 'temperature,run_start,run_end,monitor_counts,run_number'
- logvalues = '296.15,2013-07-28T11:32:19+0053,2013-07-28T12:32:19+0053,145145,TOFTOFTestdata2'
+ logvalues = '296.16,2013-07-28T11:32:19+0053,2013-07-28T12:32:19+0053,145145,TOFTOFTestdata2'
AddSampleLogMultiple(ws2, lognames, logvalues)
group=GroupWorkspaces('ws1,ws2')