Davidson works when doubles folding in ADC(2) by TianLin-228 · Pull Request #176 · adc-connect/adcc

TianLin-228 · 2024-08-16T14:53:07Z

Implement a modified Davidson procedure for doubles-folding. It solves pseudo-eigenvalue problem ω_i u_i = A(ω_i) u_i, where A(ω_i) is an effective ADC matrix which depends on the eigenvalue ω_i. The modified procedure is based on the implementation stated in the paper ( J. Chem. Phys. 158, 124121 (2023)).

The algorithm consists of state-specific macro and micro iterations and further DIIS acceleration. Micro-iterations use Davidson iterations to diagonalize the effective matrix A_eff(ω_i) with the fixed eigenvalue ω_i, giving a new eigenvalue ω^'_i. After convergence, a new macro-iteration begins with the effective matrix A_eff(ω^'_i) . This process continues until the eigenvectors meet a threshold (default=1e-3), after which DIIS further converges the individual roots.

NB: This procedure only works for single excitations.

Changes:

In file “davidson.py”:

New functions named “davidson_folded_DIIS“ and “eigsh_folded” are added, which implements the main procedure of the modified Davidson method. It consists of loops for macro iterations, in which the davidson_iterations are performed as micro iterations, and loops for DIIS iterations.
Changes in function “davidson_iterations” :
- For the folding case, when it breaks at convergence or otherwise, the eigenvectors with the number of n_block are calculated by the rvecs and guesses, and the subspace_vectors is updated for the next macro iteration;
- A different convergence criteria for the folding case as following:
  ω⁰_i - ω¹_i > ω^n-1_i - ωⁿ_i , where ω⁰_i is the initial guess of ω_i and ωⁿ_i is the Ritz value of the current micro iteration.
Add new Class DIIS to implement diis acceleration.
There are two new Classes: Class FoldedDavidsonState inherits from Class DavidsonState and contains more properties about the DavidsonState in doubles-folding case; Class DIIS is used when performing extrapolation on the corrected vector.
Add new properties for Class DavidsonState: “folded” is the flag to distinguish normal or modified davidson procedures when running “davidson_iterations”, and “DIIS_iter” sums the total number of performed DIIS iterations for all required states.
In the function “default_print”, there are new identifiers for the folding case.

In the file “AdcMatrix.py”, the matrix-vector product of the folded ADC matrix with singles component is defined in the new Class AdcMatrixFolded.
Workflow - two options of guesses vector in doubles-folding case:
guesses_fold = “adc1”, which takes adc1 results (excitation_vector and excitation_energy_uncorrected) as initial guess vectors and guess eigenvalues.
Or obtaining guess vectors by inspecting the diagonal matrix elements as default.

Testing:

test_davidson_folded.py: testing davidson_folded_DIIS in two cases of given guesses and taking guesses as adc1 results.
test_workflow.py: I added two tests for new parameters “fold”, “guesses_fold” and “omegas”.

apapapostolou · 2025-04-07T15:01:07Z

@TianLin-228 could you update this against the current master?

TianLin-228 · 2025-04-08T15:34:17Z

Updating brings the branch up to date with the current master. The updates include:

davidson.py: involving the use of n_block

davidson_test.py: Expanded testing for davidson_folded_DIIS by adding two cases:

 - Testing with  given guess inputs.

 - Testing by using ADC1 results as the guess.

adcc/AdcMatrix.py

frieschneider · 2025-06-26T08:23:32Z

adcc/AdcMatrix.py

+        """
+        diag = super().diagonal().pphh
+        e = diag.ones_like()
+        u2 = self.block_apply("pphh_ph", u1.ph) / (e * self.omega - diag)


You should explicitly symmetrise the doubles vector. This can be done, for example, using the IndexSymmetrisation class from solver/explicit_symmetrisation.py. You can find usage examples in respondo/MatrixWrapper.py.

frieschneider · 2025-06-26T11:56:44Z

adcc/solver/davidson.py

        print("    Total solver time:          ", strtime(soltime), file=file)
    elif identifier == "restart":
        print("=== Restart ===", file=file)
+    # For folded matrix


The printout for the folded davidson solver looks a bit messy, the alignment is off, for example. I also noticed that the style is different compared to the standard davidson solver in adcc. Was there a specific reason for changing the formatting? If not, it might be better to stick with the earlier style for better readability.

adcc/solver/davidson.py

adcc/tests/solver/davidson_test.py

frieschneider · 2025-06-27T09:02:45Z

adcc/tests/solver/davidson_test.py

        assert res.converged
        assert res.eigenvalues[:n_states] == pytest.approx(ref_triplets[:n_states])
+
+    def test_adc2_singlets_folded(self):


I would put it in an other class. Like TestSolverDavidsonFolded.
You should also think about testing the correct symmetry of the unfolded eigenvector.

adcc/workflow.py

apapapostolou · 2025-09-03T10:30:11Z

@TianLin-228 what is the current status here? Can you push your local changes?

TianLin-228 · 2025-10-27T02:02:05Z

@TianLin-228 what is the current status here? Can you push your local changes?

Hi, sorry for delayed update!

I've been suffering from the symmetry test, and there is another one triggered by max_subspace. I’d also like to discuss the tests for unfold in AdcMatrix_test.py. This is also to keep a record.

frieschneider · 2025-10-27T14:41:25Z

adcc/AdcMatrix.py

+                         block_orders=matrix.block_orders,
+                         intermediates=matrix.intermediates)
+        if matrix.method.name != "adc2":
+            raise TypeError("The matrix should be ADC2 Matrix for doubles-folding.")


I would call it:
"Doubles folding can currently only be applied to an ADC(2) matrix."

frieschneider · 2025-10-27T14:41:38Z

adcc/AdcMatrix.py

+        """
+        return AmplitudeVector(ph=super().diagonal().ph)
+
+    def u2_fold(self, other):


