def _QCoDeS_Loop(self,
measured_parameter,
sweeped_parameter,
sweep_value=[0, 0, 0],
**kw):
Sweep_Values = sweeped_parameter[
sweep_value[0]:sweep_value[1]:sweep_value[2]]
# Sweep_Values2 = sweeped_parameter2[sweep_value2[0]:sweep_value2[1]:sweep_value2[2]]
LOOP = Loop(sweep_values=Sweep_Values).each(measured_parameter)
data_set = LOOP.get_data_set(
location=None,
loc_record={
'name': 'Chevron Pattern',
'label': 'frequency-burst_time'
},
io=self.data_IO,
)
data_set = LOOP.run()
return data_set
def test_measurement_with_many_nans(self):
loop = Loop(self.p1.sweep(0, 1, num=10),
delay=0.05).each(self.p4_crazy)
ds = loop.get_data_set()
loop.run()
# assert that both the snapshot and the datafile are there
self.assertEqual(len(os.listdir(ds.location)), 2)
def test_halt(self):
abort_after = 3
self.res = list(np.arange(0, abort_after-1, 1.))
[self.res.append(float('nan')) for i in range(0, abort_after-1)]
p1 = AbortingGetter('p1', count=abort_after, vals=Numbers(-10, 10), set_cmd=None)
loop = Loop(p1.sweep(0, abort_after, 1), 0.005).each(p1)
# we want to test what's in data, so get it ahead of time
# because loop.run will not return.
data = loop.get_data_set(location=False)
loop.run(quiet=True)
self.assertEqual(repr(data.p1.tolist()), repr(self.res))
def test_halt(self):
p1 = AbortingGetter('p1',
count=2,
vals=Numbers(-10, 10),
msg=ActiveLoop.HALT_DEBUG)
loop = Loop(p1[1:6:1], 0.005).each(p1)
# we want to test what's in data, so get it ahead of time
# because loop.run will not return.
data = loop.get_data_set(location=False)
p1.set_queue(loop.signal_queue)
with self.assertRaises(_DebugInterrupt):
# need to use explicit loop.run rather than run_temp
# so we can avoid providing location=False twice, which
# is an error.
loop.run(background=False, data_manager=False, quiet=True)
self.check_data(data)
def scan_outside_awg(name, set_parameter, measured_parameter, start, end,
step):
Sweep_Value = set_parameter[start:end:step]
LOOP = Loop(sweep_values=Sweep_Value).each(measured_parameter)
data_set = LOOP.get_data_set(
location=None,
loc_record={
'name': name,
'label': 'Freq_sweep'
},
io=data_IO,
)
data_set = LOOP.run()
awg.stop()
awg2.stop()
vsg.status('Off')
vsg2.status('Off')
return data_set
def _do_measurement(loop: Loop, set_params: tuple, meas_params: tuple,
do_plots: Optional[bool]=True,
use_threads: bool=True) -> Tuple[QtPlot, DataSet]:
"""
The function to handle all the auxiliary magic of the T10 users, e.g.
their plotting specifications, the device image annotation etc.
The input loop should just be a loop ready to run and perform the desired
measurement. The two params tuple are used for plotting.
Args:
loop: The QCoDeS loop object describing the actual measurement
set_params: tuple of tuples. Each tuple is of the form
(param, start, stop)
meas_params: tuple of parameters to measure
do_plots: Whether to do a live plot
use_threads: Whether to use threads to parallelise simultaneous
measurements. If only one thing is being measured at the time
in loop, this does nothing.
Returns:
(plot, data)
"""
try:
parameters = [sp[0] for sp in set_params] + list(meas_params)
_flush_buffers(*parameters)
# startranges for _plot_setup
try:
startranges = {}
for sp in set_params:
minval = min(sp[1], sp[2])
maxval = max(sp[1], sp[2])
startranges[sp[0].full_name] = {'max': maxval, 'min': minval}
except Exception:
startranges = None
interrupted = False
data = loop.get_data_set()
if do_plots:
try:
plot, _ = _plot_setup(data, meas_params, startranges=startranges)
except (ClosedError, ConnectionError):
log.warning('Remote process crashed png will not be saved')
else:
plot = None
try:
if do_plots:
_ = loop.with_bg_task(plot.update).run(use_threads=use_threads)
else:
_ = loop.run(use_threads=use_threads)
except KeyboardInterrupt:
interrupted = True
print("Measurement Interrupted")
if do_plots:
# Ensure the correct scaling before saving
try:
plot.autorange()
plot.save()
except (ClosedError, ConnectionError):
log.warning('Remote process crashed png will not be saved')
if 'pdf_subfolder' in CURRENT_EXPERIMENT or 'png_subfolder' in CURRENT_EXPERIMENT:
_do_MatPlot(data,meas_params)
if CURRENT_EXPERIMENT.get('device_image'):
log.debug('Saving device image')
save_device_image(tuple(sp[0] for sp in set_params))
# add the measurement ID to the logfile
with open(CURRENT_EXPERIMENT['logfile'], 'a') as fid:
print("#[QCoDeS]# Saved dataset to: {}".format(data.location),
file=fid)
if interrupted:
raise KeyboardInterrupt
except:
log.exception("Exception in doND")
raise
return plot, data
def _do_measurement(loop: Loop,
set_params: tuple,
meas_params: tuple,
do_plots: bool = True,
use_threads: bool = True) -> Tuple[QtPlot, DataSet]:
"""
The function to handle all the auxiliary magic of the T10 users, e.g.
their plotting specifications, the device image annotation etc.
The input loop should just be a loop ready to run and perform the desired
measurement. The two params tuple are used for plotting.
Args:
loop: The QCoDeS loop object describing the actual measurement
set_params: tuple of tuples. Each tuple is of the form
(param, start, stop)
meas_params: tuple of parameters to measure
do_plots: Whether to do a live plot
use_threads: Whether to use threads to parallelise simultaneous
measurements. If only one thing is being measured at the time
in loop, this does nothing.
Returns:
(plot, data)
"""
try:
parameters = [sp[0] for sp in set_params] + list(meas_params)
_flush_buffers(*parameters)
# startranges for _plot_setup
startranges = {}
for sp in set_params:
minval = min(sp[1], sp[2])
maxval = max(sp[1], sp[2])
startranges[sp[0].full_name] = {'max': maxval, 'min': minval}
interrupted = False
data = loop.get_data_set()
if do_plots:
try:
plot, _ = _plot_setup(data,
meas_params,
startranges=startranges)
except (ClosedError, ConnectionError):
log.warning('Remote process crashed png will not be saved')
else:
plot = None
try:
if do_plots:
_ = loop.with_bg_task(plot.update).run(use_threads=use_threads)
else:
_ = loop.run(use_threads=use_threads)
except KeyboardInterrupt:
interrupted = True
print("Measurement Interrupted")
if do_plots:
# Ensure the correct scaling before saving
try:
plot.autorange()
plot.save()
except (ClosedError, ConnectionError):
log.warning('Remote process crashed png will not be saved')
plt.ioff()
pdfplot, num_subplots = _plot_setup(data, meas_params, useQT=False)
# pad a bit more to prevent overlap between
# suptitle and title
pdfplot.rescale_axis()
pdfplot.fig.tight_layout(pad=3)
title_list = plot.get_default_title().split(sep)
title_list.insert(-1, CURRENT_EXPERIMENT['pdf_subfolder'])
title = sep.join(title_list)
pdfplot.save("{}.pdf".format(title))
if pdfdisplay['combined'] or (num_subplots == 1
and pdfdisplay['individual']):
pdfplot.fig.canvas.draw()
plt.show()
else:
plt.close(pdfplot.fig)
if num_subplots > 1:
_save_individual_plots(data, meas_params,
pdfdisplay['individual'])
plt.ion()
if CURRENT_EXPERIMENT.get('device_image'):
log.debug('Saving device image')
save_device_image(tuple(sp[0] for sp in set_params))
# add the measurement ID to the logfile
with open(CURRENT_EXPERIMENT['logfile'], 'a') as fid:
print("#[QCoDeS]# Saved dataset to: {}".format(data.location),
file=fid)
if interrupted:
raise KeyboardInterrupt
except:
log.exception("Exception in doND")
raise
return plot, data
class Measure(Metadatable):
"""
Create a DataSet from a single (non-looped) set of actions.
Args:
*actions (Any): sequence of actions to perform. Any action that is
valid in a ``Loop`` can be used here. If an action is a gettable
``Parameter``, its output will be included in the DataSet.
Scalars returned by an action will be saved as length-1 arrays,
with a dummy setpoint for consistency with other DataSets.
"""
dummy_parameter = Parameter(name='single',
label='Single Measurement',
set_cmd=None, get_cmd=None)
def __init__(self, *actions):
super().__init__()
self._dummyLoop = Loop(self.dummy_parameter[0]).each(*actions)
def run_temp(self, **kwargs):
"""
Wrapper to run this measurement as a temporary data set
"""
return self.run(quiet=True, location=False, **kwargs)
def get_data_set(self, *args, **kwargs):
return self._dummyLoop.get_data_set(*args, **kwargs)
def run(self, use_threads=False, quiet=False, station=None, **kwargs):
"""
Run the actions in this measurement and return their data as a DataSet
Args:
quiet (Optional[bool]): Set True to not print anything except
errors. Default False.
station (Optional[Station]): the ``Station`` this measurement
pertains to. Defaults to ``Station.default`` if one is defined.
Only used to supply metadata.
use_threads (Optional[bool]): whether to parallelize ``get``
operations using threads. Default False.
location (Optional[Union[str, bool]]): the location of the
DataSet, a string whose meaning depends on formatter and io,
or False to only keep in memory. May be a callable to provide
automatic locations. If omitted, will use the default
DataSet.location_provider
name (Optional[str]): if location is default or another provider
function, name is a string to add to location to make it more
readable/meaningful to users
formatter (Optional[Formatter]): knows how to read and write the
file format. Default can be set in DataSet.default_formatter
io (Optional[io_manager]): knows how to connect to the storage
(disk vs cloud etc)
location, name formatter and io are passed to ``data_set.new_data``
along with any other optional keyword arguments.
returns:
a DataSet object containing the results of the measurement
"""
data_set = self._dummyLoop.get_data_set(**kwargs)
# set the DataSet to local for now so we don't save it, since
# we're going to massage it afterward
original_location = data_set.location
data_set.location = False
# run the measurement as if it were a Loop
self._dummyLoop.run(use_threads=use_threads,
station=station, quiet=True)
# look for arrays that are unnecessarily nested, and un-nest them
all_unnested = True
for array in data_set.arrays.values():
if array.ndim == 1:
if array.is_setpoint:
dummy_setpoint = array
else:
# we've found a scalar - so keep the dummy setpoint
all_unnested = False
else:
# The original return was an array, so take off the extra dim.
# (This ensures the outer dim length was 1, otherwise this
# will raise a ValueError.)
array.ndarray.shape = array.ndarray.shape[1:]
# TODO: DataArray.shape masks ndarray.shape, and a user *could*
# change it, thinking they were reshaping the underlying array,
# but this would a) not actually reach the ndarray right now,
# and b) if it *did* and the array was reshaped, this array
# would be out of sync with its setpoint arrays, so bad things
# would happen. So we probably want some safeguards in place
# against this
array.shape = array.ndarray.shape
array.set_arrays = array.set_arrays[1:]
array.init_data()
# Do we still need the dummy setpoint array at all?
if all_unnested:
del data_set.arrays[dummy_setpoint.array_id]
if hasattr(data_set, 'action_id_map'):
del data_set.action_id_map[dummy_setpoint.action_indices]
# now put back in the DataSet location and save it
data_set.location = original_location
data_set.write()
# metadata: ActiveLoop already provides station snapshot, but also
# puts in a 'loop' section that we need to replace with 'measurement'
# but we use the info from 'loop' to ensure consistency and avoid
# duplication.
LOOP_SNAPSHOT_KEYS = ['ts_start', 'ts_end', 'use_threads']
data_set.add_metadata({'measurement': {
k: data_set.metadata['loop'][k] for k in LOOP_SNAPSHOT_KEYS
}})
del data_set.metadata['loop']
# actions are included in self.snapshot() rather than in
# LOOP_SNAPSHOT_KEYS because they are useful if someone just
# wants a local snapshot of the Measure object
data_set.add_metadata({'measurement': self.snapshot()})
data_set.save_metadata()
if not quiet:
print(repr(data_set))
print(datetime.now().strftime('acquired at %Y-%m-%d %H:%M:%S'))
return data_set
def snapshot_base(self, update: Optional[bool] = False,
params_to_skip_update: Optional[Sequence[str]] = None):
return {
'__class__': full_class(self),
'actions': _actions_snapshot(self._dummyLoop.actions, update)
}
LP = Loop(sweep_values = Sweep_Value).each(F,E)
#%%
#LP.with_bg_task(task = Print,bg_final_task = None,min_delay=1).run()
#LP = Loop(sweep_values = Sweep_Value,).each(F)
print('loop.data_set: %s' % LP.data_set)
NewIO = DiskIO(base_location = 'C:\\Users\\LocalAdmin\\Documents')
formatter = HDF5FormatMetadata()
OldIO = DiskIO(base_location = 'D:\\文献\\QuTech\\QTlab\\xiaotest\\testIO')
## get_data_set should contain parameter like io, location, formatter and others
data = LP.get_data_set(location=None, loc_record = {'name':'T1', 'label':'Vread_sweep'},
io = NewIO, formatter = formatter)
#data = LP.get_data_set(data_manager=False, location=None, loc_record = {'name':'T1', 'label':'T_load_sweep'})
print('loop.data_set: %s' % LP.data_set)
#%%
DS = new_data(location = 'aaaaaaaaaa',io = NewIO)
def live_plotting():
for para in data.arrays:
DS.arrays[para] = data.arrays[para]
return DS
DS = live_plotting()
#def add_T1exp_metadata(data):
#
# data.metadata['Parameters'] = {'Nrep': 10, 't_empty': 2, 't_load': 2.4, 't_read': 2.2}
# data.write(write_metadata=True)
#
def _do_measurement(loop: Loop, set_params: tuple, meas_params: tuple,
do_plots: Optional[bool]=True,
use_threads: bool=True,
auto_color_scale: Optional[bool]=None,
cutoff_percentile: Optional[Union[Tuple[Number, Number], Number]]=None) -> Tuple[QtPlot, DataSet]:
"""
The function to handle all the auxiliary magic of the T10 users, e.g.
their plotting specifications, the device image annotation etc.
The input loop should just be a loop ready to run and perform the desired
measurement. The two params tuple are used for plotting.
Args:
loop: The QCoDeS loop object describing the actual measurement
set_params: tuple of tuples. Each tuple is of the form
(param, start, stop)
meas_params: tuple of parameters to measure
do_plots: Whether to do a live plot
use_threads: Whether to use threads to parallelise simultaneous
measurements. If only one thing is being measured at the time
in loop, this does nothing.
auto_color_scale: if True, the colorscale of heatmap plots will be
automatically adjusted to disregard outliers.
cutoff_percentile: percentile of data that may maximally be clipped
on both sides of the distribution.
If given a tuple (a,b) the percentile limits will be a and 100-b.
See also the plotting tuorial notebook.
Returns:
(plot, data)
"""
try:
parameters = [sp[0] for sp in set_params] + list(meas_params)
_flush_buffers(*parameters)
# startranges for _plot_setup
try:
startranges = {}
for sp in set_params:
minval = min(sp[1], sp[2])
maxval = max(sp[1], sp[2])
startranges[sp[0].full_name] = {'max': maxval, 'min': minval}
except Exception:
startranges = None
interrupted = False
data = loop.get_data_set()
if do_plots:
try:
plot, _ = _plot_setup(data, meas_params, startranges=startranges,
auto_color_scale=auto_color_scale,
cutoff_percentile=cutoff_percentile)
except (ClosedError, ConnectionError):
log.warning('Remote process crashed png will not be saved')
# if remote process crashed continue without plots
do_plots = False
else:
plot = None
try:
if do_plots:
_ = loop.with_bg_task(plot.update).run(use_threads=use_threads)
else:
_ = loop.run(use_threads=use_threads)
except KeyboardInterrupt:
interrupted = True
print("Measurement Interrupted")
if do_plots:
# Ensure the correct scaling before saving
try:
plot.autorange()
plot.save()
except (ClosedError, ConnectionError):
log.warning('Remote process crashed png will not be saved')
# if remote process crashed continue without plots
do_plots = False
if 'pdf_subfolder' in CURRENT_EXPERIMENT or 'png_subfolder' in CURRENT_EXPERIMENT:
_do_MatPlot(data,meas_params,
auto_color_scale=auto_color_scale,
cutoff_percentile=cutoff_percentile)
if CURRENT_EXPERIMENT.get('device_image'):
log.debug('Saving device image')
save_device_image(tuple(sp[0] for sp in set_params))
log.info("#[QCoDeS]# Saved dataset to: {}".format(data.location))
if interrupted:
raise KeyboardInterrupt
except:
log.exception("Exception in doND")
raise
return plot, data
def _do_measurement(loop: Loop, set_params: tuple, meas_params: tuple,
do_plots: Optional[bool]=True) -> Tuple[QtPlot, DataSet]:
"""
The function to handle all the auxiliary magic of the T10 users, e.g.
their plotting specifications, the device image annotation etc.
The input loop should just be a loop ready to run and perform the desired
measurement. The two params tuple are used for plotting.
Args:
loop: The QCoDeS loop object describing the actual measurement
set_params: tuple of tuples. Each tuple is of the form
(param, start, stop)
meas_params: tuple of parameters to measure
Returns:
(plot, data)
"""
parameters = [sp[0] for sp in set_params] + list(meas_params)
_flush_buffers(*parameters)
# startranges for _plot_setup
startranges = dict(zip((sp[0].label for sp in set_params),
((sp[1], sp[2]) for sp in set_params)))
interrupted = False
data = loop.get_data_set()
if do_plots:
plot, _ = _plot_setup(data, meas_params, startranges=startranges)
else:
plot = None
try:
if do_plots:
_ = loop.with_bg_task(plot.update).run()
else:
_ = loop.run()
except KeyboardInterrupt:
interrupted = True
print("Measurement Interrupted")
if do_plots:
# Ensure the correct scaling before saving
for subplot in plot.subplots:
vBox = subplot.getViewBox()
vBox.enableAutoRange(vBox.XYAxes)
cmap = None
# resize histogram
for trace in plot.traces:
if 'plot_object' in trace.keys():
if (isinstance(trace['plot_object'], dict) and
'hist' in trace['plot_object'].keys()):
cmap = trace['plot_object']['cmap']
max = trace['config']['z'].max()
min = trace['config']['z'].min()
trace['plot_object']['hist'].setLevels(min, max)
trace['plot_object']['hist'].vb.autoRange()
if cmap:
plot.set_cmap(cmap)
# set window back to original size
plot.win.resize(1000, 600)
plot.save()
pdfplot, num_subplots = _plot_setup(data, meas_params, useQT=False)
# pad a bit more to prevent overlap between
# suptitle and title
pdfplot.fig.tight_layout(pad=3)
pdfplot.save("{}.pdf".format(plot.get_default_title()))
pdfplot.fig.canvas.draw()
if num_subplots > 1:
_save_individual_plots(data, meas_params)
if CURRENT_EXPERIMENT.get('device_image'):
log.debug('Saving device image')
save_device_image(tuple(sp[0] for sp in set_params))
# add the measurement ID to the logfile
with open(CURRENT_EXPERIMENT['logfile'], 'a') as fid:
print("#[QCoDeS]# Saved dataset to: {}".format(data.location),
file=fid)
if interrupted:
raise KeyboardInterrupt
return plot, data
#LOOP = Loop(sweep_values = Sweep_Value1).each(AMP)
#Sweep_Value3 = Count[0:4000:1]
#LOOP = Loop(sweep_values = Sweep_Value3, delay = 0.5).each(AMP)
NewIO = DiskIO(base_location='D:\\Data\\RB_experiment')
NewIO = DiskIO(
base_location=
'K:\\ns\\qt\\spin-qubits\\data\\b059_data\\2018 data\\Data\\RB_experiment')
## get_data_set should contain parameter like io, location, formatter and others
data = LOOP.get_data_set(
location=None,
loc_record={
'name': 'DAC',
'label': 'V_sweep'
},
io=NewIO,
)
print('loop.data_set: %s' % LOOP.data_set)
'''
plot = QtPlot()
plot.add(data.keithley_amplitude, figsize=(1200, 500))
_ = LOOP.with_bg_task(plot.update, plot.save).run()
'''
'''
pt = MatPlot()
pt.add(x = data.gates_T_set, y = data.gates_LP_set, z = data.keithley_amplitude)
pt = MatPlot()
pt.add(x = data.gates_SQD1_set, y = data.gates_SQD3_set, z = data.keithley_amplitude)
