Esempio n. 1
0
def make5014pulsar(awg):
    awg = awg.name
    pulsar = Pulsar(name='PuLsAr', default_AWG=awg, master_AWG=awg)
    #    pulsar = ps.Pulsar()
    #    pulsar.AWG = AWG
    marker1highs = [2, 2, 2.7, 2, 2, 2, 2.7, 2]
    for i in range(8):
        pulsar.define_channel(id='ch{}'.format(i % 4 + 1),
                              name='ch{}'.format(i + 1),
                              type='analog',
                              high=.7,
                              low=-.7,
                              offset=0.0,
                              delay=0,
                              active=True,
                              AWG=awg)
        pulsar.define_channel(id='ch{}_marker1'.format(i % 4 + 1),
                              name='ch{}_marker1'.format(i + 1),
                              type='marker',
                              high=marker1highs[i],
                              low=0,
                              offset=0.,
                              delay=0,
                              active=True,
                              AWG=awg)
        pulsar.define_channel(id='ch{}_marker2'.format(i % 4 + 1),
                              name='ch{}_marker2'.format(i + 1),
                              type='marker',
                              high=2,
                              low=0,
                              offset=0.,
                              delay=0,
                              active=True,
                              AWG=awg)
    return pulsar
Esempio n. 2
0
    def setUp(self):
        """Called before every test in the class."""

        # Random instrument name, otherwise error if tests are run too fast...
        id = random.randint(1, 1000000)
        self.pulsar = Pulsar(f"pulsar_{id}")

        self.awg5014 = VirtualAWG5014(f"awg5014_{id}",
                                      timeout=20,
                                      address='TCPIP0::192.168.1.4')

        self.hdawg = ZI_HDAWG_qudev(f"hdawg_{id}",
                                    device="dev8000",
                                    interface="1GbE",
                                    server="emulator")

        # TODO: SHFQ currently has no virtual driver, so we do not unit test it.
        # self.shfqa = SHFQA(name=f"shfqa_{id}", serial="dev12000", host="localhost")

        self.uhfqc = UHFQA(f"uhfqc_{id}",
                           device='dev2000',
                           interface='1GbE',
                           server="emulator")

        self.awgs: List[Tuple[Instrument, Type[PulsarAWGInterface]]] = [
            (self.awg5014, AWG5014Pulsar),
            (self.hdawg, HDAWG8Pulsar),
            # (self.shfqa, SHFQAPulsar),
            (self.uhfqc, UHFQCPulsar),
        ]
def set_5014pulsar(awg, awg2):
    
    awg = awg.name
    awg2 = awg2.name
    pulsar = Pulsar(name = 'PuLsAr', default_AWG = awg, master_AWG = awg)

    marker1highs = [2, 2, 2, 2, 2, 2, 2, 2]
    for i in range(8):
        pulsar.define_channel(id='ch{}'.format(i%4 + 1),
                              name='ch{}'.format(i + 1), type='analog',
                              high=2, low=-2,
                              offset=0.0, delay=0, active=True, AWG = awg if i<4 else awg2)
        pulsar.define_channel(id='ch{}_marker1'.format(i%4 + 1),
                              name='ch{}_marker1'.format(i + 1),
                              type='marker',
                              high=marker1highs[i], low=0, offset=0.,
                              delay=0, active=True, AWG = awg if i<4 else awg2)
        pulsar.define_channel(id='ch{}_marker2'.format(i%4 + 1),
                              name='ch{}_marker2'.format(i + 1),
                              type='marker',
                              high=2, low=0, offset=0.,
                              delay=0, active=True, AWG = awg if i<4 else awg2)
    return pulsar
