def get_sweep_elements(self):
        wait_elt = element.Element('pulse_delay', pulsar=qt.pulsar)
        wait_elt.append(pulse.cp(self.T, length=1e-6))

        pulse_elts = []
        sweep_elts = []
        
        for i in range(self.params['pts']):
            e = element.Element('ERabi_pt-{}'.format(i), pulsar=qt.pulsar)
            e.append(self.T)
            e.append(
                pulse.cp(self.e_pulse,
                    frequency = self.params_lt1['MW_pulse_mod_frqs'][i],
                    amplitude = self.params_lt1['MW_pulse_amps'][i],
                    length = self.params_lt1['MW_pulse_durations'][i]))
            pulse_elts.append(e)

        for i in range(self.params['pts']):
            if self.params_lt1['MW_pulse_multiplicities'][i] == 0:
                sweep_elts.append(pulse_elts[i])

            else:
                subelts = []
                for j in range(self.params_lt1['MW_pulse_multiplicities'][i]):
                    subelts.append(pulse_elts[i])
                    subelts.append(wait_elt)
                sweep_elts.append(subelts)

        return sweep_elts

    def get_sweep_elements(self):
        e = element.Element('Hadamard', pulsar=qt.pulsar, 
            global_time = True)
        e.append(self.T)
        e.append(self.shelving_pulse)
        e.append(pulse.cp(self.T, length=100e-9))
        
        # this is by using two rotations around x/y -- This works much better!
        # phase of 0 makes x (rotate around +Y), -90 makes y (rotate around -X)
        prep_name = e.append(pulse.cp(self.N_pi2,
            phase = -90.,
            amplitude = 1))

        # first a pi/2 over +Y
        h_pi2_name = e.append(pulse.cp(self.N_pi2,
            phase = 0,
            amplitude = 1))
        
        # then a pi over +X
        h_pi_name = e.append(pulse.cp(self.N_pi,
            phase = 90.,
            amplitude = 1))

        self.element = e
        self.params['tomo_time_offset'] = e.length()

        return BSM.NTomo.get_sweep_elements(self)

