def setDatadir(self, newindex):
logging.info(f'Setting datadir with index: {newindex}')
oldindex = self.datadirindex
self.datadirindex = newindex
datadir = self.datadirlist[newindex]
self.io = DiskIO(datadir)
logging.info('DataViewer: data directory %s' % datadir)
self.logfile.setText('Log files at %s' % datadir)
self.menuFolder.actions()[oldindex + 1].setText(self.menuFolder.actions()[oldindex + 1].text()[2:])
self.menuFolder.actions()[newindex + 1].setText('>>' + self.menuFolder.actions()[newindex + 1].text())
self.updateLogs()
def setUp(self):
get_data_manager().restart(force=True)
kill_processes()
# TODO: figure out what's leaving DataManager in a weird state
# and fix it
get_data_manager().restart(force=True)
time.sleep(0.1)
self.model = AMockModel()
self.gates = MockGates(model=self.model, server_name='')
self.source = MockSource(model=self.model, server_name='')
self.meter = MockMeter(model=self.model, server_name='')
self.location = '_loop_test_'
self.location2 = '_loop_test2_'
self.io = DiskIO('.')
c1 = self.gates.chan1
self.loop = Loop(c1[1:5:1], 0.001).each(c1)
self.loop_progress = Loop(c1[1:5:1], 0.001,
progress_interval=1).each(c1)
self.assertFalse(self.io.list(self.location))
self.assertFalse(self.io.list(self.location2))
def __init__(self, name, qubits, awg, awg2, pulsar,
**kw): ## name = 'calibration_20170615_Xiao'...
super().__init__(name, qubits, awg, awg2, pulsar, **kw)
self.Pi_length = [qubit.Pi_pulse_length for qubit in qubits]
self.X_length = 0
self.Rabi_power = 0
# self.qubits_name = qubits_name
# self.calibration_sequence = Sequence()
self.sweep_inside_sequence = False
# self.formatter = HDF5FormatMetadata()
self.data_IO = DiskIO(base_location='C:\\Users\\LocalAdmin\\Documents')
self.calibration_data_location = self.data_location + '_calibration'
self.data_set = None
self.calibration = 'Ramsey'
self.experiment = 'AllXY'
self.calibrated_parameter = None
def test_write_copy(self):
data = DataSet1D(location=False)
mockbase = os.path.abspath('some_folder')
data.io = DiskIO(mockbase)
mr = (2, 3)
mr_full = (0, 4)
lsi = 1
data.x_set.modified_range = mr
data.y.modified_range = mr
data.x_set.last_saved_index = lsi
data.y.last_saved_index = lsi
with self.assertRaises(TypeError):
data.write_copy()
with self.assertRaises(TypeError):
data.write_copy(path='some/path', io_manager=DiskIO('.'))
with self.assertRaises(TypeError):
data.write_copy(path='some/path', location='something/else')
data.formatter = RecordingMockFormatter()
data.write_copy(path='/some/abs/path')
self.assertEqual(data.formatter.write_calls,
[(None, '/some/abs/path')])
self.assertEqual(data.formatter.write_metadata_calls,
[(None, '/some/abs/path', False)])
# check that the formatter gets called as if nothing has been saved
self.assertEqual(data.formatter.modified_ranges, [{
'x_set': mr_full,
'y': mr_full
}])
self.assertEqual(data.formatter.last_saved_indices, [{
'x_set': None,
'y': None
}])
# but the dataset afterward has its original mods back
self.assertEqual(data.x_set.modified_range, mr)
self.assertEqual(data.y.modified_range, mr)
self.assertEqual(data.x_set.last_saved_index, lsi)
self.assertEqual(data.y.last_saved_index, lsi)
# recreate the formatter to clear the calls attributes
data.formatter = RecordingMockFormatter()
data.write_copy(location='some/rel/path')
self.assertEqual(data.formatter.write_calls,
[(mockbase, 'some/rel/path')])
self.assertEqual(data.formatter.write_metadata_calls,
[(mockbase, 'some/rel/path', False)])
mockbase2 = os.path.abspath('some/other/folder')
io2 = DiskIO(mockbase2)
with self.assertRaises(ValueError):
# if location=False we need to specify it in write_copy
data.write_copy(io_manager=io2)
data.location = 'yet/another/path'
data.formatter = RecordingMockFormatter()
data.write_copy(io_manager=io2)
self.assertEqual(data.formatter.write_calls,
[(mockbase2, 'yet/another/path')])
self.assertEqual(data.formatter.write_metadata_calls,
[(mockbase2, 'yet/another/path', False)])
return A * (p**(m)) + B
def sequence_decay(t, A, B, T):
return A * (np.e**(-t / T)) + B
def Exp_Sin_decay(t, A, B, F, Phase, T):
return A * (np.e**((-t / T)**1.0)) * np.sin(2 * 3.14 * F * t + Phase) + B
#%%
IO = DiskIO(base_location='C:\\Users\\LocalAdmin\\Documents\\RB_experiment')
formatter = HDF5FormatMetadata()
'''
data operated with Hardmard gate in 2 qubit space
'''
location1 = '2018-01-09/11-35-49/RB_experimentAllXY_sequence'
location2 = '2018-01-09/15-00-49/RB_experimentAllXY_sequence'
location3 = '2018-01-09/17-00-07/RB_experimentAllXY_sequence'
location4 = '2018-01-10/16-22-55/RB_experimentAllXY_sequence'
location5 = '2018-01-16/14-39-54/RB_experimentAllXY_sequence'
'''
data operated with Hardmard gate in 2 qubit space
'''
location6 = '2018-01-16/15-26-33/RB_experimentAllXY_sequence'
location7 = '2018-01-16/15-38-47/RB_experimentAllXY_sequence'
def T2_star_fitting(t, A, B, F, Phase, T):
return A * (np.e**(-(t / T)**2)) * np.sin(2 * 3.14 * F * t + Phase) + B
def T2_star_fitting2(t, A, B, T):
return A * (np.e**(-(t / T)**2)) + B
# return A*(np.exp(-(t/T)**2))*+B
#%%
IO = DiskIO(base_location='C:\\Users\\LocalAdmin\\Documents\\RB_experiment')
formatter = HDF5FormatMetadata()
IO_new = DiskIO(
base_location=
'K:\\ns\\qt\\spin-qubits\\data\\b059_data\\2018 data\\Data\\RB_experiment')
#%%
location = '2017-12-12/16-57-48/RB_experimentAllXY_sequence'
location2 = '2017-12-12/17-28-29/RB_experimentAllXY_sequence'
location3 = '2017-12-12/17-47-41/RB_experimentAllXY_sequence'
location3 = '2018-03-23/14-41-59/RB_experimentAllXY_sequence'
location3 = '2018-03-23/17-16-26/RB_experimentAllXY_sequence'
location3 = '2018-03-23/17-39-47/RB_experimentAllXY_sequence'
Sweep_Value = P[1:5.5:0.5]
Sweep_2 = Q[2:10:1]
LP1 = Loop(sweep_values = Sweep_2).each(F)
#LP = Loop(sweep_values = Sweep_Value).each(LP1, TP, E)
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]
class TestMockInstLoop(TestCase):
def setUp(self):
get_data_manager().restart(force=True)
kill_processes()
# TODO: figure out what's leaving DataManager in a weird state
# and fix it
get_data_manager().restart(force=True)
time.sleep(0.1)
self.model = AMockModel()
self.gates = MockGates(model=self.model, server_name='')
self.source = MockSource(model=self.model, server_name='')
self.meter = MockMeter(model=self.model, server_name='')
self.location = '_loop_test_'
self.location2 = '_loop_test2_'
self.io = DiskIO('.')
c1 = self.gates.chan1
self.loop = Loop(c1[1:5:1], 0.001).each(c1)
self.loop_progress = Loop(c1[1:5:1], 0.001,
progress_interval=1).each(c1)
self.assertFalse(self.io.list(self.location))
self.assertFalse(self.io.list(self.location2))
def tearDown(self):
for instrument in [self.gates, self.source, self.meter]:
instrument.close()
get_data_manager().close()
self.model.close()
self.io.remove_all(self.location)
self.io.remove_all(self.location2)
def check_empty_data(self, data):
expected = repr([float('nan')] * 4)
self.assertEqual(repr(data.gates_chan1.tolist()), expected)
self.assertEqual(repr(data.gates_chan1_set.tolist()), expected)
def check_loop_data(self, data):
self.assertEqual(data.gates_chan1.tolist(), [1, 2, 3, 4])
self.assertEqual(data.gates_chan1_set.tolist(), [1, 2, 3, 4])
self.assertTrue(self.io.list(self.location))
def test_background_and_datamanager(self):
# make sure that an unpicklable instrument can indeed run in a loop
# because the instrument itself is in a server
# TODO: if we don't save the dataset (location=False) then we can't
# sync it when we're done. Should fix that - for now that just means
# you can only do in-memory loops if you set data_manager=False
# TODO: this is the one place we don't do quiet=True - test that we
# really print stuff?
data = self.loop.run(location=self.location, background=True)
self.check_empty_data(data)
# wait for process to finish (ensures that this was run in the bg,
# because otherwise there *is* no loop.process)
self.loop.process.join()
data.sync()
self.check_loop_data(data)
def test_local_instrument(self):
# a local instrument should work in a foreground loop, but
# not in a background loop (should give a RuntimeError)
self.gates.close() # so we don't have two gates with same name
gates_local = MockGates(model=self.model, server_name=None)
self.gates = gates_local
c1 = gates_local.chan1
loop_local = Loop(c1[1:5:1], 0.001).each(c1)
# if spawn, pickle will happen
if mp.get_start_method() == "spawn":
with self.assertRaises(RuntimeError):
loop_local.run(location=self.location,
quiet=True,
background=True)
# allow for *nix
# TODO(giulioungaretti) see what happens ?
# what is the expected beavhiour ?
# The RunimError will never be raised here, as the forkmethod
# won't try to pickle anything at all.
else:
logging.error(
"this should not be allowed, but for now we let it be")
loop_local.run(location=self.location, quiet=True)
data = loop_local.run(location=self.location2,
background=False,
quiet=True)
self.check_loop_data(data)
def test_background_no_datamanager(self):
data = self.loop.run(location=self.location,
background=True,
data_manager=False,
quiet=True)
self.check_empty_data(data)
self.loop.process.join()
data.sync()
self.check_loop_data(data)
def test_foreground_and_datamanager(self):
data = self.loop.run(location=self.location,
background=False,
quiet=True)
self.assertFalse(hasattr(self.loop, 'process'))
self.check_loop_data(data)
def test_foreground_no_datamanager_progress(self):
data = self.loop_progress.run(location=self.location,
background=False,
data_manager=False,
quiet=True)
self.assertFalse(hasattr(self.loop, 'process'))
self.check_loop_data(data)
@patch('qcodes.loops.tprint')
def test_progress_calls(self, tprint_mock):
data = self.loop_progress.run(location=self.location,
background=False,
data_manager=False,
quiet=True)
self.assertFalse(hasattr(self.loop, 'process'))
self.check_loop_data(data)
expected_calls = len(self.loop_progress.sweep_values) + 1
self.assertEqual(tprint_mock.call_count, expected_calls)
# now run again with no progress interval and check that we get no
# additional calls
data = self.loop_progress.run(location=False,
background=False,
data_manager=False,
quiet=True,
progress_interval=None)
self.assertFalse(hasattr(self.loop, 'process'))
self.check_loop_data(data)
self.assertEqual(tprint_mock.call_count, expected_calls)
def test_foreground_no_datamanager(self):
data = self.loop.run(location=self.location,
background=False,
data_manager=False,
quiet=True)
self.assertFalse(hasattr(self.loop, 'process'))
self.check_loop_data(data)
def test_enqueue(self):
c1 = self.gates.chan1
loop = Loop(c1[1:5:1], 0.01).each(c1)
data1 = loop.run(location=self.location,
quiet=True,
background=True,
data_manager=True)
# second running of the loop should be enqueued, blocks until
# the first one finishes.
# TODO: check what it prints?
data2 = loop.run(location=self.location2,
quiet=True,
background=True,
data_manager=True)
data1.sync()
data2.sync()
self.assertEqual(data1.gates_chan1.tolist(), [1, 2, 3, 4])
for v in data2.gates_chan1:
self.assertTrue(np.isnan(v))
loop.process.join()
data2.sync()
self.assertEqual(data2.gates_chan1.tolist(), [1, 2, 3, 4])
# and while we're here, check that running a loop in the
# foreground *after* the background clears its .process
self.assertTrue(hasattr(loop, 'process'))
loop.run_temp()
self.assertFalse(hasattr(loop, 'process'))
def time_trace(dev_name: str, channels: Dict[str, int], units: Dict[str, str],
prefactors: Dict[str, Any], samplerate: int,
sampleduration: Union[float, int]):
"""Records a time trace of data from DAQ analog input channels, converts data to desired units.
Args:
dev_name: DAQ device name (e.g. 'Dev1').
channel: Dict of {channel_name: analog_input} (e.g. {'MAG': 0, 'SUSCX': 1}).
unit: Physical unit of the channel (e.g. {'MAG': 'Phi0', 'SUSCX': 'Phi0/A'}).
prefactor: Dict of {channel_name: Pint Quantity} from microscope.get_prefactors().
samplerate: DAQ sampling rate (for each channel) in Hz.
sampleduration: Sampling time in seconds.
Returns:
Dict: mdict
"""
loc_provider = qc.FormatLocation(
fmt='./data/{date}/#{counter}_{name}_{time}')
loc = loc_provider(DiskIO('.'), record={'name': 'time_trace'})
pathlib.Path(loc).mkdir(parents=True, exist_ok=True)
prefactor_strs = {}
for ch in channels:
unit = units[ch]
prefactors[ch].ito('{}/V'.format(unit))
prefactor_strs.update({
ch:
'{} {}'.format(prefactors[ch].magnitude, prefactors[ch].units)
})
nsamples = int(samplerate * sampleduration)
time = np.linspace(0, sampleduration, nsamples)
mdict = {
'time': {
'array': time,
'unit': 's'
},
'metadata': {
#'channels': channels,
#'units': units,
#'prefactors': prefactor_strs,
'samplerate': samplerate,
'sampleduration': sampleduration,
'location': loc
}
}
nsamples = int(samplerate * sampleduration)
time = np.linspace(0, sampleduration, nsamples)
with nidaqmx.Task('time_trace_ai_task') as ai_task:
for inst in DAQAnalogInputs.instances():
inst.close()
daq_ai = DAQAnalogInputs('daq_ai',
dev_name,
samplerate,
channels,
ai_task,
samples_to_read=nsamples,
timeout=sampleduration + 10)
data_v = daq_ai.voltage()
daq_ai.close()
for i, ch in enumerate(channels):
mdict.update({
ch: {
'array': data_v[i] * prefactors[ch].magnitude,
'unit': units[ch],
'prefactor': prefactor_strs[ch]
}
})
io.savemat(loc + '/time_trace.mat', mdict)
return mdict
def get_surface(self, x_vec: np.ndarray, y_vec: np.ndarray,
tdc_params: Dict[str, Any]) -> None:
"""Performs touchdowns on a grid and fits a plane to the resulting surface.
Args:
x_vec: 1D array of x positions (must be same length as y_vec).
y_vec: 1D array of y positions (must be same length as x_vec).
tdc_params: Dict of capacitive touchdown parameters as defined
in measurement configuration file.
"""
old_pos = self.scanner.position()
#: True if touchdown doesn't occur for any point in the grid
out_of_range = False
#: True if the loop is exited before finishing
premature_exit = False
self.scanner.break_loop = False
self.scanner.td_has_occurred = False
self.snapshot(update=True)
x_grid, y_grid = np.meshgrid(x_vec, y_vec, indexing='ij')
td_grid = np.full((len(x_vec), len(y_vec)), np.nan, dtype=np.double)
log.info('Aqcuiring a plane.')
v_retract = self.scanner.voltage_retract[self.temp].to('V').magnitude
fig = plt.figure(figsize=(8, 3))
ax0 = fig.add_subplot(121, projection='3d')
ax1 = fig.add_subplot(122, projection='3d')
for ax in [ax0, ax1]:
ax.set_xlabel('x position [V]')
ax.set_ylabel('y position [V]')
ax.set_zlabel('z position [V]')
ax0.set_title('Sample Plane')
ax1.set_title('Sample Surface')
fig.canvas.draw()
fig.show()
for i in range(len(x_vec)):
for j in range(len(y_vec)):
#: If any of the safety limits in td_cap() are exceeded,
#: or the loop is interrupted by the user.
if self.scanner.break_loop and not self.scanner.td_has_occurred:
log.warning('Aborting get_surface().')
premature_exit = True
break #: goes to outer break statement
else:
self.scanner.goto([x_grid[i, j], y_grid[i, j], v_retract])
data, tdc_plot = self.td_cap(tdc_params, update_snap=False)
td_grid[i, j] = self.scanner.td_height
clear_output(wait=True)
if self.scanner.td_height is None:
out_of_range = True
premature_exit = True
log.warning(
'Touchdown out of range. Stopping get_surface().')
self.scanner.goto(old_pos)
break #: goes to outer break statement
plt.close(fig)
fig = plt.figure(figsize=(8, 3))
ax0 = fig.add_subplot(121, projection='3d')
ax1 = fig.add_subplot(122, projection='3d')
for ax in [ax0, ax1]:
ax.scatter(x_grid[np.isfinite(td_grid)],
y_grid[np.isfinite(td_grid)],
td_grid[np.isfinite(td_grid)],
cmap='viridis')
ax.set_xlabel('x position [V]')
ax.set_ylabel('y position [V]')
ax.set_zlabel('z position [V]')
ax0.set_title('Sample Plane')
ax1.set_title('Sample Surface')
fig.canvas.draw()
fig.show()
plt.close(tdc_plot.fig)
continue #: skips outer break statement
break #: occurs only if out_of_range or loop is broken
self.scanner.goto(old_pos)
if not out_of_range and not premature_exit:
self.scanner.metadata.update(
{'td_grid': {
'x': x_grid,
'y': y_grid,
'z': td_grid
}})
# Create spline function to interpolate over surface:
self.scanner.surface_interp = Rbf(x_grid,
y_grid,
td_grid,
function='cubic')
#: Fit a plane to the td_grid
x = np.reshape(x_grid, (-1, 1))
y = np.reshape(y_grid, (-1, 1))
td = np.reshape(td_grid, (-1, 1))
z = np.column_stack((x, y, np.ones_like(x)))
plane, res, _, _ = lstsq(z, td)
log.info('New plane : {}.'.format([plane[i][0] for i in range(3)]))
ax0.plot_surface(x_grid,
y_grid,
plane[0] * x_grid + plane[1] * y_grid + plane[2],
cmap='viridis',
alpha=0.5)
ax1.plot_surface(x_grid,
y_grid,
self.scanner.surface_interp(x_grid, y_grid),
cmap='viridis',
alpha=0.5)
for i, axis in enumerate(['x', 'y', 'z']):
self.scanner.metadata['plane'].update({axis: plane[i][0]})
self.atto.surface_is_current = True
loc_provider = qc.FormatLocation(
fmt='./data/{date}/#{counter}_{name}_{time}')
loc = loc_provider(DiskIO('.'), record={'name': 'surface'})
pathlib.Path(loc).mkdir(parents=True, exist_ok=True)
fig.suptitle(loc)
fig.canvas.draw()
fig.show()
plt.savefig(loc + '/surface.png')
mdict = {
'plane': {
ax: self.scanner.metadata['plane'][ax]
for ax in ['x', 'y', 'z']
},
'td_grid': {
ax: self.scanner.metadata['td_grid'][ax]
for ax in ['x', 'y', 'z']
}
}
io.savemat(loc + '/surface.mat', mdict)
def iv_tek_mod_daq(self, ivm_params: Dict[str, Any]) -> None:
"""Performs digital feedback on mod coil to measure flux vs. delay.
AFG ch1 is used for pulse generator bias.
AFG ch2 is used for comparator bias.
DG ch1 is used for pulse generator trigger.
Args:
ivm_params: Dict of measurement parameters as definted in config_measurements json file.
Returns:
Tuple[Dict]: data_dict, metadict
Dictionaries containing data arrays and instrument metadata.
"""
data_dict = {}
meta_dict = {}
daq_config = self.config['instruments']['daq']
ai_channels = daq_config['channels']['analog_inputs']
meas_channels = ivm_params['channels']
channels = {}
for ch in meas_channels:
channels.update({ch: ai_channels[ch]})
vmod = self.Q_(ivm_params['vmod_initial']).to('V').magnitude
vcomp_set = self.Q_(ivm_params['vcomp_set']).to('V').magnitude
vmod_low = self.Q_(ivm_params['vmod_low']).to('V').magnitude
vmod_high = self.Q_(ivm_params['vmod_high']).to('V').magnitude
tsettle = self.Q_(ivm_params['tsettle']).to('s').magnitude
tavg = self.Q_(ivm_params['tavg']).to('s').magnitude
time_constant = self.Q_(ivm_params['time_constant'])
period = self.Q_(ivm_params['afg']['ch1']['period'])
delay0, delay1 = [self.Q_(val).to('s').magnitude for val in ivm_params['dg']['range']]
delay_vec = np.linspace(delay0, delay1, ivm_params['dg']['nsteps'])
vmod_vec = np.full_like(delay_vec, np.nan, dtype=np.double)
#: Set AFG pulse parameters
for ch in [1, 2]:
p = ivm_params['afg']['ch{}'.format(ch)]
getattr(self.afg, 'voltage_high{}'.format(ch))('{}V'.format(self.Q_(p['high']).to('V').magnitude))
getattr(self.afg, 'voltage_low{}'.format(ch))('{}V'.format(self.Q_(p['low']).to('V').magnitude))
getattr(self.afg, 'pulse_period{}'.format(ch))('{}us'.format(self.Q_(p['period']).to('us').magnitude))
getattr(self.afg, 'pulse_width{}'.format(ch))('{}us'.format(self.Q_(p['width']).to('us').magnitude))
getattr(self.afg, 'pulse_trans_lead{}'.format(ch))('{}us'.format(self.Q_(p['lead']).to('us').magnitude))
getattr(self.afg, 'pulse_trans_trail{}'.format(ch))('{}us'.format(self.Q_(p['trail']).to('us').magnitude))
getattr(self.afg, 'pulse_delay{}'.format(ch))('{}us'.format(self.Q_(p['delay']).to('us').magnitude))
#: Set delay generator parameters
p = ivm_params['dg']
self.dg.delay_B('A, {:e}'.format(delay0))
self.dg.delay_C('T0, {:e}'.format(self.Q_(p['ch2']['delay']).to('s').magnitude))
self.dg.delay_D('C, {:e}'.format(self.Q_(p['ch2']['width']).to('s').magnitude))
self.dg.amp_out_AB(self.Q_(p['ch1']['voltage']).to('V').magnitude)
self.dg.offset_out_AB(self.Q_(p['ch1']['offset']).to('V').magnitude)
self.dg.amp_out_CD(self.Q_(p['ch2']['voltage']).to('V').magnitude)
self.dg.offset_out_CD(self.Q_(p['ch2']['offset']).to('V').magnitude)
self.MAG_lockin.time_constant(self.Q_(ivm_params['time_constant']).to('s').magnitude)
#: Get instrument metadata and prefactors
lockin_snap = self.MAG_lockin.snapshot(update=True)
lockin_meta = {}
for param in ['time_constant', 'sensitivity', 'phase', 'reserve', 'filter_slope']:
lockin_meta.update({param: lockin_snap['parameters'][param]})
meta_dict.update({'metadata':
{'lockin': lockin_meta,
'afg': self.afg.snapshot(update=True),
'dg': self.dg.snapshot(update=True),
'ivm_params': ivm_params}
})
#prefactor = 1 / (10 / lockin_snap['parameters']['sensitivity']['value'])
#prefactor /= ivm_params['channels']['lockinX']['gain']
with nidaqmx.Task('ai_task') as ai_task, nidaqmx.Task('ao_task') as ao_task:
ao = '{}/ao{}'.format(daq_config['name'], daq_config['channels']['analog_outputs']['mod'])
ao_task.ao_channels.add_ao_voltage_chan(ao, 'mod')
for ch, idx in channels.items():
channel = '{}/ai{}'.format(daq_config['name'], idx)
ai_task.ai_channels.add_ai_voltage_chan(channel, ch)
figM = plt.figure(figsize=(4,3))
axM = plt.gca()
plt.xlim(min(delay_vec), max(delay_vec))
plt.xlabel(r'Delay time [$\mu$s]')
plt.ylabel('Modulation Voltage [V]')
figT = plt.figure(figsize=(4,3))
axT = plt.gca()
plt.xlabel('Iteration number')
plt.ylabel('Modulation Voltage [V]')
log.info('Starting iv_tek_mod_daq.')
try:
#: Sweep delay time
for j in range(len(delay_vec)):
self.dg.delay_A('T0, {:e}'.format(delay_vec[j]))
self.dg.delay_B('A, {:e}'.format(period.to('s').magnitude - delay_vec[j]))
elapsed_time = 0
nsamples = 0
vmod_time = np.array([])
t0 = time.time()
time.sleep(0.01)
#: Do digital PID control
while elapsed_time < tsettle + tavg:
ai_data = ai_task.read()
vcomp = ai_data[0]
err = vcomp - vcomp_set
vmod += P * err
vmod = np.mod(vmod, vmod_high)
#vmod = max(vmod, vmod_low) if vmod < 0 else min(vmod, vmod_high)
ao_task.write(vmod)
elapsed_time = time.time() - t0
nsamples += 1
vmod_time = np.append(vmod_time, vmod)
avg_start_pt = int(nsamples * tavg // (tsettle + tavg))
vmod_vec[j] = np.mean(vmod_time[avg_start_pt:])
clear_artists(axM)
axM.plot(delay_vec, vmod_vec, 'bo-')
plt.tight_layout()
figM.canvas.draw()
clear_artists(axT)
axT.plot(vmod_time, 'bo')
plt.tight_layout()
figT.canvas.draw()
time.sleep(0.05)
except KeyboardInterrupt:
log.warning('Measurement aborted by user.')
data_dict.update({
'delay_vec': {'array': delay_vec, 'unit': 's'},
'vmod_vec': {'array': vmod_vec, 'unit': 'V'}
})
if ivm_params['save']:
#: Get/create data location
loc_provider = qc.FormatLocation(fmt='{date}/#{counter}_{name}_{time}')
loc = loc_provider(DiskIO('.'), record={'name': ivm_params['fname']})
pathlib.Path(loc).mkdir(parents=True, exist_ok=True)
#: Save arrays to mat
io.savemat('{}/{}'.format(loc, ivm_params['fname']), data_dict)
#: Save metadata to json
with open(loc + '/metadata.json', 'w') as f:
try:
json.dump(meta_dict, f, sort_keys=True, indent=4, skipkeys=True)
except TypeError:
pass
#: Save figures to png
figM.suptitle(loc)
figM.tight_layout(rect=[0, 0.03, 1, 0.95])
figM.savefig('{}/{}mod_d.png'.format(loc, ivm_params['fname']))
figT.suptitle(loc)
figT.tight_layout(rect=[0, 0.03, 1, 0.95])
figT.savefig('{}/{}mod_t.png'.format(loc, ivm_params['fname']))
log.info('Data saved to {}.'.format(loc))
return data_dict, meta_dict
def iv_mod_tek(self, ivm_params: Dict[str, Any]) -> Tuple[Dict[str, Any]]:
"""Measures IV characteristic at different mod coil voltages.
Args:
ivm_params: Dict of measurement parameters as definted in config_measurements json file.
Returns:
Tuple[Dict]: data_dict, metadict
Dictionaries containing data arrays and instrument metadata.
"""
data_dict = {}
meta_dict = {}
mod_range = [self.Q_(value).to('V').magnitude for value in ivm_params['mod_range']]
bias_range = [self.Q_(value).to('V').magnitude for value in ivm_params['bias_range']]
mod_vec = np.linspace(mod_range[0], mod_range[1], ivm_params['ntek2'])
bias_vec = np.linspace(bias_range[0], bias_range[1], ivm_params['ntek1'])
mod_grid, bias_grid = np.meshgrid(mod_vec, bias_vec)
data_dict.update({
'mod_vec': {'array': mod_vec, 'unit': 'V'},
'bias_vec': {'array': bias_vec, 'unit': 'V'},
'mod_grid': {'array': mod_grid, 'unit': 'V'},
'bias_grid': {'array': bias_grid, 'unit': 'V'}
})
ivmX = np.full_like(mod_grid, np.nan, dtype=np.double)
ivmY = np.full_like(mod_grid, np.nan, dtype=np.double)
#: Set AFG output channels
self.afg.voltage_low1('0V')
self.afg.voltage_high1('{}V'.format(bias_range[0]))
self.afg.voltage_low2('0V')
self.afg.voltage_high2('{}V'.format(mod_range[0]))
self.afg.voltage_offset2('0V')
#: Set pulse parameters
for ch in [1, 2]:
p = ivm_params['afg']['ch{}'.format(ch)]
getattr(self.afg, 'pulse_period{}'.format(ch))('{}us'.format(self.Q_(p['period']).to('us').magnitude))
getattr(self.afg, 'pulse_width{}'.format(ch))('{}us'.format(self.Q_(p['width']).to('us').magnitude))
getattr(self.afg, 'pulse_trans_lead{}'.format(ch))('{}us'.format(self.Q_(p['lead']).to('us').magnitude))
getattr(self.afg, 'pulse_trans_trail{}'.format(ch))('{}us'.format(self.Q_(p['trail']).to('us').magnitude))
getattr(self.afg, 'pulse_delay{}'.format(ch))('{}us'.format(self.Q_(p['delay']).to('us').magnitude))
#: Get instrument metadata and prefactors
lockin_snap = self.MAG_lockin.snapshot(update=True)
lockin_meta = {}
for param in ['time_constant', 'sensitivity', 'phase', 'reserve', 'filter_slope']:
lockin_meta.update({param: lockin_snap['parameters'][param]})
meta_dict.update({'metadata':
{'lockin': lockin_meta,
'afg': self.afg.snapshot(update=True),
'ivm_params': ivm_params}
})
prefactor = 1 / (10 / lockin_snap['parameters']['sensitivity']['value'])
prefactor /= ivm_params['channels']['lockinX']['gain']
delay = ivm_params['delay_factor'] * lockin_snap['parameters']['time_constant']['value']
fig, ax = plt.subplots(1, figsize=(4,3))
ax.set_xlim(min(bias_range), max(bias_range))
ax.set_xlabel('Bias [V]')
ax.set_ylabel('Voltage [V]')
ax.set_title(ivm_params['channels']['lockinX']['label'])
log.info('Starting iv_mod_tek.')
try:
for j in range(len(mod_vec)):
dataX, dataY, dataX_avg, dataY_avg = (np.zeros(len(mod_vec)), ) * 4
self.afg.voltage_offset2('{}V'.format(mod_vec[j]))
for _ in range(ivm_params['navg']):
for i in range(len(bias_vec)):
self.afg.voltage_high1('{}V'.format(bias_vec[i]))
time.sleep(delay)
dataX[i] = self.MAG_lockin.X()
dataY[i] = self.MAG_lockin.Y()
dataX_avg += dataX
dataY_avg += dataY
dataX_avg /= ivm_params['navg']
dataY_avg /= ivm_params['navg']
ivmX[:,j] = prefactor * dataX_avg
ivmY[:,j] = prefactor * dataY_avg
clear_artists(ax)
ax.plot(bias_vec, prefactor * dataX_avg, 'bo-')
plt.tight_layout()
fig.canvas.draw()
fig.show()
except KeyboardInterrupt:
log.warning('Measurement aborted by user.')
figX = plt.figure(figsize=(4,3))
plt.pcolormesh(mod_grid, bias_grid, ivmX)
plt.xlabel('Modulation [V]')
plt.ylabel('Bias [V]')
plt.title(ivm_params['channels']['lockinX']['label'])
figX.tight_layout(rect=[0, 0.03, 1, 0.95])
cbarX = plt.colorbar()
cbarX.set_label('Voltage [V]')
figY = plt.figure(figsize=(4,3))
plt.pcolormesh(mod_grid, bias_grid, ivmY)
plt.xlabel('Modulation [V]')
plt.ylabel('Bias [V]')
plt.title(ivm_params['channels']['lockinY']['label'])
figY.tight_layout(rect=[0, 0.03, 1, 0.95])
cbarY = plt.colorbar()
cbarY.set_label('Voltage [V]')
data_dict.update({
'lockinX': {'array': ivmX, 'unit': 'V'},
'lockinY': {'array': ivmY, 'unit': 'V'}
})
if ivm_params['save']:
#: Get/create data location
loc_provider = qc.FormatLocation(fmt='{date}/#{counter}_{name}_{time}')
loc = loc_provider(DiskIO('.'), record={'name': ivm_params['fname']})
pathlib.Path(loc).mkdir(parents=True, exist_ok=True)
#: Save arrays to mat
io.savemat('{}/{}'.format(loc, ivm_params['fname']), data_dict)
#: Save metadata to json
with open(loc + '/metadata.json', 'w') as f:
try:
json.dump(meta_dict, f, sort_keys=True, indent=4, skipkeys=True)
except TypeError:
pass
#: Save figures to png
figX.suptitle(loc)
figX.savefig('{}/{}X.png'.format(loc, ivm_params['fname']))
figY.suptitle(loc)
figY.savefig('{}/{}Y.png'.format(loc, ivm_params['fname']))
log.info('Data saved to {}.'.format(loc))
return data_dict, meta_dict
loop = loop.loop((sp[sp.values]))
play_task = Task(upload_play, seq)
if loop is not None:
m = loop.each(play_task, *params)
else:
m = Measure(play_task, *params)
ds = m.run(loc_record={'name':name})
return ds
path = 'C:/Projects/test/data'
io = DiskIO(path)
DataSet.default_io = io
station = Station()
# create "AWG1"
awgs = init_hardware()
# create channels P1, P2
p = init_pulselib(awgs)
v_param = lp.linspace(0, 200, 5, axis=0, unit = "mV", name = "vPulse")
t_wait = lp.linspace(20, 100, 3, axis=1, unit = "mV", name = "t_wait")
seg1 = p.mk_segment()
data_array1 = DataArray(preset_data = data, name = 'digitizer', is_setpoint = True)
data_array2 = DataArray(preset_data = data, name = 'digitizer2')
data_array3 = DataArray(preset_data = data, name = 'digitizer3')
#data_array4 = DataArray(parameter=digitizer_param, is_setpoint=True)
data_array5 = DataArray(preset_data = data, name = 'digitizer5')
data_array6 = DataArray(preset_data = data1, name = 'digitizer6')
"""
#%%
NewIO = DiskIO(base_location='C:\\Users\\LocalAdmin\\Documents')
formatter = HDF5FormatMetadata()
try_location = 'trytrytry'
"""
#arrays = LP.containers()
arrays2 = []
arrays3 = [data_array1,]
arrays4 = [data_array1, data_array2, data_array3]
data_set = new_data(arrays=arrays3, location=try_location, loc_record = {'name':'T1', 'label':'Vread_sweep'}, io = NewIO,)
#data_set.save_metadata()
"""
#%% load data
NewIO = DiskIO(base_location='C:\\Users\\LocalAdmin\\Documents')
def fft_noise(dev_name: str, channel: Dict[str, int], unit: str,
prefactor: Any, samplerate: int,
sampleduration: Union[float, int], navg: int, fmax: Union[float,
int]):
"""Noise measurement of a single channel.
Args:
dev_name: DAQ device name (e.g. 'Dev1').
channel: Dict of {channel_name: analog_input} (e.g. {'MAG': 0}).
unit: Physical unit of the channel (e.g. 'Phi0').
prefactor: Pint Quantity with dimenions of unit/V, from microscope.get_prefactors().
samplerate: DAQ sampling rate in Hz.
sampleduration: Sampling time in seconds.
navg: Number of times to average the spectrum.
fmax: Maximum frequency up to which the spectrum will be saved.
Returns:
Dict: mdict
"""
loc_provider = qc.FormatLocation(
fmt='./data/{date}/#{counter}_{name}_{time}')
loc = loc_provider(DiskIO('.'), record={'name': 'fft_noise'})
pathlib.Path(loc).mkdir(parents=True, exist_ok=True)
prefactor_str = {}
prefactor.ito('{}/V'.format(unit))
prefactor_str.update({
list(channel.keys())[0]:
'{} {}'.format(prefactor.magnitude, prefactor.units)
})
mdict = {
'metadata': {
'channel': channel,
'unit': unit,
'prefactor': prefactor_str,
'samplerate': samplerate,
'sampleduration': sampleduration,
'navg': navg,
'fmax': fmax,
'location': loc
}
}
nsamples = int(samplerate * sampleduration)
v_fft_avg = np.zeros((nsamples // 2, ))
with nidaqmx.Task('fft_noise_ai_task') as ai_task:
for inst in DAQAnalogInputs.instances():
inst.close()
daq_ai = DAQAnalogInputs('daq_ai',
dev_name,
samplerate,
channel,
ai_task,
samples_to_read=nsamples,
timeout=sampleduration + 10)
for i in range(navg):
data_v = daq_ai.voltage()[0].T
Fs = nsamples / sampleduration
v_fft = np.fft.fft(data_v) / (nsamples /
np.sqrt(2 * sampleduration))
v_fft_abs = np.abs(v_fft[:nsamples // 2])
freqs = np.fft.fftfreq(nsamples, d=1 / Fs)[:nsamples // 2]
v_fft_avg += v_fft_abs
daq_ai.close()
v_fft_avg = v_fft_avg / navg
sig_fft_avg = prefactor.magnitude * v_fft_avg
mdict.update({
'v_fft_avg': v_fft_avg[freqs < fmax],
'sig_fft_avg': sig_fft_avg[freqs < fmax],
'freqs': freqs[freqs < fmax]
})
fig, ax = plt.subplots(1, 2, figsize=(8, 4), tight_layout=True)
ax[0].loglog(freqs, v_fft_avg, lw=1)
ax[0].set_ylabel('V/$\\sqrt{Hz}$')
ax[1].loglog(freqs, sig_fft_avg, lw=1)
ax[1].set_ylabel('{}/$\\sqrt{Hz}$'.format(unit))
fig.suptitle(loc, x=0.5, y=1)
for i in [0, 1]:
ax[i].set_xlabel('Frequency [Hz]')
ax[i].grid()
plt.savefig(loc + '/fft_noise.png')
io.savemat(loc + '/fft_noise.mat', mdict)
return mdict
def join(self, *args):
return DiskIO('.').join(*args)
LOOP = Loop(sweep_values=Sweep_Value2).loop(
sweep_values=Sweep_Value1).each(AMP)
#LOOP = Loop(sweep_values = Sweep_Value1).each(DIG)
#Sweep_Value1 = T[-25:-27:0.1]
#Sweep_Value2 = LP[-558:-562:0.2]
#LOOP = Loop(sweep_values = Sweep_Value2).loop(sweep_values = Sweep_Value1).each(dig)
#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)
'''
