Merge pull request #9 from flexcompute/dev

v1.1.2: Tutorial UX fixes + Selig database + Smart Group + Show Me tours

Author: aeronauty-flexcompute

.claude/worktrees/inspiring-dijkstra

@@ -0,0 +1 @@
+Subproject commit 56b7a922a088c748a6b6b4278bd106ce89ebfd66

.cursor/rules/pr-to-main.mdc

@@ -5,7 +5,7 @@ alwaysApply: true
 
 # PR-to-Main Requirements
 
-Every pull request that targets `main` **must** satisfy the two gates below before it can be opened. Treat these as blocking — do not create the PR until both are done.
+Every pull request that targets `main` **must** satisfy the three gates below before it can be opened. Treat these as blocking — do not create the PR until all are done.
 
 ## 1. Update "What's New"
 
@@ -19,7 +19,20 @@ The in-app changelog lives in `flexfoil-ui/src/lib/version.ts` (the `CHANGELOG`
   - `fixed` — bug fix
 - Keep descriptions concise (one sentence, no period).
 
-## 2. Keep Documentation in Sync
+## 2. Bump Distribution Versions
+
+All version numbers **must** stay in sync with the changelog's latest entry.
+
+| File | Field | Must match |
+|------|-------|------------|
+| `flexfoil-ui/package.json` | `"version"` | Top `CHANGELOG` entry version (drives `__APP_VERSION__` via Vite) |
+| `packages/flexfoil-python/pyproject.toml` | `version` | Bump if the PR touches **anything** in `packages/flexfoil-python/`, `crates/rustfoil-python/`, solver behavior, or the WASM bridge. Skip only if the PR is purely UI cosmetic. |
+
+- Use semver: bump **patch** for fixes, **minor** for new features, **major** for breaking changes.
+- The `package.json` version and the top `CHANGELOG` entry version must always be identical after the PR.
+- When in doubt about whether the Python package needs a bump, bump it — users should always be able to `pip install --upgrade flexfoil` to get the latest solver/API changes.
+
+## 3. Keep Documentation in Sync
 
 The docs site lives in `docs-site/docs/` (Docusaurus `.mdx` files).
 
@@ -32,9 +45,11 @@ The docs site lives in `docs-site/docs/` (Docusaurus `.mdx` files).
 When drafting the PR description, include this checklist (filled in):
 
 ```markdown
-## Changelog & Docs
+## Changelog, Versions & Docs
 - [ ] `flexfoil-ui/src/lib/version.ts` CHANGELOG updated
 - [ ] All user-visible changes have a changelog entry
+- [ ] `flexfoil-ui/package.json` version matches top CHANGELOG entry
+- [ ] `packages/flexfoil-python/pyproject.toml` version bumped (if applicable)
 - [ ] New/changed docs pages added or updated in `docs-site/docs/`
 - [ ] No stale or aspirational content remains in affected docs
 ```

.github/workflows/ci.yml

@@ -2,7 +2,7 @@ name: CI
 
 on:
   push:
-    branches: [main]
+    branches: [main, dev]
   pull_request:
 
 concurrency:
@@ -13,6 +13,7 @@ jobs:
   rust:
     runs-on: ubuntu-latest
     timeout-minutes: 30
+    continue-on-error: ${{ github.ref == 'refs/heads/dev' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v5
@@ -29,6 +30,7 @@ jobs:
   python:
     runs-on: ubuntu-latest
     timeout-minutes: 30
+    continue-on-error: ${{ github.ref == 'refs/heads/dev' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v5

.github/workflows/pypi-publish.yml

@@ -2,6 +2,7 @@ name: Build & Publish flexfoil Python wheels
 
 on:
   push:
+    branches: [main]
     tags:
       - "pypi-v*"
   workflow_dispatch:
@@ -161,7 +162,10 @@ jobs:
   publish:
     needs: [build-wheels, build-sdist]
     runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/pypi-v') || (github.event_name == 'workflow_dispatch' && inputs.publish)
+    if: >-
+      github.ref == 'refs/heads/main'
+      || startsWith(github.ref, 'refs/tags/pypi-v')
+      || (github.event_name == 'workflow_dispatch' && inputs.publish)
     environment:
       name: pypi
       url: https://pypi.org/p/flexfoil

crates/rustfoil-python/src/lib.rs

@@ -414,6 +414,96 @@ fn analyze_inviscid_batch(
         .collect()
 }
 
+/// Compute boundary-layer distributions for a viscous operating point.
+///
+/// Returns a dict with keys: x_upper, x_lower, theta_upper, theta_lower,
+/// delta_star_upper, delta_star_lower, h_upper, h_lower, cf_upper, cf_lower,
+/// ue_upper, ue_lower, x_tr_upper, x_tr_lower, converged, iterations,
+/// residual, success, error.
+#[pyfunction]
+#[pyo3(signature = (coords, alpha_deg, reynolds=1.0e6, mach=0.0, ncrit=9.0, max_iterations=100))]
+fn get_bl_distribution(
+    py: Python<'_>,
+    coords: Vec<f64>,
+    alpha_deg: f64,
+    reynolds: f64,
+    mach: f64,
+    ncrit: f64,
+    max_iterations: usize,
+) -> PyResult<Py<PyDict>> {
+    use rustfoil_xfoil::oper::{build_state_from_coords, solve_operating_point_from_state, coords_from_body, AlphaSpec};
+    use rustfoil_xfoil::XfoilOptions;
+
+    let d = PyDict::new(py);
+
+    if coords.len() < 6 || coords.len() % 2 != 0 {
+        d.set_item("success", false)?;
+        d.set_item("error", "Invalid coordinates")?;
+        return Ok(d.into());
+    }
+
+    let points = points_from_flat(&coords);
+    let body = match Body::from_points("airfoil", &points) {
+        Ok(b) => b,
+        Err(e) => {
+            d.set_item("success", false)?;
+            d.set_item("error", format!("Geometry error: {e}"))?;
+            return Ok(d.into());
+        }
+    };
+
+    let body_coords = coords_from_body(&body);
+    let options = XfoilOptions {
+        reynolds, mach, ncrit, max_iterations,
+        ..Default::default()
+    };
+
+    let (mut state, factorized) = match build_state_from_coords(
+        "airfoil", &body_coords, AlphaSpec::AlphaDeg(alpha_deg), &options,
+    ) {
+        Ok(v) => v,
+        Err(e) => {
+            d.set_item("success", false)?;
+            d.set_item("error", format!("{e}"))?;
+            return Ok(d.into());
+        }
+    };
+
+    match solve_operating_point_from_state(&mut state, &factorized, &options) {
+        Ok(result) => {
+            let iblte_upper = state.iblte_upper.min(state.upper_rows.len().saturating_sub(1));
+            let iblte_lower = state.iblte_lower.min(state.lower_rows.len().saturating_sub(1));
+            let upper = &state.upper_rows[..=iblte_upper];
+            let lower = &state.lower_rows[..=iblte_lower];
+
+            d.set_item("x_upper", upper.iter().map(|r| r.x_coord).collect::<Vec<_>>())?;
+            d.set_item("x_lower", lower.iter().map(|r| r.x_coord).collect::<Vec<_>>())?;
+            d.set_item("theta_upper", upper.iter().map(|r| r.theta).collect::<Vec<_>>())?;
+            d.set_item("theta_lower", lower.iter().map(|r| r.theta).collect::<Vec<_>>())?;
+            d.set_item("delta_star_upper", upper.iter().map(|r| r.dstr).collect::<Vec<_>>())?;
+            d.set_item("delta_star_lower", lower.iter().map(|r| r.dstr).collect::<Vec<_>>())?;
+            d.set_item("h_upper", upper.iter().map(|r| r.h).collect::<Vec<_>>())?;
+            d.set_item("h_lower", lower.iter().map(|r| r.h).collect::<Vec<_>>())?;
+            d.set_item("cf_upper", upper.iter().map(|r| r.cf).collect::<Vec<_>>())?;
+            d.set_item("cf_lower", lower.iter().map(|r| r.cf).collect::<Vec<_>>())?;
+            d.set_item("ue_upper", upper.iter().map(|r| r.uedg).collect::<Vec<_>>())?;
+            d.set_item("ue_lower", lower.iter().map(|r| r.uedg).collect::<Vec<_>>())?;
+            d.set_item("x_tr_upper", result.x_tr_upper)?;
+            d.set_item("x_tr_lower", result.x_tr_lower)?;
+            d.set_item("converged", result.converged)?;
+            d.set_item("iterations", result.iterations)?;
+            d.set_item("residual", result.residual)?;
+            d.set_item("success", true)?;
+            d.set_item("error", py.None())?;
+        }
+        Err(e) => {
+            d.set_item("success", false)?;
+            d.set_item("error", format!("{e}"))?;
+        }
+    }
+    Ok(d.into())
+}
+
 #[pymodule]
 fn _rustfoil(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(analyze_faithful, m)?)?;
@@ -424,5 +514,6 @@ fn _rustfoil(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(repanel_xfoil, m)?)?;
     m.add_function(wrap_pyfunction!(deflect_flap, m)?)?;
     m.add_function(wrap_pyfunction!(parse_dat_file, m)?)?;
+    m.add_function(wrap_pyfunction!(get_bl_distribution, m)?)?;
     Ok(())
 }

docs-site/docs/python-api.mdx

@@ -57,7 +57,19 @@ Polar sweeps are **parallelized by default** using all available CPU cores
 ```python
 polar = foil.polar(alpha=(-5, 15, 0.5), Re=1e6)
 print(polar)
-# PolarResult('NACA 2412', Re=1e+06, 40/41 converged)
+# PolarResult('NACA 2412', Re=1e+06, 40/41 converged, CLmax=1.4523, α_stall=12.5°, L/D_max=78.3)
+
+# Aggregate statistics
+polar.cl_max         # 1.4523
+polar.alpha_stall    # 12.5
+polar.ld_max         # 78.3
+polar.cd_min         # 0.00523
+polar.summary()      # dict with all aggregate statistics
+
+# Generic aggregation with optional outlier filtering
+polar.column_max('cl', filter_outliers=True)
+polar.argmax('ld', 'alpha')   # alpha at max L/D
+polar.argmin('cd', 'alpha')   # alpha at min CD
 
 # Interactive plotly figure (default): CL-α, CD-α, CL-CD, CM-α
 polar.plot()
@@ -68,8 +80,8 @@ polar.plot(backend="matplotlib")
 # Sequential mode (for debugging or progress output)
 polar = foil.polar(alpha=(-5, 15, 0.5), Re=1e6, parallel=False)
 
-# Export to pandas
-df = polar.to_dataframe()
+# Export to pandas (with summary statistics in df.attrs)
+df = polar.to_dataframe(summary=True)
 df.to_csv("polar.csv", index=False)
 ```
 
@@ -262,8 +274,23 @@ are byte-identical.
 | `.ld` | `list[float]` — lift-to-drag ratios |
 | `.converged` | `list[SolveResult]` — converged results only |
 | `.results` | `list[SolveResult]` — all results |
-| `.to_dict()` | Export as `dict` |
-| `.to_dataframe()` | Export as `pandas.DataFrame` |
+| `.cl_max` | `float \| None` — maximum CL |
+| `.cl_min` | `float \| None` — minimum CL |
+| `.cd_min` | `float \| None` — minimum CD |
+| `.ld_max` | `float \| None` — maximum L/D |
+| `.alpha_stall` | `float \| None` — alpha at CL_max |
+| `.alpha_at_ld_max` | `float \| None` — alpha at L/D_max |
+| `.alpha_at_cd_min` | `float \| None` — alpha at CD_min |
+| `.column_max(col, filter_outliers=False)` | Max of any column |
+| `.column_min(col, filter_outliers=False)` | Min of any column |
+| `.column_mean(col, filter_outliers=False)` | Mean of any column |
+| `.column_median(col, filter_outliers=False)` | Median of any column |
+| `.column_stdev(col, filter_outliers=False)` | Std deviation of any column |
+| `.argmax(target, return_col, filter_outliers=False)` | Value of *return_col* at max of *target* |
+| `.argmin(target, return_col, filter_outliers=False)` | Value of *return_col* at min of *target* |
+| `.summary()` | Dict of all aggregate statistics |
+| `.to_dict(summary=False)` | Export as `dict` (optionally include summary) |
+| `.to_dataframe(summary=False)` | Export as `pandas.DataFrame` (summary in `.attrs`) |
 | `.plot(show=True, backend="plotly")` | 4-panel figure (plotly default, or `"matplotlib"`) |
 
 ### RunDatabase

docs-site/docs/web-app.mdx

@@ -29,8 +29,11 @@ The UI is organized as a set of dockable, rearrangeable panels.
 
 ### Airfoil Library
 
-Browse and load airfoils from the NACA 4-digit generator and the Selig
-database (over 1,500 airfoils). Select any airfoil to load it into the canvas.
+Browse and load airfoils from the NACA 4-digit generator, import `.dat` files,
+or search the UIUC Selig database (~1,600 airfoils). Type at least two
+characters in the Selig search box to filter by name or filename, then click an
+entry to fetch and load it. The **Random Foil** button picks a random airfoil
+from the database and loads it instantly.
 
 ### Airfoil Canvas
 
@@ -57,7 +60,8 @@ Visualize sweep results with configurable axes — CL, CD, CM, L/D, alpha,
 Reynolds, Mach, Ncrit, flap deflection, and flap hinge x/c. Overlay
 multiple series for direct comparison. Enable the **Outliers** checkbox to
 automatically remove statistical outliers (IQR method) from the displayed
-data.
+data. Right-click any data point to manually flag it as an outlier; flagged
+points appear as red X marks and are excluded when the outlier filter is on.
 
 ### Visualization
 
@@ -76,13 +80,44 @@ filter, and search across airfoils, operating conditions, and results. Includes
 a SPLOM (scatter plot matrix) correlogram for multivariate exploration. Custom
 computed columns let you define algebraic expressions over existing fields. The
 correlogram view supports automatic outlier removal via the **Outliers** toggle.
+Right-click a scatter point to manually flag it as an outlier; flagged runs are
+persisted in the database and excluded from all plots. The table includes a
+filterable **Outlier** column.
+
+**Row grouping and aggregation** — drag any column header (e.g. Airfoil, Re) into
+the row group panel above the grid. Grouped rows automatically aggregate their
+children: CL shows `max`, CD shows `min`, L/D shows `max`, etc. Change the
+aggregation function for any column via the sidebar (right-click a column header
+→ "Value Aggregation"). Custom aggregation functions include:
+
+- **at max(CL)** / **at min(CD)** / **at max(L/D)** — returns the value of the
+  current column at the row where the target column reaches its extremum.
+  For example, applying "at max(CL)" to the alpha column gives **α_stall**.
+- **median** — median aggregation (not available by default in AG Grid).
+
+Two predefined aerodynamic summary columns are available (hidden by default —
+show them via the sidebar):
+- **α_stall** — angle of attack at CL_max
+- **α @ L/D_max** — angle of attack at maximum lift-to-drag ratio
+
+Use the **Converged Only** button to quickly filter out non-converged solver
+points before grouping, which is particularly useful near stall where the
+solver may not converge reliably.
 
 ### Plot Builder
 
 Build custom charts from run data: scatter, line, bar, and histogram plots.
 Map any database field to axes, color, or size. Useful for parameter studies
 and trade-off visualization. Toggle **Outliers** to automatically exclude
-statistical outliers using the IQR method.
+statistical outliers using the IQR method. Right-click any plotted point to
+manually flag it as an outlier; flagged runs are persisted and excluded from
+the chart.
+
+The **Aggregated** data source (available when row grouping is active in the
+Data Explorer) lets you plot group-level statistics directly. For example, to
+plot L/D_max vs Reynolds number for multiple airfoils: group by Airfoil and Re
+in the Data Explorer, then select Data → Aggregated, X → Re, Y → L/D in the
+Plot Builder.
 
 ### Case Logs
 

docs-site/docusaurus.config.ts

@@ -14,7 +14,7 @@ const config: Config = {
   url: 'https://foil.flexcompute.com',
   baseUrl: '/docs/',
 
-  organizationName: 'flexfoil',
+  organizationName: 'flexcompute',
   projectName: 'flexfoil',
 
   onBrokenLinks: 'throw',
@@ -37,7 +37,7 @@ const config: Config = {
         docs: {
           routeBasePath: '/',
           sidebarPath: './sidebars.ts',
-          editUrl: 'https://github.com/flexfoil/flexfoil/tree/main/docs-site/',
+          editUrl: 'https://github.com/flexcompute/flexfoil/tree/main/docs-site/',
         },
         blog: false,
         theme: {
@@ -69,7 +69,7 @@ const config: Config = {
           label: 'Documentation',
         },
         {
-          href: 'https://github.com/flexfoil/flexfoil',
+          href: 'https://github.com/flexcompute/flexfoil',
           label: 'GitHub',
           position: 'right',
         },
@@ -104,7 +104,7 @@ const config: Config = {
             },
             {
               label: 'GitHub',
-              href: 'https://github.com/flexfoil/flexfoil',
+              href: 'https://github.com/flexcompute/flexfoil',
             },
           ],
         },