Ejemplo n.º 1
0
    def test_generating_standard_pulses(self):
        """Test if standard waveforms are correctly generated."""

        self.AWG8_MW_LutMan.LutMap(mwl.default_mw_lutmap)
        print(self.AWG8_MW_LutMan.LutMap())
        self.AWG8_MW_LutMan.generate_standard_waveforms()

        # remove this line later
        self.AWG8_MW_LutMan.set_default_lutmap()

        expected_wf = wf.mod_gauss(
            amp=self.AWG8_MW_LutMan.mw_amp180(),
            sigma_length=self.AWG8_MW_LutMan.mw_gauss_width(),
            f_modulation=self.AWG8_MW_LutMan.mw_modulation(),
            sampling_rate=self.AWG8_MW_LutMan.sampling_rate(),
            phase=0,
            motzoi=self.AWG8_MW_LutMan.mw_motzoi())[0]
        # expected on cw 1 based on LutMap
        generated_wf = self.AWG8_MW_LutMan._wave_dict[1]
        np.testing.assert_array_almost_equal(expected_wf, generated_wf[0])

        generated_wf = self.AWG8_MW_LutMan._wave_dict[8]
        expected_wf_spec = wf.block_pulse(
            length=self.AWG8_MW_LutMan.spec_length(),
            amp=self.AWG8_MW_LutMan.spec_amp(),
            sampling_rate=self.AWG8_MW_LutMan.sampling_rate(),
            delay=0,
            phase=0)[0]
        np.testing.assert_array_almost_equal(expected_wf_spec, generated_wf[0])
Ejemplo n.º 2
0
    def test_uploading_standard_pulses(self):
        # Tests that all waveforms are present and no error is raised.
        self.AWG8_MW_LutMan.load_waveforms_onto_AWG_lookuptable()
        expected_wf = wf.mod_gauss(
            amp=self.AWG8_MW_LutMan.mw_amp180(),
            sigma_length=self.AWG8_MW_LutMan.mw_gauss_width(),
            f_modulation=self.AWG8_MW_LutMan.mw_modulation(),
            sampling_rate=self.AWG8_MW_LutMan.sampling_rate(),
            phase=0,
            motzoi=self.AWG8_MW_LutMan.mw_motzoi())[0]

        # Make sure the expected waveform has a length that is a multiple of
        # 8 samples.
        expected_wf = adjust_array_len(expected_wf, 8)
        uploaded_wf = self.AWG.get('wave_ch1_cw001')
        np.testing.assert_array_almost_equal(expected_wf, uploaded_wf)

        expected_wf_spec = wf.block_pulse(
            length=self.AWG8_MW_LutMan.spec_length(),
            amp=self.AWG8_MW_LutMan.spec_amp(),
            sampling_rate=self.AWG8_MW_LutMan.sampling_rate(),
            delay=0,
            phase=0)[0]

        expected_wf_spec = adjust_array_len(expected_wf_spec, 8)
        uploaded_wf = self.AWG.get('wave_ch1_cw008')
        np.testing.assert_array_almost_equal(expected_wf_spec, uploaded_wf)
Ejemplo n.º 3
0
    def test_mod_gauss(self):
        amplitude = .4  # something not equal to one to prevent some bugs
        motzoi = .73
        sigma = 20e-9
        I, Q = wf.mod_gauss(amplitude, sigma, axis='x', nr_sigma=4,
                            sampling_rate=1e9, f_modulation=0,
                            motzoi=motzoi, delay=0)

        np.testing.assert_almost_equal(I, g_env)
        np.testing.assert_almost_equal(Q, d_env)
    def prepare(self):
        self.CBox.set_acquisition_mode(0)
        self.CBox.set_awg_mode(0,0)
        self.AWG.stop()
        self.AWG.set_setup_filename(self.filename,
                                    force_load=False)

        Wave_I_180, Wave_Q_180 = wf.mod_gauss(self.amp180, self.gauss_width,
                                              self.f_modulation)
        Wave_I_90, Wave_Q_90 = wf.mod_gauss(self.amp90, self.gauss_width,
                                            self.f_modulation)
        self.CBox.set_awg_lookuptable(0, 7, 1, np.round(Wave_I_180))
        self.CBox.set_awg_lookuptable(0, 7, 0, np.round(Wave_Q_180))
        self.CBox.set_awg_lookuptable(0, 0, 1, np.round(Wave_I_90))
        self.CBox.set_awg_lookuptable(0, 0, 0, np.round(Wave_Q_90))

        # These two lines should be combined to CBox.set_No_Samples but is untested
        NoAvg = self.CBox.get_avg_size()
        self.CBox.set_averaging_parameters(self.NoSegments, NoAvg)
