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)
