def test_meshgrid_conversion():
"""Test making a meshgrid from a dataset"""
a = np.linspace(0, 1, 11)
b = np.arange(5)
aa, bb = np.meshgrid(a, b, indexing='ij')
zz = aa * bb
dd = DataDict(
a=dict(values=aa.reshape(-1)),
b=dict(values=bb.reshape(-1)),
z=dict(values=zz.reshape(-1), axes=['a', 'b']),
__info__='some info',
)
dd2 = datadict_to_meshgrid(dd, target_shape=(11, 5))
assert DataDictBase.same_structure(dd, dd2)
assert num.arrays_equal(dd2.data_vals('a'), aa)
assert num.arrays_equal(dd2.data_vals('z'), zz)
dd2 = datadict_to_meshgrid(dd, target_shape=None)
assert DataDictBase.same_structure(dd, dd2)
assert num.arrays_equal(dd2.data_vals('a'), aa)
assert num.arrays_equal(dd2.data_vals('z'), zz)
# test the case where inner/outer
aa, bb = np.meshgrid(a, b, indexing='xy')
zz = aa * bb
dd = DataDict(
a=dict(values=aa.reshape(-1)),
b=dict(values=bb.reshape(-1)),
z=dict(values=zz.reshape(-1), axes=['a', 'b']),
__info__='some info',
)
dd2 = datadict_to_meshgrid(dd,
target_shape=(5, 11),
inner_axis_order=['b', 'a'])
assert DataDictBase.same_structure(dd, dd2)
assert num.arrays_equal(dd2.data_vals('a'), np.transpose(aa, (1, 0)))
assert num.arrays_equal(dd2.data_vals('z'), np.transpose(zz, (1, 0)))
dd2 = datadict_to_meshgrid(dd, target_shape=None)
assert DataDictBase.same_structure(dd, dd2)
assert num.arrays_equal(dd2.data_vals('a'), np.transpose(aa, (1, 0)))
assert num.arrays_equal(dd2.data_vals('z'), np.transpose(zz, (1, 0)))
def sinefit(self, dataIn: DataDictBase = None):
if dataIn is None:
return None
# this is just a ghetto example: only support very simple datasets
naxes = len(dataIn.axes())
ndeps = len(dataIn.dependents())
if not (naxes == 1 and ndeps == 1):
return dict(dataOut=dataIn)
# getting the data
axname = dataIn.axes()[0]
x = dataIn.data_vals(axname)
y = dataIn.data_vals(dataIn.dependents()[0])
# try to fit
sinemodel = lmfit.Model(sinefunc)
p0 = sinemodel.make_params(amp=1, freq=self.frequencyGuess, phase=0)
result = sinemodel.fit(y, p0, x=x)
# if the fit works, add the fit result to the output
dataOut = dataIn.copy()
if result.success:
dataOut['fit'] = dict(values=result.best_fit, axes=[
axname,
])
dataOut.add_meta('info', result.fit_report())
else:
dataOut.add_meta('info', 'Could not fit sine.')
return dict(dataOut=dataOut)
def setMeta(self, data: DataDictBase) -> None:
"""Add meta info contained in the data to the figure.
:param data: data object containing the meta information
if meta field ``title`` or ``info`` are in the data object, then
they will be added as text info to the figure.
"""
if data.has_meta('title'):
self.plot.setFigureTitle(data.meta_val('title'))
if data.has_meta('info'):
self.plot.setFigureInfo(data.meta_val('info'))
all_meta = {}
for k, v in sorted(data.meta_items()):
this_meta = str(v)
if len(this_meta) > 200:
this_meta = this_meta[:200] + "..."
all_meta[k] = this_meta
self.plot.setMetaInfo(all_meta)
def test_reorder():
"""Test reordering and transposing axes."""
dd = DataDictBase(a=dict(values=[4, 5, 6], axes=[]),
b=dict(values=[5, 6, 7], axes=[]),
c=dict(values=[6, 7, 8], axes=[]),
d=dict(values=[0, 0, 0], axes=['a', 'b', 'c']))
assert dd.axes('d') == ['a', 'b', 'c']
dd = dd.reorder_axes('d', b=0, a=1, c=2)
assert dd.axes('d') == ['b', 'a', 'c']
dd = dd.reorder_axes(c=0)
assert dd.axes('d') == ['c', 'b', 'a']
def test_sanitizing():
"""Test cleaning up of datasets."""
dd = DataDictBase(
x=dict(values=[0]),
y=dict(values=[0]),
z=dict(values=[0], axes=['y']),
)
dd = dd.sanitize()
assert dd.axes() == ['y']
assert dd.dependents() == ['z']
assert dd.validate()
def test_get_data():
"""Test basic accessing of data."""
dd = DataDictBase(
x=dict(values=[1, 2, 3]),
y=dict(values=[1, 2, 3], axes=['x']),
a=dict(values=[4, 5, 6], axes=[]),
b=dict(values=[5, 6, 7], axes=[]),
c=dict(values=[6, 7, 8], axes=['b', 'a']),
)
assert set(dd.dependents()) == {'y', 'c'}
assert set(dd.axes()) == {'a', 'b', 'x'}
assert dd.axes('c') == ['b', 'a']
assert dd.data_vals('c') == [6, 7, 8]
def test_equality():
"""test whether direct comparison of datasets is working."""
dd1 = DataDict(
x=dict(values=np.arange(5), unit='A'),
y=dict(values=np.arange(5)**2, axes=['x']),
)
assert dd1.validate()
dd1.add_meta('some_info', 'some_value')
dd2 = dd1.copy()
assert datasets_are_equal(dd1, dd2)
assert dd1 == dd2
dd2 = dd1.copy()
dd2.delete_meta('some_info')
assert not datasets_are_equal(dd1, dd2)
assert not dd1 == dd2
assert datasets_are_equal(dd1, dd2, ignore_meta=True)
dd2 = dd1.copy()
dd2['x']['unit'] = 'B'
assert not datasets_are_equal(dd1, dd2)
dd2 = dd1.copy()
dd2['y']['values'][-1] -= 1
assert not datasets_are_equal(dd1, dd2)
dd2 = DataDictBase(**dd1)
assert not datasets_are_equal(dd1, dd2)
dd2 = datadict_to_meshgrid(dd1)
assert not datasets_are_equal(dd1, dd2)
dd2 = dd1.copy()
dd2['w'] = dict(values=np.arange(5), unit='C')
dd2['y']['axes'] = ['w', 'x']
assert not datasets_are_equal(dd1, dd2)
assert not dd1 == 'abc'
def sinefit(self, dataIn: DataDictBase = None):
if dataIn is None:
return None
if len(dataIn.axes()) > 1 or len(dataIn.dependents()) > 1:
return dict(dataOut=dataIn)
axname = dataIn.axes()[0]
x = dataIn.data_vals(axname)
y = dataIn.data_vals(dataIn.dependents()[0])
sinemodel = lmfit.Model(sinefunc)
p0 = sinemodel.make_params(amp=1, freq=self.frequencyGuess, phase=0)
result = sinemodel.fit(y, p0, x=x)
dataOut = dataIn.copy()
if result.success:
dataOut['fit'] = dict(values=result.best_fit, axes=[
axname,
])
dataOut.add_meta('info', result.fit_report())
return dict(dataOut=dataOut)
def test_structure():
"""Test if structure is reported correctly."""
dd = DataDictBase(
x=dict(values=[1, 2, 3, 1]),
y=dict(values=[1, 2, 3, 1]),
z=dict(values=[0, 0, 0, 0], axes=['x', 'y']),
__info__='some info',
)
dd2 = DataDictBase(
x=dict(values=[2, 3, 4]),
y=dict(values=[10, 20, 30]),
z=dict(values=[-1, -3, -5], axes=['x', 'y']),
__otherinfo__=0,
)
assert dd.structure().dependents() == ['z']
assert dd.structure().axes('z') == ['x', 'y']
assert dd.structure(include_meta=False) == \
dd2.structure(include_meta=False)
assert dd.structure(include_meta=True) != \
dd2.structure(include_meta=True)
assert DataDictBase.same_structure(dd, dd2)