excitationsolve 2.2.1__tar.gz → 2.2.3__tar.gz

{excitationsolve-2.2.1/excitationsolve.egg-info → excitationsolve-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: excitationsolve
-Version: 2.2.1
+Version: 2.2.3
 Summary: ExcitationSolve: a fast globally-informed gradient-free optimizer for physically-motivated ansätze constructed of excitation operators
 Author-email: Jonas Jäger <jojaeger@cs.ubc.ca>, "Thierry N. Kaldenbach" <Thierry.Kaldenbach@dlr.de>, Max Haas <Max.Haas@dlr.de>, Erik Schultheis <Erik.Schultheis@dlr.de>
 License:        Copyright 2025 Jonas Jäger, Thierry N. Kaldenbach, Max Haas, Erik Schultheis,
@@ -241,7 +241,7 @@ Requires-Dist: tencirchem-ng==2024.10; extra == "test"
 Requires-Dist: pyscf==2.8.0; extra == "test"
 Dynamic: license-file
 
-# ExcitationSolve [![paper](https://img.shields.io/badge/Commun.%20Phys.-Paper-0274b5.svg)](https://www.nature.com/articles/s42005-025-02375-9) [![DOI](https://zenodo.org/badge/958004975.svg)](https://doi.org/10.5281/zenodo.17457122)
+# ExcitationSolve [![paper](https://img.shields.io/badge/Commun.%20Phys.-Paper-0274b5.svg)](https://www.nature.com/articles/s42005-025-02375-9) [![DOI](https://zenodo.org/badge/958004975.svg)](https://doi.org/10.5281/zenodo.17457122) [![PyPI](https://img.shields.io/pypi/v/excitationsolve.svg?color=0274b5&label=PyPI)](https://pypi.org/project/excitationsolve/)
 
 An optimization algorithm for ansätze consisting of excitation operators in variational quantum eigensolvers (VQEs).
 
@@ -257,6 +257,11 @@ VQE convergence for different molecules and optimizers, including ExcitationSolv
 </h1>
 
 ## Installation
+ExcitationSolve is available on [PyPI](https://pypi.org/project/excitationsolve/):
+```
+pip install excitationsolve
+```
+Alternatively, install directly from GitHub:
 ```
 pip install git+https://github.com/dlr-wf/ExcitationSolve.git
 ```
@@ -287,11 +292,27 @@ Use the `excitationsolve.ExcitationSolveScipy` class in combination with the `sc
 ```python
 excsolve_obj = ExcitationSolveScipy(maxiter=100, tol=1e-10, save_parameters=True)
 optimizer = excsolve_obj.minimize
-res = scipy.optimize.minimize(cost, params, method=optimizer)
+def callback(xk): # or callback(intermediate_result)
+    print(xk)
+options = dict(parameter_occ=parameter_occ) # optional, use if parameters occur multiple times in the ansatz
+res = scipy.optimize.minimize(cost, params, method=optimizer, callback=callback, options=options)
 energies = excsolve_obj.energies
 counts = excsolve_obj.nfevs
 ```
 
+### Optimal parameters of double excitations w.r.t. the Hartree-Fock state
+Use `exitationsolve.optimal_theta` and `excitationsolve.optimal_theta_pyscf` to calculate analytic optimal parameter values for individual double excitations when applied to the Hartree-Fock reference state. Both functions return the optimal parameter and the energy difference to the Hartree-Fock energy. The optimal parameter is defined as $\theta^*=\argmin_\theta\bra{\mathrm{HF}}U^\dagger(\theta) H U(\theta)\ket{\mathrm{HF}}$ where $H$ is the electronic structure Hamiltonian, $U(\theta)$ is **one** double excitation, and $\ket{\mathrm{HF}}$ is the Hartree-Fock state. In [Haas et al., 2026](https://doi.org/10.48550/arXiv.2602.10776) it has been shown that initializing doubles in their respective optimal parameter and appending them to the ansatz in order of energy impact is an efficient operator selection and warm-start strategy.
+
+### Testing
+To run the tests, install the needed dependencies with
+```bash
+uv pip install .[test]
+```
+and execute
+```bash
+pytest
+```
+
 
 ## Authors
 - Jonas Jäger
@@ -305,7 +326,7 @@ Feel free to contact [David Melching](mailto:David.Melching@dlr.de) if you have
 ## Citation
 If you use portions of this code please cite our [paper](https://www.nature.com/articles/s42005-025-02375-9):
 ```bibtex
-@article{Jaeger2024Fast,
+@article{Jaeger2025Fast,
     title={Fast gradient-free optimization of excitations in variational quantum eigensolvers},
     author={Jäger, Jonas and Kaldenbach, Thierry N. and Haas, Max and Schultheis, Erik},
     year={2025},
@@ -319,5 +340,18 @@ If you use portions of this code please cite our [paper](https://www.nature.com/
 }
 ```
 
+If you use the `exitationsolve.optimal_theta` or `excitationsolve.optimal_theta_pyscf` functionalities please also cite [Haas et al., 2026](https://doi.org/10.48550/arXiv.2602.10776):
+```bibtex
+@article{Haas2026Efficient,
+    title={Efficient Operator Selection and Warm-Start Strategy for Excitations in Variational Quantum Eigensolvers}, 
+    url={https://arxiv.org/abs/2602.10776},
+    DOI={10.48550/ARXIV.2602.10776},
+    publisher={arXiv},
+    author={Haas, Max and Kaldenbach, Thierry N. and Hammerschmidt, Thomas and Barragan-Yani, Daniel}, 
+    year={2026} 
+} 
+```
+
+
 ## Acknowledgment
 This project was made possible by the DLR Quantum Computing Initiative and the Federal Ministry for Economic Affairs and Climate Action; https://qci.dlr.de/quanticom.

{excitationsolve-2.2.1 → excitationsolve-2.2.3}/README.md

@@ -1,4 +1,4 @@
-# ExcitationSolve [![paper](https://img.shields.io/badge/Commun.%20Phys.-Paper-0274b5.svg)](https://www.nature.com/articles/s42005-025-02375-9) [![DOI](https://zenodo.org/badge/958004975.svg)](https://doi.org/10.5281/zenodo.17457122)
+# ExcitationSolve [![paper](https://img.shields.io/badge/Commun.%20Phys.-Paper-0274b5.svg)](https://www.nature.com/articles/s42005-025-02375-9) [![DOI](https://zenodo.org/badge/958004975.svg)](https://doi.org/10.5281/zenodo.17457122) [![PyPI](https://img.shields.io/pypi/v/excitationsolve.svg?color=0274b5&label=PyPI)](https://pypi.org/project/excitationsolve/)
 
 An optimization algorithm for ansätze consisting of excitation operators in variational quantum eigensolvers (VQEs).
 
@@ -14,6 +14,11 @@ VQE convergence for different molecules and optimizers, including ExcitationSolv
 </h1>
 
 ## Installation
+ExcitationSolve is available on [PyPI](https://pypi.org/project/excitationsolve/):
+```
+pip install excitationsolve
+```
+Alternatively, install directly from GitHub:
 ```
 pip install git+https://github.com/dlr-wf/ExcitationSolve.git
 ```
@@ -44,11 +49,27 @@ Use the `excitationsolve.ExcitationSolveScipy` class in combination with the `sc
 ```python
 excsolve_obj = ExcitationSolveScipy(maxiter=100, tol=1e-10, save_parameters=True)
 optimizer = excsolve_obj.minimize
-res = scipy.optimize.minimize(cost, params, method=optimizer)
+def callback(xk): # or callback(intermediate_result)
+    print(xk)
+options = dict(parameter_occ=parameter_occ) # optional, use if parameters occur multiple times in the ansatz
+res = scipy.optimize.minimize(cost, params, method=optimizer, callback=callback, options=options)
 energies = excsolve_obj.energies
 counts = excsolve_obj.nfevs
 ```
 
+### Optimal parameters of double excitations w.r.t. the Hartree-Fock state
+Use `exitationsolve.optimal_theta` and `excitationsolve.optimal_theta_pyscf` to calculate analytic optimal parameter values for individual double excitations when applied to the Hartree-Fock reference state. Both functions return the optimal parameter and the energy difference to the Hartree-Fock energy. The optimal parameter is defined as $\theta^*=\argmin_\theta\bra{\mathrm{HF}}U^\dagger(\theta) H U(\theta)\ket{\mathrm{HF}}$ where $H$ is the electronic structure Hamiltonian, $U(\theta)$ is **one** double excitation, and $\ket{\mathrm{HF}}$ is the Hartree-Fock state. In [Haas et al., 2026](https://doi.org/10.48550/arXiv.2602.10776) it has been shown that initializing doubles in their respective optimal parameter and appending them to the ansatz in order of energy impact is an efficient operator selection and warm-start strategy.
+
+### Testing
+To run the tests, install the needed dependencies with
+```bash
+uv pip install .[test]
+```
+and execute
+```bash
+pytest
+```
+
 
 ## Authors
 - Jonas Jäger
@@ -62,7 +83,7 @@ Feel free to contact [David Melching](mailto:David.Melching@dlr.de) if you have
 ## Citation
 If you use portions of this code please cite our [paper](https://www.nature.com/articles/s42005-025-02375-9):
 ```bibtex
-@article{Jaeger2024Fast,
+@article{Jaeger2025Fast,
     title={Fast gradient-free optimization of excitations in variational quantum eigensolvers},
     author={Jäger, Jonas and Kaldenbach, Thierry N. and Haas, Max and Schultheis, Erik},
     year={2025},
@@ -76,5 +97,18 @@ If you use portions of this code please cite our [paper](https://www.nature.com/
 }
 ```
 
+If you use the `exitationsolve.optimal_theta` or `excitationsolve.optimal_theta_pyscf` functionalities please also cite [Haas et al., 2026](https://doi.org/10.48550/arXiv.2602.10776):
+```bibtex
+@article{Haas2026Efficient,
+    title={Efficient Operator Selection and Warm-Start Strategy for Excitations in Variational Quantum Eigensolvers}, 
+    url={https://arxiv.org/abs/2602.10776},
+    DOI={10.48550/ARXIV.2602.10776},
+    publisher={arXiv},
+    author={Haas, Max and Kaldenbach, Thierry N. and Hammerschmidt, Thomas and Barragan-Yani, Daniel}, 
+    year={2026} 
+} 
+```
+
+
 ## Acknowledgment
 This project was made possible by the DLR Quantum Computing Initiative and the Federal Ministry for Economic Affairs and Climate Action; https://qci.dlr.de/quanticom.

{excitationsolve-2.2.1 → excitationsolve-2.2.3}/excitationsolve/excitation_solve_scipy.py

@@ -3,6 +3,8 @@ import logging
 from collections.abc import Callable
 import numpy as np
 from scipy.optimize import OptimizeResult
+from scipy.optimize._optimize import _wrap_callback
+from scipy._lib._util import _call_callback_maybe_halt
 from excitationsolve import excitation_solve_step, excitation_solve_step_shared_param
 
 
@@ -14,7 +16,9 @@ class ExcitationSolveScipy:
         ```python
             excsolve_obj = ExcitationSolveScipy(maxiter=100, tol=1e-10, save_parameters=True)
             optimizer = excsolve_obj.minimize
-            res = scipy.optimize.minimize(cost, params, method=optimizer)
+            def callback(xk): # or callback(intermediate_result)
+                print(xk)
+            res = scipy.optimize.minimize(cost, params, method=optimizer, callback=callback, options=dict(parameter_occ=parameter_occ))
             energies = excsolve_obj.energies
             counts = excsolve_obj.nfevs
         ```
@@ -71,10 +75,30 @@ class ExcitationSolveScipy:
                                                    how many excitations share each parameter.
                                                    parameter_occ[i] is the number of times the i-th parameter occurs in different excitations.
                                                    Defaults to [1, 1, ...] (all set to 1).
+            callback (callable, optional): A callable called after each iteration. Supports a callable with the signature::
+
+                                                callback(intermediate_result: OptimizeResult)
+
+                                           where ``intermediate_result`` is a keyword parameter containing an
+                                           `OptimizeResult` with attributes ``x`` and ``fun``, the present values
+                                           of the parameter vector and objective function. Not all attributes of
+                                           `OptimizeResult` may be present. The name of the parameter must be
+                                           ``intermediate_result`` for the callback to be passed an `OptimizeResult`.
+                                           These methods will also terminate if the callback raises ``StopIteration``.
+                                           Also supports a signature like::
+
+                                                callback(xk)
+
+                                           where ``xk`` is the current parameter vector.
+                                           Introspection is used to determine which of the signatures above to
+                                           invoke.
 
         Returns:
             OptimizeResult: Scipy OptimizeResult object
         """
+        callback = kwargs.get("callback")
+        callback = _wrap_callback(callback)
+
         params_excsolve = np.array(x0.copy())
         num_params = len(params_excsolve)
 
@@ -155,6 +179,11 @@ class ExcitationSolveScipy:
             if len(self.energies_after_it) > 1 and np.abs(self.energies_after_it[-1] - self.energies_after_it[-2]) <= self.tol:
                 break
 
+            if callback is not None:
+                intermediate_result = OptimizeResult(x=np.copy(params_excsolve), fun=current_energy_excsolve)
+                if _call_callback_maybe_halt(callback, intermediate_result):
+                    break
+
         result = OptimizeResult()
         result.x = params_excsolve
         result.fun = current_energy_excsolve

{excitationsolve-2.2.1 → excitationsolve-2.2.3}/excitationsolve/info.py

@@ -1,3 +1,3 @@
-__version__ = "2.2.1"  # MAJOR.MINOR.PATCH, like in https://semver.org/
+__version__ = "2.2.3"  # MAJOR.MINOR.PATCH, like in https://semver.org/
 
 HOMEPAGE = "https://github.com/dlr-wf/ExcitationSolve"  # GitHub page

{excitationsolve-2.2.1 → excitationsolve-2.2.3}/excitationsolve/parameter_prediction.py

@@ -8,8 +8,7 @@ period-pi curve
 
 with a = (E_HF - E_exc) / 2 and b = <HF|H|Phi>. The minimiser of this curve has
 the closed form theta = -1/2 * arctan2(-b, -a). `optimal_theta` evaluates a
-and b from the molecular integrals and returns this exact angle together with
-its first-order (EN2 / MP2) linearisations.
+and b from the molecular integrals and returns this exact angle.
 
 The module is self-contained: it only needs a converged PySCF RHF object and the
 four excitation indices (in TCC/Qiskit-sorted spin-orbital order).
@@ -47,7 +46,7 @@ def _transform_integrals_to_mo(mf):
     return h1_mo, eri_mo, occ_indices
 
 
-def _determinant_energy(h1_mo, eri_mo, occ_indices, MP2=False):
+def _determinant_energy(h1_mo, eri_mo, occ_indices):
     """
     Compute the energy of a single Slater determinant in MO basis.
 
@@ -83,10 +82,7 @@ def _determinant_energy(h1_mo, eri_mo, occ_indices, MP2=False):
         for q in occ:
             e_two += eri_mo[p, q, q, p] - eri_mo[p, q, p, q]
 
-    if MP2:
-        return e_one
-    else:
-        return e_one + 0.5 * e_two
+    return e_one + 0.5 * e_two
 
 
 def _apply_double_excitation(occ_indices, i, j, a, b):
@@ -116,7 +112,7 @@ def _apply_double_excitation(occ_indices, i, j, a, b):
     return sorted(occ_set)
 
 
-def _compute_a_b(h1_mo, h2_mo, occ_indices, i, j, k, l, MP2=False):
+def _compute_a_b(h1_mo, h2_mo, occ_indices, i, j, k, l):
     """
     Compute the parameters a and b for the two-level effective Hamiltonian
     defined by the HF determinant and a doubly excited determinant.
@@ -153,11 +149,11 @@ def _compute_a_b(h1_mo, h2_mo, occ_indices, i, j, k, l, MP2=False):
     b : float
     """
     # HF determinant energy
-    e_hf = _determinant_energy(h1_mo, h2_mo, occ_indices, MP2)
+    e_hf = _determinant_energy(h1_mo, h2_mo, occ_indices)
 
     # Excited determinant: remove (i, j), add (k, l)
     occ_exc = _apply_double_excitation(occ_indices, k, l, i, j)
-    e_exc = _determinant_energy(h1_mo, h2_mo, occ_exc, MP2)
+    e_exc = _determinant_energy(h1_mo, h2_mo, occ_exc)
 
     a_val = 0.5 * (e_hf - e_exc)
 
@@ -254,7 +250,7 @@ def _block_to_interleaved(idx, no, nv):
     return 2 * spatial + spin
 
 
-def optimal_theta_pyscf(mf: pyscf.scf.hf.RHF, excitation_indices: list[int]):
+def optimal_theta_pyscf(mf: pyscf.scf.hf.RHF, excitation_indices: list[int]) -> tuple[float, float]:
     """
     High-level convenience function to compute the optimal VQE angle theta_opt
     for a given double excitation in an RHF reference.
@@ -283,7 +279,7 @@ def optimal_theta_pyscf(mf: pyscf.scf.hf.RHF, excitation_indices: list[int]):
     return optimal_theta(h1_mo, eri_mo, occ_spatial, excitation_indices)
 
 
-def optimal_theta(h1: np.ndarray, eri: np.ndarray, occ_spatial: list[int], excitation_indices: list[int]):
+def optimal_theta(h1: np.ndarray, eri: np.ndarray, occ_spatial: list[int], excitation_indices: list[int]) -> tuple[float, float]:
     """
     High-level convenience function to compute the optimal VQE angle theta_opt
     for a given double excitation in an RHF reference.

{excitationsolve-2.2.1 → excitationsolve-2.2.3/excitationsolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: excitationsolve
-Version: 2.2.1
+Version: 2.2.3
 Summary: ExcitationSolve: a fast globally-informed gradient-free optimizer for physically-motivated ansätze constructed of excitation operators
 Author-email: Jonas Jäger <jojaeger@cs.ubc.ca>, "Thierry N. Kaldenbach" <Thierry.Kaldenbach@dlr.de>, Max Haas <Max.Haas@dlr.de>, Erik Schultheis <Erik.Schultheis@dlr.de>
 License:        Copyright 2025 Jonas Jäger, Thierry N. Kaldenbach, Max Haas, Erik Schultheis,
@@ -241,7 +241,7 @@ Requires-Dist: tencirchem-ng==2024.10; extra == "test"
 Requires-Dist: pyscf==2.8.0; extra == "test"
 Dynamic: license-file
 
-# ExcitationSolve [![paper](https://img.shields.io/badge/Commun.%20Phys.-Paper-0274b5.svg)](https://www.nature.com/articles/s42005-025-02375-9) [![DOI](https://zenodo.org/badge/958004975.svg)](https://doi.org/10.5281/zenodo.17457122)
+# ExcitationSolve [![paper](https://img.shields.io/badge/Commun.%20Phys.-Paper-0274b5.svg)](https://www.nature.com/articles/s42005-025-02375-9) [![DOI](https://zenodo.org/badge/958004975.svg)](https://doi.org/10.5281/zenodo.17457122) [![PyPI](https://img.shields.io/pypi/v/excitationsolve.svg?color=0274b5&label=PyPI)](https://pypi.org/project/excitationsolve/)
 
 An optimization algorithm for ansätze consisting of excitation operators in variational quantum eigensolvers (VQEs).
 
@@ -257,6 +257,11 @@ VQE convergence for different molecules and optimizers, including ExcitationSolv
 </h1>
 
 ## Installation
+ExcitationSolve is available on [PyPI](https://pypi.org/project/excitationsolve/):
+```
+pip install excitationsolve
+```
+Alternatively, install directly from GitHub:
 ```
 pip install git+https://github.com/dlr-wf/ExcitationSolve.git
 ```
@@ -287,11 +292,27 @@ Use the `excitationsolve.ExcitationSolveScipy` class in combination with the `sc
 ```python
 excsolve_obj = ExcitationSolveScipy(maxiter=100, tol=1e-10, save_parameters=True)
 optimizer = excsolve_obj.minimize
-res = scipy.optimize.minimize(cost, params, method=optimizer)
+def callback(xk): # or callback(intermediate_result)
+    print(xk)
+options = dict(parameter_occ=parameter_occ) # optional, use if parameters occur multiple times in the ansatz
+res = scipy.optimize.minimize(cost, params, method=optimizer, callback=callback, options=options)
 energies = excsolve_obj.energies
 counts = excsolve_obj.nfevs
 ```
 
+### Optimal parameters of double excitations w.r.t. the Hartree-Fock state
+Use `exitationsolve.optimal_theta` and `excitationsolve.optimal_theta_pyscf` to calculate analytic optimal parameter values for individual double excitations when applied to the Hartree-Fock reference state. Both functions return the optimal parameter and the energy difference to the Hartree-Fock energy. The optimal parameter is defined as $\theta^*=\argmin_\theta\bra{\mathrm{HF}}U^\dagger(\theta) H U(\theta)\ket{\mathrm{HF}}$ where $H$ is the electronic structure Hamiltonian, $U(\theta)$ is **one** double excitation, and $\ket{\mathrm{HF}}$ is the Hartree-Fock state. In [Haas et al., 2026](https://doi.org/10.48550/arXiv.2602.10776) it has been shown that initializing doubles in their respective optimal parameter and appending them to the ansatz in order of energy impact is an efficient operator selection and warm-start strategy.
+
+### Testing
+To run the tests, install the needed dependencies with
+```bash
+uv pip install .[test]
+```
+and execute
+```bash
+pytest
+```
+
 
 ## Authors
 - Jonas Jäger
@@ -305,7 +326,7 @@ Feel free to contact [David Melching](mailto:David.Melching@dlr.de) if you have
 ## Citation
 If you use portions of this code please cite our [paper](https://www.nature.com/articles/s42005-025-02375-9):
 ```bibtex
-@article{Jaeger2024Fast,
+@article{Jaeger2025Fast,
     title={Fast gradient-free optimization of excitations in variational quantum eigensolvers},
     author={Jäger, Jonas and Kaldenbach, Thierry N. and Haas, Max and Schultheis, Erik},
     year={2025},
@@ -319,5 +340,18 @@ If you use portions of this code please cite our [paper](https://www.nature.com/
 }
 ```
 
+If you use the `exitationsolve.optimal_theta` or `excitationsolve.optimal_theta_pyscf` functionalities please also cite [Haas et al., 2026](https://doi.org/10.48550/arXiv.2602.10776):
+```bibtex
+@article{Haas2026Efficient,
+    title={Efficient Operator Selection and Warm-Start Strategy for Excitations in Variational Quantum Eigensolvers}, 
+    url={https://arxiv.org/abs/2602.10776},
+    DOI={10.48550/ARXIV.2602.10776},
+    publisher={arXiv},
+    author={Haas, Max and Kaldenbach, Thierry N. and Hammerschmidt, Thomas and Barragan-Yani, Daniel}, 
+    year={2026} 
+} 
+```
+
+
 ## Acknowledgment
 This project was made possible by the DLR Quantum Computing Initiative and the Federal Ministry for Economic Affairs and Climate Action; https://qci.dlr.de/quanticom.

{excitationsolve-2.2.1 → excitationsolve-2.2.3}/excitationsolve.egg-info/SOURCES.txt

@@ -24,4 +24,5 @@ excitationsolve.egg-info/requires.txt
 excitationsolve.egg-info/top_level.txt
 tests/pyscf_molecules.py
 tests/tcc_helpers.py
-tests/tcc_tests.py
+tests/test_callback.py
+tests/test_tcc.py

excitationsolve-2.2.3/tests/test_callback.py

@@ -0,0 +1,266 @@
+import time
+import numpy as np
+import scipy
+import matplotlib.pyplot as plt
+from pyscf import scf, gto, fci, ao2mo
+from tencirchem import UCCSD
+import tcc_helpers
+import pyscf_molecules
+from excitationsolve import ExcitationSolveScipy
+import logging
+
+
+def test_tcc_h3plus_callback_xk():
+    logging.basicConfig(level=logging.INFO)
+
+    # molecule = pyscf_molecules.H_chain.build_hydrogen_chain(2)
+    molecule = pyscf_molecules.H3plus
+    symbols = molecule.symbols
+    basis = molecule.basis
+    geometry = molecule.geometry
+    charge = molecule.charge
+
+    atom = "; ".join([f"{a} {', '.join([str(x) for x in p.tolist()])}" for a, p in zip(symbols, geometry)])
+    symbols_unique, unique_counts = np.unique(symbols, return_counts=True)
+    molname = "".join([f"{a}{n}" for a, n in zip(symbols_unique, unique_counts)])
+    if charge > 0:
+        molname += "+" * np.abs(charge)
+    elif charge < 0:
+        molname += "-" * np.abs(charge)
+
+    unit = "Angstrom"  # Angstrom or Bohr
+    mol_pyscf = gto.M(atom=atom, basis=basis, charge=charge, unit=unit)
+    _electrons = mol_pyscf.nelectron
+    rhf = scf.RHF(mol_pyscf)
+    _hf_energy = rhf.kernel()
+
+    _mo_occ = rhf.mo_occ
+
+    print(f"Building TCC Hamiltonian for {molname} (early build to use TCC canonicalized MO-coefficients) ...")
+    tcc_uccsd = UCCSD(rhf, init_method="zeros", run_hf=False, run_mp2=False, run_ccsd=False, run_fci=True)  # TCC params = -params
+    print(f"{tcc_uccsd.engine=}")
+    rhf.mo_coeff = tcc_uccsd.hf.mo_coeff
+
+    fci_calc = fci.FCI(mol_pyscf, rhf.mo_coeff)
+    fci_energy, ci_vector = fci_calc.kernel()
+    print(f"FCI Energy: {fci_energy} Ha")
+
+    reference_energy = fci_energy
+
+    # one_ao = mol_pyscf.intor_symmetric("int1e_kin") + mol_pyscf.intor_symmetric("int1e_nuc")
+    # two_ao = mol_pyscf.intor("int2e_sph")
+    # one_mo = np.einsum("pi,pq,qj->ij", rhf.mo_coeff, one_ao, rhf.mo_coeff) * 1.0
+    # two_mo = ao2mo.incore.full(two_ao, rhf.mo_coeff) * 1.0
+    # two_mo = two_mo.swapaxes(1, 2).swapaxes(2, 3)  # to physicist order
+    # core_constant = rhf.energy_nuc()
+
+    nelec = mol_pyscf.nelec
+    norb = mol_pyscf.nao
+
+    # energy_offset = core_constant
+
+    #####################################################################################
+    ##                                 Define Ansatz                                   ##
+    #####################################################################################
+    singles_pool = tcc_helpers.get_ex1_ops(norb, nelec)
+    doubles_pool = tcc_helpers.get_ex2_ops(norb, nelec)
+    singles_pool_sorted = sorted(singles_pool)
+    doubles_pool_sorted = sorted([(*sorted(x[:2]), *sorted(x[2:])) for x in doubles_pool])
+    # complete_pool = doubles_pool_sorted + singles_pool_sorted
+    complete_pool = singles_pool_sorted + doubles_pool_sorted
+
+    tcc_uccsd.ex_ops = complete_pool
+    # tcc_uccsd.param_ids = None
+    # tcc_uccsd.param_ids = [0, 0, 1]
+    print(f"{tcc_uccsd.param_ids=}")
+
+    n_params = len(complete_pool)
+    _params = np.zeros(n_params)
+    _ex_ops = [(x[: len(x) // 2], x[len(x) // 2 :]) for x in complete_pool]
+
+    #######################
+    # Manual optimization
+    times_tcc = []
+    eval_count_tcc = 0
+    counts_tcc = []
+    values_tcc = []
+    tcc_vqe_params_lst = []
+
+    def cost(x):
+        nonlocal times_tcc
+        nonlocal eval_count_tcc
+        nonlocal counts_tcc
+        nonlocal values_tcc
+
+        tcc_energy = tcc_uccsd.energy(x)
+        times_tcc.append(time.perf_counter())
+
+        eval_count_tcc += 1
+        print(
+            f"Optimizer evaluation #{eval_count_tcc}, Diff. to ref.: {np.abs(tcc_energy - reference_energy)}",
+            end="\r",
+            flush=True,
+        )
+        counts_tcc.append(eval_count_tcc)
+        values_tcc.append(tcc_energy)
+        tcc_vqe_params_lst.append(x)
+
+        return tcc_energy
+
+    callback_works = False
+
+    def callback(xk):
+        nonlocal callback_works
+        callback_works = True
+        print(f" ========= From callback: {xk=} =========")
+
+    maxiter = 100
+    excsolve_obj = ExcitationSolveScipy(maxiter=maxiter, tol=1e-10, save_parameters=True)
+    optimizer_func = excsolve_obj.minimize
+    _, parameter_occ = np.unique(tcc_uccsd.param_ids, return_counts=True)
+    options = dict(reference_energy=reference_energy, parameter_occ=parameter_occ)
+
+    n_params_tmp = tcc_uccsd.n_params
+    initial_params = np.zeros(n_params_tmp)
+    res_tcc = scipy.optimize.minimize(cost, initial_params, method=optimizer_func, callback=callback, options=options)
+    _params_tcc = res_tcc.x
+
+    print(f"\nFinal energy difference: {(res_tcc.fun - reference_energy):.2e}")
+
+    # plt.plot(excsolve_obj.nfevs, np.abs(excsolve_obj.energies - reference_energy))
+    # plt.plot(excsolve_obj.nfevs_after_it, np.abs(excsolve_obj.energies_after_it - reference_energy), linestyle="", marker="x")
+    # for x in excsolve_obj.nfevs_after_it:
+    #     plt.axvline(x, linestyle="--", color="black", alpha=0.5)
+    # plt.yscale("log")
+    # plt.grid()
+    # plt.show()
+
+    assert callback_works, "Callback does not work!"
+
+
+def test_tcc_h3plus_callback_intermediateresult():
+    logging.basicConfig(level=logging.INFO)
+
+    # molecule = pyscf_molecules.H_chain.build_hydrogen_chain(2)
+    molecule = pyscf_molecules.H3plus
+    symbols = molecule.symbols
+    basis = molecule.basis
+    geometry = molecule.geometry
+    charge = molecule.charge
+
+    atom = "; ".join([f"{a} {', '.join([str(x) for x in p.tolist()])}" for a, p in zip(symbols, geometry)])
+    symbols_unique, unique_counts = np.unique(symbols, return_counts=True)
+    molname = "".join([f"{a}{n}" for a, n in zip(symbols_unique, unique_counts)])
+    if charge > 0:
+        molname += "+" * np.abs(charge)
+    elif charge < 0:
+        molname += "-" * np.abs(charge)
+
+    unit = "Angstrom"  # Angstrom or Bohr
+    mol_pyscf = gto.M(atom=atom, basis=basis, charge=charge, unit=unit)
+    _electrons = mol_pyscf.nelectron
+    rhf = scf.RHF(mol_pyscf)
+    _hf_energy = rhf.kernel()
+
+    _mo_occ = rhf.mo_occ
+
+    print(f"Building TCC Hamiltonian for {molname} (early build to use TCC canonicalized MO-coefficients) ...")
+    tcc_uccsd = UCCSD(rhf, init_method="zeros", run_hf=False, run_mp2=False, run_ccsd=False, run_fci=True)  # TCC params = -params
+    print(f"{tcc_uccsd.engine=}")
+    rhf.mo_coeff = tcc_uccsd.hf.mo_coeff
+
+    fci_calc = fci.FCI(mol_pyscf, rhf.mo_coeff)
+    fci_energy, ci_vector = fci_calc.kernel()
+    print(f"FCI Energy: {fci_energy} Ha")
+
+    reference_energy = fci_energy
+
+    # one_ao = mol_pyscf.intor_symmetric("int1e_kin") + mol_pyscf.intor_symmetric("int1e_nuc")
+    # two_ao = mol_pyscf.intor("int2e_sph")
+    # one_mo = np.einsum("pi,pq,qj->ij", rhf.mo_coeff, one_ao, rhf.mo_coeff) * 1.0
+    # two_mo = ao2mo.incore.full(two_ao, rhf.mo_coeff) * 1.0
+    # two_mo = two_mo.swapaxes(1, 2).swapaxes(2, 3)  # to physicist order
+    # core_constant = rhf.energy_nuc()
+
+    nelec = mol_pyscf.nelec
+    norb = mol_pyscf.nao
+
+    # energy_offset = core_constant
+
+    #####################################################################################
+    ##                                 Define Ansatz                                   ##
+    #####################################################################################
+    singles_pool = tcc_helpers.get_ex1_ops(norb, nelec)
+    doubles_pool = tcc_helpers.get_ex2_ops(norb, nelec)
+    singles_pool_sorted = sorted(singles_pool)
+    doubles_pool_sorted = sorted([(*sorted(x[:2]), *sorted(x[2:])) for x in doubles_pool])
+    # complete_pool = doubles_pool_sorted + singles_pool_sorted
+    complete_pool = singles_pool_sorted + doubles_pool_sorted
+
+    tcc_uccsd.ex_ops = complete_pool
+    # tcc_uccsd.param_ids = None
+    # tcc_uccsd.param_ids = [0, 0, 1]
+    print(f"{tcc_uccsd.param_ids=}")
+
+    n_params = len(complete_pool)
+    _params = np.zeros(n_params)
+    _ex_ops = [(x[: len(x) // 2], x[len(x) // 2 :]) for x in complete_pool]
+
+    #######################
+    # Manual optimization
+    times_tcc = []
+    eval_count_tcc = 0
+    counts_tcc = []
+    values_tcc = []
+    tcc_vqe_params_lst = []
+
+    def cost(x):
+        nonlocal times_tcc
+        nonlocal eval_count_tcc
+        nonlocal counts_tcc
+        nonlocal values_tcc
+
+        tcc_energy = tcc_uccsd.energy(x)
+        times_tcc.append(time.perf_counter())
+
+        eval_count_tcc += 1
+        print(
+            f"Optimizer evaluation #{eval_count_tcc}, Diff. to ref.: {np.abs(tcc_energy - reference_energy)}",
+            end="\r",
+            flush=True,
+        )
+        counts_tcc.append(eval_count_tcc)
+        values_tcc.append(tcc_energy)
+        tcc_vqe_params_lst.append(x)
+
+        return tcc_energy
+
+    callback_works = False
+
+    def callback(intermediate_result):
+        nonlocal callback_works
+        callback_works = True
+        print(f" ========= From callback: {intermediate_result.x=} | {intermediate_result.fun=} =========")
+
+    maxiter = 100
+    excsolve_obj = ExcitationSolveScipy(maxiter=maxiter, tol=1e-10, save_parameters=True)
+    optimizer_func = excsolve_obj.minimize
+    _, parameter_occ = np.unique(tcc_uccsd.param_ids, return_counts=True)
+    options = dict(reference_energy=reference_energy, parameter_occ=parameter_occ)
+
+    n_params_tmp = tcc_uccsd.n_params
+    initial_params = np.zeros(n_params_tmp)
+    res_tcc = scipy.optimize.minimize(cost, initial_params, method=optimizer_func, callback=callback, options=options)
+    _params_tcc = res_tcc.x
+
+    print(f"\nFinal energy difference: {(res_tcc.fun - reference_energy):.2e}")
+
+    # plt.plot(excsolve_obj.nfevs, np.abs(excsolve_obj.energies - reference_energy))
+    # plt.plot(excsolve_obj.nfevs_after_it, np.abs(excsolve_obj.energies_after_it - reference_energy), linestyle="", marker="x")
+    # for x in excsolve_obj.nfevs_after_it:
+    #     plt.axvline(x, linestyle="--", color="black", alpha=0.5)
+    # plt.yscale("log")
+    # plt.grid()
+    # plt.show()
+
+    assert callback_works, "Callback does not work!"

excitationsolve-2.2.1/tests/tcc_tests.py → excitationsolve-2.2.3/tests/test_tcc.py

@@ -30,11 +30,11 @@ def test_tcc_h3plus_mult_occurence():
 
     unit = "Angstrom"  # Angstrom or Bohr
     mol_pyscf = gto.M(atom=atom, basis=basis, charge=charge, unit=unit)
-    electrons = mol_pyscf.nelectron
+    _electrons = mol_pyscf.nelectron
     rhf = scf.RHF(mol_pyscf)
-    hf_energy = rhf.kernel()
+    _hf_energy = rhf.kernel()
 
-    mo_occ = rhf.mo_occ
+    _mo_occ = rhf.mo_occ
 
     print(f"Building TCC Hamiltonian for {molname} (early build to use TCC canonicalized MO-coefficients) ...")
     tcc_uccsd = UCCSD(rhf, init_method="zeros", run_hf=False, run_mp2=False, run_ccsd=False, run_fci=True)  # TCC params = -params
@@ -75,8 +75,8 @@ def test_tcc_h3plus_mult_occurence():
     print(f"{tcc_uccsd.param_ids=}")
 
     n_params = len(complete_pool)
-    params = np.zeros(n_params)
-    ex_ops = [(x[: len(x) // 2], x[len(x) // 2 :]) for x in complete_pool]
+    _params = np.zeros(n_params)
+    _ex_ops = [(x[: len(x) // 2], x[len(x) // 2 :]) for x in complete_pool]
 
     #######################
     # Manual optimization
@@ -116,7 +116,7 @@ def test_tcc_h3plus_mult_occurence():
     n_params_tmp = tcc_uccsd.n_params
     initial_params = np.zeros(n_params_tmp)
     res_tcc = scipy.optimize.minimize(cost, initial_params, method=optimizer_func, options=options)
-    params_tcc = res_tcc.x
+    _params_tcc = res_tcc.x
 
     print(f"\nFinal energy difference: {(res_tcc.fun - reference_energy):.2e}")