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 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']