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 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 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
''' 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) ])
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
#params.y0[qc.stateToIndex('SDD' + ',0', hspace)] = 0.25-0.25j
''' 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
dec.dict['none'] = True # not doIdeal # if doPPKitaev: params.ppcpus = 2 Kit = Kitaev.Kitaev() ########################################## # load the pulse sequences # 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),
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)
#pl.plot(data.T, np.sum(data.YR,axis=1))