Python envelopehelpers.mix函数代码示例

 def func(server, delay):
     reqs = []
     for controlPi in [False,True]:
         t = 0
         qC.xy = qC.z = env.NOTHING
         if controlPi:
             qC.xy += eh.boostState(qC, t, controlState)
             t += (controlState-0.5)*qC['piLen'] + 0.5*qM['piLen']
         qM.xy = eh.boostState(qM, t, measureState-1)
         t += (measureState-1)*qM['piLen']
         qM.xy += eh.mix(qM, eh.piHalfPulse(qM, t, phase=0.0, state=measureState), state=measureState)
         t += delay
         qM.xy += eh.mix(qM, eh.piHalfPulse(qM, t, phase = 2*np.pi*(fringeFreq['GHz']*delay['ns']), state=measureState), state=measureState)
         t += 0.5*qM['piLen']
         qM.z = eh.measurePulse(qM, t, state=measureState)
         if controlPi:
             qM['readout'] = True
             qC['readout'] = True
             qC.z += eh.measurePulse(qC, t, state=controlState)
             if control < measure:
                 probsReadout = [2,3]
             else:
                 probsReadout = [1,3]
         else:
             probsReadout = [1]
             qM['readout'] = True
             qC['readout'] = False
         reqs.append(runQubits(server, qubits, stats, probs=probsReadout))
     probs = yield FutureList(reqs)
     data = []
     for probset in probs:
         data += probset
     problist = [data[0],data[1],data[2]]
     returnValue(data)

 def func(server, targetAmp):
     start = 0
     #state prep
     #Control g -> e
     qc.xy = eh.mix(qc, eh.piPulseHD(qc, start))
     start += qc['piLen']/2    
     #Control iSWAP with Resonator 
     qc.z = env.rect(start, qc.cZControlLen, qt.cZControlAmp)
     start += qt.cZControlLen
     #state prep Target
     qt.xy = eh.mix(qt, eh.piHalfPulseHD(qt, start))
     start += qt['piLen']/2       
     #Target Phase swap Q21 with R21 for iswap^2 time
     qt.z = env.rect(start, qt.cZTargetLen, qc.cZTargetAmp)
     start += qt.cZTargetLen
     
     #Target phase correction, time is fixed sweeping amplitude 
     qt.z += env.rect(start, qt.cZTargetPhaseCorrLen, targetAmp)
     start += qt.cZTargetPhaseCorrLen + qt['piLen']/2
     #Final pi/2 for Ramsey, rotate about X
     qt.xy += eh.mix(qt, eh.piHalfPulseHD(qt, start, phase=0.0*np.pi))
     start += qt['piLen']/2    
         
     #Measure
     qt.z += eh.measurePulse(qt, start)
     
     qt['readout'] = True
     
     return runQubits(server, qubits, stats=stats, probs=[1])

 def func(server, fraction):
     if useHD:
         q.xy = eh.mix(q, eh.rotPulseHD(q, 0, angle=fraction*np.pi/np.sqrt(2)))
     else:
         q.xy = eh.mix(q, env.gaussian(0, q['piFWHM'], amp=fraction*q['piAmp']/np.sqrt(2)))
     q.z = eh.rotPulseZ(q, 0, angle=fraction*np.pi/np.sqrt(2))
     return measureFunc(server, qubits, q['piLen']/2, stats=stats)

    def func(server, mpa):
        t_pi = 0
        t_meas = q['piLen']/2.0
        
        # without pi-pulse
        q['readout'] = True
        q['measureAmp'] = mpa
        q.xy = env.NOTHING
        q.z = eh.measurePulse(q, t_meas)
        req0 = runQubits(server, qubits, stats, probs=[1])
        
        # with pi-pulse
        q['readout'] = True
        q['measureAmp'] = mpa
        q.xy = eh.mix(q, eh.piPulseHD(q, t_pi))
        q.z = eh.measurePulse(q, t_meas)
        req1 = runQubits(server, qubits, stats, probs=[1])

        # |2> with pi-pulse
        q['readout'] = True
        q['measureAmp'] = mpa
        q.xy = eh.mix(q, eh.piPulseHD(q, t_pi-q.piLen))+eh.mix(q, env.gaussian(t_pi, q.piFWHM, q.piAmp21, df=q.piDf21), freq = 'f21')
        q.z = eh.measurePulse(q, t_meas)
        req2 = runQubits(server, qubits, stats, probs=[1])
        
        probs = yield FutureList([req0, req1, req2])
        p0, p1, p2 = [p[0] for p in probs]
        
        returnValue([p0, p1, p1-p0, p2, p2-p1])

 def func(server, len, amp, measureDelay):
     if useHd:
         q.xy = eh.mix(q, eh.rabiPulseHD(q, 0, len, amp=amp, width=turnOnWidth))
     else:
         q.xy = eh.mix(q, env.flattop(0, len, w=turnOnWidth, amp=amp))
     if not check2State:
         q.z = eh.measurePulse(q, measureDelay+len)
     else:
         q.z = eh.measurePulse2(q, measureDelay+len)
     q['readout'] = True
     return runQubits(server, qubits, stats, probs=[1])

 def func(server, delay):
     qubit.xy = eh.mix(qubit, eh.piPulseHD(qubit, 0))
     qubit.z = env.rect(qubit.piLen/2, swapTime, swapAmp) 
     qubit.z += env.rect(qubit.piLen/2+swapTime+delay, swapTime, swapAmp)
     qubit.z += eh.measurePulse(qubit, qubit.piLen/2+swapTime+delay+swapTime)
     qubit['readout'] = True
     return runQubits(server, qubits, stats, probs=[1])

 def func(server, phase, t_couple):
     dt = max(q['piLen'] for q in qubits)
     if t0 is None:
         tp0 = 0
         tz = dt/2
     else:
         tp0 = t0 - dt/2
         tz = t0
     tm = tz + t_couple + dt/2
     
     for i, (q, zpa) in enumerate(zip(qubits, zpas)):
         q['uwavePhase'] = 0 # turn off automatic phase correction
         
         if i == adjust:
             xy = eh.piHalfPulse(q, tp0) * np.exp(1j*phase)
         elif i == ref:
             xy = eh.piHalfPulse(q, tp0)
         else:
             xy = env.NOTHING
         
         q.xy = eh.mix(q, xy)
         q.z = env.rect(tz, t_couple, zpa, overshoot=q['wZpulseOvershoot'])
     
     eh.correctCrosstalkZ(qubits)
     return measure(server, qubits, tm, stats=stats)

 def addTomoPulse(q, rot):
     """Add a tomography pulse to the microwave sequence for one qubit."""
     _name, angle, axis = rot
     phase = axis + q['tomoPhase']
     pulse = eh.mix(q, eh.rotPulse(q, tp, angle=angle, phase=phase))
     xy = q.get('xy', env.NOTHING) + pulse
     return q.where(xy=xy)

 def addRotation(q, rot):
     """Add rotation pulse to a single qubit."""
     if rot is None:
         return q
     angle, axis = rot
     phase = axis + q['tomoPhase']
     pulse = eh.mix(q, eh.rotPulse(q, tp, angle=angle, phase=phase))
     return q.where(xy=q.get('xy', env.NOTHING) + pulse)

 def func(server, delay):
     start = 0*ns
     q.xy = eh.mix(q, eh.piPulse(q, start))
     start+=q.piLen
     q.z = env.rect(start, delay+q['measureLenTop']+q['measureLenFall'], zpa)
     start+=delay
     q.z += env.trapezoid(start, 0, q['measureLenTop'], q['measureLenFall'], q['measureAmp']-zpa)
     q['readout'] = True
     return runQubits(server, qubits, stats, probs=[1])