def test_remove_variance():
values = np.random.rand(2, 3)
variances = np.random.rand(2, 3)
var = sc.Variable(dims=['x', 'y'], values=values, variances=variances)
expected = sc.Variable(dims=['x', 'y'], values=values)
assert var.variances is not None
var.variances = None
assert var.variances is None
assert sc.is_equal(var, expected)
def test_in_place_binary_with_scalar():
v = sc.Variable(dims=['x'], values=[10.0])
copy = v.copy()
v += 2
v *= 2
v -= 4
v /= 2
assert sc.is_equal(v, copy)
def test_coord_setitem():
var = sc.Variable(dims=['x'], values=np.arange(4))
d = sc.Dataset({'a': var}, coords={'x': var})
with pytest.raises(RuntimeError):
d['x', 2:3].coords['y'] = sc.Variable(1.0)
d.coords['y'] = sc.Variable(1.0)
assert len(d) == 1
assert len(d.coords) == 2
assert sc.is_equal(d.coords['y'], sc.Variable(1.0))
def test_iadd_range():
d = sc.Dataset(
coords={'x': sc.Variable(dims=['x'], values=np.arange(4, 8))})
d['a'] = sc.Variable(dims=['x'], values=np.arange(4))
with pytest.raises(RuntimeError):
d['a']['x', 2:4] += d['a']['x', 1:3]
d['a']['x', 2:4] += d['a']['x', 2:4]
assert sc.is_equal(d['a'].data,
sc.Variable(dims=['x'], values=np.array([0, 1, 4, 6])))
def test_dataset_set_data():
d1 = sc.Dataset(
{
'a': sc.Variable(dims=['x', 'y'], values=np.random.rand(2, 3)),
'b': sc.Variable(1.0)
},
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=['y'], values=np.arange(3))
})
d2 = sc.Dataset(
{
'a': sc.Variable(dims=['x', 'y'], values=np.random.rand(2, 3)),
'b': sc.Variable(1.0)
},
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=['y'], values=np.arange(3))
})
d3 = sc.Dataset()
d3['b'] = d1['a']
assert d3['b'].data == d1['a'].data
assert d3['b'].coords == d1['a'].coords
d1['a'] = d2['a']
d1['c'] = d2['a']
assert d2['a'].data == d1['a'].data
assert d2['a'].data == d1['c'].data
d = sc.Dataset()
d.coords['row'] = sc.Variable(dims=['row'], values=np.arange(10.0))
d['a'] = sc.Variable(dims=['row'],
values=np.arange(10.0),
variances=np.arange(10.0))
d['b'] = sc.Variable(dims=['row'], values=np.arange(10.0, 20.0))
d1 = d['row', 0:1]
d2 = sc.Dataset({'a': d1['a'].data}, coords={'row': d1['a'].coords['row']})
d2['b'] = d1['b']
expected = sc.Dataset()
expected.coords['row'] = sc.Variable(dims=['row'], values=np.arange(1.0))
expected['a'] = sc.Variable(dims=['row'],
values=np.arange(1.0),
variances=np.arange(1.0))
expected['b'] = sc.Variable(dims=['row'], values=np.arange(10.0, 11.0))
assert sc.is_equal(d2, expected)
def test_numpy_self_assign_shift_2d_flip_first():
# Special case of shift combined with negative stride: Essentially we walk
# backwards from "begin", but away from "end" since the outer dim has a
# positive stride, so a naive range check based does not catch this case.
var = sc.Variable(dims=['y', 'x'], values=np.arange(9).reshape(3, 3))
expected = sc.Variable(dims=['y', 'x'],
values=np.array([[0, 1, 2], [3, 3, 4], [6, 0, 1]]))
var['y', 1:3]['x', 1:3].values = np.flip(var['y', 0:2]['x', 0:2].values,
axis=0)
assert sc.is_equal(var, expected)
def test_view_in_place_binary_with_scalar():
d = sc.Dataset({'data': sc.Variable(dims=['x'], values=[10.0])},
coords={'x': sc.Variable(dims=['x'], values=[10])})
copy = d.copy()
d['x', :] += 2
d['x', :] *= 2
d['x', :] -= 4
d['x', :] /= 2
assert sc.is_equal(d, copy)
def test_in_place_binary_with_dataarray():
da = sc.DataArray(
data=sc.Variable(['x'], values=np.arange(1.0, 10.0)),
coords={'x': sc.Variable(['x'], values=np.arange(1.0, 10.0))})
orig = da.copy()
da += orig
da -= orig
da *= orig
da /= orig
assert sc.is_equal(da, orig)
def test_in_place_binary_with_variable():
a = sc.DataArray(data=sc.Variable(['x'], values=np.arange(10.0)),
coords={'x': sc.Variable(['x'], values=np.arange(10.0))})
copy = a.copy()
a += 2.0 * sc.units.dimensionless
a *= 2.0 * sc.units.m
a -= 4.0 * sc.units.m
a /= 2.0 * sc.units.m
assert sc.is_equal(a, copy)
def test_in_place_binary_with_scalar():
a = sc.DataArray(data=sc.Variable(['x'], values=[10.0]),
coords={'x': sc.Variable(['x'], values=[10])})
copy = a.copy()
a += 2
a *= 2
a -= 4
a /= 2
assert sc.is_equal(a, copy)
def test_dataset_to_dict():
ds = sc.Dataset()
ds.coords["x"] = sc.Variable(dims=["x"], values=np.arange(10))
ds.coords["y"] = sc.Variable(dims=["y"],
values=np.arange(5),
unit=sc.units.m)
ds["a"] = sc.Variable(dims=["y", "x"], values=np.random.random([5, 10]))
ds["b"] = sc.Variable(dims=["y", "x"],
values=np.random.random([5, 10]),
variances=np.random.random([5, 10]),
unit=sc.units.s)
ds["a"].masks["amask"] = sc.Variable(
dims=["y"], values=[True, True, False, True, False])
# Note that attributes complicate things here, as they are duplicated in
# each entry during the conversion to dict. So for now, we leave attributes
# out.
ds_dict = sc.to_dict(ds)
assert sc.is_equal(sc.from_dict(ds_dict["a"]), ds["a"])
assert sc.is_equal(sc.from_dict(ds_dict["b"]), ds["b"])
def test_init_from_variable_views():
var = sc.Variable(['x'], values=np.arange(5))
a = sc.DataArray(data=var,
coords={'x': var},
unaligned_coords={'meta': var},
masks={'mask1': sc.less(var, sc.Variable(value=3))})
b = sc.DataArray(data=a.data,
coords={'x': a.coords['x']},
unaligned_coords={'meta': a.unaligned_coords['meta']},
masks={'mask1': a.masks['mask1']})
assert sc.is_equal(a, b)
# Ensure mix of Variables and Variable views work
c = sc.DataArray(data=a.data,
coords={'x': var},
unaligned_coords={'meta': a.unaligned_coords['meta']},
masks={'mask1': a.masks['mask1']})
assert sc.is_equal(a, c)
def test_collapse_dataset():
d = make_dataset()
collapsed = sc.collapse(d, keep='tof')
# In a Dataset, the order of the dims is not fixed
first_key = list(collapsed.keys())[0]
if first_key.startswith('x'):
dim1 = 'x'
dim2 = 'y'
else:
dim1 = 'y'
dim2 = 'x'
assert sc.is_equal(collapsed['{}:0-{}:0'.format(dim1, dim2)],
d[dim2, 0][dim1, 0])
assert sc.is_equal(collapsed['{}:0-{}:1'.format(dim1, dim2)],
d[dim2, 1][dim1, 0])
assert sc.is_equal(collapsed['{}:1-{}:0'.format(dim1, dim2)],
d[dim2, 0][dim1, 1])
assert sc.is_equal(collapsed['{}:1-{}:1'.format(dim1, dim2)],
d[dim2, 1][dim1, 1])
def test_eq():
da = make_dataarray()
assert sc.is_equal(da['x', :], da)
assert sc.is_equal(da['y', :], da)
assert sc.is_equal(da['y', :]['x', :], da)
assert not sc.is_equal(da['y', 1:], da)
assert not sc.is_equal(da['x', 1:], da)
assert not sc.is_equal(da['y', 1:]['x', :], da)
assert not sc.is_equal(da['y', :]['x', 1:], da)
def test_binary_of_item_with_variable():
d = sc.Dataset(
{'data': sc.Variable(dims=['x'], values=np.arange(10.0))},
coords={'x': sc.Variable(dims=['x'], values=np.arange(10.0))})
copy = d.copy()
d['data'] += 2.0 * sc.units.dimensionless
d['data'] *= 2.0 * sc.units.m
d['data'] -= 4.0 * sc.units.m
d['data'] /= 2.0 * sc.units.m
assert sc.is_equal(d, copy)
def test_binary__with_dataarray():
da = sc.DataArray(
data=sc.Variable(dims=['x'], values=np.arange(1.0, 10.0)),
coords={'x': sc.Variable(dims=['x'], values=np.arange(1.0, 10.0))})
ds = sc.Dataset({da.name: da})
orig = ds.copy()
ds += da
ds -= da
ds *= da
ds /= da
assert sc.is_equal(ds, orig)
def test_bins_arithmetic():
var = sc.Variable(dims=['event'], values=[1.0, 2.0, 3.0, 4.0])
table = sc.DataArray(var, {'x': var})
binned = sc.bin(table, [sc.Variable(dims=['x'], values=[1.0, 5.0])])
hist = sc.DataArray(
data=sc.Variable(dims=['x'], values=[1.0, 2.0]),
coords={'x': sc.Variable(dims=['x'], values=[1.0, 3.0, 5.0])})
binned.bins *= sc.lookup(func=hist, dim='x')
assert sc.is_equal(
binned.bins.data.data,
sc.Variable(dims=['event'], values=[1.0, 2.0, 6.0, 8.0]))
def test_binary_with_broadcast():
da = sc.DataArray(data=sc.Variable(['x', 'y'],
values=np.arange(20).reshape(5, 4)),
coords={
'x': sc.Variable(['x'],
values=np.arange(0.0, 0.6, 0.1)),
'y': sc.Variable(['y'],
values=np.arange(0.0, 0.5, 0.1))
})
d2 = da - da['x', 0]
da -= da['x', 0]
assert sc.is_equal(da, d2)
def test_variable_matrix_round_trip():
data = np.array([
np.arange(9.0).reshape(3, 3),
np.arange(5.0, 14.0).reshape(3, 3),
np.arange(1.0, 10.0).reshape(3, 3),
np.arange(2.0, 11.0).reshape(3, 3)
])
var = sc.Variable(['x'],
values=data,
unit=sc.units.m,
dtype=sc.dtype.matrix_3_float64)
assert sc.is_equal(var, sc.from_dict(sc.to_dict(var)))
def test_nan_to_num_out_with_multiple_special_replacements():
a = sc.Variable(dims=['x'], values=np.array([1, np.inf, -np.inf, np.nan]))
out = sc.Variable(dims=['x'], values=np.zeros(4))
replace = sc.Variable(value=0.0)
# just replace nans
sc.nan_to_num(a, nan=replace, out=out)
expected = sc.Variable(dims=['x'],
values=np.array([1, np.inf, -np.inf,
replace.value]))
assert sc.is_equal(out, expected)
# replace neg inf
sc.nan_to_num(out, neginf=replace, out=out)
expected = sc.Variable(dims=['x'],
values=np.array(
[1, np.inf, replace.value, replace.value]))
assert sc.is_equal(out, expected)
# replace pos inf
sc.nan_to_num(out, posinf=replace, out=out)
expected = sc.Variable(dims=['x'],
values=np.array([1] + [replace.value] * 3))
assert sc.is_equal(out, expected)
def test_neutron_beamline():
d = make_dataset_with_beamline()
assert sc.is_equal(
sc.neutron.source_position(d),
sc.Variable(value=np.array([0, 0, -10]),
dtype=sc.dtype.vector_3_float64,
unit=sc.units.m))
assert sc.is_equal(
sc.neutron.sample_position(d),
sc.Variable(value=np.array([0, 0, 0]),
dtype=sc.dtype.vector_3_float64,
unit=sc.units.m))
assert sc.is_equal(sc.neutron.l1(d), 10.0 * sc.units.m)
assert sc.is_equal(
sc.neutron.l2(d),
sc.Variable(dims=['position'], values=np.ones(4), unit=sc.units.m))
two_theta = sc.neutron.two_theta(d)
assert two_theta.unit == sc.units.rad
assert two_theta.dims == ['position']
assert sc.is_equal(sc.neutron.scattering_angle(d), 0.5 * two_theta)
def test_variable_0D_matrix():
# Use known rotation (180 deg around z) to check correct construction
rot = sc.Variable(value=sc.rotation_matrix_from_quaternion_coeffs(
[0, 0, 1, 0]),
unit=sc.units.one,
dtype=sc.dtype.matrix_3_float64)
vec = sc.Variable(value=[1, 2, 3],
unit=sc.units.m,
dtype=sc.dtype.vector_3_float64)
rotated = sc.Variable(value=[-1, -2, 3],
unit=sc.units.m,
dtype=sc.dtype.vector_3_float64)
assert sc.is_equal(rot * vec, rotated)
def test_binary_equal():
a, b, a_slice, b_slice, data = make_variables()
assert sc.is_equal(a, b)
assert sc.is_equal(a, a_slice)
assert sc.is_equal(a_slice, b_slice)
assert sc.is_equal(b, a)
assert sc.is_equal(b_slice, a)
assert sc.is_equal(b_slice, a_slice)
def test_data_array_from_dict():
da_dict = {
"coords": {
"x": {
"dims": ["x"],
"values": np.arange(10)
},
"y": {
"dims": ["y"],
"values": np.arange(5),
"unit": sc.units.m
},
},
"masks": {
"amask": {
"dims": ["y"],
"values": [True, True, False, True, False]
}
},
"attrs": {
"attr1": {
"dims": ["x"],
"values": np.random.random(10)
}
},
"data": {
"dims": ["y", "x"],
"values": np.random.random([5, 10])
}
}
da = sc.from_dict(da_dict)
assert sc.is_equal(da.coords["x"], sc.from_dict(da_dict["coords"]["x"]))
assert sc.is_equal(da.coords["y"], sc.from_dict(da_dict["coords"]["y"]))
assert sc.is_equal(da.masks["amask"],
sc.from_dict(da_dict["masks"]["amask"]))
assert sc.is_equal(da.attrs["attr1"],
sc.from_dict(da_dict["attrs"]["attr1"]))
assert sc.is_equal(da.data, sc.from_dict(da_dict["data"]))
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_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 test_data_array_round_trip():
da = sc.DataArray(coords={
"x":
sc.Variable(dims=["x"], values=np.arange(10.)),
"y":
sc.Variable(dims=["y"], values=np.arange(5), unit=sc.units.m),
},
masks={
"amask":
sc.Variable(dims=["y"],
values=[True, True, False, True, False])
},
data=sc.Variable(dims=["y", "x"],
values=np.random.random([5, 10])))
assert sc.is_equal(da, sc.from_dict(sc.to_dict(da)))
def test_dataset_round_trip():
ds = sc.Dataset()
ds.coords["x"] = sc.Variable(dims=["x"], values=np.arange(10))
ds.coords["y"] = sc.Variable(dims=["y"],
values=np.arange(5),
unit=sc.units.m)
ds["a"] = sc.Variable(dims=["y", "x"], values=np.random.random([5, 10]))
ds["b"] = sc.Variable(dims=["y", "x"],
values=np.random.random([5, 10]),
variances=np.random.random([5, 10]),
unit=sc.units.s)
ds["a"].masks["amask"] = sc.Variable(
dims=["y"], values=[True, True, False, True, False])
# Note that round trip would not work if attrs are present, since they get
# become a per-item attribute during the conversion to dict.
assert sc.is_equal(ds, sc.from_dict(sc.to_dict(ds)))
def test_EventWorkspace_realign_events(self):
import mantid.simpleapi as mantid
eventWS = mantid.CloneWorkspace(self.base_event_ws)
realigned = mantidcompat.convert_EventWorkspace_to_data_array(
eventWS, realign_events=True, load_pulse_times=False)
d = mantidcompat.convert_EventWorkspace_to_data_array(
eventWS, realign_events=False, load_pulse_times=False)
d.realign({'tof': realigned.coords['tof']})
# Removing run and sample due to missing comparison operators
del d.unaligned_coords['run']
del d.unaligned_coords['sample']
del realigned.unaligned_coords['run']
del realigned.unaligned_coords['sample']
assert sc.is_equal(realigned, d)
def test_nan_to_nan_with_multiple_special_replacements():
a = sc.Variable(dims=['x'], values=np.array([1, np.nan, np.inf, -np.inf]))
replace_nan = sc.Variable(value=-1.0)
replace_pos_inf = sc.Variable(value=-2.0)
replace_neg_inf = sc.Variable(value=-3.0)
b = sc.nan_to_num(a,
nan=replace_nan,
posinf=replace_pos_inf,
neginf=replace_neg_inf)
expected = sc.Variable(
dims=['x'],
values=np.array([1] + [
repl.value
for repl in [replace_nan, replace_pos_inf, replace_neg_inf]
]))
assert sc.is_equal(b, expected)
