def test_LoadPRFFile(self):
""" Test to load a .prf file
"""
# 1. Create test .prf file
prffilename = "test.prf"
self._createPrfFile(prffilename)
# 2. Execute the algorithm
alg_test = run_algorithm("LoadFullprofFile",
Filename = prffilename,
OutputWorkspace = "Data",
PeakParameterWorkspace = "Info")
self.assertTrue(alg_test.isExecuted())
# 3. Check data
dataws = AnalysisDataService.retrieve("Data")
self.assertEqual(dataws.getNumberHistograms(), 4)
self.assertEqual(len(dataws.readX(0)), 36)
# value
self.assertEqual(dataws.readX(0)[13], 5026.3223)
self.assertEqual(dataws.readY(1)[30], 0.3819)
# 4. Clean
os.remove(prffilename)
AnalysisDataService.remove("Data")
AnalysisDataService.remove("Info")
return
def test_setTitle(self):
run_algorithm('CreateWorkspace', OutputWorkspace='ws1',DataX=[1.,2.,3.], DataY=[2.,3.], DataE=[2.,3.],UnitX='TOF')
ws1 = AnalysisDataService['ws1']
title = 'test_title'
ws1.setTitle(title)
self.assertEquals(title, ws1.getTitle())
AnalysisDataService.remove(ws1.getName())
def test_LoadHKLFile(self):
""" Test to load a .hkl file
"""
# 1. Create a test file
hklfilename = "test.hkl"
self._createHKLFile(hklfilename)
# 2.
alg_test = run_algorithm("LoadFullprofFile", Filename = hklfilename,
OutputWorkspace = "Foo", PeakParameterWorkspace = "PeakParameterTable")
self.assertTrue(alg_test.isExecuted())
# 3. Verify some values
tablews = AnalysisDataService.retrieve("PeakParameterTable")
self.assertEqual(4, tablews.rowCount())
# alpha of (11 5 1)/Row 0
self.assertEqual(0.34252, tablews.cell(0, 3))
# 4. Delete the test hkl file
os.remove(hklfilename)
AnalysisDataService.remove("PeakParameterTable")
AnalysisDataService.remove("Foo")
return
def test_batch_reduction_on_multiperiod_file(self):
# Arrange
# Build the data information
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("SANS2D0005512")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info)
user_file_director.set_user_file("MASKSANS2Doptions.091A")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB)
state = user_file_director.construct()
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = ["5512p1rear_1D_2.0_14.0Phi-45.0_45.0", "5512p2rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p3rear_1D_2.0_14.0Phi-45.0_45.0", "5512p4rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p5rear_1D_2.0_14.0Phi-45.0_45.0", "5512p6rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p7rear_1D_2.0_14.0Phi-45.0_45.0", "5512p8rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p9rear_1D_2.0_14.0Phi-45.0_45.0", "5512p10rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p11rear_1D_2.0_14.0Phi-45.0_45.0", "5512p12rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p13rear_1D_2.0_14.0Phi-45.0_45.0"]
for element in expected_workspaces:
self.assertTrue(AnalysisDataService.doesExist(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def test_removing_from_ads_calls_any_change_handle(self):
CreateSampleWorkspace(OutputWorkspace="ws1")
self.project.anyChangeHandle = mock.MagicMock()
ADS.remove("ws1")
self.assertEqual(1, self.project.anyChangeHandle.call_count)
def test_saveGSS(self):
""" Test to Save a GSAS file to match V-drive
"""
# Create a test data file and workspace
binfilename = "testbin.dat"
self._createBinFile(binfilename)
datawsname = "TestInputWorkspace"
self._createDataWorkspace(datawsname)
# Execute
alg_test = run_algorithm("SaveVulcanGSS",
InputWorkspace = datawsname,
BinFilename = binfilename,
OutputWorkspace = datawsname+"_rebinned",
GSSFilename = "tempout.gda")
self.assertTrue(alg_test.isExecuted())
# Verify ....
outputws = AnalysisDataService.retrieve(datawsname+"_rebinned")
#self.assertEqual(4, tablews.rowCount())
# Delete the test hkl file
os.remove(binfilename)
AnalysisDataService.remove("InputWorkspace")
AnalysisDataService.remove(datawsname+"_rebinned")
return
def test_exportFileNew(self):
""" Test to export logs without header file
"""
# Generate the matrix workspace with some logs
ws = self.createTestWorkspace()
AnalysisDataService.addOrReplace("TestMatrixWS", ws)
# Test algorithm
alg_test = run_algorithm("ExportExperimentLog",
InputWorkspace = "TestMatrixWS",
OutputFilename = "TestRecord001.txt",
SampleLogNames = ["run_number", "duration", "proton_charge", "proton_charge", "proton_charge"],
SampleLogTitles = ["RUN", "Duration", "ProtonCharge", "MinPCharge", "MeanPCharge"],
SampleLogOperation = [None, None, "sum", "min", "average"],
FileMode = "new")
# Validate
self.assertTrue(alg_test.isExecuted())
# Locate file
outfilename = alg_test.getProperty("OutputFilename").value
try:
ifile = open(outfilename)
lines = ifile.readlines()
ifile.close()
except IOError as err:
print("Unable to open file {0}.".format(outfilename))
self.assertTrue(False)
return
# Last line cannot be empty, i.e., before EOF '\n' is not allowed
lastline = lines[-1]
self.assertTrue(len(lastline.strip()) > 0)
# Number of lines
self.assertEquals(len(lines), 2)
# Check line
firstdataline = lines[1]
terms = firstdataline.strip().split("\t")
self.assertEquals(len(terms), 5)
# Get property
pchargelog = ws.getRun().getProperty("proton_charge").value
sumpcharge = numpy.sum(pchargelog)
minpcharge = numpy.min(pchargelog)
avgpcharge = numpy.average(pchargelog)
v2 = float(terms[2])
self.assertAlmostEqual(sumpcharge, v2)
v3 = float(terms[3])
self.assertAlmostEqual(minpcharge, v3)
v4 = float(terms[4])
self.assertAlmostEqual(avgpcharge, v4)
# Remove generated files
os.remove(outfilename)
AnalysisDataService.remove("TestMatrixWS")
return
def test_len_increases_when_item_added(self):
wsname = 'ADSTest_test_len_increases_when_item_added'
current_len = len(AnalysisDataService)
self._run_createws(wsname)
self.assertEquals(len(AnalysisDataService), current_len + 1)
# Remove to clean the test up
AnalysisDataService.remove(wsname)
def _determine_factors(self, q_high_angle, q_low_angle, mode, scale, shift):
# We need to make suret that the fitting only occurs in the y direction
constant_x_shift_and_scale = ', f0.Shift=0.0, f0.XScaling=1.0'
# Determine the StartQ and EndQ values
q_min, q_max = self._get_start_q_and_end_q_values(rear_data=q_low_angle, front_data=q_high_angle)
# We need to transfer the errors from the front data to the rear data, as we are using the the front data as a model, but
# we want to take into account the errors of both workspaces.
error_correction = ErrorTransferFromModelToData()
front_data_corrected, rear_data_corrected = error_correction.get_error_corrected(rear_data=q_low_angle,
front_data=q_high_angle,
q_min=q_min, q_max=q_max)
fit = self.createChildAlgorithm('Fit')
# We currently have to put the front_data into the ADS so that the TabulatedFunction has access to it
front_data_corrected = AnalysisDataService.addOrReplace('front_data_corrected', front_data_corrected)
front_in_ads = AnalysisDataService.retrieve('front_data_corrected')
function = 'name=TabulatedFunction, Workspace="' + str(
front_in_ads.name()) + '"' + ";name=FlatBackground"
fit.setProperty('Function', function)
fit.setProperty('InputWorkspace', rear_data_corrected)
constant_x_shift_and_scale = 'f0.Shift=0.0, f0.XScaling=1.0'
if mode == Mode.BothFit:
fit.setProperty('Ties', constant_x_shift_and_scale)
elif mode == Mode.ShiftOnly:
fit.setProperty('Ties', 'f0.Scaling=' + str(scale) + ',' + constant_x_shift_and_scale)
elif mode == Mode.ScaleOnly:
fit.setProperty('Ties', 'f1.A0=' + str(shift) + '*f0.Scaling,' + constant_x_shift_and_scale)
else:
raise RuntimeError('Unknown fitting mode requested.')
fit.setProperty('StartX', q_min)
fit.setProperty('EndX', q_max)
fit.setProperty('CreateOutput', True)
fit.execute()
param = fit.getProperty('OutputParameters').value
AnalysisDataService.remove(front_in_ads.name())
# The outparameters are:
# 1. Scaling in y direction
# 2. Shift in x direction
# 3. Scaling in x direction
# 4. Shift in y direction
scale = param.row(0)['Value']
if scale == 0.0:
raise RuntimeError('Fit scaling as part of stitching evaluated to zero')
# In order to determine the shift, we need to remove the scale factor
shift = param.row(3)['Value'] / scale
return (shift, scale)
def test_exportFileAppend(self):
""" Test to export logs without header file
"""
# Generate the matrix workspace with some logs
ws = self.createTestWorkspace()
AnalysisDataService.addOrReplace("TestMatrixWS", ws)
# Test algorithm
# create new file
alg_test = run_algorithm("ExportExperimentLog",
InputWorkspace = "TestMatrixWS",
OutputFilename = "TestRecord.txt",
SampleLogNames = ["run_number", "duration", "proton_charge"],
SampleLogTitles = ["RUN", "Duration", "ProtonCharge"],
SampleLogOperation = [None, None, "sum"],
FileMode = "new")
# append
alg_test = run_algorithm("ExportExperimentLog",
InputWorkspace = "TestMatrixWS",
OutputFilename = "TestRecord.txt",
SampleLogNames = ["run_number", "duration", "proton_charge"],
SampleLogTitles = ["RUN", "Duration", "ProtonCharge"],
SampleLogOperation = [None, None, "sum"],
FileMode = "fastappend")
# Validate
self.assertTrue(alg_test.isExecuted())
# Locate file
outfilename = alg_test.getProperty("OutputFilename").value
try:
print "Output file is %s. " % (outfilename)
ifile = open(outfilename)
lines = ifile.readlines()
ifile.close()
except IOError as err:
print "Unable to open file %s. " % (outfilename)
self.assertTrue(False)
return
# Last line cannot be empty, i.e., before EOF '\n' is not allowed
lastline = lines[-1]
self.assertTrue(len(lastline.strip()) > 0)
# Number of lines
self.assertEquals(len(lines), 3)
# Check line
firstdataline = lines[1]
terms = firstdataline.strip().split("\t")
self.assertEquals(len(terms), 3)
#
# # Remove generated files
os.remove(outfilename)
AnalysisDataService.remove("TestMatrixWS")
return
def tearDown(self):
self.cleanup_names.append(self.wsname)
for name in self.cleanup_names:
try:
AnalysisDataService.remove(name)
except KeyError:
pass
self.cleanup_names = []
def test_observeDelete_calls_deleteHandle_when_set_on_ads_and_a_workspace_is_deleted(self):
CreateSampleWorkspace(OutputWorkspace="ws")
self.fake_class.observeDelete(True)
self.fake_class.deleteHandle = mock.MagicMock()
ADS.remove("ws")
self.assertEqual(self.fake_class.deleteHandle.call_count, 1)
def test_add_raises_error_if_name_exists(self):
data = [1.0,2.0,3.0]
alg = run_algorithm('CreateWorkspace',DataX=data,DataY=data,NSpec=1,UnitX='Wavelength', child=True)
name = "testws"
ws = alg.getProperty("OutputWorkspace").value
AnalysisDataService.addOrReplace(name, ws)
self.assertRaises(RuntimeError, AnalysisDataService.add, name, ws)
AnalysisDataService.remove(name)
def test_setTitleAndComment(self):
run_algorithm('CreateWorkspace', OutputWorkspace='ws1',DataX=[1.,2.,3.], DataY=[2.,3.], DataE=[2.,3.],UnitX='TOF')
ws1 = AnalysisDataService['ws1']
title = 'test_title'
ws1.setTitle(title)
self.assertEquals(title, ws1.getTitle())
comment = 'Some comment on this workspace.'
ws1.setComment(comment)
self.assertEquals(comment, ws1.getComment())
AnalysisDataService.remove(ws1.name())
def _load_param_file(self, inst_name):
InstrumentParameters.instrument_name = inst_name
if IS_IN_MANTIDPLOT:
idf_loc = config.getInstrumentDirectory()
idf_pattern = os.path.join(idf_loc, "%s_Definition*.xml") % inst_name
import glob
idf_files = glob.glob(idf_pattern)
emptyInst = LoadEmptyInstrument(Filename=str(idf_files[0]))
InstrumentParameters._instrument = emptyInst.getInstrument()
AnalysisDataService.remove(str(emptyInst)) # Don't need to keep workspace
def test_addOrReplace_replaces_workspace_with_existing_name(self):
data = [1.0,2.0,3.0]
alg = run_algorithm('CreateWorkspace',DataX=data,DataY=data,NSpec=1,UnitX='Wavelength', child=True)
name = "testws"
ws = alg.getProperty("OutputWorkspace").value
AnalysisDataService.add(name, ws)
len_before = len(AnalysisDataService)
AnalysisDataService.addOrReplace(name, ws)
len_after = len(AnalysisDataService)
self.assertEquals(len_after, len_before)
AnalysisDataService.remove(name)
def _deleteWorkspaces(self, workspaces):
"""
Deletes a list of workspaces if they exist but ignores any errors
@param workspaces: list of workspaces to try to delete
"""
for wk in workspaces:
try:
if AnalysisDataService.doesExist(wk):
AnalysisDataService.remove(wk)
except:
#if the workspace can't be deleted this function does nothing
pass
def test_exportUTC(self):
""" Test to export logs without header file
"""
import os
import os.path
# Generate the matrix workspace with some logs
ws = self.createTestWorkspace()
AnalysisDataService.addOrReplace("TestMatrixWS", ws)
# Test algorithm
alg_test = run_algorithm(
"ExportSampleLogsToCSVFile",
InputWorkspace="TestMatrixWS",
OutputFilename="furnace20339utc.txt",
SampleLogNames=["SensorA", "SensorB", "SensorC"],
WriteHeaderFile=True,
TimeZone="UTC",
Header="SensorA[K]\t SensorB[K]\t SensorC[K]",
)
# Validate
self.assertTrue(alg_test.isExecuted())
# Locate file
outfilename = alg_test.getProperty("OutputFilename").value
filepath = os.path.dirname(outfilename)
basename = os.path.basename(outfilename)
baseheadername = basename.split(".")[0] + "_header.txt"
headerfilename = os.path.join(filepath, baseheadername)
try:
ifile = open(headerfilename)
lines = ifile.readlines()
ifile.close()
except IOError as err:
errmsg = "Unable to open header file %s. " % (headerfilename)
self.assertEquals(errmsg, "")
return
# Count lines in the file
goodlines = 0
for line in lines:
line = line.strip()
if len(line) > 0:
goodlines += 1
self.assertEquals(goodlines, 3)
# Clean
os.remove(outfilename)
os.remove(headerfilename)
AnalysisDataService.remove("TestMatrixWS")
return
def test_that_a_histogram_workspace_is_returned_as_a_MatrixWorkspace_from_ADS(self):
wsname = "MatrixWorkspaceTest_ADS"
AnalysisDataService.add(wsname, self._test_ws)
value = AnalysisDataService[wsname]
self.assertTrue(isinstance(value, Workspace))
# Have got a MatrixWorkspace back and not just the generic interface
self.assertTrue(isinstance(value, MatrixWorkspace))
mem = value.getMemorySize()
self.assertTrue((mem > 0))
AnalysisDataService.remove(wsname)
def test_history_access(self):
run_algorithm('CreateWorkspace', OutputWorkspace='raw',DataX=[1.,2.,3.], DataY=[2.,3.], DataE=[2.,3.],UnitX='TOF')
run_algorithm('Rebin', InputWorkspace='raw', Params=[1.,0.5,3.],OutputWorkspace='raw')
raw = AnalysisDataService['raw']
history = raw.getHistory()
last = history.lastAlgorithm()
self.assertEquals(last.name(), "Rebin")
self.assertEquals(last.getPropertyValue("InputWorkspace"), "raw")
first = history[0]
self.assertEquals(first.name(), "CreateWorkspace")
self.assertEquals(first.getPropertyValue("OutputWorkspace"), "raw")
AnalysisDataService.remove('raw')
def test_batch_reduction_on_time_sliced_file(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information("SANS2D00034484")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00034484")
data_builder.set_sample_transmission("SANS2D00034505")
data_builder.set_sample_direct("SANS2D00034461")
data_builder.set_can_scatter("SANS2D00034481")
data_builder.set_can_transmission("SANS2D00034502")
data_builder.set_can_direct("SANS2D00034461")
data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file("USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY BEGIN -- Remove when appropriate
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Since we are dealing with event based data but we want to compare it with histogram data from the
# old reduction system we need to enable the compatibility mode
user_file_director.set_compatibility_builder_use_compatibility_mode(True)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY END
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
user_file_director.set_slice_event_builder_start_time([1.0,3.0])
user_file_director.set_slice_event_builder_end_time([3.0,5.0])
state = user_file_director.construct()
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
expected_workspaces = ["34484rear_1D_1.75_16.5_t1.00_T3.00", "34484rear_1D_1.75_16.5_t3.00_T5.00"]
reference_file_names = ["SANS2D_event_slice_referance_t1.00_T3.00.nxs", "SANS2D_event_slice_referance_t3.00_T5.00.nxs"]
for element, reference_file in zip(expected_workspaces, reference_file_names):
self.assertTrue(AnalysisDataService.doesExist(element))
# Evaluate it up to a defined point
self._compare_workspace(element, reference_file)
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def test_batch_reduction_on_period_time_sliced_wavelength_range_data(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information("SANS2D0005512")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D0005512")
data_builder.set_sample_scatter_period(1)
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file("MASKSANS2Doptions.091A")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB)
user_file_director.set_slice_event_builder_start_time([1.0, 3.0])
user_file_director.set_slice_event_builder_end_time([3.0, 5.0])
state = user_file_director.construct()
start = [1.0, 1.0]
end = [3.0, 2.0]
state.wavelength.wavelength_low = start
state.wavelength.wavelength_high = end
state.adjustment.normalize_to_monitor.wavelength_low = start
state.adjustment.normalize_to_monitor.wavelength_high = end
state.adjustment.calculate_transmission.wavelength_low = start
state.adjustment.calculate_transmission.wavelength_high = end
state.adjustment.wavelength_and_pixel_adjustment.wavelength_low = start
state.adjustment.wavelength_and_pixel_adjustment.wavelength_high = end
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = ["5512p1rear_1D_1.0_2.0Phi-45.0_45.0_t1.00_T3.00", "5512p1rear_1D_1.0_2.0Phi-45.0_45.0_t3.00_T5.00",
"5512p1rear_1D_1.0_3.0Phi-45.0_45.0_t1.00_T3.00", "5512p1rear_1D_1.0_3.0Phi-45.0_45.0_t3.00_T5.00"
]
for element in expected_workspaces:
self.assertTrue(AnalysisDataService.doesExist(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def _removeWorkspace(workspace_name):
"""Remove the workspace with the given name, including any child workspaces if it
is a group. If a corresponding monitors workspace exists, remove that too."""
if AnalysisDataService.doesExist(workspace_name):
workspace = AnalysisDataService.retrieve(workspace_name)
if isinstance(workspace, WorkspaceGroup):
# Remove child workspaces first
while workspace.getNumberOfEntries():
_removeWorkspace(workspace[0].name())
AnalysisDataService.remove(workspace_name)
# If a corresponding monitors workspace also exists, remove that too
if AnalysisDataService.doesExist(_monitorWorkspace(workspace_name)):
_removeWorkspace(_monitorWorkspace(workspace_name))
def test_key_operator_does_same_as_retrieve(self):
wsname = 'ADSTest_test_key_operator_does_same_as_retrieve'
self._run_createws(wsname)
ws_from_op = AnalysisDataService[wsname]
ws_from_method = AnalysisDataService.retrieve(wsname)
self.do_check_for_matrix_workspace_type(ws_from_op)
self.do_check_for_matrix_workspace_type(ws_from_method)
self.assertEquals(ws_from_op.name(), ws_from_method.name())
self.assertEquals(ws_from_op.getMemorySize(), ws_from_method.getMemorySize())
# Remove to clean the test up
AnalysisDataService.remove(wsname)
def test_exportFileMissingLog(self):
""" Test to export logs without header file
"""
# Generate the matrix workspace with some logs
ws = self.createTestWorkspace()
AnalysisDataService.addOrReplace("TestMatrixWS", ws)
# Test algorithm
alg_test = run_algorithm(
"ExportSampleLogsToCSVFile",
InputWorkspace="TestMatrixWS",
OutputFilename="furnace20335.txt",
SampleLogNames=["SensorA", "SensorB", "SensorX", "SensorC"],
WriteHeaderFile=False,
)
# Validate
self.assertTrue(alg_test.isExecuted())
# Locate file
outfilename = alg_test.getProperty("OutputFilename").value
try:
ifile = open(outfilename)
lines = ifile.readlines()
ifile.close()
except IOError as err:
print "Unable to open file %s. " % (outfilename)
self.assertTrue(False)
return
# Count lines in the file
goodlines = 0
for line in lines:
line = line.strip()
if len(line) > 0:
goodlines += 1
self.assertEquals(goodlines, 25)
# Check values
line0 = lines[0]
terms = line0.split()
self.assertEquals(len(terms), 6)
value2 = float(terms[4])
self.assertEquals(value2, 0.0)
# Clean
os.remove(outfilename)
AnalysisDataService.remove("TestMatrixWS")
return
def _mask_to_roi(self, ws_mask):
# invert mask and then extract "masked" detectors in order to get ROI
# BUG in Mantid forces us to use AnalysisDataService
alg = AlgorithmManager.create("InvertMask")
alg.initialize()
alg.setProperty("InputWorkspace", ws_mask)
alg.setPropertyValue("OutputWorkspace", "_ws")
alg.execute()
ws_tranmskinv = AnalysisDataService.retrieve("_ws")
alg = self.createChildAlgorithm("ExtractMask")
alg.setProperty("InputWorkspace", ws_tranmskinv)
alg.execute()
AnalysisDataService.remove("_ws")
return alg.getProperty("DetectorList").value
def test_exportFileAndHeader(self):
""" Test to export logs without header file
"""
import os
import os.path
# Generate the matrix workspace with some logs
ws = self.createTestWorkspace()
AnalysisDataService.addOrReplace("TestMatrixWS", ws)
# Test algorithm
alg_test = run_algorithm(
"ExportSampleLogsToCSVFile",
InputWorkspace="TestMatrixWS",
OutputFilename="furnace20339.txt",
SampleLogNames=["SensorA", "SensorB", "SensorC"],
WriteHeaderFile=True,
Header="SensorA[K]\t SensorB[K]\t SensorC[K]")
# Validate
self.assertTrue(alg_test.isExecuted())
# Locate file
outfilename = alg_test.getProperty("OutputFilename").value
filepath = os.path.dirname(outfilename)
basename = os.path.basename(outfilename)
baseheadername = basename.split(".")[0] + "_header.txt"
headerfilename = os.path.join(filepath, baseheadername)
try:
ifile = open(headerfilename)
lines = ifile.readlines()
ifile.close()
except IOError as err:
errmsg = "Unable to open header file %s. " % (headerfilename)
self.assertEquals(errmsg, "")
return
# Count lines in the file
goodlines = 0
for line in lines:
line = line.strip()
if len(line) > 0:
goodlines += 1
self.assertEquals(goodlines, 3)
# Clean
os.remove(outfilename)
os.remove(headerfilename)
AnalysisDataService.remove("TestMatrixWS")
return
def test_LoadMultipleGSSTest(self):
# Set up
alg_test = run_algorithm("LoadMultipleGSS",
FilePrefix = "PG3",
RunNumbers = [11485,11486],
Directory = "")
# Execute
self.assertTrue(alg_test.isExecuted())
# just make sure there are output workspaces then delete them
for name in ["PG3_11485", "PG3_11486"]:
wksp = AnalysisDataService.retrieve(name)
self.assertTrue(wksp is not None)
AnalysisDataService.remove(name)
def test_that_a_histogram_workspace_is_returned_as_a_MatrixWorkspace_from_a_property(self):
wsname = "MatrixWorkspaceTest_Property"
AnalysisDataService.add(wsname, self._test_ws)
alg = create_algorithm("Rebin", InputWorkspace=wsname)
propValue = alg.getProperty("InputWorkspace").value
# Is Workspace in the hierarchy of the value
self.assertTrue(isinstance(propValue, Workspace))
# Have got a MatrixWorkspace back and not just the generic interface
self.assertTrue(isinstance(propValue, MatrixWorkspace))
mem = propValue.getMemorySize()
self.assertTrue((mem > 0))
AnalysisDataService.remove(wsname)
def test_that_a_histogram_workspace_is_returned_as_a_MatrixWorkspace_from_a_property(self):
wsname = "MatrixWorkspaceTest_Property"
AnalysisDataService.add(wsname, self._test_ws)
alg = create_algorithm("Rebin", InputWorkspace=wsname)
propValue = alg.getProperty("InputWorkspace").value
# Is Workspace in the hierarchy of the value
self.assertTrue(isinstance(propValue, Workspace))
# Have got a MatrixWorkspace back and not just the generic interface
self.assertTrue(isinstance(propValue, MatrixWorkspace))
mem = propValue.getMemorySize()
self.assertGreater(mem, 0)
AnalysisDataService.remove(wsname)
def test_nomad_no_mins(self):
api.LoadNexusProcessed(Filename='NOM_91796_banks.nxs', OutputWorkspace='NOM_91796_banks')
alg_test = run_algorithm('CropWorkspaceRagged',
InputWorkspace='NOM_91796_banks', OutputWorkspace='NOM_91796_banks',
XMax=[10.20, 20.8, np_inf, math_nan, np_nan, 9.35])
self.assertTrue(alg_test.isExecuted())
# Verify ....
outputws = AnalysisDataService.retrieve('NOM_91796_banks')
for i, Xlen in enumerate([511,1041,2001,2001,2001,468]): # larger than in test_nomad_inplace
self.assertEqual(len(outputws.readX(i)), Xlen)
AnalysisDataService.remove('NOM_91796_banks')
def test_batch_reduction_on_period_time_sliced_wavelength_range_data(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D0005512")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D0005512")
data_builder.set_sample_scatter_period(1)
data_info = data_builder.build()
# Get the rest of the state from the user file
user_filename = "MASKSANS2Doptions.091A"
user_file_director = UserFileReaderAdapter(
file_information=file_information, user_file_name=user_filename)
state = user_file_director.get_all_states(
file_information=file_information)
# Set the reduction mode to LAB
state.reduction.reduction_mode = ReductionMode.LAB
state.data = data_info
state.slice.start_time = [1.0, 3.0]
state.slice.end_time = [3.0, 5.0]
selected_range = [(1.0, 2.0), (1.0, 3.0)]
state.wavelength.wavelength_interval.selected_ranges = selected_range
state.adjustment.calculate_transmission.wavelength_interval.selected_ranges = selected_range
state.adjustment.wavelength_and_pixel_adjustment.wavelength_interval.selected_ranges = selected_range
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = [
"5512_p1rear_1D_1.0_2.0Phi-45.0_45.0_t1.00_T3.00",
"5512_p1rear_1D_1.0_2.0Phi-45.0_45.0_t3.00_T5.00",
"5512_p1rear_1D_1.0_3.0Phi-45.0_45.0_t1.00_T3.00",
"5512_p1rear_1D_1.0_3.0Phi-45.0_45.0_t3.00_T5.00"
]
for element in expected_workspaces:
self.assertTrue(AnalysisDataService.doesExist(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def test_exportFileMissingLog(self):
""" Test to export logs without header file
"""
# Generate the matrix workspace with some logs
ws = self.createTestWorkspace()
AnalysisDataService.addOrReplace("TestMatrixWS", ws)
# Test algorithm
alg_test = run_algorithm(
"ExportSampleLogsToCSVFile",
InputWorkspace="TestMatrixWS",
OutputFilename="furnace20335.txt",
SampleLogNames=["SensorA", "SensorB", "SensorX", "SensorC"],
WriteHeaderFile=False)
# Validate
self.assertTrue(alg_test.isExecuted())
# Locate file
outfilename = alg_test.getProperty("OutputFilename").value
try:
ifile = open(outfilename)
lines = ifile.readlines()
ifile.close()
except IOError as err:
print("Unable to open file {0}.".format(outfilename))
self.assertTrue(False)
return
# Count lines in the file
goodlines = 0
for line in lines:
line = line.strip()
if len(line) > 0:
goodlines += 1
self.assertEquals(goodlines, 25)
# Check values
line0 = lines[0]
terms = line0.split()
self.assertEquals(len(terms), 6)
value2 = float(terms[4])
self.assertEquals(value2, 0.)
# Clean
os.remove(outfilename)
AnalysisDataService.remove("TestMatrixWS")
return
def test_nomad_inplace(self):
api.LoadNexusProcessed(Filename='NOM_91796_banks.nxs', OutputWorkspace='NOM_91796_banks')
alg_test = run_algorithm('CropWorkspaceRagged',
InputWorkspace='NOM_91796_banks', OutputWorkspace='NOM_91796_banks',
XMin=[0.67, 1.20, 2.42, 3.70, 4.12, 0.39],
XMax=[10.20, 20.8, np_nan, math_nan, np_nan, 9.35])
self.assertTrue(alg_test.isExecuted())
# Verify ....
outputws = AnalysisDataService.retrieve('NOM_91796_banks')
for i, Xlen in enumerate([477,981,1880,1816,1795,448]):
self.assertEqual(len(outputws.readX(i)), Xlen)
AnalysisDataService.remove('NOM_91796_banks')
def test_key_operator_does_same_as_retrieve(self):
wsname = 'ADSTest_test_key_operator_does_same_as_retrieve'
self._run_createws(wsname)
ws_from_op = AnalysisDataService[wsname]
ws_from_method = AnalysisDataService.retrieve(wsname)
self.do_check_for_matrix_workspace_type(ws_from_op)
self.do_check_for_matrix_workspace_type(ws_from_method)
self.assertEquals(ws_from_op.name(), ws_from_method.name())
self.assertEquals(ws_from_op.getMemorySize(),
ws_from_method.getMemorySize())
# Remove to clean the test up
AnalysisDataService.remove(wsname)
def test_setTitleAndComment(self):
run_algorithm('CreateWorkspace',
OutputWorkspace='ws1',
DataX=[1., 2., 3.],
DataY=[2., 3.],
DataE=[2., 3.],
UnitX='TOF')
ws1 = AnalysisDataService['ws1']
title = 'test_title'
ws1.setTitle(title)
self.assertEqual(title, ws1.getTitle())
comment = 'Some comment on this workspace.'
ws1.setComment(comment)
self.assertEqual(comment, ws1.getComment())
AnalysisDataService.remove(ws1.name())
def test_addOrReplace_replaces_workspace_with_existing_name(self):
data = [1.0, 2.0, 3.0]
alg = run_algorithm('CreateWorkspace',
DataX=data,
DataY=data,
NSpec=1,
UnitX='Wavelength',
child=True)
name = "testws"
ws = alg.getProperty("OutputWorkspace").value
AnalysisDataService.add(name, ws)
len_before = len(AnalysisDataService)
AnalysisDataService.addOrReplace(name, ws)
len_after = len(AnalysisDataService)
self.assertEquals(len_after, len_before)
AnalysisDataService.remove(name)
def test_removing_item_invalidates_extracted_handles(self):
# If a reference to a DataItem has been extracted from the ADS
# and it is then removed. The extracted handle should no longer
# be able to access the DataItem
wsname = 'ADSTest_test_removing_item_invalidates_extracted_handles'
self._run_createws(wsname)
ws_handle = AnalysisDataService[wsname]
succeeded = False
try:
ws_handle.id() # Should be okay
succeeded = True
except RuntimeError:
pass
self.assertTrue(succeeded, "DataItem handle should be valid and allow function calls")
AnalysisDataService.remove(wsname)
self.assertRaises(RuntimeError, ws_handle.id)
def test_batch_reduction_on_multiperiod_file(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D0005512")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D0005512")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file("MASKSANS2Doptions.091A")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(
ISISReductionMode.LAB)
state = user_file_director.construct()
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = [
"5512p1rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p2rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p3rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p4rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p5rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p6rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p7rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p8rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p9rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p10rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p11rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p12rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p13rear_1D_2.0_14.0Phi-45.0_45.0"
]
for element in expected_workspaces:
self.assertTrue(AnalysisDataService.doesExist(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def test_that_batch_reduction_evaluates_LAB(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D00034484")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00034484")
data_builder.set_sample_transmission("SANS2D00034505")
data_builder.set_sample_direct("SANS2D00034461")
data_builder.set_can_scatter("SANS2D00034481")
data_builder.set_can_transmission("SANS2D00034502")
data_builder.set_can_direct("SANS2D00034461")
data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs")
data_info = data_builder.build()
user_filename = "USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt"
user_file_director = StateBuilder.new_instance(
file_information=file_information,
data_information=data_info,
user_filename=user_filename)
# Get the rest of the state from the user file
state = user_file_director.get_all_states()
# Set the reduction mode to LAB
state.reduction.reduction_mode = ReductionMode.LAB
# Since we are dealing with event based data but we want to compare it with histogram data from the
# old reduction system we need to enable the compatibility mode
state.compatibility.use_compatibility_mode = True # COMPATIBILITY BEGIN -- Remove when appropriate
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
workspace_name = "34484_rear_1D_1.75_16.5"
output_workspace = AnalysisDataService.retrieve(workspace_name)
# Evaluate it up to a defined point
reference_file_name = "SANS2D_ws_D20_reference_LAB_1D.nxs"
self._compare_workspace(output_workspace, reference_file_name)
if AnalysisDataService.doesExist(workspace_name):
AnalysisDataService.remove(workspace_name)
def calculate(self, reducer, wave_wksps=[]):
"""
Multiplies all the wavelength scalings into one workspace and all the detector
dependent scalings into another workspace that can be used by ConvertToQ. It is important
that the wavelength correction workspaces have a know distribution/non-distribution state
@param reducer: settings used for this reduction
@param wave_wksps: additional wavelength dependent correction workspaces to include
"""
for step in self._wave_steps:
if step.output_wksp:
wave_wksps.append(step.output_wksp)
wave_adj = None
for wksp in wave_wksps:
# before the workspaces can be combined they all need to match
api.RebinToWorkspace(WorkspaceToRebin=wksp,
WorkspaceToMatch=reducer.output_wksp,
OutputWorkspace=self.TMP_WORKSPACE_NAME)
if not wave_adj:
# first time around this loop
wave_adj = self.WAVE_CORR_NAME
api.RenameWorkspace(InputWorkspace=self.TMP_WORKSPACE_NAME,
OutputWorkspace=wave_adj)
else:
api.Multiply(LHSWorkspace=self.TMP_WORKSPACE_NAME,
RHSWorkspace=wave_adj,
OutputWorkspace=wave_adj)
# read pixel correction file
# note the python code below is an attempt to emulate function overloading
# If a derived class overwrite self._load and self._load_params then
# a custom specific loading can be achieved
pixel_adj = ''
if self._pixel_file:
pixel_adj = self.PIXEL_CORR_NAME
load_com = self._load + '(Filename="' + self._pixel_file + '",OutputWorkspace="' + pixel_adj + '"'
if self._load_params:
load_com += ',' + self._load_params
load_com += ')'
eval(load_com)
if AnalysisDataService.doesExist(self.TMP_WORKSPACE_NAME):
AnalysisDataService.remove(self.TMP_WORKSPACE_NAME)
return wave_adj, pixel_adj
def test_genHKLList(self):
""" Test to load a .hkl file
"""
# Set up
alg_test = run_algorithm("CreateLeBailFitInput",
ReflectionsFile="",
MaxHKL="12,12,12",
FullprofParameterFile="2011B_HR60b2.irf",
Bank=2,
LatticeConstant=4.66,
GenerateBraggReflections=True,
InstrumentParameterWorkspace="PG3_Bank2_Foo2",
BraggPeakParameterWorkspace="Arb_Peaks")
# Execute
self.assertTrue(alg_test.isExecuted())
# Verify some values
# Profile parameter workspace
paramws = AnalysisDataService.retrieve("PG3_Bank2_Foo2")
paramname0 = paramws.cell(0, 0)
if paramname0.lower() == "bank":
numrowgood = 28
else:
numrowgood = 27
#print "Parameter name of first line = ", paramname0
#self.assertEqual(numrowgood, paramws.rowCount())
paramnames = []
for i in range(paramws.rowCount()):
paramname = paramws.cell(i, 0)
paramnames.append(paramname)
self.assertEqual(paramnames.count("LatticeConstant"), 1)
# Bragg peak list
braggws = AnalysisDataService.retrieve("Arb_Peaks")
self.assertEqual(braggws.rowCount() > 20, True)
# 4. Delete the test hkl file
AnalysisDataService.remove("PG3_Bank2_Foo2")
AnalysisDataService.remove("Arb_Peaks")
return
def test_retrieve_workspaces_uses_weak_ptrs(self):
ws_names = ["test_retrieve_workspaces_1", "test_retrieve_workspaces_2"]
for name in ws_names:
self._run_createws(name)
workspaces = AnalysisDataService.retrieveWorkspaces(ws_names)
self.assertEqual(len(workspaces), 2)
AnalysisDataService.remove(ws_names[0])
# even though workspace has been deleted this should not affect workspaces size
self.assertEqual(len(workspaces), 2)
# check that the second workspace pointer in workspaces exists and can be used
str(workspaces[1])
# if a weak pointer has been used we expect a RuntimeError. Any other pointer will result in a different error
with self.assertRaises(RuntimeError):
str(workspaces[0])
def test_exportFile2(self):
""" Get a partial of real load frame log values, and set them to
different logs
"""
# Generate the matrix workspace with some logs
ws = self.createTestWorkspace2()
AnalysisDataService.addOrReplace("TestMatrixWS2", ws)
# Test algorithm
alg_test = run_algorithm(
"ExportSampleLogsToCSVFile",
InputWorkspace="TestMatrixWS2",
OutputFilename="furnace20334.txt",
SampleLogNames=["SensorA", "SensorB", "SensorC", "SensorD"],
WriteHeaderFile=False,
TimeTolerance=1.0)
# Validate
self.assertTrue(alg_test.isExecuted())
# Locate file
outfilename = alg_test.getProperty("OutputFilename").value
try:
ifile = open(outfilename)
lines = ifile.readlines()
ifile.close()
except IOError as err:
print("Unable to open file {0}.".format(outfilename))
self.assertTrue(False)
return
# Count lines in the file
goodlines = 0
for line in lines:
line = line.strip()
if len(line) > 0 and len(
line.split()) == 6 and line.startswith('76130'):
goodlines += 1
self.assertEquals(goodlines, 64)
# Remove generated files
os.remove(outfilename)
AnalysisDataService.remove("TestMatrixWS2")
return
def test_nomad_inplace(self):
api.LoadNexusProcessed(Filename='NOM_91796_banks.nxs',
OutputWorkspace='NOM_91796_banks')
alg_test = run_algorithm(
'CropWorkspaceRagged',
InputWorkspace='NOM_91796_banks',
OutputWorkspace='NOM_91796_banks',
XMin=[0.67, 1.20, 2.42, 3.70, 4.12, 0.39],
XMax=[10.20, 20.8, np_nan, math_nan, np_nan, 9.35])
self.assertTrue(alg_test.isExecuted())
# Verify ....
outputws = AnalysisDataService.retrieve('NOM_91796_banks')
for i, Xlen in enumerate([477, 981, 1880, 1816, 1795, 448]):
self.assertEqual(len(outputws.readX(i)), Xlen)
AnalysisDataService.remove('NOM_91796_banks')
def test_nomad_no_mins(self):
api.LoadNexusProcessed(Filename='NOM_91796_banks.nxs',
OutputWorkspace='NOM_91796_banks')
alg_test = run_algorithm(
'CropWorkspaceRagged',
InputWorkspace='NOM_91796_banks',
OutputWorkspace='NOM_91796_banks',
XMax=[10.20, 20.8, np_inf, math_nan, np_nan, 9.35])
self.assertTrue(alg_test.isExecuted())
# Verify ....
outputws = AnalysisDataService.retrieve('NOM_91796_banks')
for i, Xlen in enumerate([511, 1041, 2001, 2001, 2001,
468]): # larger than in test_nomad_inplace
self.assertEqual(len(outputws.readX(i)), Xlen)
AnalysisDataService.remove('NOM_91796_banks')
def test_create_with_2D_numpy_array(self):
x = np.array([1., 2., 3., 4.])
y = np.array([[1., 2., 3.], [4., 5., 6.]])
e = np.sqrt(y)
wksp = CreateWorkspace(DataX=x, DataY=y, DataE=e, NSpec=2, UnitX='TOF')
self.assertTrue(isinstance(wksp, MatrixWorkspace))
self.assertEqual(wksp.getNumberHistograms(), 2)
for i in [0, 1]:
for j in range(len(y[0])):
self.assertEqual(wksp.readY(i)[j], y[i][j])
self.assertEqual(wksp.readE(i)[j], e[i][j])
self.assertEqual(wksp.readX(i)[j], x[j])
# Last X value
self.assertEqual(wksp.readX(i)[len(x) - 1], x[len(x) - 1])
AnalysisDataService.remove("wksp")
def test_exportFileOnly(self):
""" Test to export logs without header file
"""
# Generate the matrix workspace with some logs
ws = self.createTestWorkspace()
AnalysisDataService.addOrReplace("TestMatrixWS", ws)
# Test algorithm
alg_test = run_algorithm(
"ExportSampleLogsToCSVFile",
InputWorkspace="TestMatrixWS",
OutputFilename="furnace20333.txt",
SampleLogNames=["SensorA", "SensorB", "SensorC"],
WriteHeaderFile=False)
# Validate
self.assertTrue(alg_test.isExecuted())
# Locate file
outfilename = alg_test.getProperty("OutputFilename").value
try:
ifile = open(outfilename)
lines = ifile.readlines()
ifile.close()
except IOError as err:
print("Unable to open file {0}.".format(outfilename))
self.fail()
return
# Count lines in the file
goodlines = 0
for line in lines:
line = line.strip()
if len(line) > 0:
goodlines += 1
# ENDIF
# ENDFOR
self.assertEqual(goodlines, 25)
# Remove generated files
os.remove(outfilename)
AnalysisDataService.remove("TestMatrixWS")
return
def test_nomad_no_mins(self):
api.LoadNexusProcessed(Filename="NOM_91796_banks.nxs",
OutputWorkspace="NOM_91796_banks")
alg_test = run_algorithm(
"RebinRagged",
InputWorkspace="NOM_91796_banks",
OutputWorkspace="NOM_91796_banks",
Delta=0.04, # double original data bin size
XMax=[10.20, 20.8, np_inf, math_nan, np_nan, 9.35])
self.assertTrue(alg_test.isExecuted())
# Verify ....
outputws = AnalysisDataService.retrieve("NOM_91796_banks")
for i, Xlen in enumerate([256, 521, 1001, 1001, 1001,
235]): # larger than in test_nomad_inplace
self.assertEqual(len(outputws.readX(i)), Xlen)
AnalysisDataService.remove("NOM_91796_banks")
def _collapse_workspace_groups(self, workspaces):
"""Given a list of workspaces, which themselves could be groups of workspaces,
return a new list of workspaces which are TOF"""
ungrouped_workspaces = set([])
delete_ws_group_flag = True
for ws_name in workspaces:
ws = AnalysisDataService.retrieve(ws_name)
if isinstance(ws, WorkspaceGroup):
ungrouped_workspaces = ungrouped_workspaces.union(
self._collapse_workspace_groups(ws.getNames()))
if delete_ws_group_flag is True:
AnalysisDataService.remove(ws_name)
else:
if (ws.getAxis(0).getUnit().unitID()) == 'TOF':
ungrouped_workspaces.add(ws_name)
else:
# Do not remove the workspace group from the ADS if a non-TOF workspace exists
delete_ws_group_flag = False
return ungrouped_workspaces
def test_nomad_inplace(self):
api.LoadNexusProcessed(Filename="NOM_91796_banks.nxs",
OutputWorkspace="NOM_91796_banks")
alg_test = run_algorithm(
"RebinRagged",
InputWorkspace="NOM_91796_banks",
OutputWorkspace="NOM_91796_banks",
XMin=[0.67, 1.20, 2.42, 3.70, 4.12, 0.39],
Delta=0.02, # original data bin size
XMax=[10.20, 20.8, np_nan, math_nan, np_nan, 9.35])
self.assertTrue(alg_test.isExecuted())
# Verify ....
outputws = AnalysisDataService.retrieve("NOM_91796_banks")
for i, Xlen in enumerate([478, 981, 1880, 1816, 1795, 449]):
self.assertEqual(len(outputws.readX(i)), Xlen)
AnalysisDataService.remove("NOM_91796_banks")
def test_success(self):
OutputWorkspaceName = "output_ws"
Inputws = "%s, %s" % (self._input_ws_base.name(), self._input_good.name())
alg_test = run_algorithm("TOFTOFMergeRuns",
InputWorkspaces=Inputws,
OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName)
run_out = wsoutput.getRun()
run_in = self._input_ws_base.getRun()
self.assertEqual(run_out.getLogData('wavelength').value, run_in.getLogData('wavelength').value)
self.assertEqual(run_out.getLogData('chopper_speed').value, run_in.getLogData('chopper_speed').value)
self.assertEqual(run_out.getLogData('chopper_ratio').value, run_in.getLogData('chopper_ratio').value)
self.assertEqual(run_out.getLogData('channel_width').value, run_in.getLogData('channel_width').value)
self.assertEqual(run_out.getLogData('Ei').value, run_in.getLogData('Ei').value)
self.assertEqual(run_out.getLogData('EPP').value, run_in.getLogData('EPP').value)
self.assertEqual(run_out.getLogData('proposal_number').value, run_in.getLogData('proposal_number').value)
self.assertEqual(run_out.getLogData('proposal_title').value, run_in.getLogData('proposal_title').value)
self.assertEqual(run_out.getLogData('mode').value, run_in.getLogData('mode').value)
self.assertEqual(run_out.getLogData('experiment_team').value, run_in.getLogData('experiment_team').value)
run_in_good = self._input_good.getRun()
self.assertEqual(run_out.getLogData('run_number').value,
str([run_in.getLogData('run_number').value, run_in_good.getLogData('run_number').value]))
self.assertEqual(run_out.getLogData('temperature').value, float(run_in.getLogData('temperature').value))
self.assertEqual(run_out.getLogData('duration').value,
float(run_in.getLogData('duration').value) + float(run_in_good.getLogData('duration').value))
self.assertEqual(run_out.getLogData('run_start').value, run_in.getLogData('run_start').value)
self.assertEqual(run_out.getLogData('run_end').value, run_in.getLogData('run_end').value)
self.assertEqual(run_out.getLogData('full_channels').value, run_in.getLogData('full_channels').value)
self.assertEqual(run_out.getLogData('monitor_counts').value, 2*int(run_in.getLogData('monitor_counts').value))
# Dimension output workspace
self.assertEqual(wsoutput.getNumberHistograms(), self._input_ws_base.getNumberHistograms())
self.assertEqual(wsoutput.blocksize(), self._input_ws_base.blocksize())
# check instrument
self.assertEqual(wsoutput.getInstrument().getName(), "TOFTOF")
AnalysisDataService.remove("output_ws")
def test_history_access(self):
run_algorithm('CreateWorkspace',
OutputWorkspace='raw',
DataX=[1., 2., 3.],
DataY=[2., 3.],
DataE=[2., 3.],
UnitX='TOF')
run_algorithm('Rebin',
InputWorkspace='raw',
Params=[1., 0.5, 3.],
OutputWorkspace='raw')
raw = AnalysisDataService['raw']
history = raw.getHistory()
last = history.lastAlgorithm()
self.assertEqual(last.name(), "Rebin")
self.assertEqual(last.getPropertyValue("InputWorkspace"), "raw")
first = history[0]
self.assertEqual(first.name(), "CreateWorkspace")
self.assertEqual(first.getPropertyValue("OutputWorkspace"), "raw")
AnalysisDataService.remove('raw')
def test_create_with_1D_numpy_array(self):
x = np.array([1., 2., 3., 4.])
y = np.array([1., 2., 3.])
e = np.sqrt(np.array([1., 2., 3.]))
wksp = CreateWorkspace(DataX=x, DataY=y, DataE=e, NSpec=1, UnitX='TOF')
self.assertTrue(isinstance(wksp, MatrixWorkspace))
self.assertEqual(wksp.getNumberHistograms(), 1)
self.assertEqual(len(wksp.readY(0)), len(y))
self.assertEqual(len(wksp.readX(0)), len(x))
self.assertEqual(len(wksp.readE(0)), len(e))
for index in range(len(y)):
self.assertEqual(wksp.readY(0)[index], y[index])
self.assertEqual(wksp.readE(0)[index], e[index])
self.assertEqual(wksp.readX(0)[index], x[index])
# Last X value
self.assertEqual(wksp.readX(0)[len(x) - 1], x[len(x) - 1])
AnalysisDataService.remove("wksp")
def test_failed(self):
"""
Failed tests because of missing keys or different values
"""
OutputWorkspaceName = "output_ws"
Inputws_badvalue = "%s, %s" % (self._input_ws_base.name(), self._input_bad_value.name())
self.assertRaises(RuntimeError,
run_algorithm, 'TOFTOFMergeRuns',
InputWorkspaces=Inputws_badvalue,
OutputWorkspace=OutputWorkspaceName,
rethrow=True)
Inputws_badentry = "%s, %s" % (self._input_ws_base.name(), self._input_bad_entry.name())
self.assertRaises(RuntimeError,
run_algorithm, 'TOFTOFMergeRuns',
InputWorkspaces=Inputws_badentry,
OutputWorkspace=OutputWorkspaceName,
rethrow=True)
if "output_ws" is not None:
AnalysisDataService.remove("output_ws")
def _clean_up(self, base_name, number_of_workspaces):
for index in range(1, number_of_workspaces + 1):
workspace_name = base_name + str(index)
monitor_name = workspace_name + "_monitors"
AnalysisDataService.remove(workspace_name)
AnalysisDataService.remove(monitor_name)
AnalysisDataService.remove("80tubeCalibration_18-04-2016_r9330-9335")
def test_batch_reduction_on_multiperiod_file(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D0005512")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D0005512")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_filename = "MASKSANS2Doptions.091A"
user_file_parser = StateBuilder.new_instance(
file_information=file_information,
data_information=data_info,
user_filename=user_filename)
state = user_file_parser.get_all_states()
# Set the reduction mode to LAB
state.reduction.reduction_mode = ReductionMode.LAB
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = [
"5512_p{0}rear_1D_2.0_14.0Phi-45.0_45.0".format(i)
for i in range(1, 14)
]
for element in expected_workspaces:
does_exist = AnalysisDataService.doesExist(element)
self.assertTrue(does_exist,
msg="{0} was not found".format(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def runTest(self):
UseCompatibilityMode()
LARMOR()
Set1D()
Detector("DetectorBench")
MaskFile('USER_LARMOR_151B_LarmorTeam_80tubes_BenchRot1p4_M4_r3699.txt')
Gravity(True)
AddRuns(('13065', '13065'), 'LARMOR', 'nxs', lowMem=True)
AssignSample('13065-add.nxs')
WavRangeReduction(2, 4, DefaultTrans)
# Clean up
for element in AnalysisDataService.getObjectNames():
if AnalysisDataService.doesExist(element) and element != "13065p1rear_1D_2.0_4.0":
AnalysisDataService.remove(element)
paths = [os.path.join(config['defaultsave.directory'], 'LARMOR00013065-add.nxs'),
os.path.join(config['defaultsave.directory'], 'SANS2D00013065.log')] # noqa
for path in paths:
if os.path.exists(path):
os.remove(path)
def cleanup(self, nf):
for iif in range(nf):
AnalysisDataService.remove('sim{0}'.format(iif))
AnalysisDataService.remove('targetW')
# Remove the fitting results, if present
for suffix in 'NormalisedCovarianceMatrix Parameters Workspace':
if mtd.doesExist('targetW_{0}'.format(suffix)):
AnalysisDataService.remove('targetW_{0}'.format(suffix))
def test_pickle_table_workspace(self):
from mantid.kernel import V3D
import pickle
table = TableWorkspace()
table.addColumn(type="int", name="index")
table.addColumn(type="str", name="value")
table.addColumn(type="V3D", name="position")
values = (1, '10', V3D(0, 0, 1))
table.addRow(values)
values = (2, '100', V3D(1, 0, 0))
table.addRow(values)
p = pickle.dumps(table)
table2 = pickle.loads(p)
self.assertEqual(table.toDict(), table2.toDict())
# Can we add it to the ADS
name = "test_pickle_table_workspace"
AnalysisDataService.add(name, table2)
self.assertTrue(name in AnalysisDataService)
AnalysisDataService.remove(name)