def _lt3_LDE_element(msmt, **kw):  ### WE NEED THIS GUY
    """
    This element contains the LDE part for LT3, i.e., spin pumping and MW pulses
    for the LT3 NV and the optical pi pulses as well as all the markers for HH and PLU.
    """

    # variable parameters
    name = kw.pop('name', 'LDE_LT3')
    pi2_pulse_phase = kw.pop('pi2_pulse_phase', 0)
    if kw.pop('use_short_eom_pulse',False):
        eom_pulse=pulse.cp(msmt.short_eom_aom_pulse,
            aom_on=msmt.params_lt3['eom_aom_on'])
    else:
        eom_pulse=pulse.cp(msmt.eom_aom_pulse,
            eom_pulse_amplitude = kw.pop('eom_pulse_amplitude', msmt.params_lt3['eom_pulse_amplitude']),
            eom_off_amplitude = kw.pop('eom_off_amplitude', msmt.params_lt3['eom_off_amplitude']),
            aom_on=msmt.params_lt3['eom_aom_on'])

    ###
    e = element.Element(name, 
        pulsar = qt.pulsar, 
        global_time = True)
    e.add(pulse.cp(msmt.empty_pulse,
            amplitude = 0,
            length = msmt.params['LDE_element_length']))

    #1 SP
    e.add(pulse.cp(msmt.empty_pulse, 
            amplitude = 0, 
            length = msmt.params_lt3['initial_delay']), 
        name = 'initial delay')
    
    
    for i in range(msmt.params['opt_pi_pulses']):
        name = 'opt pi {}'.format(i+1)
        refpulse = 'opt pi {}'.format(i) if i > 0 else 'initial delay'
        start = msmt.params_lt3['opt_pulse_separation'] if i > 0 else msmt.params['wait_after_sp']
        refpoint = 'start' if i > 0 else 'end'

        e.add(eom_pulse,        
            name = name, 
            start = start,
            refpulse = refpulse,
            refpoint = refpoint,)
        e.add(msmt.eom_trigger,
            name = name+'_trigger', 
            start = start,
            refpulse = refpulse,
            refpoint = refpoint,)

    #5 HHsync
    syncpulse_name = e.add(msmt.TH_sync, refpulse = 'initial delay', refpoint = 'start', refpoint_new = 'end')

    ############

    if e.length() != msmt.params['LDE_element_length']:
        raise Exception('LDE element length'+e.name+' is not as specified - granylarity issue?')
    return e

    return e

    def get_sweep_elements(self):        
        elts = []

        for i in range(self.params['pts']):
            e = element.Element('CNOTPHaseCheck_pt-{}'.format(i), pulsar=qt.pulsar, global_time = True)
            e.append(self.T)
            e.append(self.shelving_pulse)
            e.append(self.T)
            e.append(self.N_pi2)
            e.append(pulse.cp(self.T, length=200e-9))
            for m in np.arange(self.params['multiplicity']/2):
                if m == 0:
                    e.append(self.pi2pi_m1)
                    e.append(self.TIQ)
                    e.append(self.pi2pi_m1)
                else:
                    e.append(self.TIQ)
                    e.append(self.pi2pi_m1)
                    e.append(self.TIQ)
                    e.append(self.pi2pi_m1)
            e.append(pulse.cp(self.T, length=200e-9))
            e.append(pulse.cp(self.N_pi2, 
                phase = self.params['analysis_phases'][i]))

            elts.append(e)

        return elts

    def sequence(self, upload = True):
        # define the pulses we'll use
        sq_pulseAOM = pulse.SquarePulse(channel='AOM975', name='A square pulse on ThorLabsAOM')
        sq_pulseMW = pulse.SquarePulse(channel='MW_pulsemod', name='A square pulse on MW modulation')
        sq_pulsePC = pulse.SquarePulse(channel='photoncount', name='A square pulse on photon counting switch')
        sq_pulseMW_Imod = pulse.SquarePulse(channel='MW_Imod', name='A square pulse on MW I modulation')
        sq_pulseMW_Qmod = pulse.SquarePulse(channel='MW_Qmod', name='A square pulse on MW I modulation')

        elements = []
        # Create waveform that has laser, microwaves, photon counting, and 1/0 I/Q modulation on
        # all the time for a long period of time (~100 us).
        e = element.Element('CW_mode', pulsar=qt.pulsar)
        e.add(pulse.cp(sq_pulseAOM, amplitude=1, length=100e-6), name='laser')
        e.add(pulse.cp(sq_pulsePC, amplitude=1.0, length=100e-6), name='photoncountpulse')
        e.add(pulse.cp(sq_pulseMW_Imod, amplitude=1.0, length=100e-6),
        name='MWimodpulsecw', start=0e-9)
        e.add(pulse.cp(sq_pulseMW_Qmod, amplitude=0.0, length=100e-6),
        name='MWqmodpulsecw', start=0e-9)
        elements.append(e)

        # create a sequence from the pulses -- only one in this case
        seq = pulsar.Sequence('CW ESR Sequence')
        for e in elements:
            seq.append(name=e.name, wfname=e.name, trigger_wait=False, repetitions=-1)

        if upload:
            qt.pulsar.upload(*elements)
            time.sleep(2.0)
        # program the AWG
        qt.pulsar.program_sequence(seq)

    def get_sweep_elements(self):
        """
        to lock phases it's important to set the tomo_time_offset parameter.
        """

        z_element = element.Element('Z Tomo pulse', pulsar=qt.pulsar)
        z_element.append(pulse.cp(self.TN, length=1e-6))

        x_element = element.Element('X Tomo pulse', pulsar=qt.pulsar)
        xn = x_element.append(pulse.cp(self.N_pi2, 
            phase = phaseref(self.N_pi2.frequency, 
                self.params['tomo_time_offset']) + \
                self.params['tomo_pulse_phases'][1]))

        y_element = element.Element('Y Tomo pulse', pulsar=qt.pulsar)
        yn = y_element.append(pulse.cp(self.N_pi2, 
            phase = phaseref(self.N_pi2.frequency, 
                self.params['tomo_time_offset']) + \
                self.params['tomo_pulse_phases'][2]))

        sweep_elements = []
        for n, tomo_elt in zip(self.params['tomo_bases'],
            [z_element, x_element, y_element]):

            if type(self.element) == list:
                elts = [e for e in self.element]
                elts.append(tomo_elt)
                sweep_elements.append(elts)
            else:
                elts = [self.element, tomo_elt]
                sweep_elements.append(elts)

        return sweep_elements

