wavepacket 0.4.0__tar.gz → 0.4.1__tar.gz

{wavepacket-0.4.0 → wavepacket-0.4.1}/CHANGELOG.rst

@@ -2,6 +2,28 @@
 ChangeLog
 =========
 
+0.4.1
+-----
+
+Minor changes:
+
+- (#56) Added acceptance / regression tests, also for CI
+
+Bug fixes:
+
+- The SinSquare function had an incorrect implementation without the "square" part
+
+- population() could return complex values for density operators.
+  The imaginary part was negligible, but the type was still wrong.
+  The return values are also no longer (negligible) negative values.
+
+- log() calculated <x> only for the first degree of freedom,
+  and reported it for all other degrees of freedom as well.
+  Also, fixed a typo in the output.
+
+- Stacked1DPlot threw an exception if you exceeded the number of plots.
+  It now overwrites the last plot as it is documented.
+
 0.4
 ---
 

{wavepacket-0.4.0 → wavepacket-0.4.1}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024-2025 Ulf Lorenz
+Copyright (c) 2024-2026 Ulf Lorenz
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{wavepacket-0.4.0 → wavepacket-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavepacket
-Version: 0.4.0
+Version: 0.4.1
 Summary: A package for solving Schrödinger and Liouville von Neumann equations.
 Keywords: wave packet,quantum simulation,quantum system,DVR,Schroedinger equation,Liouville von Neumann equation,open systems,wave function,density operator,Liouvillian
 Author: Ulf Lorenz

{wavepacket-0.4.0 → wavepacket-0.4.1}/doc/conf.py

@@ -9,7 +9,7 @@
 project = "Wavepacket"
 copyright = "2024-%Y, Ulf Lorenz"
 author = "Ulf Lorenz"
-release = "0.4"
+release = "0.4.1"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{wavepacket-0.4.0 → wavepacket-0.4.1}/pyproject.toml

@@ -98,7 +98,7 @@ env_list = ["py311", "py312", "py313", "py314", "py311-min", "py312-min", "py313
 description = "Run unit tests under {python_base}; Standard environments like py313 implicitly inherit this."
 set_env = { "PIP_ONLY_BINARY" = ":all:" }
 dependency_groups = ["test"]
-commands = [["pytest", "test"]]
+commands = [["pytest", "test", "test_acceptance"]]
 
 [tool.tox.env.py311-min]
 dependency_groups = ["minimum_dependencies", "test"]

{wavepacket-0.4.0 → wavepacket-0.4.1}/src/wavepacket/__init__.py

@@ -2,7 +2,7 @@
 A package for solving Schrödinger and Liouville von Neumann equations.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 
 __all__ = [
     "__version__",

wavepacket-0.4.1/src/wavepacket/logging.py

@@ -0,0 +1,54 @@
+import math
+
+import wavepacket as wp
+
+
+def _truncate(value: float, truncation: float | None) -> float:
+    if truncation is None or abs(value) >= truncation:
+        return value
+    else:
+        return 0.0
+
+
+def log(
+    t: float, state: wp.grid.State, precision: int = 6, truncate: float | None = None
+) -> None:
+    """
+    Prints some data about the state for inspection.
+
+    The idea is that you call this function during every solver step and get
+    a log with the most important values about the propagation, for example
+    the state trace (if it deviates from one, this may be caused by poor convergence).
+
+    Parameters
+    ----------
+    t : float
+        The time at which you log.
+    state : wp.grid.State
+        The state to log.
+    precision : int, default=6
+        How many decimal places should be printed.
+    truncate: float | None, default=None
+        If set, set all calculated values smaller than this boundary to zero.
+        The main use case is for tests; values that are approximately zero can
+        differ in their actual value based on numpy version etc. This causes
+        regression tests to fail for uninteresting reasons.
+    """
+    print(
+        f"\n-----------------------------------------------\n"
+        f"t = {float(t):.{precision}},     trace = {wp.trace(state):.{precision}}\n"
+    )
+
+    normalized_state = wp.normalize(state)
+    for index, dof in enumerate(state.grid.dofs):
+        x = wp.operator.Potential1D(state.grid, index, lambda dvr_grid: dvr_grid)
+
+        x_val = wp.expectation_value(x, normalized_state).real
+        x2_val = wp.expectation_value(x * x, normalized_state).real
+
+        x_avg = _truncate(x_val, truncate)
+        dx = _truncate(math.sqrt(x2_val - x_avg**2), truncate)
+
+        # In exotic cases, the error dx**2 can become negative, so we trade
+        # correctness for robustness here by taking its absolute value.
+        print(f"<x_{index}> = {x_avg:.{precision}}  +/- {dx:.{precision}}")

{wavepacket-0.4.0 → wavepacket-0.4.1}/src/wavepacket/plot/plot_1d.py

@@ -227,7 +227,7 @@ class StackedPlot1D(BasePlot1D):
 
     def plot(self, t: float, state: wp.grid.State) -> plt.Axes:
         axes: plt.Axes = self._axes.flat[self._index]
-        self._index = min(self._index + 1, self._axes.size)
+        self._index = min(self._index + 1, self._axes.size - 1)
 
         super()._plot(axes, t, state)
 

{wavepacket-0.4.0 → wavepacket-0.4.1}/src/wavepacket/special/pulse_shapes.py

@@ -36,7 +36,7 @@ class SinSquare:
     def __call__(self, t: float) -> float:
         dt = abs(t - self._t0)
         if dt < self._half_width:
-            return math.cos(self._scale * dt)
+            return math.cos(self._scale * dt) ** 2
         else:
             return 0.0
 

{wavepacket-0.4.0 → wavepacket-0.4.1}/src/wavepacket/state_utilities.py

@@ -324,6 +324,8 @@ def population(state: wp.grid.State, target: wp.grid.State) -> float:
         matrix_form = np.reshape(state.data, [state.grid.size, state.grid.size])
         flat_target = np.ravel(target.data)
         left_summation = np.tensordot(np.conj(flat_target), matrix_form, axes=(0, 0))
-        return np.tensordot(left_summation, flat_target, axes=(0, 0)).sum() / target_trace
+        return np.abs(
+            np.tensordot(left_summation, flat_target, axes=(0, 0)).sum() / target_trace
+        )
     else:
         raise wp.BadStateError("Input is not a valid state.")

{wavepacket-0.4.0 → wavepacket-0.4.1}/test/special/test_pulse_shapes.py

@@ -18,9 +18,9 @@ def test_sin_square_values():
     functor = wp.special.SinSquare(5.0, 2.0)
 
     assert functor(2.9) == 0
-    assert_allclose(functor(4), math.sqrt(0.5), rtol=0, atol=1e-12)
+    assert_allclose(functor(4), 0.5, rtol=0, atol=1e-12)
     assert functor(5) == 1
-    assert_allclose(functor(6), math.sqrt(0.5), rtol=0, atol=1e-12)
+    assert_allclose(functor(6), 0.5, rtol=0, atol=1e-12)
     assert functor(7.1) == 0
 
 

{wavepacket-0.4.0 → wavepacket-0.4.1}/test/test_state_utilities.py

@@ -52,6 +52,7 @@ def test_wave_function_dvr_density():
     dx = 1 / 3.0 * 2 / 5.0
     expected = np.abs(psi.data**2) / dx
     assert_allclose(result, expected, atol=1e-14, rtol=0)
+    assert_allclose(np.imag(result), 0, atol=0, rtol=0)
 
 
 def test_density_operator_dvr_density(grid_2d):
@@ -62,6 +63,7 @@ def test_density_operator_dvr_density(grid_2d):
     density_from_rho = wp.dvr_density(rho)
 
     assert_allclose(density_from_rho, density_from_psi, atol=1e-14, rtol=0)
+    assert_allclose(np.imag(density_from_rho), 0, atol=0, rtol=0)
 
 
 def test_wave_function_fbr_density():
@@ -76,6 +78,7 @@ def test_wave_function_fbr_density():
     expected = np.zeros(grid.shape)
     expected[5 - 2, 7 - 5] = 4
     assert_allclose(expected, density, rtol=0, atol=1e-12)
+    assert_allclose(0, np.imag(density), rtol=0, atol=0)
 
 
 def test_density_operator_fbr_density(grid_2d):
@@ -86,6 +89,7 @@ def test_density_operator_fbr_density(grid_2d):
     density_from_rho = wp.fbr_density(rho)
 
     assert_allclose(density_from_psi, density_from_rho, rtol=0, atol=1e-12)
+    assert_allclose(0, np.imag(density_from_rho), rtol=0, atol=0)
 
 
 def test_reduced_dvr_and_fbr_density(grid_2d):
@@ -136,6 +140,7 @@ def test_trace():
     rho = wp.builder.pure_density(psi)
     result_rho = wp.trace(rho)
     assert_allclose(result_rho, result, atol=1e-12, rtol=0)
+    assert_allclose(result_rho.imag, 0, atol=0, rtol=0)
 
 
 def test_normalize(grid_1d):
@@ -236,7 +241,7 @@ def test_population(grid_2d):
     a, target = (states[0], states[1])
 
     # create a state that triggers a complex scalar product to check for abs()
-    psi = 2 * a + 0.7 * target * np.sqrt(1j)
+    psi = 2j * a + 0.7 * target * np.sqrt(1j)
     rho = wp.builder.pure_density(psi)
     expected = 0.7**2
 
@@ -245,13 +250,14 @@ def test_population(grid_2d):
 
     rho_projection = wp.population(rho, target)
     assert_allclose(rho_projection, expected, rtol=0, atol=1e-12)
+    assert_allclose(rho_projection.imag, 0, rtol=0, atol=0)
 
 
 def test_normalize_population_target(grid_2d):
     target = wp.testing.random_state(grid_2d, 1)
     target /= math.sqrt(wp.trace(target))
 
-    psi = 0.7 * target * np.sqrt(1j)
+    psi = 0.7j * target * np.sqrt(1j)
     rho = wp.builder.pure_density(psi)
     expected = 0.7**2
 

wavepacket-0.4.1/test_acceptance/readme

@@ -0,0 +1,7 @@
+The tests here verify the correctness on a higher level than the unit tests in test/.
+Thy are meant to catch issues in code that is difficult to unit-test (e.g., logging output),
+and to catch invalid unit tests.
+Because the tests are full-fledged simulations and sometimes do unusual things,
+they can also serve as additional examples, but that is not the primary focus here.
+
+Because results are not meant to change at all, most if not all tests are regression tests.

wavepacket-0.4.1/test_acceptance/test_1d_absorbing_boundaries.txt

@@ -0,0 +1,75 @@
+>>> import numpy as np
+>>> import wavepacket as wp
+>>>
+>>> dof = wp.grid.PlaneWaveDof(-10, 20, 96)
+>>> grid = wp.grid.Grid(dof)
+>>>
+>>> def absorbing_boundary(x):
+...     potential = -10j * (x - 12.0) ** 2 / (20 - 12.0) ** 2
+...     potential[x < 12] = 0
+...     return potential
+>>>
+>>> kinetic = wp.operator.CartesianKineticEnergy(grid, 0, mass=1)
+>>> absorber = wp.operator.Potential1D(grid, 0, absorbing_boundary)
+>>> equation = wp.expression.SchroedingerEquation(kinetic + absorber)
+>>> 
+>>> psi0 = wp.builder.product_wave_function(grid, wp.special.Gaussian(-5, 2, rms=1))
+>>> solver = wp.solver.OdeSolver(equation, 1)
+>>> 
+>>> for t, psi in solver.propagate(psi0, 0.0, 10):
+...     wp.log(t, psi, precision=4, truncate=1e-10)
+<BLANKLINE>
+-----------------------------------------------
+t = 0.0,     trace = 1.0
+<BLANKLINE>
+<x_0> = -5.0  +/- 0.7071
+<BLANKLINE>
+-----------------------------------------------
+t = 1.0,     trace = 1.0
+<BLANKLINE>
+<x_0> = -3.0  +/- 1.0
+<BLANKLINE>
+-----------------------------------------------
+t = 2.0,     trace = 1.0
+<BLANKLINE>
+<x_0> = -1.0  +/- 1.581
+<BLANKLINE>
+-----------------------------------------------
+t = 3.0,     trace = 1.0
+<BLANKLINE>
+<x_0> = 1.0  +/- 2.236
+<BLANKLINE>
+-----------------------------------------------
+t = 4.0,     trace = 0.9999
+<BLANKLINE>
+<x_0> = 2.999  +/- 2.914
+<BLANKLINE>
+-----------------------------------------------
+t = 5.0,     trace = 0.996
+<BLANKLINE>
+<x_0> = 4.959  +/- 3.552
+<BLANKLINE>
+-----------------------------------------------
+t = 6.0,     trace = 0.9615
+<BLANKLINE>
+<x_0> = 6.637  +/- 3.959
+<BLANKLINE>
+-----------------------------------------------
+t = 7.0,     trace = 0.8678
+<BLANKLINE>
+<x_0> = 7.791  +/- 4.111
+<BLANKLINE>
+-----------------------------------------------
+t = 8.0,     trace = 0.7319
+<BLANKLINE>
+<x_0> = 8.47  +/- 4.154
+<BLANKLINE>
+-----------------------------------------------
+t = 9.0,     trace = 0.5905
+<BLANKLINE>
+<x_0> = 8.83  +/- 4.18
+<BLANKLINE>
+-----------------------------------------------
+t = 10.0,     trace = 0.4666
+<BLANKLINE>
+<x_0> = 8.994  +/- 4.221

wavepacket-0.4.1/test_acceptance/test_2d_harmonic_oscillator.txt

@@ -0,0 +1,65 @@
+>>> import math
+>>> import wavepacket as wp
+>>>
+>>> dof = wp.grid.PlaneWaveDof(-10, 10, 96)
+>>> grid = wp.grid.Grid([dof, dof])
+>>>
+>>> kin_args = {"mass": 1, "cutoff": 40}
+>>> pot_args = {"generator": lambda x: 0.5 * x**2, "cutoff": 40}
+>>> T_0 = wp.operator.CartesianKineticEnergy(grid, 0, **kin_args)
+>>> T_1 = wp.operator.CartesianKineticEnergy(grid, 1, **kin_args)
+>>> V_0 = wp.operator.Potential1D(grid, 0, **pot_args)
+>>> V_1 = wp.operator.Potential1D(grid, 1, **pot_args)
+>>> hamiltonian = T_0 + T_1 + V_0 + V_1
+>>> equation = wp.expression.SchroedingerEquation(hamiltonian)
+>>> 
+>>> psi0 = wp.builder.product_wave_function(
+...     grid, [wp.special.Gaussian(-5, 0, rms=1), wp.special.Gaussian(0, 5, rms=1)]
+... )
+>>> solver = wp.solver.ChebychevSolver(equation, math.pi / 3, (0, 160))
+>>> 
+>>> for t, psi in solver.propagate(psi0, 0.0, 6):
+...     wp.log(t, psi, precision=4, truncate=1e-10)
+<BLANKLINE>
+-----------------------------------------------
+t = 0.0,     trace = 1.0
+<BLANKLINE>
+<x_0> = -5.0  +/- 0.7071
+<x_1> = 0.0  +/- 0.7071
+<BLANKLINE>
+-----------------------------------------------
+t = 1.047,     trace = 1.0
+<BLANKLINE>
+<x_0> = -2.5  +/- 0.7071
+<x_1> = 4.33  +/- 0.7071
+<BLANKLINE>
+-----------------------------------------------
+t = 2.094,     trace = 1.0
+<BLANKLINE>
+<x_0> = 2.5  +/- 0.7071
+<x_1> = 4.33  +/- 0.7071
+<BLANKLINE>
+-----------------------------------------------
+t = 3.142,     trace = 1.0
+<BLANKLINE>
+<x_0> = 5.0  +/- 0.7071
+<x_1> = 1.077e-07  +/- 0.7071
+<BLANKLINE>
+-----------------------------------------------
+t = 4.189,     trace = 1.0
+<BLANKLINE>
+<x_0> = 2.5  +/- 0.7071
+<x_1> = -4.33  +/- 0.7071
+<BLANKLINE>
+-----------------------------------------------
+t = 5.236,     trace = 1.0
+<BLANKLINE>
+<x_0> = -2.5  +/- 0.7071
+<x_1> = -4.33  +/- 0.7071
+<BLANKLINE>
+-----------------------------------------------
+t = 6.283,     trace = 1.0
+<BLANKLINE>
+<x_0> = -5.0  +/- 0.7071
+<x_1> = -2.187e-07  +/- 0.7071
+

wavepacket-0.4.1/test_acceptance/test_laser_pulse_with_density_operator.txt

@@ -0,0 +1,161 @@
+Note:
+
+* It is not required to use a density operator here; in fact, doing so
+  slows down the calculation by a factor of ~10; however, we have no
+  other complex test of density operators right now.
+* For a proper calculation, the time evolution should have 20 steps,
+  which is the length of the laser pulse. We truncate because
+  using a density operator is rather expensive.
+
+>>> import numpy as np
+>>> import wavepacket as wp
+>>> 
+>>> unit_amu = 1e-3 / 9.10938215E-31 / 6.0221408E23
+>>> unit_angstroem = 1.88973
+>>> unit_debye = 1e10 / 1.60217662E-19 * 1e-21 / 299792458
+>>> unit_mv_per_cm = 0.000194469
+>>> unit_fs = 41.3414
+>>> unit_inv_cm = 4.55634e-06
+>>> 
+>>> def morse_potential(x):
+...     return  0.1994 * (1 - np.exp(-1.189 * (x - 1.821))) ** 2
+>>> 
+>>> def mecke_dipole(x):
+...     q0 = 7.85 * unit_debye
+...     r0 = 0.6 * unit_angstroem
+...     return q0 * x * np.exp(-x / r0)
+>>> 
+>>> mass_H1 = 1.0078250 * unit_amu
+>>> mass_O16 = 15.994915 * unit_amu
+>>> mu = mass_H1 * mass_O16 / (mass_H1 + mass_O16)
+>>> 
+>>> dof = wp.grid.PlaneWaveDof(0.7, 8, 64)
+>>> grid = wp.grid.Grid(dof)
+>>> 
+>>> kinetic = wp.operator.CartesianKineticEnergy(grid, 0, mass=mu, cutoff=0.3)
+>>> potential = wp.operator.Potential1D(grid, 0, morse_potential, cutoff=0.3)
+>>> dipole = wp.operator.Potential1D(grid, 0, mecke_dipole)
+>>> laser = wp.operator.LaserField(grid,
+...                                max_field=328.5 * unit_mv_per_cm,
+...                                shape=wp.special.SinSquare(500 * unit_fs, 500 * unit_fs),
+...                                omega=3424.19 * unit_inv_cm)
+>>> equation = wp.expression.CommutatorLiouvillian(kinetic + potential - dipole * laser)
+>>> 
+>>> bound_states = [state for energy, state in wp.diagonalize(kinetic + potential) if energy < 0.1994]
+>>>                 
+>>> psi_0 = wp.builder.product_wave_function(grid, lambda x: bound_states[0].data)
+>>> rho_0 = wp.builder.pure_density(psi_0)
+>>> 
+>>> solver = wp.solver.OdeSolver(equation, 50.0 * unit_fs)
+>>> populations = np.zeros((9, 8))
+>>> time_index = 0
+>>> for t, rho in solver.propagate(rho_0, 0.0, 8):
+...     for state_index in range(8):
+...         populations[time_index, state_index] = wp.population(rho, bound_states[state_index])
+...     time_index += 1
+>>> 
+>>> populations[np.abs(populations) < 1e-10] = 0
+>>> 
+>>> for i in range(7):
+...     print(f"\n\nbound state {i}\n\n")
+...     for t in range(9):
+...         print(f"{t*50*41.341:.4}:   {populations[t, i]:.4}")
+<BLANKLINE>
+<BLANKLINE>
+bound state 0
+<BLANKLINE>
+<BLANKLINE>
+0.0:   1.0
+2.067e+03:   0.9999
+4.134e+03:   0.9978
+6.201e+03:   0.9894
+8.268e+03:   0.9662
+1.034e+04:   0.9366
+1.24e+04:   0.8892
+1.447e+04:   0.803
+1.654e+04:   0.705
+<BLANKLINE>
+<BLANKLINE>
+bound state 1
+<BLANKLINE>
+<BLANKLINE>
+0.0:   0.0
+2.067e+03:   0.0001345
+4.134e+03:   0.002225
+6.201e+03:   0.01055
+8.268e+03:   0.03287
+1.034e+04:   0.05944
+1.24e+04:   0.09693
+1.447e+04:   0.1512
+1.654e+04:   0.1706
+<BLANKLINE>
+<BLANKLINE>
+bound state 2
+<BLANKLINE>
+<BLANKLINE>
+0.0:   0.0
+2.067e+03:   3.286e-08
+4.134e+03:   5.724e-06
+6.201e+03:   9.384e-05
+8.268e+03:   0.0009288
+1.034e+04:   0.003546
+1.24e+04:   0.01048
+1.447e+04:   0.02547
+1.654e+04:   0.03777
+<BLANKLINE>
+<BLANKLINE>
+bound state 3
+<BLANKLINE>
+<BLANKLINE>
+0.0:   0.0
+2.067e+03:   0.0
+4.134e+03:   2.451e-08
+6.201e+03:   1.135e-06
+8.268e+03:   4.049e-05
+1.034e+04:   0.0003052
+1.24e+04:   0.001663
+1.447e+04:   0.006138
+1.654e+04:   0.02057
+<BLANKLINE>
+<BLANKLINE>
+bound state 4
+<BLANKLINE>
+<BLANKLINE>
+0.0:   0.0
+2.067e+03:   0.0
+4.134e+03:   1.793e-10
+6.201e+03:   3.112e-08
+8.268e+03:   4.711e-06
+1.034e+04:   4.706e-05
+1.24e+04:   0.0007506
+1.447e+04:   0.006458
+1.654e+04:   0.03295
+<BLANKLINE>
+<BLANKLINE>
+bound state 5
+<BLANKLINE>
+<BLANKLINE>
+0.0:   0.0
+2.067e+03:   0.0
+4.134e+03:   0.0
+6.201e+03:   2.164e-09
+8.268e+03:   1.098e-06
+1.034e+04:   4.586e-05
+1.24e+04:   0.0005787
+1.447e+04:   0.003726
+1.654e+04:   0.01069
+<BLANKLINE>
+<BLANKLINE>
+bound state 6
+<BLANKLINE>
+<BLANKLINE>
+0.0:   0.0
+2.067e+03:   0.0
+4.134e+03:   0.0
+6.201e+03:   0.0
+8.268e+03:   7.184e-08
+1.034e+04:   1.186e-05
+1.24e+04:   0.0003607
+1.447e+04:   0.003443
+1.654e+04:   0.01842
+

wavepacket-0.4.1/test_acceptance/test_relaxation.txt

@@ -0,0 +1,37 @@
+>>> import numpy as np
+>>> import wavepacket as wp
+>>> 
+>>> dof = wp.grid.PlaneWaveDof(0.7, 8, 96)
+>>> grid = wp.grid.Grid(dof)
+>>> 
+>>> def morse_potential(x):
+...     return  0.1994 * (1 - np.exp(-1.189 * (x - 1.821))) ** 2
+>>> 
+>>> kinetic = wp.operator.CartesianKineticEnergy(grid, 0, mass=1728.539, cutoff=0.3)
+>>> potential = wp.operator.Potential1D(grid, 0, morse_potential, cutoff=0.3)
+>>> hamiltonian = kinetic + potential
+>>> 
+>>> bound_states = [state for energy, state in wp.diagonalize(kinetic + potential) if energy < 0.1994]
+>>> 
+>>> solver = wp.solver.RelaxationSolver(hamiltonian, 20, (0, 0.6))
+>>> psi0 = wp.builder.product_wave_function(grid, wp.special.Gaussian(2, 0, fwhm=0.5))
+>>> 
+>>> relaxed_states = []
+>>> for i in range(5):
+...     psi = psi0
+...     for step in range(20):
+...         psi = solver.step(psi, 0.0)
+...         # Trick: the last element is orthogonalized w.r.t. all other elements.
+...         # That way, we can orthonormalize psi against all already found states.
+...         psi = wp.orthonormalize(relaxed_states + [psi])[-1]
+...     relaxed_states.append(psi)
+>>> 
+>>> for i in range(5):
+...     energy_bound = wp.expectation_value(hamiltonian, bound_states[i]).real
+...     energy_relaxed = wp.expectation_value(hamiltonian, relaxed_states[i]).real
+...     print(f"State {i}:   E_bound = {energy_bound:.6}     E_relax = {energy_relaxed:.6}")
+State 0:   E_bound = 0.00892781     E_relax = 0.00892781
+State 1:   E_bound = 0.02617     E_relax = 0.02617
+State 2:   E_bound = 0.0425944     E_relax = 0.0425944
+State 3:   E_bound = 0.0582008     E_relax = 0.0582009
+State 4:   E_bound = 0.0729895     E_relax = 0.0729896

wavepacket-0.4.1/test_acceptance/test_tise.txt

@@ -0,0 +1,49 @@
+>>> import numpy as np
+>>> import wavepacket as wp
+>>>
+>>> dof = wp.grid.PlaneWaveDof(-7, 7, 96)
+>>> grid = wp.grid.Grid(dof)
+>>>
+>>> def razavy_potential(x):
+...     cosh_val = np.cosh(x)
+...     return -0.7 * cosh_val + 0.01 * cosh_val ** 2
+>>>
+>>> kinetic = wp.operator.CartesianKineticEnergy(grid, 0, mass=0.5)
+>>> potential = wp.operator.Potential1D(grid, 0, razavy_potential)
+>>> hamiltonian = kinetic + potential
+>>> 
+>>> states = [psi for _, psi in wp.diagonalize(hamiltonian)]
+>>> 
+>>> for index, psi in enumerate(states[:30]):
+...     print(f"{index}:   {wp.expectation_value(hamiltonian, psi).real:.4}")
+0:   -9.002
+1:   -9.002
+2:   -4.012
+3:   -4.011
+4:   -1.16
+5:   -0.9569
+6:   0.2135
+7:   1.374
+8:   2.813
+9:   4.463
+10:   6.305
+11:   8.324
+12:   10.51
+13:   12.86
+14:   15.37
+15:   18.03
+16:   20.84
+17:   23.79
+18:   26.88
+19:   30.11
+20:   33.48
+21:   36.99
+22:   40.62
+23:   44.39
+24:   48.28
+25:   52.3
+26:   56.45
+27:   60.72
+28:   65.11
+29:   69.62
+

wavepacket-0.4.0/src/wavepacket/logging.py

@@ -1,39 +0,0 @@
-import math
-
-import wavepacket as wp
-
-
-def log(t: float, state: wp.grid.State, precision: int = 6) -> None:
-    """
-    Prints some data about the state for inspection.
-
-    The idea is that you call this function during every solver step and get
-    a log with the most important values about the propagation, for example
-    the state trace (if it deviates from one, this may be caused by poor convergence).
-
-    Parameters
-    ----------
-    t : float
-        The time at which you log.
-    state : wp.grid.State
-        The state to log.
-    precision : int, default=6
-        How many decimal places should be printed.
-    """
-    print(
-        f"\n-----------------------------------------------\n"
-        f"t = {float(t):.{precision}},     trace = {wp.trace(state):.{precision}}\n"
-    )
-
-    normalized_state = wp.normalize(state)
-    for index, dof in enumerate(state.grid.dofs):
-        x = wp.operator.Potential1D(state.grid, 0, lambda dvr_grid: dvr_grid)
-
-        x_avg = wp.expectation_value(x, normalized_state).real
-        x2_avg = wp.expectation_value(x * x, normalized_state).real
-
-        # In exotic cases, the error dx**2 can become negative, so we trade
-        # correctness for robustness here by taking its absolute value.
-        print(
-            f"<x_{index}> = {x_avg:.{precision}}  =/- {math.sqrt(abs(x2_avg - x_avg ** 2)):.{precision}}"
-        )