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)))