714 detached pagani sync

deprecated/pycqed/instrument_drivers/meta_instrument/heterodyne.py

@@ -157,10 +157,10 @@ def prepare_UHFQC(self):
         # Upload the correct integration weigths
         if self.single_sideband_demod():
             self._acquisition_instr.prepare_SSB_weight_and_rotation(
-                IF=self.f_RO_mod(), weight_function_I=0, weight_function_Q=1)
+                IF=self.f_RO_mod(), weight_chI=0, weight_chQ=1)
         else:
             self._acquisition_instr.prepare_DSB_weight_and_rotation(
-                IF=self.f_RO_mod(), weight_function_I=0, weight_function_Q=1)
+                IF=self.f_RO_mod(), weight_chI=0, weight_chQ=1)
 
         if self._UHFQC_awg_parameters_changed and self.auto_seq_loading():
             # self._acquisition_instr.awg_sequence_acquisition() # Dirty hack to get UHFLI to cooperate
@@ -553,10 +553,10 @@ def prepare_UHFQC(self):
         # prepare weights and rotation
         if self.single_sideband_demod():
             self._acquisition_instr.prepare_SSB_weight_and_rotation(
-                IF=self.f_RO_mod(), weight_function_I=0, weight_function_Q=1)
+                IF=self.f_RO_mod(), weight_chI=0, weight_chQ=1)
         else:
             self._acquisition_instr.prepare_DSB_weight_and_rotation(
-                IF=self.f_RO_mod(), weight_function_I=0, weight_function_Q=1)
+                IF=self.f_RO_mod(), weight_chI=0, weight_chQ=1)
 
         # this sets the result to integration and rotation outcome
         self._acquisition_instr.qas_0_result_source(2)

deprecated/pycqed/instrument_drivers/meta_instrument/qubit_objects/CC_transmon.py

@@ -421,13 +421,13 @@ def prepare_readout(self):
             if self.RO_acq_weights() == 'SSB':
                 UHFQC.prepare_SSB_weight_and_rotation(
                     IF=self.f_RO_mod(),
-                    weight_function_I=self.RO_acq_weight_function_I(),
-                    weight_function_Q=self.RO_acq_weight_function_Q())
+                    weight_chI=self.RO_acq_weight_function_I(),
+                    weight_chQ=self.RO_acq_weight_function_Q())
             elif self.RO_acq_weights() == 'DSB':
                 UHFQC.prepare_DSB_weight_and_rotation(
                     IF=self.f_RO_mod(),
-                    weight_function_I=self.RO_acq_weight_function_I(),
-                    weight_function_Q=self.RO_acq_weight_function_Q())
+                    weight_chI=self.RO_acq_weight_function_I(),
+                    weight_chQ=self.RO_acq_weight_function_Q())
             elif self.RO_acq_weights() == 'optimal':
                 if (self.RO_optimal_weights_I() is None or
                         self.RO_optimal_weights_Q() is None):

deprecated/pycqed/instrument_drivers/meta_instrument/qubit_objects/Tektronix_driven_transmon.py

@@ -850,8 +850,8 @@ def measure_ssro(self, no_fits=False,
             MC=MC,
             AWG=self.AWG.get_instr(), acquisition_instr=self._acquisition_instr,
             pulse_pars=self.pulse_pars, RO_pars=self.RO_pars, IF=self.f_RO_mod(),
-            weight_function_I=self.RO_acq_weight_function_I(),
-            weight_function_Q=self.RO_acq_weight_function_Q(),
+            weight_chI=self.RO_acq_weight_function_I(),
+            weight_chQ=self.RO_acq_weight_function_Q(),
             nr_shots=nr_shots, one_weight_function_UHFQC=one_weight_function_UHFQC,
             optimized_weights=optimized_weights,
             integration_length=self.RO_acq_integration_length(),

pycqed/__init__.py

@@ -2,6 +2,7 @@
 
 from pycqed.version import __version__
 import sys
+import warnings
 
 if 1:   # FIXME: hack should be removed
     module_name = "qcodes"
@@ -13,7 +14,12 @@
             "NB: Any `qcodes` submodule must also be imported after pycqed.")
     # We need to import this here so that any later imports of `QtPlot` from qcodes
     # KEEP ABOVE any QtPlot import!!!
-    from pycqed.measurement import qcodes_QtPlot_monkey_patching
+    warnings.warn(message="Attempts to apply qcodes QtPlot monkey patch.")
+    try:
+        # from qcodes import plots
+        from pycqed.measurement import qcodes_QtPlot_monkey_patching
+    except ImportError as e:
+        warnings.warn(message="Failed to apply qcodes QtPlot monkey patch.")
 
 # from pycqed import measurement
 # from pycqed import analysis

pycqed/analysis/analysis_toolbox.py

@@ -9,7 +9,7 @@
 import colorsys as colors
 # FIXME: was commented out, breaks code below
 import qutip as qtp
-import qutip.metrics as qpmetrics
+import qutip.core.metrics as qpmetrics
 
 from copy import deepcopy
 from collections import OrderedDict as od

pycqed/analysis/measurement_analysis.py

