def test_add_comment(self):
ds0 = DataSet2D()
ds = DataSet2D()
try:
add_comment('hello world')
except NotImplementedError:
ds.metadata['comment'] = 'hello world'
add_comment('hello world 0', ds0)
self.assertTrue(ds.metadata['comment'] == 'hello world')
self.assertTrue(ds0.metadata['comment'] == 'hello world 0')
def test_numpy_on_dataset(verbose=0):
all_data = DataSet2D()
x = all_data.z
_ = np.array(x)
s = np.linalg.svd(x)
if verbose:
print(s)
def test_qcodes_dataset_encoding(self):
dataset = DataSet2D()
json_data = encode_json(dataset)
self.assertIsInstance(json_data, str)
dataset2 = decode_json(json_data)
self.assertIsInstance(dataset2, DataSet)
def test_slice_dataset_copy_metadata(self):
dataset = DataSet2D()
dataset.metadata['a'] = 1
dataset_sliced = slice_dataset(dataset, [2, 5])
self.assertDictEqual(dataset_sliced.metadata, {})
dataset_sliced = slice_dataset(dataset, [2, 5], copy_metadata=True)
self.assertDictEqual(dataset_sliced.metadata, dataset.metadata)
def test_average_dataset(self):
dataset2d = DataSet2D()
d = average_dataset(dataset2d, axis=0)
self.assertEqual(d.z.shape, (4,))
d = average_dataset(dataset2d, axis=1)
self.assertEqual(d.z.shape, (6,))
def test_image_transform(verbose=0):
ds = DataSet2D()
tr = image_transform(ds)
im = tr.image()
if verbose:
print('transform: im.shape %s' % (str(im.shape),))
tr = image_transform(ds, unitsperpixel=[None, 2])
im = tr.image()
if verbose:
print('transform: im.shape %s' % (str(im.shape),))
def test_image_operations(self, verbose=0):
if verbose:
print('testing resampleImage')
ds = DataSet2D()
_, _ = resampleImage(ds.z)
z = self.test_array()
_, _ = resampleImage(z)
if verbose:
print('testing diffImage')
_ = diffImage(ds.z, dy='x')
def test_average_multirow_dataset(self):
dataset2d = DataSet2D()
averaged_dataset = average_multirow_dataset(dataset2d, 2)
self.assertEqual(averaged_dataset.signal.shape, (3, 4))
np.testing.assert_array_equal(averaged_dataset.signal, np.array(
[[0.5, 1.5, 4.5, 9.5], [6.5, 7.5, 10.5, 15.5], [20.5, 21.5, 24.5, 29.5]]))
averaged_dataset = average_multirow_dataset(dataset2d, 2, [-1, -2, -3])
np.testing.assert_array_equal(averaged_dataset.x, [-1, -2, -3])
with self.assertRaises(AssertionError):
np.testing.assert_array_equal(averaged_dataset.x, [-1, -2, -3, -4])
def test_slice_dataset(self):
dataset = DataSet1D()
dataset_sliced = slice_dataset(dataset, [2, 5])
self.assertEqual(dataset_sliced.default_parameter_array().shape, (3,))
dataset = DataSet2D()
dataset_sliced = slice_dataset(dataset, [3, 5], axis=0)
np.testing.assert_array_equal(dataset_sliced.z, np.array([[9, 10, 13, 18], [16, 17, 20, 25]]))
dataset_sliced = slice_dataset(dataset, [1, 5], axis=1)
np.testing.assert_array_equal(dataset_sliced.z, np.array(
[[1, 4], [2, 5], [5, 8], [10, 13], [17, 20], [26, 29]]))
def test_dataset_to_dictionary(self):
input_dataset = DataSet2D()
data_dictionary = dataset_to_dictionary(input_dataset, include_data=False, include_metadata=False)
self.assertIsNone(data_dictionary['metadata'])
data_dictionary = dataset_to_dictionary(input_dataset, include_data=True, include_metadata=True)
self.assertTrue('metadata' in data_dictionary)
converted_dataset = dictionary_to_dataset(data_dictionary)
self.assertEqual(converted_dataset.default_parameter_name(), input_dataset.default_parameter_name())
def test_resample_dataset(self):
dataset1d = DataSet1D()
dataset2d = DataSet2D()
with self.assertRaises(ValueError):
d = resample_dataset(dataset1d, (0, 1))
d = resample_dataset(dataset1d, (4,))
self.assertEqual(d.y.shape, (2,))
d = resample_dataset(dataset2d, (2, 1))
np.testing.assert_array_equal(d.z, np.array([[0, 1, 4, 9], [4, 5, 8, 13], [16, 17, 20, 25]]))
d = average_dataset(dataset2d, axis=1)
self.assertEqual(d.z.shape, (6,))
def test_read_write(self):
for f in self.formatters:
print('test formatter %s' % f)
dataset = DataSet2D(name="test_read_write")
dataset.formatter = f()
dataset.add_metadata(self.metadata)
dataset.write(write_metadata=True)
dataset2 = load_data(dataset.location, formatter=f())
self.assertEqual(list(dataset.arrays.keys()),
list(dataset2.arrays.keys()))
# strings should be read and written identically
self.assertEqual(dataset.metadata['string'],
dataset2.metadata['string'])
def test_load_dataset(verbose=0):
h = qcodes.data.hdf5_format.HDF5Format()
g = qcodes.data.gnuplot_format.GNUPlotFormat()
disk_io = qcodes.data.io.DiskIO(tempfile.mkdtemp())
dd = []
name = DataSet.location_provider.base_record['name']
for jj, fmt in enumerate([g, h]):
ds = DataSet2D(name='format%d' % jj)
ds.formatter = fmt
ds.io = disk_io
ds.add_metadata({'1': 1, '2': [2, 'x'], 'np': np.array([1, 2.])})
ds.write(write_metadata=True)
dd.append(ds.location)
time.sleep(.1)
DataSet.location_provider.base_record['name'] = name
for _, location in enumerate(dd):
if verbose:
print('load %s' % location)
r = load_dataset(location, io=disk_io)
if verbose:
print(r)
def test_datasetCentre(self):
dataset = DataSet2D()
cc = qtt.data.datasetCentre(dataset)
self.assertEqual(cc[0], 1.5)
def test_transform(self):
dataset = DataSet2D()
tr = qtt.data.image_transform(dataset, arrayname='z')
resolution = tr.scan_resolution()
self.assertEqual(resolution, 1)
def test_dataset_dimension(self):
dataset1d = DataSet1D()
self.assertEqual(dataset_dimension(dataset1d), 1)
dataset2d = DataSet2D()
self.assertEqual(dataset_dimension(dataset2d), 2)
def test_compare():
ds = DataSet2D()
compare_dataset_metadata(ds, ds, verbose=0)
def test_dataset_labels_dataset_2d(self):
dataset = DataSet2D()
zz = qtt.data.dataset_labels(dataset)
self.assertEqual(zz, 'Z')
zz = qtt.data.dataset_labels(dataset, add_unit=True)
self.assertEqual(zz, 'Z [None]')
