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