Ejemplo n.º 5
0
    def prepare(self):
        self.CBox.set_acquisition_mode(0)
        self.CBox.set_awg_mode(0, 0)
        self.AWG.stop()
        self.AWG.set_setup_filename(self.filename, force_load=False)

        Wave_I_180, Wave_Q_180 = wf.mod_gauss(self.amp180, self.gauss_width,
                                              self.f_modulation)
        Wave_I_90, Wave_Q_90 = wf.mod_gauss(self.amp90, self.gauss_width,
                                            self.f_modulation)
        self.CBox.set_awg_lookuptable(0, 7, 1, np.round(Wave_I_180))
        self.CBox.set_awg_lookuptable(0, 7, 0, np.round(Wave_Q_180))
        self.CBox.set_awg_lookuptable(0, 0, 1, np.round(Wave_I_90))
        self.CBox.set_awg_lookuptable(0, 0, 0, np.round(Wave_Q_90))

        # These two lines should be combined to CBox.set_No_Samples but is
        # untested
        NoAvg = self.CBox.get_avg_size()
        self.CBox.set_averaging_parameters(self.NoSegments, NoAvg)
Ejemplo n.º 6
0
    def prepare(self):
        self.CBox.set_acquisition_mode(0)
        print("CBox set to mode 0")
        self.CBox.set_awg_mode(0, 0)
        self.CBox.set_awg_mode(1, 0)
        self.AWG.stop()
        print("AWG is stopped")
        self.AWG.set_setup_filename(self.filename,
                                    force_load=False)

        Wave_I_180, Wave_Q_180 = wf.mod_gauss(self.amp180, self.gauss_width,
                                              self.f_modulation)
        Wave_I_0 = Wave_I_180*0
        Wave_Q_0 = Wave_I_0

        self.CBox.set_awg_lookuptable(0, 0, 1, np.round(Wave_I_180))
        self.CBox.set_awg_lookuptable(0, 0, 0, np.round(Wave_Q_180))
        print("1")
        self.CBox.set_awg_lookuptable(0, 7, 1, np.round(Wave_I_0))
        self.CBox.set_awg_lookuptable(0, 7, 0, np.round(Wave_Q_0))
        # copying the tables to AWG2 for scope
        self.CBox.set_awg_lookuptable(1, 0, 1, np.round(Wave_I_180))
        self.CBox.set_awg_lookuptable(1, 0, 0, np.round(Wave_Q_180))
        print("2")
        self.CBox.set_awg_lookuptable(1, 7, 1, np.round(Wave_I_0))
        self.CBox.set_awg_lookuptable(1, 7, 0, np.round(Wave_Q_0))
        sequence_points = self.NoSegments-self.cal_points
        tape_length = (sequence_points)*self.NoSegments
        tape = 7*np.ones(tape_length)
        print("tape_length", tape_length)
        for i in range(sequence_points):
            tape[(i+1)*(sequence_points)-i-1] = 0
            print(tape[i*(sequence_points):i *
                       (sequence_points)+sequence_points])
        print("done first part")
        # adding calibration points
        for i in range(self.cal_points):
            first_cal_segment = (sequence_points)**2
            segment = first_cal_segment+(i+1)*(sequence_points)-1
            # print segment
            if i > (self.cal_points/2-1):
                tape[segment] = 0
            # print segment-(sequence_points)+1
            print(tape[segment-sequence_points+1:segment+1])
            print(i)
        print("3")
        self.CBox.set_awg_tape(0, len(tape), tape)
        print("tape length", len(tape))
        # copying the tables to AWG2 for scope
        self.CBox.set_awg_tape(1, len(tape), tape)
        # These two lines should be combined to CBox.set_No_Samples but is
        # untested
        NoAvg = self.CBox.get_avg_size()
        self.CBox.set_averaging_parameters(self.NoSegments, NoAvg)
        print("tape is loaded")
    def prepare(self):
        self.CBox.set_acquisition_mode(0)
        print("CBox set to mode 0")
        self.CBox.set_awg_mode(0, 0)
        self.CBox.set_awg_mode(1, 0)
        self.AWG.stop()
        print("AWG is stopped")
        self.AWG.set_setup_filename(self.filename,
                                    force_load=False)

        Wave_I_180, Wave_Q_180 = wf.mod_gauss(self.amp180, self.gauss_width,
                                      self.f_modulation)
        Wave_I_0=Wave_I_180*0
        Wave_Q_0=Wave_I_0

        self.CBox.set_awg_lookuptable(0, 0, 1, np.round(Wave_I_180))
        self.CBox.set_awg_lookuptable(0, 0, 0, np.round(Wave_Q_180))
        print("1")
        self.CBox.set_awg_lookuptable(0, 7, 1, np.round(Wave_I_0))
        self.CBox.set_awg_lookuptable(0, 7, 0, np.round(Wave_Q_0))
        #copying the tables to AWG2 for scope
        self.CBox.set_awg_lookuptable(1, 0, 1, np.round(Wave_I_180))
        self.CBox.set_awg_lookuptable(1, 0, 0, np.round(Wave_Q_180))
        print("2")
        self.CBox.set_awg_lookuptable(1, 7, 1, np.round(Wave_I_0))
        self.CBox.set_awg_lookuptable(1, 7, 0, np.round(Wave_Q_0))
        sequence_points=self.NoSegments-self.cal_points
        tape_length=(sequence_points)*self.NoSegments
        tape=7*np.ones(tape_length)
        print("tape_length", tape_length)
        for i in range(sequence_points):
            tape[(i+1)*(sequence_points)-i-1]=0
            print(tape[i*(sequence_points):i*(sequence_points)+sequence_points])
        print("done first part")
        # adding calibration points
        for i in range(self.cal_points):
            first_cal_segment = (sequence_points)**2
            segment = first_cal_segment+(i+1)*(sequence_points)-1
            # print segment
            if i > (self.cal_points/2-1):
                tape[segment] = 0
            # print segment-(sequence_points)+1
            print(tape[segment-sequence_points+1:segment+1])
            print(i)
        print("3")
        self.CBox.set_awg_tape(0, len(tape), tape)
        print("tape length", len(tape))
        # copying the tables to AWG2 for scope
        self.CBox.set_awg_tape(1, len(tape), tape)
        # These two lines should be combined to CBox.set_No_Samples but is untested
        NoAvg = self.CBox.get_avg_size()
        self.CBox.set_averaging_parameters(self.NoSegments, NoAvg)
        print("tape is loaded")