def set_5014pulsar():

    pulsar = Pulsar(name='PuLsAr', )

    marker1highs = [2, 2, 2, 2, 2, 2, 2, 2]
    for i in range(8):
        pulsar.define_channel(
            id='ch{}'.format(i + 1),
            name='ch{}'.format(i + 1),
            type='analog',
            high=2,
            low=-2,
            offset=0.0,
            delay=0,
            active=True,
        )
        pulsar.define_channel(
            id='ch{}_marker1'.format(i + 1),
            name='ch{}_marker1'.format(i + 1),
            type='marker',
            high=marker1highs[i],
            low=0,
            offset=0.,
            delay=0,
            active=True,
        )
        pulsar.define_channel(
            id='ch{}_marker2'.format(i + 1),
            name='ch{}_marker2'.format(i + 1),
            type='marker',
            high=2,
            low=0,
            offset=0.,
            delay=0,
            active=True,
        )
    return pulsar
Esempio n. 5
0
 def setUp(self):
     # set up a pulsar with some mock settings for the element
     self.station = qc.Station()
     self.AWG = VirtualAWG5014('AWG'+str(time.time()))
     self.AWG.clock_freq(1e9)
     self.pulsar = Pulsar('Pulsar' + str(time.time()), self.AWG.name)
     self.station.pulsar = self.pulsar
     for i in range(4):
         self.pulsar.define_channel(id='ch{}'.format(i+1),
                                       name='ch{}'.format(i+1),
                                       type='analog',
                                       # max safe IQ voltage
                                       high=.7, low=-.7,
                                       offset=0.0, delay=0, active=True)
         self.pulsar.define_channel(id='ch{}_marker1'.format(i+1),
                                       name='ch{}_marker1'.format(i+1),
                                       type='marker',
                                       high=2.0, low=0, offset=0.,
                                       delay=0, active=True)
         self.pulsar.define_channel(id='ch{}_marker2'.format(i+1),
                                       name='ch{}_marker2'.format(i+1),
                                       type='marker',
                                       high=2.0, low=0, offset=0.,
                                       delay=0, active=True)
Esempio n. 6
0
    def setUp(self):
        # set up a pulsar with some mock settings for the element
        self.AWG = VirtualAWG5014('AWG' + str(time.time()))
        self.AWG.clock_freq(1e9)
        self.pulsar = Pulsar('Pulsar' + str(time.time()), self.AWG.name)
        for i in range(4):
            self.pulsar.define_channel(
                id='ch{}'.format(i + 1),
                name='ch{}'.format(i + 1),
                type='analog',
                # max safe IQ voltage
                high=.7,
                low=-.7,
                offset=0.0,
                delay=0,
                active=True)
            self.pulsar.define_channel(id='ch{}_marker1'.format(i + 1),
                                       name='ch{}_marker1'.format(i + 1),
                                       type='marker',
                                       high=2.0,
                                       low=0,
                                       offset=0.,
                                       delay=0,
                                       active=True)
            self.pulsar.define_channel(id='ch{}_marker2'.format(i + 1),
                                       name='ch{}_marker2'.format(i + 1),
                                       type='marker',
                                       high=2.0,
                                       low=0,
                                       offset=0.,
                                       delay=0,
                                       active=True)

        self.pulse_pars = {
            'I_channel': 'ch1',
            'Q_channel': 'ch2',
            'amplitude': .5,
            'amp90_scale': .5,
            'sigma': 10e-9,
            'nr_sigma': 4,
            'motzoi': .8,
            'mod_frequency': 100e-6,
            'pulse_delay': 0,
            'phi_skew': 0,
            'alpha': 1,
            'phase': 0,
            'pulse_type': 'SSB_DRAG_pulse'
        }

        self.RO_pars = {
            'I_channel': 'ch3',
            'Q_channel': 'ch4',
            'operation_type': 'RO',
            'RO_pulse_marker_channel': 'ch3_marker1',
            'amplitude': '.5',
            'length': 300e-9,
            'pulse_delay': 0,
            'mod_frequency': 50e6,
            'acq_marker_delay': 0,
            'acq_marker_channel': 'ch1_marker1',
            'phase': 0,
            'pulse_type': 'MW_IQmod_pulse_tek'
        }

        station = Bunch(pulsar=self.pulsar)
        sqs.station = station
