FastLSQ 0.1.2__tar.gz → 0.1.4__tar.gz

{fastlsq-0.1.2 → fastlsq-0.1.4}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to FastLSQ will be documented in this file.
 
+## [Unreleased]
+
+### Added
+
+- **Learnable operator coefficients**: `Op` now accepts `nn.Parameter` (and tensors) as coefficients in scalar multiplication. Use `k = nn.Parameter(...)` with `Op.laplacian(d=2) + k**2 * Op.identity(d=2)` and optimise via AdamW; gradients flow through the prebuilt linear solve. See `examples/learnable_helmholtz.py`.
+
 ## [0.2.0] - 2026-03-01
 
 ### Added

{fastlsq-0.1.2 → fastlsq-0.1.4/FastLSQ.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.1.2
+Version: 0.1.4
 Summary: Solving PDEs in one shot via Fourier features with exact analytical derivatives
 Author: Antonin Sulc
 License-Expression: MIT
@@ -96,6 +96,7 @@ print(f"Value error: {result['metrics']['val_err']:.2e}")
 ### Use the basis directly
 
 ```python
+import torch
 from fastlsq.basis import SinusoidalBasis
 
 basis = SinusoidalBasis.random(input_dim=2, n_features=1500, sigma=5.0)
@@ -113,8 +114,14 @@ lap_H = basis.laplacian(x)           # (5000, 1500)
 ### Compose PDE operators symbolically
 
 ```python
-from fastlsq.basis import Op
+import torch
+from fastlsq.basis import SinusoidalBasis, Op
 
+basis = SinusoidalBasis.random(input_dim=2, n_features=1500, sigma=5.0)
+x = torch.rand(5000, 2)
+
+# Coefficients can be scalars or nn.Parameter (for AdamW optimisation)
+k, c = 10.0, 2.0
 helmholtz = Op.laplacian(d=2) + k**2 * Op.identity(d=2)
 A_pde = helmholtz.apply(basis, x)    # (5000, 1500)
 
@@ -138,6 +145,9 @@ python examples/run_linear.py
 
 # Nonlinear PDE benchmark (Newton-Raphson)
 python examples/run_nonlinear.py
+
+# Learnable Helmholtz wavenumber (nn.Parameter + AdamW)
+python examples/learnable_helmholtz.py
 ```
 
 ### Inverse problems
@@ -163,7 +173,7 @@ derivative engine:
 |-------|---------|
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
-| `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar * |
+| `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -242,9 +252,10 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 ## Features
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
-- **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic
+- **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Learnable bandwidth**: `LearnableFastLSQ` optimises the bandwidth (scalar or anisotropic) via reparameterisation
+- **Learnable PDE coefficients**: Plug `nn.Parameter` into `Op` (e.g. Helmholtz wavenumber `k`) and optimise via AdamW; gradients flow through the prebuilt linear solve
 - **Auto-tuning**: Automatic scale selection via grid search
 - **Built-in plotting**: Solution visualization, convergence plots, spectral sensitivity
 - **Geometry samplers**: Box, ball, sphere, interval, custom samplers

{fastlsq-0.1.2 → fastlsq-0.1.4}/FastLSQ.egg-info/SOURCES.txt

@@ -10,23 +10,30 @@ FastLSQ.egg-info/dependency_links.txt
 FastLSQ.egg-info/requires.txt
 FastLSQ.egg-info/top_level.txt
 examples/add_your_own_pde.py
-examples/apebench_compare.py
 examples/benchmark_comparison.py
-examples/compare_sindy_methods.py
 examples/custom_features.py
 examples/inverse_heat_source.py
 examples/inverse_magnetostatics.py
 examples/inverse_source_position.py
+examples/learnable_helmholtz.py
 examples/pde_discovery.py
 examples/run_all_extensions.py
 examples/run_linear.py
 examples/run_nonlinear.py
-examples/sindy_benchmarks.py
-examples/sindy_differentiable.py
-examples/sindy_minimal_diff.py
 examples/tutorial_basic.py
 examples/tutorial_nonlinear.py
-examples/wing_aerodynamics.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
@@ -42,7 +49,6 @@ fastlsq/solvers.py
 fastlsq/tuning.py
 fastlsq/utils.py
 fastlsq/problems/__init__.py
-fastlsq/problems/apebench.py
 fastlsq/problems/linear.py
 fastlsq/problems/nonlinear.py
 fastlsq/problems/regression.py

{fastlsq-0.1.2/FastLSQ.egg-info → fastlsq-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.1.2
+Version: 0.1.4
 Summary: Solving PDEs in one shot via Fourier features with exact analytical derivatives
 Author: Antonin Sulc
 License-Expression: MIT
@@ -96,6 +96,7 @@ print(f"Value error: {result['metrics']['val_err']:.2e}")
 ### Use the basis directly
 
 ```python
+import torch
 from fastlsq.basis import SinusoidalBasis
 
 basis = SinusoidalBasis.random(input_dim=2, n_features=1500, sigma=5.0)
@@ -113,8 +114,14 @@ lap_H = basis.laplacian(x)           # (5000, 1500)
 ### Compose PDE operators symbolically
 
 ```python
-from fastlsq.basis import Op
+import torch
+from fastlsq.basis import SinusoidalBasis, Op
 
+basis = SinusoidalBasis.random(input_dim=2, n_features=1500, sigma=5.0)
+x = torch.rand(5000, 2)
+
+# Coefficients can be scalars or nn.Parameter (for AdamW optimisation)
+k, c = 10.0, 2.0
 helmholtz = Op.laplacian(d=2) + k**2 * Op.identity(d=2)
 A_pde = helmholtz.apply(basis, x)    # (5000, 1500)
 
@@ -138,6 +145,9 @@ python examples/run_linear.py
 
 # Nonlinear PDE benchmark (Newton-Raphson)
 python examples/run_nonlinear.py
+
+# Learnable Helmholtz wavenumber (nn.Parameter + AdamW)
+python examples/learnable_helmholtz.py
 ```
 
 ### Inverse problems
@@ -163,7 +173,7 @@ derivative engine:
 |-------|---------|
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
-| `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar * |
+| `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -242,9 +252,10 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 ## Features
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
-- **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic
+- **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Learnable bandwidth**: `LearnableFastLSQ` optimises the bandwidth (scalar or anisotropic) via reparameterisation
+- **Learnable PDE coefficients**: Plug `nn.Parameter` into `Op` (e.g. Helmholtz wavenumber `k`) and optimise via AdamW; gradients flow through the prebuilt linear solve
 - **Auto-tuning**: Automatic scale selection via grid search
 - **Built-in plotting**: Solution visualization, convergence plots, spectral sensitivity
 - **Geometry samplers**: Box, ball, sphere, interval, custom samplers

{fastlsq-0.1.2 → fastlsq-0.1.4}/README.md

@@ -60,6 +60,7 @@ print(f"Value error: {result['metrics']['val_err']:.2e}")
 ### Use the basis directly
 
 ```python
+import torch
 from fastlsq.basis import SinusoidalBasis
 
 basis = SinusoidalBasis.random(input_dim=2, n_features=1500, sigma=5.0)
@@ -77,8 +78,14 @@ lap_H = basis.laplacian(x)           # (5000, 1500)
 ### Compose PDE operators symbolically
 
 ```python
-from fastlsq.basis import Op
+import torch
+from fastlsq.basis import SinusoidalBasis, Op
 
+basis = SinusoidalBasis.random(input_dim=2, n_features=1500, sigma=5.0)
+x = torch.rand(5000, 2)
+
+# Coefficients can be scalars or nn.Parameter (for AdamW optimisation)
+k, c = 10.0, 2.0
 helmholtz = Op.laplacian(d=2) + k**2 * Op.identity(d=2)
 A_pde = helmholtz.apply(basis, x)    # (5000, 1500)
 
@@ -102,6 +109,9 @@ python examples/run_linear.py
 
 # Nonlinear PDE benchmark (Newton-Raphson)
 python examples/run_nonlinear.py
+
+# Learnable Helmholtz wavenumber (nn.Parameter + AdamW)
+python examples/learnable_helmholtz.py
 ```
 
 ### Inverse problems
@@ -127,7 +137,7 @@ derivative engine:
 |-------|---------|
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
-| `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar * |
+| `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -206,9 +216,10 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 ## Features
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
-- **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic
+- **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Learnable bandwidth**: `LearnableFastLSQ` optimises the bandwidth (scalar or anisotropic) via reparameterisation
+- **Learnable PDE coefficients**: Plug `nn.Parameter` into `Op` (e.g. Helmholtz wavenumber `k`) and optimise via AdamW; gradients flow through the prebuilt linear solve
 - **Auto-tuning**: Automatic scale selection via grid search
 - **Built-in plotting**: Solution visualization, convergence plots, spectral sensitivity
 - **Geometry samplers**: Box, ball, sphere, interval, custom samplers

{fastlsq-0.1.2 → fastlsq-0.1.4}/examples/add_your_own_pde.py

@@ -100,3 +100,8 @@ if __name__ == "__main__":
 
     bih = Op.biharmonic(d=2)
     print(f"  Biharmonic:        {bih}")
+
+    # Learnable coefficients: use nn.Parameter for AdamW optimisation
+    # k = torch.nn.Parameter(torch.tensor(10.0))
+    # helmholtz = Op.laplacian(d=2) + k**2 * Op.identity(d=2)
+    # See examples/learnable_helmholtz.py for the full workflow.

fastlsq-0.1.4/examples/inverse/aero_.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Antonin Sulc – MIT License
+"""
+Rotating wing aerodynamics: Navier-Stokes flow field animation.
+
+Models a wing (Bézier airfoil) at varying angles of attack, solves steady laminar
+NS (Oseen/Picard) for each angle, and saves the flow fields as an animated GIF.
+
+Similar to shape_ns.py — uses the same NS solver and shape parameterization.
+The wing rotates in the fixed freestream (angle of attack α).
+
+USAGE
+-----
+  python aero_.py                    # default: 9 angles, 0°–20°
+  python aero_.py --quick            # faster, coarser grid
+  python aero_.py --full             # high quality: full domain, more iterations, high-res render
+  python aero_.py --angles 15       # more frames
+  python aero_.py --output my_gif/  # custom output dir
+"""
+
+from __future__ import annotations
+import io
+import os
+import sys
+import warnings
+from typing import Union
+
+import numpy as np
+import torch
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from fastlsq.utils import device, setup
+
+try:
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    from PIL import Image
+    HAS_MPL = True
+except ImportError:
+    HAS_MPL = False
+
+# Import NS solver and shape utilities from shape_ns
+sys.path.insert(0, os.path.dirname(__file__))
+from shape_ns import (
+    BezierShape,
+    TeardropShape,
+    DomainConfig,
+    OptConfig,
+    solve_ns,
+    obj_drag,
+    _shape_boundary_xy,
+)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# ROTATED SHAPE WRAPPER
+# ══════════════════════════════════════════════════════════════════════════════
+
+class RotatedShape:
+    """
+    Wraps a base shape (BezierShape or TeardropShape) with rotation by angle α.
+    Angle of attack: α=0 → chord aligned with flow; α>0 → nose up.
+    """
+    def __init__(self, base: Union[BezierShape, TeardropShape], angle_rad: float):
+        self.base = base
+        self.angle = float(angle_rad)
+        self._cos = np.cos(self.angle)
+        self._sin = np.sin(self.angle)
+
+    def _rotate(self, xy: np.ndarray) -> np.ndarray:
+        """Rotate points (x,y) by self.angle: R @ [x,y]^T."""
+        x, y = xy[:, 0], xy[:, 1]
+        xr = self._cos * x - self._sin * y
+        yr = self._sin * x + self._cos * y
+        return np.c_[xr, yr]
+
+    def _inv_rotate(self, xy: np.ndarray) -> np.ndarray:
+        """Inverse rotate: R(-angle) @ [x,y]^T."""
+        x, y = xy[:, 0], xy[:, 1]
+        xr = self._cos * x + self._sin * y
+        yr = -self._sin * x + self._cos * y
+        return np.c_[xr, yr]
+
+    def boundary_points(self, n: int = 800) -> np.ndarray:
+        return self._rotate(self.base.boundary_points(n))
+
+    def is_inside(self, xy: np.ndarray) -> np.ndarray:
+        return self.base.is_inside(self._inv_rotate(xy))
+
+    def radius(self, theta: np.ndarray) -> np.ndarray:
+        """Distance from origin to rotated boundary in direction theta."""
+        pts = self.boundary_points(400)
+        out = np.empty_like(theta, dtype=float)
+        for i, th in enumerate(theta):
+            ct, st = np.cos(th), np.sin(th)
+            lam = np.where(np.abs(ct) > 1e-10, pts[:, 0] / ct, pts[:, 1] / st)
+            ang_pts = np.arctan2(pts[:, 1], pts[:, 0])
+            ang_diff = np.abs(np.angle(np.exp(1j * (ang_pts - th))))
+            valid = (lam > 0.01) & (ang_diff < 0.1)
+            out[i] = lam[valid].min() if valid.any() else 0.5
+        return np.maximum(out, 0.05)
+
+    def _xy(self, s: np.ndarray) -> np.ndarray:
+        return self._rotate(self.base._xy(s))
+
+    def _dxy_ds(self, s: np.ndarray, eps: float = 1e-7) -> np.ndarray:
+        return self._rotate(self.base._dxy_ds(s, eps))
+
+    def projected_width(self) -> float:
+        return self.base.projected_width()
+
+    def area(self) -> float:
+        return self.base.area()
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# FLOW EVALUATION & VISUALIZATION
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _eval_grid(su, sv, sp, shape: RotatedShape, ng: int = 200,
+               xmin: float = -2.0, xmax: float = 5.0,
+               ymin: float = -2.0, ymax: float = 2.0) -> tuple:
+    """Evaluate u, v, p, |u| on a grid. Mask interior points."""
+    x = np.linspace(xmin, xmax, ng)
+    y = np.linspace(ymin, ymax, ng)
+    X, Y = np.meshgrid(x, y)
+    dtype = torch.get_default_dtype()
+    xy = torch.tensor(np.c_[X.ravel(), Y.ravel()], device=device, dtype=dtype)
+    ins = shape.is_inside(np.c_[X.ravel(), Y.ravel()])
+
+    def ev(s):
+        return (s.basis.evaluate(xy) @ s.beta).squeeze(-1).cpu().detach().numpy()
+
+    u = ev(su)
+    v = ev(sv)
+    p = ev(sp)
+    vel = np.hypot(u, v)
+    for arr in [vel, p, u, v]:
+        arr[ins] = np.nan
+    return x, y, X, Y, u, v, p, vel
+
+
+def _flow_panel(axes_row, shape: RotatedShape, su, sv, sp, label: str,
+                ng: int = 200, levels: int = 90, stream_density: float = 1.2,
+                stream_alpha: float = 0.25, bdry_pts: int = 500, U: float = 1.0,
+                xmin: float = -2.0, xmax: float = 5.0,
+                ymin: float = -2.0, ymax: float = 2.0):
+    """Draw 2 panels: velocity magnitude and Cp (pressure coefficient)."""
+    x, y, X, Y, u, v, p, vel = _eval_grid(su, sv, sp, shape, ng=ng,
+                                          xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)
+    xb, yb = _shape_boundary_xy(shape, bdry_pts)
+    # Pressure Cp = (p - p∞)/(½ρU²); p∞ from far upstream (median for robustness)
+    x_flat = X.ravel()
+    far_up = (x_flat < xmin + 0.5) & ~np.isnan(p)
+    p_inf = np.median(p[far_up]) if np.sum(far_up) > 10 else 0.0
+    cp = 2.0 * (p - p_inf) / (U * U)
+    # Symmetric Cp scale centered at 0 so freestream (Cp=0) is white
+    cp_valid = cp[~np.isnan(cp)]
+    cp_max = max(np.abs(cp_valid).max(), 0.1) if len(cp_valid) else 1.0
+    cp_lim = (-cp_max, cp_max)
+    for ax, (dat, tit, cm, vlim) in zip(axes_row, [
+        (vel, "Velocity |u|", "viridis", None),
+        (cp, "Cp (pressure coeff.)", "RdBu_r", cp_lim),
+    ]):
+        kw = dict(levels=levels, cmap=cm)
+        if vlim is not None:
+            kw["vmin"], kw["vmax"] = vlim
+        im = ax.contourf(X, Y, dat.reshape(X.shape), **kw)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            # Streamlines: from solution (u,v); streamplot integrates velocity to trace paths
+            ax.streamplot(
+                x, y,
+                u.reshape(X.shape),
+                v.reshape(X.shape),
+                color=(1, 1, 1, stream_alpha),
+                linewidth=0.4,
+                density=stream_density,
+                arrowsize=0.5,
+            )
+        ax.fill(xb, yb, color="white", zorder=5)
+        ax.plot(xb, yb, "k-", lw=1.5, zorder=6)
+        ax.set_aspect("equal")
+        ax.set_title(f"{label} — {tit}", fontsize=9)
+        ax.set_xlabel("x")
+        ax.set_ylabel("y")
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# MAIN: SOLVE & ANIMATE
+# ══════════════════════════════════════════════════════════════════════════════
+
+def run_rotating_wing_animation(
+    angles_deg: np.ndarray,
+    quick: bool = False,
+    full: bool = False,
+    nu: float = 1.0 / 75.0,  # Re = U/nu = 75
+    U: float = 1.0,
+    output_dir: str | None = None,
+) -> str:
+    """
+    Solve NS for each angle, collect flow fields, save as GIF.
+
+    Returns path to the saved GIF.
+    """
+    if output_dir is None:
+        output_dir = os.path.join(os.path.dirname(__file__), "aero_output")
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Wing: Bézier airfoil (similar to shape_ns default)
+    base_wing = BezierShape(np.array([0.18, 0.12, 0.06]), chord=1.0)
+
+    if full:
+        # High quality: dense collocation, large RFF basis, many Picard iters, fine render
+        dom_cfg = DomainConfig(
+            n_bulk=6000, n_near=2400, n_cyl=1200,
+            n_in=300, n_out=300, n_wall=250,
+            h1=600, h2=400, h3=250,
+        )
+        opt_cfg = OptConfig(n_iter=80, omega=0.75, mu=1e-5)
+        render = dict(ng=600, levels=150, stream_density=2.0, stream_alpha=0.25,
+                     bdry_pts=1200, figsize=(14, 7), dpi=200,
+                     xmin=dom_cfg.xmin, xmax=dom_cfg.xmax,
+                     ymin=dom_cfg.ymin, ymax=dom_cfg.ymax)
+    elif quick:
+        dom_cfg = DomainConfig().quick()
+        opt_cfg = OptConfig.quick_preset()
+        render = dict(ng=200, levels=60, stream_density=1.2, stream_alpha=0.25,
+                     bdry_pts=500, figsize=(10, 5), dpi=100,
+                     xmin=dom_cfg.xmin, xmax=dom_cfg.xmax,
+                     ymin=dom_cfg.ymin, ymax=dom_cfg.ymax)
+    else:
+        dom_cfg = DomainConfig()
+        opt_cfg = OptConfig(n_iter=8)
+        render = dict(ng=280, levels=90, stream_density=1.4, stream_alpha=0.25,
+                     bdry_pts=600, figsize=(10, 5), dpi=120,
+                     xmin=dom_cfg.xmin, xmax=dom_cfg.xmax,
+                     ymin=dom_cfg.ymin, ymax=dom_cfg.ymax)
+
+    results = []
+    for i, a_deg in enumerate(angles_deg):
+        a_rad = np.deg2rad(a_deg)
+        shape = RotatedShape(base_wing, a_rad)
+        print(f"  [{i+1}/{len(angles_deg)}] Solving α = {a_deg:.1f}° …")
+        try:
+            su, sv, sp, _ = solve_ns(
+                shape, dom_cfg, opt_cfg,
+                nu=nu, U=U,
+                enforce_sym=False,  # rotated wing breaks y-symmetry
+                warm_start=(i > 0),  # warm start from previous angle
+                solvers=None if i == 0 else results[-1]["solvers"],
+                domain_seed=42,  # same collocation across angles
+            )
+            cd_val = abs(-obj_drag(su, sv, sp, shape, nu=nu, U=U))
+            # Store beta copies — solvers are reused, so .beta gets overwritten each solve.
+            # Same basis (RFF) for all angles, but each angle has its own field coefficients.
+            results.append({
+                "shape": shape,
+                "su": su, "sv": sv, "sp": sp,
+                "beta_u": su.beta.clone().detach(),
+                "beta_v": sv.beta.clone().detach(),
+                "beta_p": sp.beta.clone().detach(),
+                "angle_deg": a_deg,
+                "cd": cd_val,
+                "solvers": [su, sv, sp],
+            })
+        except Exception as e:
+            print(f"    Failed: {e}")
+            raise
+
+    if not HAS_MPL:
+        print("Matplotlib not available, skipping GIF.")
+        return ""
+
+    # Build GIF — render each frame to a fresh figure, then combine (no FuncAnimation / nested context)
+    gif_path = os.path.join(output_dir, "wing_rotation.gif")
+    n_frames = len(results)
+    frames = []
+    for frame_idx in range(n_frames):
+        data = results[frame_idx]
+        # Restore beta for this angle — same basis, different field per rotation
+        su, sv, sp = data["su"], data["sv"], data["sp"]
+        su.beta = data["beta_u"].to(device)
+        sv.beta = data["beta_v"].to(device)
+        sp.beta = data["beta_p"].to(device)
+        fig, axes = plt.subplots(1, 2, figsize=render["figsize"])
+        axes = np.atleast_1d(axes)
+        label = f"α = {data['angle_deg']:.1f}°  Cd = {data['cd']:.4f}"
+        _flow_panel(axes, data["shape"], su, sv, sp, label,
+                    ng=render["ng"], levels=render["levels"],
+                    stream_density=render["stream_density"],
+                    stream_alpha=render["stream_alpha"],
+                    bdry_pts=render["bdry_pts"], U=U,
+                    xmin=render["xmin"], xmax=render["xmax"],
+                    ymin=render["ymin"], ymax=render["ymax"])
+        #fig.suptitle(
+        #    f"Rotating wing — Re ≈ {U/nu:.0f}  |  frame {frame_idx+1}/{n_frames}",
+        #    fontsize=12,
+        #)
+        fig.tight_layout()
+        buf = io.BytesIO()
+        fig.savefig(buf, format="png", dpi=render["dpi"], bbox_inches="tight")
+        plt.close(fig)
+        buf.seek(0)
+        frames.append(Image.open(buf).copy())
+        buf.close()
+    frames[0].save(
+        gif_path,
+        save_all=True,
+        append_images=frames[1:],
+        duration=333,
+        loop=0,
+    )
+    print(f"\n  Saved GIF → {gif_path}")
+    return gif_path
+
+
+def main():
+    import argparse
+    p = argparse.ArgumentParser(
+        description="Rotating wing: NS flow field animation",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    p.add_argument("--quick", action="store_true", help="Coarser grid, faster")
+    p.add_argument("--full", action="store_true",
+                   help="High quality: full domain, 20 Picard iters, high-res render (ng=450, dpi=150)")
+    p.add_argument("--angles", type=int, default=9,
+                   help="Number of angle steps from 0° to 20° (default: 9)")
+    p.add_argument("--max-angle", type=float, default=20.0,
+                   help="Max angle of attack in degrees (default: 20)")
+    p.add_argument("--nu", type=float, default=1.0/75.0,
+                   help="Viscosity (default: 1/75 → Re=75)")
+    p.add_argument("--U", type=float, default=1.0)
+    p.add_argument("--output", "-o", type=str, default=None)
+    args = p.parse_args()
+
+    setup(dtype=torch.float64, seed=42)
+
+    angles_deg = np.linspace(0, args.max_angle, args.angles)
+    mode = "full" if args.full else ("quick" if args.quick else "default")
+    print("=" * 60)
+    print("ROTATING WING — Navier-Stokes flow field animation")
+    print("=" * 60)
+    print(f"  Angles: {angles_deg[0]:.1f}° … {angles_deg[-1]:.1f}° ({len(angles_deg)} frames)")
+    print(f"  Re ≈ {args.U/args.nu:.0f}  mode={mode}")
+    print("=" * 60)
+
+    run_rotating_wing_animation(
+        angles_deg,
+        quick=args.quick,
+        full=args.full,
+        nu=args.nu,
+        U=args.U,
+        output_dir=args.output,
+    )
+
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()