Ejemplo n.º 8
0
    def test_load_ef_rabi_pulses_to_AWG_lookuptable_correct_waveform(self):
        self.AWG8_VSM_MW_LutMan.load_ef_rabi_pulses_to_AWG_lookuptable()

        expected_wf = wf.mod_gauss(
            amp=self.AWG8_MW_LutMan.mw_ef_amp180(),
            sigma_length=self.AWG8_MW_LutMan.mw_gauss_width(),
            f_modulation=self.AWG8_MW_LutMan.mw_ef_modulation(),
            sampling_rate=self.AWG8_MW_LutMan.sampling_rate(),
            phase=0,
            motzoi=self.AWG8_MW_LutMan.mw_motzoi())[0]

        uploaded_wf = self.AWG.get('wave_ch1_cw009')
        np.testing.assert_array_almost_equal(expected_wf, uploaded_wf)
Ejemplo n.º 9
0
    def prepare(self):
        self.CBox.set_awg_mode(0, 1)
        self.CBox.set_awg_mode(1, 1)
        self.AWG.stop()
        self.AWG.set_setup_filename(self.filename, force_load=False)

        Wave_I, Wave_Q = wf.mod_gauss(self.amp180, self.gauss_width,
                                      self.f_modulation)
        self.CBox.set_awg_lookuptable(0, 0, 1, np.round(Wave_I))
        self.CBox.set_awg_lookuptable(0, 0, 0, np.round(Wave_Q))
        # additionally loading to AWG1 for scope
        self.CBox.set_awg_lookuptable(1, 0, 1, np.round(Wave_I))
        self.CBox.set_awg_lookuptable(1, 0, 0, np.round(Wave_Q))

        # These two lines should be combined to CBox.set_No_Samples but is
        # untested
        NoAvg = self.CBox.get_avg_size()
        self.CBox.set_averaging_parameters(self.NoSegments, NoAvg)
    def prepare(self):
        self.CBox.set_awg_mode(0, 1)
        self.CBox.set_awg_mode(1, 1)
        self.AWG.stop()
        self.AWG.set_setup_filename(self.filename,
                                    force_load=False)

        Wave_I, Wave_Q = wf.mod_gauss(self.amp180, self.gauss_width,
                                      self.f_modulation)
        self.CBox.set_awg_lookuptable(0, 0, 1, np.round(Wave_I))
        self.CBox.set_awg_lookuptable(0, 0, 0, np.round(Wave_Q))
        #additionally loading to AWG1 for scope
        self.CBox.set_awg_lookuptable(1, 0, 1, np.round(Wave_I))
        self.CBox.set_awg_lookuptable(1, 0, 0, np.round(Wave_Q))


        # These two lines should be combined to CBox.set_No_Samples but is untested
        NoAvg = self.CBox.get_avg_size()
        self.CBox.set_averaging_parameters(self.NoSegments, NoAvg)
    def generate_standard_pulses(self):
        '''
        Generates a basic set of pulses (I, X-180, Y-180, x-90, y-90, Block,
                                         X180_delayed)
        using the parameters set on this meta-instrument and returns the
        corresponding waveforms for both I and Q channels as a dict.

        Note the primitive set is a different set than the one used in
        Serwan's thesis.
        '''
        # Standard qubit pulses
        Wave_I = [np.zeros(10), np.zeros(10)]
        Wave_X_180 = wf.mod_gauss(self.get('Q_amp180'), self.get('Q_gauss_width'),
                                  self.get('Q_modulation'), axis='x',
                                  motzoi=self.get('Q_motzoi_parameter'),
                                  sampling_rate=self.get('sampling_rate'),
                                  Q_phase_delay=self.get('mixer_IQ_phase_skewness'))
        Wave_X_90 = wf.mod_gauss(self.get('Q_amp90'), self.get('Q_gauss_width'),
                                 self.get('Q_modulation'), axis='x',
                                 motzoi=self.get('Q_motzoi_parameter'),
                                 sampling_rate=self.get('sampling_rate'),
                                 Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Wave_Y_180 = wf.mod_gauss(self.get('Q_amp180'), self.get('Q_gauss_width'),
                                  self.get('Q_modulation'), axis='y',
                                  motzoi=self.get('Q_motzoi_parameter'),
                                  sampling_rate=self.get('sampling_rate'),
                                  Q_phase_delay=self.get('mixer_IQ_phase_skewness'))
        Wave_Y_90 = wf.mod_gauss(self.get('Q_amp90'), self.get('Q_gauss_width'),
                                 self.get('Q_modulation'), axis='y',
                                 motzoi=self.get('Q_motzoi_parameter'),
                                 sampling_rate=self.get('sampling_rate'),
                                 Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Wave_mX90 = wf.mod_gauss(-self.get('Q_amp90'), self.get('Q_gauss_width'),
                                 self.get('Q_modulation'), axis='x',
                                 motzoi=self.get('Q_motzoi_parameter'),
                                 sampling_rate=self.get('sampling_rate'),
                                 Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Wave_mY90 = wf.mod_gauss(-self.get('Q_amp90'), self.get('Q_gauss_width'),
                                 self.get('Q_modulation'), axis='y',
                                 motzoi=self.get('Q_motzoi_parameter'),
                                 sampling_rate=self.get('sampling_rate'),
                                 Q_phase_delay=self.get('mixer_IQ_phase_skewness'))
        Block = wf.block_pulse(self.get('Q_ampCW'), self.Q_block_length.get(),  # ns
                               sampling_rate=self.get('sampling_rate'),
                               delay=0,
                               phase=0)
        ModBlock = wf.mod_pulse(Block[0], Block[1],
                                f_modulation=self.Q_modulation.get(),
                                sampling_rate=self.sampling_rate.get(),
                                Q_phase_delay=self.mixer_IQ_phase_skewness.get())

        # RO pulses
        M = wf.block_pulse(self.get('M_amp'), self.M_length.get(),  # ns
                           sampling_rate=self.get('sampling_rate'),
                           delay=0,
                           phase=self.get('M_phi'))
        Mod_M = wf.mod_pulse(M[0], M[1],
                             f_modulation=self.M_modulation.get(),
                             sampling_rate=self.sampling_rate.get(),
                             Q_phase_delay=self.mixer_IQ_phase_skewness.get())
        # advanced RO pulses
        # with ramp-up
        M_up = wf.block_pulse(self.get('M_up_amp'), self.M_up_length.get(),  # ns
                              sampling_rate=self.get('sampling_rate'),
                              delay=0,
                              phase=self.get('M_up_phi'))

        M_up_mid = (np.concatenate((M_up[0], M[0])),
                    np.concatenate((M_up[1], M[1])))

        Mod_M_up_mid = wf.mod_pulse(M_up_mid[0], M_up_mid[1],
                                    f_modulation=self.get('M_modulation'),
                                    sampling_rate=self.get('sampling_rate'),
                                    Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        # with ramp-up and double frequency depletion
        M_down0 = wf.block_pulse(self.get('M_down_amp0'), self.get('M_down_length'),  # ns
                                 sampling_rate=self.get('sampling_rate'),
                                 delay=0,
                                 phase=self.get('M_down_phi0'))

        M_down1 = wf.block_pulse(self.get('M_down_amp1'), self.get('M_down_length'),  # ns
                                 sampling_rate=self.get('sampling_rate'),
                                 delay=0,
                                 phase=self.get('M_down_phi1'))
        Mod_M_down0 = wf.mod_pulse(M_down0[0],
                                   M_down1[1],
                                   f_modulation=self.get('M0_modulation'),
                                   sampling_rate=self.get('sampling_rate'),
                                   Q_phase_delay=self.get('mixer_IQ_phase_skewness'))
        Mod_M_down1 = wf.mod_pulse(M_down1[0],
                                   M_down1[1],
                                   f_modulation=self.get('M1_modulation'),
                                   sampling_rate=self.get('sampling_rate'),
                                   Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        # summing the depletion components
        Mod_M_down = (np.add(Mod_M_down0[0],
                             Mod_M_down1[0]),
                      np.add(Mod_M_down0[1],
                             Mod_M_down1[1]))

        # concatenating up, mid and depletion
        Mod_M_up_mid_down = (np.concatenate((Mod_M_up_mid[0], Mod_M_down[0])),
                             np.concatenate((Mod_M_up_mid[1], Mod_M_down[1])))

        self._wave_dict = {'I': Wave_I,
                           'X180': Wave_X_180, 'Y180': Wave_Y_180,
                           'X90': Wave_X_90, 'Y90': Wave_Y_90,
                           'mX90': Wave_mX90, 'mY90': Wave_mY90,
                           'Block': Block,
                           'ModBlock': ModBlock,
                           'M_square': Mod_M,
                           'M_up_mid': Mod_M_up_mid,
                           'M_up_mid_double_dep': Mod_M_up_mid_down
                           }

        if self.mixer_apply_predistortion_matrix():
            M = self.get_mixer_predistortion_matrix()
            for key, val in self._wave_dict.items():
                self._wave_dict[key] = np.dot(M, val)

        return self._wave_dict
Ejemplo n.º 12
0
    def generate_standard_pulses(self):
        '''
        Generates a basic set of pulses (I, X-180, Y-180, x-90, y-90, Block,
                                         X180_delayed)
        using the parameters set on this meta-instrument and returns the
        corresponding waveforms for both I and Q channels as a dict.

        Note the primitive set is a different set than the one used in
        Serwan's thesis.
        '''
        # Standard qubit pulses
        Wave_I = [np.zeros(10), np.zeros(10)]
        Wave_X_180 = wf.mod_gauss(self.get('Q_amp180'), self.get('Q_gauss_width'),
                                  self.get('Q_modulation'), axis='x',
                                  motzoi=self.get('Q_motzoi_parameter'),
                                  sampling_rate=self.get('sampling_rate'),
                                  Q_phase_delay=self.get('mixer_IQ_phase_skewness'))
        Wave_X_90 = wf.mod_gauss(self.get('Q_amp90'), self.get('Q_gauss_width'),
                                 self.get('Q_modulation'), axis='x',
                                 motzoi=self.get('Q_motzoi_parameter'),
                                 sampling_rate=self.get('sampling_rate'),
                                 Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Wave_Y_180 = wf.mod_gauss(self.get('Q_amp180'), self.get('Q_gauss_width'),
                                  self.get('Q_modulation'), axis='y',
                                  motzoi=self.get('Q_motzoi_parameter'),
                                  sampling_rate=self.get('sampling_rate'),
                                  Q_phase_delay=self.get('mixer_IQ_phase_skewness'))
        Wave_Y_90 = wf.mod_gauss(self.get('Q_amp90'), self.get('Q_gauss_width'),
                                 self.get('Q_modulation'), axis='y',
                                 motzoi=self.get('Q_motzoi_parameter'),
                                 sampling_rate=self.get('sampling_rate'),
                                 Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Wave_mX90 = wf.mod_gauss(-self.get('Q_amp90'), self.get('Q_gauss_width'),
                                 self.get('Q_modulation'), axis='x',
                                 motzoi=self.get('Q_motzoi_parameter'),
                                 sampling_rate=self.get('sampling_rate'),
                                 Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Wave_mY90 = wf.mod_gauss(-self.get('Q_amp90'), self.get('Q_gauss_width'),
                                 self.get('Q_modulation'), axis='y',
                                 motzoi=self.get('Q_motzoi_parameter'),
                                 sampling_rate=self.get('sampling_rate'),
                                 Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Wave_Rphi180 = wf.mod_gauss(self.get('Q_amp180'), self.Q_gauss_width(),
                                    self.get('Q_modulation'), phase=self.Q_Rphi(),
                                    motzoi=self.get('Q_motzoi_parameter'),
                                    sampling_rate=self.get('sampling_rate'),
                                    Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Wave_Rphi90 = wf.mod_gauss(self.get('Q_amp90'), self.Q_gauss_width(),
                                   self.get('Q_modulation'), phase=self.Q_Rphi(),
                                   motzoi=self.get('Q_motzoi_parameter'),
                                   sampling_rate=self.get('sampling_rate'),
                                   Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        Block = wf.block_pulse(self.get('Q_ampCW'), self.Q_block_length.get(),  # ns
                               sampling_rate=self.get('sampling_rate'),
                               delay=0,
                               phase=0)
        ModBlock = wf.mod_pulse(Block[0], Block[1],
                                f_modulation=self.Q_modulation.get(),
                                sampling_rate=self.sampling_rate.get(),
                                Q_phase_delay=self.mixer_IQ_phase_skewness.get())

        # RO pulses
        M = wf.block_pulse(self.get('M_amp'), self.M_length.get(),  # ns
                           sampling_rate=self.get('sampling_rate'),
                           delay=0,
                           phase=self.get('M_phi'))
        Mod_M = wf.mod_pulse(M[0], M[1],
                             f_modulation=self.M_modulation.get(),
                             sampling_rate=self.sampling_rate.get(),
                             Q_phase_delay=self.mixer_IQ_phase_skewness.get())
        # advanced RO pulses
        # with ramp-up
        M_up = wf.block_pulse(self.get('M_up_amp'), self.M_up_length.get(),  # ns
                              sampling_rate=self.get('sampling_rate'),
                              delay=0,
                              phase=self.get('M_up_phi'))

        M_up_mid = (np.concatenate((M_up[0], M[0])),
                    np.concatenate((M_up[1], M[1])))

        Mod_M_up_mid = wf.mod_pulse(M_up_mid[0], M_up_mid[1],
                                    f_modulation=self.get('M_modulation'),
                                    sampling_rate=self.get('sampling_rate'),
                                    Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        # with ramp-up and double frequency depletion
        M_down0 = wf.block_pulse(self.get('M_down_amp0'), self.get('M_down_length'),  # ns
                                 sampling_rate=self.get('sampling_rate'),
                                 delay=0,
                                 phase=self.get('M_down_phi0'))

        M_down1 = wf.block_pulse(self.get('M_down_amp1'), self.get('M_down_length'),  # ns
                                 sampling_rate=self.get('sampling_rate'),
                                 delay=0,
                                 phase=self.get('M_down_phi1'))
        Mod_M_down0 = wf.mod_pulse(M_down0[0],
                                   M_down1[1],
                                   f_modulation=self.get('M0_modulation'),
                                   sampling_rate=self.get('sampling_rate'),
                                   Q_phase_delay=self.get('mixer_IQ_phase_skewness'))
        Mod_M_down1 = wf.mod_pulse(M_down1[0],
                                   M_down1[1],
                                   f_modulation=self.get('M1_modulation'),
                                   sampling_rate=self.get('sampling_rate'),
                                   Q_phase_delay=self.get('mixer_IQ_phase_skewness'))

        # summing the depletion components
        Mod_M_down = (np.add(Mod_M_down0[0],
                             Mod_M_down1[0]),
                      np.add(Mod_M_down0[1],
                             Mod_M_down1[1]))

        # concatenating up, mid and depletion
        Mod_M_up_mid_down = (np.concatenate((Mod_M_up_mid[0], Mod_M_down[0])),
                             np.concatenate((Mod_M_up_mid[1], Mod_M_down[1])))

        self._wave_dict = {'I': Wave_I,
                           'X180': Wave_X_180, 'Y180': Wave_Y_180,
                           'X90': Wave_X_90, 'Y90': Wave_Y_90,
                           'mX90': Wave_mX90, 'mY90': Wave_mY90,
                           'Rphi90': Wave_Rphi90, 'Rphi180': Wave_Rphi180,
                           'Block': Block,
                           'ModBlock': ModBlock,
                           'M_square': Mod_M,
                           'M_up_mid': Mod_M_up_mid,
                           'M_up_mid_double_dep': Mod_M_up_mid_down
                           }

        if self.mixer_apply_predistortion_matrix():
            M = self.get_mixer_predistortion_matrix()
            for key, val in self._wave_dict.items():
                self._wave_dict[key] = np.dot(M, val)

        return self._wave_dict