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