Please rename it so that it is a bit more meaningful:
get_doubles_component(self, in_ampl)

frieschneider · 2025-10-27T14:41:41Z

adcc/AdcMatrix.py

+        u2 = self.block_apply("pphh_ph", other.ph) / (e * self.omega - diag)
+        return self.isymm.symmetrise(AmplitudeVector(pphh=u2))
+
+    def matvec(self, other):


same here, you can rename other to in_ampl to keep it more in line with the AdcMatrix implementation.

frieschneider · 2025-10-27T14:41:48Z

adcc/AdcMatrix.py

+        return AmplitudeVector(ph=self.block_apply("ph_ph", other.ph)
+                               + self.block_apply("ph_pphh", u2.pphh))
+
+    def unfold(self, other):


unfold_solution(self, in_ampl)

frieschneider · 2025-10-27T14:42:14Z

adcc/solver/davidson.py

 from .preconditioner import JacobiPreconditioner
 from .SolverStateBase import EigenSolverStateBase
 from .explicit_symmetrisation import IndexSymmetrisation
+from .DIIS import DIIS


You forgot to add the DIIS.py file :)

frieschneider · 2025-10-28T15:56:20Z

adcc/AdcMatrix.py

        #      a block_view and then wrap that in an AdcMatrixProjected.
+
+
+class AdcMatrixFolded(AdcMatrix):


I would move it into a separate file within the solver directory, since it’s currently quite solver-specific (for example, the unfold_solution function clearly refers to solving the eigenvalue problem handled in the solver) and specific to ADC(2). I’d also rename it to Adc2MatrixFolded.

However, we should consider how to generalize it in the future. :)

frieschneider · 2025-10-28T15:59:02Z

adcc/AdcMatrix.py

+        super().__init__(matrix.method, matrix.ground_state,
+                         block_orders=matrix.block_orders,
+                         intermediates=matrix.intermediates)
+        if matrix.method.name != "adc2":


As an idea for a more general approach: matrix.method.level % 2 !=0, because in general the ADC(4) matrix can also be folded.

frieschneider · 2025-10-29T08:31:33Z

adcc/tests/AdcMatrix_test.py

+                             - odiag["ph"].to_ndarray())) < 1e-12
+        assert not hasattr(fdiag, "pphh")
+
+    def test_u2_fold(self, system: str):


please rename it to test_get_doubles_component

frieschneider · 2025-10-29T08:34:54Z

adcc/tests/AdcMatrix_test.py

+        diff = diff_manual - diff_matvec
+        assert np.max(np.abs(diff.to_ndarray())) < 1e-12
+
+    def test_unfold_random_vec(self,system:str):


I think that either this or the test_u2_fold are necessary as they essentially do the same.

frieschneider · 2025-10-30T16:08:57Z

adcc/AdcMatrix.py

+        """
+        diag = super().diagonal().pphh
+        e = diag.ones_like()
+        u2 = self.block_apply("pphh_ph", other.ph) / (e * self.omega - diag)


to get the correct symmetry: try to explicitly symmetrise it:

u2 = ( self.block_apply("pphh_ph", other.ph) / (e * self.omega - diag) ).antisymmetrise(0, 1).antisymmetrise(2, 3).symmetrise([(0, 1), (2, 3)])

frieschneider · 2025-10-30T16:14:22Z

and please update it against the master :)

frieschneider · 2025-10-30T16:17:37Z

adcc/tests/solver/davidson_test.py

+        from adcc.AmplitudeVector import AmplitudeVector
+        print(ref_singlets_vec_s,type(ref_singlets_vec_s),type(res.eigenvectors[0]),res.eigenvectors[0])
+        ref_vec = AmplitudeVector(ph=ref_singlets_vec_s,pphh=ref_singlets_vec_d)
+        assert res.eigenvectors[0].ph.describe_symmetry() == ref_vec.ph.describe_symmetry()


Instead of using describe_symmetry to compare the symmetries, you can use the assert_equal_symmetry function from projection_test.py. It provides a more robust comparison.

Davidson works when doubles folding in ADC(2)

a5ba0e5

TianLin-228 marked this pull request as ready for review August 19, 2024 13:06

TianLin-228 added 2 commits August 19, 2024 15:06

Merge branch 'master' into davidson_foldingMatrix

615032e

Merge branch 'master' into davidson_foldingMatrix

e14f645

TianLin-228 added 2 commits April 8, 2025 13:17

Merge branch 'master' into davidson_foldingMatrix

23b7557

Merge branch 'master' into davidson_foldingMatrix

4906cff

delete update_omega & test for AdcMatrixFolded

bcc13f9

frieschneider reviewed Jun 27, 2025

View reviewed changes

emplicit symmetry; workflow test

1197c30

frieschneider reviewed Oct 30, 2025

View reviewed changes

		# a block_view and then wrap that in an AdcMatrixProjected.


		class AdcMatrixFolded(AdcMatrix):

Conversation

TianLin-228 commented Aug 16, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Changes:

Testing:

Uh oh!

apapapostolou commented Apr 7, 2025

Uh oh!

TianLin-228 commented Apr 8, 2025

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

apapapostolou commented Sep 3, 2025

Uh oh!

TianLin-228 commented Oct 27, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

frieschneider Oct 30, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

frieschneider commented Oct 30, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

TianLin-228 commented Aug 16, 2024 •

edited

Loading

frieschneider Oct 30, 2025 •

edited

Loading