FastLSQ 0.2.5__tar.gz → 0.2.6__tar.gz

{fastlsq-0.2.5 → fastlsq-0.2.6}/FastLSQ.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.2.5
+Version: 0.2.6
 Summary: One-shot PDE solving via Fourier features with exact analytical derivatives; rank-revealing solvers, learnable anisotropic bandwidth, and CPU/CUDA/MPS support
 Author: Antonin Sulc
 License-Expression: MIT

{fastlsq-0.2.5 → fastlsq-0.2.6}/FastLSQ.egg-info/SOURCES.txt

@@ -32,6 +32,17 @@ examples/run_nonlinear.py
 examples/tutorial_basic.py
 examples/tutorial_nonlinear.py
 examples/vector_basis_stream_vorticity.py
+examples/digital_twins/darcy_heat.py
+examples/digital_twins/pendulum.py
+examples/digital_twins/pendulum_benchmark.py
+examples/digital_twins/plasma_wakefield.py
+examples/digital_twins/plasma_wakefield_2D_1.py
+examples/digital_twins/plasma_wakefield_2D_2.py
+examples/digital_twins/plasma_wakefield_2d_3.py
+examples/digital_twins/plasma_wakefield_parameteric.py
+examples/digital_twins/plot_utils.py
+examples/digital_twins/structural_health_simple.py
+examples/digital_twins/turbulence_gravity_cooling.py
 examples/extras/fred_sde.py
 examples/extras/fred_sde_fastlsq.py
 examples/extras/gaia_potential.py
@@ -73,6 +84,18 @@ examples/extras/scenarios/s12_mems_resonator.py
 examples/extras/scenarios/s13_variable_stars_kepler.py
 examples/extras/scenarios/s14_eeg.py
 examples/extras/scenarios/s15_circadian.py
+examples/inverse/aero_.py
+examples/inverse/denoising_parameter_estimation.py
+examples/inverse/elastic_wave_animation.py
+examples/inverse/heat_from_video.py
+examples/inverse/inverse_turbulence.py
+examples/inverse/shape_ns.py
+examples/inverse/subsurface_imaging.py
+examples/inverse/wing_optimize_simple.py
+examples/sindy/compare_sindy_methods.py
+examples/sindy/sindy_benchmarks.py
+examples/sindy/sindy_differentiable.py
+examples/sindy/sindy_minimal_diff.py
 fastlsq/__init__.py
 fastlsq/api.py
 fastlsq/basis.py
@@ -95,6 +118,16 @@ fastlsq/problems/__init__.py
 fastlsq/problems/linear.py
 fastlsq/problems/nonlinear.py
 fastlsq/problems/regression.py
+misc/fastlsq_teaser.png
+misc/ideal_quadrupole.png
+misc/inverse_heat_source.gif
+misc/inverse_heat_source.png
+misc/inverse_magnetostatics.png
+misc/inverse_magnetostatics_convergence.png
+misc/quadrupole_convergence.png
+misc/quadrupole_optimization.png
+misc/tutorial_nlpoisson_convergence.png
+misc/tutorial_nlpoisson_solution.png
 tests/test_basic.py
 tests/test_benchmarks_inverse.py
 tests/test_block.py

