Addresses pull request requested changes.

Stefania Lazar · Stefania Lazar · commit cedc07a91c2f · 2019-10-03T11:33:24.000+02:00
- removes the resonator amplitude sweep and ro dynamic phase measurements + sequence functions.
- properly implements the result_logging_mode in UHFQC_correlation_detector.
- reverts push-away flux pulse to be nz for the NZBufferedCZPulse.
diff --git a/pycqed/instrument_drivers/meta_instrument/qubit_objects/QuDev_transmon.py b/pycqed/instrument_drivers/meta_instrument/qubit_objects/QuDev_transmon.py
@@ -652,64 +652,6 @@ def measure_resonator_spectroscopy(self, freqs, sweep_points_2D=None,
             ma.MeasurementAnalysis(close_fig=close_fig, qb_name=self.name, 
                                    TwoD=(mode == '2D'))
 
-    def measure_resonator_amplitude_sweep(self, freqs, amps,
-                                          trigger_separation=3e-6,
-                                          upload=True, analyze=True,
-                                          close_fig=True, label=None):
-        """ Varies the frequency of the microwave source to the resonator and
-        measures the transmittance """
-        if np.any(freqs < 500e6):
-            log.warning(('Some of the values in the freqs array might be '
-                         'too small. The units should be Hz.'))
-
-        if label is None:
-            label = 'resonator_amplitude_scan' + self.msmt_suffix
-
-        self.prepare(drive=None)
-        MC = self.instr_mc.get_instr()
-
-        hard_sweep_params = {'mod_frequency': {
-            'values': freqs - self.instr_ro_lo.get_instr().frequency(),
-            'unit': 'Hz'}}
-        soft_sweep_params = {'amplitude': {'values': amps, 'unit': 'V'}}
-
-        sequences, hard_sweep_points, soft_sweep_points = \
-            sq.res_amp_sweep_seqs(
-                qb_name=self.name,
-                hard_sweep_dict=hard_sweep_params,
-                soft_sweep_dict=soft_sweep_params,
-                uhf_name=self.instr_uhf.get_instr().name,
-                operation_dict=self.get_operation_dict(), upload=False)
-
-        hard_sweep_func = awg_swf.SegmentHardSweep(
-            sequence=sequences[0], upload=upload,
-            parameter_name=list(hard_sweep_params)[0],
-            unit=list(hard_sweep_params.values())[0]['unit'])
-        MC.set_sweep_function(hard_sweep_func)
-        MC.set_sweep_points(hard_sweep_points)
-
-        channels_to_upload = [self.ro_I_channel(), self.ro_Q_channel()]
-        MC.set_sweep_function_2D(awg_swf.SegmentSoftSweep(
-            hard_sweep_func, sequences,
-            list(soft_sweep_params)[0],
-            list(soft_sweep_params.values())[0]['unit'],
-            channels_to_upload=channels_to_upload))
-        MC.set_sweep_points_2D(soft_sweep_points)
-        MC.set_detector_function(self.int_avg_det)
-
-        exp_metadata = {'hard_sweep_params': hard_sweep_params,
-                        'soft_sweep_params': soft_sweep_params}
-
-        with temporary_value(self.instr_trigger.get_instr().pulse_period,
-                             trigger_separation):
-            self.instr_pulsar.get_instr().start(exclude=[self.instr_uhf()])
-            MC.run(name=label, mode='2D', exp_metadata=exp_metadata)
-            self.instr_pulsar.get_instr().stop()
-
-        if analyze:
-            ma.MeasurementAnalysis(close_fig=close_fig, qb_name=self.name,
-                                   TwoD=True)
-
     def measure_qubit_spectroscopy(self, freqs, sweep_points_2D=None,
             sweep_function_2D=None, pulsed=True, trigger_separation=13e-6, 
             upload=True, analyze=True, close_fig=True, label=None):
@@ -943,7 +885,6 @@ def measure_qscale(self, qscales=None, analyze=True, upload=True, label=None,
         if exp_metadata is None:
             exp_metadata = {}
         exp_metadata.update({'sweep_points_dict': {self.name: qscales},
-                             'preparation_params': prep_params,
              'sweep_name': 'Qscale factor',
              'sweep_unit': '',
              'preparation_params': prep_params,
diff --git a/pycqed/measurement/detector_functions.py b/pycqed/measurement/detector_functions.py
@@ -841,19 +841,22 @@ def __init__(self, UHFQC, AWG=None, integration_length=1e-6,
                  channels: list = [0, 1], correlations: list=[(0, 1)],
                  result_logging_mode: str='raw',
                  used_channels=None, value_names=None,
-                 seg_per_point=1, single_int_avg=False, thresholding=False,
+                 seg_per_point=1, single_int_avg=False,
                  **kw):
         super().__init__(
             UHFQC, AWG=AWG, integration_length=integration_length,
             nr_averages=nr_averages, real_imag=real_imag,
             channels=channels,
             seg_per_point=seg_per_point, single_int_avg=single_int_avg,
-            result_logging_mode=result_logging_mode,  # FIXME -> do the proper thing (MAR)
+            result_logging_mode=result_logging_mode,
             **kw)
 
         self.result_logging_mode = result_logging_mode
         self.correlations = correlations
         self.thresholding = self.result_logging_mode == 'digitized'
+        res_logging_indices = {'lin_trans': 0, 'digitized': 1, 'raw': 2}
+        self.result_logging_mode_idx = res_logging_indices[
+            self.result_logging_mode]
 
         self.used_channels = used_channels
         if self.used_channels is None:
@@ -868,12 +871,19 @@ def __init__(self, UHFQC, AWG=None, integration_length=1e-6,
             self.value_names = value_names
 
         # Note that V^2 is in brackets to prevent confusion with unit prefixes
-        if not thresholding:
+        if self.result_logging_mode == 'raw':
             self.value_units = ['V']*len(self.value_names) + \
                                ['(V^2)']*len(self.correlations)
-        else:
-            self.value_units = ['fraction']*len(self.value_names) + \
+            self.scaling_factor = 1/(1.8e9*integration_length)
+        elif self.result_logging_mode == 'lin_trans':
+            self.value_units = ['a.u']*len(self.value_names) + \
+                               ['a.u.']*len(self.correlations)
+            self.scaling_factor = 1
+        elif self.result_logging_mode == 'digitized':
+            self.value_units = ['frac']*len(self.value_names) + \
                                ['normalized']*len(self.correlations)
+            self.scaling_factor = 1
+
         for corr in correlations:
             self.value_names += ['corr ({},{})'.format(corr[0], corr[1])]
 
@@ -1003,16 +1013,13 @@ def process_data(self, data_raw):
             data = data_raw
         else:
             data = []
-            self.scaling_factor = 1 / (1.8e9 * self.integration_length)
-            # FIXME: this should be tested
             for n, ch in enumerate(self.used_channels):
                 if ch in self.correlation_channels:
                     data.append(3 * np.array(data_raw[n]) *
                                 (self.scaling_factor**2 / self.nr_averages))
                 else:
                     data.append(np.array(data_raw[n]) *
                                 (self.scaling_factor / self.nr_averages))
-
         return data
 
 
diff --git a/pycqed/measurement/multi_qubit_module.py b/pycqed/measurement/multi_qubit_module.py
@@ -3001,81 +3001,3 @@ def measure_pygsti(qubits, f_LO, pygsti_gateset=None,
                 title=label, verbosity=2)
 
     return MC
-
-
-def measure_ro_dynamic_phases(pulsed_qubit, measured_qubits,
-                              hard_sweep_params=None, exp_metadata=None,
-                              pulse_separation=None, init_state='g',
-                              upload=True, n_cal_points_per_state=1,
-                              cal_states='auto', classified=False,
-                              prep_params=None):
-    if not hasattr(measured_qubits, '__iter__'):
-        measured_qubits = [measured_qubits]
-    qubits = measured_qubits + [pulsed_qubit]
-
-    if pulse_separation is None:
-        pulse_separation = max([qb.acq_length() for qb in qubits])
-
-    for qb in qubits:
-        MC = qb.instr_mc.get_instr()
-        qb.prepare(drive='timedomain')
-
-    if hard_sweep_params is None:
-        hard_sweep_params = {
-            'phase': {'values': np.tile(np.linspace(0, 2*np.pi, 6)*180/np.pi, 2),
-                      'unit': 'deg'}
-        }
-
-    cal_states = CalibrationPoints.guess_cal_states(cal_states,
-                                                    for_ef=False)
-    cp = CalibrationPoints.multi_qubit([qb.name for qb in qubits], cal_states,
-                                       n_per_state=n_cal_points_per_state)
-
-    if prep_params is None:
-        prep_params = measured_qubits[0].preparation_params()
-    operation_dict = get_operation_dict(qubits)
-    sequences, hard_sweep_points = \
-        mqs.ro_dynamic_phase_seq(
-            hard_sweep_dict=hard_sweep_params,
-            qbp_name=pulsed_qubit.name, qbr_names=[qb.name for qb in
-                                                   measured_qubits],
-            operation_dict=operation_dict,
-            pulse_separation=pulse_separation,
-            init_state = init_state, prep_params=prep_params,
-            cal_points=cp, upload=False)
-
-    hard_sweep_func = awg_swf.SegmentHardSweep(
-        sequence=sequences, upload=upload,
-        parameter_name=list(hard_sweep_params)[0],
-        unit=list(hard_sweep_params.values())[0]['unit'])
-    MC.set_sweep_function(hard_sweep_func)
-    MC.set_sweep_points(hard_sweep_points)
-
-    det_name = 'int_avg{}_det'.format('_classif' if classified else '')
-    det_func = get_multiplexed_readout_detector_functions(
-        measured_qubits, nr_averages=max(qb.acq_averages() for qb in measured_qubits)
-    )[det_name]
-    MC.set_detector_function(det_func)
-
-    if exp_metadata is None:
-        exp_metadata = {}
-
-    hard_sweep_params = {
-        'phase': {'values': np.repeat(np.tile(np.linspace(0, 2 * np.pi, 6) * 180 /
-                                         np.pi,
-                                     2),2),
-                  'unit': 'deg'}
-    }
-    exp_metadata.update({'qbnames': [qb.name for qb in qubits],
-                         'preparation_params': prep_params,
-                         'cal_points': repr(cp),
-                         'rotate': len(cal_states) != 0,
-                         'cal_states_rotations':
-                             {qb.name: {'g': 0, 'e': 1} for qb in qubits} if
-                             len(cal_states) != 0 else None,
-                         'data_to_fit': {qb.name: 'pe' for qb in qubits},
-                         'hard_sweep_params': hard_sweep_params})
-    MC.run('RO_DynamicPhase_{}{}'.format(
-        pulsed_qubit.name, ''.join([qb.name for qb in qubits])),
-        exp_metadata=exp_metadata)
-    tda.MultiQubit_TimeDomain_Analysis(qb_names=[qb.name for qb in measured_qubits])
diff --git a/pycqed/measurement/pulse_sequences/multi_qubit_tek_seq_elts.py b/pycqed/measurement/pulse_sequences/multi_qubit_tek_seq_elts.py
@@ -1802,122 +1802,6 @@ def pygsti_seq(qb_names, pygsti_listOfExperiments, operation_dict,
         return seq_name
 
 
-def ro_dynamic_phase_seq(hard_sweep_dict, qbp_name, qbr_names,
-                         operation_dict,
-                         pulse_separation, init_state,
-                         cal_points=True, prep_params=dict(),
-                         upload=True):
-
-    """
-    RO cross-dephasing measurement sequence. Measures the dynamic phase induced
-    on qbr by a measurement tone on the pulsed qubit (qbp).
-    Args:
-        qbp_name: pulsed qubit name; RO pulse is applied on this qubit
-        qbr_names: ramsey (measured) qubits
-        phases: array of phases for the second piHalf pulse on qbr
-        operation_dict: contains operation dicts from both qubits;
-            !!! Must contain 'RO mux' which is the mux RO pulse only for
-            the measured_qubits (qbr_names) !!!
-        pulse_separation: separation between the two pi-half pulses, shouls be
-            equal to integration length
-        cal_points: use cal points
-    """
-
-    seq_name = 'ro_dynamic_phase_sequence'
-    dummy_ro_1 = {'pulse_type': 'GaussFilteredCosIQPulse',
-                  'I_channel': 'UHF1_ch1',
-                  'Q_channel': 'UHF1_ch2',
-                  'amplitude': 0.00001,
-                  'pulse_length': 50e-09,
-                  'pulse_delay': 0,
-                  'mod_frequency': 900.0e6,
-                  'phase': 0,
-                  'phi_skew': 0,
-                  'alpha': 1,
-                  'gaussian_filter_sigma': 1e-09,
-                  'nr_sigma': 2,
-                  'phase_lock': True,
-                  'basis_rotation': {},
-                  'operation_type': 'RO'}
-    dummy_ro_2 = {'pulse_type': 'GaussFilteredCosIQPulse',
-                  'I_channel': 'UHF2_ch1',
-                  'Q_channel': 'UHF2_ch2',
-                  'amplitude': 0.00001,
-                  'pulse_length': 50e-09,
-                  'pulse_delay': 0,
-                  'mod_frequency': 900.0e6,
-                  'phase': 0,
-                  'phi_skew': 0,
-                  'alpha': 1,
-                  'gaussian_filter_sigma': 1e-09,
-                  'nr_sigma': 2,
-                  'phase_lock': True,
-                  'basis_rotation': {},
-                  'operation_type': 'RO'}
-
-
-
-
-
-    # put together n-qubit calibration point pulse lists
-    # put together n-qubit ramsey pulse lists
-    pulse_list = []
-    for j, qbr_name in enumerate(qbr_names):
-        pulse_list.append(deepcopy(operation_dict['X90 ' + qbr_name]))
-        pulse_list[-1]['name'] = f'x1_{qbr_name}'
-        pulse_list[-1]['ref_pulse'] = 'segment_start'
-        pulse_list[-1]['refpoint'] = 'start'
-
-    ro_probe = deepcopy(operation_dict['RO ' + qbp_name])
-    pulse_list.append(ro_probe)
-    pulse_list[-1]['name'] = f'ro_probe'
-    pulse_list[-1]['element_name'] = f'ro_probe'
-    pulse_list.append(dummy_ro_1)
-    pulse_list[-1]['refpoint'] = 'start'
-    pulse_list[-1]['element_name'] = f'ro_probe'
-    pulse_list.append(dummy_ro_2)
-    pulse_list[-1]['refpoint'] = 'start'
-    pulse_list[-1]['element_name'] = f'ro_probe'
-
-    for j, qbr_name in enumerate(qbr_names):
-        pulse_list.append(deepcopy(operation_dict['X90 ' + qbr_name]))
-        pulse_list[-1]['name'] = f'x2_{qbr_name}'
-        pulse_list[-1]['ref_pulse'] = 'segment_start'
-        pulse_list[-1]['refpoint'] = 'start'
-        pulse_list[-1]['pulse_delay'] = pulse_separation
-
-    ro_list = generate_mux_ro_pulse_list(qbr_names+[qbp_name], operation_dict)
-    pulse_list += ro_list
-
-    if init_state == 'e':
-        pulse_list.append(deepcopy(operation_dict['X180 ' + qbp_name]))
-        pulse_list[-1]['ref_pulse'] = 'segment_start'
-        pulse_list[-1]['refpoint'] = 'start'
-        pulse_list[-1]['pulse_delay'] = -100e-9
-
-    params = {f'x2_{qbr_name}.{k}': v['values']
-                   for k, v in hard_sweep_dict.items() for qbr_name in qbr_names}
-    hsl = len(list(hard_sweep_dict.values())[0]['values'])
-    params.update({f'ro_probe.amplitude': np.concatenate(
-        [ro_probe['amplitude'] * np.ones(hsl // 2), np.zeros(hsl // 2)])})
-
-    swept_pulses = sweep_pulse_params(pulse_list, params)
-
-    swept_pulses_with_prep = \
-        [add_preparation_pulses(p, operation_dict, [qbp_name], **prep_params)
-         for p in swept_pulses]
-    seq = pulse_list_list_seq(swept_pulses_with_prep, seq_name, upload=False)
-
-    if cal_points is not None:
-        # add calibration segments
-        seq.extend(cal_points.create_segments(operation_dict, **prep_params))
-
-    log.debug(seq)
-    if upload:
-        ps.Pulsar.get_instance().program_awgs(seq)
-    return seq, np.arange(seq.n_acq_elements())
-
-
 def generate_mux_ro_pulse_list(qubit_names, operation_dict, element_name='RO',
                                ref_point='end', pulse_delay=0.0):
     ro_pulses = []
diff --git a/pycqed/measurement/pulse_sequences/single_qubit_tek_seq_elts.py b/pycqed/measurement/pulse_sequences/single_qubit_tek_seq_elts.py
@@ -834,35 +834,6 @@ def over_under_rotation_seq(qb_name, nr_pi_pulses_array, operation_dict,
     return
 
 
-def res_amp_sweep_seqs(qb_name, hard_sweep_dict, soft_sweep_dict,
-                       uhf_name, operation_dict, upload=True):
-    seq_name = 'Res_amp_sweep_sequence'
-
-    ro_pulse = deepcopy(operation_dict['RO ' + qb_name])
-    ro_pulse['name'] = 'RO_pulse'
-
-    ssl = len(list(soft_sweep_dict.values())[0]['values'])
-    sequences = []
-    for i in range(ssl):
-        ro_p = deepcopy(ro_pulse)
-        ro_p.update({k: v['values'][i] for k, v in soft_sweep_dict.items()})
-        pulses = [ro_p]
-        swept_pulses = sweep_pulse_params(
-            pulses, {f'RO_pulse.{k}': v['values']
-                        for k, v in hard_sweep_dict.items()})
-        seq = pulse_list_list_seq(swept_pulses,
-                                  seq_name+f'_{i}', upload=False)
-        sequences.append(seq)
-
-    repeat_dict = {uhf_name: (sequences[0].n_acq_elements(), 1)}
-
-    if upload:
-        ps.Pulsar.get_instance().program_awgs(sequences[0],
-                                              repeat_dict=repeat_dict)
-
-    return sequences, np.arange(sequences[0].n_acq_elements()), np.arange(ssl)
-
-
 # Helper functions
 
 def pulse_list_list_seq(pulse_list_list, name='pulse_list_list_sequence',
diff --git a/pycqed/measurement/waveform_control/pulse_library.py b/pycqed/measurement/waveform_control/pulse_library.py