def _lt2_final_id(msmt, name, time_offset, **kw):
    wait_length = msmt.params_lt2['CORPSE_pi2_wait_length'] + msmt.CORPSE_pi.length 
    final_id_elt = element.Element('second_id_elt-{}'.format(name), pulsar= qt.pulsar, 
                global_time = True, time_offset = time_offset)
    final_id_elt.append(pulse.cp(msmt.T, length =  wait_length)) 
    final_id_elt.append(pulse.cp(msmt.T, length =  100e-9 )) 

    return final_id_elt

    def generate_sequence(self, upload=True):
        # MBI element
        mbi_elt = self._MBI_element()

        # electron manipulation pulses
        T = pulse.SquarePulse(channel='MW_pulsemod',
            length = 10e-9, amplitude = 0)

        X = pulselib.MW_IQmod_pulse('MW pulse',
            I_channel = 'MW_Imod', 
            Q_channel = 'MW_Qmod',
            PM_channel = 'MW_pulsemod',
            PM_risetime = self.params['MW_pulse_mod_risetime'])

        adwin_sync = pulse.SquarePulse(channel='adwin_sync',
            length = self.params['AWG_to_adwin_ttl_trigger_duration'], 
            amplitude = 2)

        # electron manipulation elements
        elts = []
        for i in range(self.params['pts']):
            e = element.Element('ERamsey_pt-%d' % i, pulsar=qt.pulsar,
                global_time = True)
            e.append(T)
        
            e.append(
                pulse.cp(X,
                    frequency = self.params['MW_pulse_mod_frqs'][i],
                    amplitude = self.params['MW_pulse_amps'][i],
                    length = self.params['MW_pulse_durations'][i],
                    phase = self.params['MW_pulse_1_phases'][i]))

            e.append(
                pulse.cp(T, length=self.params['MW_pulse_delays'][i]))

            e.append(
                pulse.cp(X, 
                    frequency = self.params['MW_pulse_mod_frqs'][i],
                    amplitude = self.params['MW_pulse_amps'][i],
                    length = self.params['MW_pulse_durations'][i],
                    phase = self.params['MW_pulse_2_phases'][i]))

            e.append(adwin_sync)
            elts.append(e)

        # sequence
        seq = pulsar.Sequence('MBI Electron Rabi sequence')
        for i,e in enumerate(elts):
            seq.append(name = 'MBI-%d' % i, wfname = mbi_elt.name, 
                trigger_wait = True, goto_target = 'MBI-%d' % i, 
                jump_target = e.name)
            seq.append(name = e.name, wfname = e.name, 
                trigger_wait = True)

        # program AWG
        if upload:
            qt.pulsar.upload(mbi_elt, *elts)
        qt.pulsar.program_sequence(seq)

 def generate_sequence(self, upload=True):
     # load all the other pulsar resources
     self._pulse_defs()
     
     self.FT_pulse = pulse.SquarePulse(channel='Velocity1AOM',
         length = self.params['sp_duration'], amplitude = self.params['FT_pulse_amp'])
     
     self.yel_pulse = pulse.SquarePulse(channel='YellowAOM',
         length = self.params['sp_duration']*3/4., amplitude = self.params['yellow_pulse_amp'])
     
     # make the list of elements required for uploading
     e = element.Element('N_FT_Polarisation', pulsar=qt.pulsar, global_time = True)
     
     e.append(pulse.cp(self.T, length=200e-9))
     last = e.append(self.yel_pulse)
     e.add(self.FT_pulse, refpulse=last, refpoint='start')
     e.append(pulse.cp(self.T, length=200e-9))
     e.append(pulse.cp(self.CORPSE_pi)) # ,
         # frequency = self.params['CORPSE_pi_mod_frq'],
         # amplitude = 0.))        
     
     # create the sequence
     seq = pulsar.Sequence('N_FT_Polarisation_Check_ESR_sequence')
     
     ro_elts = []
     for i,f in enumerate(self.params['RO_mod_frqs']):
         
         # 1: MBI 
         seq.append(name = 'MBI-{}'.format(i),
             wfname = self.mbi_elt.name,
             trigger_wait = True,
             goto_target = 'MBI-{}'.format(i),
             jump_target = 'ft_mw'+str(i))  
                 
         #2  then repeat (SP+MW pi)-element for the current number of times
         seq.append(name = 'ft_mw'+str(i), wfname=e.name,
                 repetitions = self.params['FT_element_repetitions'],
                 trigger_wait = True)
         
         #3 ESR type readout
         ro_e = element.Element('N_RO-{}'.format(i), pulsar=qt.pulsar, global_time = True)
         ro_e.append(self.T)
         ro_e.append(pulse.cp(self.slow_pi, 
             frequency = f))
         
         seq.append(name='N_ro'+str(i), wfname=ro_e.name,
             trigger_wait=False)
         ro_elts.append(ro_e)
             
         seq.append(name = 'sync-{}'.format(i), 
                 wfname = self.sync_elt.name) 
             
     # program AWG
     if upload:
         qt.pulsar.upload(self.mbi_elt, e ,self.sync_elt, *ro_elts)
     
     qt.pulsar.program_sequence(seq)        

    def generate_sequence(self, upload=True):
        # electron manipulation pulses
        T = pulse.SquarePulse(channel='MW_pulsemod',
            length = 100e-9, amplitude = 0)
        TIQ = pulse.SquarePulse(channel='MW_Imod',
            length = 10e-9, amplitude = 0)

        CORPSE_pi = pulselib.IQ_CORPSE_pulse('CORPSE pi-pulse',
            I_channel = 'MW_Imod', 
            Q_channel = 'MW_Qmod',    
            PM_channel = 'MW_pulsemod',
            PM_risetime = self.params['MW_pulse_mod_risetime'],
            frequency = self.params['CORPSE_mod_frq'],
            rabi_frequency = self.params['CORPSE_rabi_frequency'],
            amplitude = self.params['CORPSE_amp'],
            eff_rotation_angle = 180)

        CORPSE_pi2 = pulselib.IQ_CORPSE_pulse('CORPSE pi-pulse',
            I_channel = 'MW_Imod', 
            Q_channel = 'MW_Qmod',    
            PM_channel = 'MW_pulsemod',
            PM_risetime = self.params['MW_pulse_mod_risetime'],
            frequency = self.params['CORPSE_mod_frq'],
            rabi_frequency = self.params['CORPSE_rabi_frequency'],
            amplitude = self.params['CORPSE_amp'],
            eff_rotation_angle = 90)

        wait_1us = element.Element('1us_delay', pulsar=qt.pulsar)
        wait_1us.append(pulse.cp(T, length=1e-6))

        sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
        adwin_sync = pulse.SquarePulse(channel='adwin_sync',
            length = 10e-6, amplitude = 2)
        sync_elt.append(adwin_sync)

        elts = []
        seq = pulsar.Sequence('CORPSE test')

        for i in range(self.params['pts']):
            e = element.Element('CORPSE_Pi2_Pi-{}'.format(i), 
                pulsar = qt.pulsar,
                global_time=True)
            e.append(T)
            e.append(pulse.cp(CORPSE_pi2))
            e.append(pulse.cp(TIQ, length=self.params['delays'][i]))
            e.append(pulse.cp(CORPSE_pi))
            e.append(T)
            elts.append(e)
            seq.append(name='CORPSE_Pi2_Pi-{}'.format(i),
                wfname = e.name,
                trigger_wait=True)
            seq.append(name='sync-{}'.format(i),
                wfname = sync_elt.name)

        if upload:
            qt.pulsar.upload(sync_elt, wait_1us, *elts)
        qt.pulsar.program_sequence(seq)

    def generate_sequence(self, upload=True):
        # MBI element
        mbi_elt = self._MBI_element()

        # electron manipulation pulses
        self.T = pulse.SquarePulse(channel='MW_pulsemod',
            length = 100e-9, amplitude = 0)

        self.g_pulse = self.PulseClass('gaussian IQ pulse',
            I_channel = 'MW_Imod',
            Q_channel = 'MW_Qmod',
            PM_channel = 'MW_pulsemod',
            PM_risetime = self.params['MW_pulse_mod_risetime'],
            frequency = self.params['pulse_mod_frqs'][0],
            amplitude = self.params['pulse_amps'][0],
            length = self.params['pulse_durations'][0])
    
        elts = []
        for i in range(self.params['pts']):
            e = element.Element('ERabi_pt-{}'.format(i), pulsar=qt.pulsar)
            e.append(self.T)            
            for j in range(self.params['MW_pulse_multiplicities'][i]):
                e.append(
                    pulse.cp(self.g_pulse,
                        frequency = self.params['pulse_mod_frqs'][i],
                        amplitude = self.params['pulse_amps'][i],
                        length = self.params['pulse_durations'][i]))
                e.append(
                    pulse.cp(self.T, length=self.params['MW_pulse_delays'][i]))
            elts.append(e)

        sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
        adwin_sync = pulse.SquarePulse(channel='adwin_sync',
            length = 10e-6, amplitude = 2)
        sync_elt.append(adwin_sync)

        seq = pulsar.Sequence('CNOT sequence')
        for i in range(self.params['pts']):

            seq.append(name = 'MBI-%d' % i, 
                wfname = mbi_elt.name, 
                trigger_wait = True, 
                goto_target = 'MBI-%d' % i, 
                jump_target = 'pulse-{}'.format(i))

            seq.append(name = 'pulse-{}'.format(i), 
                       wfname = elts[i].name,
                       trigger_wait=True)

            seq.append(name = 'sync-{}'.format(i),
                wfname = sync_elt.name)

        # program AWG
        if upload:
            qt.pulsar.upload(mbi_elt, sync_elt, *elts)
        qt.pulsar.program_sequence(seq)

    def generate_sequence(self, upload=True):
        # MBI element
        mbi_elt = self._MBI_element()

        # electron manipulation pulses
        T = pulse.SquarePulse(channel='MW_pulsemod',
            length = 10e-9, amplitude = 0)

        CORPSE_pi = pulselib.IQ_CORPSE_pi_pulse('CORPSE pi-pulse',
            I_channel = 'MW_Imod', 
            Q_channel = 'MW_Qmod',
            PM_channel = 'MW_pulsemod',
            PM_risetime = self.params['MW_pulse_mod_risetime'],
            frequency = self.params['CORPSE_pi_mod_frq'],
            amplitude = self.params['CORPSE_pi_amp'],
            length_60 = self.params['CORPSE_pi_60_duration'],
            length_m300 = self.params['CORPSE_pi_m300_duration'],
            length_420 = self.params['CORPSE_pi_420_duration'])

        sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar)
        adwin_sync = pulse.SquarePulse(channel='adwin_sync',
            length = 10e-6, amplitude = 2)
        sync_elt.append(adwin_sync)

        wait_1us = element.Element('1us_delay', pulsar=qt.pulsar)
        wait_1us.append(pulse.cp(T, length=1e-6))

        elts = []
        for i in range(self.params['pts']):
            e = element.Element('CORPSE-{}'.format(i), pulsar=qt.pulsar)
            e.append(T,
                pulse.cp(CORPSE_pi,
                    amplitude=self.params['CORPSE_pi_sweep_amps'][i]))
            elts.append(e)

        # sequence
        seq = pulsar.Sequence('CORPSE pi calibration')
        for i,e in enumerate(elts):
            seq.append(name = 'MBI-%d' % i, wfname = mbi_elt.name, 
                trigger_wait = True, goto_target = 'MBI-%d' % i, 
                jump_target = e.name+'-0')
            
            for j in range(self.params['multiplicity']):
                seq.append(name = e.name+'-{}'.format(j), 
                    wfname = e.name,
                    trigger_wait = (j==0))
                seq.append(name = 'wait-{}-{}'.format(i,j), 
                    wfname = wait_1us.name, 
                    repetitions = self.params['delay_reps'])
            seq.append(name = 'sync-{}'.format(i),
                wfname = sync_elt.name)

        # program AWG
        if upload:
            qt.pulsar.upload(mbi_elt, sync_elt, wait_1us, *elts)
        qt.pulsar.program_sequence(seq)

    def calibrate_CORPSE_pi_phase_shift_or_e_time(self):
        """
        Do a Hahn echo sequence with the CORPSE pi pulse, and sweep it's zero
        phase with respect the rotating frame at that time.
        """
        sweep_elements = []
        self.flattened_elements = []
        self.seq = pulsar.Sequence('{}_{}-Sequence'.format(self.mprefix, 
            self.name))

        first_pi2_elt = element.Element('first pi2', pulsar=qt.pulsar,
            global_time = True)
        first_pi2_elt.append(pulse.cp(self.T, length=1e-6))
        first_pi2_name = first_pi2_elt.append(self.fast_pi2)
        first_pi2_elt.append(pulse.cp(self.TIQ, length=100e-9))

        self.flattened_elements.append(first_pi2_elt)

        # the start time of the second pi2, and the evolution time depends on the time when the
        # pulse stops in the first pi2 element:
        t_pi2 = first_pi2_elt.length() - \
            first_pi2_elt.effective_pulse_end_time(first_pi2_name, 'MW_Imod')

        # calculate the evolution time from the interpulse delay
        etimes = self.params_lt1['interpulse_delays'] - t_pi2 - self.fast_pi2.effective_length()/2.

        pi_elts = []
        second_pi2_elts = []
        for i in range(self.params['pts']):
            e = self.UNROT_element('pi-{}'.format(i),
                None, etimes[i], first_pi2_elt.length(),
                CORPSE_pi_phase_shift = \
                    self.params_lt1['CORPSE_pi_phase_shifts'][i])
            
            self.flattened_elements.append(e)
            pi_elts.append(e)

            # make the element
            second_pi2_elt = element.Element('second pi2-{}'.format(i), pulsar=qt.pulsar,
                global_time = True, 
                time_offset = e.length()+first_pi2_elt.length())        
            second_pi2_elt.append(pulse.cp(self.TIQ, length=t_pi2))
            second_pi2_elt.append(self.fast_pi2)

            self.flattened_elements.append(second_pi2_elt)
            second_pi2_elts.append(second_pi2_elt)

        self.flattened_elements.append(self.N_RO_CNOT_elt)

        for i in range(self.params['pts']):
            sweep_elements.append([first_pi2_elt, 
                pi_elts[i],second_pi2_elts[i]])
        
        self.seq = self._add_MBI_and_sweep_elements_to_sequence(
            sweep_elements, self.N_RO_CNOT_elt, self.adwin_lt1_trigger_element)

