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 test_heating_detailed(figNum): NumberOfIons = 1 NumberofPhonons = 10 hspace = sim.hspace(NumberOfIons,2,NumberofPhonons,0) params = sim.parameters(hspace) dec = sim.decoherence(params) # since data.RhoPNAll doesn't save phonons, we'll have to simulate sequentially numRuns = 5 phonons = np.zeros(numRuns) dec.doRandNtimes = 1 dec.dict['heating'] = True dec.progbar = False params.progbar = False params.heatingrate = 250 maxDelay = 1000 pulseseq = sim.PulseSequence( [ \ sim.Delay(params, maxDelay), \ ] ) widgets = [progbar.Percentage(), ' ', progbar.Bar(),' ', progbar.ETA()] pbar = progbar.ProgressBar(widgets=widgets).start() for i in range(numRuns): data = qc.simulateevolution(pulseseq, params, dec) phonons[i] = qc.indexToState(np.nonzero(data.Yend)[0][0], hspace)[0] pbar.update(int(1.*(i+1)*100/numRuns)) epsilon = np.abs(maxDelay/params.heatingrate - np.mean(phonons)) return epsilon < 2*np.std(phonons) # allow 2 sigma deviation
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_heating_detailed(figNum): NumberOfIons = 1 NumberofPhonons = 10 hspace = sim.hspace(NumberOfIons, 2, NumberofPhonons, 0) params = sim.parameters(hspace) dec = sim.decoherence(params) # since data.RhoPNAll doesn't save phonons, we'll have to simulate sequentially numRuns = 5 phonons = np.zeros(numRuns) dec.doRandNtimes = 1 dec.dict['heating'] = True dec.progbar = False params.progbar = False params.heatingrate = 250 maxDelay = 1000 pulseseq = sim.PulseSequence( [ \ sim.Delay(params, maxDelay), \ ] ) widgets = [progbar.Percentage(), ' ', progbar.Bar(), ' ', progbar.ETA()] pbar = progbar.ProgressBar(widgets=widgets).start() for i in range(numRuns): data = qc.simulateevolution(pulseseq, params, dec) phonons[i] = qc.indexToState(np.nonzero(data.Yend)[0][0], hspace)[0] pbar.update(int(1. * (i + 1) * 100 / numRuns)) epsilon = np.abs(maxDelay / params.heatingrate - np.mean(phonons)) return epsilon < 2 * np.std(phonons) # allow 2 sigma deviation
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 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 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 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 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 loadsimdata(self, data, print_fidelities=False): ''' load simulation data directly from variables ''' try: # data is a database object self.data = data self.data.RhoPNAll = np.array(self.data.RhoPNAll) self.rhosim = self.data.RhoPN except AttributeError: # or it's just the densmats # make a dummy data object self.data = sim.database(np.zeros(1), np.zeros(1), sim.hspace(1,2,0,0)) self.data.RhoPNAll = data self.simloaded = True if print_fidelities: for i in range(np.min([len(self.rhosim), len(self.rho)])): print i, ": ", U.jozsafid(self.rho[i], self.rhosim[i])
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 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.doRandNtimes = 1000 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 test_spontdecay_detailed(figNum): NumberOfIons = 1 NumberofPhonons = 1 hspace = sim.hspace(NumberOfIons, 2, NumberofPhonons, 0) params = sim.parameters(hspace) dec = sim.decoherence(params) dec.doRandNtimes = 100 dec.dict['spontdecay'] = True dec.doPP = True dec.doPPprintstats = False dec.progbar = False # for the test we set it to 300 mus, instead of 1.168 s params.lifetime = 300 params.y0[qc.stateToIndex(NumberOfIons * 'D' + ',0', hspace)] = 1 params.y0[qc.stateToIndex(NumberOfIons * 'S' + ',0', hspace)] = 0 pulseseq = sim.PulseSequence( [ \ sim.Delay(params, 1000), \ ] ) data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(figNum) # fitting part p0 = [1, params.lifetime] fitfun = lambda p, x: p[0] * np.exp(-x / float(p[1])) errfun = lambda p, x, y: y - fitfun(p, x) x = data.T y = data.YtrN[:, 0] par, covmat, infodict, mesg, ier = leastsq(errfun, p0, args=(x, y), full_output=True) epsilon = 50 # with 100 iterations allow 50us offset in decay time # print(np.abs(par[-1] - params.lifetime)) return np.abs(par[-1] - params.lifetime) < epsilon
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 test_spontdecay_detailed(figNum): NumberOfIons = 1 NumberofPhonons = 1 hspace = sim.hspace(NumberOfIons,2,NumberofPhonons,0) params = sim.parameters(hspace) dec = sim.decoherence(params) dec.doRandNtimes = 100 dec.dict['spontdecay'] = True dec.doPP = True dec.doPPprintstats = False dec.progbar = False # for the test we set it to 300 mus, instead of 1.168 s params.lifetime = 300 params.y0[qc.stateToIndex(NumberOfIons*'D'+',0', hspace)] = 1 params.y0[qc.stateToIndex(NumberOfIons*'S'+',0', hspace)] = 0 pulseseq = sim.PulseSequence( [ \ sim.Delay(params, 1000), \ ] ) data = qc.simulateevolution(pulseseq, params, dec) data.tracedpopulation(figNum) # fitting part p0 = [1, params.lifetime] fitfun = lambda p, x: p[0] * np.exp(-x / float(p[1])) errfun = lambda p, x, y: y-fitfun(p,x) x = data.T y = data.YtrN[:,0] par, covmat, infodict, mesg, ier = leastsq(errfun, p0, args=(x,y), full_output = True) epsilon = 50 # with 100 iterations allow 50us offset in decay time # print np.abs(par[-1] - params.lifetime) return np.abs(par[-1] - params.lifetime) < epsilon
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
''' test of MS gates ''' import numpy as np import PyTIQC.core.simtools as sim import PyTIQC.core.qctools as qc import time import matplotlib.pyplot as pl import PyTIQC.tools.progressbar as progbar import scipy.optimize as spop pi = np.pi NumberOfIons = 2 PhononOverhead = 7 hspace = sim.hspace(NumberOfIons,2,NumberOfIons+PhononOverhead,0) params = sim.parameters(hspace) dec = sim.decoherence(params) #dec.doRandNtimes = 1 #dec.dict['all'] = True #dec.doPP = False #params.use_servers( ['local']) params.progbar = True #params.shortestMS = 4 params.calcPulseParams() pulseseq = sim.PulseSequence( [ \ # sim.Hide(params, 3, True), # sim.Hide(params, 4, True), sim.RMS(params, pi/2, 0),
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)
import numpy as np import PyTIQC.core.simtools as sim import PyTIQC.core.qctools as qc pi = np.pi 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()
''' a 2-ion CNOT in a 3-ion chain based on pulse sequence from Nebendahl (2009) ''' import numpy as np import PyTIQC.core.simtools as sim import PyTIQC.core.qctools as qc import matplotlib.pyplot as pl 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),
''' Cirac-Zoller CNOT ''' 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)
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)
''' Cirac-Zoller CNOT ''' import PyTIQC 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)
def main(): ### run params ################################## pulseseqfileShor = 'experiments/Shorseq.py' firstMultMap = True # Do first multiplication with CNOT # mapping instead of Multiplier # (does nothing in easy cases) select_a = 7 # Factoring base: 2, 4, 7, 8, 13, 11, or 14 doRun = True doIdeal = True printpulse = False saveKitaev = False doPPKitaev = True print 'a =',select_a NumberOfIons = 5 NumberOfPhonons = 0 if doIdeal else 7 hspace = sim.hspace(NumberOfIons,2,NumberOfPhonons,0) hspace.initial_state("quantum", qstate='DSSSS') params = sim.parameters(hspace) params.use_servers( ['all'] ) params.ppcpus = 16 params.shortestMS = 16 params.calcPulseParams() params.progbar = True params.saveallpoints = False params.coherenceTime = 15000 params.hidingerr = 1 params.printpulse = printpulse params.progbar = printpulse params.pplog = False dec = sim.decoherence(params) dec.doRandNtimes = 16 dec.doPP = True dec.dict['all'] = True # if doPPKitaev: params.ppcpus = 2 Kit = Kitaev.Kitaev() ########################################## # load the pulse sequences # change ion order and define permutations ########################################## execfile(pulseseqfileShor,locals(),globals()) Fred12 = copy.deepcopy(Fredkin) Fred23 = copy.deepcopy(Fredkin) Fred34 = copy.deepcopy(Fredkin) Fred24 = copy.deepcopy(Fredkin) Fred13 = copy.deepcopy(Fredkin) Fred12.changeions(params, (1,2,0)) Fred23.changeions(params, (2,3,0)) Fred34.changeions(params, (3,4,0)) Fred24.changeions(params, (2,4,0)) Fred13.changeions(params, (1,3,0)) cnot13 = copy.deepcopy(cnot12) cnot24 = copy.deepcopy(cnot12) cnot13.changeions(params,(0,1,3)) cnot24.changeions(params,(0,2,4)) times2 = sim.PulseSequence([ \ sim.Hide(params, 3, True), sim.Hide(params, 4, True), #vis: 1,2 Fred12, sim.Hide(params, 3, False), sim.Hide(params, 1, True), #vis: 2,3 Fred23, sim.Hide(params, 4, False), sim.Hide(params, 2, True), #vis: 3,4 Fred34, sim.Hide(params, 1, False), sim.Hide(params, 2, False) #vis: 1,2,3,4 ]) times4 = sim.PulseSequence([ \ sim.Hide(params, 1, True), sim.Hide(params, 3, True), #vis: 2,4 Fred24, sim.Hide(params, 1, False), sim.Hide(params, 3, False), sim.Hide(params, 2, True), sim.Hide(params, 4, True), #vis: 1,3 Fred13, sim.Hide(params, 2, False), sim.Hide(params, 4, False) ]) times8 = sim.PulseSequence([ \ sim.Hide(params, 1, True), sim.Hide(params, 2, True), #vis: 3,4 Fred34, sim.Hide(params, 2, False), sim.Hide(params, 4, True), #vis: 2,3 Fred23, sim.Hide(params, 1, False), sim.Hide(params, 3, True), #vis: 1,2 Fred12, sim.Hide(params, 3, False), sim.Hide(params, 4, False) ]) times13 = copy.deepcopy(times8) times13.append(cnot1234) times7 = copy.deepcopy(times2) times7.append(cnot1234) ### general pulse sequence def GeneratePulseSeq(a): NOP = sim.PulseSequence([sim.Delay(params, 0.1)]) if a in (2,7,8,13): # hard cases if firstMultMap: a2modN = cnot24 else: a2modN = times4 else: # easy cases a2modN = NOP if a == 2: amodN = times2 elif a == 7: amodN = times7 elif a == 8: amodN = times8 elif a == 13: amodN = times13 elif a == 4: amodN = cnot24 elif a == 11: amodN = cnot13 elif a == 14: amodN = cnot1234 pulseseq_group = Kit.GeneratePulseSeq(params, [NOP, a2modN, amodN]) return pulseseq_group ####################################################### pulseseq = GeneratePulseSeq(select_a) if doIdeal: for ps in pulseseq: for pulse in ps: pulse.use_ideal = True ### run it if doRun: tic = time.time() result = Kit.simulateevolution(pulseseq, params, dec, doPP=doPPKitaev) if not doIdeal: print "runtime: ", time.time()-tic, "sec" print np.around(result,6) if saveKitaev: timestr = datetime.datetime.now().strftime('%Y%m%d-%H%M%S-%f') fnameappend = '' Kit.getQFTall() Kit.datagroupsave('Shor'+str(select_a)+'-data-'+fnameappend+timestr+'.pk', RhoOnly=True) Kit.resultSave('Shor'+str(select_a)+'-res-'+fnameappend+timestr+'.npy') f = open('Shor'+str(select_a)+'-params-'+fnameappend+timestr+'.pk', 'wb') pickle.dump(dec.dict_params_static, f) f.close() return True#dataobj
def main(): ### run params ################################## pulseseqfileShor = 'experiments/Shorseq_6qubit.py' firstMultMap = True # Do first multiplication with CNOT # mapping instead of Multiplier # (does nothing in easy cases) select_a = 4 # Factoring base: 2,4,5,8,10,11,13,16,17,19 doRun = True doIdeal = True printpulse = False saveKitaev = False doPPKitaev = True print 'N = 21, a =',select_a NumberOfIons = 6 NumberOfPhonons = 0 if doIdeal else 7 hspace = sim.hspace(NumberOfIons,2,NumberOfPhonons,0) hspace.initial_state("quantum", qstate='DSSSSS') params = sim.parameters(hspace) params.use_servers( ['all'] ) params.ppcpus = 16 params.shortestMS = 16 params.calcPulseParams() params.progbar = True params.saveallpoints = False params.coherenceTime = 15000 params.hidingerr = 1 params.printpulse = printpulse params.progbar = printpulse params.pplog = False dec = sim.decoherence(params) dec.doRandNtimes = 1 #16 dec.doPP = True dec.dict['all'] = False # if doPPKitaev: params.ppcpus = 2 Kit = Kitaev.Kitaev() ########################################## # load the pulse sequences # change ion order and define permutations ########################################## execfile(pulseseqfileShor,locals(),globals()) cnot12_6 = sim.PulseSequence([ cnot12 ]) Fred35 = copy.deepcopy(Fredkin) Fred13 = copy.deepcopy(Fredkin) Fred35.changeions(params, (3,5,0)) Fred13.changeions(params, (1,3,0)) cnot15 = copy.deepcopy(cnot12_6) cnot23 = copy.deepcopy(cnot12_6) cnot24 = copy.deepcopy(cnot12_6) cnot25 = copy.deepcopy(cnot12_6) cnot35 = copy.deepcopy(cnot12_6) cnot15.changeions(params,(0,1,5)) cnot23.changeions(params,(0,2,3)) cnot24.changeions(params,(0,2,4)) cnot25.changeions(params,(0,2,5)) cnot35.changeions(params,(0,3,5)) times4 = sim.PulseSequence([ \ sim.Hide(params, 1, True), sim.Hide(params, 2, True), sim.Hide(params, 4, True), #vis: 3,5 Fred35, sim.Hide(params, 1, False), sim.Hide(params, 5, True), #vis: 1,3 Fred13, sim.Hide(params, 2, False), sim.Hide(params, 4, False), sim.Hide(params, 5, False) ]) times16 = sim.PulseSequence([ \ sim.Hide(params, 2, True), sim.Hide(params, 4, True), sim.Hide(params, 5, True), #vis: 1,3 Fred35, sim.Hide(params, 5, False), sim.Hide(params, 1, True), #vis: 3,5 Fred13, sim.Hide(params, 1, False), sim.Hide(params, 2, False), sim.Hide(params, 4, False) ]) ### general pulse sequence def GeneratePulseSeq(a): NOP = sim.PulseSequence([sim.Delay(params, 0.1)]) if a in (2,5,16,19): # a^2=4 cases if firstMultMap: a16modN = cnot15 else: a16modN = times16 a8modN = times4 a4modN = times16 a2modN = times4 if a == 16: a1modN = times16 else: a1modN = cnot24 # only cheating method implimented... elif a in (4,10,11,17): # a^2=16 cases if firstMultMap: a16modN = cnot13 else: a16modN = times4 a8modN = times16 a4modN = times4 a2modN = times16 if a == 4: a1modN = times4 else: a1modN = cnot24 # only cheating method implimented... elif a in (8,13): a16modN = NOP a8modN = NOP a4modN = NOP a2modN = NOP if a == 8: a1modN = cnot25 elif a == 13: a1modN = cnot23 oplist = [a16modN, a8modN, a4modN, a2modN, a1modN] pulseseq_group = Kit.GeneratePulseSeq(params, oplist) return pulseseq_group ####################################################### pulseseq = GeneratePulseSeq(select_a) if doIdeal: for ps in pulseseq: for pulse in ps: pulse.use_ideal = True ### run it if doRun: tic = time.time() result = Kit.simulateevolution(pulseseq, params, dec, doPP=doPPKitaev) if not doIdeal: print "runtime: ", time.time()-tic, "sec" print np.around(result,6) if saveKitaev: timestr = datetime.datetime.now().strftime('%Y%m%d-%H%M%S-%f') fnameappend = '' Kit.getQFTall() Kit.datagroupsave('Shor'+str(select_a)+'-data-'+fnameappend+timestr+'.pk', RhoOnly=True) Kit.resultSave('Shor'+str(select_a)+'-res-'+fnameappend+timestr+'.npy') f = open('Shor'+str(select_a)+'-params-'+fnameappend+timestr+'.pk', 'wb') pickle.dump(dec.dict_params_static, f) f.close() return True#dataobj
def main(): ### run params ################################## pulseseqfileShor = 'experiments/Shorseq_6qubit.py' firstMultMap = True # Do first multiplication with CNOT # mapping instead of Multiplier # (does nothing in easy cases) select_a = 4 # Factoring base: 2,4,5,8,10,11,13,16,17,19 doRun = True doIdeal = True printpulse = False saveKitaev = False doPPKitaev = True print('N = 21, a =', select_a) NumberOfIons = 6 NumberOfPhonons = 0 if doIdeal else 7 hspace = sim.hspace(NumberOfIons, 2, NumberOfPhonons, 0) hspace.initial_state("quantum", qstate='DSSSSS') params = sim.parameters(hspace) params.use_servers(['all']) params.ppcpus = 16 params.shortestMS = 16 params.calcPulseParams() params.progbar = True params.saveallpoints = False params.coherenceTime = 15000 params.hidingerr = 1 params.printpulse = printpulse params.progbar = printpulse params.pplog = False dec = sim.decoherence(params) dec.doRandNtimes = 1 #16 dec.doPP = True dec.dict['all'] = False # if doPPKitaev: params.ppcpus = 2 Kit = Kitaev.Kitaev() ########################################## # load the pulse sequences # change ion order and define permutations ########################################## # execfile(pulseseqfileShor,locals(),globals()) def makeexec(f): f = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', f)) c = compile(open(f, 'rb').read(), f, 'exec') return c exec(makeexec(pulseseqfileShor)) cnot12_6 = sim.PulseSequence([cnot12]) Fred35 = copy.deepcopy(Fredkin) Fred13 = copy.deepcopy(Fredkin) Fred35.changeions(params, (3, 5, 0)) Fred13.changeions(params, (1, 3, 0)) cnot15 = copy.deepcopy(cnot12_6) cnot23 = copy.deepcopy(cnot12_6) cnot24 = copy.deepcopy(cnot12_6) cnot25 = copy.deepcopy(cnot12_6) cnot35 = copy.deepcopy(cnot12_6) cnot15.changeions(params, (0, 1, 5)) cnot23.changeions(params, (0, 2, 3)) cnot24.changeions(params, (0, 2, 4)) cnot25.changeions(params, (0, 2, 5)) cnot35.changeions(params, (0, 3, 5)) times4 = sim.PulseSequence([ \ sim.Hide(params, 1, True), sim.Hide(params, 2, True), sim.Hide(params, 4, True), #vis: 3,5 Fred35, sim.Hide(params, 1, False), sim.Hide(params, 5, True), #vis: 1,3 Fred13, sim.Hide(params, 2, False), sim.Hide(params, 4, False), sim.Hide(params, 5, False) ]) times16 = sim.PulseSequence([ \ sim.Hide(params, 2, True), sim.Hide(params, 4, True), sim.Hide(params, 5, True), #vis: 1,3 Fred35, sim.Hide(params, 5, False), sim.Hide(params, 1, True), #vis: 3,5 Fred13, sim.Hide(params, 1, False), sim.Hide(params, 2, False), sim.Hide(params, 4, False) ]) ### general pulse sequence def GeneratePulseSeq(a): NOP = sim.PulseSequence([sim.Delay(params, 0.1)]) if a in (2, 5, 16, 19): # a^2=4 cases if firstMultMap: a16modN = cnot15 else: a16modN = times16 a8modN = times4 a4modN = times16 a2modN = times4 if a == 16: a1modN = times16 else: a1modN = cnot24 # only cheating method implimented... elif a in (4, 10, 11, 17): # a^2=16 cases if firstMultMap: a16modN = cnot13 else: a16modN = times4 a8modN = times16 a4modN = times4 a2modN = times16 if a == 4: a1modN = times4 else: a1modN = cnot24 # only cheating method implimented... elif a in (8, 13): a16modN = NOP a8modN = NOP a4modN = NOP a2modN = NOP if a == 8: a1modN = cnot25 elif a == 13: a1modN = cnot23 oplist = [a16modN, a8modN, a4modN, a2modN, a1modN] pulseseq_group = Kit.GeneratePulseSeq(params, oplist) return pulseseq_group ####################################################### pulseseq = GeneratePulseSeq(select_a) if doIdeal: for ps in pulseseq: for pulse in ps: pulse.use_ideal = True ### run it if doRun: tic = time.time() result = Kit.simulateevolution(pulseseq, params, dec, doPP=doPPKitaev) if not doIdeal: print("runtime: ", time.time() - tic, "sec") print(np.around(result, 6)) if saveKitaev: timestr = datetime.datetime.now().strftime('%Y%m%d-%H%M%S-%f') fnameappend = '' Kit.getQFTall() Kit.datagroupsave('Shor' + str(select_a) + '-data-' + fnameappend + timestr + '.pk', RhoOnly=True) Kit.resultSave('Shor' + str(select_a) + '-res-' + fnameappend + timestr + '.npy') f = open( 'Shor' + str(select_a) + '-params-' + fnameappend + timestr + '.pk', 'wb') pickle.dump(dec.dict_params_static, f) f.close() return True #dataobj
""" scan of carrier transition varying detuning, showing spectrum """ import numpy as np import PyTIQC.core.simtools as sim import PyTIQC.core.qctools as qc import PyTIQC.tools.progressbar as progbar import matplotlib.pyplot as pl pi = np.pi NumberOfIons = 1 NumberofPhonons = 1 hspace = sim.hspace(NumberOfIons, 2, NumberofPhonons, 0) hspace.initial_state("thermal", nBar=0.5) params = sim.parameters(hspace) dec = sim.decoherence(params) 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]
''' test script for AC Stark pulse. do a single AC stark pulse and show the state evolution. ''' import numpy as np import PyTIQC.core.simtools as sim import PyTIQC.core.qctools as qc import matplotlib.pyplot as pl import scipy.optimize as spop pi = np.pi hspace = sim.hspace(1, 2, 0, 0) 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) \ ] )