def test_iterators():
"""Test that each kind of iterator gives identical results."""
mol = molecules_pyscf.molecule_glycine_sto3g()
mol.charge = 1
mol.spin = 1
mol.build()
mf = pyscf.scf.uhf.UHF(mol)
mf.scf()
assert isinstance(mf.mo_coeff, np.ndarray)
assert len(mf.mo_coeff) == 2
C = utils.fix_mocoeffs_shape(mf.mo_coeff)
E = utils.fix_moenergies_shape(mf.mo_energy)
occupations = utils.occupations_from_pyscf_mol(mol, C)
solver_ref = iterators.ExactInv(C, E, occupations)
calculator_ref = magnetic.Magnetizability(Program.PySCF,
mol,
C,
E,
occupations,
solver=solver_ref)
calculator_ref.form_operators()
calculator_ref.run(hamiltonian="rpa", spin="singlet")
calculator_ref.form_results()
ref = calculator_ref.magnetizability
inv_funcs = (sp.linalg.inv, sp.linalg.pinv, sp.linalg.pinv2)
thresh = 6.0e-14
for inv_func in inv_funcs:
solver_res = iterators.ExactInv(C, E, occupations, inv_func=inv_func)
calculator_res = magnetic.Magnetizability(Program.PySCF,
mol,
C,
E,
occupations,
solver=solver_res)
calculator_res.form_operators()
calculator_res.run(hamiltonian="rpa", spin="singlet")
calculator_res.form_results()
np.testing.assert_equal(
np.sign(calculator_ref.magnetizability),
np.sign(calculator_res.magnetizability),
)
diff = calculator_ref.magnetizability - calculator_res.magnetizability
abs_diff = np.abs(diff)
print(abs_diff)
assert np.all(abs_diff < thresh)
return
def __init__(self,
program,
program_obj,
mocoeffs,
moenergies,
occupations,
frequencies=[0.0],
*args,
**kwargs):
super().__init__(program, program_obj, mocoeffs, moenergies,
occupations, *args, **kwargs)
# Don't allow a single number; force one of the basic
# iterables.
assert isinstance(frequencies, (list, tuple, np.ndarray))
self.frequencies = frequencies
if "solver" in kwargs:
solver = kwargs["solver"]
elif self.solver is not None:
solver = self.solver
else:
solver = iterators.ExactInv(mocoeffs, moenergies, occupations)
# TODO this doesn't belong here.
if solver.tei_mo is None:
solver.form_tei_mo(program, program_obj)
if "driver" in kwargs:
driver = kwargs["driver"]
else:
driver = CPHF(solver)
self.driver = driver
self.driver.set_frequencies(frequencies)
def test_uncoupled_uhf():
mol = molecules.molecule_trithiolane_sto3g()
mol.charge = 1
mol.spin = 1
mol.build()
mf = pyscf.scf.uhf.UHF(mol)
mf.scf()
C = utils.fix_mocoeffs_shape(mf.mo_coeff)
E = utils.fix_moenergies_shape(mf.mo_energy)
occupations = utils.occupations_from_pyscf_mol(mol, C)
solver = iterators.ExactInv(C, E, occupations)
ao2mo = AO2MOpyscf(C, mol.verbose, mol)
ao2mo.perform_uhf_partial()
solver.tei_mo = ao2mo.tei_mo
solver.tei_mo_type = "partial"
driver = cphf.CPHF(solver)
operator_diplen = operators.Operator(
label="dipole", is_imaginary=False, is_spin_dependent=False, triplet=False
)
integrals_diplen_ao = mol.intor("cint1e_r_sph", comp=3)
operator_diplen.ao_integrals = integrals_diplen_ao
driver.add_operator(operator_diplen)
frequencies = [0.0, 0.0773178, 0.128347, 0.4556355]
driver.set_frequencies(frequencies)
driver.run(solver_type="exact", hamiltonian="rpa", spin="singlet")
for idxf, frequency in enumerate(frequencies):
print(idxf, frequency)
print("uncoupled")
diag_res = np.diag(driver.uncoupled_results[idxf])
diag_ref = np.diag(uhf_uncoupled[frequency]["result"])
diff = diag_res - diag_ref
print(diag_res)
print(diag_ref)
print(diff)
assert np.max(np.abs(diff)) < uhf_uncoupled[frequency]["error_max_diag"]
print("coupled")
diag_res = np.diag(driver.results[idxf])
diag_ref = np.diag(uhf_coupled[frequency]["result"])
diff = diag_res - diag_ref
print(diag_res)
print(diag_ref)
print(diff)
assert np.max(np.abs(diff)) < uhf_coupled[frequency]["error_max_diag"]
return
def test_explicit_uhf():
mol = molecules.molecule_water_sto3g()
mol.charge = 1
mol.spin = 1
mol.build()
mf = pyscf.scf.UHF(mol)
mf.kernel()
C = np.stack(mf.mo_coeff, axis=0)
E_a = np.diag(mf.mo_energy[0])
E_b = np.diag(mf.mo_energy[1])
assert E_a.shape == E_b.shape
E = np.stack((E_a, E_b), axis=0)
integrals_dipole_ao = mol.intor("cint1e_r_sph", comp=3)
occupations = utils.occupations_from_pyscf_mol(mol, C)
solver = iterators.ExactInv(C, E, occupations)
ao2mo = AO2MOpyscf(C, mol.verbose, mol)
ao2mo.perform_uhf_full()
solver.tei_mo = ao2mo.tei_mo
solver.tei_mo_type = "full"
driver = cphf.CPHF(solver)
operator_dipole = operators.Operator(label="dipole",
is_imaginary=False,
is_spin_dependent=False)
operator_dipole.ao_integrals = integrals_dipole_ao
driver.add_operator(operator_dipole)
driver.set_frequencies()
driver.run(solver_type="exact", hamiltonian="rpa", spin="singlet")
assert len(driver.frequencies) == len(driver.results) == 1
res = driver.results[0]
print(res)
atol = 1.0e-5
rtol = 0.0
np.testing.assert_allclose(res,
ref_water_cation_UHF_HF_STO3G,
rtol=rtol,
atol=atol)
def test_final_result_rhf_h2o_sto3g_tda_triplet():
hamiltonian = "tda"
spin = "triplet"
C = utils.fix_mocoeffs_shape(utils.np_load(REFDIR / "C.npz"))
E = utils.fix_moenergies_shape(utils.np_load(REFDIR / "F_MO.npz"))
TEI_MO = utils.np_load(REFDIR / "TEI_MO.npz")
# nocc_alph, nvirt_alph, nocc_beta, nvirt_beta
occupations = [5, 2, 5, 2]
stub = "h2o_sto3g_"
dim = occupations[0] + occupations[1]
mat_dipole_x = utils.parse_int_file_2(REFDIR / f"{stub}mux.dat", dim)
mat_dipole_y = utils.parse_int_file_2(REFDIR / f"{stub}muy.dat", dim)
mat_dipole_z = utils.parse_int_file_2(REFDIR / f"{stub}muz.dat", dim)
solver = iterators.ExactInv(C, E, occupations)
solver.tei_mo = (TEI_MO, )
solver.tei_mo_type = "full"
driver = cphf.CPHF(solver)
ao_integrals_dipole = np.stack((mat_dipole_x, mat_dipole_y, mat_dipole_z),
axis=0)
operator_dipole = operators.Operator(label="dipole",
is_imaginary=False,
is_spin_dependent=False)
operator_dipole.ao_integrals = ao_integrals_dipole
driver.add_operator(operator_dipole)
frequencies = (0.0, 0.02, 0.06, 0.1)
driver.set_frequencies(frequencies)
driver.run(solver_type="exact", hamiltonian=hamiltonian, spin=spin)
assert len(driver.results) == len(frequencies)
result__0_00 = np.array([[14.64430714, 0.0, 0.0], [0.0, 8.80921432, 0.0],
[0.0, 0.0, 0.06859496]])
result__0_02 = np.array([[14.68168443, 0.0, 0.0], [0.0, 8.83562647, 0.0],
[0.0, 0.0, 0.0689291]])
result__0_06 = np.array([[14.98774296, 0.0, 0.0], [0.0, 9.0532224, 0.0],
[0.0, 0.0, 0.07172414]])
result__0_10 = np.array([[15.63997724, 0.0, 0.0], [0.0, 9.52504267, 0.0],
[0.0, 0.0, 0.07805428]])
atol = 1.0e-8
rtol = 0.0
np.testing.assert_allclose(driver.results[0],
result__0_00,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[1],
result__0_02,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[2],
result__0_06,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[3],
result__0_10,
rtol=rtol,
atol=atol)
mol = molecules.molecule_water_sto3g()
mol.build()
polarizability = electric.Polarizability(Program.PySCF, mol, C, E,
occupations, frequencies)
polarizability.form_operators()
polarizability.run(hamiltonian=hamiltonian, spin=spin)
polarizability.form_results()
np.testing.assert_allclose(polarizability.polarizabilities[0],
result__0_00,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[1],
result__0_02,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[2],
result__0_06,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[3],
result__0_10,
rtol=rtol,
atol=atol)
return
def test_final_result_rhf_h2o_sto3g_tda_singlet():
hamiltonian = "tda"
spin = "singlet"
C = utils.fix_mocoeffs_shape(utils.np_load(REFDIR / "C.npz"))
E = utils.fix_moenergies_shape(utils.np_load(REFDIR / "F_MO.npz"))
TEI_MO = utils.np_load(REFDIR / "TEI_MO.npz")
# nocc_alph, nvirt_alph, nocc_beta, nvirt_beta
occupations = [5, 2, 5, 2]
stub = "h2o_sto3g_"
dim = occupations[0] + occupations[1]
mat_dipole_x = utils.parse_int_file_2(REFDIR / f"{stub}mux.dat", dim)
mat_dipole_y = utils.parse_int_file_2(REFDIR / f"{stub}muy.dat", dim)
mat_dipole_z = utils.parse_int_file_2(REFDIR / f"{stub}muz.dat", dim)
solver = iterators.ExactInv(C, E, occupations)
solver.tei_mo = (TEI_MO, )
solver.tei_mo_type = "full"
driver = cphf.CPHF(solver)
ao_integrals_dipole = np.stack((mat_dipole_x, mat_dipole_y, mat_dipole_z),
axis=0)
operator_dipole = operators.Operator(label="dipole",
is_imaginary=False,
is_spin_dependent=False)
operator_dipole.ao_integrals = ao_integrals_dipole
driver.add_operator(operator_dipole)
frequencies = (0.0, 0.02, 0.06, 0.1)
driver.set_frequencies(frequencies)
driver.run(solver_type="exact", hamiltonian=hamiltonian, spin=spin)
assert len(driver.results) == len(frequencies)
result__0_00 = np.array([[8.89855952, 0.0, 0.0], [0.0, 4.00026556, 0.0],
[0.0, 0.0, 0.0552774]])
result__0_02 = np.array([[8.90690928, 0.0, 0.0], [0.0, 4.00298342, 0.0],
[0.0, 0.0, 0.05545196]])
result__0_06 = np.array([[8.97427725, 0.0, 0.0], [0.0, 4.02491517, 0.0],
[0.0, 0.0, 0.05688918]])
result__0_10 = np.array([[9.11212633, 0.0, 0.0], [0.0, 4.06981937, 0.0],
[0.0, 0.0, 0.05999934]])
atol = 1.0e-8
rtol = 0.0
np.testing.assert_allclose(driver.results[0],
result__0_00,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[1],
result__0_02,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[2],
result__0_06,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[3],
result__0_10,
rtol=rtol,
atol=atol)
mol = molecules.molecule_water_sto3g()
mol.build()
polarizability = electric.Polarizability(Program.PySCF, mol, C, E,
occupations, frequencies)
polarizability.form_operators()
polarizability.run(hamiltonian=hamiltonian, spin=spin)
polarizability.form_results()
np.testing.assert_allclose(polarizability.polarizabilities[0],
result__0_00,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[1],
result__0_02,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[2],
result__0_06,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[3],
result__0_10,
rtol=rtol,
atol=atol)
return
def test_final_result_rhf_h2o_sto3g_rpa_singlet():
hamiltonian = "rpa"
spin = "singlet"
C = utils.fix_mocoeffs_shape(utils.np_load(REFDIR / "C.npz"))
E = utils.fix_moenergies_shape(utils.np_load(REFDIR / "F_MO.npz"))
TEI_MO = utils.np_load(REFDIR / "TEI_MO.npz")
# nocc_alph, nvirt_alph, nocc_beta, nvirt_beta
occupations = [5, 2, 5, 2]
stub = "h2o_sto3g_"
dim = occupations[0] + occupations[1]
mat_dipole_x = utils.parse_int_file_2(REFDIR / f"{stub}mux.dat", dim)
mat_dipole_y = utils.parse_int_file_2(REFDIR / f"{stub}muy.dat", dim)
mat_dipole_z = utils.parse_int_file_2(REFDIR / f"{stub}muz.dat", dim)
solver = iterators.ExactInv(C, E, occupations)
solver.tei_mo = (TEI_MO, )
solver.tei_mo_type = "full"
driver = cphf.CPHF(solver)
ao_integrals_dipole = np.stack((mat_dipole_x, mat_dipole_y, mat_dipole_z),
axis=0)
operator_dipole = operators.Operator(label="dipole",
is_imaginary=False,
is_spin_dependent=False)
operator_dipole.ao_integrals = ao_integrals_dipole
driver.add_operator(operator_dipole)
frequencies = (0.0, 0.02, 0.06, 0.1)
driver.set_frequencies(frequencies)
driver.run(solver_type="exact", hamiltonian=hamiltonian, spin=spin)
assert len(driver.results) == len(frequencies)
result__0_00 = np.array([[7.93556221, 0.0, 0.0], [0.0, 3.06821077, 0.0],
[0.0, 0.0, 0.05038621]])
result__0_02 = np.array([[7.94312371, 0.0, 0.0], [0.0, 3.07051688, 0.0],
[0.0, 0.0, 0.05054685]])
result__0_06 = np.array([[8.00414009, 0.0, 0.0], [0.0, 3.08913608, 0.0],
[0.0, 0.0, 0.05186977]])
result__0_10 = np.array([[8.1290378, 0.0, 0.0], [0.0, 3.12731363, 0.0],
[0.0, 0.0, 0.05473482]])
atol = 1.0e-8
rtol = 0.0
np.testing.assert_allclose(driver.results[0],
result__0_00,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[1],
result__0_02,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[2],
result__0_06,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[3],
result__0_10,
rtol=rtol,
atol=atol)
# Reminder: there's no call to do SCF here because we already have
# the MO coefficients.
mol = molecules.molecule_water_sto3g()
mol.build()
polarizability = electric.Polarizability(Program.PySCF, mol, C, E,
occupations, frequencies)
polarizability.form_operators()
polarizability.run(hamiltonian=hamiltonian, spin=spin)
polarizability.form_results()
np.testing.assert_allclose(polarizability.polarizabilities[0],
result__0_00,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[1],
result__0_02,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[2],
result__0_06,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[3],
result__0_10,
rtol=rtol,
atol=atol)
return
def test_final_result_rhf_h2o_sto3g_rpa_triplet():
hamiltonian = "rpa"
spin = "triplet"
C = utils.fix_mocoeffs_shape(utils.np_load(REFDIR / "C.npz"))
E = utils.fix_moenergies_shape(utils.np_load(REFDIR / "F_MO.npz"))
TEI_MO = utils.np_load(REFDIR / "TEI_MO.npz")
# nocc_alph, nvirt_alph, nocc_beta, nvirt_beta
occupations = [5, 2, 5, 2]
stub = "h2o_sto3g_"
dim = occupations[0] + occupations[1]
mat_dipole_x = utils.parse_int_file_2(REFDIR / f"{stub}mux.dat", dim)
mat_dipole_y = utils.parse_int_file_2(REFDIR / f"{stub}muy.dat", dim)
mat_dipole_z = utils.parse_int_file_2(REFDIR / f"{stub}muz.dat", dim)
solver = iterators.ExactInv(C, E, occupations)
solver.tei_mo = (TEI_MO, )
solver.tei_mo_type = "full"
driver = cphf.CPHF(solver)
ao_integrals_dipole = np.stack((mat_dipole_x, mat_dipole_y, mat_dipole_z),
axis=0)
operator_dipole = operators.Operator(label="dipole",
is_imaginary=False,
is_spin_dependent=False)
operator_dipole.ao_integrals = ao_integrals_dipole
driver.add_operator(operator_dipole)
frequencies = (0.0, 0.02, 0.06, 0.1)
driver.set_frequencies(frequencies)
driver.run(solver_type="exact", hamiltonian=hamiltonian, spin=spin)
assert len(driver.results) == len(frequencies)
result__0_00 = np.array([[26.59744305, 0.0, 0.0], [0.0, 18.11879557, 0.0],
[0.0, 0.0, 0.07798969]])
result__0_02 = np.array([[26.68282287, 0.0, 0.0], [0.0, 18.19390051, 0.0],
[0.0, 0.0, 0.07837521]])
result__0_06 = np.array([[27.38617401, 0.0, 0.0], [0.0, 18.81922578, 0.0],
[0.0, 0.0, 0.08160226]])
result__0_10 = np.array([[28.91067234, 0.0, 0.0], [0.0, 20.21670386, 0.0],
[0.0, 0.0, 0.08892512]])
atol = 1.0e-8
rtol = 0.0
np.testing.assert_allclose(driver.results[0],
result__0_00,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[1],
result__0_02,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[2],
result__0_06,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(driver.results[3],
result__0_10,
rtol=rtol,
atol=atol)
mol = molecules.molecule_water_sto3g()
mol.build()
polarizability = electric.Polarizability(Program.PySCF, mol, C, E,
occupations, frequencies)
polarizability.form_operators()
polarizability.run(hamiltonian=hamiltonian, spin=spin)
polarizability.form_results()
np.testing.assert_allclose(polarizability.polarizabilities[0],
result__0_00,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[1],
result__0_02,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[2],
result__0_06,
rtol=rtol,
atol=atol)
np.testing.assert_allclose(polarizability.polarizabilities[3],
result__0_10,
rtol=rtol,
atol=atol)
return
def calculate_disk_uhf(testcasedir, hamiltonian, spin, frequency, label_1,
label_2):
occupations = utils.read_file_occupations(testcasedir / "occupations")
nocc_alph, nvirt_alph, nocc_beta, nvirt_beta = occupations
norb = nocc_alph + nvirt_alph
C = utils.read_file_3(testcasedir / "C")
assert C.shape[0] == 2
assert C.shape[2] == norb
nbasis = C.shape[1]
moene = utils.read_file_2(testcasedir / "moene")
assert moene.shape == (norb, 2)
moints_iajb_aaaa = utils.read_file_4(testcasedir / "moints_iajb_aaaa")
moints_iajb_aabb = utils.read_file_4(testcasedir / "moints_iajb_aabb")
moints_iajb_bbaa = utils.read_file_4(testcasedir / "moints_iajb_bbaa")
moints_iajb_bbbb = utils.read_file_4(testcasedir / "moints_iajb_bbbb")
moints_ijab_aaaa = utils.read_file_4(testcasedir / "moints_ijab_aaaa")
moints_ijab_bbbb = utils.read_file_4(testcasedir / "moints_ijab_bbbb")
assert moints_iajb_aaaa.shape == (nocc_alph, nvirt_alph, nocc_alph,
nvirt_alph)
assert moints_iajb_aabb.shape == (nocc_alph, nvirt_alph, nocc_beta,
nvirt_beta)
assert moints_iajb_bbaa.shape == (nocc_beta, nvirt_beta, nocc_alph,
nvirt_alph)
assert moints_iajb_bbbb.shape == (nocc_beta, nvirt_beta, nocc_beta,
nvirt_beta)
assert moints_ijab_aaaa.shape == (nocc_alph, nocc_alph, nvirt_alph,
nvirt_alph)
assert moints_ijab_bbbb.shape == (nocc_beta, nocc_beta, nvirt_beta,
nvirt_beta)
operator_1 = utils.dalton_label_to_operator(label_1)
operator_2 = utils.dalton_label_to_operator(label_2)
operator_1_integrals_mn = utils.read_file_3(
testcasedir / f"operator_mn_{operator_1.label}")
operator_2_integrals_mn = utils.read_file_3(
testcasedir / f"operator_mn_{operator_2.label}")
# The first dimension can"t be checked since there may be multiple
# components.
assert operator_1_integrals_mn.shape[1:] == (nbasis, nbasis)
assert operator_2_integrals_mn.shape[1:] == (nbasis, nbasis)
# Only take the component/slice from the integral as determined
# from the DALTON operator label.
operator_1_integrals_mn = operator_1_integrals_mn[operator_1.slice_idx]
operator_2_integrals_mn = operator_2_integrals_mn[operator_2.slice_idx]
# However, this eliminates an axis, which needs to be added back.
operator_1_integrals_mn = operator_1_integrals_mn[np.newaxis, ...]
operator_2_integrals_mn = operator_2_integrals_mn[np.newaxis, ...]
operator_1.ao_integrals = operator_1_integrals_mn
operator_2.ao_integrals = operator_2_integrals_mn
moene_alph = np.diag(moene[:, 0])
moene_beta = np.diag(moene[:, 1])
moene = np.stack((moene_alph, moene_beta), axis=0)
assert moene.shape == (2, norb, norb)
solver = iterators.ExactInv(C, moene, occupations)
solver.tei_mo = (
moints_iajb_aaaa,
moints_iajb_aabb,
moints_iajb_bbaa,
moints_iajb_bbbb,
moints_ijab_aaaa,
moints_ijab_bbbb,
)
solver.tei_mo_type = "partial"
driver = cphf.CPHF(solver)
driver.add_operator(operator_1)
driver.add_operator(operator_2)
driver.set_frequencies([float(frequency)])
driver.run(solver_type="exact", hamiltonian=hamiltonian, spin=spin)
assert len(driver.frequencies) == len(driver.results) == 1
res = driver.results[0]
assert res.shape == (2, 2)
bl = res[1, 0]
tr = res[0, 1]
diff = abs(abs(bl) - abs(tr))
# Results should be symmetric w.r.t. interchange between operators
# in the LR equations.
thresh = 1.0e-14
assert diff < thresh
return bl
def calculate_uhf(
dalton_tmpdir,
hamiltonian=None,
spin=None,
operator_label=None,
operator=None,
source_moenergies=None,
source_mocoeffs=None,
source_operator=None,
):
if operator_label:
# TODO add dipvel
assert operator_label in ("dipole", "angmom", "spinorb")
assert source_moenergies in ("pyscf", "dalton")
assert source_mocoeffs in ("pyscf", "dalton")
dalton_molecule = dalmol.readin(dalton_tmpdir / "DALTON.BAS")
lines = []
for atom in dalton_molecule:
label = atom["label"][0]
center = atom["center"][0]
center_str = " ".join(["{:f}".format(pos) for pos in center])
line = "{:3} {}".format(label, center_str)
lines.append(line)
lines = "\n".join(lines)
# PySCF molecule setup, needed for generating the TEIs in the MO
# basis.
mol = pyscf.gto.Mole()
verbose = 1
mol.verbose = verbose
mol.atom = lines
mol.unit = "Bohr"
# TODO read basis from DALTON molecule
mol.basis = "sto-3g"
mol.symmetry = False
# TODO read charge from DALTON molecule?
mol.charge = 1
# TODO read spin from DALTON molecule?
mol.spin = 1
mol.build()
ifc = sirifc.sirifc(dalton_tmpdir / "SIRIFC")
occupations = utils.occupations_from_sirifc(ifc)
if source_moenergies == "pyscf" or source_mocoeffs == "pyscf":
mf = pyscf.scf.UHF(mol)
mf.kernel()
if source_moenergies == "pyscf":
E_alph = np.diag(mf.mo_energy[0])
E_beta = np.diag(mf.mo_energy[1])
E = np.stack((E_alph, E_beta), axis=0)
elif source_moenergies == "dalton":
job = ccopen(dalton_tmpdir / "DALTON.OUT")
data = job.parse()
# pylint: disable=no-member
E = np.diag([
convertor(x, "eV", "hartree") for x in data.moenergies[0]
])[np.newaxis, ...]
E = np.concatenate((E, E), axis=0)
else:
pass
if source_mocoeffs == "pyscf":
C = mf.mo_coeff
elif source_mocoeffs == "dalton":
C = ifc.cmo[0][np.newaxis, ...]
C = np.concatenate((C, C), axis=0)
else:
pass
solver = iterators.ExactInv(C, E, occupations)
solver.tei_mo = ao2mo.perform_tei_ao2mo_uhf_partial(mol, C)
solver.tei_mo_type = "partial"
driver = cphf.CPHF(solver)
if operator:
driver.add_operator(operator)
elif operator_label:
if operator_label == "dipole":
operator_dipole = operators.Operator(label="dipole",
is_imaginary=False,
is_spin_dependent=False,
triplet=False)
integrals_dipole_ao = mol.intor("cint1e_r_sph", comp=3)
operator_dipole.ao_integrals = integrals_dipole_ao
driver.add_operator(operator_dipole)
elif operator_label == "angmom":
operator_angmom = operators.Operator(label="angmom",
is_imaginary=True,
is_spin_dependent=False,
triplet=False)
integrals_angmom_ao = mol.intor("cint1e_cg_irxp_sph", comp=3)
operator_angmom.ao_integrals = integrals_angmom_ao
driver.add_operator(operator_angmom)
elif operator_label == "spinorb":
operator_spinorb = operators.Operator(label="spinorb",
is_imaginary=True,
is_spin_dependent=False,
triplet=False)
integrals_spinorb_ao = 0
for atm_id in range(mol.natm):
mol.set_rinv_orig(mol.atom_coord(atm_id))
chg = mol.atom_charge(atm_id)
integrals_spinorb_ao += chg * mol.intor("cint1e_prinvxp_sph",
comp=3)
operator_spinorb.ao_integrals = integrals_spinorb_ao
driver.add_operator(operator_spinorb)
else:
pass
else:
pass
driver.set_frequencies()
driver.run(solver_type="exact", hamiltonian=hamiltonian, spin=spin)
return driver.results[0]
def test_explicit_uhf():
mol = molecules.molecule_water_sto3g()
mol.charge = 1
mol.spin = 1
mol.build()
mf = pyscf.scf.UHF(mol)
mf.kernel()
C = np.stack(mf.mo_coeff, axis=0)
C_a = C[0, ...]
C_b = C[1, ...]
E_a = np.diag(mf.mo_energy[0])
E_b = np.diag(mf.mo_energy[1])
assert C_a.shape == C_b.shape
assert E_a.shape == E_b.shape
E = np.stack((E_a, E_b), axis=0)
norb = C_a.shape[1]
nocc_a, nocc_b = mol.nelec
nvirt_a, nvirt_b = norb - nocc_a, norb - nocc_b
occupations = [nocc_a, nvirt_a, nocc_b, nvirt_b]
C_occ_alph = C_a[:, :nocc_a]
C_virt_alph = C_a[:, nocc_a:]
C_occ_beta = C_b[:, :nocc_b]
C_virt_beta = C_b[:, nocc_b:]
C_ovov_aaaa = (C_occ_alph, C_virt_alph, C_occ_alph, C_virt_alph)
C_ovov_aabb = (C_occ_alph, C_virt_alph, C_occ_beta, C_virt_beta)
C_ovov_bbaa = (C_occ_beta, C_virt_beta, C_occ_alph, C_virt_alph)
C_ovov_bbbb = (C_occ_beta, C_virt_beta, C_occ_beta, C_virt_beta)
C_oovv_aaaa = (C_occ_alph, C_occ_alph, C_virt_alph, C_virt_alph)
C_oovv_bbbb = (C_occ_beta, C_occ_beta, C_virt_beta, C_virt_beta)
tei_mo_ovov_aaaa = pyscf.ao2mo.general(mol,
C_ovov_aaaa,
aosym="s4",
compact=False,
verbose=5).reshape(
nocc_a, nvirt_a, nocc_a,
nvirt_a)
tei_mo_ovov_aabb = pyscf.ao2mo.general(mol,
C_ovov_aabb,
aosym="s4",
compact=False,
verbose=5).reshape(
nocc_a, nvirt_a, nocc_b,
nvirt_b)
tei_mo_ovov_bbaa = pyscf.ao2mo.general(mol,
C_ovov_bbaa,
aosym="s4",
compact=False,
verbose=5).reshape(
nocc_b, nvirt_b, nocc_a,
nvirt_a)
tei_mo_ovov_bbbb = pyscf.ao2mo.general(mol,
C_ovov_bbbb,
aosym="s4",
compact=False,
verbose=5).reshape(
nocc_b, nvirt_b, nocc_b,
nvirt_b)
tei_mo_oovv_aaaa = pyscf.ao2mo.general(mol,
C_oovv_aaaa,
aosym="s4",
compact=False,
verbose=5).reshape(
nocc_a, nocc_a, nvirt_a,
nvirt_a)
tei_mo_oovv_bbbb = pyscf.ao2mo.general(mol,
C_oovv_bbbb,
aosym="s4",
compact=False,
verbose=5).reshape(
nocc_b, nocc_b, nvirt_b,
nvirt_b)
integrals_dipole_ao = mol.intor("cint1e_r_sph", comp=3)
solver = iterators.ExactInv(C, E, occupations)
solver.tei_mo = (
tei_mo_ovov_aaaa,
tei_mo_ovov_aabb,
tei_mo_ovov_bbaa,
tei_mo_ovov_bbbb,
tei_mo_oovv_aaaa,
tei_mo_oovv_bbbb,
)
solver.tei_mo_type = "partial"
driver = cphf.CPHF(solver)
operator_dipole = operators.Operator(label="dipole",
is_imaginary=False,
is_spin_dependent=False)
operator_dipole.ao_integrals = integrals_dipole_ao
driver.add_operator(operator_dipole)
driver.set_frequencies()
driver.run(solver_type="exact", hamiltonian="rpa", spin="singlet")
assert len(driver.frequencies) == len(driver.results) == 1
res = driver.results[0]
print(res)
atol = 1.0e-5
rtol = 0.0
np.testing.assert_allclose(res,
ref_water_cation_UHF_HF_STO3G,
rtol=rtol,
atol=atol)
return
