def test_default_parameter(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'test_default_parameter'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) # Test whether the default_array function works m = DataSet2D(name="test_default_parameter", location=loc_provider) # test we can run with default arguments name = m.default_parameter_name() # test with paramname name = m.default_parameter_name(paramname='z') self.assertEqual(name, 'z') # test we can get the array instead of the name array = m.default_parameter_array(paramname='z') self.assertEqual(array, m.z) # first non-setpoint array array = m.default_parameter_array() self.assertEqual(array, m.z) # test with metadata m.metadata = dict({'default_parameter_name': 'x_set'}) name = m.default_parameter_name() self.assertEqual(name, 'x_set') # test the fallback: no name matches, no non-setpoint array x = DataArray(name='x', label='X', preset_data=(1., 2., 3., 4., 5.), is_setpoint=True) m = new_data(arrays=(x, ), name='onlysetpoint') name = m.default_parameter_name(paramname='dummy') self.assertEqual(name, 'x_set')
def test_loop_measure_channels_by_name(dci, values): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) for i in range(4): dci.channels[i].temperature(values[i]) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'channelsByName'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each( dci.A.temperature, dci.B.temperature, dci.C.temperature, dci.D.temperature ) data = loop.run(location=loc_provider) assert data.p1_set.ndarray.shape == (21, ) for i, chan in enumerate(['A', 'B', 'C', 'D']): assert getattr( data, f'dci_Chan{chan}_temperature' ).ndarray.shape == (21,) assert getattr( data, f'dci_Chan{chan}_temperature' ).ndarray.max() == values[i] assert getattr( data, f'dci_Chan{chan}_temperature' ).ndarray.min() == values[i]
def testLoopCombinedParameterPrintTask(self, npoints, x_start_stop, y_start_stop, z_start_stop): x_set = np.linspace(x_start_stop[0], x_start_stop[1], npoints) y_set = np.linspace(y_start_stop[0], y_start_stop[1], npoints) z_set = np.linspace(z_start_stop[0], z_start_stop[1], npoints) setpoints = np.hstack((x_set.reshape(npoints, 1), y_set.reshape(npoints, 1), z_set.reshape(npoints, 1))) parameters = [Parameter(name, get_cmd=None, set_cmd=None) for name in ["X", "Y", "Z"]] sweep_values = combine(*parameters, name="combined").sweep(setpoints) def ataskfunc(): a = 1+1 def btaskfunc(): b = 1+2 atask = Task(ataskfunc) btask = Task(btaskfunc) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'printTask'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(sweep_values).each(atask, btask) data = loop.run(location=loc_provider, quiet=True) np.testing.assert_array_equal(data.arrays['X'].ndarray, x_set) np.testing.assert_array_equal(data.arrays['Y'].ndarray, y_set) np.testing.assert_array_equal(data.arrays['Z'].ndarray, z_set)
def test_metadata(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'test_metadata'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) c = Measure(self.p1).run(location=loc_provider) self.assertEqual(c.metadata['arrays']['this']['unit'], 'this unit') self.assertEqual(c.metadata['arrays']['this']['name'], 'this') self.assertEqual(c.metadata['arrays']['this']['label'], 'this label') self.assertEqual(c.metadata['arrays']['this']['is_setpoint'], False) self.assertEqual(c.metadata['arrays']['this']['shape'], (5, )) assert_array_equal(c.this.ndarray, np.zeros(5)) self.assertEqual(c.metadata['arrays']['that']['unit'], 'that unit') self.assertEqual(c.metadata['arrays']['that']['name'], 'that') self.assertEqual(c.metadata['arrays']['that']['label'], 'that label') self.assertEqual(c.metadata['arrays']['that']['is_setpoint'], False) self.assertEqual(c.metadata['arrays']['that']['shape'], (5, )) assert_array_equal(c.that.ndarray, np.ones(5)) self.assertEqual(c.metadata['arrays']['this_setpoint_set']['unit'], 'this setpointunit') self.assertEqual(c.metadata['arrays']['this_setpoint_set']['name'], 'this_setpoint') self.assertEqual(c.metadata['arrays']['this_setpoint_set']['label'], 'this setpoint') self.assertEqual( c.metadata['arrays']['this_setpoint_set']['is_setpoint'], True) self.assertEqual(c.metadata['arrays']['this_setpoint_set']['shape'], (5, )) assert_array_equal(c.this_setpoint_set.ndarray, np.linspace(5, 9, 5))
def test_loop_measure_channels_by_name(self, values): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) for i in range(4): self.instrument.channels[i].temperature(values[i]) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'channelsByName'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each(self.instrument.A.temperature, self.instrument.B.temperature, self.instrument.C.temperature, self.instrument.D.temperature) data = loop.run(location=loc_provider) self.assertEqual(data.p1_set.ndarray.shape, (21, )) for i, chan in enumerate(['A', 'B', 'C', 'D']): self.assertEqual( getattr(data, 'testchanneldummy_Chan{}_temperature'.format( chan)).ndarray.shape, (21, )) self.assertEqual( getattr(data, 'testchanneldummy_Chan{}_temperature'.format( chan)).ndarray.max(), values[i]) self.assertEqual( getattr(data, 'testchanneldummy_Chan{}_temperature'.format( chan)).ndarray.min(), values[i])
def test_remove_array(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'test_remove_array'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) m = DataSet2D(location=loc_provider) m.remove_array('z') _ = m.__repr__() self.assertFalse('z' in m.arrays)
def test_loop_arrayparameter_by_name(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'arrayParamByName'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(self.instrument.A.temperature.sweep(0, 10, 1), 0.1) data = loop.each(self.instrument.A.dummy_array_parameter)\ .run(location=loc_provider) self._verify_array_data(data)
def test_loop_slicing_arrayparameter(dci): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'loopSlicing'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(dci.A.temperature.sweep(0, 10, 1), 0.1) data = loop.each(dci.channels[0:2].dummy_array_parameter)\ .run(location=loc_provider) _verify_array_data(data, channels=('A', 'B'))
def test_pickle_dataset(self): # Test pickling of DataSet object # If the data_manager is set to None, then the object should pickle. loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'test_pickle_dataset'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) m = DataSet2D(location=loc_provider) pickle.dumps(m)
def test_loop_arrayparameter_by_index(dci): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'arrayParamByIndex'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(dci.channels[0].temperature.sweep(0, 10, 1), 0.1) data = loop.each(dci.A.dummy_array_parameter)\ .run(location=loc_provider) _verify_array_data(data)
def test_loop_simple(dci): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'loopSimple'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(dci.channels[0].temperature.sweep(0, 300, 10), 0.001).each(dci.A.temperature) data = loop.run(location=loc_provider) assert_array_equal(data.dci_ChanA_temperature_set.ndarray, data.dci_ChanA_temperature.ndarray)
def test_loop_multiparameter_by_name(dci): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'multiParamByName'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(dci.A.temperature.sweep(0, 10, 1), 0.1) data = loop.each(dci.A.dummy_multi_parameter)\ .run(location=loc_provider) _verify_multiparam_data(data) assert 'multi_setpoint_param_this_setpoint_set' in data.arrays.keys()
def test_loop_multiparameter_by_index(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'loopByIndex'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(self.instrument.channels[0].temperature.sweep(0, 10, 1), 0.1) data = loop.each(self.instrument.A.dummy_multi_parameter)\ .run(location=loc_provider) self._verify_multiparam_data(data)
def setUp(self): self.io = DataSet.default_io self.formatter = HDF5Format() # Set up the location provider to always store test data in # "qc.tests.unittest_data cur_fp = os.path.dirname(__file__) base_fp = os.path.abspath(os.path.join(cur_fp, '../unittest_data')) self.loc_provider = FormatLocation(fmt=base_fp + '/{date}/#{counter}_{name}_{time}') DataSet.location_provider = self.loc_provider
def test_record_override(self): # this one needs 'c' filled in at call time lp = FormatLocation(fmt='{a}_{b}_{c}', record={'a': 'A', 'b': 'B'}) io = MatchIO([]) self.assertEqual(lp(io, {'c': 'C'}), 'A_B_C') self.assertEqual(lp(io, {'a': 'aa', 'c': 'cc'}), 'aa_B_cc') # extra keys just get discarded self.assertEqual(lp(io, {'c': 'K', 'd': 'D'}), 'A_B_K') self.assertEqual(lp(MatchIO([])), 'A_B_{c}') self.assertEqual(lp(MatchIO([]), {'a': 'AA'}), 'AA_B_{c}') # this one has defaults for everything, so nothing is needed at # call time, but things can still be overridden lp = FormatLocation(fmt='{d}_{e}', record={'d': 'D', 'e': 'E'}) self.assertEqual(lp(MatchIO([])), 'D_E') self.assertEqual(lp(MatchIO([]), {'d': 'T'}), 'T_E')
def test_default(self): lp = FormatLocation() fmt = '%Y-%m-%d/%H-%M-%S' name = "name" self.assertEqual(lp(MatchIO([]), {'name': name}), _default(datetime.now(), lp, "001", name)) # counter starts at +1 using MatchIo undocumented magic argument start_magic_value = 5 self.assertEqual(lp(MatchIO(['', '{0:03d}'.format(start_magic_value)]), {'name':name}), _default(datetime.now(), lp, '{0:03d}'.format(start_magic_value+1), name))
def test_default(self): lp = FormatLocation() fmt = '%Y-%m-%d/%H-%M-%S' self.assertEqual(lp(MatchIO([])), datetime.now().strftime(fmt)) self.assertEqual(lp(MatchIO([]), {'name': 'who?'}), datetime.now().strftime(fmt) + '_who?') # counter starts at 2 if we added it for disambiguation self.assertEqual(lp(MatchIO([''])), datetime.now().strftime(fmt) + '_002') self.assertEqual(lp(MatchIO(['', '005'])), datetime.now().strftime(fmt) + '_006') self.assertEqual(lp(MatchIO(['', '888888']), {'name': 'you!'}), datetime.now().strftime(fmt) + '_you!_888889')
def test_record_call(self): lp = FormatLocation(fmt='{date}/#{counter}_{time}_{name}_{label}') # counter starts at 1 if it's a regular part of the format string expected = datetime.now().strftime('%Y-%m-%d/#001_%H-%M-%S_Joe_fruit') self.assertEqual(lp(MatchIO([]), {'name': 'Joe', 'label': 'fruit'}), expected) expected = datetime.now().strftime('%Y-%m-%d/#1000_%H-%M-%S_Ga_As') self.assertEqual(lp(MatchIO(['999']), {'name': 'Ga', 'label': 'As'}), expected) # missing label expected = datetime.now().strftime( '%Y-%m-%d/#001_%H-%M-%S_Fred_{label}') self.assertEqual(lp(MatchIO([]), {'name': 'Fred'}), expected)
def test_loop_measure_all_channels(dci): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'allChannels'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).\ each(dci.channels.temperature) data = loop.run(location=loc_provider) assert data.p1_set.ndarray.shape == (21, ) assert len(data.arrays) == 7 for chan in ['A', 'B', 'C', 'D', 'E', 'F']: assert getattr(data, f'dci_Chan{chan}_temperature').ndarray.shape == (21, )
def test_fmt_subparts(self): lp = FormatLocation(fmt='{date}/{time}', fmt_date='%d-%b-%Y', fmt_time='%I-%M%p', fmt_counter='##{:.1f}~') fmt = '%d-%b-%Y/%I-%M%p' self.assertEqual(lp(MatchIO([])), datetime.now().strftime(fmt)) self.assertEqual(lp(MatchIO([]), {'name': 'who?'}), datetime.now().strftime(fmt) + '_who?') self.assertEqual(lp(MatchIO([''])), datetime.now().strftime(fmt) + '_##2.0~') self.assertEqual(lp(MatchIO(['', '9'])), datetime.now().strftime(fmt) + '_##10.0~') self.assertEqual(lp(MatchIO(['', '12345']), {'name': 'you!'}), datetime.now().strftime(fmt) + '_you!_##12346.0~')
def test_overridable_methods(self): formatter = Formatter() loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'test_overridable_methods'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) data = DataSet1D(name="test_overridable", location=loc_provider) with self.assertRaises(NotImplementedError): formatter.write(data, data.io, data.location) with self.assertRaises(NotImplementedError): formatter.read_one_file(data, 'a file!', set()) with self.assertRaises(NotImplementedError): formatter.write_metadata(data, data.io, data.location) with self.assertRaises(NotImplementedError): formatter.read_metadata(data)
def test_loop_measure_channels_individually(dci): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'channelsIndividually'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each(dci.channels[0].temperature, dci.channels[1].temperature, dci.channels[2].temperature, dci.channels[3].temperature) data = loop.run(location=loc_provider) assert data.p1_set.ndarray.shape == (21, ) for chan in ['A', 'B', 'C', 'D']: assert getattr(data, f'dci_Chan{chan}_temperature').ndarray.shape == (21, )
def test_loop_measure_all_channels(self): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'allChannels'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).\ each(self.instrument.channels.temperature) data = loop.run(location=loc_provider) self.assertEqual(data.p1_set.ndarray.shape, (21, )) self.assertEqual(len(data.arrays), 7) for chan in ['A', 'B', 'C', 'D', 'E', 'F']: self.assertEqual( getattr(data, 'testchanneldummy_Chan{}_temperature'.format( chan)).ndarray.shape, (21, ))
def test_nested_loop_over_channels(self, loop_channels, measure_channel): channel_to_label = {0: 'A', 1: 'B', 2: 'C', 3: "D"} loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'nestedLoopOverChannels'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop( self.instrument.channels[loop_channels[0]].temperature.sweep( 0, 10, 0.5)) loop = loop.loop( self.instrument.channels[loop_channels[1]].temperature.sweep( 50, 51, 0.1)) loop = loop.each(self.instrument.channels[measure_channel].temperature) data = loop.run(location=loc_provider) self.assertEqual( getattr( data, 'testchanneldummy_Chan{}_temperature_set'.format( channel_to_label[loop_channels[0]])).ndarray.shape, (21, )) self.assertEqual( getattr( data, 'testchanneldummy_Chan{}_temperature_set'.format( channel_to_label[loop_channels[1]])).ndarray.shape, ( 21, 11, )) self.assertEqual( getattr( data, 'testchanneldummy_Chan{}_temperature'.format( channel_to_label[measure_channel])).ndarray.shape, (21, 11)) assert_array_equal( getattr( data, 'testchanneldummy_Chan{}_temperature_set'.format( channel_to_label[loop_channels[0]])).ndarray, np.arange(0, 10.1, 0.5)) expected_array = np.repeat(np.arange(50, 51.01, 0.1).reshape(1, 11), 21, axis=0) array = getattr( data, 'testchanneldummy_Chan' '{}_temperature_set'.format( channel_to_label[loop_channels[1]])).ndarray assert_allclose(array, expected_array)
def testLoopCombinedParameterAndMore(self, npoints, x_start_stop, y_start_stop, z_start_stop): x_set = np.linspace(x_start_stop[0], x_start_stop[1], npoints) y_set = np.linspace(y_start_stop[0], y_start_stop[1], npoints) z_set = np.linspace(z_start_stop[0], z_start_stop[1], npoints) setpoints = np.hstack( (x_set.reshape(npoints, 1), y_set.reshape(npoints, 1), z_set.reshape(npoints, 1))) parameters = [ Parameter(name, get_cmd=None, set_cmd=None) for name in ["X", "Y", "Z"] ] sweep_values = combine(*parameters, name="combined").sweep(setpoints) def wrapper(): counter = 0 def inner(): nonlocal counter counter += 1 return counter return inner self.dmm.voltage.get = wrapper() loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'parameterAndMore'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(sweep_values).each(self.dmm.voltage, self.dmm.somethingelse, self.dmm.voltage) data = loop.run(location=loc_provider, quiet=True) np.testing.assert_array_equal(data.arrays['X'].ndarray, x_set) np.testing.assert_array_equal(data.arrays['Y'].ndarray, y_set) np.testing.assert_array_equal(data.arrays['Z'].ndarray, z_set) np.testing.assert_array_equal(data.arrays['dmm_voltage_0'].ndarray, np.arange(1, npoints * 2, 2)) np.testing.assert_array_equal(data.arrays['dmm_somethingelse'].ndarray, np.ones(npoints)) np.testing.assert_array_equal(data.arrays['dmm_voltage_2'].ndarray, np.arange(2, npoints * 2 + 1, 2))
def test_metadata(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'test_metadata'} param_name_1 = "multi_setpoint_param_this" param_name_2 = "multi_setpoint_param_that" setpoint_name = "multi_setpoint_param_this_setpoint_set" loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) c = Measure(self.p1).run(location=loc_provider) self.assertEqual(c.metadata['arrays'][param_name_1]['unit'], 'this unit') self.assertEqual(c.metadata['arrays'][param_name_1]['name'], param_name_1) self.assertEqual(c.metadata['arrays'][param_name_1]['label'], 'this label') self.assertEqual(c.metadata['arrays'][param_name_1]['is_setpoint'], False) self.assertEqual(c.metadata['arrays'][param_name_1]['shape'], (5, )) assert_array_equal(getattr(c, param_name_1).ndarray, np.zeros(5)) self.assertEqual(c.metadata['arrays'][param_name_2]['unit'], 'that unit') self.assertEqual(c.metadata['arrays'][param_name_2]['name'], param_name_2) self.assertEqual(c.metadata['arrays'][param_name_2]['label'], 'that label') self.assertEqual(c.metadata['arrays'][param_name_2]['is_setpoint'], False) self.assertEqual(c.metadata['arrays'][param_name_2]['shape'], (5, )) assert_array_equal(getattr(c, param_name_2).ndarray, np.ones(5)) self.assertEqual(c.metadata['arrays'][setpoint_name]['unit'], 'this setpointunit') self.assertEqual(c.metadata['arrays'][setpoint_name]['name'], "multi_setpoint_param_this_setpoint") self.assertEqual(c.metadata['arrays'][setpoint_name]['label'], 'this setpoint') self.assertEqual(c.metadata['arrays'][setpoint_name]['is_setpoint'], True) self.assertEqual(c.metadata['arrays'][setpoint_name]['shape'], (5, )) assert_array_equal( getattr(c, setpoint_name).ndarray, np.linspace(5, 9, 5))
liveValue = _redisStrValue liveValueSet = _redisStrSet abort_measurements = _abort_measurement # type: ignore # patch the qcodes abort function qcodes.loops.abort_measurements = _abort_measurement # type: ignore # %% Override default location formatter FormatLocation.default_fmt = '{date}/{time}_{name}_{label}' qcodes.DataSet.location_provider = FormatLocation( fmt='{date}/{time}_{name}_{label}', record={ 'name': 'qtt', 'label': 'generic' }) def set_location_name(name, verbose=1): if verbose: print('setting location name tag to %s' % name) qcodes.DataSet.location_provider.base_record['name'] = name # %% def _copy_to_str(x, memo=None): return str(x)
def testLoopCombinedParameterInside(self, npoints, npoints_outer, x_start_stop, y_start_stop, z_start_stop): x_set = np.linspace(x_start_stop[0], x_start_stop[1], npoints_outer) y_set = np.linspace(y_start_stop[0], y_start_stop[1], npoints) z_set = np.linspace(z_start_stop[0], z_start_stop[1], npoints) setpoints = np.hstack((y_set.reshape(npoints, 1), z_set.reshape(npoints, 1))) parameters = [Parameter(name, get_cmd=None, set_cmd=None) for name in ["X", "Y", "Z"]] sweep_values = combine(parameters[1], parameters[2], name="combined").sweep(setpoints) def ataskfunc(): a = 1+1 def btaskfunc(): b = 1+2 atask = Task(ataskfunc) btask = Task(btaskfunc) def wrapper(): counter = 0 def inner(): nonlocal counter counter += 1 return counter return inner self.dmm.voltage.get = wrapper() loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'parameterInside'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(parameters[0].sweep(x_start_stop[0], x_start_stop[1], num=npoints_outer)).loop(sweep_values)\ .each(self.dmm.voltage, atask, self.dmm.somethingelse, self.dmm.voltage, btask) data = loop.run(location=loc_provider, quiet=True) np.testing.assert_array_equal(data.arrays['X_set'].ndarray, x_set) np.testing.assert_array_equal(data.arrays['Y'].ndarray, np.repeat(y_set.reshape(1, npoints), npoints_outer, axis=0)) np.testing.assert_array_equal(data.arrays['Z'].ndarray, np.repeat(z_set.reshape(1, npoints), npoints_outer, axis=0)) np.testing.assert_array_equal(data.arrays['dmm_voltage_0'].ndarray, np.arange(1, npoints * npoints_outer * 2, 2).reshape(npoints_outer, npoints)) np.testing.assert_array_equal(data.arrays['dmm_voltage_3'].ndarray, np.arange(2, npoints * npoints_outer * 2 + 1, 2).reshape(npoints_outer, npoints)) np.testing.assert_array_equal(data.arrays['dmm_somethingelse'].ndarray, np.ones((npoints_outer, npoints)))