def test_quasiboson_solver(value):
np.random.seed(0)
# normal boson
mol_list1 = parameter.custom_mol_list(None, *value[0])
mps1, mpo1 = solver.construct_mps_mpo_2(
mol_list1, procedure[0][0], nexciton
)
mps1.optimize_config.procedure = procedure
# quasiboson
mol_list2 = parameter.custom_mol_list(None, *value[1])
mps2, mpo2 = solver.construct_mps_mpo_2(
mol_list2, procedure[0][0], nexciton
)
mps2.optimize_config.procedure = procedure
# quasiboson + normal boson
mol_list3 = parameter.custom_mol_list(None, *value[2])
mps3, mpo3 = solver.construct_mps_mpo_2(
mol_list3, procedure[0][0], nexciton
)
mps3.optimize_config.procedure = procedure
for method in ["1site", "2site"]:
mps1.optimize_config.method = method
mps2.optimize_config.method = method
mps3.optimize_config.method = method
energy1 = solver.optimize_mps(mps1, mpo1)
energy2 = solver.optimize_mps(mps2, mpo2)
energy3 = solver.optimize_mps(mps3, mpo3)
assert np.min(energy1) == pytest.approx(np.min(energy2), rel=1e-4)
assert np.min(energy2) == pytest.approx(np.min(energy3), rel=1e-4)
def test_zero_t_abs_mposcheme3(
algorithm, compress_method, ph_info, rtol, switch_to_64backend
):
np.random.seed(0)
# print "data", value
j_matrix = (
np.array([[0.0, -0.1, 0.0], [-0.1, 0.0, -0.3], [0.0, -0.3, 0.0]])
/ constant.au2ev
)
procedure = [[1, 0], [1, 0], [1, 0]]
mol_list = parameter.custom_mol_list(j_matrix, *ph_info)
nsteps = 50
dt = 30.0
if algorithm == 1:
SpectraZeroT = SpectraOneWayPropZeroT
else:
SpectraZeroT = SpectraTwoWayPropZeroT
optimize_config = OptimizeConfig()
optimize_config.procedure = procedure
zero_t_corr2 = SpectraZeroT(
mol_list, "abs", optimize_config, offset=parameter.offset
)
zero_t_corr2.evolve(dt, nsteps)
zero_t_corr3 = SpectraZeroT(
mol_list.switch_scheme(3), "abs", optimize_config, offset=parameter.offset
)
zero_t_corr3.evolve(dt, nsteps)
assert np.allclose(zero_t_corr2.autocorr, zero_t_corr3.autocorr, rtol=rtol)
def test_zero_t_abs(algorithm, compress_method, ph_info, rtol, switch_to_64backend):
np.random.seed(0)
# print "data", value
procedure = [[1, 0], [1, 0], [1, 0]]
optimize_config = OptimizeConfig()
optimize_config.procedure = procedure
mol_list = parameter.custom_mol_list(None, *ph_info)
if algorithm == 1:
SpectraZeroT = SpectraOneWayPropZeroT
else:
SpectraZeroT = SpectraTwoWayPropZeroT
zero_t_corr = SpectraZeroT(
mol_list.switch_scheme(2), "abs", optimize_config, offset=parameter.offset
)
zero_t_corr.info_interval = 30
nsteps = 100
dt = 30.0
zero_t_corr.evolve(dt, nsteps)
with open(
os.path.join(
cur_dir, "ZeroTabs_" + str(algorithm) + str(compress_method) + ".npy"
),
"rb",
) as f:
std = np.load(f)
assert np.allclose(zero_t_corr.autocorr[:nsteps], std[:nsteps], rtol=rtol)
def test_FT_spectra(D_value, spectratype, std_path):
if spectratype == "emi":
E_offset = 2.28614053 / constant.au2ev
elif spectratype == "abs":
E_offset = -2.28614053 / constant.au2ev
else:
assert False
mol_list = custom_mol_list(None,
dis=[Quantity(d) for d in D_value],
hartrees=[True, True])
T = Quantity(298, "K")
insteps = 50
spectra = tdh.LinearSpectra(spectratype,
mol_list,
E_offset=E_offset,
temperature=T,
insteps=insteps)
nsteps = 300 - 1
dt = 30.0
spectra.evolve(dt, nsteps)
with open(os.path.join(cur_dir, std_path), "rb") as f:
std = np.load(f)
assert np.allclose(spectra.autocorr, std)
def test_distance():
mol_list = parameter.custom_mol_list(n_phys_dim=(2, 2))
a = Mps.random(mol_list, 1, 10)
b = Mps.random(mol_list, 1, 10)
check_distance(a, b)
h = Mpo(mol_list)
for i in range(100):
a = a.evolve(h, 10)
b = b.evolve(h, 10)
check_distance(a, b)
def test_construct_MPO_scheme3():
Mmax = 10
J = (np.array([[0.0, -0.1, 0.0], [-0.1, 0.0, -0.3], [0.0, -0.3, 0.0]]) /
constant.au2ev)
mol_list = custom_mol_list(J)
mps2, mpo2 = construct_mps_mpo_2(mol_list, Mmax, nexciton)
mps3, mpo3 = construct_mps_mpo_2(mol_list.switch_scheme(3), Mmax, nexciton)
assert mpo2.ephtable == mpo3.ephtable
assert mpo2.pbond_list == mpo3.pbond_list
assert mpo3.distance(mpo2) == pytest.approx(0)
def test_SCF_exact():
nexciton = 1
dmrg_mol_list = custom_mol_list(None,
ph_phys_dim,
dis=[Quantity(0), Quantity(0)])
# DMRG calculation
procedure = [[40, 0.4], [40, 0.2], [40, 0.1], [40, 0], [40, 0]]
mps, mpo = construct_mps_mpo_2(dmrg_mol_list, 40, nexciton)
mps.optimize_config.procedure = procedure
energy = optimize_mps(mps, mpo)
dmrg_e = mps.expectation(mpo)
# print occupation
dmrg_occ = []
for i in [0, 1, 2]:
mpo = Mpo.onsite(dmrg_mol_list,
r"a^\dagger a",
dipole=False,
mol_idx_set={i})
dmrg_occ.append(mps.expectation(mpo))
print("dmrg_occ", dmrg_occ)
hartree_mol_list = custom_mol_list(None,
ph_phys_dim,
dis=[Quantity(0),
Quantity(0)],
hartrees=[True, True])
WFN, Etot = tdh.SCF(hartree_mol_list, nexciton)
assert Etot == pytest.approx(dmrg_e)
fe, fv = 1, 6
HAM, Etot, A_el = tdh.construct_H_Ham(hartree_mol_list,
nexciton,
WFN,
fe,
fv,
debug=True)
assert Etot == pytest.approx(dmrg_e)
assert np.allclose(A_el.flatten(), dmrg_occ, rtol=1e-4)
def test_1mol_Exact_Spectra_hybrid_TDDMRG_TDH(algorithm):
nmols = 1
J = np.zeros([1, 1])
if algorithm == "pure":
mol_list = parameter.custom_mol_list(J, nmols=nmols)
elif algorithm == "hybrid":
mol_list = parameter.custom_mol_list(J, hartrees=[True, False], nmols=nmols)
else:
assert False
E_offset = -mol_list[0].elocalex - mol_list[0].reorganization_energy
exact_abs = SpectraExact(mol_list, spectratype="abs", offset=Quantity(E_offset))
exact_abs.info_interval = 100
nsteps = 1000
dt = 30.0
exact_abs.evolve(dt, nsteps)
with open(os.path.join(cur_dir, "1mol_ZTabs.npy"), "rb") as f:
mol1_ZTabs_std = np.load(f)
assert np.allclose(exact_abs.autocorr[:nsteps], mol1_ZTabs_std[:nsteps], rtol=1e-3)
def test_finite_t_spectra_abs(algorithm, compress_method, ph_info, rtol):
# print "data", value
mol_list = parameter.custom_mol_list(None, *ph_info)
insteps = 50
finite_t_abs = SpectraFiniteT(mol_list, "abs", Quantity(298, "K"), insteps,
parameter.offset)
nsteps = 50
dt = 30.0
finite_t_abs.evolve(dt, nsteps)
with open(os.path.join(cur_dir, "TTabs_" + str(compress_method) + ".npy"),
"rb") as fin:
std = np.load(fin)
assert np.allclose(finite_t_abs.autocorr[:nsteps], std[:nsteps], rtol=rtol)
def test_quasiboson_constructMPO():
mol_list1 = parameter.custom_mol_list(None, [4, 4])
mps1, mpo1 = solver.construct_mps_mpo_2(mol_list1, procedure[0][0],
nexciton)
mol_list2 = mol_list = parameter.custom_mol_list(None, [4, 4], [2, 2],
[1e-7, 1e-7])
mps2, mpo2 = solver.construct_mps_mpo_2(mol_list2, procedure[0][0],
nexciton)
# merge the decomposed MPO
mpo_merge = Mpo()
mpo_merge.mol_list = mol_list
impo = 0
for mol in mol_list:
mpo_merge.append(mpo2[impo])
impo += 1
for _ in mol.dmrg_phs:
mo = einsum("abcd, defg -> abecfg", mpo2[impo],
mpo2[impo + 1]).reshape((mpo2[impo].shape[0], 4, 4,
mpo2[impo + 1].shape[-1]))
mpo_merge.append(mo)
impo += 2
assert mpo1.distance(mpo_merge) == pytest.approx(0)
mps2.optimize_config.procedure = procedure
mps2.optimize_config.method = "2site"
energy = solver.optimize_mps(mps2, mpo2)
assert np.min(energy) * constant.au2ev == pytest.approx(2.28614053133,
rel=1e-4)
mps2.optimize_config.method = "1site"
energy = solver.optimize_mps(mps2, mpo2)
assert np.min(energy) * constant.au2ev == pytest.approx(2.28614053133,
rel=1e-4)
def test_save_load():
mol_list = custom_mol_list(hartrees=[True, False])
mps = Mpo.onsite(mol_list, "a^\dagger", mol_idx_set={0}) @ Mps.gs(
mol_list, False)
mpo = Mpo(mol_list)
mps1 = mps.copy()
for i in range(2):
mps1 = mps1.evolve(mpo, 10)
mps2 = mps.evolve(mpo, 10)
fname = "test.npz"
mps2.dump(fname)
mps2 = Mps.load(mol_list, fname)
mps2 = mps2.evolve(mpo, 10)
assert np.allclose(mps1.e_occupations, mps2.e_occupations)
os.remove(fname)