def test_qasm_seq_echo(self):
        qasm_file = sq_qasm.echo(self.qubit_name, self.times)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.echo(self.qubit_name, self.times)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.echo(self.qubit_name, self.times,
                                 artificial_detuning=4/self.times[-4])
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.echo(self.qubit_name, self.times,
                                 artificial_detuning=None)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.echo(self.qubit_name, self.times,
                                 cal_points=False)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()
    def test_qasm_function_with_function_arg(self):
        ext_op_dict = deepcopy(self.operation_dict)

        def Rx_codeword(amp, min_amp=-.5, max_amp=0.5):
            """
            maps an amp to a codeword, defining a function like this
            is NOT the responsibility of the qasm compiler
            """
            amp = float(amp)
            codeword = int((amp-min_amp)/(max_amp - min_amp) * 127)
            return 'Trigger {:07b}, 2 , \n'.format(codeword)

        ext_op_dict['Rx'] = {
            self.qubit_name: {'instruction': Rx_codeword,
                              'duration': 2}}
        filename = join(self.base_qasm_path, 'argument.qasm')
        qasm_file = mopen(filename, mode='w')
        qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
        # test wait argument
        qasm_file.writelines('I {} 12\n'.format(
                             self.qubit_name))
        qasm_file.writelines('I {} 4\n'.format(
                             self.qubit_name))
        qasm_file.close()
        qta.qasm_to_asm(qasm_file.name, ext_op_dict)
Example #3
0
    def test_qasm_function_with_function_arg(self):
        ext_op_dict = deepcopy(self.operation_dict)

        def Rx_codeword(amp, min_amp=-.5, max_amp=0.5):
            """
            maps an amp to a codeword, defining a function like this
            is NOT the responsibility of the qasm compiler
            """
            amp = float(amp)
            codeword = int((amp - min_amp) / (max_amp - min_amp) * 127)
            return 'Trigger {:07b}, 2 \n'.format(codeword)

        ext_op_dict['Rx'] = {
            self.qubit_name: {
                'instruction': Rx_codeword,
                'duration': 2
            }
        }
        filename = join(self.base_qasm_path, 'argument.qasm')
        qasm_file = mopen(filename, mode='w')
        qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
        # test wait argument
        qasm_file.writelines('I {} 12\n'.format(self.qubit_name))
        qasm_file.writelines('I {} 4\n'.format(self.qubit_name))
        qasm_file.close()
        qta.qasm_to_asm(qasm_file.name, ext_op_dict)
Example #4
0
    def test_qasm_seq_echo(self):
        qasm_file = sq_qasm.echo(self.qubit_name, self.times)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.echo(self.qubit_name, self.times)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.echo(self.qubit_name,
                                 self.times,
                                 artificial_detuning=4 / self.times[-4])
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.echo(self.qubit_name,
                                 self.times,
                                 artificial_detuning=None)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.echo(self.qubit_name, self.times, cal_points=False)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()
Example #5
0
 def test_qasm_seq_butterfly(self):
     qasm_file = sq_qasm.butterfly(self.qubit_name, initialize=False)
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
     qasm_file = sq_qasm.butterfly(self.qubit_name, initialize=True)
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
Example #6
0
 def test_invalid_command(self):
     filename = join(self.base_qasm_path, 'invalid_command.qasm')
     qasm_file = mopen(filename, mode='w')
     qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
     qasm_file.writelines('Xbla {}     # invalid cmd\n'.format(
         self.qubit_name))
     qasm_file.close()
     with self.assertRaises(ValueError):
         qta.qasm_to_asm(qasm_file.name, self.operation_dict)
 def test_invalid_command(self):
     filename = join(self.base_qasm_path, 'invalid_command.qasm')
     qasm_file = mopen(filename, mode='w')
     qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
     qasm_file.writelines('Xbla {}     # invalid cmd\n'.format(
                          self.qubit_name))
     qasm_file.close()
     with self.assertRaises(ValueError):
         qta.qasm_to_asm(qasm_file.name, self.operation_dict)
 def test_qasm_seq_butterfly(self):
     qasm_file = sq_qasm.butterfly(self.qubit_name, initialize=False)
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
     qasm_file = sq_qasm.butterfly(self.qubit_name, initialize=True)
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
Example #9
0
    def test_qasm_function_with_string_format_arg(self):
        ext_op_dict = deepcopy(self.operation_dict)

        filename = join(self.base_qasm_path, 'argument.qasm')
        qasm_file = mopen(filename, mode='w')
        qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
        # test wait argument
        qasm_file.writelines('I {} 12\n'.format(self.qubit_name))
        qasm_file.writelines('I {} 4\n'.format(self.qubit_name))
        qasm_file.close()
        qta.qasm_to_asm(qasm_file.name, ext_op_dict)