def _lt1_N_RO_elt(msmt):
    """
    This is an element with spin pumping to ms=0 and a (pi-2pi) CNOT pulse for the nitrogen readout.
    """
    N_RO_elt = element.Element('N-RO', pulsar=msmt.pulsar_lt1)
    N_RO_elt.append(pulse.cp(msmt.T,
                              length=1000e-9))    
    N_RO_elt.append(pulse.cp(msmt.SP_pulse,
                             length = msmt.params_lt1['N_RO_SP_duration']))
    N_RO_elt.append(pulse.cp(msmt.T,
                             length=2000e-9))
    N_RO_elt.append(msmt.pi2pi_m1)

    return N_RO_elt

    def generate_sequence(self, upload=True):

        # define the necessary pulses
        X = pulselib.IQ_CORPSE_pi2_pulse('CORPSE pi2-pulse', 
            I_channel='MW_Imod', 
            Q_channel='MW_Qmod', 
            PM_channel='MW_pulsemod',
            PM_risetime = self.params['MW_pulse_mod_risetime'],
            frequency = self.params['CORPSE_pi2_mod_frq'],
            amplitude = self.params['CORPSE_pi2_amp'],
            length_24p3 = self.params['CORPSE_pi2_24p3_duration'],
            length_m318p6 = self.params['CORPSE_pi2_m318p6_duration'],
            length_384p3 = self.params['CORPSE_pi2_384p3_duration'])

        T = pulse.SquarePulse(channel='MW_Imod', name='delay', 
            length = 200e-9, amplitude = 0.)
        
        # make the elements - one for each ssb frequency
        elements = []
        for i in range(self.params['pts']):

            e = element.Element('ElectronRamsey_pt-%d' % i, pulsar=qt.pulsar,
                global_time = True)
            e.append(T)
            
            e.append(pulse.cp(X,
                amplitude = self.params['CORPSE_pi2_amps'][i],
                phase = self.params['CORPSE_pi2_phases1'][i]))

            e.append(pulse.cp(T,
                length = self.params['evolution_times'][i]))

            e.append(pulse.cp(X,
                amplitude = self.params['CORPSE_pi2_amps'][i],
                phase = self.params['CORPSE_pi2_phases2'][i]))
    
            elements.append(e)

        # create a sequence from the pulses
        seq = pulsar.Sequence('ElectronRamsey sequence')
        for e in elements:
            seq.append(name=e.name, wfname=e.name, trigger_wait=True)

        # upload the waveforms to the AWG
        if upload:
            qt.pulsar.upload(*elements)

        # program the AWG
        qt.pulsar.program_sequence(seq)