{fastlsq-0.2.5 → fastlsq-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.2.5
+Version: 0.2.6
 Summary: One-shot PDE solving via Fourier features with exact analytical derivatives; rank-revealing solvers, learnable anisotropic bandwidth, and CPU/CUDA/MPS support
 Author: Antonin Sulc
 License-Expression: MIT

fastlsq-0.2.6/examples/digital_twins/darcy_heat.py

@@ -0,0 +1,583 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Antonin Sulc
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""
+Digital Twin: Darcy Flow + Heat (Porous Media).
+
+Coupled PDEs:
+  1. Darcy: ∇·(K∇p) = 0  →  pressure p, velocity u = −K∇p
+  2. Heat:  −k∇²T + u·∇T = Q  →  advection by Darcy flow
+
+Heat as tracer: Temperature observations reveal flow structure. Infer permeability
+K(x) from T—where flow is blocked (clog) or channeled, heat distribution changes.
+
+Domain [0,1]²: fluid flows left→right. Multiple heat sources; flow mixes/transports.
+Spatially varying K: low-K "clog" or high-K "channel" changes flow paths.
+
+USAGE
+-----
+  python darcy_heat.py
+  python darcy_heat.py --quick
+  python darcy_heat.py --inverse        # infer constant K from T
+  python darcy_heat.py --clog           # spatially varying K (clog)
+  python darcy_heat.py --clog --inverse # infer clog params from T
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+import numpy as np
+import torch
+from scipy.optimize import minimize_scalar, minimize
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+from fastlsq.solvers import FastLSQSolver
+from fastlsq.linalg import solve_lstsq
+from fastlsq.geometry import sample_box
+from fastlsq.utils import device, setup
+
+try:
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    from plot_utils import paper_style, panel_label, COLORS
+    HAS_MPL = True
+except ImportError:
+    HAS_MPL = False
+
+
+# =============================================================================
+# Configuration
+# =============================================================================
+
+K_DARCY = 1.0       # permeability (constant or base value)
+K_THERMAL = 1.0     # thermal diffusivity
+P_IN = 1.0          # pressure at inlet (x=0)
+P_OUT = 0.0         # pressure at outlet (x=1)
+SOURCE_SIGMA = 0.08
+# Multiple sources: (cx, cy, strength) — flow mixes and transports heat from each
+SOURCES = [(0.25, 0.4, 2.5), (0.5, 0.7, 2.0), (0.75, 0.35, 1.5)]
+# Clog: K(x) = K0 * (1 - A*exp(-r²/(2σ²))), r²=(x-cx)²+(y-cy)²
+CLOG_CX, CLOG_CY = 0.5, 0.5
+CLOG_A = 0.75      # strength of clog (K drops to 0.25*K0 at center)
+CLOG_SIGMA = 0.15  # extent of clog
+N_FEAT = 400
+SIGMA_BASIS = 6.0
+M_PDE_DARCY = 2000
+M_BC_DARCY = 400
+M_PDE_HEAT = 2000
+M_BC_HEAT = 400
+
+
+# =============================================================================
+# Domain sampling
+# =============================================================================
+
+def sample_domain(n_int, n_in, n_out, n_top, n_bot):
+    """Sample [0,1]²: interior, inlet (x=0), outlet (x=1), top (y=1), bottom (y=0)."""
+    x_int = sample_box(n_int, 2)
+    x_in = torch.rand(n_in, 2, device=device)
+    x_in[:, 0] = 0.0
+    x_out = torch.rand(n_out, 2, device=device)
+    x_out[:, 0] = 1.0
+    x_top = torch.rand(n_top, 2, device=device)
+    x_top[:, 1] = 1.0
+    x_bot = torch.rand(n_bot, 2, device=device)
+    x_bot[:, 1] = 0.0
+    return {"x_int": x_int, "x_in": x_in, "x_out": x_out, "x_top": x_top, "x_bot": x_bot}
+
+
+# =============================================================================
+# Permeability: constant or spatially varying (clog)
+# =============================================================================
+
+def permeability(x, K0=K_DARCY, clog_params=None):
+    """K(x) = K0 for constant; K0*(1 - A*exp(-r²/(2σ²))) for clog."""
+    if clog_params is None:
+        return K0 * torch.ones(x.shape[0], 1, device=x.device, dtype=x.dtype)
+    cx, cy, A, sig = clog_params
+    xv, yv = x[:, 0:1], x[:, 1:2]
+    r2 = (xv - cx) ** 2 + (yv - cy) ** 2
+    return K0 * (1.0 - A * torch.exp(-r2 / (2 * sig ** 2)))
+
+
+def permeability_grad(x, K0=K_DARCY, clog_params=None):
+    """∇K at x. Returns (dK/dx, dK/dy) each shape (n,1)."""
+    if clog_params is None:
+        return torch.zeros(x.shape[0], 1, device=x.device, dtype=x.dtype), \
+               torch.zeros(x.shape[0], 1, device=x.device, dtype=x.dtype)
+    cx, cy, A, sig = clog_params
+    xv, yv = x[:, 0:1], x[:, 1:2]
+    r2 = (xv - cx) ** 2 + (yv - cy) ** 2
+    g = K0 * A * torch.exp(-r2 / (2 * sig ** 2)) / (sig ** 2)
+    dK_dx = -g * (xv - cx)
+    dK_dy = -g * (yv - cy)
+    return dK_dx, dK_dy
+
+
+# =============================================================================
+# Darcy flow: ∇·(K∇p) = 0, u = −K∇p
+# =============================================================================
+
+def solve_darcy(solver_p, K, pts, clog_params=None):
+    """
+    Solve ∇·(K∇p) = 0. For constant K: −K∇²p = 0.
+    For variable K: K∇²p + ∇K·∇p = 0.
+    BC: p = P_IN at inlet, p = P_OUT at outlet, ∂p/∂y = 0 on top/bottom.
+    """
+    basis = solver_p.basis
+    x_int = pts["x_int"]
+    cache = basis.cache(x_int)
+    lap = basis.laplacian(x_int, cache=cache)
+    dH = basis.gradient(x_int, cache=cache)
+    dH_dx, dH_dy = dH[:, 0, :], dH[:, 1, :]
+
+    if clog_params is None:
+        A_pde = -K * lap
+    else:
+        K_val = permeability(x_int, K, clog_params)
+        dK_dx, dK_dy = permeability_grad(x_int, K, clog_params)
+        # K∇²p + ∇K·∇p = 0  =>  K*lap + dK_dx*dH_dx + dK_dy*dH_dy
+        A_pde = K_val * lap + dK_dx * dH_dx + dK_dy * dH_dy
+    b_pde = torch.zeros(len(x_int), 1, device=device, dtype=x_int.dtype)
+
+    # BC: inlet p = P_IN
+    H_in = basis.evaluate(pts["x_in"])
+    A_in = H_in * 150.0
+    b_in = torch.full((len(pts["x_in"]), 1), P_IN * 150.0, device=device, dtype=pts["x_int"].dtype)
+
+    # BC: outlet p = P_OUT
+    H_out = basis.evaluate(pts["x_out"])
+    A_out = H_out * 150.0
+    b_out = torch.full((len(pts["x_out"]), 1), P_OUT * 150.0, device=device, dtype=pts["x_int"].dtype)
+
+    # BC: top/bottom ∂p/∂y = 0 (no flow through walls)
+    dH_top = basis.gradient(pts["x_top"], cache=basis.cache(pts["x_top"]))[:, 1, :]
+    dH_bot = basis.gradient(pts["x_bot"], cache=basis.cache(pts["x_bot"]))[:, 1, :]
+    A_top = dH_top * 100.0
+    A_bot = dH_bot * 100.0
+    b_top = torch.zeros(len(pts["x_top"]), 1, device=device, dtype=pts["x_int"].dtype)
+    b_bot = torch.zeros(len(pts["x_bot"]), 1, device=device, dtype=pts["x_int"].dtype)
+
+    A = torch.cat([A_pde, A_in, A_out, A_top, A_bot])
+    b = torch.cat([b_pde, b_in, b_out, b_top, b_bot])
+    solver_p.beta = solve_lstsq(A, b, mu=1e-10)
+    return solver_p.beta
+
+
+def get_velocity_at(solver_p, K, pts, clog_params=None):
+    """Darcy velocity: u = −K∇p (K constant or K(x))."""
+    dH = solver_p.basis.gradient(pts, cache=solver_p.basis.cache(pts))
+    grad_p_x = dH[:, 0, :] @ solver_p.beta
+    grad_p_y = dH[:, 1, :] @ solver_p.beta
+    K_val = permeability(pts, K, clog_params)
+    u = (-K_val * grad_p_x).squeeze(-1)
+    v = (-K_val * grad_p_y).squeeze(-1)
+    return u, v
+
+
+# =============================================================================
+# Heat equation: −k∇²T + u·∇T = Q
+# =============================================================================
+
+def heat_source_multi(x, sources=SOURCES, sigma=SOURCE_SIGMA):
+    """Sum of Gaussian sources. sources = [(cx, cy, strength), ...]."""
+    xv, yv = x[:, 0:1], x[:, 1:2]
+    f = torch.zeros_like(xv)
+    for cx, cy, strength in sources:
+        f = f + strength * torch.exp(-((xv - cx) ** 2 + (yv - cy) ** 2) / (2 * sigma ** 2))
+    return f
+
+
+def solve_heat_advection(solver_T, solver_p, K, x_pde, x_bc_dir, x_bc_outflow,
+                        sources=SOURCES, clog_params=None):
+    """
+    Solve −k∇²T + u·∇T = Q.
+    u from Darcy. Dirichlet T=0 on 3 edges, outflow (zero gradient) at outlet.
+    """
+    x_all = torch.cat([x_pde, x_bc_dir, x_bc_outflow])
+    u_all, v_all = get_velocity_at(solver_p, K, x_all, clog_params)
+    n_pde = len(x_pde)
+    u_pde = u_all[:n_pde]
+    v_pde = v_all[:n_pde]
+
+    basis = solver_T.basis
+    cache = basis.cache(x_pde)
+    lap = basis.laplacian(x_pde, cache=cache)
+    dH = basis.gradient(x_pde, cache=cache)
+    dH_dx = dH[:, 0, :]
+    dH_dy = dH[:, 1, :]
+
+    # PDE: −k∇²T + u·∇T = Q
+    # u·∇T = u_x * dT/dx + u_y * dT/dy
+    adv = u_pde.unsqueeze(1) * dH_dx + v_pde.unsqueeze(1) * dH_dy
+    A_pde = -K_THERMAL * lap + adv
+    b_pde = heat_source_multi(x_pde, sources)
+
+    As, bs = [A_pde], [b_pde]
+
+    # Dirichlet T=0 on left, top, bottom
+    H_dir = basis.evaluate(x_bc_dir)
+    As.append(H_dir * 100.0)
+    bs.append(torch.zeros(len(x_bc_dir), 1, device=device, dtype=x_pde.dtype))
+
+    # Outflow at outlet: convective BC or zero gradient
+    # Use ∂T/∂x + (u/k)*T = 0 for advection-dominated outflow (simplified)
+    # Simpler: zero gradient ∂T/∂x = 0
+    dH_out = basis.gradient(x_bc_outflow, cache=basis.cache(x_bc_outflow))[:, 0, :]
+    As.append(dH_out * 100.0)
+    bs.append(torch.zeros(len(x_bc_outflow), 1, device=device, dtype=x_pde.dtype))
+
+    A = torch.cat(As)
+    b = torch.cat(bs)
+    solver_T.beta = solve_lstsq(A, b, mu=1e-10)
+    return solver_T.beta
+
+
+# =============================================================================
+# Inverse: infer permeability from temperature (heat as tracer)
+# =============================================================================
+
+def run_inverse_constant_K(solver_p, solver_T, pts_darcy, x_pde, x_bc_dir, x_bc_outflow,
+                           K_true, sources=SOURCES, n_obs=80, noise=0.01):
+    """Infer constant K from temperature observations (heat as tracer)."""
+    solve_darcy(solver_p, K_true, pts_darcy, None)
+    solve_heat_advection(solver_T, solver_p, K_true, x_pde, x_bc_dir, x_bc_outflow, sources, None)
+
+    x_obs = sample_box(n_obs, 2)
+    T_obs = solver_T.predict(x_obs).detach().cpu().numpy()
+    T_obs = T_obs + noise * np.std(T_obs) * np.random.randn(*T_obs.shape)
+    x_obs_np = x_obs.detach().cpu().numpy()
+
+    def loss(K_val):
+        K = float(np.clip(K_val, 0.2, 5.0))
+        solve_darcy(solver_p, K, pts_darcy, None)
+        solve_heat_advection(solver_T, solver_p, K, x_pde, x_bc_dir, x_bc_outflow, sources, None)
+        T_pred = solver_T.predict(torch.tensor(x_obs_np, device=device, dtype=torch.float64)).detach().cpu().numpy()
+        return float(np.mean((T_pred - T_obs) ** 2))
+
+    res = minimize_scalar(loss, bounds=(0.2, 5.0), method="bounded", options={"maxiter": 100})
+    K_inferred = float(np.clip(res.x, 0.2, 5.0))
+    return K_true, K_inferred, x_obs_np, T_obs
+
+
+def sample_obs_with_interior_density(n_uniform, n_interior, box=(0.25, 0.75)):
+    """Uniform samples + dense sampling in interior [box, box]² where clog effects are strongest."""
+    x_uni = sample_box(n_uniform, 2)
+    lo, hi = box
+    x_int = torch.rand(n_interior, 2, device=device, dtype=torch.float64)
+    x_int[:, 0] = lo + (hi - lo) * x_int[:, 0]
+    x_int[:, 1] = lo + (hi - lo) * x_int[:, 1]
+    return torch.cat([x_uni, x_int], dim=0)
+
+
+def run_inverse_clog(solver_p, solver_T, pts_darcy, x_pde, x_bc_dir, x_bc_outflow,
+                     clog_true, sources=SOURCES, n_obs=200, n_near=80, noise=0.01,
+                     n_restarts=5):
+    """Infer clog params (cx, cy, A, σ) from T. Heat reveals where flow is blocked."""
+    cx_t, cy_t, A_t, sig_t = clog_true
+    solve_darcy(solver_p, K_DARCY, pts_darcy, clog_true)
+    solve_heat_advection(solver_T, solver_p, K_DARCY, x_pde, x_bc_dir, x_bc_outflow, sources, clog_true)
+
+    # More observations: uniform + dense in interior [0.25, 0.75]² where clog perturbs flow
+    x_obs = sample_obs_with_interior_density(n_obs - n_near, n_near, box=(0.25, 0.75))
+    T_obs = solver_T.predict(x_obs).detach().cpu().numpy()
+    T_obs = T_obs + noise * np.std(T_obs) * np.random.randn(*T_obs.shape)
+    x_obs_np = x_obs.detach().cpu().numpy()
+
+    def loss(params):
+        cx, cy, A, sig = np.clip(params[0], 0.2, 0.8), np.clip(params[1], 0.2, 0.8), \
+                         np.clip(params[2], 0.3, 0.95), np.clip(params[3], 0.06, 0.25)
+        cp = (float(cx), float(cy), float(A), float(sig))
+        solve_darcy(solver_p, K_DARCY, pts_darcy, cp)
+        solve_heat_advection(solver_T, solver_p, K_DARCY, x_pde, x_bc_dir, x_bc_outflow, sources, cp)
+        T_pred = solver_T.predict(torch.tensor(x_obs_np, device=device, dtype=torch.float64)).detach().cpu().numpy()
+        return float(np.mean((T_pred - T_obs) ** 2))
+
+    bounds = [(0.2, 0.8), (0.2, 0.8), (0.3, 0.95), (0.06, 0.25)]
+    starts = [
+        [0.5, 0.5, 0.7, 0.14],
+        [0.4, 0.5, 0.6, 0.12],
+        [0.6, 0.5, 0.6, 0.12],
+        [0.5, 0.4, 0.5, 0.15],
+        [0.5, 0.6, 0.8, 0.10],
+        [0.5, 0.5, 0.8, 0.12],
+        [0.5, 0.5, 0.6, 0.18],
+        [0.3, 0.3, 0.8, 0.15],
+        [0.7, 0.7, 0.5, 0.10],
+        [0.4, 0.6, 0.7, 0.20],
+        [0.6, 0.4, 0.9, 0.08],
+        [0.5, 0.5, 0.5, 0.10],
+    ][:n_restarts]
+    best_res, best_loss = None, float("inf")
+    for x0 in starts:
+        res = minimize(loss, x0, method="L-BFGS-B", bounds=bounds, options={"maxiter": 120})
+        L = loss(res.x)
+        if L < best_loss:
+            best_loss = L
+            best_res = res
+    res = best_res
+    cx_i = float(np.clip(res.x[0], 0.2, 0.8))
+    cy_i = float(np.clip(res.x[1], 0.2, 0.8))
+    A_i = float(np.clip(res.x[2], 0.3, 0.95))
+    sig_i = float(np.clip(res.x[3], 0.06, 0.25))
+    clog_inferred = (cx_i, cy_i, A_i, sig_i)
+    return clog_true, clog_inferred, x_obs_np, T_obs
+
+
+# =============================================================================
+# Main
+# =============================================================================
+
+def run_darcy_heat(quick=False, inverse=False, clog=False, seed=42):
+    setup(dtype=torch.float64)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+
+    m_darcy = M_PDE_DARCY // 2 if quick else M_PDE_DARCY
+    m_bc_d = M_BC_DARCY // 2 if quick else M_BC_DARCY
+    m_heat = M_PDE_HEAT // 2 if quick else M_PDE_HEAT
+    m_bc_h = M_BC_HEAT // 2 if quick else M_BC_HEAT
+
+    pts_darcy = sample_domain(m_darcy, m_bc_d, m_bc_d, m_bc_d, m_bc_d)
+
+    solver_p = FastLSQSolver(2, normalize=False)
+    solver_p.add_block(hidden_size=N_FEAT, scale=SIGMA_BASIS)
+
+    x_pde = sample_box(m_heat, 2)
+    x_left = torch.rand(m_bc_h // 3, 2, device=device)
+    x_left[:, 0] = 0.0
+    x_right = torch.rand(m_bc_h // 3, 2, device=device)
+    x_right[:, 0] = 1.0
+    x_bot_h = torch.rand(m_bc_h // 3, 2, device=device)
+    x_bot_h[:, 1] = 0.0
+    x_top_h = torch.rand(m_bc_h // 3, 2, device=device)
+    x_top_h[:, 1] = 1.0
+    x_bc_dir = torch.cat([x_left, x_bot_h, x_top_h])
+    x_bc_outflow = torch.rand(m_bc_h // 3, 2, device=device)
+    x_bc_outflow[:, 0] = 1.0
+
+    solver_T = FastLSQSolver(2, normalize=False)
+    solver_T.add_block(hidden_size=N_FEAT, scale=SIGMA_BASIS)
+
+    K = K_DARCY
+    clog_params = None
+    clog_true = None
+    clog_inferred = None
+
+    if clog:
+        clog_params = (CLOG_CX, CLOG_CY, CLOG_A, CLOG_SIGMA)
+
+    solve_darcy(solver_p, K, pts_darcy, clog_params)
+    solve_heat_advection(solver_T, solver_p, K, x_pde, x_bc_dir, x_bc_outflow, SOURCES, clog_params)
+
+    print("Darcy + Heat (Porous Media) - Digital Twin")
+    print("=" * 60)
+    print("Heat as tracer: T reveals flow structure → infer K(x)")
+    print("1. Darcy: ∇·(K∇p) = 0, u = −K∇p")
+    print("2. Heat:  −k∇²T + u·∇T = Q (multiple sources)")
+    print("3. Coupling: flow distributes heat; T encodes where flow is blocked/channeled")
+    print()
+
+    if inverse:
+        if clog:
+            clog_true = (CLOG_CX, CLOG_CY, CLOG_A, CLOG_SIGMA)
+            n_r = 3 if quick else 12
+            clog_true, clog_inferred, x_obs, T_obs = run_inverse_clog(
+                solver_p, solver_T, pts_darcy, x_pde, x_bc_dir, x_bc_outflow,
+                clog_true, SOURCES, n_obs=300, n_near=120, noise=0.01, n_restarts=n_r
+            )
+            solve_darcy(solver_p, K, pts_darcy, clog_inferred)
+            solve_heat_advection(solver_T, solver_p, K, x_pde, x_bc_dir, x_bc_outflow, SOURCES, clog_inferred)
+            print(f"Inverse (clog): cx {clog_true[0]:.2f}→{clog_inferred[0]:.2f}, "
+                  f"cy {clog_true[1]:.2f}→{clog_inferred[1]:.2f}, "
+                  f"A {clog_true[2]:.2f}→{clog_inferred[2]:.2f}, σ {clog_true[3]:.2f}→{clog_inferred[3]:.2f}")
+        else:
+            K_true = 1.5
+            K_true, K_inferred, x_obs, T_obs = run_inverse_constant_K(
+                solver_p, solver_T, pts_darcy, x_pde, x_bc_dir, x_bc_outflow, K_true,
+                SOURCES, n_obs=80, noise=0.01
+            )
+            solve_darcy(solver_p, K_inferred, pts_darcy, None)
+            solve_heat_advection(solver_T, solver_p, K_inferred, x_pde, x_bc_dir, x_bc_outflow, SOURCES, None)
+            print(f"Inverse: K_true = {K_true:.3f}, K_inferred = {K_inferred:.3f}")
+    else:
+        K_inferred = None
+
+    # Evaluation grid
+    xx = np.linspace(0.05, 0.95, 40)
+    yy = np.linspace(0.05, 0.95, 40)
+    X, Y = np.meshgrid(xx, yy)
+    pts = torch.tensor(np.c_[X.ravel(), Y.ravel()], device=device, dtype=torch.float64)
+
+    eff_K = K_inferred if inverse and not clog else K
+    eff_clog = clog_inferred if inverse and clog else clog_params
+    u, v = get_velocity_at(solver_p, eff_K, pts, eff_clog)
+    U = u.detach().cpu().numpy().reshape(X.shape)
+    V = v.detach().cpu().numpy().reshape(X.shape)
+    P = solver_p.predict(pts).detach().cpu().numpy().reshape(X.shape)
+    T = solver_T.predict(pts).detach().cpu().numpy().reshape(X.shape)
+
+    print(f"Pressure range: [{P.min():.3f}, {P.max():.3f}]")
+    print(f"Velocity |u|_max: {np.sqrt(U**2 + V**2).max():.4f}")
+    print(f"Temperature range: [{T.min():.3f}, {T.max():.3f}]")
+    print()
+
+    if HAS_MPL:
+        paper_style()
+        fig, axes = plt.subplots(2, 2, figsize=(8, 6.5))
+
+        # (a) Darcy flow (pressure + streamlines)
+        ax = axes[0, 0]
+        speed = np.sqrt(U ** 2 + V ** 2)
+        ax.contourf(X, Y, P, levels=20, cmap="viridis")
+        ax.streamplot(X, Y, U, V, color="white", density=1.2, linewidth=0.8)
+        plt.colorbar(ax.collections[0], ax=ax, label="p")
+        ax.set_xlabel("x")
+        ax.set_ylabel("y")
+        ax.set_title("Darcy: pressure & flow")
+        ax.set_aspect("equal")
+        panel_label(ax, "a")
+
+        # (b) Temperature (heat as tracer: reveals flow paths)
+        ax = axes[0, 1]
+        im = ax.contourf(X, Y, T, levels=25, cmap="hot")
+        for cx, cy, _ in SOURCES:
+            ax.scatter([cx], [cy], c="cyan", s=80, marker="*", edgecolors="white")
+        plt.colorbar(im, ax=ax, label="T")
+        ax.set_xlabel("x")
+        ax.set_ylabel("y")
+        ax.set_title("Heat as tracer (flow distributes sources)")
+        ax.set_aspect("equal")
+        panel_label(ax, "b")
+
+        # (c) Velocity magnitude or K(x) for clog
+        ax = axes[1, 0]
+        if clog or clog_inferred:
+            cp = eff_clog
+            K_field = permeability(pts, K_DARCY, cp).detach().cpu().numpy().reshape(X.shape)
+            im = ax.contourf(X, Y, K_field, levels=20, cmap="YlOrBr")
+            ax.streamplot(X, Y, U, V, color="black", density=1.0, linewidth=0.5)
+            plt.colorbar(im, ax=ax, label="K(x)")
+            ax.set_title("Permeability K(x) & flow")
+        else:
+            speed_flat = np.sqrt(U ** 2 + V ** 2)
+            im = ax.contourf(X, Y, speed_flat, levels=20, cmap="Blues")
+            ax.streamplot(X, Y, U, V, color="black", density=1.0, linewidth=0.5)
+            plt.colorbar(im, ax=ax, label="|u|")
+            ax.set_title("Darcy velocity")
+        ax.set_xlabel("x")
+        ax.set_ylabel("y")
+        ax.set_aspect("equal")
+        panel_label(ax, "c")
+
+        # (d) Inferred K(x) or velocity magnitude
+        ax = axes[1, 1]
+        if inverse and clog and clog_inferred is not None:
+            K_inf_field = permeability(pts, K_DARCY, clog_inferred)
+            K_inf_2d = K_inf_field.detach().cpu().numpy().reshape(X.shape)
+            im = ax.contourf(X, Y, K_inf_2d, levels=20, cmap="YlOrBr")
+            u_inf, v_inf = get_velocity_at(solver_p, K, pts, clog_inferred)
+            U_inf = u_inf.detach().cpu().numpy().reshape(X.shape)
+            V_inf = v_inf.detach().cpu().numpy().reshape(X.shape)
+            ax.streamplot(X, Y, U_inf, V_inf, color="black", density=1.0, linewidth=0.5)
+            plt.colorbar(im, ax=ax, label="$K(x)$")
+            ax.set_title("Inferred permeability $K(x)$")
+        else:
+            speed_flat = np.sqrt(U ** 2 + V ** 2)
+            im = ax.contourf(X, Y, speed_flat, levels=20, cmap="Blues")
+            ax.streamplot(X, Y, U, V, color="black", density=1.0, linewidth=0.5)
+            plt.colorbar(im, ax=ax, label="$|u|$")
+            ax.set_title("Darcy velocity $|u|$")
+        ax.set_xlabel("x")
+        ax.set_ylabel("y")
+        ax.set_aspect("equal")
+        panel_label(ax, "d")
+
+        plt.tight_layout()
+        out_dir = os.path.join(os.path.dirname(__file__), "output")
+        os.makedirs(out_dir, exist_ok=True)
+        if inverse:
+            fname = "darcy_heat_clog_inverse.pdf" if clog else "darcy_heat_inverse.pdf"
+        else:
+            fname = "darcy_heat_clog.pdf" if clog else "darcy_heat.pdf"
+        plt.savefig(os.path.join(out_dir, fname), dpi=300, bbox_inches="tight")
+        plt.close()
+        print(f"Saved {out_dir}/{fname}")
+
+    return {"K": K, "clog": clog_inferred if (inverse and clog) else clog_params,
+            "P": P, "T": T, "U": U, "V": V}
+
+
+def run_paper_benchmark(n_runs=5, base_seed=0, quick=False):
+    """Run clog inverse multiple times with different seeds; save JSON results."""
+    import json
+    all_results = []
+    for i in range(n_runs):
+        seed = base_seed + i
+        print(f"\n--- Run {i+1}/{n_runs} (seed={seed}) ---")
+        result = run_darcy_heat(quick=quick, inverse=True, clog=True, seed=seed)
+        clog_rec = result["clog"]
+        all_results.append({
+            "seed": seed,
+            "cx": round(clog_rec[0], 4),
+            "cy": round(clog_rec[1], 4),
+            "A": round(clog_rec[2], 4),
+            "sigma": round(clog_rec[3], 4),
+        })
+
+    cxs = [r["cx"] for r in all_results]
+    cys = [r["cy"] for r in all_results]
+    As = [r["A"] for r in all_results]
+    sigs = [r["sigma"] for r in all_results]
+    summary = {
+        "true": {"cx": CLOG_CX, "cy": CLOG_CY, "A": CLOG_A, "sigma": CLOG_SIGMA},
+        "runs": all_results,
+        "mean": {
+            "cx": round(float(np.mean(cxs)), 4),
+            "cy": round(float(np.mean(cys)), 4),
+            "A": round(float(np.mean(As)), 4),
+            "sigma": round(float(np.mean(sigs)), 4),
+        },
+        "std": {
+            "cx": round(float(np.std(cxs)), 4),
+            "cy": round(float(np.std(cys)), 4),
+            "A": round(float(np.std(As)), 4),
+            "sigma": round(float(np.std(sigs)), 4),
+        },
+    }
+    out_dir = os.path.join(os.path.dirname(__file__), "output")
+    os.makedirs(out_dir, exist_ok=True)
+    out_path = os.path.join(out_dir, "darcy_heat_benchmark.json")
+    with open(out_path, "w") as f:
+        json.dump(summary, f, indent=2)
+
+    print("\n" + "=" * 60)
+    print("Darcy--heat clog benchmark results:")
+    for param in ["cx", "cy", "A", "sigma"]:
+        t = summary["true"][param]
+        m = summary["mean"][param]
+        s = summary["std"][param]
+        print(f"  {param}: true={t:.4f}, recovered={m:.4f} ± {s:.4f}")
+    print(f"Saved to {out_path}")
+    return summary
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--quick", action="store_true")
+    parser.add_argument("--inverse", action="store_true", help="Infer K from T (heat as tracer)")
+    parser.add_argument("--clog", action="store_true", help="Spatially varying K (clog); infer clog params")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    parser.add_argument("--n-runs", type=int, default=1,
+                        help="Number of runs for benchmark (implies --clog --inverse)")
+    args = parser.parse_args()
+
+    if args.n_runs > 1:
+        run_paper_benchmark(n_runs=args.n_runs, base_seed=args.seed, quick=args.quick)
+    else:
+        run_darcy_heat(quick=args.quick, inverse=args.inverse, clog=args.clog, seed=args.seed)