def doRamseyRun(hspace, params, dec): tdelay = np.linspace(0,5000,500) YR = np.zeros([len(tdelay),hspace.dimensions], np.complex64) pop = np.zeros([len(tdelay),hspace.dimensions], np.complex64) widgets = [progbar.Percentage(), ' ', progbar.Bar(),' ', progbar.ETA()] pbar = progbar.ProgressBar(widgets=widgets).start() for i in range(len(tdelay)): pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, pi/2, 0), \ sim.Delay(params, tdelay[i]), \ sim.Rcar(params, pi/2, pi/2) \ ] ) data = qc.simulateevolution(pulseseq, params, dec) YR[i,:] = data.YR[-1,:] pbar.update(int(1.*(i+1)*100/(len(tdelay)))) data1 = sim.database(tdelay, YR, hspace, pulseseq=None, statesvalid = False) data1.tracedpopulation(0) [fitfun, par] = doRamseyFit(data1) return data1, fitfun, par
def test_dephasing_detailed(figNum): NumberOfIons = 1 NumberofPhonons = 0 hspace = sim.hspace(NumberOfIons, 2, NumberofPhonons, 0) params = sim.parameters(hspace) dec = sim.decoherence(params) params.coherenceTime = 1000 params.correlationTime = 0.1 dec.doRandNtimes = 20 dec.dict['dephase'] = True dec.progbar = False params.stepsize = 10 params.ODEtimestep = 1 params.detuning = 2 * pi * 0.01 #kHz params.progbar = False #dec.doPP = True #params.use_servers(['local']) #dec.doPPprintstats = False tdelay = np.linspace(0, 1000, 100) YR = np.zeros([len(tdelay), hspace.dimensions], np.complex64) pop = np.zeros([len(tdelay), hspace.dimensions], np.complex64) widgets = [progbar.Percentage(), ' ', progbar.Bar(), ' ', progbar.ETA()] pbar = progbar.ProgressBar(widgets=widgets).start() for i in range(len(tdelay)): pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, pi/2, 0), \ sim.Delay(params, tdelay[i]), \ sim.Rcar(params, pi/2, pi/2) \ ] ) data = qc.simulateevolution(pulseseq, params, dec) YR[i, :] = data.YR[-1, :] pbar.update(int(1. * (i + 1) * 100 / (len(tdelay)))) data1 = sim.database(tdelay, YR, hspace, pulseseq=None, statesvalid=False) data1.tracedpopulation(figNum) # fitting part p0 = [0.5, params.detuning, pi / 2, 0.5, params.coherenceTime] fitfun = lambda p, x: p[0] * np.cos(p[1] * x + p[2]) * np.exp(-np.log( 2) * (x / p[4])**2) + p[3] errfun = lambda p, x, y: y - fitfun(p, x) x = data1.T y = data1.YR[:, 0] par, covmat, infodict, mesg, ier = leastsq(errfun, p0, args=(x, y), full_output=True) epsilon = 100 # with 20 iterations allow 100us offset in coherence time #print(par) return data1
def test_ACStark_detailed(figNum): NumberOfIons = 1 hspace = sim.hspace(NumberOfIons,2,0,0) params = sim.parameters(hspace) dec = sim.decoherence(params) params.progbar = False pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, pi/2, 0), sim.Rac(params, 0, 0, 0), sim.Rcar(params, pi/2, 0) ] ) ACtime = np.linspace(0,10*pi,100) realtime = np.zeros_like(ACtime) YR = np.zeros([len(ACtime), hspace.dimensions], dtype='complex') for i in range(len(ACtime)): pulseseq[1] = sim.Rac(params, ACtime[i], 0, 0) realtime[i] = pulseseq[1].duration data = qc.simulateevolution(pulseseq, params, dec) YR[i,:] = data.YR[-1,:] data1 = sim.database(realtime, YR, hspace, statesvalid = False) data1.tracedpopulation(figNum) # start with fit here x = data1.T y = data1.YtrN.transpose()[0] # this is the s-state population # p[0] ... amplitude, should be 1 # p[1] ... freq, should be params.omc # p[2] ... phase, should be 0 # p[3] ... offset, should be 0 startparams = np.array([1, params.omac, 0, 0]) # 1-data ... to get the D-state population fitfun = lambda p, x: 1-p[0]*np.sin(p[1]*x/2+p[2])**2 + p[3] errfun = lambda p, x, y: y-fitfun(p,x) par, covmat, infodict, mesg, ier = leastsq(errfun, startparams, args=(x,y), full_output = True) epsilon = 10**-3 if par[0] - startparams[0] > epsilon: print("amplitude of AC oscillations wrong") if par[1] - startparams[1] > epsilon: print("frequency of AC oscillations wrong") if par[2] - startparams[2] > epsilon: print("phase of AC oscillations wrong") if par[3] - startparams[3] > epsilon: print("offset of AC oscillations wrong") return np.all(par-startparams < epsilon), data1, fitfun, par, startparams
def ProcTomoPrepare(parameter, simparams, use_ideal=False): """ pulses for a proctomo (preparation part) using addressed pulses. working with up to 3 qubits for the moment """ nuions = simparams.hspace.nuions total_prepend = [] par = int(parameter) # first qubit if (mod(par//(4**0 * 3**nuions), 4) == 1): total_prepend.append(sim.Rcar(simparams, pi/2 , 0, nuions-1)) if (mod(par//(4**0 * 3**nuions), 4) == 2): total_prepend.append(sim.Rcar(simparams, pi/2, pi*0.5, nuions-1)) if (mod(par//(4**0 * 3**nuions), 4) == 3): total_prepend.append(sim.Rcar(simparams, pi, 0, nuions-1)) # second qubit if (mod(par//(4**1 * 3**nuions), 4) == 1) and nuions >= 2 : total_prepend.append(sim.Rcar(simparams, pi/2 , 0, nuions-2)) if (mod(par//(4**1 * 3**nuions), 4) == 2) and nuions >= 2 : total_prepend.append(sim.Rcar(simparams, pi/2, pi*0.5, nuions-2)) if (mod(par//(4**1 * 3**nuions), 4) == 3) and nuions >= 2 : total_prepend.append(sim.Rcar(simparams, pi, 0, nuions-2)) # third qubit if (mod(par//(4**2 * 3**nuions), 4) == 1) and nuions >= 3 : total_prepend.append(sim.Rcar(simparams, pi/2 , 0, nuions-3)) if (mod(par//(4**2 * 3**nuions), 4) == 2) and nuions >= 3 : total_prepend.append(sim.Rcar(simparams, pi/2, pi*0.5, nuions-3)) if (mod(par//(4**2 * 3**nuions), 4) == 3) and nuions >= 3 : total_prepend.append(sim.Rcar(simparams, pi, 0, nuions-3)) if use_ideal: for pulse in total_prepend: pulse.use_ideal = True return total_prepend
def cnot1234(): return sim.PulseSequence([ \ sim.Rcar(params, 1.5*pi, 0*pi), sim.Rac(params, 1.5*pi, 0, 0), sim.RMS(params, 0.25*pi, 0.5*pi), sim.Rcar(params, 0.75*pi, 0*pi), sim.Rac(params, 1*pi, 0, 0), sim.RMS(params, 1.75*pi, 0.5*pi), sim.Rcar(params, 0.75*pi, 0*pi), sim.Rac(params, 1.5*pi, 0, 0), sim.Rcar(params, 0.5*pi, 0*pi) ])
def StateTomo(parameter, simparams, use_ideal=False): """ pulses for a state tomography using addressed pulses. working with up to 4 qubits for the moment """ # 0 - Z # 1 - X # 2 - Y # counting from the right, in principle ... :( total_append = [] par = int(parameter) nuions = simparams.hspace.nuions # first qubit if (mod(par//3**0, 3) == 1): total_append.append(sim.Rcar(simparams, pi/2, 1.5*pi, 0)) if (mod(par//3**0, 3) == 2): total_append.append(sim.Rcar(simparams, pi/2, pi, 0)) # second qubit if (mod(par//3**1, 3) == 1): total_append.append(sim.Rcar(simparams, pi/2, 1.5*pi, 1)) if (mod(par//3**1, 3) == 2): total_append.append(sim.Rcar(simparams, pi/2, pi, 1)) # third qubit if (mod(par//3**2, 3) == 1): total_append.append(sim.Rcar(simparams, pi/2, 1.5*pi, 2)) if (mod(par//3**2, 3) == 2): total_append.append(sim.Rcar(simparams, pi/2, pi, 2)) # fourth qubit if (mod(par//3**3, 3) == 1): total_append.append(sim.Rcar(simparams, pi/2, 1.5*pi, 3)) if (mod(par//3**3, 3) == 2): total_append.append(sim.Rcar(simparams, pi/2, pi, 3)) if use_ideal: for pulse in total_append: pulse.use_ideal = True return total_append
def GeneratePulseSeq(self, params, Perms, perm2=None, perm3=None): #Legacy support for old-style calls: if perm2 and perm3: Perms = [Perms, perm2, perm3] ''' generate pulse sequences given all permutations '''\ self.nOps = len(Perms) controlRots = [ \ [sim.Delay(params, sim.Rac(params, pi/2**(i+1), 0, 0).duration), sim.Rac(params, pi/2**(i+1), 0, 0)] for i in range(self.nOps)] Hadamard0 = sim.PulseSequence( [ \ sim.Rcar(params, pi/4, pi), sim.Rac(params, pi, 0), sim.Rcar(params, pi/4, 0) ]) def PulseSeqWithControls(ctl): # 'ctl' is a bit array of control qubits ctlstr = np.binary_repr(ctl).zfill(self.nOps - 1) pulseseq = sim.PulseSequence([]) for k in range(self.nOps): pulseseq.append(Hadamard0) pulseseq.append(Perms[k]) pulseseq += [copy.deepcopy(controlRots[i] \ [int(ctlstr[self.nOps-i-k-1])]) for i in range(k)] pulseseq.append(Hadamard0) if k == self.nOps - 1: pulseseq += [ \ sim.Hide(params, 1, True), sim.Hide(params, 2, True), sim.MeasInit(params, 0, incl_hidingerr=False) ] else: pulseseq += [ \ sim.Hide(params, 1, True), sim.Hide(params, 2, True), sim.MeasInit(params, 0), sim.Hide(params, 1, False), sim.Hide(params, 2, False) ] return pulseseq pulseseq_group = [] for ctl in range(2**(self.nOps - 1)): pulseseq_group.append(PulseSeqWithControls(ctl)) return pulseseq_group
def test_StateTomo_detailed(): NumberOfIons = 2 PhononOverhead = 1 hspace = sim.hspace(NumberOfIons, 2, NumberOfIons + PhononOverhead, 0) params = sim.parameters(hspace) dec = sim.decoherence(params) params.y0[qc.stateToIndex('SS,0', hspace)] = 1 pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, 2*pi, 0, 0), \ ] ) ScanObj = IPS.ScanParameter_in_Sequence(pulseseq, params, dec, np.arange(3**NumberOfIons), type='StateTomo') ScanObj.runScan() data_dmr = ScanObj.output_dict['qstates_camera'] rho = dmr.IterML.iterfun(data_dmr, 100) #if np.real(rho[3,3]) > 0.99: # print 'statetomo passed' return np.real(rho[3, 3]) > 0.99
def GeneratePulseSeq(Perm, Perm2, Perm4, QFTseq, doKitaev): if not doKitaev: pulseseq = sim.PulseSequence([ \ sim.Hide(params, 3, True), sim.Hide(params, 4, True), sim.Rcar(params, pi/2, -pi/2), sim.Hide(params, 3, False), sim.Hide(params, 4, False), sim.Hide(params, 0, True), sim.Hide(params, 1, True,), Perm, Perm2, Perm4, sim.Hide(params, 0, False), sim.Hide(params, 1, False), sim.Hide(params, 2, False), sim.Hide(params, 3, True), sim.Hide(params, 4, True), QFTseq, ]) return pulseseq else: pulseseq_group = Kit.GeneratePulseSeq(params, [Perm4, Perm2, Perm]) return pulseseq_group
def data_optimize(inputparam, params, dec): ''' use this function to search for params.MScorr for every detuning. How-to: - in the root-level code above, enter params.MSdelta and params.shortestMS - here put 'inputparam' in place of the number you want to optimize - run the file and enter the result in above - repeat for every number that appears in params.MScorr ''' #params.MScorr = { # 'duration': 1.1642, # 'omrabi': 1.0268, # 'shortPulseFactorPos': {2: 1.000, 4: 1.0106, 8: inputparam, 16: 1.01835}, # 'shortPulseFactorNeg': {2: 1.010, 4: 1.0214, 8: 1.0271, 16: 1.02986} # } pulseseq = sim.PulseSequence([ sim.Hide(params, 0, True), sim.Hide(params, 1, True), sim.RMS(params, pi / 2, 0), sim.Rcar(params, pi / 2, pi / 2) ]) pulseseq[2].omrabi_r = params.omc_ms * inputparam pulseseq[2].omrabi_b = params.omc_ms * inputparam data = qc.simulateevolution(pulseseq, params, dec) data.displayPMTpopulations(0) inbalance = abs(data.P_PMT_end[2] - data.P_PMT_end[5]) unwanted = abs(data.P_PMT_end[0] + data.P_PMT_end[1] + data.P_PMT_end[3] + data.P_PMT_end[4]) print inputparam, inbalance + unwanted return inbalance + unwanted
def test_ProcTomo_detailed(): NumberOfIons = 1 PhononOverhead = 7 hspace = sim.hspace(NumberOfIons, 2, NumberOfIons + PhononOverhead, 0) params = sim.parameters(hspace) dec = sim.decoherence(params) params.y0[qc.stateToIndex('S,0', hspace)] = 1 pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, pi/2,0), ] ) ScanObj = IPS.ScanParameter_in_Sequence(pulseseq, params, dec, np.arange(12**NumberOfIons), type='ProcTomo') ScanObj.runScan() data_proctom = ScanObj.output_dict['qstates_camera'] chi = proctom.proctomo(data_proctom, 100) #if np.real(chi[0,0]) > 0.99: # print 'proctomo passed' chiId = qproc.Unitary2Chi(pulseseq[0].Uidtr.conjugate()) return np.max(abs(chi - chiId)) < 0.001
def test_Rabi_carrier_detailed(figNum): #print(TestUserFUnction.figNum, TestUserFunction.figNum_start, "<<<<") NumberOfIons = 1 PhononOverhead = 2 hspace = sim.hspace(NumberOfIons,2,NumberOfIons+PhononOverhead,0) params = sim.parameters(hspace) params.stepsize = 1 dec = sim.decoherence(params) params.y0[qc.stateToIndex('S,0', hspace)] = 1 params.printpulse = False # don't print pulse details pulseseq = sim.PulseSequence( [ sim.Rcar(params, 10*pi, 0, -1) ] ) data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(figNum) # start with fit here x = data.T y = data.YtrN.transpose()[0] # this is the s-state population # p[0] ... amplitude, should be 1 # p[1] ... freq, should be params.omc # p[2] ... phase, should be 0 # p[3] ... offset, should be 0 startparams = np.array([1, params.omc, 0, 0]) # 1-data ... to get the D-state population fitfun = lambda p, x: 1-p[0]*np.sin(p[1]*x/2+p[2])**2 + p[3] errfun = lambda p, x, y: y-fitfun(p,x) par, covmat, infodict, mesg, ier = leastsq(errfun, startparams, args=(x,y), full_output = True) #print(startparams) #print(par) #print(startparams-par) epsilon = 10**-5 if par[0] - startparams[0] > epsilon: print("amplitude of Rabi oscillations wrong") if par[1] - startparams[1] > epsilon: print("frequency of Rabi oscillations wrong") if par[2] - startparams[2] > epsilon: print("phase of Rabi oscillations wrong") if par[3] - startparams[3] > epsilon: print("offset of Rabi oscillations wrong") return np.all(par-startparams < epsilon)
def ProcTomoAnalyse(parameter, simparams, use_ideal=False): """ pulses for proctomo (analysis part) using addressed pulses. working with up to 3 qubits for the moment """ # 0 - Z # 1 - X # 2 - Y # counting from the right # i have to use strings here because neither sim nor params is # known here. nuions = simparams.hspace.nuions total_append = [] par = int(parameter) # first qubit if (mod(par//3**0, 3) == 1): total_append.append(sim.Rcar(simparams, pi/2, pi*1.5, 0)) if (mod(par//3**0, 3) == 2): total_append.append(sim.Rcar(simparams, pi/2, pi*1, 0)) # second qubit if (mod(par//3**1, 3) == 1) and nuions >= 2: total_append.append(sim.Rcar(simparams, pi/2, pi*1.5, 1)) if (mod(par//3**1, 3) == 2) and nuions >= 2: total_append.append(sim.Rcar(simparams, pi/2, pi*1, 1)) # third qubit if (mod(par//3**2, 3) == 1) and nuions >= 3: total_append.append(sim.Rcar(simparams, pi/2, pi*1.5, 2)) if (mod(par//3**2, 3) == 2) and nuions >= 3: total_append.append(sim.Rcar(simparams, pi/2, pi*1, 2)) if use_ideal: for pulse in total_append: pulse.use_ideal = True return total_append
def test_state_initialisation_detailed(figNum): NumberOfIons = 1 NumberOfPhonons = 1 hspace = sim.hspace(NumberOfIons, 2, NumberOfPhonons, 0) params = sim.parameters(hspace) params.stateiniterr = 0.2 dec = sim.decoherence(params) dec.doPP = False dec.progbar = False dec.doRandNtimes = 10 dec.dict['initerr'] = True params.y0[qc.stateToIndex(NumberOfIons * 'S' + ',0', hspace)] = 1 pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, 5*pi, 0), ] ) data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(figNum) # start with fit here x = data.T y = data.YtrN.transpose()[-1] # this is the d-state population # p[0] ... amplitude, should be 0.8 # p[1] ... freq, should be params.omc # p[2] ... phase, should be 0 # p[3] ... offset, should be 0 startparams = np.array([0.8, params.omc, 0, 0]) # 1-data ... to get the D-state population fitfun = lambda p, x: p[0] * np.sin(p[1] * x / 2 + p[2])**2 + p[3] errfun = lambda p, x, y: y - fitfun(p, x) par, covmat, infodict, mesg, ier = leastsq(errfun, startparams, args=(x, y), full_output=True) # print(par) # even for the 1000 realisations, allow for a 3% error epsilon = 0.03 return abs(abs(par[0]) - startparams[0]) < epsilon
def parity(data, params): ''' check the parity of the pi/2 MS gate. must run expMS first. call: parity(data.Yend) ''' phase = np.linspace(0, 2 * pi, 20) params.y0 = data.Yend P_PMT = data.P_PMT parity = np.zeros(len(phase)) params.printpulse = False dec = sim.decoherence(params) widgets = [progbar.Percentage(), ' ', progbar.Bar(), ' ', progbar.ETA()] pbar = progbar.ProgressBar(widgets=widgets).start() for i in range(len(phase)): pulseseq = sim.PulseSequence([sim.Rcar(params, pi / 2, phase[i], -1)]) data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(0) parity[i] = data.YtrN[-1, 0] + data.YtrN[-1, 3] - data.YtrN[ -1, 1] - data.YtrN[-1, 2] pbar.update(int(1. * (i + 1) * 100 / (len(phase)))) def sinefunc(x, a, b): return -a * np.sin(2 * x) + b [p, pcov] = spop.curve_fit(sinefunc, phase, parity) population = P_PMT[-1, 0] + P_PMT[-1, -1] coherence = abs(p[0]) fidelity = (population + coherence) / 2 xphase = np.linspace(0, 2 * pi, 200) parityfit = sinefunc(xphase, p[0], p[1]) pl.plot(phase, parity, '.', xphase, parityfit, '-') pl.xlabel('phase [rad]') pl.ylabel('parity') pl.show() print "population = ", population print "coherence contrast = ", coherence print "fidelity = ", fidelity return phase, parity, pulseseq
''' pulse sequences for (fully-quantum) QFT ''' import PyTIQC.core.simtools as sim QFTseqP1 = sim.PulseSequence([sim.Rcar(params, pi / 2, -pi / 2)]) QFTseqP2 = sim.PulseSequence([ sim.Rcar(params, pi / 2, -pi / 2), sim.Rac(params, pi / 2, 0, 0), sim.Rcar(params, pi / 2, 0) ]) QFTseqP3 = sim.PulseSequence( [ \ sim.Rcar(params, pi/4, pi/2), #U.Uy(pi/4, N), sim.Rac(params, pi, 0, 1), #U.Uz(pi, N, 1), sim.Rcar(params, pi/4, -pi/2), # U.Uy(-pi/4, N), sim.Rcar(params, pi/2, pi/2), #U.Uy(pi/2,N), sim.Rac(params, pi, 0, 2), #U.Uz(pi, N, 2), sim.Rcar(params, pi/2, -pi/2), #U.Uy(-pi/2,N), sim.RMS(params, pi/4, 0), #U.MS(pi/4,0,N), sim.Rac(params, pi, 0, 1), #U.Uz(pi, N, 1), sim.RMS(params, pi/4, 0), #U.MS(pi/4,0,N) ] ) QFTseqP4 = sim.PulseSequence([ sim.Rcar(params, pi / 4, -pi / 2), sim.Rac(params, pi, 0, 2), sim.Rcar(params, pi / 4, pi / 2) ]) QFTseq = sim.PulseSequence( [ \ sim.Rcar(params, pi/2, 0), #1 sim.Rac(params, pi, 0, 1), #2
NumberOfIons = 1 NumberofPhonons = 10 hspace = sim.hspace(NumberOfIons, 2, NumberofPhonons, 0) hspace.initial_state('thermal', nBar=5) # use thermal state params = sim.parameters(hspace) params.eta = np.array([0.3, 0.3]) dec = sim.decoherence(params) params.use_servers(['anna']) dec.doRandNtimes = 8 dec.dict['all'] = True dec.doPP = True dec.progbar = False params.progbar = True params.printpulse = True params.LDapproximation = False params.addressingerr = 0.03 pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, 10*pi, 0, 0), \ ] ) #pulseseq[0].dotimedepPulse = True data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(2)
def MSparity(phase, simparams, use_ideal=False): """ add a pi/2 pulse to MS gate, varying phase """ total_append =[ sim.Rcar(simparams, pi/2, phase, -1)] total_append[0].use_ideal = use_ideal return total_append
runStateTomo = False runStateTomoPP = False runProcTomo = False runProcTomoPP = True if runStateTomo or runStateTomoPP: NumberOfIons = 2 PhononOverhead = 1 hspace = sim.hspace(NumberOfIons,2,NumberOfIons+PhononOverhead,0) params = sim.parameters(hspace) dec = sim.decoherence(params) params.use_servers(['lindhard']) pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, 2*pi, 0, 0), ] ) if runStateTomo: ScanObj = ScanParameter_in_Sequence(pulseseq, params, dec, np.arange(3**NumberOfIons), type='StateTomo', verbose=True) elif runStateTomoPP: ScanObj = ScanParameter_in_Sequence(pulseseq, params, dec, np.arange(3**NumberOfIons), type='StateTomo', verbose=True, doPP=True, use_ideal=True) ScanObj.runScan() data_dmr = ScanObj.output_dict['qstates_camera'] rho = dmr.IterML.iterfun(data_dmr, 100) if np.real(rho[-1,-1]) > 0.99: print('statetomo passed') else: print('statetomo failed')
import time pi = np.pi NumberOfIons = 3 NumberOfPhonons = 7 hspace = sim.hspace(NumberOfIons, 2, NumberOfPhonons, 0) params = sim.parameters(hspace) params.stepsize = 100 params.printpulse = True dec = sim.decoherence(params) pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, pi/2, 0), sim.Rac(params, pi/2, 0, 0), sim.RMS(params, pi/4, 0), sim.Rcar(params, pi/4, 0), sim.Rac(params, pi, 0, 2), sim.Rcar(params, pi/4, 0), sim.RMS(params, pi/4, 0), sim.Rac(params, pi/2, 0, 0), sim.Rcar(params, pi/2, 0), sim.Rac(params, pi, 0, 2) ] ) #params.y0[qc.stateToIndex('DDD' + ',0', hspace)] = 0.25-0.25j #params.y0[qc.stateToIndex('DDS' + ',0', hspace)] = -0.25-0.25j #params.y0[qc.stateToIndex('DSD' + ',0', hspace)] = -0.25-0.25j #params.y0[qc.stateToIndex('DSS' + ',0', hspace)] = -0.25+0.25j
import numpy as np import PyTIQC.core.simtools as sim import PyTIQC.core.qctools as qc pi = np.pi hspace = sim.hspace(2, 2, 2, 0) params = sim.parameters(hspace) dec = sim.decoherence(params) params.y0[qc.stateToIndex('SS,0', hspace)] = 1 params.stepsize = 10 params.ignorelightshift = 1 #params.addressing = np.array([[1,0.1],[0.1,1]]) ang = np.arccos(-np.real(np.exp(pi / 2 * 1j * np.sqrt(2)))) pulseseq = sim.PulseSequence( [ \ sim.Rblue(params, pi, 0, 0), \ sim.Rcar(params, pi/2, 0, 1), \ sim.Rblue(params, pi/2, 0, 1), \ sim.Rblue(params, np.sqrt(2)*pi, pi/2, 1), \ sim.Rblue(params, pi/2, pi, 1), \ sim.Rcar(params, pi/2, pi + ang, 1), \ sim.Rblue(params, pi, 0, 0) \ ] ) data = qc.simulateevolution(pulseseq, params, dec) data.displaypopulation(1) data.tracedpopulation(2)
params = sim.parameters(hspace) dec = sim.decoherence(params) params.y0[qc.stateToIndex('S' + ',0', hspace)] = 1 params.stepsize = 1 params.printpulse = False params.progbar = False # change this to check amplitude of off-resonant excitations #params.ACintenFac = 60 #params.recalculate() #params.solver = "Cheby" # seems to not work for this one pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, pi/2, 0, 0), \ sim.Rac(params,pi, 0, 0), \ sim.Rcar(params, pi/2, 0, 0) \ ] ) # this line turns on the ODE solver for the AC pulse # then the total population exceeds 1, growing linearly w/ time #pulseseq[1].dotimedepPulse = True #pulseseq[1].duration = 40 data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(1) #plot the total population for all states vs time #pl.figure(2)
params.stepsize = 600 detuning = np.arange(-1.2*params.omz, 1.2*params.omz, params.omz/300) #dets1 = np.arange(-1.1*params.omz, -0.9*params.omz, 2*pi*0.001) #detc = np.arange(-2*pi*0.1, 2*pi*0.1, 2*pi*0.001) #dets2 = np.arange(0.9*params.omz, 1.1*params.omz, 2*pi*0.001) #detuning = np.hstack([ dets1, detc, dets2 ]) YR = np.zeros([len(detuning),hspace.dimensions], np.complex128) widgets = [progbar.Percentage(), ' ', progbar.Bar(),' ', progbar.ETA()] pbar = progbar.ProgressBar(widgets=widgets).start() for i in range(len(detuning)): params.detuning = detuning[i] pulseseq = sim.PulseSequence( [ \ sim.Rcar(params, pi/params.eta[0], 0), \ ] ) data = qc.simulateevolution(pulseseq, params, dec) YR[i,:] = data.YR[-1,:] pbar.update(int(1.*(i+1)*100/(len(detuning)))) data1 = sim.database(detuning, YR, hspace, pulseseq=None, statesvalid = False) #data1.displaypopulation(1) data1.tracedpopulation(0) pl.plot(detuning/2/pi, 1-data1.YtrI) pl.xlabel('relative frequency (2$\pi$ MHz)') pl.ylabel('D state population') pl.show()
def test_Ramsey_carrier_detailed(figNum): NumberOfIons = 1 PhononOverhead = 2 hspace = sim.hspace(NumberOfIons,2,NumberOfIons+PhononOverhead,0) params = sim.parameters(hspace) dec = sim.decoherence(params) params.y0[qc.stateToIndex('S,0', hspace)] = 1 params.stepsize = 1 params.printpulse = False # don't print pulse details numberofpoints = 20 phi = np.linspace(0, 2*pi, numberofpoints) ex = np.zeros(numberofpoints) for i in range(numberofpoints): pulseseq = sim.PulseSequence( [ sim.Rcar(params, pi/2, 0, -1), # sim.Delay(params, tdelay[i]), sim.Rcar(params, pi/2, phi[i], -1) ]) data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(figNum) ex[i] = data.YtrN[-1,0] # fig1 = pl.figure(1) # ax1 = fig1.add_subplot(111) # ax1.plot(phi, ex) # fig1.show() # p[0] ... amplitude, should be 1 # p[1] ... because phase is in units of pi -> 1 # p[2] ... phase, should be 0 # p[3] ... offset, should be 0.5 startparams = np.array([1, 1, 0, 0.5]) # 1-data ... to get the D-state population fitfun = lambda p, x: p[0]/2*np.cos(p[1]*x+p[2]) + p[3] errfun = lambda p, x, y: y-fitfun(p,x) par, covmat, infodict, mesg, ier = leastsq(errfun, startparams, args=(phi,ex), full_output = True) #print(startparams) #print(par) #print(startparams-par) epsilon = 10**-5 if par[0] - startparams[0] > epsilon: print("amplitude of Ramsey experiment wrong") if par[1] - startparams[1] > epsilon: print("frequency of Ramsey experiment wrong") if par[2] - startparams[2] > epsilon: print("phase of Ramsey experiment wrong") if par[3] - startparams[3] > epsilon: print("offset of Ramsey experiment wrong") return np.all(par-startparams < epsilon)
# change ion order and define permutations ########################################## # execfile(pulseseqfileShor,locals(),globals()) # exec(open(pulseseqfileShor).read(),globals(),locals()) #,locals(),globals()) #Fredkin gate Fredkin = sim.PulseSequence([ \ sim.Rcar(params, 0.5*pi, 0.5*pi), sim.Rac(params, 0.5*pi, 0, 0), sim.RMS(params, 0.5*pi, pi/2), sim.Rac(params, 0.5*pi, 0, 1), sim.Rac(params, -0.5*pi, 0, 0), sim.Rcar(params, 0.75*pi, 1*pi), sim.RMS(params, -0.25*pi, pi/2), sim.Rac(params, 0.5*pi, 0, 1), sim.RMS(params, 0.5*pi, pi/2), sim.Rcar(params, 0.5*pi, 0*pi), sim.Rac(params, -0.25*pi, 0, 1), sim.Rac(params, 0.5*pi, 0, 0), sim.RMS(params, 0.5*pi, pi/2), sim.Rac(params, 0.5*pi, 0, 1), sim.Rac(params, 0.5*pi, 0, 2), sim.Rcar(params, 0.5*pi, 0*pi), sim.Rac(params, -0.5*pi, 0, 2), sim.Rac(params, -0.5*pi, 0, 1) ]) # CNOT on first four computational qubits: def cnot1234(): return sim.PulseSequence([ \ sim.Rcar(params, 1.5*pi, 0*pi),
''' pulse sequences for order-finding ''' import PyTIQC.core.simtools as sim # order 1 - Toffoli(1,3,2) - from Volkmarizer order1 = sim.PulseSequence( [ \ sim.Rcar(params, pi/2, pi/2), #0 sim.Rac(params, pi/4, 0, 1), #1 sim.RMS(params, pi/2, pi/2), #2 sim.Rcar(params, pi/2,pi), #3 sim.Rac(params, 3*pi/2, 0, 1), #4 sim.Rcar(params, pi/4,1*pi), #5 sim.RMS(params, pi/4, pi/2), #6 sim.Rac(params, pi/2, 0, 1), #7 sim.RMS(params, pi/2, pi/2), #8 sim.Rcar(params, pi/2,0*pi), #9 sim.Rcar(params, pi/2,-pi/2) ]) # order 2 - CNOT(1,3) - from paper (IV.A first one) order2 = sim.PulseSequence( [ \ sim.Rcar(params, pi/2, 0), sim.Rac(params, 7*pi/2, 0, 2), # 3pi/2 in experiment sim.RMS(params, pi/4, pi/2), sim.Rcar(params, pi/4, 0), sim.Rac(params, 3*pi, 0, 1), sim.Rcar(params, pi/4, 0), sim.RMS(params, pi/4, pi/2), sim.Rac(params, 7*pi/2, 0, 2), sim.Rcar(params, pi/2, 0), sim.Rac(params, 3*pi, 0, 1) ])
hspace = sim.hspace(NumberOfIons, 2, NumberofPhonons, 0) params = sim.parameters(hspace) dec = sim.decoherence(params) params.hidingerr = 0.75 dec.doRandNtimes = 4 dec.dict['hiding'] = True #dec.doPP = True dec.progbar = False #params.progbar= True #params.printpulse = True pulseseq = sim.PulseSequence( [ \ sim.Hide(params, 0, True), sim.Hide(params, 0, False), sim.Rcar(params, 2*pi, 0), \ sim.Hide(params, 2, True), sim.Hide(params, 2, False), sim.Rcar(params, 2*pi, 0), \ sim.Hide(params, 2, True), sim.Hide(params, 2, False), sim.Rcar(params, 2*pi, 0), \ ] ) data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(1)