def test_pure_dephasing_model_bosonic_bath(self,
evo,
combine,
liouvillianize,
atol=1e-3):
dlm = DrudeLorentzPureDephasingModel(
lam=0.025,
gamma=0.05,
T=1 / 0.95,
Nk=2,
)
ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
options = Options(nsteps=15000, store_states=True)
hsolver = HEOMSolver(H_sys, bath, 14, options=options)
tlist = np.linspace(0, 10, 21)
result = hsolver.run(dlm.rho(), tlist)
test = dlm.state_results(result.states)
expected = dlm.analytic_results(tlist)
np.testing.assert_allclose(test, expected, atol=atol)
rho_final, ado_state = hsolver.steady_state()
test = dlm.state_results([rho_final])
expected = dlm.analytic_results([100])
np.testing.assert_allclose(test, expected, atol=atol)
assert rho_final == ado_state.extract(0)
def test_create(self):
Q = sigmaz()
bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
exp_r, exp_i = bath.exponents
check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
[exp_ri] = bath.exponents
check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
exp_r, exp_i = bath.exponents
check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
with pytest.raises(ValueError) as err:
BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
assert str(err.value) == "The coupling operator Q must be a Qobj."
with pytest.raises(ValueError) as err:
BosonicBath(Q, [1.], [], [2.], [0.6])
assert str(err.value) == (
"The bath exponent lists ck_real and vk_real, and ck_imag and"
" vk_imag must be the same length.")
with pytest.raises(ValueError) as err:
BosonicBath(Q, [1.], [0.5], [2.], [])
assert str(err.value) == (
"The bath exponent lists ck_real and vk_real, and ck_imag and"
" vk_imag must be the same length.")
def test_integration_error(self):
dlm = DrudeLorentzPureDephasingModel(
lam=0.025,
gamma=0.05,
T=1 / 0.95,
Nk=2,
)
ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
options = Options(nsteps=10)
hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
with pytest.raises(RuntimeError) as err:
hsolver.run(dlm.rho(), tlist=[0, 10])
assert str(err.value) == (
"HEOMSolver ODE integration error. Try increasing the nsteps given"
" in the HEOMSolver options (which increases the allowed substeps"
" in each step between times given in tlist).")
def test_combine(self):
exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
[exp] = BosonicBath.combine([exp_rx, exp_rx])
check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
[exp] = BosonicBath.combine([exp_ix, exp_ix])
check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
[exp] = BosonicBath.combine([exp_rix, exp_rix])
check_exponent(
exp,
"RI",
dim=None,
Q=sigmax(),
ck=0.2,
vk=0.5,
ck2=0.4,
)
[exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
[exp] = BosonicBath.combine([exp_rx, exp_ix])
check_exponent(
exp,
"RI",
dim=None,
Q=sigmax(),
ck=1.0,
vk=0.5,
ck2=2.0,
)
[exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
check_exponent(
exp,
"RI",
dim=None,
Q=sigmax(),
ck=1.1,
vk=0.5,
ck2=2.2,
)
def test_ado_return_and_ado_init(self, ado_format):
dlm = DrudeLorentzPureDephasingModel(
lam=0.025,
gamma=0.05,
T=1 / 0.95,
Nk=2,
)
ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
options = Options(nsteps=15_000, store_states=True)
hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
tlist_1 = [0, 1, 2]
result_1 = hsolver.run(dlm.rho(), tlist_1, ado_return=True)
tlist_2 = [2, 3, 4]
rho0 = result_1.ado_states[-1]
if ado_format == "numpy":
rho0 = rho0._ado_state # extract the raw numpy array
result_2 = hsolver.run(
rho0,
tlist_2,
ado_return=True,
ado_init=True,
)
tlist_full = tlist_1 + tlist_2[1:]
result_full = hsolver.run(dlm.rho(), tlist_full, ado_return=True)
times_12 = result_1.times + result_2.times[1:]
times_full = result_full.times
assert times_12 == tlist_full
assert times_full == tlist_full
ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
ado_states_full = result_full.ado_states
assert len(ado_states_12) == len(tlist_full)
assert len(ado_states_full) == len(tlist_full)
for ado_12, ado_full in zip(ado_states_12, ado_states_full):
for label in hsolver.ados.labels:
np.testing.assert_allclose(
ado_12.extract(label).full(),
ado_full.extract(label).full(),
atol=1e-6,
)
states_12 = result_1.states + result_2.states[1:]
states_full = result_full.states
assert len(states_12) == len(tlist_full)
assert len(states_full) == len(tlist_full)
for ado_12, state_12 in zip(ado_states_12, states_12):
assert ado_12.rho == state_12
for ado_full, state_full in zip(ado_states_full, states_full):
assert ado_full.rho == state_full
expected = dlm.analytic_results(tlist_full)
test_12 = dlm.state_results(states_12)
np.testing.assert_allclose(test_12, expected, atol=1e-3)
test_full = dlm.state_results(states_full)
np.testing.assert_allclose(test_full, expected, atol=1e-3)