Merge pull request QudevETH#5 from QudevETH/devel/Cphi_gate

Devel/cphi gate

Author: Vintrix

pycqed/analysis/analysis_toolbox.py

@@ -328,7 +328,7 @@ def get_param_value_from_file(file_path, instr_name, param_name, h5mode='r+'):
     return param_val
 
 
-def get_qb_channel_map_from_file(qb_names, file_path, value_names, h5mode='r+'):
+def get_qb_channel_map_from_hdf(qb_names, file_path, value_names, h5mode='r+'):
 
     data_file = h5py.File(measurement_filename(file_path), h5mode)
     instr_settings = data_file['Instrument settings']
@@ -341,22 +341,19 @@ def get_qb_channel_map_from_file(qb_names, file_path, value_names, h5mode='r+'):
     elif 'lin_trans' in value_names[0]:
         ro_type = 'lin_trans w'
     else:
-        input_ro_type = value_names[0]
         ro_type = 'w'
-        logging.warning('Readout type "{}" does not have standard '
-                        'format.'.format(input_ro_type))
 
     for qbn in qb_names:
-        try:
-            qbchs = [str(instr_settings[qbn].attrs['acq_I_channel'])]
-            ro_acq_weight_type = instr_settings[qbn].attrs['acq_weights_type']
-            if ro_acq_weight_type in ['SSB', 'DSB', 'optimal_qutrit']:
-                qbchs += [str(instr_settings[qbn].attrs['acq_Q_channel'])]
-            channel_map[qbn] = [ch for ch in value_names for nr in qbchs
-                                if ro_type+nr in ch]
-        except KeyError:
-            log.warning('Could not get channels')
-            pass
+        qbchs = [str(instr_settings[qbn].attrs['acq_I_channel'])]
+        ro_acq_weight_type = instr_settings[qbn].attrs['acq_weights_type']
+        if ro_acq_weight_type in ['SSB', 'DSB', 'optimal_qutrit']:
+            qbchs += [str(instr_settings[qbn].attrs['acq_Q_channel'])]
+        channel_map[qbn] = [ch for ch in value_names for nr in qbchs
+                            if ro_type+nr in ch]
+
+    all_values_empty = np.all([len(v) == 0 for v in channel_map.values()])
+    if len(channel_map) == 0 or all_values_empty:
+        raise ValueError('Did not find any channels. qb_channel_map is empty.')
     return channel_map
 
 
@@ -1550,8 +1547,8 @@ def normalize_2D_data_on_elements(data_2D, elements):
     return data_2D
 
 
-def rotate_and_normalize_data(data, cal_zero_points=None, cal_one_points=None,
-                              zero_coord=None, one_coord=None, **kw):
+def rotate_and_normalize_data_IQ(data, cal_zero_points=None, cal_one_points=None,
+                                 zero_coord=None, one_coord=None, **kw):
     '''
     Rotates and normalizes data with respect to some reference coordinates.
     There are two ways to specify the reference coordinates.
@@ -1603,10 +1600,10 @@ def rotate_and_normalize_data(data, cal_zero_points=None, cal_one_points=None,
         line_slope = fit_res.params['slope'].value
         line_intercept = fit_res.params['intercept'].value
         #finx the x, y coordinates of the projected points
-        x_proj=(x+line_slope*y-line_slope*line_intercept)/(line_slope**2+1)
-        y_proj= line_slope*(x_proj)+line_intercept
+        x_proj = (x+line_slope*y-line_slope*line_intercept)/(line_slope**2+1)
+        y_proj = line_slope*(x_proj)+line_intercept
 
-        #find the minimum (on th ey axis) point on the line
+        #find the minimum (on the y axis) point on the line
         y_min_line = min(fit_res.best_fit)
         x_min_line = x[np.argmin(fit_res.best_fit)]
 
@@ -1701,8 +1698,8 @@ def rotate_and_normalize_data_no_cal_points(data, **kw):
     return normalized_data
 
 
-def normalize_data_v3(data, cal_zero_points=np.arange(-4, -2, 1),
-                      cal_one_points=np.arange(-2, 0, 1), **kw):
+def rotate_and_normalize_data_1ch(data, cal_zero_points=np.arange(-4, -2, 1),
+                                  cal_one_points=np.arange(-2, 0, 1), **kw):
     '''
     Normalizes data according to calibration points
     Inputs:
