physicskit 0.1.0__py3-none-any.whl

physicskit/semiclassical/visualizers/path_integral.py

@@ -0,0 +1,195 @@
+r"""Plotting helpers for Feynman's path-integral phasor ("arrow and stopwatch") construction."""
+
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.animation import FuncAnimation
+
+__all__ = ["animate_feynman_phasor_spiral", "plot_phasor_convergence"]
+
+
+def animate_feynman_phasor_spiral(
+    paths: np.ndarray,
+    actions: np.ndarray,
+    classical_path: np.ndarray,
+    classical_action: float,
+    hbar: float,
+    t_array: np.ndarray,
+    interval: int = 40,
+) -> FuncAnimation:
+    r"""Animate paths being added one at a time alongside their growing Feynman phasor sum.
+
+    Two side-by-side panels update together, frame by frame, as paths are
+    added in order of increasing :math:`|S-S_{\rm cl}|` (closest to the
+    classical path first -- the same order used by
+    :func:`~physicskit.semiclassical.core.path_integral.feynman_phasor_partial_sums`).
+    The left panel shows each path in real space, :math:`x(t)`, faded by
+    how far its action is from the classical action; the right panel
+    shows the cumulative phasor sum :math:`\sum\exp(iS/\hbar)` in the
+    complex plane, traced out as a connected "arrow chain" -- Feynman's
+    own picture of how nearby-action paths reinforce while distant-action
+    paths spin around and largely cancel.
+
+    Parameters
+    ----------
+    paths : ndarray, shape (n_paths, n_points)
+        Ensemble of paths, e.g. from
+        :func:`~physicskit.semiclassical.core.path_integral.build_phasor_diagram`.
+    actions : ndarray, shape (n_paths,)
+        Discretized action of each path.
+    classical_path : ndarray, shape (n_points,)
+        The exact classical trajectory, drawn on top of every frame.
+    classical_action : float
+        The exact classical action, used both as the sort reference and
+        as the reference for the color/alpha of each path.
+    hbar : float
+        Reduced Planck constant (or an effective value thereof) used in
+        the phasors :math:`\exp(iS/\hbar)`.
+    t_array : ndarray, shape (n_points,)
+        Time grid shared by every path (and the classical path).
+    interval : int, default=40
+        Delay between animation frames, in milliseconds.
+
+    Returns
+    -------
+    matplotlib.animation.FuncAnimation
+        The animation object; assign it to a variable to keep it alive,
+        and display it with ``plt.show()`` or save it with
+        ``anim.save(...)``.
+
+    Examples
+    --------
+    >>> from physicskit.semiclassical.core.path_integral import build_phasor_diagram
+    >>> paths, actions, x_cl, S_cl, _ = build_phasor_diagram(
+    ...     x0=0.0, xf=1.0, T=1.0, m=1.0, hbar=0.1, potential="free",
+    ...     n_slices=20, n_paths=30, sigma=0.3, seed=0)
+    >>> t = np.linspace(0.0, 1.0, x_cl.shape[0])
+    >>> anim = animate_feynman_phasor_spiral(paths, actions, x_cl, S_cl, hbar=0.1, t_array=t)
+    >>> isinstance(anim, FuncAnimation)
+    True
+    """
+    paths = np.asarray(paths)
+    actions = np.asarray(actions)
+    n_paths = paths.shape[0]
+
+    order = np.argsort(np.abs(actions - classical_action))
+    sorted_paths = paths[order]
+    sorted_actions = actions[order]
+
+    dist = np.abs(sorted_actions - classical_action)
+    dist_max = dist.max() if dist.max() > 0 else 1.0
+    closeness = 1.0 - dist / dist_max  # 1 = right at classical action, 0 = farthest
+
+    phasors = np.exp(1j * sorted_actions / hbar)
+    partial_sums = np.concatenate([[0.0 + 0.0j], np.cumsum(phasors)])
+
+    fig, (ax_paths, ax_complex) = plt.subplots(1, 2, figsize=(12, 5.5))
+
+    ax_paths.plot(t_array, classical_path, color="red", lw=2.5, zorder=5, label="classical path")
+    ax_paths.set_xlim(t_array.min(), t_array.max())
+    x_all = np.concatenate([paths.ravel(), classical_path.ravel()])
+    pad = 0.1 * (x_all.max() - x_all.min() + 1e-12)
+    ax_paths.set_ylim(x_all.min() - pad, x_all.max() + pad)
+    ax_paths.set_xlabel("t")
+    ax_paths.set_ylabel("x(t)")
+    ax_paths.set_title("Sampled paths (closest to classical first)")
+    ax_paths.legend(loc="upper left", fontsize=8)
+    path_lines = []
+
+    radius = np.max(np.abs(partial_sums)) * 1.15 + 1e-12
+    ax_complex.set_xlim(-radius, radius)
+    ax_complex.set_ylim(-radius, radius)
+    ax_complex.set_xlabel("Re")
+    ax_complex.set_ylabel("Im")
+    ax_complex.set_title(r"Phasor sum $\sum e^{iS/\hbar}$")
+    ax_complex.axhline(0, color="gray", lw=0.5)
+    ax_complex.axvline(0, color="gray", lw=0.5)
+    ax_complex.set_aspect("equal")
+    (spiral_line,) = ax_complex.plot([], [], color="C0", lw=1.0)
+    arrow = ax_complex.annotate("", xy=(0, 0), xytext=(0, 0), arrowprops=dict(arrowstyle="->", color="crimson", lw=2))
+
+    def init():
+        spiral_line.set_data([], [])
+        arrow.xy = (0, 0)
+        arrow.set_position((0, 0))
+        return [spiral_line, arrow]
+
+    def update(frame: int):
+        for ln in path_lines:
+            ln.remove()
+        path_lines.clear()
+        for j in range(frame + 1):
+            c = closeness[j]
+            color = (1.0, 0.35 * (1 - c), 0.0, 0.15 + 0.7 * c)
+            (ln,) = ax_paths.plot(t_array, sorted_paths[j], color=color, lw=1.0, zorder=2)
+            path_lines.append(ln)
+
+        pts = partial_sums[: frame + 2]
+        spiral_line.set_data(pts.real, pts.imag)
+        arrow.set_position((0, 0))
+        arrow.xy = (pts[-1].real, pts[-1].imag)
+        ax_complex.set_title(f"Phasor sum after {frame + 1}/{n_paths} paths")
+        return path_lines + [spiral_line, arrow]
+
+    anim = FuncAnimation(fig, update, init_func=init, frames=n_paths, interval=interval, blit=False)
+    return anim
+
+
+def plot_phasor_convergence(partial_sums_by_hbar, hbar_values, ax=None):
+    r"""Plot the running phasor-sum magnitude for several :math:`\hbar` values on shared axes.
+
+    Shows the core physics claim quantitatively: as :math:`\hbar` shrinks,
+    the growing partial sum's magnitude climbs faster and plateaus sooner
+    (dominated by an ever-smaller neighborhood of the classical path),
+    while larger :math:`\hbar` gives a partial sum that keeps wandering
+    randomly as more distant paths are added.
+
+    Parameters
+    ----------
+    partial_sums_by_hbar : sequence of ndarray of complex
+        One partial-sum array per :math:`\hbar` value (e.g. from
+        :func:`~physicskit.semiclassical.core.path_integral.feynman_phasor_partial_sums`
+        or the last element of
+        :func:`~physicskit.semiclassical.core.path_integral.build_phasor_diagram`'s
+        return value), each of shape ``(n_paths + 1,)``.
+    hbar_values : sequence of float
+        The :math:`\hbar` value corresponding to each array in
+        ``partial_sums_by_hbar`` (used only for the legend labels).
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into; a new figure is created if omitted.
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+    ax : matplotlib.axes.Axes
+
+    Examples
+    --------
+    >>> from physicskit.semiclassical.core.path_integral import build_phasor_diagram
+    >>> sums, hbars = [], [0.5, 0.05]
+    >>> for hbar in hbars:
+    ...     _, _, _, _, partial = build_phasor_diagram(
+    ...         x0=0.0, xf=1.0, T=1.0, m=1.0, hbar=hbar, potential="free",
+    ...         n_slices=20, n_paths=60, sigma=0.3, seed=0)
+    ...     sums.append(partial)
+    >>> fig, ax = plot_phasor_convergence(sums, hbars)
+    >>> isinstance(fig, plt.Figure)
+    True
+    """
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(7, 4.5))
+    else:
+        fig = ax.figure
+
+    for partial, hbar in zip(partial_sums_by_hbar, hbar_values):
+        partial = np.asarray(partial)
+        n = partial.shape[0] - 1
+        frac = np.arange(n + 1) / n
+        ax.plot(frac, np.abs(partial), label=rf"$\hbar={hbar:g}$")
+
+    ax.set_xlabel("fraction of paths included (closest-to-classical first)")
+    ax.set_ylabel(r"$\left|\sum e^{iS/\hbar}\right|$")
+    ax.set_title("Phasor-sum concentration near the classical path")
+    ax.legend(fontsize=8)
+    return fig, ax