def _lt2_dummy_element(msmt):
    """
    A 1us empty element we can use to replace 'real' elements for certain modes.
    """
    e = element.Element('Dummy', pulsar = qt.pulsar)
    e.append(pulse.cp(msmt.T, length=10e-6))
    return e

    def generate_sequence(self, upload=True):
        # MBI element
        mbi_elt = self._MBI_element()

        # electron manipulation pulses
        T = pulse.SquarePulse(channel="MW_pulsemod", length=10e-9, amplitude=0)

        Xpassage = AdiabaticPassagePulse(
            "Adiabatic Passage",
            fstart=self.params["passage_start_mod_frq"],
            fstop=self.params["passage_stop_mod_frq"],
            amplitude=self.params["passage_amp"],
        )

        adwin_sync = pulse.SquarePulse(channel="adwin_sync", length=10e-6, amplitude=2)

        # electron manipulation elements
        elts = []
        for i in range(self.params["pts"]):
            e = element.Element("Passage_pt-%d" % i, pulsar=qt.pulsar)
            e.append(T, pulse.cp(Xpassage, length=self.params["passage_lengths"][i]), adwin_sync)
            elts.append(e)

        # sequence
        seq = pulsar.Sequence("MBI adiabatic passage sequence")
        for i, e in enumerate(elts):
            seq.append(
                name="MBI-%d" % i, wfname=mbi_elt.name, trigger_wait=True, goto_target="MBI-%d" % i, jump_target=e.name
            )
            seq.append(name=e.name, wfname=e.name, trigger_wait=True)

        # program AWG
        if upload:
            qt.pulsar.upload(mbi_elt, *elts)
        qt.pulsar.program_sequence(seq)

    def generate_sequence(self, upload=True):

        # define the necessary pulse

        TT = pulse.SquarePulse(channel="HH_sync", length=1000e-9, amplitude=0)
        SP = pulse.SquarePulse(
            channel=self.params["sp_channel"],
            length=self.params["AWG_SP_duration"][0],
            amplitude=self.params["AWG_SP_voltage"][0],
        )

        # print self.params['AWG_SP_voltage']
        # make the elements - one for each ssb frequency
        elements = []
        for i in range(self.params["pts"]):
            e = element.Element("AWG_SP_sweep-%d" % i, pulsar=self.pulsar)
            e.add(TT, name="wait")
            e.append(pulse.cp(SP(length=self.params["AWG_SP_duration"][i], amplitude=self.params["AWG_SP_voltage"][i])))
            elements.append(e)

        # create a sequence from the pulses
        seq = pulsar.Sequence("SSRO sequence")
        for e in elements:
            seq.append(name=e.name, wfname=e.name, trigger_wait=True)

        # upload the waveforms to the AWG
        if upload:
            self.pulsar.upload(*elements)

        # program the AWG
        self.pulsar.program_sequence(seq)

    def test_BSM_with_LDE_element_calibrate_echo_time(self, basis='-Z'):
        sweep_elements = []
        self.flattened_elements = []
        self.seq = pulsar.Sequence('{}_{}-Sequence'.format(self.mprefix, 
            self.name))

        for i in range(self.params['pts']):            
            N_init = self.N_init_element('N_init-{}'.format(i), 
                basis = basis, 
                echo_time_after_LDE = self.params_lt1['echo_times_after_LDE'][i], 
                end_offset_time = -100e-9)
            
            e_pi2_elt = element.Element('e_pi2-{}'.format(i), pulsar = qt.pulsar, 
                global_time = True, time_offset = self.LDE_element.length() + N_init.length())
            e_pi2_elt.append(pulse.cp(self.TIQ, 
                length = 100e-9))
            e_pi2_elt.append(self.fast_pi2)


            self.flattened_elements.append(self.LDE_element)
            self.flattened_elements.append(N_init)
            self.flattened_elements.append(e_pi2_elt)
            sweep_elements.append([self.LDE_element,N_init,e_pi2_elt])
            
        self.seq = self._add_MBI_and_sweep_elements_to_sequence(
            sweep_elements, self.N_RO_CNOT_elt, self.adwin_lt1_trigger_element)

