def base_test(self, system, method, kind): hf = cache.hfdata[system] refdata = cache.reference_data[system] ref = refdata[method][kind] n_ref = len(ref["eigenvectors_singles"]) refstate = adcc.ReferenceState(hf) groundstate = adcc.LazyMp(refstate) mtms = [ compute_modified_transition_moments( groundstate, refstate.operators.electric_dipole[i], "adc2") for i in range(3) ] for i in range(n_ref): ref_s = ref["eigenvectors_singles"][i] ref_d = ref["eigenvectors_doubles"][i] mtm_np_s = [mtms[i]['s'].to_ndarray() for i in range(3)] mtm_np_d = [mtms[i]['d'].to_ndarray() for i in range(3)] # computing the scalar product of the eigenvector # and the modified transition moments yields # the transition dipole moment (doi.org/10.1063/1.1752875) res_tdm = -1.0 * np.array([ np.sum(ref_s * mtm_s) + np.sum(ref_d * mtm_d) for mtm_s, mtm_d in zip(mtm_np_s, mtm_np_d) ]) ref_tdm = ref["transition_dipole_moments"][i] # Test norm and actual values res_tdm_norm = np.sum(res_tdm * res_tdm) ref_tdm_norm = np.sum(ref_tdm * ref_tdm) assert res_tdm_norm == approx(ref_tdm_norm, abs=1e-8) np.testing.assert_allclose(res_tdm, ref_tdm, atol=1e-8)
def test_product_trace_nonsymmetric(self): ref = cache.refstate["cn_sto3g"] dipx_mo = ref.operators.electric_dipole[0] mp2diff_mo = adcc.LazyMp(ref).mp2_diffdm mp2diff_nosym = OneParticleOperator(ref.mospaces, is_symmetric=False) mp2diff_nosym.set_block("o1o1", mp2diff_mo["o1o1"]) mp2diff_nosym.set_block("o1v1", mp2diff_mo["o1v1"]) mp2diff_nosym.set_block("v1v1", mp2diff_mo["v1v1"]) mp2diff_nosym.set_block("v1o1", zeros_like(mp2diff_mo["o1v1"].transpose())) mp2diff_ao = mp2diff_nosym.to_ao_basis(ref) mp2a = mp2diff_ao[0].to_ndarray() mp2b = mp2diff_ao[1].to_ndarray() dipx_ao = ref.operators.provider_ao.electric_dipole[0] dipx_ref = np.sum(mp2a * dipx_ao) + np.sum(mp2b * dipx_ao) oo = np.sum(mp2diff_nosym["o1o1"].to_ndarray() * dipx_mo["o1o1"].to_ndarray()) ov = np.sum(mp2diff_nosym["o1v1"].to_ndarray() * dipx_mo["o1v1"].to_ndarray()) vo = np.sum(mp2diff_nosym["v1o1"].to_ndarray() * dipx_mo["o1v1"].to_ndarray().T) vv = np.sum(mp2diff_nosym["v1v1"].to_ndarray() * dipx_mo["v1v1"].to_ndarray()) dipx_np = oo + ov + vo + vv assert dipx_np == approx(product_trace(mp2diff_nosym, dipx_mo)) assert product_trace(mp2diff_nosym, dipx_mo) == approx(dipx_ref) assert product_trace(dipx_mo, mp2diff_nosym) == approx(dipx_ref)
def test_obtain_guesses_by_inspection(self): from adcc.workflow import obtain_guesses_by_inspection refstate = cache.refstate["h2o_sto3g"] ground_state = adcc.LazyMp(refstate) matrix2 = adcc.AdcMatrix("adc2", ground_state) matrix1 = adcc.AdcMatrix("adc1", ground_state) # Test that the right number of guesses is returned ... for mat in [matrix1, matrix2]: for i in range(4, 9): res = obtain_guesses_by_inspection(mat, n_guesses=i, kind="singlet") assert len(res) == i for i in range(4, 9): res = obtain_guesses_by_inspection(matrix2, n_guesses=i, kind="triplet", n_guesses_doubles=2) assert len(res) == i with pytest.raises(InputError): obtain_guesses_by_inspection(matrix1, n_guesses=4, kind="any", n_guesses_doubles=2) with pytest.raises(InputError): obtain_guesses_by_inspection(matrix1, n_guesses=40, kind="any")
def test_product_trace_both_nonsymmetric(self): ref = cache.refstate["cn_sto3g"] dipx_mo = ref.operators.electric_dipole[0] mp2diff_mo = adcc.LazyMp(ref).mp2_diffdm mp2diff_nosym = OneParticleOperator(ref.mospaces, is_symmetric=False) dipx_nosym = OneParticleOperator(ref.mospaces, is_symmetric=False) mp2diff_nosym.oo = mp2diff_mo.oo mp2diff_nosym.ov = mp2diff_mo.ov mp2diff_nosym.vv = mp2diff_mo.vv mp2diff_nosym.vo = zeros_like(mp2diff_mo.ov.transpose()) mp2diff_ao = mp2diff_nosym.to_ao_basis(ref) dipx_nosym.oo = dipx_mo.oo dipx_nosym.ov = dipx_mo.ov dipx_nosym.vv = dipx_mo.vv dipx_nosym.vo = zeros_like(dipx_mo.ov.transpose()) dipx_ao = dipx_nosym.to_ao_basis(ref) mp2a = mp2diff_ao[0].to_ndarray() mp2b = mp2diff_ao[1].to_ndarray() dipxa = dipx_ao[0].to_ndarray() dipxb = dipx_ao[1].to_ndarray() dipx_ref = np.sum(mp2a * dipxa) + np.sum(mp2b * dipxb) oo = np.sum(mp2diff_nosym.oo.to_ndarray() * dipx_nosym.oo.to_ndarray()) ov = np.sum(mp2diff_nosym.ov.to_ndarray() * dipx_nosym.ov.to_ndarray()) vo = np.sum(mp2diff_nosym.vo.to_ndarray() * dipx_nosym.vo.to_ndarray()) vv = np.sum(mp2diff_nosym.vv.to_ndarray() * dipx_nosym.vv.to_ndarray()) dipx_np = oo + ov + vo + vv assert dipx_np == approx(product_trace(mp2diff_nosym, dipx_nosym)) assert product_trace(mp2diff_nosym, dipx_nosym) == approx(dipx_ref) assert product_trace(dipx_nosym, mp2diff_nosym) == approx(dipx_ref)
class TestAdcMatrixInterface(unittest.TestCase): def test_properties_adc2(self): case = "h2o_sto3g" method = "adc2" reference_state = cache.refstate[case] ground_state = adcc.LazyMp(reference_state) matrix = adcc.AdcMatrix(method, ground_state) assert matrix.ndim == 2 assert not matrix.is_core_valence_separated assert matrix.shape == (1640, 1640) assert len(matrix) == 1640 assert matrix.axis_blocks == ["ph", "pphh"] assert sorted(matrix.axis_spaces.keys()) == matrix.axis_blocks assert sorted(matrix.axis_lengths.keys()) == matrix.axis_blocks assert matrix.axis_spaces["ph"] == ["o1", "v1"] assert matrix.axis_spaces["pphh"] == ["o1", "o1", "v1", "v1"] assert matrix.axis_lengths["ph"] == 40 assert matrix.axis_lengths["pphh"] == 1600 assert matrix.reference_state == reference_state assert matrix.mospaces == reference_state.mospaces assert isinstance(matrix.timer, adcc.timings.Timer)
def test_intermediates_adc2(self): ground_state = adcc.LazyMp(cache.refstate["h2o_sto3g"]) matrix = adcc.AdcMatrix("adc2", ground_state) assert isinstance(matrix.intermediates, Intermediates) intermediates = Intermediates(ground_state) matrix.intermediates = intermediates assert matrix.intermediates == intermediates
class TestAdcMatrixInterface(unittest.TestCase): def test_properties_adc2(self): case = "h2o_sto3g" method = "adc2" reference_state = cache.refstate[case] ground_state = adcc.LazyMp(reference_state) matrix = adcc.AdcMatrix(method, ground_state) assert matrix.ndim == 2 assert not matrix.is_core_valence_separated assert matrix.shape == (1640, 1640) assert len(matrix) == 1640 assert matrix.blocks == ["s", "d"] assert matrix.has_block("s") assert matrix.has_block("d") assert not matrix.has_block("t") assert matrix.block_spaces("s") == ["o1", "v1"] assert matrix.block_spaces("d") == ["o1", "o1", "v1", "v1"] assert matrix.reference_state == reference_state assert matrix.mospaces == reference_state.mospaces assert isinstance(matrix.timer, adcc.timings.Timer) assert isinstance(matrix.to_cpp(), libadcc.AdcMatrix)
class TestAdcMatrixShifted(unittest.TestCase): def construct_matrices(self, case, shift): reference_state = cache.refstate[case] ground_state = adcc.LazyMp(reference_state) matrix = adcc.AdcMatrix("adc3", ground_state) shifted = AdcMatrixShifted(matrix, shift) return matrix, shifted
def test_to_ndarray(self): mp2diff = adcc.LazyMp(cache.refstate["h2o_sto3g"]).mp2_diffdm dm_oo = mp2diff["o1o1"].to_ndarray() dm_ov = mp2diff["o1v1"].to_ndarray() dm_vv = mp2diff["v1v1"].to_ndarray() dm_o = np.hstack((dm_oo, dm_ov)) dm_v = np.hstack((dm_ov.transpose(), dm_vv)) dm_full = np.vstack((dm_o, dm_v)) np.testing.assert_almost_equal(dm_full, mp2diff.to_ndarray(), decimal=12)
def test_estimate_n_guesses(self): from adcc.workflow import estimate_n_guesses refstate = cache.refstate["h2o_sto3g"] ground_state = adcc.LazyMp(refstate) matrix = adcc.AdcMatrix("adc2", ground_state) # Check minimal number of guesses is 4 and at some point # we get more than four guesses assert 4 == estimate_n_guesses(matrix, n_states=1, singles_only=True) assert 4 == estimate_n_guesses(matrix, n_states=2, singles_only=True) for i in range(3, 20): assert i <= estimate_n_guesses( matrix, n_states=i, singles_only=True)
def test_functionality(self): ground_state = adcc.LazyMp(cache.refstate["h2o_sto3g"]) matrix = adcc.AdcMatrix("adc2", ground_state) vectors = [adcc.guess_zero(matrix) for i in range(2)] for vec in vectors: vec.set_random() v, w = vectors with pytest.raises(AttributeError): v.pph with pytest.raises(AttributeError): v.pph = w.ph # setattr with expression z = adcc.zeros_like(v) z.ph = v.ph + w.ph z -= w np.testing.assert_allclose(v.ph.to_ndarray(), z.ph.to_ndarray())
def test_copy(self): ref = cache.refstate["h2o_sto3g"] mp2diff = adcc.LazyMp(ref).mp2_diffdm cpy = mp2diff.copy() assert cpy.blocks == mp2diff.blocks assert cpy.blocks_nonzero == mp2diff.blocks_nonzero assert cpy.reference_state == mp2diff.reference_state assert cpy.mospaces == mp2diff.mospaces for b in mp2diff.blocks: assert cpy.is_zero_block(b) == mp2diff.is_zero_block(b) if not mp2diff.is_zero_block(b): assert_equal( cpy.block(b).to_ndarray(), mp2diff.block(b).to_ndarray()) assert cpy.block(b) is not mp2diff.block(b)
def template_singles_view(self, method): if "cvs" in method: reference_state = cache.refstate_cvs["h2o_sto3g"] shape = (8, 8) spaces_s = ["o2", "v1"] else: reference_state = cache.refstate["h2o_sto3g"] shape = (40, 40) spaces_s = ["o1", "v1"] matrix = adcc.AdcMatrix(method, adcc.LazyMp(reference_state)) view = adcc.AdcBlockView(matrix, "s") assert view.ndim == 2 assert view.is_core_valence_separated == ("cvs" in method) assert view.shape == shape assert len(view) == shape[0] assert view.blocks == ["s"] assert view.has_block("s") assert not view.has_block("d") assert not view.has_block("t") assert view.block_spaces("s") == spaces_s assert view.reference_state == reference_state assert view.mospaces == reference_state.mospaces assert isinstance(view.timer, adcc.timings.Timer) assert view.to_cpp() == matrix.to_cpp() # Check diagonal diff = matrix.diagonal("s") - view.diagonal("s") assert diff.dot(diff) < 1e-12 # Check @ (one vector and multiple vectors) invec = adcc.guess_zero(matrix) invec["s"].set_random() # "d" left as zero invec_singles = adcc.AmplitudeVector(invec["s"]) ref = matrix @ invec res = view @ invec_singles diff = res["s"] - ref["s"] assert diff.dot(diff) < 1e-12 res = view @ [invec_singles, invec_singles, invec_singles] diff = [res[i]["s"] - ref["s"] for i in range(3)] assert max(d.dot(d) for d in diff) < 1e-12
def template_singles_view(self, method): if "cvs" in method: reference_state = cache.refstate_cvs["h2o_sto3g"] shape = (8, 8) spaces_ph = ["o2", "v1"] else: reference_state = cache.refstate["h2o_sto3g"] shape = (40, 40) spaces_ph = ["o1", "v1"] matrix = adcc.AdcMatrix(method, adcc.LazyMp(reference_state)) view = matrix.block_view("ph_ph") assert view.ndim == 2 assert view.is_core_valence_separated == ("cvs" in method) assert view.shape == shape assert len(view) == shape[0] assert view.axis_blocks == ["ph"] assert sorted(view.axis_spaces.keys()) == view.axis_blocks assert sorted(view.axis_lengths.keys()) == view.axis_blocks assert view.axis_spaces["ph"] == spaces_ph assert view.axis_lengths["ph"] == shape[0] assert view.reference_state == reference_state assert view.mospaces == reference_state.mospaces assert isinstance(view.timer, adcc.timings.Timer) # Check diagonal diff = matrix.diagonal().ph - view.diagonal().ph assert diff.dot(diff) < 1e-12 # Check @ (one vector and multiple vectors) invec = adcc.guess_zero(matrix) invec.ph.set_random() # "d" left as zero invec_singles = adcc.AmplitudeVector(ph=invec.ph) ref = matrix @ invec res = view @ invec_singles diff = res.ph - ref.ph assert diff.dot(diff) < 1e-12 res = view @ [invec_singles, invec_singles, invec_singles] diff = [res[i].ph - ref.ph for i in range(3)] assert max(d.dot(d) for d in diff) < 1e-12
def test_matvec_adc2(self): ground_state = adcc.LazyMp(cache.refstate["h2o_sto3g"]) matrix = adcc.AdcMatrix("adc2", ground_state) vectors = [adcc.guess_zero(matrix) for i in range(3)] for vec in vectors: vec.set_random() v, w, x = vectors # Compute references: refv = matrix.matvec(v) refw = matrix.matvec(w) refx = matrix.matvec(x) # @ operator (1 vector) resv = matrix @ v diffv = refv - resv assert diffv.ph.dot(diffv.ph) < 1e-12 assert diffv.pphh.dot(diffv.pphh) < 1e-12 # @ operator (multiple vectors) resv, resw, resx = matrix @ [v, w, x] diffs = [refv - resv, refw - resw, refx - resx] for i in range(3): assert diffs[i].ph.dot(diffs[i].ph) < 1e-12 assert diffs[i].pphh.dot(diffs[i].pphh) < 1e-12 # compute matvec resv = matrix.matvec(v) diffv = refv - resv assert diffv.ph.dot(diffv.ph) < 1e-12 assert diffv.pphh.dot(diffv.pphh) < 1e-12 resv = matrix.rmatvec(v) diffv = refv - resv assert diffv.ph.dot(diffv.ph) < 1e-12 assert diffv.pphh.dot(diffv.pphh) < 1e-12 # Test apply resv.ph = matrix.block_apply("ph_ph", v.ph) resv.ph += matrix.block_apply("ph_pphh", v.pphh) refv = matrix.matvec(v) diffv = resv.ph - refv.ph assert diffv.dot(diffv) < 1e-12
def test_product_trace_symmetric(self): ref = cache.refstate["h2o_sto3g"] dipx_mo = ref.operators.electric_dipole[0] mp2diff_mo = adcc.LazyMp(ref).mp2_diffdm mp2diff_ao = mp2diff_mo.to_ao_basis(ref) mp2a = mp2diff_ao[0].to_ndarray() mp2b = mp2diff_ao[1].to_ndarray() dipx_ao = ref.operators.provider_ao.electric_dipole[0] dipx_ref = np.sum(mp2a * dipx_ao) + np.sum(mp2b * dipx_ao) oo = np.sum(mp2diff_mo.oo.to_ndarray() * dipx_mo.oo.to_ndarray()) ov = 2.0 * np.sum(mp2diff_mo.ov.to_ndarray() * dipx_mo.ov.to_ndarray()) vv = np.sum(mp2diff_mo.vv.to_ndarray() * dipx_mo.vv.to_ndarray()) dipx_np = oo + ov + vv assert dipx_np == approx(product_trace(mp2diff_mo, dipx_mo)) assert product_trace(mp2diff_mo, dipx_mo) == approx(dipx_ref) assert product_trace(dipx_mo, mp2diff_mo) == approx(dipx_ref)
def test_diagonalise_adcmatrix(self): from adcc.workflow import diagonalise_adcmatrix refdata = cache.reference_data["h2o_sto3g"] matrix = adcc.AdcMatrix("adc2", adcc.LazyMp(cache.refstate["h2o_sto3g"])) res = diagonalise_adcmatrix(matrix, n_states=3, kind="singlet", eigensolver="davidson") ref_singlets = refdata["adc2"]["singlet"]["eigenvalues"] assert res.converged assert res.eigenvalues == approx(ref_singlets[:3]) guesses = adcc.guesses_singlet(matrix, n_guesses=6, block="ph") res = diagonalise_adcmatrix(matrix, n_states=3, kind="singlet", guesses=guesses) ref_singlets = refdata["adc2"]["singlet"]["eigenvalues"] assert res.converged assert res.eigenvalues == approx(ref_singlets[:3]) with pytest.raises(InputError): # Too low tolerance res = diagonalise_adcmatrix(matrix, n_states=9, kind="singlet", eigensolver="davidson", conv_tol=1e-14) with pytest.raises(InputError): # Wrong solver method res = diagonalise_adcmatrix(matrix, n_states=9, kind="singlet", eigensolver="blubber") with pytest.raises(InputError): # Too few guesses res = diagonalise_adcmatrix(matrix, n_states=9, kind="singlet", eigensolver="davidson", guesses=guesses)
def test_matvec_adc2(self): ground_state = adcc.LazyMp(cache.refstate["h2o_sto3g"]) matrix = adcc.AdcMatrix("adc2", ground_state) cppmatrix = libadcc.AdcMatrix("adc2", ground_state) vectors = [adcc.guess_zero(matrix) for i in range(3)] for vec in vectors: vec["s"].set_random() vec["d"].set_random() v, w, x = vectors # Compute references: refv = adcc.empty_like(v) refw = adcc.empty_like(w) refx = adcc.empty_like(x) cppmatrix.compute_matvec(v.to_cpp(), refv.to_cpp()) cppmatrix.compute_matvec(w.to_cpp(), refw.to_cpp()) cppmatrix.compute_matvec(x.to_cpp(), refx.to_cpp()) # @ operator (1 vector) resv = matrix @ v diffv = refv - resv assert diffv["s"].dot(diffv["s"]) < 1e-12 assert diffv["d"].dot(diffv["d"]) < 1e-12 # @ operator (multiple vectors) resv, resw, resx = matrix @ [v, w, x] diffs = [refv - resv, refw - resw, refx - resx] for i in range(3): assert diffs[i]["s"].dot(diffs[i]["s"]) < 1e-12 assert diffs[i]["d"].dot(diffs[i]["d"]) < 1e-12 # compute matvec matrix.compute_matvec(v, resv) diffv = refv - resv assert diffv["s"].dot(diffv["s"]) < 1e-12 assert diffv["d"].dot(diffv["d"]) < 1e-12 matrix.compute_apply("ss", v["s"], resv["s"]) cppmatrix.compute_apply("ss", v["s"], refv["s"]) diffv = resv["s"] - refv["s"] assert diffv.dot(diffv) < 1e-12
#!/usr/bin/env python3 ## vi: tabstop=4 shiftwidth=4 softtabstop=4 expandtab import adcc from import_data import import_data from adcc.caching_policy import GatherStatisticsPolicy # Gather precomputed data data = import_data() # Initialise the caching policy: statistics_policy = GatherStatisticsPolicy() mp = adcc.LazyMp(adcc.ReferenceState(data), statistics_policy) # Run an adc2 calculation: singlets = adcc.adc2x(mp, n_singlets=5, conv_tol=1e-8) triplets = adcc.adc2x(mp, n_triplets=5, conv_tol=1e-8) print(singlets.describe()) print(triplets.describe()) print("Tensor cache statistics:") print(statistics_policy.call_count)
def test_diagonal_adc2(self): ground_state = adcc.LazyMp(cache.refstate["h2o_sto3g"]) matrix = adcc.AdcMatrix("adc2", ground_state) cppmatrix = libadcc.AdcMatrix("adc2", ground_state) diff = cppmatrix.diagonal("s") - matrix.diagonal("s") assert diff.dot(diff) < 1e-12
assert sorted(matrix.axis_lengths.keys()) == matrix.axis_blocks assert matrix.axis_spaces["ph"] == ["o1", "v1"] assert matrix.axis_spaces["pphh"] == ["o1", "o1", "v1", "v1"] assert matrix.axis_lengths["ph"] == 40 assert matrix.axis_lengths["pphh"] == 1600 assert matrix.reference_state == reference_state assert matrix.mospaces == reference_state.mospaces assert isinstance(matrix.timer, adcc.timings.Timer) def test_properties_cvs_adc1(self): case = "h2o_sto3g" method = "cvs-adc1" reference_state = cache.refstate_cvs[case] ground_state = adcc.LazyMp(reference_state) matrix = adcc.AdcMatrix(method, ground_state) assert matrix.ndim == 2 assert matrix.is_core_valence_separated assert matrix.shape == (8, 8) assert len(matrix) == 8 assert matrix.axis_blocks == ["ph"] assert sorted(matrix.axis_spaces.keys()) == matrix.axis_blocks assert sorted(matrix.axis_lengths.keys()) == matrix.axis_blocks assert matrix.axis_spaces["ph"] == ["o2", "v1"] assert matrix.axis_lengths["ph"] == 8 assert matrix.reference_state == reference_state assert matrix.mospaces == reference_state.mospaces
def test_construct_adcmatrix(self): from adcc.workflow import construct_adcmatrix # # Construction from hfdata # hfdata = cache.hfdata["h2o_sto3g"] res = construct_adcmatrix(hfdata, method="adc3") assert isinstance(res, adcc.AdcMatrix) assert res.method == adcc.AdcMethod("adc3") assert res.mospaces.core_orbitals == [] assert res.mospaces.frozen_core == [] assert res.mospaces.frozen_virtual == [] res = construct_adcmatrix(hfdata, method="cvs-adc3", core_orbitals=1) assert isinstance(res, adcc.AdcMatrix) assert res.method == adcc.AdcMethod("cvs-adc3") assert res.mospaces.core_orbitals == [0, 7] assert res.mospaces.frozen_core == [] assert res.mospaces.frozen_virtual == [] res = construct_adcmatrix(hfdata, method="adc2", frozen_core=1) assert res.mospaces.core_orbitals == [] assert res.mospaces.frozen_core == [0, 7] assert res.mospaces.frozen_virtual == [] res = construct_adcmatrix(hfdata, method="adc2", frozen_virtual=1) assert res.mospaces.core_orbitals == [] assert res.mospaces.frozen_core == [] assert res.mospaces.frozen_virtual == [6, 13] res = construct_adcmatrix(hfdata, method="adc2", frozen_virtual=1, frozen_core=1) assert res.mospaces.core_orbitals == [] assert res.mospaces.frozen_core == [0, 7] assert res.mospaces.frozen_virtual == [6, 13] invalid_cases = [ dict(), # Missing method dict(method="dadadad"), # Unknown method dict(frozen_core=1), # Missing method dict(frozen_virtual=3), # Missing method dict(core_orbitals=4), # Missing method dict(method="cvs-adc2"), # No core_orbitals dict(method="cvs-adc2", frozen_core=1), dict(method="adc2", core_orbitals=3), # Extra core parameter dict(method="adc2", core_orbitals=3, frozen_virtual=2), ] for case in invalid_cases: with pytest.raises(InputError): construct_adcmatrix(hfdata, **case) # # Construction from LazyMp or ReferenceState # refst_ful = cache.refstate["h2o_sto3g"] refst_cvs = cache.refstate_cvs["h2o_sto3g"] gs_ful, gs_cvs = adcc.LazyMp(refst_ful), adcc.LazyMp(refst_cvs) for obj in [gs_ful, refst_ful]: res = construct_adcmatrix(obj, method="adc2") assert isinstance(res, adcc.AdcMatrix) assert res.method == adcc.AdcMethod("adc2") with pytest.raises(InputError, match=r"Cannot run a core-valence"): construct_adcmatrix(obj, method="cvs-adc2x") with pytest.warns(UserWarning, match=r"^Ignored frozen_core parameter"): construct_adcmatrix(obj, frozen_core=3, method="adc1") with pytest.warns(UserWarning, match=r"^Ignored frozen_virtual parameter"): construct_adcmatrix(obj, frozen_virtual=1, method="adc3") for obj in [gs_cvs, refst_cvs]: res = construct_adcmatrix(obj, method="cvs-adc2x") assert isinstance(res, adcc.AdcMatrix) assert res.method == adcc.AdcMethod("cvs-adc2x") with pytest.raises(InputError): construct_adcmatrix(obj) # Missing method with pytest.raises(InputError, match=r"Cannot run a general"): construct_adcmatrix(obj, method="adc2") with pytest.warns(UserWarning, match=r"^Ignored core_orbitals parameter"): construct_adcmatrix(obj, core_orbitals=2, method="cvs-adc1") # # Construction from ADC matrix # mtx_ful = adcc.AdcMatrix("adc2", gs_ful) mtx_cvs = adcc.AdcMatrix("cvs-adc2", gs_cvs) assert construct_adcmatrix(mtx_ful) == mtx_ful assert construct_adcmatrix(mtx_ful, method="adc2") == mtx_ful assert construct_adcmatrix(mtx_cvs) == mtx_cvs assert construct_adcmatrix(mtx_cvs, method="cvs-adc2") == mtx_cvs with pytest.warns(UserWarning, match=r"Ignored method parameter"): construct_adcmatrix(mtx_ful, method="adc3") with pytest.warns(UserWarning, match=r"^Ignored core_orbitals parameter"): construct_adcmatrix(mtx_cvs, core_orbitals=2) with pytest.warns(UserWarning, match=r"^Ignored frozen_core parameter"): construct_adcmatrix(mtx_ful, frozen_core=3) with pytest.warns(UserWarning, match=r"^Ignored frozen_virtual parameter"): construct_adcmatrix(mtx_cvs, frozen_virtual=1)
def test_extra_term(self): ground_state = adcc.LazyMp(cache.refstate["h2o_sto3g"]) matrix_adc1 = adcc.AdcMatrix("adc1", ground_state) with pytest.raises(TypeError): matrix_adc1 += 42 matrix = adcc.AdcMatrix("adc2", ground_state) with pytest.raises(TypeError): adcc.AdcMatrix("adc2", ground_state, diagonal_precomputed=42) with pytest.raises(ValueError): adcc.AdcMatrix("adc2", ground_state, diagonal_precomputed=matrix.diagonal() + 42) with pytest.raises(TypeError): AdcExtraTerm(matrix, "fail") with pytest.raises(TypeError): AdcExtraTerm(matrix, {"fail": "not_callable"}) shift = -0.3 shifted = AdcMatrixShifted(matrix, shift) # TODO: need to use AmplitudeVector to differentiate between # diagonals for ph and pphh # if we just pass numbers, i.e., shift # we get 2*shift on the diagonal ones = matrix.diagonal().ones_like() def __shift_ph(hf, mp, intermediates): def apply(invec): return adcc.AmplitudeVector(ph=shift * invec.ph) diag = adcc.AmplitudeVector(ph=shift * ones.ph) return AdcBlock(apply, diag) def __shift_pphh(hf, mp, intermediates): def apply(invec): return adcc.AmplitudeVector(pphh=shift * invec.pphh) diag = adcc.AmplitudeVector(pphh=shift * ones.pphh) return AdcBlock(apply, diag) extra = AdcExtraTerm(matrix, { 'ph_ph': __shift_ph, 'pphh_pphh': __shift_pphh }) # cannot add to 'pphh_pphh' in ADC(1) matrix with pytest.raises(ValueError): matrix_adc1 += extra shifted_2 = matrix + extra shifted_3 = extra + matrix for manual in [shifted_2, shifted_3]: assert_allclose(shifted.diagonal().ph.to_ndarray(), manual.diagonal().ph.to_ndarray(), atol=1e-12) assert_allclose(shifted.diagonal().pphh.to_ndarray(), manual.diagonal().pphh.to_ndarray(), atol=1e-12) vec = adcc.guess_zero(matrix) vec.set_random() ref = shifted @ vec ret = manual @ vec diff_s = ref.ph - ret.ph diff_d = ref.pphh - ret.pphh assert np.max(np.abs(diff_s.to_ndarray())) < 1e-12 assert np.max(np.abs(diff_d.to_ndarray())) < 1e-12
def test_reference_cn_adc3(self): ground_state = adcc.LazyMp(cache.refstate["cn_sto3g"]) matrix = adcc.AdcMatrix("adc3", ground_state) self.base_reference(matrix, self.get_ref_cn())
def test_reference_h2o_adc2x(self): ground_state = adcc.LazyMp(cache.refstate["h2o_sto3g"]) matrix = adcc.AdcMatrix("adc2x", ground_state) self.base_reference(matrix, self.get_ref_h2o())