Example #10
0
    def test_too_many_args_command(self):
        filename = join(self.base_qasm_path, 'too_many_args.qasm')
        qasm_file = mopen(filename, mode='w')
        qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
        # leaving out the \n prevents the line from breaking
        qasm_file.writelines('X180 {}'.format(self.qubit_name))
        qasm_file.writelines('X180 {}'.format(self.qubit_name))
        qasm_file.writelines('Y180 {}'.format(self.qubit_name))

        qasm_file.close()
        with self.assertRaises(ValueError):
            qta.qasm_to_asm(qasm_file.name, self.operation_dict)
    def test_qasm_function_with_string_format_arg(self):
        ext_op_dict = deepcopy(self.operation_dict)

        filename = join(self.base_qasm_path, 'argument.qasm')
        qasm_file = mopen(filename, mode='w')
        qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
        # test wait argument
        qasm_file.writelines('I {} 12\n'.format(
                             self.qubit_name))
        qasm_file.writelines('I {} 4\n'.format(
                             self.qubit_name))
        qasm_file.close()
        qta.qasm_to_asm(qasm_file.name, ext_op_dict)
Example #12
0
    def test_qasm_seq_MotzoiXY(self):
        qasm_file = sq_qasm.MotzoiXY(self.qubit_name,
                                     motzois=np.linspace(-.5, .5, 21),
                                     cal_points=False)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.MotzoiXY(self.qubit_name,
                                     motzois=np.linspace(-.5, .5, 21),
                                     cal_points=True)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()
    def test_qasm_seq_MotzoiXY(self):
        qasm_file = sq_qasm.MotzoiXY(
            self.qubit_name, motzois=np.linspace(-.5, .5, 21),
            cal_points=False)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.MotzoiXY(
            self.qubit_name, motzois=np.linspace(-.5, .5, 21),
            cal_points=True)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()
    def test_too_many_args_command(self):
        filename = join(self.base_qasm_path, 'too_many_args.qasm')
        qasm_file = mopen(filename, mode='w')
        qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
        # leaving out the \n prevents the line from breaking
        qasm_file.writelines('X180 {}'.format(
                             self.qubit_name))
        qasm_file.writelines('X180 {}'.format(
                             self.qubit_name))
        qasm_file.writelines('Y180 {}'.format(
                             self.qubit_name))

        qasm_file.close()
        with self.assertRaises(ValueError):
            qta.qasm_to_asm(qasm_file.name, self.operation_dict)
    def test_qasm_seq_randomized_benchmarking(self):
        nr_cliffords = (2**(np.arange(10)+1))
        nr_seeds = 10
        qasm_file = sq_qasm.randomized_benchmarking(self.qubit_name,
                                                    nr_cliffords, nr_seeds,
                                                    double_curves=True)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.randomized_benchmarking(self.qubit_name,
                                                    nr_cliffords, nr_seeds,
                                                    double_curves=False)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()