@@ -2531,8 +2531,8 @@ def run_default_analysis(self, print_fit_results=False,
 
         verbose = kw.get('verbose', False)
         # Get old values for qubit frequency
-        instr_set = self.data_file['Instrument settings']
         try:
+            instr_set = self.data_file['Instrument settings']
             if self.for_ef:
                 self.qubit_freq_spec = \
                     float(instr_set[self.qb_name].attrs['f_ef_qubit'])
@@ -4697,24 +4697,11 @@ def run_default_analysis(self, show=False, close_file=False, **kw):
 
             units = SI_prefix_and_scale_factor(val=max(abs(self.ax.get_xticks())),
                                                unit=self.sweep_unit[0])[1]
-            # Get old values
-            instr_set = self.data_file['Instrument settings']
-            try:
-                if self.for_ef:
-                    T1_old = float(
-                        instr_set[self.qb_name].attrs['T1_ef']) * 1e6
-                else:
-                    T1_old = float(instr_set[self.qb_name].attrs['T1']) * 1e6
-                old_vals = '\nold $T_1$ = {:.5f} '.format(T1_old) + units
-            except (TypeError, KeyError, ValueError):
-                logging.warning('qb_name is None. Old parameter values will '
-                                'not be retrieved.')
-                old_vals = ''
 
             textstr = ('$T_1$ = {:.5f} '.format(T1_micro_sec) +
                        units +
                        ' $\pm$ {:.5f} '.format(T1_err_micro_sec) +
-                       units + old_vals)
+                       units)
 
             self.fig.text(0.5, -0.2, textstr, transform=self.ax.transAxes,
                           fontsize=self.font_size,
@@ -4778,7 +4765,8 @@ class Ramsey_Analysis(TD_Analysis):
     Most kw parameters for Rabi_Analysis are also used here.
     """
 
-    def __init__(self, label='Ramsey', phase_sweep_only=False, **kw):
+    def __init__(self, label='Ramsey', phase_sweep_only=False,
+                 **kw):
         kw['label'] = label
         kw['h5mode'] = 'r+'
         self.phase_sweep_only = phase_sweep_only
@@ -4970,15 +4958,17 @@ def run_default_analysis(self, print_fit_results=False,
             close_main_figure=True, save_fig=False, **kw)
 
         verbose = kw.get('verbose', False)
-        # Get old values for qubit frequency
-        instr_set = self.data_file['Instrument settings']
         try:
             if self.for_ef:
+                # Get old values for qubit frequency
+                instr_set = self.data_file['Instrument settings']
                 self.qubit_freq_spec = \
                     float(instr_set[self.qb_name].attrs['f_ef_qubit'])
             elif 'freq_qubit' in kw.keys():
                 self.qubit_freq_spec = kw['freq_qubit']
             else:
+                # Get old values for qubit frequency
+                instr_set = self.data_file['Instrument settings']
                 try:
                     self.qubit_freq_spec = \
                         float(instr_set[self.qb_name].attrs['f_qubit'])
@@ -6335,16 +6325,8 @@ def run_default_analysis(self, print_fit_results=False,
 
         scale = SI_prefix_and_scale_factor(val=max(abs(ax.get_xticks())),
                                            unit=self.sweep_unit[0])[0]
-
-        instr_set = self.data_file['Instrument settings']
-        try:
-            old_RO_freq = float(instr_set[self.qb_name].attrs['f_RO'])
-            old_vals = '\n$f_{\mathrm{old}}$ = %.5f GHz' % (
-                old_RO_freq * scale)
-        except (TypeError, KeyError, ValueError):
-            logging.warning('qb_name is None. Old parameter values will '
-                            'not be retrieved.')
-            old_vals = ''
+
+        old_vals = ''
 
         if ('hanger' in fitting_model) or ('complex' in fitting_model):
             if kw['custom_power_message'] is None:

pycqed/analysis/tomography.py

@@ -4,6 +4,7 @@
 # except ImportError as e:
 #     logging.warning('Could not import qutip, tomo code will not work')
 import qutip as qtp
+from qutip.qip import operations
 import numpy as np
 import time
 import scipy
@@ -38,10 +39,10 @@ class TomoAnalysis_JointRO():
     # The set of single qubit rotation matrixes used in the tomography
     # measurement (will be assumed to be used on all qubits)
     rotation_matrixes = [qtp.identity(2), qtp.sigmax(),
-                         qtp.rotation(qtp.sigmax(), np.pi / 2),
-                         qtp.rotation(qtp.sigmay(), np.pi / 2),
-                         qtp.rotation(qtp.sigmax(), -np.pi / 2),
-                         qtp.rotation(qtp.sigmay(), -np.pi / 2)]
+                         operations.gates.rotation(qtp.sigmax(), np.pi / 2),
+                         operations.gates.rotation(qtp.sigmay(), np.pi / 2),
+                         operations.gates.rotation(qtp.sigmax(), -np.pi / 2),
+                         operations.gates.rotation(qtp.sigmay(), -np.pi / 2)]
     measurement_operator_labels = ['I', 'X', 'x', 'y', '-x', '-y']
     # MAKE SURE THE LABELS CORRESPOND TO THE ROTATION MATRIXES DEFINED ABOVE
 
@@ -1164,10 +1165,10 @@ def run_default_analysis(self, **kw):
         TomoAnalysis_JointRO.rotation_matrixes = [
             qtp.identity(2),
             qtp.sigmax(),
-            qtp.rotation(qtp.sigmay(), np.pi / 2),
-            qtp.rotation(qtp.sigmay(), -np.pi / 2),
-            qtp.rotation(qtp.sigmax(), np.pi / 2),
-            qtp.rotation(qtp.sigmax(), -np.pi / 2)]
+            operations.gates.rotation(qtp.sigmay(), np.pi / 2),
+            operations.gates.rotation(qtp.sigmay(), -np.pi / 2),
+            operations.gates.rotation(qtp.sigmax(), np.pi / 2),
+            operations.gates.rotation(qtp.sigmax(), -np.pi / 2)]
         TomoAnalysis_JointRO.measurement_operator_labels = ['I', 'X', 'y',
                                                             '-y', 'x', '-x']
         TomoAnalysis_JointRO.measurement_basis = [qtp.identity(2),