def extract_data(self):
self.raw_data_dict = OrderedDict()
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
self.raw_data_dict["timestamps"] = self.timestamps
self.timestamp = self.timestamps[0]
a = ma_old.MeasurementAnalysis(timestamp=self.timestamp,
auto=False,
close_file=False)
a.get_naming_and_values()
self.raw_data_dict["xvals"] = a.sweep_points
self.raw_data_dict["xlabel"] = a.parameter_names[0]
self.raw_data_dict["xunit"] = a.parameter_units[0]
self.raw_data_dict["bins"] = a.data_file["Experimental Data"][
"Experimental Metadata"]["bins"].value
self.raw_data_dict["measured_values"] = a.measured_values
self.raw_data_dict["value_names"] = a.value_names
self.raw_data_dict["value_units"] = a.value_units
self.raw_data_dict["measurementstring"] = a.measurementstring
self.raw_data_dict["folder"] = a.folder
a.finish()
def __init__(self,
t_start: str = None,
t_stop: str = None,
label: str = '_ro_amp_sweep_dephasing',
options_dict: dict = None,
extract_only: bool = False,
auto: bool = True,
close_figs: bool = True,
do_fitting: bool = True):
super().__init__(
t_start=t_start,
t_stop=t_start,
label=label,
options_dict=options_dict,
do_fitting=do_fitting,
close_figs=close_figs,
extract_only=extract_only,
)
self.single_timestamp = True
ts = a_tools.get_timestamps_in_range(timestamp_start=t_start,
timestamp_end=t_stop,
label=label,
exact_label_match=True)
if self.verbose:
print('DephasingAnalysisSweep', ts)
assert len(ts) == 1, 'Expected a single match, found %d' % len(ts)
self.timestamp = ts[0]
if auto:
self.run_analysis()
def extract_data(self):
"""
Custom data extraction for this specific experiment.
"""
self.timestamps = a_tools.get_timestamps_in_range(
self.t_start, self.t_stop,
label=self.labels)
self.raw_data_dict = OrderedDict()
# auto is True for the TwoD analysis as the heatmap can be useful
# for debugging the data
a = ma_old.TwoD_Analysis(timestamp=self.timestamps[0], auto=True,
close_file=False)
a.get_naming_and_values_2D()
ch_amp = a.data_file[self.ch_amp_key].attrs['value']
if self.ch_range_key is None:
ch_range = 2 # corresponds to a scale factor of 1
else:
ch_range = a.data_file[self.ch_range_key].attrs['value']
waveform_amp = a.data_file[self.waveform_amp_key].attrs['value']
amp = ch_amp*ch_range/2*waveform_amp
self.raw_data_dict['amp'] = amp
self.raw_data_dict['phases'] = a.measured_values[0]
self.raw_data_dict['times'] = a.sweep_points
# hacky but required for data saving
self.raw_data_dict['folder'] = a.folder
self.raw_data_dict['timestamps'] = self.timestamps
a.finish()
def extract_data(self):
"""
Custom data extraction for this specific experiment.
"""
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
self.raw_data_dict = OrderedDict()
# auto is True for the TwoD analysis as the heatmap can be useful
# for debugging the data
a = ma_old.TwoD_Analysis(timestamp=self.timestamps[0],
auto=True,
close_file=False)
a.get_naming_and_values_2D()
# FIXME: this is hardcoded and should be an argument in options dict
amp_key = 'Snapshot/instruments/AWG8_8005/parameters/awgs_0_outputs_1_amplitude'
amp = a.data_file[amp_key].attrs['value']
self.raw_data_dict['amp'] = amp
self.raw_data_dict['phases'] = a.measured_values[0]
self.raw_data_dict['times'] = a.sweep_points
# hacky but required for data saving
self.raw_data_dict['folder'] = a.folder
self.raw_data_dict['timestamps'] = self.timestamps
a.finish()
def extract_linecuts(start_timestamp, end_timestamp, label):
data_dict = {}
timestamps = a_tools.get_timestamps_in_range(start_timestamp, end_timestamp,
label=label)
if len(timestamps) == 0:
raise ValueError('No timestamps in range')
# for tst in conv_stamps:
for tst in timestamps:
try:
a = ma.MeasurementAnalysis(timestamp=tst, auto=False)
cl_idx0 = a.measurementstring.find('att_') # for restless
cl_idx1 = a.measurementstring.find('cl')
n_cl = int(a.measurementstring[cl_idx0+4:cl_idx1])
att_idx0 = a.measurementstring.find('noise_') # for restless
att_idx1 = a.measurementstring.find('att')
att = (a.measurementstring[att_idx0+6:att_idx1])
a.get_naming_and_values()
a.sweep_points
vals = a.measured_values[0]
if n_cl not in data_dict.keys():
data_dict[n_cl] = {}
if att not in data_dict[n_cl].keys():
data_dict[n_cl][att] = []
data_dict[n_cl][att] += [vals]
except Exception as e:
print(tst)
raise(e)
return data_dict
def extract_data(self):
self.raw_data_dict = OrderedDict()
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
self.raw_data_dict['timestamps'] = self.timestamps
self.timestamp = self.timestamps[0]
a = ma_old.MeasurementAnalysis(timestamp=self.timestamp,
auto=False,
close_file=False)
a.get_naming_and_values()
self.raw_data_dict['xvals'] = a.sweep_points
self.raw_data_dict['xlabel'] = a.parameter_names[0]
self.raw_data_dict['xunit'] = a.parameter_units[0]
self.raw_data_dict['bins'] = a.data_file['Experimental Data']\
['Experimental Metadata']['bins'].value
self.raw_data_dict['measured_values'] = a.measured_values
self.raw_data_dict['value_names'] = a.value_names
self.raw_data_dict['value_units'] = a.value_units
self.raw_data_dict['measurementstring'] = a.measurementstring
self.raw_data_dict['folder'] = a.folder
a.finish()
def _next_folder(self):
ts = self._current_timestamp()
if ts is None:
return None
tss = a_tools.get_timestamps_in_range(ts, label='')
if len(tss) < 2:
return None
return a_tools.get_folder(tss[1])
def extract_durations(start_timestamp, end_timestamp, label):
timestamps = a_tools.get_timestamps_in_range(start_timestamp, end_timestamp,
label=label)
durs = []
for tst in timestamps:
a = ma.MeasurementAnalysis(timestamp=tst, auto=False)
dur = get_duration_in_min(a)
durs.append(dur[0]*60 + dur[1])
a.finish()
return durs
def extract_data(self):
self.TD_timestamps = a_tools.get_timestamps_in_range(self.t_start, self.t_stop, label=self.labels)
if len(self.TD_timestamps) < 1:
raise ValueError("No timestamps in range! Check the labels and other filters.")
self.TD_dict = a_tools.get_data_from_timestamp_list(self.TD_timestamps, self.params_dict_TD, numeric_params=self.numeric_params)
# Use timestamps to calculate datetimes and add to dictionary
self.TD_dict['datetime'] = [a_tools.datetime_from_timestamp(timestamp) for timestamp in self.TD_dict['timestamps']]
def write_experiment_runs_to_text_files_conv_vs_restless(starttime,endtime,maxlength,filename_gateseq,number_of_gateseq):
"""
Function for writing experiment runs to text files. At the moment only
works for an experiment which is repeated for same parameters several times in time. It also assumes that one starts with conventional tuning, then restless etc. It's specialised for only experiment and is more of a One-fit.
----------------------------------------------------------------------------------------
Parameters:
starttime:string
Formatted in the standard form as used in PycQED_py3, in the form of e.g. 20160614_000000.
endtime:string
Formatted in the standard form as used in PycQED_py3, in the form of e.g.20160615_235959
maxlength: integer
Maximum length of germ power sequence
filename_gateseq: string
Text file containing the list of experiments/gatesequences
number_of_gateseq:
the number of gatesequences in each experiment
"""
from pycqed.analysis import measurement_analysis as ma
from pycqed.analysis import analysis_toolbox as a_tools
import measurement.pulse_sequences.gate_set_tomography as _gst
from importlib import reload
import h5py
reload(_gst)
experiment_timestamp_strings = a_tools.get_timestamps_in_range(starttime, endtime, label = 'GST')
file_path_names = []
for i in range(len(experiment_timestamp_strings)):
file_path_names.append(a_tools.data_from_time(experiment_timestamp_strings[i]))
file_path_names_conventional = file_path_names[0::2]
file_path_names_restless = file_path_names[1::2]
for i in range(len(file_path_names_conventional)):
fn = file_path_names_conventional[i]
suffix = fn[len(a_tools.datadir)+10:]
filename_input = file_path_names_conventional[i]+'\\'+suffix+'.hdf5'
filename_output = 'GST_data_paper_L%s_conv_%s_run%s_17june' %(maxlength,suffix, i) +'.txt'
_gst.write_textfile_data_for_GST_input_adapt_develop(filename_input,
filename_output,filename_gateseq,
number_of_gateseq,zero_one_inverted = 'automatic')
for i in range(len(file_path_names_restless)):
fn = file_path_names_restless[i]
suffix = fn[len(a_tools.datadir)+10:]
filename_input = file_path_names_restless[i]+'\\'+suffix+'.hdf5'
filename_output = 'GST_data_paper_L%s_rest_%s_run%s_17june' %(maxlength,suffix, i) +'.txt'
_gst.write_textfile_data_for_GST_input_adapt_develop(filename_input,
filename_output,filename_gateseq,
number_of_gateseq,zero_one_inverted = 'automatic')
def write_experiment_runs_to_text_files_conv_vs_restless(starttime,endtime,maxlength,filename_gateseq,number_of_gateseq):
"""
Function for writing experiment runs to text files. At the moment only
works for an experiment which is repeated for same parameters several times in time. It also assumes that one starts with conventional tuning, then restless etc. It's specialised for only experiment and is more of a One-fit.
----------------------------------------------------------------------------------------
Parameters:
starttime:string
Formatted in the standard form as used in PycQED_py3, in the form of e.g. 20160614_000000.
endtime:string
Formatted in the standard form as used in PycQED_py3, in the form of e.g.20160615_235959
maxlength: integer
Maximum length of germ power sequence
filename_gateseq: string
Text file containing the list of experiments/gatesequences
number_of_gateseq:
the number of gatesequences in each experiment
"""
from pycqed.analysis import measurement_analysis as ma
from pycqed.analysis import analysis_toolbox as a_tools
import measurement.pulse_sequences.gate_set_tomography as _gst
from importlib import reload
import h5py
reload(_gst)
experiment_timestamp_strings = a_tools.get_timestamps_in_range(starttime, endtime, label = 'GST')
file_path_names = []
for i in range(len(experiment_timestamp_strings)):
file_path_names.append(a_tools.data_from_time(experiment_timestamp_strings[i]))
file_path_names_conventional = file_path_names[0::2]
file_path_names_restless = file_path_names[1::2]
for i in range(len(file_path_names_conventional)):
fn = file_path_names_conventional[i]
suffix = fn[len(a_tools.datadir)+10:]
filename_input = file_path_names_conventional[i]+'\\'+suffix+'.hdf5'
filename_output = 'GST_data_paper_L%s_conv_%s_run%s_17june' %(maxlength,suffix, i) +'.txt'
_gst.write_textfile_data_for_GST_input_adapt_develop(filename_input,
filename_output,filename_gateseq,
number_of_gateseq,zero_one_inverted = 'automatic')
for i in range(len(file_path_names_restless)):
fn = file_path_names_restless[i]
suffix = fn[len(a_tools.datadir)+10:]
filename_input = file_path_names_restless[i]+'\\'+suffix+'.hdf5'
filename_output = 'GST_data_paper_L%s_rest_%s_run%s_17june' %(maxlength,suffix, i) +'.txt'
_gst.write_textfile_data_for_GST_input_adapt_develop(filename_input,
filename_output,filename_gateseq,
number_of_gateseq,zero_one_inverted = 'automatic')
def extract_data(self):
"""
Custom data extraction for this specific experiment.
"""
self.raw_data_dict = OrderedDict()
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
a = ma_old.MeasurementAnalysis(timestamp=self.timestamps[0],
auto=False,
close_file=False)
a.get_naming_and_values()
if 'bins' in a.data_file['Experimental Data'][
'Experimental Metadata'].keys():
bins = a.data_file['Experimental Data']['Experimental Metadata'][
'bins'].value
self.raw_data_dict['ncl'] = bins[:-6:2]
self.raw_data_dict['bins'] = bins
self.raw_data_dict['value_names'] = a.value_names
self.raw_data_dict['value_units'] = a.value_units
self.raw_data_dict['measurementstring'] = a.measurementstring
self.raw_data_dict['timestamp_string'] = a.timestamp_string
self.raw_data_dict['binned_vals'] = OrderedDict()
self.raw_data_dict['cal_pts_zero'] = OrderedDict()
self.raw_data_dict['cal_pts_one'] = OrderedDict()
self.raw_data_dict['cal_pts_two'] = OrderedDict()
self.raw_data_dict['measured_values_I'] = OrderedDict()
self.raw_data_dict['measured_values_X'] = OrderedDict()
for i, val_name in enumerate(a.value_names):
binned_yvals = np.reshape(a.measured_values[i],
(len(bins), -1),
order='F')
self.raw_data_dict['binned_vals'][val_name] = binned_yvals
self.raw_data_dict['cal_pts_zero'][val_name] =\
binned_yvals[-6:-4, :].flatten()
self.raw_data_dict['cal_pts_one'][val_name] =\
binned_yvals[-4:-2, :].flatten()
self.raw_data_dict['cal_pts_two'][val_name] =\
binned_yvals[-2:, :].flatten()
self.raw_data_dict['measured_values_I'][val_name] =\
binned_yvals[:-6:2, :]
self.raw_data_dict['measured_values_X'][val_name] =\
binned_yvals[1:-6:2, :]
else:
bins = None
self.raw_data_dict['folder'] = a.folder
self.raw_data_dict['timestamps'] = self.timestamps
a.finish() # closes data file
def measure_vs_pump_power(self, pump_powers, analyze=True):
timestamp_start = a_tools.current_timestamp()
self.on()
label = f'pump_power_scan_pf{self.pump_freq() / 1e9:.3f}G_' + \
f'sf{self.signal_freq() / 1e9:.3f}G'
self._measure_1D(self.pump_power, pump_powers, label, analyze)
self.off()
label = f'pump_power_scan_off_sf{self.signal_freq() / 1e9:.3f}G'
self._measure_1D(self.pump_power, pump_powers[:1], label, analyze)
if analyze:
timestamps = a_tools.get_timestamps_in_range(
timestamp_start, label='pump_power_scan')
ca.Amplifier_Characterization_Analysis(timestamps)
def extract_data(self):
self.raw_data_dict = {}
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_start,
label=self.labels)
self.raw_data_dict['timestamps'] = self.timestamps
data_fp = a_tools.get_datafilepath_from_timestamp(self.timestamps[0])
param_spec = {'data': ('Experimental Data/Data', 'dset')}
data = h5d.extract_pars_from_datafile(data_fp, param_spec)
self.raw_data_dict['number_flips'] = data['data'][:, 0]
for i, q in enumerate(self.qubits):
self.raw_data_dict['{}_data'.format(q)] = data['data'][:, i + 1]
self.raw_data_dict['folder'] = os.path.dirname(data_fp)
def extract_data(self):
"""
Custom data extraction for this specific experiment.
"""
self.timestamps = a_tools.get_timestamps_in_range(
self.t_start, self.t_stop,
label=self.labels)
self.timestamp = self.timestamps[0]
self.raw_data_dict = OrderedDict()
self.raw_data_dict['amps'] = []
self.raw_data_dict['data'] = []
for i, timestamp in enumerate(self.timestamps):
a = ma_old.MeasurementAnalysis(
timestamp=timestamp, auto=False, close_file=False)
a.get_naming_and_values()
if i == 0:
if self.ch_amp_key is None:
ch_amp = 1
else:
ch_amp = a.data_file[self.ch_amp_key].attrs['value']
if self.ch_range_key is None:
ch_range = 2 # corresponds to a scale factor of 1
else:
ch_range = a.data_file[self.ch_range_key].attrs['value']
waveform_amp = a.data_file[self.waveform_amp_key].attrs['value']
amp = ch_amp*ch_range/2*waveform_amp
# read conversion polynomial from the datafile if not provided as input
if isinstance(self.polycoeffs_freq_conv, str):
self.polycoeffs_freq_conv = np.array(
a.data_file[self.polycoeffs_freq_conv])
self.raw_data_dict['data'] =\
a.measured_values[self.ch_idx_cos] + \
1j * a.measured_values[self.ch_idx_sin]
# hacky but required for data saving
self.raw_data_dict['folder'] = a.folder
self.raw_data_dict['amps'].append(amp)
else:
# If multiple datasets are used, shapes must match
self.raw_data_dict['data'] +=\
a.measured_values[self.ch_idx_cos] + \
1j * a.measured_values[self.ch_idx_sin]
a.finish()
self.raw_data_dict['times'] = a.sweep_points
self.raw_data_dict['timestamps'] = self.timestamps
def extract_data(self):
self.raw_data_dict = dict()
self.raw_data_dict['timestamps'] = list()
self.raw_data_dict['folder'] = list()
self.timestamps = a_tools.get_timestamps_in_range(self.t_start, self.t_stop,label=self.labels)
for ts in self.timestamps:
data_fp = ma.a_tools.get_datafilepath_from_timestamp(ts)
param_spec = {'data_settings': ('Experimental Data', 'attr:all_attr'),
'data': ('Experimental Data/Data', 'dset'),
'optimization_settings': ('Optimization settings', 'attr:all_attr')}
self.raw_data_dict[ts] = h5d.extract_pars_from_datafile(data_fp, param_spec)
# Parts added to be compatible with base analysis data requirements
self.raw_data_dict['timestamps'].append(ts)
self.raw_data_dict['folder'].append(os.path.split(data_fp)[0])
def measure_vs_signal_freq_pump_freq(self,
signal_freqs,
pump_freqs,
analyze=True):
timestamp_start = a_tools.current_timestamp()
self.on()
label = f'signal_freq_pump_freq_scan_pp{self.pump_power():.2f}dB'
self._measure_2D(self.signal_freq, self.pump_freq, signal_freqs,
pump_freqs, label, analyze)
self.off()
label = f'signal_freq_pump_freq_scan_off'
self._measure_1D(self.signal_freq, signal_freqs, label, analyze)
if analyze:
timestamps = a_tools.get_timestamps_in_range(
timestamp_start, label='signal_freq_pump_freq_scan')
ca.Amplifier_Characterization_Analysis(timestamps)
def extract_data(self):
"""
Custom data extraction for this specific experiment.
"""
self.raw_data_dict = OrderedDict()
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
a = ma_old.MeasurementAnalysis(timestamp=self.timestamps[0],
auto=False,
close_file=False)
a.get_naming_and_values()
time = a.sweep_points[:-6:2]
self.raw_data_dict['time'] = time
self.raw_data_dict['time units'] = a.sweep_unit[0]
self.raw_data_dict['value_names'] = a.value_names
self.raw_data_dict['value_units'] = a.value_units
self.raw_data_dict['measurementstring'] = a.measurementstring
self.raw_data_dict['timestamp_string'] = a.timestamp_string
self.raw_data_dict['cal_pts_zero'] = OrderedDict()
self.raw_data_dict['cal_pts_one'] = OrderedDict()
self.raw_data_dict['cal_pts_two'] = OrderedDict()
self.raw_data_dict['measured_values_I'] = OrderedDict()
self.raw_data_dict['measured_values_X'] = OrderedDict()
for i, val_name in enumerate(a.value_names):
self.raw_data_dict['cal_pts_zero'][val_name] = \
a.measured_values[i][-6:-4]
self.raw_data_dict['cal_pts_one'][val_name] = \
a.measured_values[i][-4:-2]
self.raw_data_dict['cal_pts_two'][val_name] = \
a.measured_values[i][-2:]
self.raw_data_dict['measured_values_I'][val_name] = \
a.measured_values[i][::2][:-3]
self.raw_data_dict['measured_values_X'][val_name] = \
a.measured_values[i][1::2][:-3]
self.raw_data_dict['folder'] = a.folder
self.raw_data_dict['timestamps'] = self.timestamps
a.finish() # closes data file
def extract_data(self):
self.raw_data_dict = OrderedDict()
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
self.raw_data_dict['timestamps'] = self.timestamps
self.timestamp = self.timestamps[0]
a = ma_old.MeasurementAnalysis(timestamp=self.timestamp,
auto=False,
close_file=False)
a.get_naming_and_values()
self.raw_data_dict['xvals'] = a.sweep_points
self.raw_data_dict['xlabel'] = a.parameter_names[0]
self.raw_data_dict['xunit'] = a.parameter_units[0]
self.raw_data_dict['bins'] = a.data_file['Experimental Data'][
'Experimental Metadata']['bins'].value
if self.gst_exp_list_filepath == None:
gst_exp_list_filename = a.data_file['Experimental Data'][
'Experimental Metadata'].attrs['gst_exp_list_filename']
self.raw_data_dict['gst_exp_list_filepath'] = os.path.join(
gst_exp_filepath, gst_exp_list_filename)
else:
self.raw_data_dict['gst_exp_list_filepath'] = \
self.gst_exp_list_filepath
self.raw_data_dict['expList'] = pygsti_expList_from_dataset(
self.raw_data_dict['gst_exp_list_filepath'])
self.raw_data_dict['measured_values'] = a.measured_values
self.raw_data_dict['value_names'] = a.value_names
self.raw_data_dict['value_units'] = a.value_units
self.raw_data_dict['measurementstring'] = a.measurementstring
self.measurementstring = a.measurementstring
self.raw_data_dict['folder'] = a.folder
a.finish()
def extract_data(self):
self.TD_timestamps = a_tools.get_timestamps_in_range(
self.t_start,
self.t_stop,
label=self.labels,
exact_label_match=self.exact_label_match)
if len(self.TD_timestamps) < 1:
raise ValueError(
"No timestamps in range! Check the labels and other filters.")
self.TD_dict = a_tools.get_data_from_timestamp_list(
self.TD_timestamps,
self.params_dict_TD,
numeric_params=self.numeric_params)
# Use timestamps to calculate datetimes and add to dictionary
self.TD_dict['datetime'] = [
a_tools.datetime_from_timestamp(timestamp)
for timestamp in self.TD_dict['timestamps']
]
def extract_data(self):
"""
Extract pauli terms from multiple hd5 files.
"""
self.raw_data_dict = {}
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
for ts in self.timestamps:
data_fp = get_datafilepath_from_timestamp(ts)
param_spec = {
'TFD_dict':
('Analysis/quantities_of_interest', 'attr:all_attr'),
'tomo_dict': ('Analysis/quantities_of_interest/full_tomo_dict',
'attr:all_attr')
}
self.raw_data_dict[ts] = h5d.extract_pars_from_datafile(
data_fp, param_spec)
# Parts added to be compatible with base analysis data requirements
self.raw_data_dict['timestamps'] = self.timestamps
self.raw_data_dict['folder'] = os.path.split(data_fp)[0]
def extract_data(self):
self.raw_data_dict = {}
self.raw_data_dict['artificial_detuning'] = self.artificial_detuning
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_start,
label=self.labels)
self.raw_data_dict['timestamps'] = self.timestamps
data_fp = a_tools.get_datafilepath_from_timestamp(self.timestamps[0])
param_spec = {'data': ('Experimental Data/Data', 'dset')}
data = h5d.extract_pars_from_datafile(data_fp, param_spec)
self.raw_data_dict['points'] = data['data'][:, 0]
for i, q in enumerate(self.qubits):
self.raw_data_dict['{}_data'.format(q)] = data['data'][:, i + 1]
self.raw_data_dict['{}_times'.format(q)] = self.times[i]
param_spec_old_freq = {
'{}_freq_old'.format(q):
('Instrument settings/{}'.format(q), 'attr:freq_qubit')
}
old_freq = h5d.extract_pars_from_datafile(data_fp,
param_spec_old_freq)
self.raw_data_dict['{}_freq_old'.format(q)] = float(
old_freq['{}_freq_old'.format(q)])
self.raw_data_dict['folder'] = os.path.dirname(data_fp)
def extract_data(self):
"""
Custom data extraction for this specific experiment.
Overwrite this method if you wnat to
"""
self.timestamps = a_tools.get_timestamps_in_range(
self.t_start, self.t_stop,
label=self.labels)
self.raw_data_dict = OrderedDict()
for t in self.timestamps:
a = ma_old.TwoD_Analysis(
timestamp=t, auto=False, close_file=False)
a.get_naming_and_values_2D()
self.raw_data_dict['folder'] = a.folder
self.raw_data_dict['xvals'] = a.sweep_points
self.raw_data_dict['yvals'] = a.sweep_points_2D
self.raw_data_dict['zvals'] = a.measured_values[self.ch_idx].T
self.raw_data_dict['xlabel'] = a.parameter_names[0]
self.raw_data_dict['ylabel'] = a.parameter_names[1]
self.raw_data_dict['zlabel'] = a.value_names[self.ch_idx]
self.raw_data_dict['xunit'] = a.parameter_units[0]
self.raw_data_dict['yunit'] = a.parameter_units[1]
self.raw_data_dict['zunit'] = a.value_units[self.ch_idx]
self.raw_data_dict['measurementstring'] = a.measurementstring
self.raw_data_dict['timestamp_string'] = a.timestamp_string
a.finish()
self.raw_data_dict['times'] = a.sweep_points
self.raw_data_dict['timestamps'] = self.timestamps
def extract_data(self):
"""
Custom data extraction for this specific experiment.
"""
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
self.raw_data_dict = OrderedDict()
self.raw_data_dict['amps'] = []
self.raw_data_dict['data'] = []
for t in self.timestamps:
a = ma_old.MeasurementAnalysis(timestamp=t,
auto=False,
close_file=False)
a.get_naming_and_values()
ch_amp = a.data_file[self.ch_amp_key].attrs['value']
if self.ch_range_key is None:
ch_range = 2 # corresponds to a scale factor of 1
else:
ch_range = a.data_file[self.ch_range_key].attrs['value']
waveform_amp = a.data_file[self.waveform_amp_key].attrs['value']
amp = ch_amp * ch_range / 2 * waveform_amp
# amp = ch_amp
data = a.measured_values[self.ch_idx_cos] + 1j * \
a.measured_values[self.ch_idx_sin]
# hacky but required for data saving
self.raw_data_dict['folder'] = a.folder
self.raw_data_dict['amps'].append(amp)
self.raw_data_dict['data'].append(data)
a.finish()
self.raw_data_dict['times'] = a.sweep_points
self.raw_data_dict['timestamps'] = self.timestamps
def extract_data(start_timestamp, end_timestamp, label):
data_dict = {}
t0 = time.time()
timestamps = a_tools.get_timestamps_in_range(start_timestamp, end_timestamp,
label=label)
if len(timestamps) == 0:
raise ValueError('No timestamps in range')
# for tst in conv_stamps:
for tst in timestamps:
a = ma.MeasurementAnalysis(timestamp=tst, auto=False)
cl_idx1 = a.measurementstring.find('cl')
if 'conv' in label:
cl_idx0 = a.measurementstring.find('l_') # for conventional
else:
cl_idx0 = a.measurementstring.find('s_') # for restless
n_cl = int(a.measurementstring[cl_idx0+2:cl_idx1])
a.get_naming_and_values()
a.sweep_points
vals = a.measured_values[0]
if n_cl in data_dict.keys():
data_dict[n_cl] += [vals]
else:
data_dict[n_cl] = [vals]
for key in data_dict.keys():
data_dict[key] = (np.mean(data_dict[key], axis=0))
t1 = time.time()
print('extracting data took {:.2f}s'.format(t1-t0))
n_cl = np.sort(list(data_dict.keys()))
y = a.sweep_points
Z = np.zeros((len(y), len(n_cl)))
for i, n in enumerate(n_cl):
Z[:, i] = data_dict[n]
return n_cl, y, Z
def extract_data(self):
self.raw_data_dict = OrderedDict()
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
self.raw_data_dict["timestamps"] = self.timestamps
self.timestamp = self.timestamps[0]
a = ma_old.MeasurementAnalysis(timestamp=self.timestamp,
auto=False,
close_file=False)
a.get_naming_and_values()
for idx, lab in enumerate(["x", "y"]):
self.raw_data_dict[lab] = a.sweep_points[idx]
self.raw_data_dict["{}label".format(lab)] = a.parameter_names[idx]
self.raw_data_dict["{}unit".format(lab)] = a.parameter_units[idx]
self.raw_data_dict["measured_values"] = a.measured_values
self.raw_data_dict["value_names"] = a.value_names
self.raw_data_dict["value_units"] = a.value_units
self.raw_data_dict["measurementstring"] = a.measurementstring
self.raw_data_dict["folder"] = a.folder
a.finish()
def extract_verification_data(start_timestamp, end_timestamp):
# T1 calibration
timestamps_T1 = a_tools.get_timestamps_in_range(
start_timestamp, end_timestamp, label='T1')
# RB assessment
timestamps_RB = a_tools.get_timestamps_in_range(
start_timestamp, end_timestamp, label='RB_30')
cycles = len(timestamps_T1)
T1_dict = {'time': np.zeros(cycles),
'mean': np.zeros(cycles),
'stderr': np.zeros(cycles),
'F': np.zeros(cycles),
'F_std': np.zeros(cycles)}
RB_rstl_dict = {'time': np.zeros([cycles/2]),
'F': np.zeros([cycles/2]),
'F_std': np.zeros([cycles/2]),
'F_sem': np.zeros([cycles/2]),
'offset': np.zeros([cycles/2]),
'offset_std': np.zeros([cycles/2])}
RB_trad_dict = deepcopy(RB_rstl_dict)
Dux_trad_dict = {'in1_out1_attenuation': np.zeros(cycles/2),
'in2_out1_attenuation': np.zeros(cycles/2),
'in1_out1_phase': np.zeros(cycles/2)}
Dux_rstl_dict = deepcopy(Dux_trad_dict)
m = ma.MeasurementAnalysis(auto=False, timestamp=timestamps_T1[0])
starting_time = t_stampt_to_hours(
m.timestamp, start_timestamp=start_timestamp)
# extracting T1 data
for j in range(cycles):
m = ma.MeasurementAnalysis(auto=False, timestamp=timestamps_T1[j])
T1_dict['time'][j] = t_stampt_to_hours(
m.timestamp, start_timestamp=start_timestamp) - starting_time
T1_dict['mean'][j] = m.data_file['Analysis'][
'Fitted Params F|1>']['tau'].attrs['value']
T1_dict['stderr'][j] = m.data_file['Analysis'][
'Fitted Params F|1>']['tau'].attrs['stderr']
T1_val = uncertainties.ufloat(T1_dict['mean'][j], T1_dict['stderr'][j])
F_T1, p_T1 = calc_T1_limited_fidelity(T1_val, 20e-9)
T1_dict['F'][j] = 100*F_T1.nominal_value
T1_dict['F_std'][j] = 100*F_T1.std_dev
m.finish()
# extracting the RB traditional values
for j in range(int(cycles/2)):
m = ma.MeasurementAnalysis(auto=False, timestamp=timestamps_RB[2*j])
RB_trad_dict['time'][j] = t_stampt_to_hours(
m.timestamp, start_timestamp=start_timestamp) - starting_time
RB_trad_dict['F'][j] = 100*m.data_file['Analysis'][
'Fitted Params Double_curve_RB']['fidelity_per_Clifford'].attrs['value']
RB_trad_dict['F_std'][j] = 100*m.data_file['Analysis'][
'Fitted Params Double_curve_RB']['fidelity_per_Clifford'].attrs['stderr']
RB_trad_dict['offset'][j] = m.data_file['Analysis'][
'Fitted Params Double_curve_RB']['offset'].attrs['value']
RB_trad_dict['offset_std'][j] = m.data_file['Analysis'][
'Fitted Params Double_curve_RB']['offset'].attrs['stderr']
Dux_trad_dict['in1_out1_attenuation'][j] = \
m.data_file['Instrument settings'][
'Dux'].attrs['in1_out1_attenuation']
Dux_trad_dict['in2_out1_attenuation'][j] = \
m.data_file['Instrument settings'][
'Dux'].attrs['in2_out1_attenuation']
Dux_trad_dict['in1_out1_phase'][j] = \
m.data_file['Instrument settings']['Dux'].attrs['in1_out1_phase']
# print(Dux_trad[j, 0])
# extracting the RB resetless values
m = ma.MeasurementAnalysis(auto=False, timestamp=timestamps_RB[2*j+1])
RB_rstl_dict['time'][j] = t_stampt_to_hours(
m.timestamp, start_timestamp=start_timestamp) - starting_time
RB_rstl_dict['F'][j] = 100*m.data_file['Analysis'][
'Fitted Params Double_curve_RB']['fidelity_per_Clifford'].attrs['value']
RB_rstl_dict['F_std'][j] = 100*m.data_file['Analysis'][
'Fitted Params Double_curve_RB']['fidelity_per_Clifford'].attrs['stderr']
RB_rstl_dict['offset'][j] = m.data_file['Analysis'][
'Fitted Params Double_curve_RB']['offset'].attrs['value']
RB_rstl_dict['offset_std'][j] = m.data_file['Analysis'][
'Fitted Params Double_curve_RB']['offset'].attrs['stderr']
Dux_rstl_dict['in1_out1_attenuation'][j] = \
m.data_file['Instrument settings'][
'Dux'].attrs['in1_out1_attenuation']
Dux_rstl_dict['in2_out1_attenuation'][j] = \
m.data_file['Instrument settings'][
'Dux'].attrs['in2_out1_attenuation']
Dux_rstl_dict['in1_out1_phase'][j] = \
m.data_file['Instrument settings']['Dux'].attrs['in1_out1_phase']
return T1_dict, RB_rstl_dict, RB_trad_dict, Dux_rstl_dict, Dux_trad_dict
def get_experimental_values(
qubit,
fluxlines_dict,
timestamp_start,
timestamp_end=None,
transitions=(
"ge",
"ef",
),
experiments=("Ramsey", ),
**kw,
):
"""
Gets the experimental values from the database in a particular time
period (between timestamp_start and timestamp_end) and returns them in
the usual format (see docstring of plot_experimental_values)
Arguments:
qubit: qubit object or qubit name
fluxlines_dict: dictionary containing the qubits and their
corresponding fluxline ids (necessary to determine voltage)
timestamp_start: start timestamp
timestamp_end: end timestamp. This timestamp should come
chronologically after timestamp_start. Default is None, which
means that the end timestamp is the latest timestamp in the
database.
transitions: transitions that will be included in the
experimental_values
experiments: experiments that will be included in the
experimental_values. Default is ('Ramsey',).
Keyword Arguments:
include_reparkings: Boolean to include reparkings in the
experimental_values. Default is False.
overwrite_warning: Boolean to display the warning message when
overwriting a transition frequency at a particular voltage.
Default is True.
datadir: path to the directory containing the desired data.
Default is D:pydata.
#FIXME code replication could have been avoided by letting
get_experimental_values call get_experimental_values_from_timestamps
with the list of timestamps returned by get_timestamps_in_range
"""
transitions = [
transition_to_str(transition) for transition in transitions
]
experimental_values = {}
# datadirectory
default_datadir = a_tools.datadir
a_tools.datadir = kw.get("datadir", default_datadir)
if not set(transitions).issubset(set(("ge", "ef"))):
log.warning(
"Only ge and ef transitions are supported now. Setting "
"transitions to ('ge', 'ef')")
transitions = ("ge", "ef")
# easily add ReparkingRamseys to the experiments list
if kw.get("include_reparkings", False):
experiments = list(experiments)
experiments.append("ReparkingRamsey")
for transition in transitions:
for experiment in experiments:
label = f"_{experiment}_{transition}_{qubit.name}"
timestamps = a_tools.get_timestamps_in_range(
timestamp_start, timestamp_end=timestamp_end, label=label)
for timestamp in timestamps:
if experiment == "Ramsey":
HamiltonianFittingAnalysis._fill_experimental_values_with_Ramsey(
experimental_values,
timestamp,
qubit,
fluxlines_dict,
)
elif experiment == "ReparkingRamsey":
HamiltonianFittingAnalysis._fill_experimental_values_with_ReparkingRamsey(
experimental_values, timestamp, qubit)
a_tools.datadir = default_datadir
return experimental_values
QtPlot_win.win.nextRow()
QtPlot_win.add(x=a_obj.sweep_points,
y=y,
name=a_obj.ylabels[i],
subplot=i + 1,
symbol='o',
symbolSize=5,
xlabel=a_obj.xlabel,
ylabel=a_obj.ylabels[i])
p0 = QtPlot_win.subplots[0]
for j, p in enumerate(QtPlot_win.subplots):
if j > 0:
p.setXLink(p0)
return QtPlot_win
# Get yourself a range of timestamps to select the relevant data
timestamps = a_tools.get_timestamps_in_range(timestamp_start='20170101_000000',
timestamp_end='20170101_000000',
label='my_label')
try:
vw.clear()
except:
vw = None
for t_stamp in timestamps:
a = ma.MeasurementAnalysis(auto=False, close_file=False, timestamp=t_stamp)
a.get_naming_and_values()
vw = show_analysis_values_pyqt(a, vw)
def get_timestamps(data_dict=None,
t_start=None,
t_stop=None,
label='',
data_file_path=None,
**params):
"""
Get timestamps (YYYYMMDD_hhmmss) of HDF files from a specified location.
Args:
data_dict (dict or OrderedDict): the extracted timestamps will be
stored here
t_start (str): timestamp of the form YYYYMMDD_hhmmss. This timestamp
is returned if t_stop is None, and otherwise it is the first
timestamp of the range [t_start, t_stop]
t_stop (str): timestamp of the form YYYYMMDD_hhmmss. The last timestamp
to be extracted, starting at t_start
label (str): if specified, only those timestamps are returned for which
this label is contained in the filename
data_file_path (str): full path to a datafile for which the timestamp
will be returned
Keyword args (**params)
passed to analysis_tools.py/latest_data and
analysis_tools.py/get_timestamps_in_range
Returns
data dict containing the timestamps
"""
# If I put data_dict = OrderedDict() in the input params, somehow this
# function sees the data_dict I have in my notebook. How???
if data_dict is None:
data_dict = OrderedDict()
timestamps = None
if data_file_path is None:
if t_start is None:
if isinstance(label, list):
timestamps = [
a_tools.latest_data(contains=l,
return_timestamp=True,
**params)[0] for l in label
]
else:
timestamps = [
a_tools.latest_data(contains=label,
return_timestamp=True,
**params)[0]
]
elif t_stop is None:
if isinstance(t_start, list):
timestamps = t_start
else:
timestamps = [t_start]
else:
timestamps = a_tools.get_timestamps_in_range(
t_start,
timestamp_end=t_stop,
label=label if label != '' else None,
**params)
if timestamps is None or len(timestamps) == 0:
raise ValueError('No data file found.')
data_dict['timestamps'] = timestamps
return data_dict
def extract_data(self):
"""
Custom data extraction for this specific experiment.
"""
self.raw_data_dict = OrderedDict()
self.timestamps = a_tools.get_timestamps_in_range(self.t_start,
self.t_stop,
label=self.labels)
a = ma_old.MeasurementAnalysis(timestamp=self.timestamps[0],
auto=False,
close_file=False)
a.get_naming_and_values()
if 'bins' in a.data_file['Experimental Data'][
'Experimental Metadata'].keys():
bins = a.data_file['Experimental Data']['Experimental Metadata'][
'bins'].value
self.raw_data_dict['ncl'] = bins[:-7:2] # 7 calibration points
self.raw_data_dict['bins'] = bins
self.raw_data_dict['value_names'] = a.value_names
self.raw_data_dict['value_units'] = a.value_units
self.raw_data_dict['measurementstring'] = a.measurementstring
self.raw_data_dict['timestamp_string'] = a.timestamp_string
self.raw_data_dict['binned_vals'] = OrderedDict()
self.raw_data_dict['cal_pts_x0'] = OrderedDict()
self.raw_data_dict['cal_pts_x1'] = OrderedDict()
self.raw_data_dict['cal_pts_x2'] = OrderedDict()
self.raw_data_dict['cal_pts_0x'] = OrderedDict()
self.raw_data_dict['cal_pts_1x'] = OrderedDict()
self.raw_data_dict['cal_pts_2x'] = OrderedDict()
self.raw_data_dict['measured_values_I'] = OrderedDict()
self.raw_data_dict['measured_values_X'] = OrderedDict()
for i, val_name in enumerate(a.value_names):
invalid_idxs = np.where((a.measured_values[0] == 0)
& (a.measured_values[1] == 0)
& (a.measured_values[2] == 0)
& (a.measured_values[3] == 0))[0]
a.measured_values[:, invalid_idxs] = \
np.array([[np.nan]*len(invalid_idxs)]*4)
binned_yvals = np.reshape(a.measured_values[i],
(len(bins), -1),
order='F')
self.raw_data_dict['binned_vals'][val_name] = binned_yvals
# 7 cal points: [00, 01, 10, 11, 02, 20, 22]
# col_idx: [-7, -6, -5, -4, -3, -2, -1]
self.raw_data_dict['cal_pts_x0'][val_name] =\
binned_yvals[(-7, -5), :].flatten()
self.raw_data_dict['cal_pts_x1'][val_name] =\
binned_yvals[(-6, -4), :].flatten()
self.raw_data_dict['cal_pts_x2'][val_name] =\
binned_yvals[(-3, -1), :].flatten()
self.raw_data_dict['cal_pts_0x'][val_name] =\
binned_yvals[(-7, -6), :].flatten()
self.raw_data_dict['cal_pts_1x'][val_name] =\
binned_yvals[(-5, -4), :].flatten()
self.raw_data_dict['cal_pts_2x'][val_name] =\
binned_yvals[(-2, -1), :].flatten()
self.raw_data_dict['measured_values_I'][val_name] =\
binned_yvals[:-7:2, :]
self.raw_data_dict['measured_values_X'][val_name] =\
binned_yvals[1:-7:2, :]
else:
bins = None
self.raw_data_dict['folder'] = a.folder
self.raw_data_dict['timestamps'] = self.timestamps
a.finish() # closes data file
def test_get_timestamps_in_nonexistent_folder_does_not_crash():
a_tools.get_timestamps_in_range('20170412_000000',
'20170414_000000',
label='Rabi')
def test_get_timestamps_in_range_no_matches_raises_ValueError():
with pytest.raises(ValueError):
a_tools.get_timestamps_in_range('20170412_000000',
'20170413_000000',
label='fake_label')
def test_get_timestamps_in_range():
timestamps = a_tools.get_timestamps_in_range('20170412_000000',
'20170413_000000',
label='Rabi')
assert timestamps == ['20170412_183928', '20170412_185618']