def AWG_Test():

    station.pulsar = Pulsar()
    station.pulsar.AWG = station.components['awg']
    marker1highs = [2, 2, 2.7, 2]
    for i in range(4):
        # Note that these are default parameters and should be kept so.
        # the channel offset is set in the AWG itself. For now the amplitude is
        # hardcoded. You can set it by hand but this will make the value in the
        # sequencer different.
        station.pulsar.define_channel(
            id='ch{}'.format(i + 1),
            name='ch{}'.format(i + 1),
            type='analog',
            # max safe IQ voltage
            high=.7,
            low=-.7,
            offset=0.0,
            delay=0,
            active=True)
        station.pulsar.define_channel(id='ch{}_marker1'.format(i + 1),
                                      name='ch{}_marker1'.format(i + 1),
                                      type='marker',
                                      high=marker1highs[i],
                                      low=0,
                                      offset=0.,
                                      delay=0,
                                      active=True)
        station.pulsar.define_channel(id='ch{}_marker2'.format(i + 1),
                                      name='ch{}_marker2'.format(i + 1),
                                      type='marker',
                                      high=2.0,
                                      low=0,
                                      offset=0.,
                                      delay=0,
                                      active=True)

    #Implementation of a sequence element.
    #Basic idea: add different pulses, and compose the actual numeric
    #arrays that form the amplitudes for the hardware (typically an AWG)
    V_empty = 0
    V_load = 0.05
    V_read = 0.025

    t_empty = 20e-6
    t_load = 10e-6
    t_read = 20e-6

    Npoints = 1

    Empty_elt = Element('Empty_elt', pulsar=station.pulsar)
    Empty_elt.add(SquarePulse(name='square_empty',
                              channel='ch1',
                              amplitude=V_empty,
                              start=0,
                              length=t_empty),
                  name='Empty')

    Load_elt = Element('Load_elt', pulsar=station.pulsar)
    Load_elt.add(SquarePulse(name='square_load',
                             channel='ch1',
                             amplitude=V_load,
                             start=0,
                             length=t_load),
                 name='Load')

    Read_elt = Element('Read_elt', pulsar=station.pulsar)
    Read_elt.add(SquarePulse(name='square_read',
                             channel='ch1',
                             amplitude=V_read,
                             start=0,
                             length=t_read),
                 name='Read')

    ReadEmpty_elt = Element('ReadEmpty_elt', pulsar=station.pulsar)
    ReadEmpty_elt.add(SquarePulse(name='square_read',
                                  channel='ch1',
                                  amplitude=V_read,
                                  start=0,
                                  length=t_read),
                      name='Read')
    ReadEmpty_elt.add(SquarePulse(name='square_empty',
                                  channel='ch1',
                                  amplitude=V_empty,
                                  start=0,
                                  length=t_empty),
                      name='Empty',
                      refpulse='Read',
                      refpoint='end',
                      refpoint_new='start')

    elts = [Empty_elt, Load_elt, Read_elt, ReadEmpty_elt]

    T1_seq = Sequence('T1_Sequence')

    T1_seq.append('Empty_0', 'Empty_elt')

    for i in range(Npoints):

        name_Load = 'Load_{}'.format(i)
        name_ReadEmpty = 'ReadEmpty_{}'.format(i)
        T1_seq.append(name_Load, 'Load_elt', repetitions=i + 1)
        T1_seq.append(name_ReadEmpty, 'ReadEmpty_elt')

    ss = station.pulsar.program_awg(T1_seq, *elts)

    win = show_element_pyqt(ReadEmpty_elt,
                            QtPlot_win=None,
                            color_idx=None,
                            channels=['ch1', 'ch2', 'ch3', 'ch4'])
    ch1_wf = test_elt.waveforms()[1]['ch1']