def testHOFiniteTemperatureStates():
"""
brmesolve: harmonic oscillator, finite temperature, states
"""
N = 10
w0 = 1.0 * 2 * np.pi
g = 0.05 * w0
kappa = 0.25
times = np.linspace(0, 25, 1000)
a = destroy(N)
H = w0 * a.dag() * a + g * (a + a.dag())
psi0 = ket2dm((basis(N, 4) + basis(N, 2) + basis(N, 0)).unit())
n_th = 1.5
w_th = w0/np.log(1 + 1/n_th)
def S_w(w):
if w >= 0:
return (n_th + 1) * kappa
else:
return (n_th + 1) * kappa * np.exp(w / w_th)
c_ops = [np.sqrt(kappa * (n_th + 1)) * a, np.sqrt(kappa * n_th) * a.dag()]
a_ops = [a + a.dag()]
e_ops = []
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H, psi0, times, a_ops, e_ops, [S_w])
n_me = expect(a.dag() * a, res_me.states)
n_brme = expect(a.dag() * a, res_brme.states)
diff = abs(n_me - n_brme).max()
assert_(diff < 1e-2)
def testCOPSwithAOPS():
"""
brmesolve: c_ops with a_ops
"""
delta = 0.0 * 2 * np.pi
epsilon = 0.5 * 2 * np.pi
gamma = 0.25
times = np.linspace(0, 10, 100)
H = delta / 2 * sigmax() + epsilon / 2 * sigmaz()
psi0 = (2 * basis(2, 0) + basis(2, 1)).unit()
c_ops = [np.sqrt(gamma) * sigmam(), np.sqrt(gamma) * sigmaz()]
c_ops_brme = [np.sqrt(gamma) * sigmaz()]
a_ops = [sigmax()]
e_ops = [sigmax(), sigmay(), sigmaz()]
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H,
psi0,
times,
a_ops,
e_ops,
spectra_cb=[lambda w: gamma * (w >= 0)],
c_ops=c_ops_brme)
for idx, e in enumerate(e_ops):
diff = abs(res_me.expect[idx] - res_brme.expect[idx]).max()
assert_(diff < 1e-2)
def testHOZeroTemperature():
"""
brmesolve: harmonic oscillator, zero temperature
"""
N = 10
w0 = 1.0 * 2 * np.pi
g = 0.05 * w0
kappa = 0.15
times = np.linspace(0, 25, 1000)
a = destroy(N)
H = w0 * a.dag() * a + g * (a + a.dag())
psi0 = ket2dm((basis(N, 4) + basis(N, 2) + basis(N, 0)).unit())
c_ops = [np.sqrt(kappa) * a]
a_ops = [a + a.dag()]
e_ops = [a.dag() * a, a + a.dag()]
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H, psi0, times, a_ops, e_ops,
spectra_cb=[lambda w: kappa * (w >= 0)])
for idx, e in enumerate(e_ops):
diff = abs(res_me.expect[idx] - res_brme.expect[idx]).max()
assert_(diff < 1e-2)
def test_harmonic_oscillator(n_th):
N = 10
w0 = 1.0 * 2 * np.pi
g = 0.05 * w0
kappa = 0.15
S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
a = qutip.destroy(N)
H = w0 * a.dag() * a + g * (a + a.dag())
psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
psi0 = qutip.ket2dm(psi0)
times = np.linspace(0, 25, 1000)
c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
a_ops = [[a + a.dag(), S_w]]
e_ops = [a.dag() * a, a + a.dag()]
me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
brme = qutip.brmesolve(H, psi0, times, a_ops, e_ops)
for me_expectation, brme_expectation in zip(me.expect, brme.expect):
np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
num = qutip.num(N)
me_num = qutip.expect(num, me.states)
brme_num = qutip.expect(num, brme.states)
np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
def testHOFiniteTemperature(self):
"brmesolve: harmonic oscillator, finite temperature"
N = 10
w0 = 1.0 * 2 * np.pi
g = 0.05 * w0
kappa = 0.15
times = np.linspace(0, 25, 1000)
a = destroy(N)
H = w0 * a.dag() * a + g * (a + a.dag())
psi0 = ket2dm((basis(N, 4) + basis(N, 2) + basis(N, 0)).unit())
n_th = 1.5
w_th = w0/np.log(1 + 1/n_th)
def S_w(w):
if w >= 0:
return (n_th + 1) * kappa
else:
return (n_th + 1) * kappa * np.exp(w / w_th)
c_ops = [np.sqrt(kappa * (n_th + 1)) * a, np.sqrt(kappa * n_th) * a.dag()]
a_ops = [a + a.dag()]
e_ops = [a.dag() * a, a + a.dag()]
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H, psi0, times, a_ops, e_ops, [S_w])
for idx, e in enumerate(e_ops):
diff = abs(res_me.expect[idx] - res_brme.expect[idx]).max()
assert_(diff < 1e-2)
def testHOZeroTemperature():
"""
brmesolve: harmonic oscillator, zero temperature
"""
N = 10
w0 = 1.0 * 2 * np.pi
g = 0.05 * w0
kappa = 0.15
times = np.linspace(0, 25, 1000)
a = destroy(N)
H = w0 * a.dag() * a + g * (a + a.dag())
psi0 = ket2dm((basis(N, 4) + basis(N, 2) + basis(N, 0)).unit())
c_ops = [np.sqrt(kappa) * a]
a_ops = [a + a.dag()]
e_ops = [a.dag() * a, a + a.dag()]
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H,
psi0,
times,
a_ops,
e_ops,
spectra_cb=[lambda w: kappa * (w >= 0)])
for idx, e in enumerate(e_ops):
diff = abs(res_me.expect[idx] - res_brme.expect[idx]).max()
assert_(diff < 1e-2)
def testHOFiniteTemperatureStates():
"""
brmesolve: harmonic oscillator, finite temperature, states
"""
N = 10
w0 = 1.0 * 2 * np.pi
g = 0.05 * w0
kappa = 0.25
times = np.linspace(0, 25, 1000)
a = destroy(N)
H = w0 * a.dag() * a + g * (a + a.dag())
psi0 = ket2dm((basis(N, 4) + basis(N, 2) + basis(N, 0)).unit())
n_th = 1.5
w_th = w0 / np.log(1 + 1 / n_th)
def S_w(w):
if w >= 0:
return (n_th + 1) * kappa
else:
return (n_th + 1) * kappa * np.exp(w / w_th)
c_ops = [np.sqrt(kappa * (n_th + 1)) * a, np.sqrt(kappa * n_th) * a.dag()]
a_ops = [a + a.dag()]
e_ops = []
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H, psi0, times, a_ops, e_ops, [S_w])
n_me = expect(a.dag() * a, res_me.states)
n_brme = expect(a.dag() * a, res_brme.states)
diff = abs(n_me - n_brme).max()
assert_(diff < 1e-2)
def testJCZeroTemperature():
"""
brmesolve: Jaynes-Cummings model, zero temperature
"""
N = 10
a = tensor(destroy(N), identity(2))
sm = tensor(identity(N), destroy(2))
psi0 = ket2dm(tensor(basis(N, 1), basis(2, 0)))
a_ops = [(a + a.dag())]
e_ops = [a.dag() * a, sm.dag() * sm]
w0 = 1.0 * 2 * np.pi
g = 0.05 * 2 * np.pi
kappa = 0.05
times = np.linspace(0, 2 * 2 * np.pi / g, 1000)
c_ops = [np.sqrt(kappa) * a]
H = w0 * a.dag() * a + w0 * sm.dag() * sm + \
g * (a + a.dag()) * (sm + sm.dag())
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H,
psi0,
times,
a_ops,
e_ops,
spectra_cb=[lambda w: kappa * (w >= 0)])
for idx, e in enumerate(e_ops):
diff = abs(res_me.expect[idx] - res_brme.expect[idx]).max()
assert_(diff < 5e-2) # accept 5% error
def test_jaynes_cummings_zero_temperature():
"""
brmesolve: Jaynes-Cummings model, zero temperature
"""
N = 10
a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
a_ops = [[(a + a.dag()), lambda w: kappa * (w >= 0)]]
e_ops = [a.dag() * a, sp.dag() * sp]
w0 = 1.0 * 2 * np.pi
g = 0.05 * 2 * np.pi
kappa = 0.05
times = np.linspace(0, 2 * 2 * np.pi / g, 1000)
c_ops = [np.sqrt(kappa) * a]
H = w0 * a.dag() * a + w0 * sp.dag() * sp + g * (a + a.dag()) * (sp +
sp.dag())
me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
brme = qutip.brmesolve(H, psi0, times, a_ops, e_ops)
for me_expectation, brme_expectation in zip(me.expect, brme.expect):
# Accept 5% error.
np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
def testJCZeroTemperature():
"""
brmesolve: Jaynes-Cummings model, zero temperature
"""
N = 10
a = tensor(destroy(N), identity(2))
sm = tensor(identity(N), destroy(2))
psi0 = ket2dm(tensor(basis(N, 1), basis(2, 0)))
a_ops = [(a + a.dag())]
e_ops = [a.dag() * a, sm.dag() * sm]
w0 = 1.0 * 2 * np.pi
g = 0.05 * 2 * np.pi
kappa = 0.05
times = np.linspace(0, 2 * 2 * np.pi / g, 1000)
c_ops = [np.sqrt(kappa) * a]
H = w0 * a.dag() * a + w0 * sm.dag() * sm + \
g * (a + a.dag()) * (sm + sm.dag())
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H, psi0, times, a_ops, e_ops,
spectra_cb=[lambda w: kappa * (w >= 0)])
for idx, e in enumerate(e_ops):
diff = abs(res_me.expect[idx] - res_brme.expect[idx]).max()
assert_(diff < 5e-2) # accept 5% error
def test_time_dependence_tuples(time_dependence_tuple):
N = 10
a = qutip.destroy(N)
H = a.dag() * a
psi0 = qutip.basis(N, 9)
times = np.linspace(0, 10, 100)
kappa = 0.2
a_ops = [[a + a.dag(), time_dependence_tuple(kappa, times)]]
exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
brme = qutip.brmesolve(H, psi0, times, a_ops, e_ops=[a.dag() * a])
assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
def test_nonhermitian_e_ops():
N = 5
a = qutip.destroy(N)
coefficient = np.random.random() + 1j * np.random.random()
H = a.dag() * a + coefficient * a + np.conj(coefficient) * a.dag()
H_brme = [[H, '1']]
psi0 = qutip.basis(N, 2)
times = np.linspace(0, 10, 10)
me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
brme = qutip.brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
assert np.allclose(me, brme, atol=1e-4)
def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
delta = 0.0 * 2 * np.pi
epsilon = 0.5 * 2 * np.pi
e_ops = pauli_spin_operators()
H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
times = np.linspace(0, 10, 100)
me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops).expect
brme = qutip.brmesolve([[H, '1']], psi0, times, brme_a_ops, e_ops,
brme_c_ops).expect
for me_expectation, brme_expectation in zip(me, brme):
assert np.allclose(me_expectation, brme_expectation, atol=1e-2)
def test_hamiltonian_taking_arguments():
N = 10
w0 = 1.0 * 2 * np.pi
g = 0.75 * 2 * np.pi
kappa = 0.05
a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
psi0 = qutip.ket2dm(psi0)
times = np.linspace(0, 5 * 2 * np.pi / g, 1000)
a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
e_ops = [a.dag() * a, sp.dag() * sp]
H = w0 * a.dag() * a + w0 * sp.dag() * sp + g * (a + a.dag()) * (sp +
sp.dag())
args = {'ii': 1}
no_args = qutip.brmesolve(H, psi0, times, a_ops, e_ops)
args = qutip.brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
for arg, no_arg in zip(args.expect, no_args.expect):
assert np.array_equal(arg, no_arg)
def test_result_states():
N = 5
a = qutip.destroy(N)
coefficient = np.random.random() + 1j * np.random.random()
H = a.dag() * a + coefficient * a + np.conj(coefficient) * a.dag()
H_brme = [[H, '1']]
psi0 = qutip.fock_dm(N, 2)
times = np.linspace(0, 10, 10)
me = qutip.mesolve(H, psi0, times).states
brme = qutip.brmesolve(H_brme, psi0, times).states
assert max(
np.abs((me_state - brme_state).full()).max()
for me_state, brme_state in zip(me, brme)) < 1e-5
def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
"""
Test that the BR solver handles collapse and coupling operators correctly
relative to the standard ME solver.
"""
delta = 0.0 * 2 * np.pi
epsilon = 0.5 * 2 * np.pi
e_ops = pauli_spin_operators()
H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
times = np.linspace(0, 10, 100)
me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops).expect
brme = qutip.brmesolve(H, psi0, times, brme_a_ops, e_ops,
brme_c_ops).expect
for me_expectation, brme_expectation in zip(me, brme):
np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
def test_solver_accepts_list_hamiltonian():
"""
brmesolve: input list of Qobj
"""
delta = 0.0 * 2 * np.pi
epsilon = 0.5 * 2 * np.pi
gamma = 0.25
c_ops = [np.sqrt(gamma) * qutip.sigmam()]
e_ops = pauli_spin_operators()
H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
times = np.linspace(0, 10, 100)
me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
brme = qutip.brmesolve(H, psi0, times, [], e_ops, c_ops).expect
for me_expectation, brme_expectation in zip(me, brme):
np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
def test_time_dependent_spline_in_c_ops():
N = 10
a = qutip.destroy(N)
H = a.dag() * a
psi0 = qutip.basis(N, 9)
times = np.linspace(0, 10, 100)
kappa = 0.2
exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
a_ops = [[a + a.dag(), _string_w_interpolating_t(kappa, times)]]
collapse_points = np.sqrt(kappa) * np.exp(-0.5 * times)
c_ops = [[a, qutip.Cubic_Spline(times[0], times[-1], collapse_points)]]
brme = qutip.brmesolve(H,
psi0,
times,
a_ops,
e_ops=[a.dag() * a],
c_ops=c_ops)
assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
def test_split_operators_maintain_answer(collapse_operators):
N = 10
w0 = 1.0 * 2 * np.pi
g = 0.05 * w0
kappa = 0.15
a = qutip.destroy(N)
H = w0 * a.dag() * a + g * (a + a.dag())
psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
psi0 = qutip.ket2dm(psi0)
times = np.linspace(0, 25, 1000)
e_ops = [a.dag() * a, a + a.dag()]
me_c_ops, brme_c_ops, a_ops = collapse_operators(N, kappa, times)
me = qutip.mesolve(H, psi0, times, me_c_ops, e_ops)
brme = qutip.brmesolve(H, psi0, times, a_ops, e_ops, brme_c_ops)
for me_expect, brme_expect in zip(me.expect, brme.expect):
assert np.allclose(me_expect, brme_expect, atol=1e-2)
def testTLS(self):
"brmesolve: qubit"
delta = 0.0 * 2 * np.pi
epsilon = 0.5 * 2 * np.pi
gamma = 0.25
times = np.linspace(0, 10, 100)
H = delta/2 * sigmax() + epsilon/2 * sigmaz()
psi0 = (2 * basis(2, 0) + basis(2, 1)).unit()
c_ops = [np.sqrt(gamma) * sigmam()]
a_ops = [sigmax()]
e_ops = [sigmax(), sigmay(), sigmaz()]
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H, psi0, times, a_ops, e_ops,
spectra_cb=[lambda w: gamma * (w >= 0)])
for idx, e in enumerate(e_ops):
diff = abs(res_me.expect[idx] - res_brme.expect[idx]).max()
assert_(diff < 1e-2)
def testCOPS():
"""
brmesolve: c_ops alone
"""
delta = 0.0 * 2 * np.pi
epsilon = 0.5 * 2 * np.pi
gamma = 0.25
times = np.linspace(0, 10, 100)
H = delta/2 * sigmax() + epsilon/2 * sigmaz()
psi0 = (2 * basis(2, 0) + basis(2, 1)).unit()
c_ops = [np.sqrt(gamma) * sigmam()]
e_ops = [sigmax(), sigmay(), sigmaz()]
res_me = mesolve(H, psi0, times, c_ops, e_ops)
res_brme = brmesolve(H, psi0, times, [], e_ops,
spectra_cb=[], c_ops=c_ops)
for idx, e in enumerate(e_ops):
diff = abs(res_me.expect[idx] - res_brme.expect[idx]).max()
assert_(diff < 1e-2)