def _lt1_LDE_element(msmt):
    """
    This element contains the LDE part for LT1, i.e., spin pumping and MW pulses
    for the LT1 NV in the real experiment.
    """
    e = element.Element('LDE_LT1', pulsar = msmt.pulsar_lt1, global_time = True)

    # this pulse to ensure that the element has equal length as the lt2 element
    e.add(pulse.cp(msmt.SP_pulse,
            amplitude = 0,
            length = msmt.params['LDE_element_length']))
    #
    #1 SP
    e.add(pulse.cp(msmt.SP_pulse,
                amplitude = 0, 
                length = msmt.params_lt1['initial_delay']), 
            name = 'initial_delay')
    
    e.add(pulse.cp(msmt.SP_pulse, 
                length = msmt.params['LDE_SP_duration'], 
                amplitude = 1.0),
            name = 'spinpumping',
            refpulse = 'initial_delay')

    e.add(pulse.cp(msmt.yellow_pulse, 
                length = msmt.params['LDE_SP_duration_yellow'], 
                amplitude = 1. if msmt.params_lt1['AWG_yellow_use']  else 0.), 
            name = 'spinpumpingyellow', 
            refpulse = 'initial_delay')

    #2 MW pi/2
    if msmt.params_lt1['MW_during_LDE'] == 1:
        e.add(msmt.fast_pi2, name = 'mw_pi2_pulse', 
                start = msmt.params_lt1['MW_wait_after_SP'],
                refpulse = 'spinpumping', refpoint = 'end', refpoint_new = 'start')

    #3 MW pi
    if msmt.params_lt1['MW_during_LDE'] == 1:
        e.add(msmt.fast_pi, name = 'mw_pi_pulse',
                start = msmt.params_lt1['MW_separation'],
                refpulse = 'mw_pi2_pulse', refpoint = 'end', refpoint_new = 'start')
        
    ################
    
    if e.length() != msmt.params['LDE_element_length']:
        raise Exception('LDE element length' + e.name+' is not as specified - granularity issue?')
    return e