def __init__(self, Ipulse, Qpulse, pi_amp, pi2_amp=0, chans=(0, 1), marker_chan='m1', marker_val=2, marker_pad=0): if marker_pad != 0: mp = np.zeros(marker_pad) Ipulse = sequencer.Pulse(Ipulse.name + '_pad%s' % len(mp), data=np.concatenate([mp, Ipulse.data, mp])) sequencer.Sequence([sequencer.Delay(marker_pad), Ipulse]) if Ipulse: Ipulse = Ipulse.rendered() if Qpulse: Qpulse = Qpulse.rendered() self.Ipulse = Ipulse self.Qpulse = Qpulse self.ampgen = ampgen.AmpGen() self.set_pi_amp(pi_amp, pi2_amp) self.chans = chans self.marker_chan = marker_chan self.marker_val = marker_val self.marker_pad = marker_pad super(FPGAAmplitudeRotation, self).__init__()
def MeasurementPulse(pulselen=200, delay=0, ro_delay=0, **kwargs): label = kwargs.pop('label', None) cb = sequencer.Combined([ sequencer.Constant(pulselen, 2, chan='m0'), sequencer.Sequence([ sequencer.Delay(delay), sequencer.Constant(40, 1, chan='master', **kwargs), sequencer.Constant(220, 2, chan='master', **kwargs) ]), ], label=label, align=sequencer.ALIGN_LEFT) if ro_delay == 0: return cb else: return sequencer.Sequence([sequencer.Delay(ro_delay), cb])
def get_readout_pulse(self, pulse_len=None): if pulse_len is None: pulse_len = self.readout_info.pulse_len if not hasattr(self.readout_info, 'flux_chan'): return sequencer.Combined([ pulselib.Constant(pulse_len, 1, chan=self.readout_info.readout_chan), pulselib.Constant(pulse_len, 1, chan=self.readout_info.acq_chan), ]) else: flux_pulse = lambda duration, flux_level: pulselib.Constant(duration, flux_level, chan=self.readout_info.flux_chan) s = sequencer.Sequence() s.append(flux_pulse(self.readout_info.pre_flux_len, self.readout_info.ro_flux_amp)) s.append(sequencer.Combined([ pulselib.Constant(self.readout_info.pulse_len, 1, chan=self.readout_info.readout_chan), pulselib.Constant(self.readout_info.pulse_len, 1, chan=self.readout_info.acq_chan), flux_pulse(self.readout_info.pulse_len, self.readout_info.ro_flux_amp) ])) s.append(flux_pulse(self.readout_info.post_flux_len, self.readout_info.ro_flux_amp)) #This is required so that after one expt and before the next trigger #we chill at zero flux. s.append(flux_pulse(2000,0)) # this is extended to return s
def load_test_waveform(self): self.awg.delete_all_waveforms() self.awg.get_id() #Sometimes AWGs are slow. If it responds it's ready. length = abs(int(1e9/self.if_freq *100)) qubit_info = mclient.get_qubit_info(self.qubit_info.get_name()) s = sequencer.Sequence() s.append(sequencer.Combined([ sequencer.Constant(length, 0.25, chan=qubit_info.sideband_channels[0]), sequencer.Constant(length, 0.25, chan=qubit_info.sideband_channels[1])])) s = sequencer.Sequencer(s) s.add_ssb(qubit_info.ssb) seqs = s.render() self.seqs = seqs l = awgloader.AWGLoader(bulkload=config.awg_bulkload) base = 1 for i in range(1, 5): awg = instruments['AWG%d'%i] if awg: chanmap = {1:base, 2:base+1, 3:base+2, 4:base+3} logging.info('Adding AWG%d, channel map: %s', i, chanmap) l.add_awg(awg, chanmap) base += 4 l.load(seqs) l.run()
def LongMeasurementPulse(pulselen=None, rolen=None, reflen=None, ro_delay=0, pulse_pump=False, **kwargs): sequencer.Pulse.RANGE_ACTION = sequencer.IGNORE label = kwargs.pop('label', None) if pulselen is None: pulselen = ro_ins.get_pulse_len() if rolen is None: rolen = ro_ins.get_acq_len() if reflen is None: reflen = ro_ins.get_ref_len() ro = sequencer.Constant(reflen, 3, chan='master', **kwargs) kwargs.pop('master_integrate', None) # Remove integrate from kwargs if reflen != rolen: ro = sequencer.Sequence([ ro, sequencer.Constant(rolen - reflen, 2, chan='master', **kwargs) ]) if pulse_pump: cb = sequencer.Sequence([ sequencer.Constant(800, 1, chan='m1'), sequencer.Combined([ sequencer.Constant(pulselen, 2, chan='m0'), sequencer.Constant(rolen, 1, chan='m1'), ro, ], align=sequencer.ALIGN_LEFT) ], label=label) else: cb = sequencer.Combined([ sequencer.Constant(pulselen, 2, chan='m0'), ro, ], label=label, align=sequencer.ALIGN_LEFT) if ro_delay == 0: return cb else: return sequencer.Sequence([sequencer.Delay(ro_delay), cb])
def cavity_cool(m, NCONVINCE=4, label='qccool', tgtlabel=None): ''' Qubit/cavity |gg> cooling sequence. If <tgtlabel> is None, a function return will be generated at the end, otherwise the sequence jumps to <tgtlabel> on completion. Uses registers R1, R2 and counter0 ''' if tgtlabel: retlabel = tgtlabel else: retlabel = label + '_ret' s = sequencer.Sequence() s.append(sequencer.Delay(1000, label=label, master_integrate=m.integrate_nolog, master_counter0=NCONVINCE)) s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), label='_')) # First measurement, store result in R1, 0 = |g>, 1 = |e> s.append(fpgapulses.LongMeasurementPulse()) s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), length=220, master_internal_function=ye.FPGASignals.s0, jump=(label+'_setR1_0', label+'_setR1_1'))) s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(1, 0), label=label+'_setR1_0', jump=label+'_M2')) s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(1, 1), label=label+'_setR1_1')) # Second measurement, store result in R2, 0 = |g>, 1 = |e> s.append(m.qubit.rotate_selective(np.pi,0,label=label+'_M2')) s.append(fpgapulses.LongMeasurementPulse()) s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), length=220, master_internal_function=ye.FPGASignals.s0, jump=(label+'_setR2_0', label+'_setR2_1'))) s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(2, 0), label=label+'_setR2_0', jump=label+'_decide')) s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(2, 1), label=label+'_setR2_1')) # Compare R1 and R2 s.append(fpgapulses.RegOp(ye.RegisterInstruction.CMP(1, 2), master_internal_function=ye.FPGASignals.r0, label=label+'_decide', jump=(label+'_same', label+'_diff'))) # If the same: reset counter, move last outcome to R1 and re-measure s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOV(1, 2), master_counter0=NCONVINCE, jump=label+'_M2', label=label+'_same')) # If different: decrease counter, move last outcome to R1 and goto remeasure if counter not zero s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOV(1, 2), master_counter0=-1, master_internal_function=ye.FPGASignals.c0, jump=('next', label+'_M2'), label=label+'_diff')) # We're almost good, make sure we are actually in |g>, if so jump to start s.append(fpgapulses.RegOp(ye.RegisterInstruction.CMPI(1, 0), master_internal_function=ye.FPGASignals.r0, jump=(retlabel, 'next'))) # s.append(fpgapulses.RegOp(ye.RegisterInstruction.CMPI(1, 0), master_internal_function=ye.FPGASignals.r0, jump=(label+'_qcool', 'next'))) # Otherwise, set counter to 1 and remeasure s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), master_counter0=1, jump=label+'_M2')) if tgtlabel is None: s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), callreturn=True, label=retlabel)) return s
def long_delay(length, block_size, label): s = sequencer.Sequence() if (length % block_size) != 0: raise Exception('Length not an integer multiple of block size') nblocks = length / block_size if nblocks > 2**17: raise Exception('Too many blocks requested!') s.append( RegOp(RegisterInstruction.MOVI(4, nblocks), label='init_%s' % label)) s.append( RegOp(RegisterInstruction.ADDI(4, -1), length=block_size, label='loop_%s' % label)) s.append( RegOp(RegisterInstruction.CMPI(4, 0), master_internal_function=FPGASignals.r0, jump=('done_%s' % label, 'loop_%s' % label))) s.append(sequencer.Delay(256, label='done_%s' % label)) return s
def __call__(self, alpha, amp=None, plot=False, **kwargs): ''' Generate a rotation pulse of angle <alpha> around axis <phase>. If <amp> is specified that amplitude is used and <alpha> is ignored. ''' self.determine_correction() sequencer.Pulse.RANGE_ACTION = sequencer.IGNORE data = self.get_pulse_data() name = self.get_pulse_name() Ipulse = sequencer.Pulse('%s_I' % name, np.real(data), chan=self.chans[0]).rendered() Qpulse = sequencer.Pulse('%s_Q' % name, np.imag(data), chan=self.chans[1]).rendered() if plot: plt.figure() plt.plot(self.pulse.data) plt.plot(np.real(data)) plt.plot(np.imag(data)) plt.plot(2 * np.arange(len(data) / 2), np.real(data[::2]), 'ks') plt.plot(2 * np.arange(len(data) / 2), np.imag(data[::2]), 'ro') pulses = [] Ipulse.set_params(mixer_amplitudes=(0xffff, 0), **kwargs) pulses.append(Ipulse) Qpulse.set_params(mixer_amplitudes=(0, 0xffff), **kwargs) pulses.append(Qpulse) if self.marker_chan is not None: mpulse = sequencer.Constant(pulses[0].get_length(), self.marker_val, chan=self.marker_chan, **kwargs) pulses.append(mpulse) if len(pulses) == 1: return sequencer.Sequence(pulses, **kwargs) else: return sequencer.Combined(pulses, **kwargs)
def qubit_cool(m, NCONVINCE=4, label='qcool', tgtlabel=None): ''' Qubit cooling sequence: measure |g> <NCONVINCE> times in a row. If <tgtlabel> is None, a function return will be generated at the end, otherwise the sequence jumps to <tgtlabel> on completion. Uses counter0 ''' if tgtlabel: retlabel = tgtlabel else: retlabel = label + '_ret' s = sequencer.Sequence() s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), master_integrate=m.integrate_nolog, master_counter0=NCONVINCE, label=label)) s.append(fpgapulses.LongMeasurementPulse(label=label+'_meas')) s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), length=220, master_internal_function=ye.FPGASignals.s0, jump=(label+'_decc0', 'next'))) # We measured |e>, reset counter and jump back to measure s.append(m.qubit.rotate(np.pi,0,jump=label+'_meas',master_counter0=NCONVINCE)) s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), master_counter0=-1, master_internal_function=ye.FPGASignals.c0, jump=(retlabel, label+'_meas'), label=label+'_decc0')) if tgtlabel is None: s.append(fpgapulses.RegOp(ye.RegisterInstruction., NCONVINCE=4NOP(), callreturn=True, label=retlabel)) return s
import time import fpgapulses import fpgameasurement import YngwieEncoding as ye N = 101 # Number of elements in sequence REPRATE_DELAY = 1200000 CAVPULSE = True DISP = np.sqrt(2) dfs = np.linspace(-14e6, 2e6, N) mask = (dfs != 0) periods = np.zeros_like(dfs) periods[mask] = 1e9 / dfs[mask] m = fpgameasurement.FPGAMeasurement('SSBspec', xs=dfs/1e6, fit_func='gaussian', rrec=False) s = sequencer.Sequence() # Old-style if 0: s.append(sequencer.Delay(240, label='start')) for period in periods: if CAVPULSE: # s.append(sequencer.Constant(500, 1, chan='m0')) s.append(m.cavity.displace(DISP)) s.append(m.qubit.rotate(np.pi, 0, detune_period=period)) s.append(fpgapulses.LongMeasurementPulse()) s.append(sequencer.Delay(REPRATE_DELAY)) s.append(sequencer.Delay(240, jump='start')) # New style, in logic a13 and up else:
def __call__(self, alpha, phase, amp=None, **kwargs): ''' Generate a rotation pulse of angle <alpha> around axis <phase>. If <amp> is specified that amplitude is used and <alpha> is ignored. ''' if amp is None: amp = self.ampgen(alpha) amp *= 65535.0 pulses = [] kwargs['chan%d_mixer_amplitudes' % self.chans[0]] = (np.cos(phase) * amp, np.sin(phase) * amp) kwargs['chan%d_mixer_amplitudes' % self.chans[1]] = (-np.sin(phase) * amp, np.cos(phase) * amp) if 'detune_period' in kwargs and kwargs['detune_period'] != 0: period = kwargs.pop('detune_period') ts = np.arange(len(self.Ipulse.data)) data = self.Ipulse.data * np.exp(2j * np.pi * ts / period) if 0: import matplotlib.pyplot as plt plt.figure() plt.plot(ts, np.real(data)) plt.plot(ts, np.imag(data)) plt.suptitle('period=%s' % period) Ipulse = sequencer.Pulse('%s_re%s' % (self.Ipulse.name, period), np.real(data), chan=self.chans[0]).rendered() Qpulse = sequencer.Pulse('%s_im%s' % (self.Ipulse.name, period), np.imag(data), chan=self.chans[1]).rendered() Ipulse.set_params(**kwargs) pulses.append(Ipulse) Qpulse.set_params(**kwargs) pulses.append(Qpulse) else: if self.Ipulse: p = copy.deepcopy(self.Ipulse) pulses.append(p) pulses[-1].chan = self.chans[0] pulses[-1].set_params(**kwargs) if not self.Qpulse: pulses.append( sequencer.Constant(self.Ipulse.get_length(), 1e-6, chan=self.chans[1])) pulses[-1].set_params( mixer_amplitudes=(-amp * np.sin(phase), amp * np.cos(phase)), **kwargs) if self.Qpulse: p = copy.deepcopy(self.Qpulse) pulses.append(p) pulses[-1].chan = self.chans[1] pulses[-1].set_params(**kwargs) sequencer.Pulse.RANGE_ACTION = sequencer.IGNORE if self.marker_chan is not None: mpulse = sequencer.Constant(pulses[0].get_length(), self.marker_val, chan=self.marker_chan, **kwargs) pulses.append(mpulse) if len(pulses) == 1: return sequencer.Sequence(pulses) else: return sequencer.Combined(pulses, **kwargs)
def measure(self): from scripts.single_qubit import spectroscopy from scripts.calibration import ropower_calibration from scripts.calibration import ro_power_cal from scripts.single_cavity import rocavspectroscopy from scripts.single_qubit import rabi from scripts.single_qubit import T1measurement from scripts.single_qubit import T2measurement from scripts.single_qubit import ssbspec_fit, stark_swap spec = lambda q_freqs, ro_freq, ro_power, yoko_set_val: \ spectroscopy.Spectroscopy( self.qubit_info, q_freqs, [self.qubit_rfsource, self.spec_power], # [ro_power], plen=self.plen, amp=self.amp, seq=self.seq, postseq=self.postseq, # pow_delay=self.pow_delay, extra_info=self.extra_info, freq_delay=self.freq_delay, plot_type=self.plot_type, title='Spec: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val), analyze_data=True, keep_data=True, use_IQge=self.use_IQge, use_weight=self.use_weight, subtraction=self.subtraction) SSBspec = lambda q_freqs, ro_freq, ro_power, yoko_set_val, b_freq, simulseq: \ ssbspec_fit.SSBSpec_fit( self.qubit_info, q_freqs, seq=self.seq, simulseq = simulseq, postseq = self.postseq, bgcor = self.spec_bgcor, extra_info=self.extra_info, title='Spec: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n brick_freq: %0.4e\n' % (ro_freq, ro_power, yoko_set_val, b_freq), generate = self.spec_generate, ) ropcal = lambda powers: ropower_calibration.ROPower_Calibration( self.qubit_info, powers, qubit_pulse=ropower_calibration.SAT_PULSE) orcpcal = lambda powers, curAmp, curplen: ro_power_cal.Optimal_Readout_Power( self.qubit_info, powers, plen=curplen, amp=curAmp, update_readout=True, verbose_plots=False, plot_best=False, shots=self.ro_shots) rospec = lambda power, ro_freqs: rocavspectroscopy.ROCavSpectroscopy(self.qubit_info, [power], ro_freqs) rb = lambda amps, ro_freq, ro_power, yoko_set_val: rabi.Rabi(self.qubit_info, amps, r_axis = 0, seq = None, postseq = None, plot_seqs=False, update=False, title='Rabi: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val), ) T1 = lambda delays, ro_freq, ro_power, yoko_set_val: T1measurement.T1Measurement(self.qubit_info, delays, double_exp=False, bgcor = self.T1_bgcor, title='T1: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val), ) T2 = lambda delays, detune, ro_freq, ro_power, yoko_set_val: T2measurement.T2Measurement(self.qubit_info, delays, detune, title='T2: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val), ) T2Echo = lambda delays, detune, ro_freq, ro_power, yoko_set_val: T2measurement.T2Measurement(self.qubit_info, delays, detune, echotype = T2measurement.ECHO_CPMG, fit_type = 'gaussian_decay', necho = 1, title='T2CPMG(N=1): (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val), ) PhT1 = lambda delays, ro_freq, ro_power, set_val: stark_swap.phonon_T1(self.qubit_info, delays, phonon_pi = self.Ph_piLength, amp = self.Ph_amp-set_val, sigma = self.Ph_sigma, title='T1: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, set_val), ) # initialize yoko to a known set_val if self.qubit_yoko != None: # if self.source_type == 'VOLT': # self.qubit_yoko.do_set_voltage(0) # elif self.source_type == 'CURR': # self.qubit_yoko.do_set_current(0) # else: # print 'source type needs to be VOLT or CURR' # return False self.qubit_yoko.set_output_state(1) # if self.stark_rfsource != None: # self.stark_rfsource.set_power(-40) # self.stark_rfsource.set_rf_on(1) time.sleep(1) if 'SPEC' in self.experiments: self.last_center = np.average(self.freqs) # middle point elif 'SSBSPEC' in self.experiments: self.last_center = self.qubit_rfsource.get_frequency()+self.sideband_freq # use current setting of brick self.next_center = self.qubit_rfsource.get_frequency()+self.sideband_freq elif self.qubit_freq_fxn!=None: self.last_center = self.qubit_freq_fxn(self.set_vals[0]) else: self.last_center = 0 #Not doing spec or changing frequency, so keeping same qubit frequency. Presumably this means we're not tuning pwr either, so this case should never be used. self.last_freq_tune_center = self.last_center self.last_pwr_tune_center = self.last_center self.ro_source.set_frequency(self.ro_freq) self.ro_source.set_power(self.ro_power) for idx, set_val in enumerate(self.set_vals): if self.source_type == 'VOLT': self.qubit_yoko.do_set_voltage(float(set_val)) elif self.source_type == 'CURR': self.qubit_yoko.do_set_current(float(set_val)) elif self.source_type == 'STARK': self.stark_rfsource.set_power(float(set_val)) elif self.source_type == 'STARK_V': if self.stark_V_channel == 'ch3': self.stark_rfsource.set_ch3_offset(float(set_val)) elif self.source_type == 'STARKSSB': self.simulseq = sequencer.Sequence(pulselib.GaussSquare(self.qubit_info.w_selective*4+2*self.starkw, float(set_val), self.starkw, chan = self.starkch)) time.sleep(1) self.yoko_set_vals[idx] = set_val # ro frequency if 'ROFREQ' in self.experiments: if ((self.ro_freq_tune != -1 and (idx % self.ro_freq_tune) == 0)\ or (self.ro_freq_tune == -1 and np.absolute(self.last_center-self.last_freq_tune_center) > self.ro_freq_tune_interval))\ and (self.ro_spec_range !=0): #tune if it's been ro_freq_tune runs or, if not, the qubit has shifted by ro_freq_tune_interval self.funcgen.set_frequency(5000) #rep rate self.alazar.set_naverages(3000) self.qubit_rfsource.set_rf_on(0) #in case rf source is resonant with qubit. This would mess up readout spec ro_freqs = np.linspace(self.ro_freq - self.ro_spec_range, self.ro_freq + self.ro_spec_range, 51) ro = rospec(self.ro_power, ro_freqs) ro.measure() plt.close() self.qubit_rfsource.set_rf_on(1) self.ro_freq = ro.fit_params[0][2] self.last_freq_tune_center = self.last_center elif self.ro_freq_fxn!=None: self.ro_freq = self.ro_freq_fxn(set_val) self.ro_source.set_frequency(self.ro_freq) self.ro_LO.set_frequency(self.ro_freq+50e6) self.ro_freq_log[idx] = self.ro_freq self.ro_pwr_log[idx] = self.ro_power # qubit saturation spec if 'SPEC' in self.experiments: self.funcgen.set_frequency(self.spec_funcgen_freq) #rep rate self.alazar.set_naverages(self.spec_avgs) spec_exp = spec(self.freqs, self.ro_freq, self.ro_power, set_val) spec_exp.measure() plt.close() center = spec_exp.fit_params['x0'].value * 1e6 width = spec_exp.fit_params['w'].value * 1e6 #save RO power, spec power, freqs, center, width, raw data.. # self.IQs[idx,:] = spec_exp.IQs[0,:] # self.amps[idx,:] = spec_exp.amps[0,:] self.IQs[idx,:] = spec_exp.IQs[:] self.amps[idx,:] = spec_exp.reals[:] # save spec fit and experiment parameter data self.widths[idx] = width self.spec_log[idx] = self.spec_power self.freqs_log[idx,:] = self.freqs #choose the next frequency range delta = center - self.last_center if self.freq_step == 0: # no step, keep the same frequency range self.freqs = self.freqs self.last_center = center elif idx == 0: # first point; don't try to stop self.freqs = self.freqs + delta + self.freq_step self.last_center = center else: # use 0th order estimator from last points # we will weight the frequency step to the expected direction # of the frequency step if self.freq_step > 0: # increasing freq ll, ul = np.array([-0.25, 1.25]) * self.freq_step else: # decreasing freq ll, ul = np.array([1.25, -0.25]) * self.freq_step #Commented out 9/3/14 Jacob, not quite right. # if not ll < delta < ul: # print 'quitting: we seem to have lost the qubit' # break #if the width is off, probably a sign that we're not fitting to qubit peak if not self.width_min*0.5 < width < self.width_max*2: print 'quitting: we seem to have lost the qubit' break # pick new frequency range such that the NEXT point should be centered q_freqs_center = np.average(self.freqs) # current point is centered self.freqs = self.freqs + (center - q_freqs_center) # blah = np.average(self.freqs) # offset to center next point self.freqs = self.freqs + delta # print 'debug: center: %0.3f, , last center: %0.3f, freq_step: %0.3f, , delta: %0.3f, ' %\ # (center, self.last_center, self.freq_step, delta) # print 'debug; current center: %0.3f, current pt center: %0.3f, next pt center: %0.3f' %\ # (q_freqs_center, blah, np.average(self.freqs)) self.last_center = center self.freq_step = delta # see if we should adjust spec power if width < self.width_min: self.amp *= 2 # self.spec_power += 1 elif width > self.width_max: self.amp /= 2 # self.spec_power -= 1 elif self.qubit_freq_fxn!=None: self.last_center = self.qubit_freq_fxn(set_val) self.qubit_rfsource.set_frequency(self.last_center) self.center_freqs[idx] = self.last_center # qubit SSB spec if 'SSBSPEC' in self.experiments: # self.qubit_inst.set_w(self.plen) # self.qubit_inst.set_pi_amp(self.amp) self.funcgen.set_frequency(self.spec_funcgen_freq) #rep rate self.alazar.set_naverages(self.spec_avgs) self.qubit_rfsource.set_frequency(self.next_center-self.sideband_freq) spec_exp = SSBspec(self.freqs, self.ro_freq, self.ro_power, set_val, self.qubit_rfsource.get_frequency(), self.simulseq) spec_exp.measure() plt.close() center = self.next_center + np.sign(self.sideband_freq)*spec_exp.fit_params['x0'].value width = spec_exp.fit_params['w'].value #save RO power, spec power, freqs, center, width, raw data.. # self.IQs[idx,:] = spec_exp.IQs[0,:] # self.amps[idx,:] = spec_exp.amps[0,:] # self.IQs[idx,:] = spec_exp.IQs[:] self.amps[idx,:] = spec_exp.get_ys() # save spec fit and experiment parameter data self.widths[idx] = width self.spec_log[idx] = self.spec_power if np.sign(self.sideband_freq)<0: self.freqs_log[idx,:] = self.next_center - np.flipud(self.freqs) self.amps[idx,:] = np.flipud(spec_exp.get_ys()) else: self.freqs_log[idx,:] = self.next_center + self.freqs self.amps[idx,:] = spec_exp.get_ys() #choose the next frequency range delta = center - self.last_center self.last_center = center if self.freq_step == 0: # no step, keep the same center frequency self.next_center = self.next_center elif idx == 0: # first point; don't try to stop self.next_center = center + self.freq_step else: # use 0th order estimator from last points # we will weight the frequency step to the expected direction # of the frequency step # if self.freq_step > 0: # # increasing freq # ll, ul = np.array([-0.25, 1.25]) * self.freq_step # else: # # decreasing freq # ll, ul = np.array([1.25, -0.25]) * self.freq_step #Commented out 9/3/14 Jacob, not quite right. # if not ll < delta < ul: # print 'quitting: we seem to have lost the qubit' # break #if the width is off, probably a sign that we're not fitting to qubit peak # if not self.width_min*0.5 < width < self.width_max*2: # print 'quitting: we seem to have lost the qubit' # break # pick new frequency range such that the NEXT point should be centered self.next_center = center + delta # print 'debug: center: %0.3f, , last center: %0.3f, freq_step: %0.3f, , delta: %0.3f, ' %\ # (center, self.last_center, self.freq_step, delta) # print 'debug; current center: %0.3f, current pt center: %0.3f, next pt center: %0.3f' %\ # (q_freqs_center, blah, np.average(self.freqs)) self.freq_step = delta # # see if we should adjust spec power # if width < self.width_min: # self.amp *= 2 # # self.spec_power += 1 # elif width > self.width_max: # self.amp /= 2 # # self.spec_power -= 1 elif self.qubit_freq_fxn!=None: self.last_center = self.qubit_freq_fxn(set_val) self.qubit_rfsource.set_frequency(self.last_center-self.sideband_freq) self.center_freqs[idx] = self.last_center if 'RABI' in self.experiments: # self.qubit_inst.set_w(self.rabi_pulse_len) self.funcgen.set_frequency(self.rabi_funcgen_freq) #rep rate self.alazar.set_naverages(self.rabi_avgs) self.qubit_rfsource.set_power(self.rabi_rf_pwr) rabi_exp = rb(self.init_rabi_amps, self.ro_freq, self.ro_power, set_val) rabi_exp.measure() plt.close() rabi_A = rabi_exp.fit_params['A'].value rabi_f = rabi_exp.fit_params['f'].value rabi_ph = rabi_exp.fit_params['dphi'].value #find pi pulse amplitude. Accounts for offsets pi_amp = (np.pi-np.pi/2*np.sign(rabi_A)-rabi_ph%(2*np.pi))/(2*np.pi*rabi_f) self.rabi_amps_log[idx,:] = rabi_exp.xs[:] self.rabi_dat[idx,:] = rabi_exp.get_ys()[:] # save spec fit and experiment parameter data self.rabi_A[idx] = rabi_A self.rabi_f[idx] = rabi_f self.rabi_ph[idx] = rabi_ph elif self.pi_amp_fxn!=None: pi_amp = self.pi_amp_fxn(set_val) else: pi_amp = 0 self.pi_amp[idx] = pi_amp if np.absolute(pi_amp)>1e-3 and np.absolute(pi_amp)<1: self.qubit_inst.set_pi_amp(pi_amp) if 'T1' in self.experiments: self.funcgen.set_frequency(self.T1_funcgen_freq) #rep rate self.alazar.set_naverages(self.T1_avgs) self.qubit_rfsource.set_power(self.T1_rf_pwr) T1_exp = T1(self.T1_delays, self.ro_freq, self.ro_power, set_val) T1_exp.measure() plt.close() T1_A = T1_exp.fit_params['A'].value T1_A_err = T1_exp.fit_params['A'].stderr T1_tau = T1_exp.fit_params['tau'].value T1_tau_err = T1_exp.fit_params['tau'].stderr self.T1_delays_log[idx,:] = T1_exp.xs[:] self.T1_dat[idx,:] = T1_exp.get_ys()[:] # save spec fit and experiment parameter data self.T1_A[idx] = T1_A self.T1_A_err[idx] = T1_A_err self.T1_tau[idx] = T1_tau self.T1_tau_err[idx] = T1_tau_err #decide next T1 delays if self.T1_update_delays and T1_tau>0.001 and T1_tau<1000: #in case something goes wrong in the fitting self.T1_delays = np.linspace(0, T1_tau*1e3*8, self.num_T1_pts) if 'T2' in self.experiments: self.funcgen.set_frequency(self.T2_funcgen_freq) #rep rate self.alazar.set_naverages(self.T2_avgs) self.qubit_rfsource.set_power(self.T2_rf_pwr) T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val) T2_exp.measure() plt.close() T2_tau = T2_exp.fit_params['tau'].value T2_tau_err = T2_exp.fit_params['tau'].stderr T2_f = T2_exp.fit_params['f'].value T2_f_err = T2_exp.fit_params['f'].stderr self.T2_delays_log[idx,:] = T2_exp.xs[:] self.T2_dat[idx,:] = T2_exp.get_ys()[:] # save spec fit and experiment parameter data self.T2_f[idx] = T2_f self.T2_f_err[idx] = T2_f_err self.T2_tau[idx] = T2_tau self.T2_tau_err[idx] = T2_tau_err if self.T2_set_f: freq_offset = np.absolute(T2_f*1e6-self.T2_delta) freq_old = self.last_center ctr = 0 while freq_offset > 2e6/(2*np.pi*T1_tau): ctr += 1 if ctr > 3: print 'quitting: cannot find qubit frequency from Ramsey' break else: freq_cur = freq_old + freq_offset self.qubit_rfsource.set_frequency(freq_cur) T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val) T2_exp.measure() plt.close() freq_offset_old = freq_offset freq_offset = np.absolute(T2_exp.fit_params['f'].value*1e6-self.T2_delta) if freq_offset <= freq_offset_old: freq_old = freq_cur if freq_offset > freq_offset_old: freq_cur = freq_old - freq_offset_old self.qubit_rfsource.set_frequency(freq_cur) T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val) T2_exp.measure() plt.close() freq_offset = np.absolute(T2_exp.fit_params['f'].value*1e6-self.T2_delta) freq_old = freq_cur # set zero detuning based on Ramsey frequency # if self.T2_set_f: # freq_offset = np.absolute(T2_f-self.T2_delta/1e6) # if freq_offset > 1/(2*np.pi*T1_tau): # self.qubit_rfsource.set_frequency(self.last_center + freq_offset*1e6) # T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val) # T2_exp.measure() # plt.close() # T2_f_new = T2_exp.fit_params['f'].value # if np.absolute(T2_f_new-self.T2_delta/1e6) > 1/(2*np.pi*T1_tau): # self.qubit_rfsource.set_frequency(self.last_center - freq_offset*1e6) # T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val) # T2_exp.measure() # plt.close() # T2_f_new = T2_exp.fit_params['f'].value # if np.absolute(T2_f_new-self.T2_delta/1e6) > 1/(2*np.pi*T1_tau): # print 'quitting: cannot find qubit frequency from Ramsey' # break #decide next T2 delays and detunings if T2_tau>0.001 and T2_tau<1000: #in case something goes wrong in the fitting self.T2_delays = np.linspace(0, T2_tau*1e3*3, self.num_T2_pts) self.T2_delta = 3/T2_tau*1e6 if 'T2Echo' in self.experiments: self.funcgen.set_frequency(self.T2E_funcgen_freq) #rep rate self.alazar.set_naverages(self.T2E_avgs) self.qubit_rfsource.set_power(self.T2E_rf_pwr) T2E_exp = T2Echo(self.T2E_delays, self.T2E_delta, self.ro_freq, self.ro_power, set_val) T2E_exp.measure() plt.close() T2E_tau = T2E_exp.fit_params['sigma'].value T2E_tau_err = T2E_exp.fit_params['sigma'].stderr T2E_A = T2E_exp.fit_params['area'].value / (2 * T2E_tau) / np.sqrt(np.pi / 2) T2E_A_err = np.absolute(T2E_A)*np.sqrt((T2E_tau_err/T2E_tau)**2+(T2E_exp.fit_params['area'].stderr/T2E_A)**2) self.T2E_delays_log[idx,:] = T2E_exp.xs[:] self.T2E_dat[idx,:] = T2E_exp.get_ys()[:] # save spec fit and experiment parameter data self.T2E_A[idx] = T2E_A self.T2E_A_err[idx] = T2E_A_err self.T2E_tau[idx] = T2E_tau self.T2E_tau_err[idx] = T2E_tau_err if T2E_tau>0.001 and T2E_tau<1000: #in case something goes wrong in the fitting self.T2E_delays = np.linspace(0, T2E_tau*1e3*5, self.num_T2E_pts) if 'PhT1' in self.experiments: self.funcgen.set_frequency(self.PhT1_funcgen_freq) #rep rate self.alazar.set_naverages(self.PhT1_avgs) PhT1_exp = PhT1(self.PhT1_delays, self.ro_freq, self.ro_power, set_val) PhT1_exp.measure() plt.close() PhT1_A = PhT1_exp.fit_params['A'].value PhT1_A_err = PhT1_exp.fit_params['A'].stderr PhT1_tau = PhT1_exp.fit_params['tau'].value PhT1_tau_err = PhT1_exp.fit_params['tau'].stderr self.PhT1_delays_log[idx,:] = PhT1_exp.xs[:] self.PhT1_dat[idx,:] = PhT1_exp.get_ys()[:] # save spec fit and experiment parameter data self.PhT1_A[idx] = PhT1_A self.PhT1_A_err[idx] = PhT1_A_err self.PhT1_tau[idx] = PhT1_tau self.PhT1_tau_err[idx] = PhT1_tau_err #RO power if 'ROPWR' in self.experiments: if ((self.ro_pwr_tune != -1 and (idx % self.ro_pwr_tune) == 0)\ or (self.ro_pwr_tune == -1 and np.absolute(self.last_center-self.last_pwr_tune_center) > self.ro_pwr_tune_interval)): #tune if it's been ro_pwr_tune runs or, if not, the qubit has shifted by ro_pwr_tune_interval self.qubit_rfsource.set_frequency(self.last_center) self.qubit_rfsource.set_power(self.ropwr_qubit_rf_pwr) self.funcgen.set_frequency(5000) #rep rate self.alazar.set_naverages(3000) powers = np.arange(self.ro_power - self.ro_range, self.ro_power + self.ro_range + self.ro_step, self.ro_step) # r = ropcal(powers) if self.ro_pwr_pi == False: r = orcpcal(powers, self.amp, self.plen) else: r = orcpcal(powers, self.amp, None) r.measure() plt.close() # # update power # self.ro_power = r.get_best_power() self.ro_power = r.best_power self.last_pwr_tune_center = self.last_center elif self.ro_pwr_fxn!=None: self.ro_power = self.ro_pwr_fxn(set_val) self.ro_source.set_power(self.ro_power) self.analyze(idx) # if self.qubit_yoko != None: # if self.source_type == 'VOLT': # self.qubit_yoko.do_set_voltage(0) # elif self.source_type == 'CURR': # self.qubit_yoko.do_set_current(0) # self.qubit_yoko.set_output_state(0) if self.stark_rfsource != None: self.stark_rfsource.set_rf_on(0) # self.analyze() # if self.savefig: # self.save_fig() return self.set_vals, self.freqs, self.IQs[:]
sequencer.Delay(20000) ]) cspec = cavspectroscopy.CavSpectroscopy( mclient.instruments['brick4'], qubit_info, cavity_info1B, [1.2], np.linspace(cav_freq - 0.5e6, cav_freq + 0.5e6, 61), Qswitchseq=seq, extra_info=[Qswitch_info1A, Qswitch_info1B]) cspec.measure() bla if 0: #Find qubit ef from scripts.single_qubit import spectroscopy ef_freq = 4959.00e6 seq = sequencer.Sequence( [sequencer.Trigger(250), qubit_info1.rotate(np.pi, 0)]) postseq = sequencer.Sequence(qubit_info1.rotate(np.pi, 0)) spec = spectroscopy.Spectroscopy(mclient.instruments['ag3'], ef_info, np.linspace(ef_freq - 5e6, ef_freq + 5e6, 101), [-32], plen=2000, amp=0.004, seq=seq, postseq=postseq, extra_info=qubit_info, plot_seqs=False) spec.measure() bla
], real_signals=True, histogram=True, title='|e>') tr.measure() tr = rabi_IQ.Rabi(qubit_info, [ 0.00, ], real_signals=True, histogram=True, title='|g>') tr.measure() if 0: from scripts.single_qubit import rabi alz.set_naverages(50000) seq = sequencer.Sequence([ sequencer.Trigger(250), cavity_info1A.rotate(0, 0), cavity_info1B.rotate(0, 0) ]) tr = rabi.Rabi(qubit_info, [ 0.00, ], histogram=True, seq=seq, title='|g>', generate=True, extra_info=[cavity_info1A, cavity_info1B]) tr.measure()
qubit_ef_brick = instruments['qubit_ef_brick'] #va_lo = instruments['va_lo'] va_lo_4_8 = instruments['va_lo'] funcgen = instruments['funcgen'] alazar = instruments['alazar'] spec_brick = instruments['spec_brick'] spec_info = mclient.get_qubit_info('spec_info') LO_brick = instruments['LO_brick'] LO_info = mclient.get_qubit_info('LO_info') cavity_info = mclient.get_qubit_info('cavity_info') yoko1 = instruments['yoko1'] yoko2 = instruments['yoko2'] #ro = mclient.get_readout_info('readout') precool = sequencer.Sequence( [sequencer.Trigger(250), pulselib.GaussSquare(0.660e3, 0.056, 10, chan=3)]) precool2 = sequencer.Sequence( [pulselib.GaussSquare(0.660e3, 0.056, 10, chan=3)]) #r = qubit_info.rotate # # #calibSeq = sequencer.Sequence([sequencer.Trigger(250)]) #calibSeq.append(sequencer.Combined([ # pulselib.Constant(ro.pulse_len, 1, chan=ro.readout_chan), # pulselib.Constant(ro.pulse_len, 1, chan=ro.acq_chan), # ])) #calibSeq.append(sequencer.Trigger(250)) #calibSeq.append(r(np.pi, 0)) #calibSeq.append(sequencer.Combined([
bla if 0: # spectroscopy for EF transition from scripts.single_qubit import spectroscopy as spectroscopy qubit_ef_freq = 5898.7e6 #5239.790e6-50e6-175e6 freq_range = 10e6 freqs = np.linspace(qubit_ef_freq - freq_range, qubit_ef_freq + freq_range, 101) drive_power = -33 qubit_brick.set_rf_on(1) spec_brick.set_rf_on(1) spec_brick.set_pulse_on(1) seq = sequencer.Sequence([ sequencer.Trigger(250), # prepend pi pulse qubit_info.rotate(np.pi, 0), sequencer.Delay(10) ]) postseq = sequencer.Sequence(qubit_info.rotate(np.pi, 0)) # postpend pi pulse # for drive_power in drive_powers: spec_params = (spec_brick, drive_power) spec_brick.set_power(drive_power) # spec_params = (qubit_ef_brick, None) s = spectroscopy.Spectroscopy( spec_info, freqs, spec_params, use_marker=True, plen=5e3,