@@ -1723,6 +1720,7 @@ def normalize_data_v3(data, cal_zero_points=np.arange(-4, -2, 1),
 
     return normalized_data
 
+
 def predict_gm_proba_from_cal_points(X, cal_points):
     """
     For each point of the data array X, predicts the probability of being

pycqed/analysis/measurement_analysis.py

@@ -1670,7 +1670,7 @@ def norm_data_to_cal_points(self):
         else:
             cal_zero_points = self.cal_points[0]
             cal_one_points = self.cal_points[1]
-        self.corr_data = a_tools.normalize_data_v3(
+        self.corr_data = a_tools.rotate_and_normalize_data_1ch(
             self.measured_values[0],
             cal_zero_points=cal_zero_points,
             cal_one_points=cal_one_points)
@@ -1817,9 +1817,9 @@ def normalize_data_to_calibration_points(self, values, calsteps,
             if len(self.measured_values) == 1 or len(self.RO_channels) == 1:
                 # Only one quadrature was measured
                 if cal_zero_points is None and cal_one_points is None:
-                    # a_tools.normalize_data_v3 does not work with 0 cal_points. Use
+                    # a_tools.rotate_and_normalize_data_1ch does not work with 0 cal_points. Use
                     # 4 cal_points.
-                    logging.warning('a_tools.normalize_data_v3 does not have support'
+                    logging.warning('a_tools.rotate_and_normalize_data_1ch does not have support'
                                     ' for 0 cal_points. Setting NoCalPoints to 4.')
                     self.NoCalPoints = 4
                     calsteps = 4
@@ -1830,8 +1830,8 @@ def normalize_data_to_calibration_points(self, values, calsteps,
                         list(range(int(NoPts - int(self.NoCalPoints) / 2), NoPts))
                 ch_to_measure = \
                     0 if len(self.measured_values) == 1 else self.RO_channels[0]
-                print('ch to measure ', ch_to_measure)
-                self.corr_data = a_tools.normalize_data_v3(
+                log.debug('ch to measure ', ch_to_measure)
+                self.corr_data = a_tools.rotate_and_normalize_data_1ch(
                     self.measured_values[ch_to_measure],
                     cal_zero_points, cal_one_points)
             else:
@@ -1935,7 +1935,7 @@ def __init__(self, NoCalPoints=4, center_point=31, make_fig=True,
     def run_default_analysis(self,
                              close_main_fig=True, **kw):
         super(chevron_optimization_v2, self).run_default_analysis(**kw)
-        measured_values = a_tools.normalize_data_v3(self.measured_values[0])
+        measured_values = a_tools.rotate_and_normalize_data_1ch(self.measured_values[0])
         self.cost_value_1, self.period = self.sum_cost(self.sweep_points * 1e9,
                                                        measured_values)
         self.cost_value_2 = self.swap_cost(self.sweep_points * 1e9,
@@ -1963,7 +1963,7 @@ def run_default_analysis(self,
         self.save_fig(fig, fig_tight=False, **kw)
 
     def analysis_on_fig(self, ax):
-        measured_values = a_tools.normalize_data_v3(self.measured_values[0])
+        measured_values = a_tools.rotate_and_normalize_data_1ch(self.measured_values[0])
         self.cost_value_1, self.period = self.sum_cost(self.sweep_points * 1e9,
                                                        measured_values)
         self.cost_value_2 = self.swap_cost(self.sweep_points * 1e9,
@@ -2629,7 +2629,7 @@ def __init__(self, NoCalPoints=4, center_point=31, make_fig=True,
     def run_default_analysis(self,
                              close_main_fig=True, **kw):
         super(TD_UHFQC, self).run_default_analysis(**kw)
-        measured_values = a_tools.normalize_data_v3(self.measured_values[0])
+        measured_values = a_tools.rotate_and_normalize_data_1ch(self.measured_values[0])
 
         fig, ax = plt.subplots(1, figsize=(8, 6))
 
@@ -8734,7 +8734,7 @@ def run_default_analysis(self, **kw):
         self.add_analysis_datagroup_to_file()
         self.get_naming_and_values()
         x = self.sweep_points
-        y = a_tools.normalize_data_v3(self.measured_values[0])
+        y = a_tools.rotate_and_normalize_data_1ch(self.measured_values[0])
 
         fit_res = self.fit(x[:-4], y[:-4])
         self.fit_res = fit_res
@@ -11253,7 +11253,7 @@ def oneD_sweep_analysis(self, **kw):
                     data_filter(self.data[1])[cal_points_idxs[0] +
                                               cal_points_idxs[1]]
                 ))
-                self.ampls = a_tools.normalize_data_v3(
+                self.ampls = a_tools.rotate_and_normalize_data_1ch(
                     measured_values, cal_zero_points=cal_points_idxs[0],
                     cal_one_points=cal_points_idxs[1])[0:-self.NoCalPoints]
 

pycqed/analysis/randomized_benchmarking_analysis.py

@@ -137,7 +137,7 @@ def extract_data(self, **kw):
 
             data = np.zeros((self.n_cl.size))
             if find_empirical_variance:
-                self.epsilon = np.zeros((self.n_cl.size))
+                self.epsilon = np.zeros(self.n_cl.size)
             for i in range(self.n_cl.size):
                 y = [data_raw[j][i] for j in range(self.nr_seeds)]
                 data[i] = np.mean(y)
@@ -169,11 +169,11 @@ def extract_data(self, **kw):
             # for TwoD==False
             self.data_calibrated = deepcopy(self.data_rearranged[0])
             if find_empirical_variance:
-                self.epsilon = np.zeros((self.n_cl.size))
+                self.epsilon = np.zeros(self.n_cl.size)
             for i in range(self.n_cl.size):
                 a[0] = data_rearranged[0][i]
                 a[1] = data_rearranged[1][i]
-                data_calibrated = a_tools.rotate_and_normalize_data(
+                data_calibrated = a_tools.rotate_and_normalize_data_IQ(
                     a, self.cal_points[0], self.cal_points[1])[0]
                 self.data_calibrated[i] = data_calibrated
                 data_calibrated = data_calibrated[:-int(self.NoCalPoints)]

pycqed/analysis_v2/base_analysis.py

@@ -27,7 +27,7 @@
 from pycqed.measurement.hdf5_data import read_dict_from_hdf5
 import copy
 import logging
-log = logging.getLogger()
+log = logging.getLogger(__name__)
 log.addHandler(logging.StreamHandler())
 
 
@@ -290,22 +290,29 @@ def get_data_from_timestamp_list(self):
         return raw_data_dict
 
     @staticmethod
-    def add_measured_values_ord_dict(raw_data_dict):
+    def add_measured_data(raw_data_dict):
         if 'measured_data' in raw_data_dict and \
                 'value_names' in raw_data_dict:
             measured_data = raw_data_dict.pop('measured_data')
             raw_data_dict['measured_data'] = OrderedDict()
-            sweep_points = measured_data[:-len(raw_data_dict['value_names'])]
+
+            value_names = raw_data_dict['value_names']
+            if not isinstance(value_names, list):
+                value_names = [value_names]
+
+            sweep_points = measured_data[:-len(value_names)]
+
+
             if sweep_points.shape[0] > 1:
                 raw_data_dict['hard_sweep_points'] = np.unique(sweep_points[0])
                 raw_data_dict['soft_sweep_points'] = np.unique(sweep_points[1:])
             else:
                 raw_data_dict['hard_sweep_points'] = np.unique(sweep_points[0])
 
-            data = measured_data[-len(raw_data_dict['value_names']):]
-            if data.shape[0] != len(raw_data_dict['value_names']):
+            data = measured_data[-len(value_names):]
+            if data.shape[0] != len(value_names):
                 raise ValueError('Shape mismatch between data and ro channels.')
-            for i, ro_ch in enumerate(raw_data_dict['value_names']):
+            for i, ro_ch in enumerate(value_names):
                 if 'soft_sweep_points' in raw_data_dict:
                     hsl = len(raw_data_dict['hard_sweep_points'])
                     ssl = len(raw_data_dict['soft_sweep_points'])
@@ -339,13 +346,13 @@ def extract_data(self):
 
         self.raw_data_dict = self.get_data_from_timestamp_list()
         if len(self.timestamps) == 1:
-            self.raw_data_dict = self.add_measured_values_ord_dict(
+            self.raw_data_dict = self.add_measured_data(
                 self.raw_data_dict)
         else:
             temp_dict_list = []
             for i, rd_dict in enumerate(self.raw_data_dict):
                 temp_dict_list.append(
-                    self.add_measured_values_ord_dict(rd_dict))
+                    self.add_measured_data(rd_dict))
             self.raw_data_dict = tuple(temp_dict_list)
 
     def process_data(self):
@@ -484,7 +491,8 @@ def run_fitting(self):
         Only model fitting is implemented here. Minimizing fitting should
         be implemented here.
         '''
-        self.fit_res = {}
+        if self.fit_res is None:
+            self.fit_res = {}
         for key, fit_dict in self.fit_dicts.items():
             guess_dict = fit_dict.get('guess_dict', None)
             guess_pars = fit_dict.get('guess_pars', None)
@@ -1008,6 +1016,8 @@ def plot_line(self, pdict, axs):
         plot_title = pdict.get('title', None)
         plot_xrange = pdict.get('xrange', None)
         plot_yrange = pdict.get('yrange', None)
+        plot_yscale = pdict.get('yscale', None)
+        plot_xscale = pdict.get('xscale', None)
 
         if pdict.get('color', False):
             plot_linekws['color'] = pdict.get('color')
@@ -1095,6 +1105,10 @@ def plot_line(self, pdict, axs):
         if plot_yrange is not None:
             ymin, ymax = plot_yrange
             axs.set_ylim(ymin, ymax)
+        if plot_yscale is not None:
+            axs.set_yscale(plot_yscale)
+        if plot_xscale is not None:
+            axs.set_xscale(plot_xscale)
 
         if self.tight_fig:
             axs.figure.tight_layout()

pycqed/analysis_v2/distortions_analysis.py

@@ -65,9 +65,9 @@ def process_data(self):
         self.proc_data_dict['xunit'] = self.raw_data_dict['value_units'][0][x_ch_idx]
 
         self.proc_data_dict['xvals'] = list(self.raw_data_dict
-            ['measured_values_ord_dict'].values())[x_ch_idx][0]
+            ['measured_data'].values())[x_ch_idx][0]
         self.proc_data_dict['yvals'] = list(self.raw_data_dict
-            ['measured_values_ord_dict'].values())[y_ch_idx][0]
+            ['measured_data'].values())[y_ch_idx][0]
 
 
         # Detect the rising edge and shift the time axis

pycqed/analysis_v2/optimization_analysis.py

@@ -33,7 +33,7 @@ def prepare_plots(self):
 
 
         for i, val_name in enumerate(self.raw_data_dict['value_names'][0]):
-            yvals = self.raw_data_dict['measured_values_ord_dict'][val_name][0]
+            yvals = self.raw_data_dict['measured_data'][val_name][0]
 
             self.plot_dicts['{}_vs_iteration'.format(val_name)] = {
                 'plotfn': self.plot_line,