def test_model_matrix(self):
model = SliceViewerModel(self.ws2d_histo)
self.assertEqual(model.get_ws(), self.ws2d_histo)
self.assertEqual(model.get_ws_type(), WS_TYPE.MATRIX)
dim_info = model.get_dim_info(0)
self.assertEqual(dim_info['minimum'], 10)
self.assertEqual(dim_info['maximum'], 30)
self.assertEqual(dim_info['number_of_bins'], 2)
self.assertAlmostEqual(dim_info['width'], 10)
self.assertEqual(dim_info['name'], 'Wavelength')
self.assertEqual(dim_info['units'], 'Angstrom')
self.assertEqual(dim_info['type'], 'MATRIX')
dim_infos = model.get_dimensions_info()
self.assertEqual(len(dim_infos), 2)
dim_info = dim_infos[1]
self.assertEqual(dim_info['minimum'], 4)
self.assertEqual(dim_info['maximum'], 8)
self.assertEqual(dim_info['number_of_bins'], 2)
self.assertAlmostEqual(dim_info['width'], 2)
self.assertEqual(dim_info['name'], 'Energy transfer')
self.assertEqual(dim_info['units'], 'meV')
self.assertEqual(dim_info['type'], 'MATRIX')
def assert_call_as_expected(exp_xmin, exp_xmax, exp_start_index, exp_end_index, transpose,
is_spectra):
mock_ws = _create_mock_matrixworkspace(x_axis=[10, 20, 30],
y_axis=[1, 2, 3, 4, 5],
distribution=False,
y_is_spectra=is_spectra)
mock_ws.name.return_value = 'mock_ws'
model = SliceViewerModel(mock_ws)
slicepoint, bin_params = MagicMock(), MagicMock()
help_msg = model.export_roi_to_workspace(slicepoint, bin_params,
((xmin, xmax), (ymin, ymax)), transpose)
self.assertEqual('ROI created: mock_ws_roi', help_msg)
if is_spectra:
self.assertEqual(2, mock_ws.getAxis(1).indexOfValue.call_count)
else:
mock_ws.getAxis(1).extractValues.assert_called_once()
mock_extract_spectra.assert_called_once_with(InputWorkspace=mock_ws,
OutputWorkspace='mock_ws_roi',
XMin=exp_xmin,
XMax=exp_xmax,
StartWorkspaceIndex=exp_start_index,
EndWorkspaceIndex=exp_end_index,
EnableLogging=True)
mock_extract_spectra.reset_mock()
def _assert_supports_peaks_overlay(self, expectation, ws_type, ndims=2):
ws = _create_mock_workspace(ws_type,
coords=SpecialCoordinateSystem.QLab,
has_oriented_lattice=False,
ndims=ndims)
model = SliceViewerModel(ws)
self.assertEqual(expectation, model.can_support_peaks_overlays())
def test_model_MDE_basis_vectors_not_normalised_when_HKL(self, mock_binmd):
ws = _create_mock_mdeventworkspace(ndims=3,
coords=SpecialCoordinateSystem.HKL,
extents=(-3, 3, -4, 4, -5, 5),
names=('h', 'k', 'l'),
units=('r.l.u.', 'r.l.u.',
'r.l.u.'),
isq=(True, True, True))
model = SliceViewerModel(ws)
mock_binmd.return_value = self.ws_MD_3D # different workspace
self.assertNotEqual(model.get_ws((None, None, 0), (1, 2, 4)), ws)
mock_binmd.assert_called_once_with(
AxisAligned=False,
NormalizeBasisVectors=False,
BasisVector0='h,r.l.u.,1.0,0.0,0.0',
BasisVector1='k,r.l.u.,0.0,1.0,0.0',
BasisVector2='l,r.l.u.,0.0,0.0,1.0',
EnableLogging=False,
InputWorkspace=ws,
OutputBins=[1, 2, 1],
OutputExtents=[-3, 3, -4, 4, -2.0, 2.0],
OutputWorkspace=ws.name() + '_svrebinned')
mock_binmd.reset_mock()
def test_get_dim_limits_returns_limits_for_display_dimensions_for_matrix(self):
model = SliceViewerModel(self.ws2d_histo)
data_limits = ((10, 30), (4, 8))
limits = model.get_dim_limits(slicepoint=(None, None), transpose=False)
self.assertEqual(data_limits, limits)
limits = model.get_dim_limits(slicepoint=(None, None), transpose=True)
self.assertEqual((data_limits[1], data_limits[0]), limits)
def test_matrix_workspace_can_be_normalized_if_not_a_distribution(self):
ws2d = CreateWorkspace(DataX=[10, 20, 30, 10, 20, 30],
DataY=[2, 3, 4, 5],
DataE=[1, 2, 3, 4],
NSpec=2,
Distribution=False,
OutputWorkspace='ws2d')
model = SliceViewerModel(ws2d)
self.assertTrue(model.can_normalize_workspace())
def test_rebin_matrixworkspace_does_nothing(self, mock_binmd):
orig_ws = self.ws2d_histo
model = SliceViewerModel(orig_ws)
model.rebin(slicepoint=(None, None, 0.),
bin_params=[100, 100, 1],
limits=(-1, 1, -2, 2, -3, 3))
mock_binmd.assert_not_called()
self.assertEqual(orig_ws, model._get_ws())
def test_model_MDE(self):
model = SliceViewerModel(self.ws_MDE_3D)
self.assertNotEqual(model.get_ws((0, 0, 0), (1, 1, 1)), self.ws_MDE_3D)
self.assertEqual(model._get_ws(), self.ws_MDE_3D)
self.assertEqual(model.get_ws_type(), WS_TYPE.MDE)
dim_info = model.get_dim_info(0)
self.assertEqual(dim_info['minimum'], -3)
self.assertEqual(dim_info['maximum'], 3)
self.assertEqual(dim_info['number_of_bins'], 1)
self.assertAlmostEqual(dim_info['width'], 6)
self.assertEqual(dim_info['name'], 'h')
self.assertEqual(dim_info['units'], 'rlu')
self.assertEqual(dim_info['type'], 'MDE')
dim_infos = model.get_dimensions_info()
self.assertEqual(len(dim_infos), 3)
dim_info = dim_infos[2]
self.assertEqual(dim_info['minimum'], -5)
self.assertEqual(dim_info['maximum'], 5)
self.assertEqual(dim_info['number_of_bins'], 1)
self.assertAlmostEqual(dim_info['width'], 10)
self.assertEqual(dim_info['name'], 'l')
self.assertEqual(dim_info['units'], 'rlu')
self.assertEqual(dim_info['type'], 'MDE')
mdh = model.get_ws((None, 0, None), (3, 0.001, 3))
assert_allclose(mdh.getSignalArray().squeeze(),
[[0, 0, 0], [0, 692.237618, 0], [0, 118.362777, 0]])
d0 = mdh.getDimension(0)
d1 = mdh.getDimension(1)
d2 = mdh.getDimension(2)
self.assertEqual(d0.name, 'h')
self.assertEqual(d0.getNBins(), 3)
self.assertEqual(d0.getMinimum(), -3)
self.assertEqual(d0.getMaximum(), 3)
self.assertEqual(d1.name, 'k')
self.assertEqual(d1.getNBins(), 1)
self.assertAlmostEqual(d1.getMinimum(), -0.0005)
self.assertAlmostEqual(d1.getMaximum(), 0.0005)
self.assertEqual(d2.name, 'l')
self.assertEqual(d2.getNBins(), 3)
self.assertEqual(d2.getMinimum(), -5)
self.assertEqual(d2.getMaximum(), 5)
assert_allclose(model.get_data((None, 0, None), (3, 0.001, 3)),
[[0, 0, 0], [0, 692.237618, 0], [0, 118.362777, 0]])
assert_allclose(
model.get_data((None, 0, None), (3, 0.001, 3), transpose=True),
[[0, 0, 0], [0, 692.237618, 118.362777], [0, 0, 0]])
def test_qflags_for_hkl_coordinates_detected(self):
mock_q3d = _create_mock_workspace(IMDEventWorkspace,
coords=SpecialCoordinateSystem.HKL,
has_oriented_lattice=False)
mock_q3d = _add_dimensions(mock_q3d, ('[H,0,0]', '[0,K,0]', '[0,0,L]', 'DeltaE'),
isq=(True, True, True, False))
model = SliceViewerModel(mock_q3d)
for i in range(3):
dim_info = model.get_dim_info(i)
self.assertTrue(dim_info['qdim'], msg=f'Dimension {i} not spatial as expected')
self.assertFalse(model.get_dim_info(3)['qdim'])
def test_model_MDE(self):
model = SliceViewerModel(self.ws_MDE_3D)
self.assertNotEqual(model.get_ws((0,0,0), (1,1,1)), self.ws_MDE_3D)
self.assertEqual(model._get_ws(), self.ws_MDE_3D)
self.assertEqual(model.get_ws_type(), WS_TYPE.MDE)
dim_info = model.get_dim_info(0)
self.assertEqual(dim_info['minimum'], -3)
self.assertEqual(dim_info['maximum'], 3)
self.assertEqual(dim_info['number_of_bins'], 1)
self.assertAlmostEqual(dim_info['width'], 6)
self.assertEqual(dim_info['name'], 'h')
self.assertEqual(dim_info['units'], 'rlu')
self.assertEqual(dim_info['type'], 'MDE')
dim_infos = model.get_dimensions_info()
self.assertEqual(len(dim_infos), 3)
dim_info = dim_infos[2]
self.assertEqual(dim_info['minimum'], -5)
self.assertEqual(dim_info['maximum'], 5)
self.assertEqual(dim_info['number_of_bins'], 1)
self.assertAlmostEqual(dim_info['width'], 10)
self.assertEqual(dim_info['name'], 'l')
self.assertEqual(dim_info['units'], 'rlu')
self.assertEqual(dim_info['type'], 'MDE')
mdh = model.get_ws((None,0,None), (3,0.001,3))
assert_allclose(mdh.getSignalArray().squeeze(), [[0, 0, 0],
[0, 692.237618, 0],
[0, 118.362777, 0]])
d0 = mdh.getDimension(0)
d1 = mdh.getDimension(1)
d2 = mdh.getDimension(2)
self.assertEqual(d0.name, 'h')
self.assertEqual(d0.getNBins(), 3)
self.assertEqual(d0.getMinimum(), -3)
self.assertEqual(d0.getMaximum(), 3)
self.assertEqual(d1.name, 'k')
self.assertEqual(d1.getNBins(), 1)
self.assertAlmostEqual(d1.getMinimum(), -0.0005)
self.assertAlmostEqual(d1.getMaximum(), 0.0005)
self.assertEqual(d2.name, 'l')
self.assertEqual(d2.getNBins(), 3)
self.assertEqual(d2.getMinimum(), -5)
self.assertEqual(d2.getMaximum(), 5)
assert_allclose(model.get_data((None,0,None), (3,0.001,3)), [[0, 0, 0],
[0, 692.237618, 0],
[0, 118.362777, 0]])
assert_allclose(model.get_data((None,0,None), (3,0.001,3), transpose=True), [[0, 0, 0],
[0, 692.237618, 118.362777],
[0, 0, 0]])
def _assert_supports_dynamic_rebinning(self, expectation, ws_type, has_original_workspace=None):
ws = _create_mock_workspace(ws_type,
coords=SpecialCoordinateSystem.QLab,
has_oriented_lattice=False,
ndims=3)
if ws_type == MatrixWorkspace:
ws.hasOriginalWorkspace.return_value = False
elif has_original_workspace is not None:
ws.hasOriginalWorkspace.return_value = has_original_workspace
if has_original_workspace:
ws.getOriginalWorkspace.return_value = self.ws_MDE_3D
model = SliceViewerModel(ws)
self.assertEqual(expectation, model.can_support_dynamic_rebinning())
def assert_call_as_expected(mock_ws, transpose, export_type,
is_spectra, is_ragged):
model = SliceViewerModel(mock_ws)
slicepoint, bin_params, dimension_indices = MagicMock(), MagicMock(
), MagicMock()
help_msg = model.export_cuts_to_workspace(
slicepoint, bin_params, ((xmin, xmax), (ymin, ymax)),
transpose, dimension_indices, export_type)
if export_type == 'c':
if is_spectra:
mock_extract_spectra.assert_called_once()
if is_ragged:
mock_rebin.assert_called_once()
mock_sum_spectra.assert_called_once()
else:
if is_ragged:
self.assertEqual(2, mock_rebin.call_count)
else:
mock_rebin.assert_called_once()
self.assertEqual(1, mock_transpose.call_count)
self.assertEqual(1, mock_extract_spectra.call_count)
self.assertEqual(
'Cuts along X/Y created: mock_ws_cut_x & mock_ws_cut_y',
help_msg)
elif export_type == 'x':
mock_extract_spectra.assert_called_once()
if is_ragged:
self.assertEqual(1, mock_rebin.call_count)
if is_spectra:
mock_sum_spectra.assert_called_once()
else:
mock_transpose.assert_not_called()
self.assertEqual('Cut along X created: mock_ws_cut_x',
help_msg)
elif export_type == 'y':
mock_extract_spectra.assert_called_once()
mock_transpose.assert_called_once()
if is_ragged:
self.assertEqual(2, mock_rebin.call_count)
else:
self.assertEqual(1, mock_rebin.call_count)
self.assertEqual('Cut along Y created: mock_ws_cut_y',
help_msg)
mock_transpose.reset_mock()
mock_rebin.reset_mock()
mock_extract_spectra.reset_mock()
mock_sum_spectra.reset_mock()
def test_model_MDH(self):
model = SliceViewerModel(self.ws_MD_3D)
self.assertEqual(model.get_ws(), self.ws_MD_3D)
self.assertEqual(model.get_ws_type(), WS_TYPE.MDH)
assert_equal(model.get_data((None, 2, 2)), range(90, 95))
assert_equal(model.get_data((1, 2, None)), range(18, 118, 25))
assert_equal(model.get_data((None, None, 0)),
np.reshape(range(50, 75), (5, 5)).T)
dim_info = model.get_dim_info(0)
self.assertEqual(dim_info['minimum'], -3)
self.assertEqual(dim_info['maximum'], 3)
self.assertEqual(dim_info['number_of_bins'], 5)
self.assertAlmostEqual(dim_info['width'], 1.2)
self.assertEqual(dim_info['name'], 'Dim1')
self.assertEqual(dim_info['units'], 'MomentumTransfer')
self.assertEqual(dim_info['type'], 'MDH')
dim_infos = model.get_dimensions_info()
self.assertEqual(len(dim_infos), 3)
dim_info = dim_infos[2]
self.assertEqual(dim_info['minimum'], -1)
self.assertEqual(dim_info['maximum'], 1)
self.assertEqual(dim_info['number_of_bins'], 4)
self.assertAlmostEqual(dim_info['width'], 0.5)
self.assertEqual(dim_info['name'], 'Dim3')
self.assertEqual(dim_info['units'], 'Angstrom')
self.assertEqual(dim_info['type'], 'MDH')
def test_model_MDH(self):
model = SliceViewerModel(self.ws_MD_3D)
self.assertEqual(model.get_ws(), self.ws_MD_3D)
self.assertEqual(model.get_ws_type(), WS_TYPE.MDH)
signal = np.arange(100).reshape(5, 5, 4)
assert_equal(model.get_data((None, 2, 2)), signal[(slice(None), 3, 3)])
assert_equal(model.get_data((1, 2, None)), range(72, 76))
assert_equal(model.get_data((None, None, 0)), signal[(slice(None), slice(None), 2)])
dim_info = model.get_dim_info(0)
self.assertEqual(dim_info['minimum'], -3)
self.assertEqual(dim_info['maximum'], 3)
self.assertEqual(dim_info['number_of_bins'], 5)
self.assertAlmostEqual(dim_info['width'], 1.2)
self.assertEqual(dim_info['name'], 'Dim1')
self.assertEqual(dim_info['units'], 'MomentumTransfer')
self.assertEqual(dim_info['type'], 'MDH')
self.assertEqual(dim_info['qdim'], False)
dim_infos = model.get_dimensions_info()
self.assertEqual(len(dim_infos), 3)
dim_info = dim_infos[2]
self.assertEqual(dim_info['minimum'], -1)
self.assertEqual(dim_info['maximum'], 1)
self.assertEqual(dim_info['number_of_bins'], 4)
self.assertAlmostEqual(dim_info['width'], 0.5)
self.assertEqual(dim_info['name'], 'Dim3')
self.assertEqual(dim_info['units'], 'Angstrom')
self.assertEqual(dim_info['type'], 'MDH')
self.assertEqual(dim_info['qdim'], False)
def test_create_non_orthogonal_transform_raises_error_if_not_supported(self):
model = SliceViewerModel(
_create_mock_workspace(MatrixWorkspace,
SpecialCoordinateSystem.QLab,
has_oriented_lattice=False))
self.assertRaises(RuntimeError, model.create_nonorthogonal_transform, (0, 1, 2))
def test_get_ws_MDE_with_limits_uses_limits_over_dimension_extents(self, mock_binmd):
model = SliceViewerModel(self.ws_MDE_3D)
mock_binmd.return_value = self.ws_MD_3D
self.assertNotEqual(model.get_ws((None, None, 0), (1, 2, 4), ((-2, 2), (-1, 1))),
self.ws_MDE_3D)
call_params = dict(InputWorkspace=self.ws_MDE_3D,
OutputWorkspace='ws_MDE_3D_svrebinned',
AlignedDim0='h,-2,2,1',
AlignedDim1='k,-1,1,2',
AlignedDim2='l,-2.0,2.0,1',
EnableLogging=False)
mock_binmd.assert_called_once_with(**call_params)
mock_binmd.reset_mock()
model.get_data((None, None, 0), (1, 2, 4), ((-2, 2), (-1, 1)))
mock_binmd.assert_called_once_with(**call_params)
def test_get_dim_limits_raises_error_num_display_dims_ne_2(self):
model = SliceViewerModel(self.ws_MDE_3D)
self.assertRaises(ValueError, model.get_dim_limits, slicepoint=(0, 0, 0), transpose=False)
self.assertRaises(ValueError,
model.get_dim_limits,
slicepoint=(None, 0, 0),
transpose=False)
def test_model_MDH(self):
model = SliceViewerModel(self.ws_MD_3D)
self.assertEqual(model.get_ws(), self.ws_MD_3D)
self.assertEqual(model.get_ws_type(), WS_TYPE.MDH)
assert_equal(model.get_data((None, 2, 2)), range(90,95))
assert_equal(model.get_data((1, 2, None)), range(18,118,25))
assert_equal(model.get_data((None, None, 0)), np.reshape(range(50,75), (5,5)).T)
dim_info = model.get_dim_info(0)
self.assertEqual(dim_info['minimum'], -3)
self.assertEqual(dim_info['maximum'], 3)
self.assertEqual(dim_info['number_of_bins'], 5)
self.assertAlmostEqual(dim_info['width'], 1.2)
self.assertEqual(dim_info['name'], 'Dim1')
self.assertEqual(dim_info['units'], 'MomentumTransfer')
self.assertEqual(dim_info['type'], 'MDH')
dim_infos = model.get_dimensions_info()
self.assertEqual(len(dim_infos), 3)
dim_info = dim_infos[2]
self.assertEqual(dim_info['minimum'], -1)
self.assertEqual(dim_info['maximum'], 1)
self.assertEqual(dim_info['number_of_bins'], 4)
self.assertAlmostEqual(dim_info['width'], 0.5)
self.assertEqual(dim_info['name'], 'Dim3')
self.assertEqual(dim_info['units'], 'Angstrom')
self.assertEqual(dim_info['type'], 'MDH')
def assert_error_returned_in_help(workspace, export_type, mock_alg, err_msg):
model = SliceViewerModel(workspace)
slicepoint, bin_params = MagicMock(), MagicMock()
mock_alg.side_effect = RuntimeError(err_msg)
try:
if export_type == 'r':
help_msg = model.export_roi_to_workspace(slicepoint, bin_params,
((1.0, 2.0), (-1, 2.0)), True)
else:
help_msg = model.export_cuts_to_workspace(slicepoint, bin_params,
((1.0, 2.0), (-1, 2.0)), True,
export_type)
except Exception as exc:
help_msg = str(exc)
mock_alg.reset_mock()
self.assertTrue(err_msg in help_msg)
def test_create_non_orthogonal_transform_uses_identity_if_W_unavilable(
self, mock_nonortho_trans):
ws = _create_mock_workspace(IMDEventWorkspace,
SpecialCoordinateSystem.HKL,
has_oriented_lattice=True)
lattice = MagicMock()
ws.getExperimentInfo().sample().getOrientedLattice.return_value = lattice
run = MagicMock()
run.get.side_effect = KeyError
ws.getExperimentInfo().run.return_value = run
model = SliceViewerModel(ws)
model.create_nonorthogonal_transform(create_mock_sliceinfo([1, 2, 0]))
mock_nonortho_trans.from_lattice.assert_called_once_with(
lattice,
x_proj=ArraysEqual(np.array([0, 1, 0])),
y_proj=ArraysEqual(np.array([0, 0, 1])))
def test_rebin_mdhistworkspace_calls_binmd(self, mock_binmd):
orig_ws = self.ws_MD_3D
model = SliceViewerModel(orig_ws)
model.rebin(slicepoint=(None, 0, None), limits=((-1, 1), (-2, 2)))
mock_binmd.assert_called_once_with(InputWorkspace=self.ws_MD_3D,
OutputWorkspace='ws_MD_3D_svrebinned',
AxisAligned=False,
EnableLogging=False,
BasisVector0='Dim1,MomentumTransfer,1.0,0.0,0.0',
BasisVector1='Dim2,EnergyTransfer,0.0,1.0,0.0',
BasisVector2='Dim3,Angstrom,0.0,0.0,1.0',
OutputExtents='-1,1,-10,10,-2,2',
OutputBins='5,5,4')
self.assertEqual(
mock_binmd.return_value,
model._get_ws(),
msg='Expected internal workspace reference to have been overwritten by result of BinMD')
def test_get_dim_limits_raises_if_slicepoint_length_ne_ndims(self):
model = SliceViewerModel(self.ws_MDE_3D)
self.assertRaises(AssertionError,
model.get_dim_limits,
slicepoint=(None, None),
transpose=False)
self.assertRaises(AssertionError,
model.get_dim_limits,
slicepoint=(None, None, 0, 0),
transpose=False)
def test_model_matrix(self):
model = SliceViewerModel(self.ws2d_histo)
self.assertEqual(model.get_ws(), self.ws2d_histo)
self.assertEqual(model.get_ws_type(), WS_TYPE.MATRIX)
dim_info = model.get_dim_info(0)
self.assertEqual(dim_info['minimum'], 10)
self.assertEqual(dim_info['maximum'], 30)
self.assertEqual(dim_info['number_of_bins'], 2)
self.assertAlmostEqual(dim_info['width'], 10)
self.assertEqual(dim_info['name'], 'Wavelength')
self.assertEqual(dim_info['units'], 'Angstrom')
self.assertEqual(dim_info['type'], 'MATRIX')
dim_infos = model.get_dimensions_info()
self.assertEqual(len(dim_infos), 2)
dim_info = dim_infos[1]
self.assertEqual(dim_info['minimum'], 4)
self.assertEqual(dim_info['maximum'], 8)
self.assertEqual(dim_info['number_of_bins'], 2)
self.assertAlmostEqual(dim_info['width'], 2)
self.assertEqual(dim_info['name'], 'Energy transfer')
self.assertEqual(dim_info['units'], 'meV')
self.assertEqual(dim_info['type'], 'MATRIX')
def test_get_ws_mde_sets_minimum_width_on_data_limits(self, mock_binmd):
model = SliceViewerModel(self.ws_MDE_3D)
mock_binmd.return_value = self.ws_MD_3D
xmin = -5e-8
xmax = 5e-8
self.assertNotEqual(
model.get_ws((None, None, 0), (1, 2, 4), ((xmin, xmax), (-1, 1)),
[0, 1, None]), self.ws_MDE_3D)
call_params = dict(
AxisAligned=False,
BasisVector0='h,rlu,1.0,0.0,0.0',
BasisVector1='k,rlu,0.0,1.0,0.0',
BasisVector2='l,rlu,0.0,0.0,1.0',
EnableLogging=False,
InputWorkspace=self.ws_MDE_3D,
OutputBins=[1, 2, 1],
OutputExtents=[xmin, xmin + MIN_WIDTH, -1, 1, -2.0, 2.0],
OutputWorkspace='ws_MDE_3D_svrebinned')
mock_binmd.assert_called_once_with(**call_params)
mock_binmd.reset_mock()
def _assert_supports_dynamic_rebinning(self,
expectation,
ws_type,
ndims=3,
has_original_workspace=None,
original_ws_ndims=None):
ws = _create_mock_workspace(ws_type,
coords=SpecialCoordinateSystem.QLab,
has_oriented_lattice=False,
ndims=ndims)
if ws_type == MatrixWorkspace:
ws.hasOriginalWorkspace.side_effect = lambda index: False
elif has_original_workspace is not None:
ws.hasOriginalWorkspace.side_effect = lambda index: has_original_workspace
if not original_ws_ndims:
original_ws_ndims = ndims
orig_ws = _create_mock_workspace(
ws_type,
coords=SpecialCoordinateSystem.QLab,
has_oriented_lattice=False,
ndims=original_ws_ndims)
ws.getOriginalWorkspace.side_effect = lambda index: orig_ws
model = SliceViewerModel(ws)
self.assertEqual(expectation, model.can_support_dynamic_rebinning())
def test_get_ws_MDE_with_limits_uses_limits_over_dimension_extents(
self, mock_binmd):
model = SliceViewerModel(self.ws_MDE_3D)
mock_binmd.return_value = self.ws_MD_3D
self.assertNotEqual(
model.get_ws((None, None, 0), (1, 2, 4), ((-2, 2), (-1, 1)),
[0, 1, None]), self.ws_MDE_3D)
call_params = dict(AxisAligned=False,
BasisVector0='h,rlu,1.0,0.0,0.0',
BasisVector1='k,rlu,0.0,1.0,0.0',
BasisVector2='l,rlu,0.0,0.0,1.0',
EnableLogging=False,
InputWorkspace=self.ws_MDE_3D,
OutputBins=[1, 2, 1],
OutputExtents=[-2, 2, -1, 1, -2.0, 2.0],
OutputWorkspace='ws_MDE_3D_svrebinned')
mock_binmd.assert_called_once_with(**call_params)
mock_binmd.reset_mock()
model.get_data((None, None, 0), (1, 2, 4), [0, 1, None],
((-2, 2), (-1, 1)))
mock_binmd.assert_called_once_with(**call_params)
def test_rebin_mdhistworkspace_twice_uses_same_output_wsname(self, mock_binmd):
orig_ws = self.ws_MD_3D
model = SliceViewerModel(orig_ws)
mock_rebinned_first = MagicMock(getNumDims=lambda: 3)
mock_binmd.return_value = mock_rebinned_first
model.rebin(slicepoint=(None, 0, None), limits=((-1, 1), (-2, 2)))
model.rebin(slicepoint=(None, 0, None), limits=((-0.5, 0.5), (-2, 2)))
self.assertEqual(2, mock_binmd.call_count)
self.assertEqual(self.ws_MD_3D.name() + '_svrebinned',
mock_binmd.call_args[-1]['OutputWorkspace'])
def test_get_dim_limits_returns_limits_for_display_dimensions_for_md(self):
model = SliceViewerModel(self.ws_MDE_3D)
data_limits = ((-3, 3), (-4, 4), (-5, 5))
limits = model.get_dim_limits(slicepoint=(None, None, 0), transpose=False)
self.assertEqual(data_limits[:2], limits)
limits = model.get_dim_limits(slicepoint=(None, None, 0), transpose=True)
self.assertEqual((data_limits[1], data_limits[0]), limits)
limits = model.get_dim_limits(slicepoint=(None, 0, None), transpose=False)
self.assertEqual((data_limits[0], data_limits[2]), limits)
limits = model.get_dim_limits(slicepoint=(None, 0, None), transpose=True)
self.assertEqual((data_limits[2], data_limits[0]), limits)
def test_model_MDE(self, mock_binmd):
model = SliceViewerModel(self.ws_MDE_3D)
mock_binmd.return_value = self.ws_MD_3D
self.assertNotEqual(model.get_ws((None, None, 0), (1, 2, 4)),
self.ws_MDE_3D)
mock_binmd.assert_called_once_with(
AxisAligned=False,
BasisVector0='h,rlu,1.0,0.0,0.0',
BasisVector1='k,rlu,0.0,1.0,0.0',
BasisVector2='l,rlu,0.0,0.0,1.0',
EnableLogging=False,
InputWorkspace=self.ws_MDE_3D,
OutputBins=[1, 2, 1],
OutputExtents=[-3, 3, -4, 4, -2.0, 2.0],
OutputWorkspace='ws_MDE_3D_svrebinned')
mock_binmd.reset_mock()
self.assertEqual(model._get_ws(), self.ws_MDE_3D)
self.assertEqual(model.get_ws_type(), WS_TYPE.MDE)
dim_info = model.get_dim_info(0)
self.assertEqual(dim_info['minimum'], -3)
self.assertEqual(dim_info['maximum'], 3)
self.assertEqual(dim_info['number_of_bins'], 1)
self.assertAlmostEqual(dim_info['width'], 6)
self.assertEqual(dim_info['name'], 'h')
self.assertEqual(dim_info['units'], 'rlu')
self.assertEqual(dim_info['type'], 'MDE')
self.assertEqual(dim_info['qdim'], False)
dim_infos = model.get_dimensions_info()
self.assertEqual(len(dim_infos), 3)
dim_info = dim_infos[2]
self.assertEqual(dim_info['minimum'], -5)
self.assertEqual(dim_info['maximum'], 5)
self.assertEqual(dim_info['number_of_bins'], 1)
self.assertAlmostEqual(dim_info['width'], 10)
self.assertEqual(dim_info['name'], 'l')
self.assertEqual(dim_info['units'], 'rlu')
self.assertEqual(dim_info['type'], 'MDE')
self.assertEqual(dim_info['qdim'], False)
def assert_call_as_expected(transpose, export_type):
model = SliceViewerModel(self.ws_MDE_3D)
if export_type == 'r':
help_msg = model.export_roi_to_workspace(slicepoint, bin_params,
((xmin, xmax), (ymin, ymax)), transpose)
else:
help_msg = model.export_cuts_to_workspace(slicepoint, bin_params,
((xmin, xmax), (ymin, ymax)), transpose,
export_type)
if transpose:
extents = [ymin, ymax, xmin, xmax, zmin, zmax]
else:
extents = [xmin, xmax, ymin, ymax, zmin, zmax]
common_call_params = dict(InputWorkspace=self.ws_MDE_3D,
AxisAligned=False,
BasisVector0='h,rlu,1.0,0.0,0.0',
BasisVector1='k,rlu,0.0,1.0,0.0',
BasisVector2='l,rlu,0.0,0.0,1.0',
OutputExtents=extents)
xcut_name, ycut_name = 'ws_MDE_3D_cut_x', 'ws_MDE_3D_cut_y'
if export_type == 'r':
expected_help_msg = 'ROI created: ws_MDE_3D_roi'
expected_calls = [
call(**common_call_params,
OutputBins=[100, 100, 1],
OutputWorkspace='ws_MDE_3D_roi')
]
elif export_type == 'x':
expected_help_msg = f'Cut along X created: {xcut_name}'
expected_bins = [1, 100, 1] if transpose else [100, 1, 1]
expected_calls = [
call(**common_call_params, OutputBins=expected_bins, OutputWorkspace=xcut_name)
]
elif export_type == 'y':
expected_help_msg = f'Cut along Y created: {ycut_name}'
expected_bins = [100, 1, 1] if transpose else [1, 100, 1]
expected_calls = [
call(**common_call_params, OutputBins=expected_bins, OutputWorkspace=ycut_name)
]
elif export_type == 'c':
expected_help_msg = f'Cuts along X/Y created: {xcut_name} & {ycut_name}'
expected_bins = [100, 1, 1] if transpose else [1, 100, 1]
expected_calls = [
call(**common_call_params, OutputBins=expected_bins, OutputWorkspace=xcut_name),
call(**common_call_params, OutputBins=expected_bins, OutputWorkspace=ycut_name)
]
mock_binmd.assert_has_calls(expected_calls, any_order=True)
if export_type == 'r':
if transpose:
mock_transposemd.assert_called_once()
else:
mock_transposemd.assert_not_called()
else:
if export_type == 'x':
index = 1 if transpose else 0
expected_calls = [
call(InputWorkspace=xcut_name, OutputWorkspace=xcut_name, Axes=[index])
]
elif export_type == 'y':
index = 0 if transpose else 1
expected_calls = [
call(InputWorkspace=ycut_name, OutputWorkspace=ycut_name, Axes=[index])
]
elif export_type == 'c':
xindex = 1 if transpose else 0
yindex = 0 if transpose else 1
expected_calls = [
call(InputWorkspace=xcut_name, OutputWorkspace=xcut_name, Axes=[xindex]),
call(InputWorkspace=ycut_name, OutputWorkspace=ycut_name, Axes=[yindex])
]
mock_transposemd.assert_has_calls(expected_calls, any_order=True)
self.assertEqual(expected_help_msg, help_msg)
mock_binmd.reset_mock()
mock_transposemd.reset_mock()
def _assert_supports_non_orthogonal_axes(self, expectation, ws_type, units,
has_oriented_lattice):
model = SliceViewerModel(
self._create_mock_workspace(ws_type, units, has_oriented_lattice))
self.assertEqual(expectation, model.can_support_nonorthogonal_axes())
def test_MDE_workspaces_cannot_be_normalized(self):
model = SliceViewerModel(self.ws_MDE_3D)
self.assertFalse(model.can_normalize_workspace())
def test_matrix_workspace_cannot_be_normalized_if_a_distribution(self):
model = SliceViewerModel(self.ws2d_histo)
self.assertFalse(model.can_normalize_workspace())
