def test_validation_fail():
"""Test if invalid data fails the validation,"""
dd = DataDict(
x=dict(values=[1, 2]),
y=dict(values=[1, 2], axes=['x']),
)
assert dd.validate()
dd = DataDict(
x=dict(values=[1, 2, 3]),
y=dict(values=[1, 2], axes=['x']),
)
with pytest.raises(ValueError):
dd.validate()
def test_expansion_fail():
"""Test whether expansion fails correctly"""
dd = DataDict(a=dict(values=np.arange(4).reshape(2, 2)),
b=dict(values=np.arange(4).reshape(2, 2), axes=['a']),
x=dict(values=np.arange(6).reshape(2, 3), ),
y=dict(values=np.arange(6).reshape(2, 3), axes=['x']))
assert dd.validate()
assert not dd.is_expandable()
with pytest.raises(ValueError):
dd.expand()
def _make_testdata(complex: bool = False):
x = np.linspace(-1, 1, 101)
y = np.arange(7)
z = np.linspace(0, 100, 16)
xx, yy, zz = np.meshgrid(x, y, z, indexing='ij')
rr = np.random.normal(loc=0, scale=1, size=xx.shape)
if complex:
ii = np.random.normal(loc=0, scale=1, size=xx.shape)
nn = rr + 1j * ii
else:
nn = rr
return datadict_to_meshgrid(
DataDict(
x=dict(values=xx),
y=dict(values=yy),
z=dict(values=zz),
noise=dict(values=nn, axes=['x', 'y', 'z']),
))
def data(self) -> Iterable[DataDictBase]:
x = np.linspace(0, 10, self.nx)
y = np.linspace(0, 2 * np.pi, self.ny)
xx, yy = np.meshgrid(x, y, indexing='ij')
zz = np.exp(-1j * (0.5 * xx + yy))
data = DataDict(time=dict(values=xx.flatten()),
phase=dict(values=yy.flatten()),
data=dict(values=zz.flatten(), axes=['time', 'phase']),
conjugate=dict(values=zz.conj().flatten(),
axes=['time', 'phase']))
data.add_meta("title",
"A complex data image (phasor vs time and phase)")
data.add_meta("info",
"This is a test data set to test complex data display.")
yield data
def three_incompatible_3d_sets(nx=3, ny=3, nz=3, rand_factor=1):
x = np.linspace(0, 10, nx)
y = np.linspace(-5, 5, ny)
z = np.arange(nz)
xx, yy, zz = np.meshgrid(x, y, z, indexing='ij')
dd = np.cos(xx) * np.sin(yy) + rand_factor * np.random.rand(*zz.shape)
dd2 = np.sin(xx) * np.cos(yy) + rand_factor * np.random.rand(*zz.shape)
d = DataDict(x=dict(values=xx.reshape(-1), unit='mA'),
y=dict(values=yy.reshape(-1), unit='uC'),
z=dict(values=zz.reshape(-1), unit='nF'),
data=dict(values=dd.reshape(-1),
axes=['x', 'y', 'z'],
unit='kW'),
more_data=dict(values=dd2.reshape(-1),
axes=['x', 'y', 'z'],
unit='MV'),
different_data=dict(values=dd2.T.reshape(-1),
axes=['z', 'y', 'x'],
unit='TS'))
return d
def test_update_qcloader(qtbot, empty_db_path):
db_path = empty_db_path
exp = load_or_create_experiment('2d_softsweep', sample_name='no sample')
N = 2
m = qc.Measurement(exp=exp)
m.register_custom_parameter('x')
m.register_custom_parameter('y')
dd_expected = DataDict(x=dict(values=np.array([])),
y=dict(values=np.array([])))
for n in range(N):
m.register_custom_parameter(f'z_{n}', setpoints=['x', 'y'])
dd_expected[f'z_{n}'] = dict(values=np.array([]), axes=['x', 'y'])
dd_expected.validate()
# setting up the flowchart
fc = linearFlowchart(('loader', QCodesDSLoader))
loader = fc.nodes()['loader']
def check():
nresults = ds.number_of_results
loader.update()
ddict = fc.output()['dataOut']
if ddict is not None and nresults > 0:
z_in = dd_expected.data_vals('z_1')
z_out = ddict.data_vals('z_1')
if z_out is not None:
assert z_in.size == z_out.size
assert np.allclose(z_in, z_out, atol=1e-15)
with m.run() as datasaver:
ds = datasaver.dataset
run_id = datasaver.dataset.captured_run_id
loader.pathAndId = db_path, run_id
for result in testdata.generate_2d_scalar_simple(3, 3, N):
row = [(k, v) for k, v in result.items()]
datasaver.add_result(*row)
dd_expected.add_data(**result)
check()
check()
def test_append():
"""Testing appending datadicts to each other."""
dd1 = DataDict(
x=dict(values=[1, 2, 3]),
y=dict(values=np.arange(6).reshape(3, 2), axes=['x']),
)
dd2 = DataDict(
x=dict(values=[4, 5, 6]),
y=dict(values=np.arange(6, 12).reshape(3, 2), axes=['x']),
)
dd3 = dd1 + dd2
assert np.all(np.isclose(dd3.data_vals('y'), np.arange(12).reshape(6, 2)))
assert np.all(np.isclose(dd3.data_vals('x'), np.arange(1, 7)))
dd1.append(dd2)
assert np.all(np.isclose(dd1.data_vals('y'), np.arange(12).reshape(6, 2)))
assert np.all(np.isclose(dd1.data_vals('x'), np.arange(1, 7)))
def test_nontrivial_expansion():
"""test expansion when different dependents require different
expansion of an axis."""
a = np.arange(4)
b = np.arange(4 * 2).reshape(4, 2)
x = np.arange(4)
y = np.arange(4 * 2).reshape(4, 2)
dd = DataDict(a=dict(values=a),
b=dict(values=b),
x=dict(values=x, axes=['a']),
y=dict(values=y, axes=['a', 'b']))
assert dd.validate()
assert dd.is_expandable()
dd_x = dd.extract('x').expand()
assert num.arrays_equal(a, dd_x.data_vals('a'))
dd_y = dd.extract('y').expand()
assert num.arrays_equal(a.repeat(2), dd_y.data_vals('a'))
def test_load_2dsoftsweep(experiment):
N = 5
m = qc.Measurement(exp=experiment)
m.register_custom_parameter('x', unit='cm')
m.register_custom_parameter('y')
# check that unused parameters don't mess with
m.register_custom_parameter('foo')
dd_expected = DataDict(x=dict(values=np.array([]), unit='cm'),
y=dict(values=np.array([])))
for n in range(N):
m.register_custom_parameter(f'z_{n}', setpoints=['x', 'y'])
dd_expected[f'z_{n}'] = dict(values=np.array([]), axes=['x', 'y'])
dd_expected.validate()
with m.run() as datasaver:
for result in testdata.generate_2d_scalar_simple(3, 3, N):
row = [(k, v) for k, v in result.items()] + [('foo', 1)]
datasaver.add_result(*row)
dd_expected.add_data(**result)
# retrieve data as data dict
ddict = ds_to_datadict(datasaver.dataset)
assert ddict == dd_expected
def test_meta():
"""Test accessing meta information."""
dd = DataDict(
x=dict(
values=[1, 2, 3],
__meta1__='abc',
__meta2__='def',
),
y=dict(
values=[1, 2, 3],
axes=['x'],
__meta3__='123',
__meta4__=None,
),
__info__=lambda x: 0,
__more_info__=object,
)
dd['__1234!__'] = '```'
dd.add_meta('###', 3e-12)
dd.add_meta('@^&', 0, data='x')
assert dd.validate()
global_meta = {k: v for k, v in dd.meta_items()}
for k in ['info', 'more_info', '1234!', '###']:
assert f'__{k}__' in dd
assert k in global_meta
assert dd.meta_val('more_info') == object
assert dd.meta_val('info')(1) == 0
assert dd.meta_val('@^&', 'x') == 0
for k in ['meta1', 'meta2', '@^&']:
assert dd.meta_val(k, data='x') == dd['x'][f'__{k}__']
assert f'__{k}__' in dd['x']
assert k in [n for n, _ in dd.meta_items('x')]
# test stripping of meta information
dd.clear_meta()
assert dd.validate()
nmeta = 0
for k, _ in dd.items():
if k[:2] == '__' and k[-2:] == '__':
nmeta += 1
assert nmeta == 0
for d, v in dd.data_items():
for k, _ in dd[d].items():
if k[:2] == '__' and k[-2:] == '__':
nmeta += 1
assert nmeta == 0
def test_combine_ddicts():
"""test the datadict combination function"""
# first case: two ddicts with different independents and shared axes.
# should work. probably the most common use case.
dd1 = DataDict(x=dict(values=np.array([1, 2, 3]), ),
y=dict(values=np.array([1, 2, 3]), ),
z1=dict(
values=np.array([1, 2, 3]),
axes=['x', 'y'],
))
dd1.validate()
dd2 = DataDict(x=dict(values=np.array([1, 2, 3]), ),
y=dict(values=np.array([1, 2, 3]), ),
z2=dict(
values=np.array([3, 2, 1]),
axes=['x', 'y'],
))
dd2.validate()
combined_dd = combine_datadicts(dd1, dd2)
expected_dd = DataDict(
x=dict(values=np.array([1, 2, 3]), ),
y=dict(values=np.array([1, 2, 3]), ),
z1=dict(
values=np.array([1, 2, 3]),
axes=['x', 'y'],
),
z2=dict(
values=np.array([3, 2, 1]),
axes=['x', 'y'],
),
)
expected_dd.validate()
assert combined_dd == expected_dd
# second case: two ddicts with a conflict in an axis
dd1 = DataDict(x=dict(values=np.array([1, 2, 3]), ),
y=dict(values=np.array([1, 2, 3]), ),
z1=dict(
values=np.array([1, 2, 3]),
axes=['x', 'y'],
))
dd1.validate()
dd2 = DataDict(x=dict(values=np.array([1, 2, 4]), ),
y=dict(values=np.array([1, 2, 3]), ),
z2=dict(
values=np.array([3, 2, 1]),
axes=['x', 'y'],
))
dd2.validate()
combined_dd = combine_datadicts(dd1, dd2)
expected_dd = DataDict(x=dict(values=np.array([1, 2, 3]), ),
y=dict(values=np.array([1, 2, 3]), ),
z1=dict(
values=np.array([1, 2, 3]),
axes=['x', 'y'],
),
x_0=dict(values=np.array([1, 2, 4]), ),
z2=dict(
values=np.array([3, 2, 1]),
axes=['x_0', 'y'],
))
expected_dd.validate()
assert combined_dd == expected_dd
# third case: rename a dependent only
x = np.array([1, 2, 3])
y = np.array([1, 2, 3])
z = np.arange(3)
dd1 = DataDict(x=dict(values=x),
y=dict(values=y),
z=dict(values=z, axes=['x', 'y']))
dd1.validate()
dd2 = dd1.copy()
dd2['z']['values'] = z[::-1]
dd2.validate()
combined_dd = combine_datadicts(dd1, dd2)
expected_dd = DataDict(x=dict(values=x),
y=dict(values=y),
z=dict(values=z, axes=['x', 'y']),
z_0=dict(values=z[::-1], axes=['x', 'y']))
assert combined_dd == expected_dd