physicskit/semiclassical/visualizers/propagators.py

@@ -0,0 +1,89 @@
+r"""Plotting helpers comparing classical trajectories with the exact quantum Wigner function."""
+
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+__all__ = ["plot_classical_trajectory_on_wigner"]
+
+
+def _wigner_transform(x: np.ndarray, psi: np.ndarray, hbar: float = 1.0, n_p: int = 200, p_max: float | None = None):
+    r"""Wigner quasi-probability distribution :math:`W(x,p)` of a 1D wavefunction.
+
+    A local copy of :func:`physicskit.quantum.visualizers.phase_space.wigner_transform`,
+    kept here so :mod:`physicskit.semiclassical` has no dependency on
+    :mod:`physicskit.quantum`.
+    """
+    x = np.asarray(x)
+    psi = np.asarray(psi, dtype=complex)
+    N = x.shape[0]
+    dx = x[1] - x[0]
+    if p_max is None:
+        p_max = np.pi * hbar / (2 * dx)
+
+    p = np.linspace(-p_max, p_max, n_p)
+    W = np.zeros((N, n_p))
+
+    for i in range(N):
+        kmax = min(i, N - 1 - i)
+        k = np.arange(-kmax, kmax + 1)
+        integrand = np.conj(psi[i + k]) * psi[i - k]
+        phase = np.exp(2j * np.outer(p, k * dx) / hbar)
+        W[i, :] = (dx / (np.pi * hbar)) * np.real(phase @ integrand)
+
+    return x, p, W
+
+
+def plot_classical_trajectory_on_wigner(x: np.ndarray, psi: np.ndarray, q_hist: np.ndarray, p_hist: np.ndarray, hbar: float = 1.0, ax=None):
+    r"""Overlay a classical phase-space trajectory on the exact quantum Wigner function.
+
+    Compares the classical and quantum pictures directly: the Wigner
+    function of a quantum state, with the classical trajectory
+    (:func:`physicskit.semiclassical.core.propagators.propagate_trajectory_monodromy_action`)
+    that WKB/Van Vleck theory builds that state's semiclassical
+    approximation from, drawn on top -- the two agree closely wherever
+    the semiclassical approximation is accurate.
+
+    Parameters
+    ----------
+    x : ndarray
+        Position grid the wavefunction is sampled on.
+    psi : ndarray of complex
+        Quantum wavefunction sampled on ``x``.
+    q_hist, p_hist : ndarray
+        Classical trajectory phase-space coordinates.
+    hbar : float, default=1.0
+        Value of :math:`\hbar` to use.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into; a new figure is created if omitted.
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+    ax : matplotlib.axes.Axes
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from physicskit.semiclassical.core.propagators import frozen_gaussian_1d
+    >>> x = np.linspace(-8, 8, 400)
+    >>> psi = frozen_gaussian_1d(x, qc=1.0, pc=0.5, gamma=1.0)
+    >>> theta = np.linspace(0, 2 * np.pi, 100)
+    >>> q_hist, p_hist = np.cos(theta), np.sin(theta)
+    >>> fig, ax = plot_classical_trajectory_on_wigner(x, psi, q_hist, p_hist)
+    >>> isinstance(fig, plt.Figure)
+    True
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.figure
+    _x, p, W = _wigner_transform(x, psi, hbar=hbar)
+    im = ax.pcolormesh(x, p, W.T, cmap="RdBu_r", shading="auto")
+    fig.colorbar(im, ax=ax, label="W(x,p)")
+    ax.plot(q_hist, p_hist, color="k", linewidth=1.5, label="classical orbit")
+    ax.set_xlabel("x")
+    ax.set_ylabel("p")
+    ax.legend()
+    return fig, ax

physicskit/semiclassical/visualizers/scarring.py

@@ -0,0 +1,146 @@
+r"""Plotting helpers for quantum scars: eigenstate density maps and Husimi phase-space projections.
+
+:func:`plot_scar_map_interactive` returns a Plotly figure for pan/zoom
+exploration of a scarred eigenstate density; the rest return a
+Matplotlib figure and axes rather than calling ``show()``.
+"""
+
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+import numpy as np
+import plotly.graph_objects as go
+
+__all__ = ["plot_scar_map", "plot_husimi_1d", "plot_scar_map_interactive"]
+
+
+def plot_scar_map(
+    X: np.ndarray,
+    Y: np.ndarray,
+    density: np.ndarray,
+    mask: np.ndarray | None = None,
+    orbit_x: np.ndarray | None = None,
+    orbit_y: np.ndarray | None = None,
+    ax=None,
+):
+    r"""Heatmap an eigenstate density with a classical periodic orbit overlaid.
+
+    Parameters
+    ----------
+    X, Y : ndarray
+        Coordinate meshgrid.
+    density : ndarray
+        Probability density :math:`|\psi|^2`, same shape as ``X``.
+    mask : ndarray of bool, optional
+        ``True`` inside the billiard; density outside is not drawn.
+    orbit_x, orbit_y : ndarray, optional
+        Classical orbit coordinates, e.g. from
+        :func:`physicskit.semiclassical.systems.scarring.bouncing_ball_orbit_points`.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into; a new figure is created if omitted.
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+    ax : matplotlib.axes.Axes
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from physicskit.semiclassical.systems.scarring import bouncing_ball_orbit_points
+    >>> x = np.linspace(-2, 2, 100)
+    >>> y = np.linspace(-1, 1, 60)
+    >>> X, Y = np.meshgrid(x, y, indexing="ij")
+    >>> density = np.exp(-(X - 0.3) ** 2 / (2 * 0.2 ** 2))
+    >>> orbit_x, orbit_y = bouncing_ball_orbit_points(x0=0.3, R=1.0)
+    >>> fig, ax = plot_scar_map(X, Y, density, orbit_x=orbit_x, orbit_y=orbit_y)
+    >>> isinstance(fig, plt.Figure)
+    True
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.figure
+    plot_density = np.where(mask, density, np.nan) if mask is not None else density
+    im = ax.pcolormesh(X, Y, plot_density, cmap="inferno", shading="auto")
+    fig.colorbar(im, ax=ax, label=r"$|\psi|^2$")
+    if orbit_x is not None:
+        ax.plot(orbit_x, orbit_y, color="c", linewidth=1.2, label="classical orbit")
+        ax.legend()
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_aspect("equal")
+    return fig, ax
+
+
+def plot_husimi_1d(S0: np.ndarray, P0: np.ndarray, husimi: np.ndarray, ax=None):
+    r"""Contour-plot a 1D Husimi phase-space projection.
+
+    Parameters
+    ----------
+    S0, P0 : ndarray
+        Phase-space grid, from :func:`physicskit.semiclassical.systems.scarring.husimi_projection_1d`.
+    husimi : ndarray
+        Husimi distribution, same shape as ``S0``.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into; a new figure is created if omitted.
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+    ax : matplotlib.axes.Axes
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from physicskit.semiclassical.systems.scarring import husimi_projection_1d
+    >>> s = np.linspace(-10, 10, 1000)
+    >>> psi = np.exp(-(s - 2.0) ** 2 / 2.0) * np.exp(1j * 3.0 * s)
+    >>> S0, P0, H = husimi_projection_1d(psi, s, sigma=1.0, resolution=40, s0_range=(-2, 6), p0_range=(-2, 8))
+    >>> fig, ax = plot_husimi_1d(S0, P0, H)
+    >>> isinstance(fig, plt.Figure)
+    True
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.figure
+    im = ax.pcolormesh(S0, P0, husimi, cmap="viridis", shading="auto")
+    fig.colorbar(im, ax=ax, label="Husimi (peak-normalized)")
+    ax.set_xlabel("s")
+    ax.set_ylabel("p")
+    return fig, ax
+
+
+def plot_scar_map_interactive(X: np.ndarray, Y: np.ndarray, density: np.ndarray):
+    r"""Interactive Plotly heatmap of an eigenstate density, for zooming into scarred structure.
+
+    Parameters
+    ----------
+    X, Y : ndarray
+        Coordinate meshgrid.
+    density : ndarray
+        Probability density :math:`|\psi|^2`, same shape as ``X``.
+
+    Returns
+    -------
+    plotly.graph_objects.Figure
+
+    See Also
+    --------
+    plot_scar_map : The static Matplotlib heatmap equivalent, with orbit overlay support.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.linspace(-2, 2, 60)
+    >>> y = np.linspace(-1, 1, 40)
+    >>> X, Y = np.meshgrid(x, y, indexing="ij")
+    >>> density = np.exp(-(X - 0.3) ** 2 / (2 * 0.2 ** 2))
+    >>> fig = plot_scar_map_interactive(X, Y, density)
+    >>> isinstance(fig, go.Figure)
+    True
+    """
+    fig = go.Figure(data=go.Heatmap(x=X[:, 0], y=Y[0, :], z=density.T, colorscale="Inferno"))
+    fig.update_layout(xaxis_title="x", yaxis_title="y")
+    return fig

physicskit/semiclassical/visualizers/wkb.py

@@ -0,0 +1,55 @@
+r"""Plotting helpers for WKB wavefunctions."""
+
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+__all__ = ["plot_wkb_wavefunction"]
+
+
+def plot_wkb_wavefunction(x: np.ndarray, psi: np.ndarray, V=None, ax=None):
+    r"""Plot a WKB (or exact) 1D wavefunction, optionally with the potential on a twin axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        Position grid.
+    psi : ndarray
+        Wavefunction values, e.g. from
+        :func:`physicskit.semiclassical.core.wkb.wkb_wavefunction`.
+    V : callable, optional
+        Potential energy function ``V(x)``, drawn on a secondary y-axis
+        if given.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw into; a new figure is created if omitted.
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+    ax : matplotlib.axes.Axes
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from physicskit.semiclassical.core.wkb import bohr_sommerfeld_energies, wkb_wavefunction
+    >>> V = lambda x: 0.5 * x ** 2
+    >>> E2 = bohr_sommerfeld_energies(V, m=1.0, x_min=-20, x_max=20, n_max=3)[2]
+    >>> x = np.linspace(-6, 6, 1000)
+    >>> psi = wkb_wavefunction(x, E2, V)
+    >>> fig, ax = plot_wkb_wavefunction(x, psi, V=V)
+    >>> isinstance(fig, plt.Figure)
+    True
+    """
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.figure
+    ax.plot(x, psi, color="C0", label=r"$\psi_{\mathrm{WKB}}(x)$")
+    ax.set_xlabel("x")
+    ax.set_ylabel(r"$\psi(x)$", color="C0")
+    if V is not None:
+        ax2 = ax.twinx()
+        ax2.plot(x, V(x), color="C1", linestyle="--", label="V(x)")
+        ax2.set_ylabel("V(x)", color="C1")
+    return fig, ax

physicskit/statphys/__init__.py

@@ -0,0 +1,80 @@
+"""physicskit.statphys: interactive, computational statistical mechanics.
+
+``physicskit.statphys`` brings the core breakthroughs of statistical mechanics, lattice
+physics, critical phenomena, molecular dynamics, and disordered systems into
+a visual, computational Python framework:
+
+- **Lattice models** (:mod:`physicskit.statphys.chapters.ising_lattice`): the 2D Ising
+  model with Metropolis and Wolff-cluster dynamics, the q-state Potts model,
+  and the XY model's topological Kosterlitz-Thouless transition.
+- **Disordered systems** (:mod:`physicskit.statphys.chapters.spin_glass`): the
+  Edwards-Anderson Ising spin glass, with quenched bond disorder,
+  frustration, and the replica-overlap order parameter.
+- **Molecular dynamics** (:mod:`physicskit.statphys.chapters.molecular_dynamics`): a
+  Velocity-Verlet-integrated Lennard-Jones gas that relaxes toward the
+  Maxwell-Boltzmann distribution, with live tracking of Boltzmann's
+  H-function.
+- **Diffusion** (:mod:`physicskit.statphys.chapters.random_walk`): random walk
+  ensembles illustrating the Einstein relation and the central limit
+  theorem.
+- **Critical phenomena** (:mod:`physicskit.statphys.chapters.percolation`,
+  :mod:`physicskit.statphys.chapters.renormalization`, :mod:`physicskit.statphys.chapters.sandpile`):
+  site/bond percolation with Hoshen-Kopelman cluster labeling, Kadanoff
+  block-spin renormalization group coarse-graining, and the
+  self-organized-critical Bak-Tang-Wiesenfeld sandpile.
+- **Irreversibility** (:mod:`physicskit.statphys.chapters.ehrenfest_urn`): the
+  Ehrenfest urn model, the simplest system reconciling reversible
+  microscopic dynamics with an observed thermodynamic arrow of time.
+- **Replica symmetry breaking** (:mod:`physicskit.statphys.chapters.spin_glass`): the
+  infinite-range Sherrington-Kirkpatrick spin glass and its numerically
+  observable replica-overlap distribution.
+- **Interface growth** (:mod:`physicskit.statphys.chapters.kpz_growth`): the
+  Kardar-Parisi-Zhang universality class via Restricted Solid-On-Solid
+  deposition.
+- **Nonequilibrium work** (:mod:`physicskit.statphys.chapters.nonequilibrium_work`):
+  Jarzynski's equality, recovering exact equilibrium free energies from
+  irreversible, finite-speed work measurements.
+
+Examples
+--------
+>>> from physicskit.statphys.chapters import Ising2D
+>>> model = Ising2D(L=32, seed=0)
+>>> round(float(model.T_C), 3)
+2.269
+>>> model.sweep(beta=1.0 / model.T_C, n_sweeps=100)
+"""
+
+from physicskit.statphys.chapters import (
+    BlockSpinRG,
+    BTWSandpile,
+    EdwardsAndersonSpinGlass2D,
+    EhrenfestUrn,
+    Ising2D,
+    JarzynskiHarmonicTrap,
+    KPZInterface,
+    LennardJonesGas,
+    Percolation2D,
+    PottsModel2D,
+    RandomWalk,
+    SherringtonKirkpatrick,
+    XYModel2D,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "BTWSandpile",
+    "BlockSpinRG",
+    "EdwardsAndersonSpinGlass2D",
+    "EhrenfestUrn",
+    "Ising2D",
+    "JarzynskiHarmonicTrap",
+    "KPZInterface",
+    "LennardJonesGas",
+    "Percolation2D",
+    "PottsModel2D",
+    "RandomWalk",
+    "SherringtonKirkpatrick",
+    "XYModel2D",
+    "__version__",
+]

physicskit/statphys/chapters/__init__.py

@@ -0,0 +1,43 @@
+"""Physics chapters: user-facing model classes built on :mod:`physicskit.statphys.core`.
+
+- :mod:`physicskit.statphys.chapters.ising_lattice` -- Ising, Potts, and XY lattice spin models.
+- :mod:`physicskit.statphys.chapters.spin_glass` -- the Edwards-Anderson Ising spin glass and the
+  infinite-range Sherrington-Kirkpatrick model.
+- :mod:`physicskit.statphys.chapters.molecular_dynamics` -- Lennard-Jones gas and the H-theorem.
+- :mod:`physicskit.statphys.chapters.random_walk` -- random walks, diffusion, and the CLT.
+- :mod:`physicskit.statphys.chapters.percolation` -- site/bond percolation and cluster geometry.
+- :mod:`physicskit.statphys.chapters.renormalization` -- Kadanoff block-spin coarse-graining.
+- :mod:`physicskit.statphys.chapters.sandpile` -- the Bak-Tang-Wiesenfeld self-organized-critical sandpile.
+- :mod:`physicskit.statphys.chapters.ehrenfest_urn` -- the Ehrenfest urn model of statistical irreversibility.
+- :mod:`physicskit.statphys.chapters.kpz_growth` -- the Kardar-Parisi-Zhang universality class via
+  Restricted Solid-On-Solid interface growth.
+- :mod:`physicskit.statphys.chapters.nonequilibrium_work` -- Jarzynski's equality for a dragged
+  harmonic trap.
+"""
+
+from physicskit.statphys.chapters.ehrenfest_urn import EhrenfestUrn
+from physicskit.statphys.chapters.ising_lattice import Ising2D, PottsModel2D, XYModel2D
+from physicskit.statphys.chapters.kpz_growth import KPZInterface
+from physicskit.statphys.chapters.molecular_dynamics import LennardJonesGas
+from physicskit.statphys.chapters.nonequilibrium_work import JarzynskiHarmonicTrap
+from physicskit.statphys.chapters.percolation import Percolation2D
+from physicskit.statphys.chapters.random_walk import RandomWalk
+from physicskit.statphys.chapters.renormalization import BlockSpinRG
+from physicskit.statphys.chapters.sandpile import BTWSandpile
+from physicskit.statphys.chapters.spin_glass import EdwardsAndersonSpinGlass2D, SherringtonKirkpatrick
+
+__all__ = [
+    "BTWSandpile",
+    "BlockSpinRG",
+    "EdwardsAndersonSpinGlass2D",
+    "EhrenfestUrn",
+    "Ising2D",
+    "JarzynskiHarmonicTrap",
+    "KPZInterface",
+    "LennardJonesGas",
+    "Percolation2D",
+    "PottsModel2D",
+    "RandomWalk",
+    "SherringtonKirkpatrick",
+    "XYModel2D",
+]