Example #16
0
 def test_empty_qasm_file(self):
     filename = join(self.base_qasm_path, 'empty.qasm')
     qasm_file = mopen(filename, mode='w')
     qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
     qasm_file.close()
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
 def test_empty_qasm_file(self):
     filename = join(self.base_qasm_path, 'empty.qasm')
     qasm_file = mopen(filename, mode='w')
     qasm_file.writelines('qubit {} \n'.format(self.qubit_name))
     qasm_file.close()
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
Example #18
0
    def test_qasm_seq_randomized_benchmarking(self):
        nr_cliffords = (2**(np.arange(10) + 1))
        nr_seeds = 10
        qasm_file = sq_qasm.randomized_benchmarking(self.qubit_name,
                                                    nr_cliffords,
                                                    nr_seeds,
                                                    double_curves=True)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()

        qasm_file = sq_qasm.randomized_benchmarking(self.qubit_name,
                                                    nr_cliffords,
                                                    nr_seeds,
                                                    double_curves=False)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()
    def test_complete_sequence_loading_simple(self):
        '''
        Tests all the loading with an AllXY sequence that
        contains all the basic steps but does not require mapping
        the allowed operations.
        '''
        qasm_file = self.AllXY_qasm_file
        ops = qta.extract_required_operations(qasm_file.name)

        # # config needs to contain enough info to generate mapping

        operation_dict = qta.create_operation_dict(ops, self.pulse_pars)
        # operation_mapping = qta.create_operation_mapping(required_ops)

        # # uploads all operations in op dict
        with Capturing() as output:
            qta.prepare_operations(operation_dict)

        qta.qasm_to_asm(qasm_file.name, operation_dict)
Example #20
0
    def test_complete_sequence_loading_simple(self):
        '''
        Tests all the loading with an AllXY sequence that
        contains all the basic steps but does not require mapping
        the allowed operations.
        '''
        qasm_file = self.AllXY_qasm_file
        ops = qta.extract_required_operations(qasm_file.name)

        # # config needs to contain enough info to generate mapping

        operation_dict = qta.create_operation_dict(ops, self.pulse_pars)
        # operation_mapping = qta.create_operation_mapping(required_ops)

        # # uploads all operations in op dict
        with Capturing() as output:
            qta.prepare_operations(operation_dict)

        qta.qasm_to_asm(qasm_file.name, operation_dict)
Example #21
0
 def prepare(self, **kw):
     self.CBox.trigger_source('internal')
     if self.upload:
         qumis_file = qta.qasm_to_asm(self.filename, self.op_dict)
         self.CBox.load_instructions(qumis_file.name)
 def test_qasm_two_elt_MotzoiXY(self):
     qasm_file = sq_qasm.two_elt_MotzoiXY(self.qubit_name)
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
    def test_qasm_seq_T1(self):

        qasm_file = sq_qasm.T1(self.qubit_name, self.times)
        asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
        asm = Assembler.Assembler(asm_file.name)
        instructions = asm.convert_to_instructions()
