wavepacket 0.4.0__tar.gz → 0.5__tar.gz

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

@@ -2,6 +2,55 @@
 ChangeLog
 =========
 
+0.5
+---
+
+Breaking changes:
+
+Major changes:
+
+- (#39) Added a PartialTraceTransformation to trace out all but one degree of freedom
+
+- (#25) Added coupled channels consisting of a degree of freedom, a transformation,
+  two operators and a few convenience functions.
+
+New documentation / examples:
+
+- (#39) Effect of an environment on system states (decoherence) for a simple example
+- (#25) Introduction and usage of coupled channels
+
+Minor changes:
+
+- documented use of atomic units in the code
+
+Bug fixes:
+
+- (#63) removed some warnings due to incorrect formula escaping
+  - fixed a type error with recent scipy versions when using a SphericalHarmonicsDof
+- (#41) fixed broken references in the documentation
+
+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.5}/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.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavepacket
-Version: 0.4.0
+Version: 0.5
 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
@@ -22,13 +22,11 @@ License-File: LICENSE
 Requires-Dist: numpy >= 2.1.3
 Requires-Dist: scipy >= 1.14.1
 Requires-Dist: matplotlib >= 3.10
-Requires-Dist: coverage >= 7 ; extra == "coverage"
 Requires-Dist: black  == 26.* ; extra == "formatting"
 Requires-Dist: pytest >= 8.3 ; extra == "test"
 Project-URL: Homepage, https://wavepacket.readthedocs.io
 Project-URL: Issues, https://github.com/ulflor/wavepacket/issues
 Project-URL: Source, https://github.com/ulflor/wavepacket
-Provides-Extra: coverage
 Provides-Extra: formatting
 Provides-Extra: test
 
@@ -49,6 +47,7 @@ Wavepacket focuses on a particular niche:
 - Direct solution of Schrödinger / Liouville von Neumann equations.
   No electronic structure, no MCTDH, no semiclassics, at least for now.
 - Grid-based representation of operators (DVR approximation).
+  Atomic units to simplify equations.
 - Accessibility is an overriding goal. Wavepacket should be directly usable in teaching.
   We try to provide good tutorials / docs, but also goodies like simple plotting.
 - Exotic use cases should be as frictionless as possible.
@@ -74,7 +73,7 @@ Support
 
 There are three different avenues for feedback and support:
 
-- The prefered option is through the mailing list wavepacket@python.org.
+- The preferred option is through the mailing list wavepacket@python.org.
   You may want to subscribe at https://mail.python.org/mailman3/lists/wavepacket.python.org/
   to ensure you receive all answers.
 - You can use the Forum on github: https://github.com/ulflor/wavepacket/discussions
@@ -94,7 +93,7 @@ I currently lack a formal procedure for new contributors, but you are
 very welcome to contribute to the project. If you do not know what to do,
 use one of the support channels from the previous section ; there is enough
 work for multiple developers, also for non-coding skills (there is never enough
-documentation).
+documentation, for example).
 
 
 History

{wavepacket-0.4.0 → wavepacket-0.5}/README.rst

@@ -15,6 +15,7 @@ Wavepacket focuses on a particular niche:
 - Direct solution of Schrödinger / Liouville von Neumann equations.
   No electronic structure, no MCTDH, no semiclassics, at least for now.
 - Grid-based representation of operators (DVR approximation).
+  Atomic units to simplify equations.
 - Accessibility is an overriding goal. Wavepacket should be directly usable in teaching.
   We try to provide good tutorials / docs, but also goodies like simple plotting.
 - Exotic use cases should be as frictionless as possible.
@@ -40,7 +41,7 @@ Support
 
 There are three different avenues for feedback and support:
 
-- The prefered option is through the mailing list wavepacket@python.org.
+- The preferred option is through the mailing list wavepacket@python.org.
   You may want to subscribe at https://mail.python.org/mailman3/lists/wavepacket.python.org/
   to ensure you receive all answers.
 - You can use the Forum on github: https://github.com/ulflor/wavepacket/discussions
@@ -60,7 +61,7 @@ I currently lack a formal procedure for new contributors, but you are
 very welcome to contribute to the project. If you do not know what to do,
 use one of the support channels from the previous section ; there is enough
 work for multiple developers, also for non-coding skills (there is never enough
-documentation).
+documentation, for example).
 
 
 History

{wavepacket-0.4.0 → wavepacket-0.5}/doc/advanced/ode_solvers.md

@@ -25,7 +25,7 @@ For the impatient, the main results of the following treatise are:
 
 ### ODE solvers theory
 
-We start from the Schrödinger equation
+We start from the Schrödinger equation (we use atomic units throughout the text)
 
 $$
     \imath \dot \psi(t) = \hat H(t) \psi(t)
@@ -245,15 +245,13 @@ To answer this question, we can look at the projection of the truncated result o
 any deviation from one can serve as a figure of merit of the additional error.
 
 ```{code-cell}
-import math
-
 truncated_hamiltonian = (wp.operator.CartesianKineticEnergy(grid, 0, 1.0, cutoff=50)
                         + wp.operator.Potential1D(grid, 0, lambda x: 0.5 * x ** 2, cutoff=50))
 truncated_equation = wp.expression.SchroedingerEquation(truncated_hamiltonian)
-truncated_solver = wp.solver.OdeSolver(truncated_equation, math.pi / 2)
+truncated_solver = wp.solver.OdeSolver(truncated_equation, np.pi / 2)
 truncated_result = truncated_solver.step(psi0, 0)
 
-solver = wp.solver.OdeSolver(equation, math.pi/2)
+solver = wp.solver.OdeSolver(equation, np.pi/2)
 result = solver.step(psi0, 0)
 
 print(f"Overlap after pi/2: {wp.population(truncated_result, result)}")

{wavepacket-0.4.0 → wavepacket-0.5}/doc/advanced/pendular_states.md

@@ -17,6 +17,7 @@ how to extract non-trivial data with minimal fuss and plot it.
 
 If a molecule interacts with a non-resonant laser field, the electronic ground state is shifted in energy.
 We can calculate the shift with standard perturbation theory and cavity-dressed states as
+(we use atomic units throughout the text)
 
 $$
 \Delta E \propto - \sum_n \frac{|\langle \Phi_0 | \hat{\vec{\mu}} \vec E |\Phi_n \rangle|^2}{E_n - E_0 - \omega}
@@ -73,7 +74,6 @@ Note that at certain points in time, the rotor exhibits alignment recurrence eve
 This field-free alignment is used in practice because the molecule is aligned, yet undisturbed by external fields.
 
 ```{code-cell}
-import math
 import matplotlib.pyplot as plt
 import numpy as np
 
@@ -91,7 +91,7 @@ def calculate_alignment(Delta, sigma, l0=0, m=0):
     kinetic = wp.operator.RotationalKineticEnergy(grid, 0, 0.5)
     cos2 = wp.operator.Potential1D(grid, 0, lambda theta: np.cos(theta)**2)
     laser = wp.operator.TimeDependentOperator(grid,
-                                              lambda t: Delta * math.exp(-(t-delay)**2/sigma**2))
+                                              lambda t: Delta * np.exp(-(t-delay)**2/sigma**2))
 
     hamiltonian = kinetic - 0.5 * cos2 * laser
     equation = wp.expression.SchroedingerEquation(hamiltonian)

{wavepacket-0.4.0 → wavepacket-0.5}/doc/advanced/plane_wave_grid.md

@@ -143,9 +143,9 @@ There are, however, two major drawbacks:
   and you may need to converge this as well.
 * With the NIP term, the Hamiltonian is no longer self-adjoint.
   Some efficient solvers like the ChebychevSolver only work for self-adjoint Hamiltonians.
-  The workaround here is to move the NIP out of the Hamiltonian,
+  A possible workaround here is to move the NIP out of the Hamiltonian,
   and absorb the wave packet after every propagation step.
-  As of Wavepacket 0.4, this is currently not implemented conveniently, though.
+  As of Wavepacket 0.4, this is not implemented conveniently, though.
 
 Let us demonstrate the first point by adding a steep NIP to the Morse oscillator example:
 

{wavepacket-0.4.0 → wavepacket-0.5}/doc/advanced/polynomial_solvers.md

@@ -25,6 +25,7 @@ was introduced by Huisinga et al. [^faber], but we omit this discussion for simp
 ## Basic theory
 
 For a time-independent, closed system, the time evolution operator is defined by
+(we use atomic units throughout the text)
 
 $$
     \psi(t+\Delta t) = \hat U(\Delta t) \psi(t) = \mathrm{e}^{-\imath \hat H \Delta t} \psi(t).
@@ -96,10 +97,10 @@ We get for a normalized state
 We do not care about the exact value of the error, just note two properties of the expression:
 
 1. There is an upper bound for the error independent of the initial state. That is, the convergence is continuous,
-   there are no individual states for which the series does not converge.
+   there are no singular states for which the series does not converge.
 2. For large enough N, the right-hand side decreases exponentially with increasing N.
 
-In practice, we do not target a specific value of the (upper bound of the) propagation error,
+For simplicity, we do not target a specific value of the (upper bound of the) propagation error,
 but simply truncate the series as soon as the Bessel function has reached a certain cutoff.
 This cutoff can still be considered a proxy for the order of magnitude of the error,
 but is not a rigorous quantity.
@@ -117,7 +118,7 @@ The size of the time step, that is, the gain, however, is proportional to the al
 argument of said Bessel function.
 
 So we can rephrase the question: At which value of alpha do we get most gain per cost?
-Let us plot the behaviour of the Bessel functions for different values of alpha
+Let us plot the behavior of the Bessel functions for different values of alpha
 
 ```{code-cell}
 import matplotlib.pyplot as plt
@@ -149,7 +150,7 @@ Hence, the proposition of using an alpha value of at least 40 to avoid inefficie
 of increasing alpha beyond, say, 100.
 Both values are not exact numbers, however, just crude rules of thumb.
 
-However, very large orders of expansion may lead to artefacts.
+However, very large orders of expansion may lead to artifacts.
 For example the values of the Bessel functions may become inaccurate, depending on the implementation details.
 Therefore, we would recommend not increasing alpha beyond something like 100, but that is also not a hard value.
 For example, we encountered a Matlab version around 2010
@@ -166,7 +167,7 @@ so let us back this up with numbers.
 We choose the truncated harmonic oscillator example from {doc}`/tutorials/chebychev_solvers`.
 
 ```{code-cell}
-import math
+import numpy as np
 import wavepacket as wp
 
 grid = wp.grid.Grid(wp.grid.PlaneWaveDof(-10, 10, 128))
@@ -200,17 +201,17 @@ Then we only wrap our (truncated) expression and propagate for a common time.
 ```{code-cell}
 counting_equation = CountingExpression(equation)
 
-solver_chebychev = wp.solver.ChebychevSolver(counting_equation, math.pi/2, (0, 70))
+solver_chebychev = wp.solver.ChebychevSolver(counting_equation, np.pi/2, (0, 70))
 solver_chebychev.step(psi0, t=0)
 print(f"Chebychev solver:                      count={counting_equation.count}, alpha={solver_chebychev.alpha:.4}")
 
 counting_equation.count = 0
-solver_rk45 = wp.solver.OdeSolver(counting_equation, math.pi/2)
+solver_rk45 = wp.solver.OdeSolver(counting_equation, np.pi/2)
 solver_rk45.step(psi0, t=0)
 print(f"Runge-Kutta 4/5 solver:                count={counting_equation.count}")
 
 counting_equation.count = 0
-solver_rk45_precise = wp.solver.OdeSolver(counting_equation, math.pi/2, rtol=1e-9, atol=1e-9)
+solver_rk45_precise = wp.solver.OdeSolver(counting_equation, np.pi/2, rtol=1e-9, atol=1e-9)
 solver_rk45_precise.step(psi0, t=0)
 print(f"High-precision Runge-Kutta 4/5 solver: count={counting_equation.count}")
 ```

wavepacket-0.5/doc/advanced/reduced_density.md

@@ -0,0 +1,259 @@
+---
+file_format: mystnb
+kernelspec:
+    name: python3
+---
+
+# Background theory: Reduced density operators
+
+This web page can be downloaded as notebook: {nb-download}`reduced_density.ipynb` (Jupyter)
+or {download}`reduced_density.md` (Markdown)
+
+In this notebook, we investigate a toy problem that qualitatively demonstrates the effect of
+an environment on a quantum measurement.
+Basically, we discuss the mechanism behind coherent and incoherent superpositions,
+that is shown in {doc}`/tutorials/schroedinger_cat`.
+
+## Theory: Partial trace
+
+Let us consider an excerpt of the universe whose state can be described by a wave function.
+At some point, we want to make a measurement, so we calculate an expectation value of the corresponding operator.
+By inserting a summation over an orthonormal basis {math}`\phi`, we can rewrite this as a trace over
+a (pure) density operator,
+
+\begin{align*}
+\langle \hat A \rangle &= \langle \psi | \hat A | \psi \rangle\\
+  &= \langle \psi | \hat A \sum_n|\phi_n\rangle \langle \phi_n | \psi \rangle\\
+  &= \sum_n \langle \phi_n | \psi \rangle \langle \psi | \hat A |\phi_n\rangle\\
+  &= \mathrm{Tr}(|\psi\rangle\langle\psi | \hat A) = \mathrm{Tr} (\hat \rho \hat A)
+  .
+\end{align*}
+
+Now we decompose our small universe into system and environment degrees of freedom, $\mathcal{H} = S \otimes E$
+with respective orthonormal basis $\varphi, \eta$.
+As "system", we denote those degrees of freedom along which our operator(s) act,
+the rest we call "environment" or "bath".
+By definition, the operator can be rewritten as $\hat A = \hat A_S \otimes \hat 1_E$,
+where the subscripts denote action or integration over the system or environment part.
+The trace now becomes
+
+\begin{align*}
+\langle \hat A \rangle &= \sum_{k,l} \Bigl(\langle \varphi_k | \otimes \langle \eta_l|\Bigr) \  \hat \rho
+    \hat A_S \otimes \hat 1_E \ \Bigl(|\varphi_k\rangle_S \otimes |\eta_l \rangle_E\Bigr)\\
+  &= \sum_k \langle \varphi_k | \ \Bigl( \sum_l \langle \eta_l | \hat \rho |\eta_l\rangle_E \Bigr)
+    \ \hat A_S |\varphi_k\rangle_S \\
+  &= \sum_k \langle \varphi_k | \hat \rho_\mathrm{red} \hat A_S | \varphi_k \rangle \\
+  &= \mathrm{Tr}_S ( \hat \varrho_\mathrm{red} \hat A_S) \qquad \qquad
+    \mathrm{with} \qquad \hat \varrho_\mathrm{red} = \mathrm{Tr}_E \hat \rho
+\end{align*}
+
+Even though our original state is pure and can be described by a wave function,
+the reduced density may be impure/mixed and describe a statistical ensemble.
+It can easily be checked that
+
+\begin{align*}
+    \psi = (\varphi_0 + \varphi_1) \otimes \eta_0 \quad &\rightarrow \quad
+        \varrho_\mathrm{red} = |\varphi_0+\varphi_1\rangle\langle\varphi_0+\varphi_1|\\
+    \psi = \varphi_0 \otimes \eta_0 + \varphi_1 \otimes \eta_1 \quad &\rightarrow \quad
+        \varrho_\mathrm{red} = |\varphi_0\rangle\langle\varphi_0| + |\varphi_1\langle\rangle \varphi_1|
+\end{align*}
+
+That is, we get a pure reduced density if $\psi$ is a product state,
+and a mixed reduced density if $\psi$ contains correlations between the system and environment.
+
+## The system under study
+
+With the basic theory result spelled out, let us look at a toy example, where we can observe these effects,
+yet still understand the full dynamics.
+We use one-dimensional harmonic oscillators for the system and environment, respectively.
+Let us start with the grid definitions:
+
+```{code-cell}
+import wavepacket as wp
+
+system_dof = wp.grid.PlaneWaveDof(-10, 10, 96)
+environment_dof = wp.grid.PlaneWaveDof(-5, 5, 96)
+full_grid = wp.grid.Grid([system_dof, environment_dof])
+
+trafo = wp.grid.PartialTraceTransformation(full_grid, 0)
+system_grid = trafo.target_grid
+```
+
+We exploit here that the transformation object creates a one-dimensional "target grid"
+containing only the first (/system) degree of freedom during setup.
+We will use this transformation later to calculate the reduced density operator
+from a state defined on the system+environment grid.
+
+For system and environment, we define different harmonic oscillators
+
+```{code-cell}
+kinetic_sys = wp.operator.CartesianKineticEnergy(system_grid, 0, mass=1, cutoff=40)
+potential_sys = wp.operator.Potential1D(system_grid, 0, lambda x: 0.5 * x**2, cutoff=40)
+
+kinetic_full = (wp.operator.CartesianKineticEnergy(full_grid, 0, mass=1, cutoff=40)
+               + wp.operator.CartesianKineticEnergy(full_grid, 1, mass=1, cutoff=40))
+potential_full = (wp.operator.Potential1D(full_grid, 0, lambda x: 0.5 * x**2, cutoff=40)
+                 + wp.operator.Potential1D(full_grid, 1, lambda x: 0.5 * (2*x)**2, cutoff=40))
+```
+
+## Dynamics with and without environment
+
+### Product state without coupling
+
+To demonstrate the theoretical results, we start with an environment not coupled to the system,
+and with a product state.
+For the initial system states, we choose a squeezed and shifted Gaussian that oscillates in the system potential.
+For the environment state, we choose some Gaussian centered around the potential minimum.
+
+```{code-cell}
+import math
+
+left_gauss = wp.special.Gaussian(-5, 0, rms=0.5)
+right_gauss = wp.special.Gaussian(5, 0, rms=0.5)
+env_gauss = wp.special.Gaussian(0, 0, rms=0.5)
+
+psi0_sys = math.sqrt(0.5) * (
+             wp.builder.product_wave_function(system_grid, left_gauss)
+             + wp.builder.product_wave_function(system_grid, right_gauss)
+           )
+
+psi0_full = math.sqrt(0.5) * (
+              wp.builder.product_wave_function(full_grid, [left_gauss, env_gauss])
+              + wp.builder.product_wave_function(full_grid, [right_gauss, env_gauss])
+            )
+```
+
+As reference, we start with a simulation of only the system degree of freedom.
+
+```{code-cell}
+equation_sys = wp.expression.SchroedingerEquation(kinetic_sys + potential_sys)
+
+solver = wp.solver.ChebychevSolver(equation_sys, math.pi/6, (0, 80))
+plotter = wp.plot.StackedPlot1D(4, psi0_sys, potential_sys, kinetic_sys + potential_sys)
+for t, psi in solver.propagate(psi0_sys, 0.0, 3):
+    plotter.plot(t, psi);
+```
+
+The two Gaussians breathe and oscillate in the potential and show interference when they cross paths.
+This is just textbook quantum mechanics, no surprises so far.
+
+Now what happens if we add an environment degree of freedom?
+We start with a product state, and because of the missing system-environment coupling,
+our solution remains a product state.
+Hence, we expect a pure reduced density matrix that just replicates the
+system-only result including interferences.
+
+```{code-cell}
+equation_uncoupled = wp.expression.SchroedingerEquation(kinetic_full + potential_full)
+
+solver = wp.solver.ChebychevSolver(equation_uncoupled, math.pi/6, (0, 160))
+plotter = wp.plot.StackedPlot1D(4, psi0_sys, potential_sys, kinetic_sys + potential_sys)
+for t, psi in solver.propagate(psi0_full, 0.0, 3):
+    reduced_density = trafo.transform(psi)
+    plotter.plot(t, reduced_density);
+```
+
+This result also makes sense for philosophical reasons.
+If the addition of an arbitrary, uninteresting degree of freedom would change the results,
+we could modify any calculation results by, say, adding the phase of the moon
+which is an obviously silly proposition.
+
+### Couplings and correlations
+
+For the environment to have an effect on the system dynamics, we need to introduce a coupling.
+To understand what happens now, let us first have a look at the two-dimensional dynamics.
+
+```{code-cell}
+coupling = -0.5 * (wp.operator.Potential1D(full_grid, 0, lambda x: x)
+                  * wp.operator.Potential1D(full_grid, 1, lambda x: x))
+equation_coupled = wp.expression.SchroedingerEquation(kinetic_full + potential_full + coupling)
+
+# store the results, we iterate twice over them, but want to calculate only once.
+solver = wp.solver.ChebychevSolver(equation_coupled, math.pi/6, (0, 210))
+results = [(t, psi) for t, psi in solver.propagate(psi0_full, 0.0, 3)]
+
+plotter = wp.plot.StackedContourPlot2D(2, 2, psi0_full, potential_full + coupling)
+plotter.contours /= 2
+for t, psi in results:
+    plotter.plot(t, psi)
+```
+
+Adding a bilinear coupling to a harmonic oscillator results in a harmonic oscillator
+with different frequencies, and rotated normal modes.
+For the parameters here, we see that the new normal modes are roughly
+$n_0 \approx x_s + 0.5 x_e$ and $n_1 \approx x_s - 0.5 x_e$.
+
+The two Gaussians that form our initial state move along these new normal modes, and now it gets interesting.
+From a purely formal perspective, we get correlations between the system and environment.
+That is, the total wave function is clearly no longer a direct product of a system and an environment wave function.
+As discussed in the theory section, we expect a mixed density operator and a suppression of interferences.
+
+We can also look at the situation from a different angle.
+Because the two Gaussians move along the new normal modes, they mostly miss each other,
+and barely overlap / interfere in the system-environment space.
+The operation of tracing out the environment just projects this situation onto the system axis;
+basically as if you "looked onto a projection of the plot while standing on the system axis".
+
+```{code-cell}
+plotter = wp.plot.StackedPlot1D(4, psi0_sys, potential_sys, kinetic_sys + potential_sys)
+for t, psi in results:
+    reduced_density = trafo.transform(psi)
+    plotter.plot(t, reduced_density);
+```
+
+In a "real" system, we define observables for a few degrees of freedom at most,
+while the environment around the system has a gazillion degrees of freedom.
+There is then much more "space" for different parts of the total wave function to avoid each other.
+After a while (the "decoherence time"), the likelihood of different parts of
+the wave function overlapping in the system+environment space is negligible,
+and interferences vanish.
+
+Note, however, that we introduced a pretty strong system-environment coupling to force visible effects.
+In practical systems, such couplings may be weak, giving significant experimental time scales during which you
+can safely ignore environment effects.
+
+But even the weakest coupling affects the initial state.
+Typically, at the start of an experiment, the system has spent plenty of time interacting with the environment;
+it is "thermalized".
+And this interaction has introduced correlations between the system and the environment into the initial state,
+whose reduced density matrix is therefore no longer pure.
+Let us set up such a prototypical situation here again: We use a correlated initial state,
+and ignore coupling between system and environment.
+
+```{code-cell}
+psi0_correlated = math.sqrt(0.5) * (
+              wp.builder.product_wave_function(full_grid, [left_gauss, wp.special.Gaussian(-1.5, 0, rms=0.5)])
+              + wp.builder.product_wave_function(full_grid, [right_gauss, env_gauss])
+            )
+
+
+# store the results, we iterate twice over them, but want to calculate only once.
+solver = wp.solver.ChebychevSolver(equation_uncoupled, math.pi/6, (0, 180))
+results = [(t, psi) for t, psi in solver.propagate(psi0_correlated, 0.0, 3)]
+
+plotter = wp.plot.StackedContourPlot2D(2, 2, psi0_correlated, potential_full)
+plotter.contours /= 2
+for t, psi in results:
+    plotter.plot(t, psi)
+```
+
+The "right" Gaussian oscillates only along the system degree of freedom,
+while the "left" Gaussian follows a trajectory from the "bottom left" to the "center top".
+As a consequence, these two wave packets again miss each other, and the interference pattern is suppressed.
+If we look at the system degree of freedom again, we find exactly this pattern:
+
+```{code-cell}
+plotter = wp.plot.StackedPlot1D(4, psi0_sys, potential_sys, kinetic_sys + potential_sys)
+for t, psi in results:
+    reduced_density = trafo.transform(psi)
+    plotter.plot(t, reduced_density);
+```
+
+While interference patterns _within_ each Gaussian are retained during the simulation (no coupling),
+there is no interference _between_ the two Gaussians.
+Or in other words, even though we can ignore the environment during the simulation, we need to
+take it into account in the initial state.
+Following this thread of thought much further eventually leads to the
+expression of thermal states with mixed density operators,
+without interference terms between the system Hamiltonian's eigentstates,
+but that goes well beyond such a small Jupyter notebook.

{wavepacket-0.4.0 → wavepacket-0.5}/doc/advanced/thermal_states.md

@@ -14,6 +14,7 @@ or {download}`thermal_states.md` (Markdown)
 Sometimes, we wish to study systems at finite temperatures.
 To describe such systems, we need either a density operator or an ensemble of wave functions.
 The textbook expression for a thermal state is a density operator
+(we use atomic units throughout the text)
 
 $$
     \hat \varrho_\mathrm{th} = \frac{1}{Z} \ \mathrm{e}^{- \beta \hat H}
@@ -49,7 +50,7 @@ but the path to more complex setups should be readily apparent from the formulas
 As example system, we calculate the temperature-dependent energy of a Morse oscillator,
 with parameters chosen for an OH radical.
 The system is simple, but not entirely trivial.
-Because we are going to use the {py:class}`RelaxationSolver`,
+Because we are going to use the {py:class}`wavepacket.solver.RelaxationSolver`,
 we truncate the operators at energies well beyond the dissociation energy.
 This has the side effect of providing us bounds for the spectrum of the Hamiltonian that we can use later.
 
@@ -211,7 +212,7 @@ explicit solver.
 
 ### Implementation
 
-For simplicity, we choose to obtain the eigenstates here from diagonalising the Hamiltonian matrix.
+For simplicity, we choose to obtain the eigenstates here from diagonalizing the Hamiltonian matrix.
 This is not a good choice performance-wise, but keeps the example focused.
 
 Conceptually, we need two passes.
@@ -276,7 +277,7 @@ complexity.
 One solution is the use of imaginary-time relaxation to get the lowest few eigenstates.
 This method is discussed in {doc}`/tutorials/relaxation`.
 Curiously, the relaxation limitation to few excited eigenstates aligns naturally
-with the this method's limitation to few excited eigenstates.
+with this method's limitation to few excited eigenstates.
 
 If relaxation is difficult, you can simply choose a different basis.
 After all, we do not need energy eigenstates, we need to cover the relevant low-energy subspace.
@@ -326,7 +327,7 @@ $$
 Random wave functions are only useful for certain manipulations, such as replacing a unit operator.
 You must not confuse them with ordinary wave functions,
 as not all operations are well-defined.
-For example, it is easy to check that they do not have a finite norm.
+For example, it is easy to check that they are not normalized.
 ```
 
 We now take again [the response expression](#eq_response), split the exponential,
@@ -361,7 +362,7 @@ On first view, this method may look like a slightly deranged variant of the prev
 So how, and especially why and when does it work?
 The hand-waving answer is that this is almost method II, but
 the ensemble of random wave functions (i) is not orthogonal (bad),
-and (ii) covers the "typical" Hilbert space space with few wave functions already (good).
+and (ii) covers the "typical" Hilbert space with few wave functions already (good).
 
 Non-orthogonality is uniformly bad; it means for example that you may count contributions twice,
 and this problem only averages out over large samples.
@@ -383,7 +384,7 @@ where the phase is drawn uniformly from the interval $\phi \in [-\pi, \pi]$.
 The overall implementation is similar to that of method II with three differences.
 
 1. Instead of calculating eigenstates, we generate random wave functions using
-   {py:func}`wp.builder.random_wave_function`.
+   {py:func}`wavepacket.builder.random_wave_function`.
 2. We need to explicitly relax the states.
 3. We do not sum the individual contributions, but average.
 

{wavepacket-0.4.0 → wavepacket-0.5}/doc/architecture.rst

@@ -27,7 +27,7 @@ To get there, the code ended up with a few common concepts.
   and we did not cover every potential pitfall. Avoid breaking this guarantee, however,
   because doing so can corrupt object consistency (and therefore results) in
   subtle ways. In particular, if you create a :py:class:`wavepacket.grid.State`
-  directly from a numpy array (very advanced use case), dispose the array and
+  directly from a numpy array (very advanced use case), forget about this array and
   do not modify it afterwards.
 
 

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

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

{wavepacket-0.4.0 → wavepacket-0.5}/doc/index.rst

@@ -19,6 +19,7 @@ Wavepacket documentation
     tutorials/schroedinger_cat
     tutorials/eigenstates
     tutorials/plotting
+    tutorials/channels
     tutorials/chebychev_solvers
     tutorials/relaxation
 
@@ -28,6 +29,7 @@ Wavepacket documentation
 
     advanced/pendular_states
     advanced/thermal_states
+    advanced/reduced_density
     advanced/plane_wave_grid
     advanced/ode_solvers
     advanced/polynomial_solvers