def gkp(hilbert_size, delta, mu=0, zrange=20):
"""Generates a GKP state.
For a detailed discussion on the definition see
`Albert, Victor V. et al. “Performance and Structure of Single-Mode Bosonic Codes.” Physical Review A 97.3 (2018) <https://arxiv.org/abs/1708.05010>`_
and `Ahmed, Shahnawaz et al., “Classification and reconstruction of quantum states with neural networks.” Journal <https://arxiv.org/abs/1708.05010>`_
Args:
hilbert_size (int): Hilbert space size (cutoff).
delta (float):
mu (int, optional): Logical encoding (0/1)
default: 0
zrange (int, optional): The number of lattice points to loop over to construct
the grid of states. This depends on the Hilbert space
size and the delta value.
default: 20
Returns:
:class:`qutip.Qobj`: GKP state.
"""
gkp = 0 * coherent(hilbert_size, 0)
c = np.sqrt(np.pi / 2)
zrange = range(-20, 20)
for n1 in zrange:
for n2 in zrange:
a = c * (2 * n1 + mu + 1j * n2)
alpha = coherent(hilbert_size, a)
gkp += (np.exp(-(delta**2) * np.abs(a)**2) *
np.exp(-1j * c**2 * 2 * n1 * n2) * alpha)
ket = gkp.unit()
return ket
def H_2cat(alpha):
C_p = (qt.coherent(NFock, alpha) + qt.coherent(NFock, -alpha)).unit()
C_m = (qt.coherent(NFock, alpha) - qt.coherent(NFock, -alpha)).unit()
H = -(qt.ket2dm(C_p) - qt.ket2dm(C_m))
return H
def testCoherentState(self):
"""
states: coherent state
"""
N = 10
alpha = 0.5
c1 = coherent(N, alpha) # displacement method
c2 = coherent(7, alpha, offset=3) # analytic method
assert_(abs(expect(destroy(N), c1) - alpha) < 1e-10)
assert_((c1[3:]-c2).norm() < 1e-7)
def testCoherentState(self):
"""
states: coherent state
"""
N = 10
alpha = 0.5
c1 = coherent(N, alpha) # displacement method
c2 = coherent(7, alpha, offset=3) # analytic method
assert_(abs(expect(destroy(N), c1) - alpha) < 1e-10)
assert_((c1[3:] - c2).norm() < 1e-7)
def test_CoherentState():
N = 10
alpha = 0.5
c1 = qutip.coherent(N, alpha) # displacement method
c2 = qutip.coherent(7, alpha, offset=3) # analytic method
c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
with pytest.raises(ValueError) as e:
qutip.coherent(N, alpha, method="other")
assert str(e.value) == ("The method option can only take "
"values 'operator' or 'analytic'")
def test_ssesolve_bad_e_ops():
tol = 0.01
N = 4
ntraj = 10
nsubsteps = 100
a = destroy(N)
b = destroy(N - 1)
H = [num(N)]
psi0 = coherent(N, 2.5)
sc_ops = [a + a.dag()]
e_ops = [a.dag() * a, a + a.dag(), (-1j) * (b - b.dag()), qeye(N + 1)]
times = np.linspace(0, 10, 101)
with pytest.raises(TypeError) as exc:
res = ssesolve(H,
psi0,
times,
sc_ops,
e_ops,
solver=None,
noise=1,
ntraj=ntraj,
nsubsteps=nsubsteps,
method='homodyne',
map_func=parallel_map)
def test_ssesolve_heterodyne():
"Stochastic: ssesolve: heterodyne, time-dependent H"
tol = 0.01
N = 4
gamma = 0.25
ntraj = 25
nsubsteps = 100
a = destroy(N)
H = [[a.dag() * a,f]]
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
times = np.linspace(0, 2.5, 50)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
res = ssesolve(H, psi0, times, sc_ops, e_ops,
ntraj=ntraj, nsubsteps=nsubsteps,
method='heterodyne', store_measurement=True,
map_func=parallel_map, args={"a":2})
assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))]))
assert_(len(res.measurement) == ntraj)
assert_(all([m.shape == (len(times), len(sc_ops), 2)
for m in res.measurement]))
def test_ssesolve_feedback():
"Stochastic: ssesolve: time-dependent H with feedback"
tol = 0.01
N = 4
ntraj = 10
nsubsteps = 100
a = destroy(N)
H = [num(N)]
psi0 = coherent(N, 2.5)
sc_ops = [[a + a.dag(), f_dargs]]
e_ops = [a.dag() * a, a + a.dag(), (-1j) * (a - a.dag()), qeye(N)]
times = np.linspace(0, 10, 101)
res_ref = mesolve(H,
psi0,
times,
sc_ops,
e_ops,
args={"expect_op_3": qeye(N)})
res = ssesolve(H,
psi0,
times,
sc_ops,
e_ops,
solver=None,
noise=1,
ntraj=ntraj,
nsubsteps=nsubsteps,
method='homodyne',
map_func=parallel_map,
args={"expect_op_3": qeye(N)})
def test_ssesolve_homodyne():
"Stochastic: smesolve: homodyne"
tol = 0.01
N = 4
gamma = 0.25
ntraj = 25
nsubsteps = 100
a = destroy(N)
H = a.dag() * a
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a]
e_ops = [a.dag() * a, a + a.dag(), (-1j) * (a - a.dag())]
times = np.linspace(0, 2.5, 50)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops)
res = smesolve(
H,
psi0,
times,
[],
sc_ops,
e_ops,
ntraj=ntraj,
nsubsteps=nsubsteps,
method="homodyne",
store_measurement=True,
map_func=parallel_map,
)
assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol for idx in range(len(e_ops))]))
assert_(len(res.measurement) == ntraj)
assert_(all([m.shape == (len(times), len(sc_ops)) for m in res.measurement]))
def test_smesolve_photocurrent():
"Stochastic: photocurrent_mesolve"
tol = 0.01
N = 4
gamma = 0.25
ntraj = 20
nsubsteps = 100
a = destroy(N)
H = [[a.dag() * a,f]]
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
times = np.linspace(0, 1.0, 21)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
ntraj=ntraj, nsubsteps=nsubsteps, store_measurement=True,
map_func=parallel_map)
assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))]))
assert_(len(res.measurement) == ntraj)
assert_(all([m.shape == (len(times), len(sc_ops))
for m in res.measurement]))
def test_smesolve_photocurrent():
"Stochastic: photocurrent_mesolve"
tol = 0.01
N = 4
gamma = 0.25
ntraj = 20
nsubsteps = 100
a = destroy(N)
H = [[a.dag() * a,f]]
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
times = np.linspace(0, 1.0, 21)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
ntraj=ntraj, nsubsteps=nsubsteps, store_measurement=True,
map_func=parallel_map)
assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))]))
assert_(len(res.measurement) == ntraj)
assert_(all([m.shape == (len(times), len(sc_ops))
for m in res.measurement]))
def setup(N):
alpha = 0.7
xvec = np.linspace(-50, 50, 100)
yvec = np.linspace(-50, 50, 100)
state = qt.coherent(N, alpha)
op = state * state.dag()
return op, xvec, yvec
def cat(hilbert_size, alpha=None, S=None, mu=None):
"""
Generates a cat state. For a detailed discussion on the definition
see `Albert, Victor V. et al. “Performance and Structure of Single-Mode Bosonic Codes.” Physical Review A 97.3 (2018) <https://arxiv.org/abs/1708.05010>`_
and `Ahmed, Shahnawaz et al., “Classification and reconstruction of quantum states with neural networks.” Journal <https://arxiv.org/abs/1708.05010>`_
Args:
-----
N (int): Hilbert size dimension.
alpha (complex64): Complex number determining the amplitude.
S (int): An integer >= 0 determining the number of coherent states used
to generate the cat superposition. S = {0, 1, 2, ...}.
corresponds to {2, 4, 6, ...} coherent state superpositions.
mu (int): An integer 0/1 which generates the logical 0/1 encoding of
a computational state for the cat state.
Returns:
-------
cat (:class:`qutip.Qobj`): Cat state density matrix
"""
if alpha == None:
alpha = random_alpha(2, 3)
if S == None:
S = np.random.randint(0, 3)
if mu is None:
mu = np.random.randint(0, 2)
kend = 2 * S + 1
cstates = 0 * (coherent(hilbert_size, 0))
for k in range(0, int((kend + 1) / 2)):
sign = 1
if k >= S:
sign = (-1) ** int(mu > 0.5)
prefactor = np.exp(1j * (np.pi / (S + 1)) * k)
cstates += sign * coherent(hilbert_size, prefactor * alpha * (-((1j) ** mu)))
cstates += sign * coherent(hilbert_size, -prefactor * alpha * (-((1j) ** mu)))
rho = cstates * cstates.dag()
return rho.unit(), mu
def qfunc_rere(N, rho, x_vec):
#if(rho.type == 'ket'):
# rho = qt.ket2dm(rho)
#elif(rho.type is not 'oper'):
# print('invalid type')
num_points = len(x_vec)
Q = np.zeros((num_points, num_points), dtype = complex)
for i, j in itertools.product(range(num_points), range(num_points)):
#a = qt.tensor(qt.coherent(N, x_vec[i]), qt.qeye(N))
#b = qt.tensor(qt.qeye(N), qt.coherent(N, x_vec[j]))
alpha = np.array(qt.tensor(qt.coherent(N, x_vec[i]), qt.coherent(N, x_vec[j])).full())
Q[i][j] = np.absolute(np.matmul(np.matmul(alpha.T, rho), alpha))
#Q[i][j] = (2*np.pi)**2 * a.dag()*(b.dag()*rho*b)*a
#Q[i][j] = (2*np.pi)**2 * a
return Q
def test_against_naive_implementation(self, xs, ys, g, size):
state = qutip.rand_dm(size)
state_np = state.full()
x, y = np.meshgrid(xs, ys)
alphas = 0.5 * g * (x + 1j * y)
naive = np.empty(alphas.shape, dtype=np.float64)
for i, alpha in enumerate(alphas.flat):
coh = qutip.coherent(size, alpha, method='analytic').full()
naive.flat[i] = (coh.conj().T @ state_np @ coh).real
naive *= (0.5 * g)**2 / np.pi
np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
def test_ket2dm():
N = 5
ket = qutip.coherent(N, 2)
bra = ket.dag()
oper = qutip.ket2dm(ket)
oper_from_bra = qutip.ket2dm(bra)
assert qutip.expect(oper, ket) == pytest.approx(1.)
assert qutip.isoper(oper)
assert oper == ket * bra
assert oper == oper_from_bra
with pytest.raises(TypeError) as e:
qutip.ket2dm(oper)
assert str(e.value) == "Input is not a ket or bra vector."
def test_general_stochastic():
"Stochastic: general_stochastic"
"Reproduce smesolve homodyne"
tol = 0.025
N = 4
gamma = 0.25
ntraj = 20
nsubsteps = 50
a = destroy(N)
H = [[a.dag() * a, f]]
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
e_ops = [a.dag() * a, a + a.dag(), (-1j) * (a - a.dag())]
L = liouvillian(QobjEvo([[a.dag() * a, f]], args={"a": 2}), c_ops=sc_ops)
L.compile()
sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
[op.compile() for op in sc_opsM]
e_opsM = [spre(op) for op in e_ops]
def d1(t, vec):
return L.mul_vec(t, vec)
def d2(t, vec):
out = []
for op in sc_opsM:
out.append(op.mul_vec(t, vec) - op.expect(t, vec) * vec)
return np.stack(out)
times = np.linspace(0, 0.5, 13)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a": 2})
list_methods_tol = ['euler-maruyama', 'platen', 'explicit15']
for solver in list_methods_tol:
res = general_stochastic(ket2dm(psi0),
times,
d1,
d2,
len_d2=2,
e_ops=e_opsM,
normalize=False,
ntraj=ntraj,
nsubsteps=nsubsteps,
solver=solver)
assert_(
all([
np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))
]))
assert_(len(res.measurement) == ntraj)
def gkp(hilbert_size, delta=None, mu = None):
"""Generates a GKP state
"""
gkp = 0*coherent(hilbert_size, 0)
c = np.sqrt(np.pi/2)
if mu is None:
mu = np.random.randint(2)
if delta is None:
delta = np.random.uniform(0.2, .50)
zrange = range(-20, 20)
for n1 in zrange:
for n2 in zrange:
a = c*(2*n1 + mu + 1j*n2)
alpha = coherent(hilbert_size, a)
gkp += np.exp(-delta**2*np.abs(a)**2)*np.exp(-1j*c**2 * 2*n1 * n2)*alpha
rho = gkp*gkp.dag()
return rho.unit(), mu
def test_CoherentState():
N = 10
alpha = 0.5
c1 = qutip.coherent(N, alpha) # displacement method
c2 = qutip.coherent(7, alpha, offset=3) # analytic method
c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
with pytest.raises(ValueError) as e:
qutip.coherent(N, alpha, method="other")
assert str(e.value) == ("The method option can only take "
"values 'operator' or 'analytic'")
with pytest.raises(ValueError) as e:
qutip.coherent(N, alpha, offset=-1)
assert str(e.value) == ("Offset must be non-negative")
with pytest.raises(ValueError) as e:
qutip.coherent(N, alpha, offset=1, method="operator")
assert str(e.value) == (
"The method 'operator' does not support offset != 0. Please"
" select another method or set the offset to zero.")
def H_4cat(alpha):
C_p = (qt.coherent(NFock, alpha) + qt.coherent(NFock, -alpha)).unit()
C_m = (qt.coherent(NFock, alpha) - qt.coherent(NFock, -alpha)).unit()
C_ip = (qt.coherent(NFock, 1j * alpha) +
qt.coherent(NFock, -1j * alpha)).unit()
C_im = (qt.coherent(NFock, 1j * alpha) -
qt.coherent(NFock, -1j * alpha)).unit()
C_0 = (C_p + C_ip).unit()
C_1 = (C_m + -1j * C_im).unit()
C_2 = (C_p - C_ip).unit()
C_3 = (C_m + 1j * C_im).unit()
H = -(qt.ket2dm(C_0) + qt.ket2dm(C_2) - qt.ket2dm(C_1) - qt.ket2dm(C_3))
return H
def test_mc_seed_noreuse():
"Monte-carlo: check not reusing seeds"
N0 = 6
N1 = 6
N2 = 6
# damping rates
gamma0 = 0.1
gamma1 = 0.4
gamma2 = 0.1
alpha = np.sqrt(2) # initial coherent state param for mode 0
tlist = np.linspace(0, 10, 2)
ntraj = 500 # number of trajectories
# define operators
a0 = tensor(destroy(N0), qeye(N1), qeye(N2))
a1 = tensor(qeye(N0), destroy(N1), qeye(N2))
a2 = tensor(qeye(N0), qeye(N1), destroy(N2))
# number operators for each mode
num0 = a0.dag() * a0
num1 = a1.dag() * a1
num2 = a2.dag() * a2
# dissipative operators for zero-temp. baths
C0 = np.sqrt(2.0 * gamma0) * a0
C1 = np.sqrt(2.0 * gamma1) * a1
C2 = np.sqrt(2.0 * gamma2) * a2
# initial state: coherent mode 0 & vacuum for modes #1 & #2
psi0 = tensor(coherent(N0, alpha), basis(N1, 0), basis(N2, 0))
# trilinear Hamiltonian
H = 1j * (a0 * a1.dag() * a2.dag() - a0.dag() * a1 * a2)
# run Monte-Carlo
data1 = mcsolve(H,
psi0,
tlist, [C0, C1, C2], [num0, num1, num2],
ntraj=ntraj)
data2 = mcsolve(H,
psi0,
tlist, [C0, C1, C2], [num0, num1, num2],
ntraj=ntraj)
diff_flag = False
for k in range(ntraj):
if len(data1.col_times[k]) != len(data2.col_times[k]):
diff_flag = 1
break
else:
if not np.allclose(data1.col_which[k], data2.col_which[k]):
diff_flag = 1
break
assert_equal(diff_flag, 1)
def f(N, options):
eta = 1.5
wc = 1.8
wl = 2.
delta_c = wl - wc
alpha0 = 0.3 - 0.5j
tspan = np.linspace(0, 10, 11)
a = qt.destroy(N)
at = qt.create(N)
n = at * a
H = delta_c * n + eta * (a + at)
psi0 = qt.coherent(N, alpha0)
exp_n = qt.mesolve(H, psi0, tspan, [], [n], options=options).expect[0]
return np.real(exp_n)
def test_smesolve_heterodyne():
"Stochastic: smesolve: heterodyne, time-dependent H"
tol = 0.01
N = 4
gamma = 0.25
ntraj = 20
nsubsteps = 100
a = destroy(N)
H = [[a.dag() * a, f]]
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
e_ops = [a.dag() * a, a + a.dag(), (-1j) * (a - a.dag())]
times = np.linspace(0, 1.0, 21)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a": 2})
list_methods_tol = [
'euler-maruyama', 'pc-euler', 'pc-euler-2', 'platen', 'milstein',
'milstein-imp', 'rouchon', 'taylor15', 'taylor15-imp', 'explicit15'
]
for solver in list_methods_tol:
res = smesolve(H,
psi0,
times, [],
sc_ops,
e_ops,
ntraj=ntraj,
nsubsteps=nsubsteps,
args={"a": 2},
method='heterodyne',
store_measurement=True,
solver=solver,
map_func=parallel_map)
assert_(
all([
np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))
]))
assert_(len(res.measurement) == ntraj)
assert_(
all([
m.shape == (len(times), len(sc_ops), 2)
for m in res.measurement
]))
def test_smesolve_bad_e_ops():
"Stochastic: ssesolve: time-dependent H with feedback"
tol = 0.01
N = 4
ntraj = 10
nsubsteps = 100
a = destroy(N)
H = [num(N)]
psi0 = coherent(N, 2.5)
sc_ops = [a + a.dag()]
e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
times = np.linspace(0, 10, 101)
with pytest.raises(TypeError) as exc:
res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
map_func=parallel_map)
def test_mc_seed_noreuse():
"Monte-carlo: check not reusing seeds"
N0 = 6
N1 = 6
N2 = 6
# damping rates
gamma0 = 0.1
gamma1 = 0.4
gamma2 = 0.1
alpha = np.sqrt(2) # initial coherent state param for mode 0
tlist = np.linspace(0, 10, 2)
ntraj = 500 # number of trajectories
# define operators
a0 = tensor(destroy(N0), qeye(N1), qeye(N2))
a1 = tensor(qeye(N0), destroy(N1), qeye(N2))
a2 = tensor(qeye(N0), qeye(N1), destroy(N2))
# number operators for each mode
num0 = a0.dag() * a0
num1 = a1.dag() * a1
num2 = a2.dag() * a2
# dissipative operators for zero-temp. baths
C0 = np.sqrt(2.0 * gamma0) * a0
C1 = np.sqrt(2.0 * gamma1) * a1
C2 = np.sqrt(2.0 * gamma2) * a2
# initial state: coherent mode 0 & vacuum for modes #1 & #2
psi0 = tensor(coherent(N0, alpha), basis(N1, 0), basis(N2, 0))
# trilinear Hamiltonian
H = 1j * (a0 * a1.dag() * a2.dag() - a0.dag() * a1 * a2)
# run Monte-Carlo
data1 = mcsolve(H, psi0, tlist, [C0, C1, C2], [num0, num1, num2],
ntraj=ntraj)
data2 = mcsolve(H, psi0, tlist, [C0, C1, C2], [num0, num1, num2],
ntraj=ntraj)
diff_flag = False
for k in range(ntraj):
if len(data1.col_times[k]) != len(data2.col_times[k]):
diff_flag = 1
break
else:
if not np.allclose(data1.col_which[k],data2.col_which[k]):
diff_flag = 1
break
assert_equal(diff_flag, 1)
def test_general_stochastic():
"Stochastic: general_stochastic"
"Reproduce smesolve homodyne"
tol = 0.025
N = 4
gamma = 0.25
ntraj = 20
nsubsteps = 50
a = destroy(N)
H = [[a.dag() * a,f]]
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
L.compile()
sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
[op.compile() for op in sc_opsM]
e_opsM = [spre(op) for op in e_ops]
def d1(t, vec):
return L.mul_vec(t,vec)
def d2(t, vec):
out = []
for op in sc_opsM:
out.append(op.mul_vec(t,vec)-op.expect(t,vec)*vec)
return np.stack(out)
times = np.linspace(0, 0.5, 13)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
list_methods_tol = ['euler-maruyama',
'platen',
'explicit15']
for solver in list_methods_tol:
res = general_stochastic(ket2dm(psi0),times,d1,d2,len_d2=2, e_ops=e_opsM,
normalize=False, ntraj=ntraj, nsubsteps=nsubsteps,
solver=solver)
assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))]))
assert_(len(res.measurement) == ntraj)
def f(N, options):
kappa = 1.
eta = 1.5
wc = 1.8
wl = 2.
delta_c = wl - wc
alpha0 = 0.3 - 0.5j
tspan = np.linspace(0, 10, 11)
a = qt.destroy(N)
at = qt.create(N)
n = at * a
H = delta_c * n + eta * (a + at)
J = [np.sqrt(kappa) * a]
psi0 = qt.coherent(N, alpha0)
exp_n = qt.mcsolve(H, psi0, tspan, J, [n], ntraj=evals,
options=options).expect[0]
return np.real(exp_n)
def f(N, options):
kappa = 1.
eta = 1.5
wc = 1.8
wl = 2.
# delta_c = wl - wc
alpha0 = 0.3 - 0.5j
tspan = np.linspace(0, 10, 11)
a = qt.destroy(N)
at = qt.create(N)
n = qt.num(N)
J = [np.sqrt(kappa) * a]
psi0 = qt.coherent(N, alpha0)
H = [
wc * n, [eta * a, lambda t, args: np.exp(1j * wl * t)],
[eta * at, lambda t, args: np.exp(-1j * wl * t)]
]
alpha_t = qt.mesolve(H, psi0, tspan, J, [a], options=options).expect[0]
return np.real(alpha_t)
class TestSeeds:
sizes = [6, 6, 6]
dampings = [0.1, 0.4, 0.1]
ntraj = 25 # Big enough to ensure there are differences without being slow
a = [qutip.destroy(size) for size in sizes]
H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag()) -
qutip.tensor(a[0].dag(), a[1], a[2]))
state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
qutip.basis(sizes[1:], [0, 0]))
times = np.linspace(0, 10, 2)
c_ops = [
np.sqrt(2 * dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
(np.sqrt(2 * dampings[1]) *
qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
np.sqrt(2 * dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
]
def test_seeds_can_be_reused(self):
args = (self.H, self.state, self.times)
kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
first = qutip.mcsolve(*args, **kwargs)
options = qutip.Options(seeds=first.seeds)
second = qutip.mcsolve(*args, options=options, **kwargs)
for first_t, second_t in zip(first.col_times, second.col_times):
np.testing.assert_equal(first_t, second_t)
for first_w, second_w in zip(first.col_which, second.col_which):
np.testing.assert_equal(first_w, second_w)
def test_seeds_are_not_reused_by_default(self):
args = (self.H, self.state, self.times)
kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
first = qutip.mcsolve(*args, **kwargs)
second = qutip.mcsolve(*args, **kwargs)
assert not all(
np.array_equal(first_t, second_t)
for first_t, second_t in zip(first.col_times, second.col_times))
assert not all(
np.array_equal(first_w, second_w)
for first_w, second_w in zip(first.col_which, second.col_which))
def test_smesolve_heterodyne():
"Stochastic: smesolve: heterodyne, time-dependent H"
tol = 0.01
N = 4
gamma = 0.25
ntraj = 20
nsubsteps = 100
a = destroy(N)
H = [[a.dag() * a, f]]
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
times = np.linspace(0, 1.0, 21)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
list_methods_tol = ['euler-maruyama',
'pc-euler',
'pc-euler-2',
'platen',
'milstein',
'milstein-imp',
'rouchon',
'taylor15',
'taylor15-imp',
'explicit15']
for solver in list_methods_tol:
res = smesolve(H, psi0, times, [], sc_ops, e_ops,
ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
method='heterodyne', store_measurement=True,
solver=solver, map_func=parallel_map)
assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))]))
assert_(len(res.measurement) == ntraj)
assert_(all([m.shape == (len(times), len(sc_ops), 2)
for m in res.measurement]))
def test_ssesolve_feedback():
"Stochastic: ssesolve: time-dependent H with feedback"
tol = 0.01
N = 4
ntraj = 10
nsubsteps = 100
a = destroy(N)
H = [num(N)]
psi0 = coherent(N, 2.5)
sc_ops = [[a + a.dag(), f_dargs]]
e_ops = [a.dag() * a, a + a.dag(), (-1j) * (a - a.dag()), qeye(N)]
times = np.linspace(0, 10, 101)
res_ref = mesolve(H,
psi0,
times,
sc_ops,
e_ops,
args={"expect_op_3": qeye(N)})
res = smesolve(H,
psi0,
times,
sc_ops=sc_ops,
e_ops=e_ops,
noise=1,
ntraj=ntraj,
nsubsteps=nsubsteps,
method='homodyne',
map_func=parallel_map,
args={"expect_op_3": qeye(N)})
print(
all([
np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))
]))
def test_ssesolve_photocurrent():
"Stochastic: ssesolve: photo-current"
tol = 0.01
N = 4
gamma = 0.25
ntraj = 25
nsubsteps = 100
a = destroy(N)
H = a.dag() * a
psi0 = coherent(N, 0.5)
sc_ops = [np.sqrt(gamma) * a]
e_ops = [a.dag() * a, a + a.dag(), (-1j) * (a - a.dag())]
times = np.linspace(0, 2.5, 50)
res_ref = mesolve(H, psi0, times, sc_ops, e_ops)
res = ssesolve(H,
psi0,
times,
sc_ops,
e_ops,
ntraj=ntraj,
nsubsteps=nsubsteps,
method='photocurrent',
store_measurement=True,
map_func=parallel_map)
assert_(
all([
np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
for idx in range(len(e_ops))
]))
assert_(len(res.measurement) == ntraj)
assert_(
all([m.shape == (len(times), len(sc_ops)) for m in res.measurement]))
def test_displacement(self):
c0 = Cavity("c0", levels=10, kerr=-10e-6)
c1 = Cavity("c1", levels=12, kerr=-10e-6)
system = System("system", modes=[c0, c1])
init_state = system.fock()
for cavity in [c0, c1]:
for _ in range(1):
_ = tune_displacement(system,
init_state,
mode_name=cavity.name,
verify=False)
for alpha in [0, 1, -1, 1j, -1j, 2, -2, 2j, -2j]:
ideal_state = cavity.tensor_with_zero(
qutip.coherent(cavity.levels, alpha))
seq = get_sequence(system)
unitary = cavity.displace(alpha, unitary=True)
cavity.displace(alpha)
result = seq.run(init_state)
unitary_fidelity = (qutip.fidelity(unitary * init_state,
ideal_state)**2)
pulse_fidelity = qutip.fidelity(result.states[-1],
ideal_state)**2
self.assertGreater(unitary_fidelity, 1 - 1e-4)
self.assertGreater(pulse_fidelity, 1 - 1e-4)
K = 1 P = 4 #Local Parameters k1_PCC = 0 k2_PCC = 1 k2_storage = 0 beta = 2# Nb of photons in PCC alpha = 2 # Nb of photons in Storage beta_inf = 2 alpha_inf = 2 chi0 = k2_PCC/30 Tp = np.pi/(4*chi0*beta) C_beta_plus = qt.coherent(Nb, beta)+qt.coherent(Nb, -beta) C_beta_plus = C_beta_plus/C_beta_plus.norm() C_beta_moins = qt.coherent(Nb, beta)-qt.coherent(Nb, -beta) C_beta_moins = C_beta_moins/C_beta_moins.norm() PCC_0 = C_beta_plus #C_alpha_plus = qt.coherent(Na, alpha)+qt.coherent(Na, -alpha) #C_alpha_plus = C_alpha_plus/C_alpha_plus.norm() #C_ialpha_plus = qt.coherent(Na, alpha*1j)+qt.coherent(Na, -alpha*1j) #C_ialpha_plus = C_ialpha_plus/C_ialpha_plus.norm() #storage_0 = C_alpha_plus + 1j*C_ialpha_plus C_alpha_plus = qt.coherent(Nb, alpha)+qt.coherent(Nb, -alpha) C_alpha_plus = C_alpha_plus/C_alpha_plus.norm() C_alpha_moins = qt.coherent(Nb, alpha)-qt.coherent(Nb, -alpha) C_alpha_moins = C_alpha_moins/C_alpha_moins.norm()
@author: andre
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import qutip as qt
N = 20
n = 5
a = qt.destroy(N)
x = qt.position(N)
p = qt.momentum(N)
H = a.dag() * a
psi0 = qt.coherent(N, n**0.5)
#psi0=qt.fock(N,n)
time = np.linspace(0, 100, 1000)
sol = qt.mesolve(H, psi0, time, [], [])
fig, ax = plt.subplots(2, 1)
xvec = np.linspace(-10, 10, 100)
#ax.plot(qt.expect(x,sol.states),qt.expect(p,sol.states))
line, = ax[1].plot([0], [qt.expect(H, psi0)])
im = ax[0].imshow(qt.wigner(psi0, xvec, xvec))
def updatefig(i):
psi = sol.states[i]
data = qt.wigner(psi, xvec, xvec)
im.set_array(data)
def test_coherent_type():
"State CSR Type: coherent"
st = coherent(25,2+2j)
assert_equal(isspmatrix_csr(st.data), True)
st = coherent(25,2+2j, method='analytic')
assert_equal(isspmatrix_csr(st.data), True)
default=25,
help="How often do you want to see the states rendered?")
parser.add_argument('-e',
'--epochs',
type=int,
default=1000,
help="How many epochs the network is trained")
args = parser.parse_args()
dim = parameters_para.N
n_par = 64 #M=3: 256, M=4: 64, M=5: 16
# target state
target_a = np.sqrt(4)
target_state = 1 / np.sqrt(2) * (
qu.coherent(dim, target_a) + qu.coherent(dim, -target_a)) # eigencat
# initialize figures to render
if args.render == True: fig, axes = plt.subplots(1, 5, figsize=(18, 4))
model = PredCorrNetwork(dim, n_par, target_state)
print(model)
# print('Check Biases:')
# print(model.net_action[-1].bias)
print('--------------------------------')
print("number of model parameters:",
sum([np.prod(p.size()) for p in model.parameters()]))
if args.optimizer == "SGD":
optimizer = optim.SGD(model.parameters(), lr=1e-6)
elif args.optimizer == "ADAM":
def thermal_state(freq, T, cav_dim=5):
n_therm = get_n_therm(freq, T)
return qt.coherent(5,n_therm)
