def test_1D_dataset(): var = sc.Variable([Dim.X], shape=(2, ), dtype=sc.dtype.Dataset) d1 = sc.Dataset({'a': 1.5 * sc.units.m}) d2 = sc.Dataset({'a': 2.5 * sc.units.m}) var.values = [d1, d2] assert var.values[0] == d1 assert var.values[1] == d2
def test_sort(): d = sc.Dataset( { 'a': sc.Variable(dims=['x', 'y'], values=np.arange(6).reshape(2, 3)), 'b': sc.Variable(dims=['x'], values=['b', 'a']) }, coords={ 'x': sc.Variable(dims=['x'], values=np.arange(2.0), unit=sc.units.m), 'y': sc.Variable(dims=['y'], values=np.arange(3.0), unit=sc.units.m), 'aux': sc.Variable(dims=['x'], values=np.arange(2.0)) }) expected = sc.Dataset( { 'a': sc.Variable(dims=['x', 'y'], values=np.flip(np.arange(6).reshape(2, 3), axis=0)), 'b': sc.Variable(dims=['x'], values=['a', 'b']) }, coords={ 'x': sc.Variable(dims=['x'], values=[1.0, 0.0], unit=sc.units.m), 'y': sc.Variable(dims=['y'], values=np.arange(3.0), unit=sc.units.m), 'aux': sc.Variable(dims=['x'], values=[1.0, 0.0]) }) assert sc.sort(d, d['b'].data) == expected
def groupby2D(data, nx_target, ny_target, x='x', y='y', z='wavelength'): element_width_x = data.sizes[x] // nx_target element_width_y = data.sizes[y] // ny_target xx = sc.Variable(dims=[x], values=np.arange(data.sizes[x]) // element_width_x) yy = sc.Variable(dims=[y], values=np.arange(data.sizes[y]) // element_width_y) grid = xx + nx_target * yy spectrum_mapping = sc.Variable(dims=["spectrum"], values=np.ravel(grid.values, order='F')) reshaped = sc.Dataset() for key, val in data.items(): reshaped[key] = sc.flatten(x=val, dims=[y, x], to='spectrum') reshaped.coords["spectrum_mapping"] = spectrum_mapping grouped = sc.groupby(reshaped, "spectrum_mapping").sum("spectrum") reshaped = sc.Dataset() for key, val in grouped.items(): item = sc.fold(x=val, dim="spectrum_mapping", dims=[y, x], shape=(ny_target, nx_target)) reshaped[key] = item return reshaped
def test_chained_slicing(): x = sc.Variable(dims=['x'], values=np.arange(11.0)) y = sc.Variable(dims=['y'], values=np.arange(11.0)) z = sc.Variable(dims=['z'], values=np.arange(11.0)) d = sc.Dataset( { 'a': sc.Variable(dims=['z', 'y', 'x'], values=np.arange(1000.0).reshape(10, 10, 10)), 'b': sc.Variable(dims=['x', 'z'], values=np.arange(0.0, 10.0, 0.1).reshape(10, 10)) }, coords={ 'x': x, 'y': y, 'z': z }) expected = sc.Dataset() expected.coords['y'] = sc.Variable(dims=['y'], values=np.arange(11.0)) expected['a'] = sc.Variable(dims=['y'], values=np.arange(501.0, 600.0, 10.0)) expected['b'] = sc.Variable(1.5) expected['a'].attrs['x'] = x['x', 1:3] expected['b'].attrs['x'] = x['x', 1:3] expected['a'].attrs['z'] = z['z', 5:7] expected['b'].attrs['z'] = z['z', 5:7] assert sc.is_equal(d['x', 1]['z', 5], expected)
def test_sum_mean(): d = sc.Dataset( { 'a': sc.Variable(dims=['x', 'y'], values=np.arange(6, dtype=np.int64).reshape(2, 3)), 'b': sc.Variable(dims=['y'], values=np.arange(3, dtype=np.int64)) }, coords={ 'x': sc.Variable(dims=['x'], values=np.arange(2, dtype=np.int64)), 'y': sc.Variable(dims=['y'], values=np.arange(3, dtype=np.int64)), 'l1': sc.Variable(dims=['x', 'y'], values=np.arange(6, dtype=np.int64).reshape(2, 3)), 'l2': sc.Variable(dims=['x'], values=np.arange(2, dtype=np.int64)) }) d_ref = sc.Dataset( { 'a': sc.Variable(dims=['x'], values=np.array([3, 12], dtype=np.int64)), 'b': sc.Variable(3) }, coords={ 'x': sc.Variable(dims=['x'], values=np.arange(2, dtype=np.int64)), 'l2': sc.Variable(dims=['x'], values=np.arange(2, dtype=np.int64)) }) assert sc.sum(d, 'y') == d_ref assert (sc.mean(d, 'y')['a'].values == [1.0, 4.0]).all() assert sc.mean(d, 'y')['b'].value == 1.0
def test_1D_dataset(): var = sc.Variable(dims=['x'], shape=(2, ), dtype=sc.dtype.Dataset) d1 = sc.Dataset({'a': 1.5 * sc.units.m}) d2 = sc.Dataset({'a': 2.5 * sc.units.m}) var.values = [d1, d2] assert sc.is_equal(var.values[0], d1) assert sc.is_equal(var.values[1], d2)
def test_shape(): a = sc.Variable(value=1) d = sc.Dataset(data={'a': a}) assert d.shape == [] a = sc.Variable(['x'], shape=[2]) b = sc.Variable(['y', 'z'], shape=[3, 4]) d = sc.Dataset(data={'a': a, 'b': b}) assert not bool(set(d.shape) - set([4, 3, 2]))
def test_mean_masked(): d = sc.Dataset( {'a': sc.Variable(dims=['x'], values=np.array([1, 5, 4, 5, 1]))}) d['a'].masks['m1'] = sc.Variable(dims=['x'], values=np.array( [False, True, False, True, False])) d_ref = sc.Dataset({'a': sc.Variable(2.0)}) assert sc.is_equal(sc.mean(d, 'x')['a'], d_ref['a'])
def test_mean_masked(): d = sc.Dataset( {'a': sc.Variable(dims=['x'], values=np.array([1, 5, 4, 5, 1]))}, masks={ 'm1': sc.Variable(dims=['x'], values=np.array([False, True, False, True, False])) }) d_ref = sc.Dataset({'a': sc.Variable(2.0)}) assert sc.mean(d, 'x')['a'] == d_ref['a']
def test_slice(): d = sc.Dataset( { 'a': sc.Variable(dims=['x'], values=np.arange(10.0)), 'b': sc.Variable(1.0) }, coords={'x': sc.Variable(dims=['x'], values=np.arange(10.0))}) expected = sc.Dataset({'a': sc.Variable(1.0)}) assert d['x', 1] == expected assert 'a' in d['x', 1] assert 'b' not in d['x', 1]
def test_dataset_concatenate(): a = sc.Dataset( {'data': sc.Variable(dims=['x'], values=np.array([11, 12]))}, coords={'x': sc.Variable(dims=['x'], values=np.array([1, 2]))}) b = sc.Dataset( {'data': sc.Variable(dims=['x'], values=np.array([13, 14]))}, coords={'x': sc.Variable(dims=['x'], values=np.array([3, 4]))}) c = sc.concatenate(a, b, 'x') assert np.array_equal(c.coords['x'].values, np.array([1, 2, 3, 4])) assert np.array_equal(c['data'].values, np.array([11, 12, 13, 14]))
def test_sum_masked(): d = sc.Dataset({ 'a': sc.Variable(dims=['x'], values=np.array([1, 5, 4, 5, 1], dtype=np.int64)) }) d['a'].masks['m1'] = sc.Variable(dims=['x'], values=np.array( [False, True, False, True, False])) d_ref = sc.Dataset({'a': sc.Variable(np.int64(6))}) result = sc.sum(d, 'x')['a'] assert sc.is_equal(result, d_ref['a'])
def test_coords_view_comparison_operators(): d = sc.Dataset( { 'a': sc.Variable(dims=['x'], values=np.arange(10.0)), 'b': sc.Variable(1.0) }, coords={'x': sc.Variable(dims=['x'], values=np.arange(10.0))}) d1 = sc.Dataset( { 'a': sc.Variable(dims=['x'], values=np.arange(10.0)), 'b': sc.Variable(1.0) }, coords={'x': sc.Variable(dims=['x'], values=np.arange(10.0))}) assert d1['a'].coords == d['a'].coords
def test_slice(): d = sc.Dataset( { 'a': sc.Variable(dims=['x'], values=np.arange(10.0)), 'b': sc.Variable(1.0) }, coords={'x': sc.Variable(dims=['x'], values=np.arange(10.0))}) expected = sc.Dataset({ 'a': sc.DataArray(1.0 * sc.units.one, attrs={'x': 1.0 * sc.units.one}) }) assert sc.is_equal(d['x', 1], expected) assert 'a' in d['x', 1] assert 'b' not in d['x', 1]
def make_dense_dataset(ndim=1, variances=False, binedges=False, labels=False, masks=False): dim_list = ['tof', 'x', 'y', 'z', 'Q_x'] N = 50 M = 10 d = sc.Dataset() shapes = [] dims = [] for i in range(ndim): n = N - (i * M) d.coords[dim_list[i]] = sc.Variable( dims=[dim_list[i]], values=np.arange(n + binedges).astype(np.float64)) dims.append(dim_list[i]) shapes.append(n) a = np.sin(np.arange(np.prod(shapes)).reshape(*shapes).astype(np.float64)) d["Sample"] = sc.Variable(dims, values=a, unit=sc.units.counts) if variances: d["Sample"].variances = np.abs(np.random.normal(a * 0.1, 0.05)) if labels: d.coords["somelabels"] = sc.Variable([dim_list[0]], values=np.linspace( 101., 105., shapes[0]), unit=sc.units.s) if masks: d["Sample"].masks["mask"] = sc.Variable(dims, values=np.where( a > 0, True, False)) return d
def test_plot_dataset(): N = 100 ds = sc.Dataset() ds.coords['x'] = sc.Variable(['x'], values=np.arange(N), unit=sc.units.m) ds['a'] = sc.Variable(['x'], values=np.random.random(N), unit=sc.units.K) ds['b'] = sc.Variable(['x'], values=np.random.random(N), unit=sc.units.K) ds.plot()
def test_lifetime_values_of_item_of_temporary(): d = sc.Dataset( {'a': sc.Variable([Dim.X], values=np.arange(3))}, coords={Dim.X: sc.Variable([Dim.X], values=["aa", "bb", "cc"])}) vals = (d + d).coords[Dim.X].values d + d # do something allocating memory to trigger potential segfault assert vals[2] == "cc"
def test_too_many_dataset_dimensions(): d = sc.Dataset({ 'xy': sc.Variable(['x', 'y'], shape=(1, 1)), 'zt': sc.Variable(['z', Dim.Time], shape=(1, 1)) }) with pytest.raises(RuntimeError): sc.make_svg(d)
def test_dataset_with_1d_data(): d = sc.Dataset() N = 10 d.coords[Dim.Tof] = sc.Variable([Dim.Tof], values=np.arange(N).astype(np.float64)) d['Counts'] = sc.Variable([Dim.Tof], values=10.0 * np.random.rand(N)) sc.table(d)
def test_binary_ops_with_variable(self): d = sc.Dataset() d[sc.Coord.X] = (['x'], np.arange(10)) d[sc.Data.Value, "a"] = (['x'], np.arange(10)) d[sc.Data.Variance, "a"] = (['x'], np.arange(10)) d += sc.Variable(2)
def test_binary_variable_rhs_operations(self): data = np.ones(10, dtype='float64') d = sc.Dataset() d[sc.Data.Value, "a"] = (['x'], data) d[sc.Data.Variance, "a"] = (['x'], data) a = d.subset[sc.Data.Value, "a"] b_var = sc.Variable(['x'], data) c = a + b_var self.assertTrue( np.array_equal(c[sc.Data.Value, "a"].numpy, data + data)) c = a - b_var self.assertTrue( np.array_equal(c[sc.Data.Value, "a"].numpy, data - data)) c = a * b_var self.assertTrue( np.array_equal(c[sc.Data.Value, "a"].numpy, data * data)) c = a / b_var with np.errstate(invalid='ignore'): np.testing.assert_equal(c[sc.Data.Value, "a"].numpy, data / data) self._apply_test_op_rhs_variable(operator.iadd, a, b_var, data) self._apply_test_op_rhs_variable(operator.isub, a, b_var, data) self._apply_test_op_rhs_variable(operator.imul, a, b_var, data) self._apply_test_op_rhs_variable(operator.itruediv, a, b_var, data)
def test_copy(): import copy a = sc.Dataset() a['x'] = sc.Variable(value=1) _is_deep_copy_of(a, a.copy()) _is_deep_copy_of(a, copy.copy(a)) _is_deep_copy_of(a, copy.deepcopy(a))
def test_is_equal(): var = sc.Variable(['x'], values=np.array([1])) assert_export(sc.is_equal, var, var) assert_export(sc.is_equal, var['x', :], var['x', :]) ds = sc.Dataset(data={'a': var}) assert_export(sc.is_equal, ds['x', :], ds['x', :])
def test_events_does_not_repeat_dense_coords(): events = sc.Variable(['y', 'z'], shape=(3, sc.Dimensions.Events)) events.values[0].extend(np.arange(0)) events.values[2].extend(np.arange(0)) events.values[1].extend(np.arange(0)) d = sc.Dataset() d['a'] = sc.Variable(['y', 'x', 'z'], shape=(3, 2, 4), variances=True) d['b'] = sc.DataArray( events, coords={ 'y': sc.Variable(['y'], values=np.arange(4)), 'z': sc.Variable(['z'], shape=(sc.Dimensions.Events, )), "binedge": sc.Variable(['y'], values=np.random.rand(4)) }, attrs={"attr": sc.Variable(['y'], values=np.random.rand(3))}) html = BeautifulSoup(make_html(d), features="html.parser") sections = html.find_all(class_="xr-section-summary") assert ["Coordinates" in section.text for section in sections].count(True) == 2 attr_section = next(section for section in sections if "Attributes" in section.text) # check that this section is a subsection assert "sc-subsection" in attr_section.parent.attrs["class"] variables = html.find_all(class_="xr-var-name") # check that each dim is only present once assert ["z" in var.text for var in variables].count(True) == 1 assert ["y" in var.text for var in variables].count(True) == 1
def test_unit_conversion(self): import mantid.simpleapi as mantid eventWS = self.base_event_ws ws = mantid.Rebin(eventWS, 10000, PreserveEvents=False) tmp = scn.mantid.convert_Workspace2D_to_data_array(ws) target_tof = tmp.coords['tof'] ws = mantid.ConvertUnits(InputWorkspace=ws, Target="Wavelength", EMode="Elastic") converted_mantid = scn.mantid.convert_Workspace2D_to_data_array(ws) da = scn.mantid.convert_EventWorkspace_to_data_array( eventWS, load_pulse_times=False) da = sc.histogram(da, bins=target_tof) d = sc.Dataset(data={da.name: da}) converted = scn.convert(d, 'tof', 'wavelength', scatter=True) self.assertTrue( np.all(np.isclose(converted_mantid.values, converted[""].values))) self.assertTrue( np.all( np.isclose( converted_mantid.coords['wavelength'].values, converted.coords['wavelength'].values, )))
def test_create_scalar_Dataset(): dataset = sc.Dataset({'a': sc.Variable(dims=['x'], values=np.arange(4.0))}) var = sc.Variable(dataset) assert sc.is_equal(var.value, dataset) assert var.dims == [] assert var.dtype == sc.dtype.Dataset assert var.unit == sc.units.dimensionless
def test_unit_conversion(self): import mantid.simpleapi as mantid eventWS = mantid.CloneWorkspace(self.base_event_ws) ws = mantid.Rebin(eventWS, 10000, PreserveEvents=False) tmp = mantidcompat.convert_Workspace2D_to_data_array(ws) target_tof = tmp.coords['tof'] ws = mantid.ConvertUnits(InputWorkspace=ws, Target="Wavelength", EMode="Elastic") converted_mantid = mantidcompat.convert_Workspace2D_to_data_array(ws) da = mantidcompat.convert_EventWorkspace_to_data_array( eventWS, load_pulse_times=False) da.realign({'tof': target_tof}) da = sc.histogram(da) d = sc.Dataset(da) converted = sc.neutron.convert(d, 'tof', 'wavelength') self.assertTrue( np.all(np.isclose(converted_mantid.values, converted[""].values))) self.assertTrue( np.all( np.isclose( converted_mantid.coords['wavelength'].values, converted.coords['wavelength'].values, )))
def test_dataset_with_coords_only(): d = sc.Dataset() N = 10 d.coords[Dim.Tof] = sc.Variable([Dim.Tof], values=np.arange(N).astype(np.float64), variances=0.1 * np.random.rand(N)) sc.table(d)
def make_dense_dataset(ndim=1, variances=False, binedges=False, labels=False): dim_list = [sc.Dim.Tof, sc.Dim.X, sc.Dim.Y, sc.Dim.Z, sc.Dim.Qx] N = 50 M = 10 d = sc.Dataset() shapes = [] dims = [] for i in range(ndim): n = N - (i*M) d.coords[dim_list[i]] = sc.Variable( [dim_list[i]], np.arange(n + binedges).astype(np.float64)) dims.append(dim_list[i]) shapes.append(n) a = np.arange(np.prod(shapes)).reshape(*shapes).astype(np.float64) d["Sample"] = sc.Variable(dims, values=a) if variances: d["Sample"].variances = np.abs(np.random.normal(a * 0.1, 0.05)) if labels: d.labels["somelabels"] = sc.Variable( [dim_list[0]], values=np.linspace(101., 105., shapes[0]), unit=sc.units.s) return d
def test_create_scalar_Dataset(): dataset = sc.Dataset({'a': sc.Variable([sc.Dim.X], np.arange(4.0))}) var = sc.Variable(dataset) assert var.value == dataset assert var.dims == [] assert var.dtype == sc.dtype.Dataset assert var.unit == sc.units.dimensionless