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_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())