Example #24
0
 def test_two_qubit_AllXY(self):
     qasm_file = mq_qasm.two_qubit_AllXY(self.qubits[0], self.qubits[1])
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     asm.convert_to_instructions()
def mixer_skewness_calibration_CBoxV3(SH, source, LutMan, MC, CBox,
                                      f_mod,
                                      name='mixer_skewness_calibration_CBox'):
    '''
    Inputs:
        SH              (instrument)     the signal hound
        source          (instrument)     MW-source used for driving
        LutMan          (instrument)     LutMan responsible for loading pulses
        CBox            (instrument)     responsible for loading qumis and
        f_mod           (float Hz)       Modulation frequency

    returns:
        alpha, phi     the coefficients that go in the predistortion matrix

    Loads a continuous wave in the lookuptable and changes the predistortion
    to minimize the power in the spurious sideband.

    For details, see Leo's notes on mixer skewness calibration in the docs
    '''

    # phi and alpha are the coefficients that go in the predistortion matrix

    # Load the pulses required for a conintuous tone
    LutMan.lut_mapping()[0] = 'ModBlock'
    Mod_Block_len = 500e-9
    LutMan.Q_modulation(f_mod)
    LutMan.Q_block_length(Mod_Block_len)
    LutMan.Q_ampCW(.5)  # not 1 as we want some margin for the alpha correction
    LutMan.load_pulses_onto_AWG_lookuptable()

    # load the QASM/QuMis sequence
    Mod_Block_len_clk = ins_lib.convert_to_clocks(Mod_Block_len) - 1
    # -1 is a hack to fix some problems with the CBox AWG output
    # 19-07-2017 XFU & MAR
    operation_dict = {}
    operation_dict['Pulse'] = {
        'duration': Mod_Block_len_clk,
        'instruction': ins_lib.cbox_awg_pulse(
            codeword=0, awg_channels=[LutMan.awg_nr()],
            duration=Mod_Block_len_clk)}

    # this generates a SSB coninuous wave sequence
    cw_tone_elt = sqqs.CW_tone()
    cw_tone_asm = qta.qasm_to_asm(cw_tone_elt.name, operation_dict)
    CBox.load_instructions(cw_tone_asm.name)
    CBox.start()

    frequency = source.frequency() - f_mod
    alpha_swf = cbs.Lutman_par_with_reload_single_pulse(
        LutMan=LutMan,
        parameter=LutMan.mixer_alpha,
        pulse_names=['ModBlock'])

    phi_swf = cbs.Lutman_par_with_reload_single_pulse(
        LutMan=LutMan,
        parameter=LutMan.mixer_phi,
        pulse_names=['ModBlock'])
    d = det.Signal_Hound_fixed_frequency(SH, frequency)

    ad_func_pars = {'adaptive_function': nelder_mead,
                    'x0': [1.0, 0.0],
                    'initial_step': [.4, 20],
                    'no_improv_break': 10,
                    'minimize': True,
                    'maxiter': 500}
    MC.set_sweep_functions([alpha_swf, phi_swf])
    MC.set_detector_function(d)
    MC.set_adaptive_function_parameters(ad_func_pars)
    MC.set_adaptive_function_parameters(ad_func_pars)
    MC.run(name=name, mode='adaptive')
    a = ma.OptimizationAnalysis(label=name)
    ma.OptimizationAnalysis_v2(label=name)

    alpha = a.optimization_result[0][0]
    phi = a.optimization_result[0][1]

    return phi, alpha
 def test_qasm_seq_Rabi(self):
     amps = np.linspace(-.4, .5, 51)  # in V
     qasm_file = sq_qasm.Rabi(self.qubit_name, amps)
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
def prepare_motzoi_seq_CC(qubit_name, op_dict):
    motzoi_elt = sqs.two_elt_MotzoiXY(qubit_name)
    single_pulse_asm = qta.qasm_to_asm(motzoi_elt.name, op_dict)
    asm_file = single_pulse_asm
    CBox.load_instructions(asm_file.name)
def RB_prepare(nr_cliffords, op_dict, CBox, nr_seeds=1):
    RB_qasm = sq_qasm.randomized_benchmarking('AncT_CB', nr_cliffords=nr_cliffords, nr_seeds=nr_seeds,
                                              double_curves=False)
    asm_file = qta.qasm_to_asm(RB_qasm.name, op_dict)
    CBox.load_instructions(asm_file.name)
    return RB_qasm, asm_file
Example #29
0
 def test_qasm_seq_AllXY(self):
     qasm_file = sq_qasm.AllXY(self.qubit_name)
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
Example #30
0
 def test_qasm_seq_Rabi(self):
     amps = np.linspace(-.4, .5, 51)  # in V
     qasm_file = sq_qasm.Rabi(self.qubit_name, amps)
     asm_file = qta.qasm_to_asm(qasm_file.name, self.operation_dict)
     asm = Assembler.Assembler(asm_file.name)
     instructions = asm.convert_to_instructions()
def prepare_rabi_seq_CC(qubit_name, op_dict):
    single_pulse_elt = sqs.single_elt_on('AncT_CB')
    single_pulse_asm = qta.qasm_to_asm(single_pulse_elt.name, op_dict)
    asm_file = single_pulse_asm
    CBox.load_instructions(asm_file.name)
 def prepare(self, **kw):
     self.CBox.trigger_source('internal')
     if self.upload:
         asm_file = qta.qasm_to_asm(self.filename, self.op_dict)
         self.CBox.load_instructions(asm_file.name)