示例#1
0
def vsaplay():
    global vsasess, vsasn, vsasr
    t = [(i + 1) / vsasr for i in range(vsasn)]
    average = int(request.args.get('average'))

    if average: avenum = int(request.args.get('avenum'))
    else: avenum = 1

    # Start Measure Loop:
    iqdata = []
    for i in range(avenum):
        VSA.Arm_Measure(vsasess)
        gd = VSA.Get_Data(vsasess, 2 * vsasn)
        iqdata.append(gd[1]['ComplexData'])
        nloop = i
    iqdata = mean(array(iqdata), axis=0)

    I, Q, Amp, Pha = IQAParray(iqdata)
    A = [sqrt(i**2 + q**2) for (i, q) in zip(I, Q)]

    log = pauselog()  #disable logging (NOT applicable on Apache)
    return jsonify(nIQpair=vsasn,
                   nloop=nloop,
                   log=str(log),
                   t=t,
                   I=list(I),
                   Q=list(Q),
                   A=list(A),
                   Amp=list(Amp),
                   Pha=list(Pha))
示例#2
0
def SQE_Pulse(user,
              tag="",
              corder={},
              comment='',
              dayindex='',
              taskentry=0,
              resumepoint=0,
              instr=['YOKO', 'PSGV', 'PSGA', 'AWG', 'VSA'],
              testeach=False):
    '''Time-domain Square-wave measurement:
    C-Structure: ['Flux-Bias', 
                    'Average', 'Pulse-Period', 'ADC-delay', 
                    'LO-Frequency', 'LO-Power', 'RO-Frequency', 'RO-Power', 'RO-ifLevel', 'RO-Pulse-Delay', 'RO-Pulse-Width', 
                    'XY-Frequency', 'XY-Power', 'XY-ifLevel', 'XY-Pulse-Delay', 'XY-Pulse-Width', 
                    'Sampling-Time'] (IQ-Bandwidth (250MHz or its HALFlings) + Acquisition-Time (dt must be multiples of 2ns))
    '''
    # Loading sample:
    sample = get_status("MSSN")[session['user_name']]['sample']
    # sample = get_status("MSSN")['abc']['sample'] # by-pass HTTP-request before interface is ready

    # pushing pre-measurement parameters to settings:
    yield user, sample, tag, instr, corder, comment, dayindex, taskentry, testeach

    # ***USER_DEFINED*** Controlling-PARAMETER(s) ======================================================================================
    structure = corder['C-Structure']
    fluxbias = waveform(corder['Flux-Bias'])
    averaging = waveform(corder['Average'])
    pperiod = waveform(corder['Pulse-Period'])
    adcdelay = waveform(corder['ADC-delay'])
    lofreq = waveform(corder['LO-Frequency'])
    lopowa = waveform(corder['LO-Power'])
    rofreq = waveform(corder['RO-Frequency'])
    ropowa = waveform(corder['RO-Power'])
    roiflevel = waveform(corder['RO-ifLevel'])
    ropdelay = waveform(corder['RO-Pulse-Delay'])
    ropwidth = waveform(corder['RO-Pulse-Width'])
    xyfreq = waveform(corder['XY-Frequency'])
    xypowa = waveform(corder['XY-Power'])
    xyiflevel = waveform(corder['XY-ifLevel'])
    xypdelay = waveform(corder['XY-Pulse-Delay'])
    xypwidth = waveform(corder['XY-Pulse-Width'])
    samptime = waveform(corder['Sampling-Time'])

    # Total data points:
    datasize = int(
        prod([waveform(corder[param]).count for param in structure],
             dtype='uint64')) * 2  #data density of 2 due to IQ
    print("data size: %s" % datasize)

    # Pre-loop settings:
    # Optionals:
    # YOKO:
    if "opt" not in fluxbias.data:  # check if it is in optional-state / serious-state
        yokog = YOKO.Initiate(current=True)  # pending option
        YOKO.output(yokog, 1)

    # PSGV:
    if "opt" not in xyfreq.data:  # check if it is in optional-state / serious-state
        sogo = PSG0.Initiate()  # pending option
        PSG0.rfoutput(sogo, action=['Set', 1])

    # Basics:
    # PSGA for LO:
    saga = PSG1.Initiate()  # pending option
    PSG1.rfoutput(saga, action=['Set', 1])

    # AWG for Control:
    awgsess = AWG.InitWithOptions()
    AWG.Abort_Gen(awgsess)
    AWG.ref_clock_source(awgsess,
                         action=['Set',
                                 int(1)])  # External 10MHz clock-reference
    AWG.predistortion_enabled(awgsess, action=['Set', True])
    AWG.output_mode_adv(awgsess, action=['Set',
                                         int(2)])  # Sequence output mode
    AWG.arb_sample_rate(awgsess,
                        action=['Set',
                                float(1250000000)])  # maximum sampling rate
    AWG.active_marker(awgsess, action=['Set', '1'])  # master
    AWG.marker_delay(awgsess, action=['Set', float(0)])
    AWG.marker_pulse_width(awgsess, action=['Set', float(1e-7)])
    AWG.marker_source(awgsess, action=['Set', int(7)])
    # PRESET Output:
    for ch in range(2):
        channel = str(ch + 1)
        AWG.output_config(awgsess, RepCap=channel, action=["Set",
                                                           0])  # Single-ended
        AWG.output_filter_bandwidth(awgsess, RepCap=channel, action=["Set", 0])
        AWG.arb_gain(awgsess, RepCap=channel, action=["Set", 0.5])
        AWG.output_impedance(awgsess, RepCap=channel, action=["Set", 50])
    # output settings:
    for ch in range(2):
        channel = str(ch + 1)
        AWG.output_enabled(awgsess, RepCap=channel, action=["Set",
                                                            int(1)])  # ON
        AWG.output_filter_enabled(awgsess,
                                  RepCap=channel,
                                  action=["Set", True])
        AWG.output_config(awgsess, RepCap=channel,
                          action=["Set", int(2)])  # Amplified 1:2
        AWG.output_filter_bandwidth(awgsess, RepCap=channel, action=["Set", 0])
        AWG.arb_gain(awgsess, RepCap=channel, action=["Set", 0.5])
        AWG.output_impedance(awgsess, RepCap=channel, action=["Set", 50])

    # VSA for Readout
    vsasess = VSA.InitWithOptions()

    # Buffer-size for lowest-bound data-collecting instrument:
    buffersize_1 = samptime.count * 2  #data density of 2 due to IQ
    print("Buffer-size: %s" % buffersize_1)

    # User-defined Measurement-FLOW ==============================================================================================
    if testeach:  # measure-time contribution from each measure-loop
        loopcount, loop_dur = [], []
        stage, prev = clocker(0)  # Marking starting point of time

    # Registerring parameter(s)-structure
    cstructure = [waveform(corder[param]).count for param in structure
                  ][:-1]  # The last one will become a buffer
    print('cstructure: %s' % cstructure)

    measure_loop_1 = range(
        resumepoint // buffersize_1, datasize //
        buffersize_1)  # saving chunck by chunck improves speed a lot!
    while True:
        for i in measure_loop_1:
            print(Back.BLUE + Fore.WHITE + 'measure %s/%s' %
                  (i, datasize // buffersize_1))
            # determining the index-locations for each parameters, i.e. the address at any instance
            caddress = cdatasearch(i, cstructure)

            # setting each c-order (From High to Low level of execution):
            # ***************************************************************
            for j in range(
                    len(cstructure) -
                    1):  # the last one will be run for every i (common sense!)
                if (
                        not i % prod(cstructure[j + 1::])
                ) or i == resumepoint // buffersize_1:  # virtual for-loop using exact-multiples condition
                    # print("entering %s-stage" %j)
                    # Optionals:
                    # YOKO
                    if structure[j] == 'Flux-Bias':
                        if "opt" not in fluxbias.data:  # check if it is in optional-state
                            if testeach:  # adding instrument transition-time between set-values:
                                loopcount += [fluxbias.count]
                                if fluxbias.count > 1:
                                    loop_dur += [
                                        abs(fluxbias.data[0] -
                                            fluxbias.data[1]) / 0.2 + 35 * 1e-3
                                    ]  # manually calculating time without really setting parameter on the instrument
                                else:
                                    loop_dur += [0]
                                stage, prev = clocker(stage,
                                                      prev)  # Marking time
                            else:
                                YOKO.sweep(
                                    yokog,
                                    str(fluxbias.data[caddress[structure.index(
                                        'Flux-Bias')]]),
                                    pulsewidth=77 * 1e-3,
                                    sweeprate=0.0007
                                )  # A-mode: sweeprate=0.0007 A/s ; V-mode: sweeprate=0.07 V/s

                    # PSG
                    if structure[j] == 'XY-Frequency':
                        if "opt" not in xyfreq.data:  # check if it is in optional-state
                            PSG0.frequency(
                                sogo,
                                action=[
                                    'Set',
                                    str(xyfreq.data[caddress[structure.index(
                                        'XY-Frequency')]]) + "GHz"
                                ])
                    if structure[j] == 'XY-Power':
                        if "opt" not in xypowa.data:  # check if it is in optional-state
                            PSG0.power(sogo,
                                       action=[
                                           'Set',
                                           str(xypowa.data[caddress[
                                               structure.index('XY-Power')]]) +
                                           "dBm"
                                       ])
                    if structure[j] == 'RO-Frequency':
                        if "opt" not in rofreq.data:  # check if it is in optional-state
                            PSG1.frequency(
                                saga,
                                action=[
                                    'Set',
                                    str(rofreq.data[caddress[structure.index(
                                        'RO-Frequency')]]) + "GHz"
                                ])
                    if structure[j] == 'RO-Power':
                        if "opt" not in ropowa.data:  # check if it is in optional-state
                            PSG1.power(saga,
                                       action=[
                                           'Set',
                                           str(ropowa.data[caddress[
                                               structure.index('RO-Power')]]) +
                                           "dBm"
                                       ])

            # AWG (Every-loop)
            if "opt" not in pperiod.data:  # check if it is in optional-state
                AWG.Clear_ArbMemory(awgsess)
                WAVE = []

                # construct waveform:
                ifperiod = pperiod.data[caddress[structure.index(
                    'Pulse-Period')]]
                ifscale = float(
                    xyiflevel.data[caddress[structure.index('XY-ifLevel')]]
                ), float(
                    roiflevel.data[caddress[structure.index('RO-ifLevel')]])

                if "lockxypwd" in str(ropdelay.data[0]):
                    if '+' in str(ropdelay.data[0]):
                        rooffset = float(ropdelay.data[0].split('+')[1])
                    else:
                        rooffset = 0  # default value
                    ifdelay = float(xypdelay.data[caddress[structure.index(
                        'XY-Pulse-Delay')]]), float(xypwidth.data[caddress[
                            structure.index('XY-Pulse-Width')]]) + rooffset
                    print("RO-Pulse Delays behind XY-Pulse for %sns" %
                          (ifdelay[1] - ifdelay[0]))
                else:
                    ifdelay = float(xypdelay.data[caddress[structure.index(
                        'XY-Pulse-Delay')]]), float(ropdelay.data[caddress[
                            structure.index('RO-Pulse-Delay')]])

                ifontime = float(
                    xypwidth.data[caddress[structure.index('XY-Pulse-Width')]]
                ), float(
                    ropwidth.data[caddress[structure.index('RO-Pulse-Width')]])
                for ch in range(2):
                    channel = str(ch + 1)
                    wavefom = squarewave(ifperiod, ifontime[ch], ifdelay[ch],
                                         ifscale[ch])  # in ns
                    stat, wave = AWG.CreateArbWaveform(awgsess, wavefom)
                    print('Waveform channel %s: %s <%s>' %
                          (channel, wave, status_code(stat)))
                    WAVE.append(wave)
                # Building Sequences:
                for ch in range(2):
                    channel = str(ch + 1)
                    status, seqhandl = AWG.CreateArbSequence(
                        awgsess, [WAVE[ch]], [1]
                    )  # loop# canbe >1 if longer sequence is needed in the future!
                    # print('Sequence channel %s: %s <%s>' %(channel, seqhandl, status_code(status)))
                    # Channel Assignment:
                    stat = AWG.arb_sequence_handle(awgsess,
                                                   RepCap=channel,
                                                   action=["Set", seqhandl])
                    # print('Sequence channel %s embeded: %s <%s>' %(channel, stat[1], status_code(stat[0])))
                # Trigger Settings:
                for ch in range(2):
                    channel = str(ch + 1)
                    AWG.operation_mode(awgsess,
                                       RepCap=channel,
                                       action=["Set", 0])
                    AWG.trigger_source_adv(awgsess,
                                           RepCap=channel,
                                           action=["Set", 0])
                AWG.Init_Gen(awgsess)
                AWG.Send_Pulse(awgsess, 1)

            # Basic / Buffer:
            # VSA (Every-loop)
            VSA.acquisition_time(vsasess,
                                 action=['Set',
                                         float(samptime.count * 2e-9)
                                         ])  # minimum time resolution
            VSA.preselector_enabled(vsasess, action=[
                'Set', False
            ])  # disable preselector to allow the highest bandwidth of 250MHz

            if "lockro" in str(lofreq.data[0]):
                if '+' in str(lofreq.data[0]):
                    lof_offset = float(lofreq.data[0].split('+')[1])
                elif '-' in str(lofreq.data[0]):
                    lof_offset = -float(lofreq.data[0].split('-')[1])
                else:
                    lof_offset = 0  # default value
                VSA.frequency(vsasess,
                              action=[
                                  'Set',
                                  float(rofreq.data[caddress[structure.index(
                                      'RO-Frequency')]]) * 1e9 + lof_offset
                              ])  # freq offset / correction in Hz
                print("Locking on RO at %sGHz" %
                      (VSA.frequency(vsasess)[1] / 1e9))
            else:
                VSA.frequency(vsasess,
                              action=[
                                  'Set',
                                  float(lofreq.data[caddress[structure.index(
                                      'LO-Frequency')]]) * 1e9
                              ])

            VSA.power(
                vsasess,
                action=[
                    'Set',
                    float(lopowa.data[caddress[structure.index('LO-Power')]])
                ])
            VSA.bandwidth(
                vsasess, action=['Set', 250e6]
            )  # maximum LO bandwidth of 250MHz (500MHz Sampling-rate gives 2ns of time resolution)
            VSA.trigger_source(vsasess,
                               action=['Set',
                                       int(1)])  # External Trigger (slave)

            # Delay for Readout
            if "lockxypwd" in str(ropdelay.data[0]):
                # trigger-delay sync with xy-pulse-width for Rabi measurement:
                VSA.trigger_delay(vsasess, action=['Set', float(adcdelay.data[caddress[structure.index('ADC-delay')]]) + \
                    float(xypwidth.data[caddress[structure.index('XY-Pulse-Width')]])*1e-9 + rooffset*1e-9])
                print("ACQ delays with XY-Pulse for %sns" %
                      int(VSA.trigger_delay(vsasess)[1] / 1e-9))
            elif "lockropdelay" in str(adcdelay.data[0]):
                # trigger-delay sync with ro-pulse-delay for T1 measurement:
                VSA.trigger_delay(
                    vsasess,
                    action=[
                        'Set',
                        float(ropdelay.data[caddress[structure.index(
                            'RO-Pulse-Delay')]]) * 1e-9
                    ])
                print("ACQ delays with RO-Pulse for %sns" %
                      int(VSA.trigger_delay(vsasess)[1] / 1e-9))
            else:
                VSA.trigger_delay(vsasess,
                                  action=[
                                      'Set',
                                      float(adcdelay.data[caddress[
                                          structure.index('ADC-delay')]])
                                  ])

            VSA.external_trigger_level(vsasess, action=['Set', float(0.3)])
            VSA.external_trigger_slope(vsasess,
                                       action=['Set',
                                               int(1)])  # Positive slope
            VSA.trigger_timeout(vsasess, action=['Set',
                                                 int(1000)])  # 1s of timeout
            stat = VSA.Init_Measure(vsasess)  # Initiate Measurement

            # Start Quantum machine:
            # Start Averaging Loop:
            avenum = int(averaging.data[caddress[structure.index('Average')]])
            vsasn = VSA.samples_number(vsasess)[1]
            iqdata = zeros((avenum, 2 * vsasn))
            for ave in range(avenum):
                VSA.Arm_Measure(vsasess)
                gd = VSA.Get_Data(vsasess, 2 * vsasn)
                iqdata[ave, :] = array(gd[1]['ComplexData'])
            iqdata = mean(iqdata, axis=0)
            print("Operation Complete")
            print(Fore.YELLOW + "\rProgress: %.3f%%" %
                  ((i + 1) / datasize * buffersize_1 * 100),
                  end='\r',
                  flush=True)

            # test for the last loop if there is
            if testeach:  # test each measure-loop:
                loopcount += [len(measure_loop_1)]
                loop_dur += [time() - prev]
                stage, prev = clocker(stage, prev)  # Marking time
                VSA.close(vsasess)
                if "opt" not in pperiod.data:  # check if it is in optional-state
                    AWG.close(awgsess)
                if "opt" not in xyfreq.data:  # check if it is in optional-state
                    PSG0.close(sogo, False)
                if "opt" not in rofreq.data:  # check if it is in optional-state
                    PSG1.close(saga, False)
                if "opt" not in fluxbias.data:  # check if it is in optional-state
                    YOKO.close(yokog, False)
                yield loopcount, loop_dur

            else:
                if get_status("SQE_Pulse")['pause']:
                    break
                else:
                    yield list(iqdata)

        if not get_status("SQE_Pulse")['repeat']:
            set_status("SQE_Pulse", dict(pause=True))
            VSA.close(vsasess)
            if "opt" not in pperiod.data:  # check if it is in optional-state
                AWG.Abort_Gen(awgsess)
                AWG.close(awgsess)
            if "opt" not in xyfreq.data:  # check if it is in optional-state
                PSG0.rfoutput(sogo, action=['Set', 0])
                PSG0.close(sogo, False)
            if "opt" not in rofreq.data:  # check if it is in optional-state
                PSG1.rfoutput(saga, action=['Set', 0])
                PSG1.close(saga, False)
            if "opt" not in fluxbias.data:  # check if it is in optional-state
                YOKO.output(yokog, 0)
                YOKO.close(yokog, False)
            return