aerorare-studio 0.1.1__tar.gz

aerorare_studio-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nsclk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aerorare_studio-0.1.1/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: aerorare-studio
+Version: 0.1.1
+Summary: Open-source CFD workbench for hypersonic, reentry and rarefied-flow analysis (SU2 + SPARTA + Gmsh + ParaView orchestration)
+Author: nsclk
+License: MIT
+Project-URL: Repository, https://github.com/nsclk/aerorare-studio
+Project-URL: Changelog, https://github.com/nsclk/aerorare-studio/blob/main/DEVELOPMENT.md
+Keywords: cfd,hypersonic,dsmc,su2,sparta,reentry,rarefied-gas,aerothermodynamics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: PyYAML>=5.4
+Provides-Extra: mesh
+Requires-Dist: gmsh>=4.11; extra == "mesh"
+Provides-Extra: cad
+Requires-Dist: cadquery>=2.4; extra == "cad"
+Provides-Extra: gui
+Requires-Dist: PySide6>=6.5; extra == "gui"
+Requires-Dist: vtk<9.5,>=9.2; extra == "gui"
+Provides-Extra: results
+Requires-Dist: vtk<9.5,>=9.2; extra == "results"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# AeroRare Studio
+
+Open-source CFD workbench for **hypersonic**, **atmospheric reentry** and
+**rarefied-flow / DSMC** analysis. AeroRare Studio is not a solver: it
+orchestrates [SU2](https://su2code.github.io/) (continuum CFD),
+[SPARTA](https://sparta.github.io/) (DSMC), [Gmsh](https://gmsh.info/)
+(meshing) and ParaView/VTK (post-processing) behind a single physics-first
+workflow. You describe the physical problem; the studio generates geometry,
+meshes, solver input files, run commands and reports.
+
+The full product concept is described (in Turkish) in
+[`docs/hyperrare_studio_spec.md`](docs/hyperrare_studio_spec.md). This package is the
+engine layer: every screen of the planned GUI maps onto a module here.
+
+## Toolchain status (this machine)
+
+All five external tools are installed and detected by `aerorare tools`:
+SU2 8.0.0, SPARTA (24 Sep 2025, built from `../sparta-master`), Gmsh 4.14,
+ParaView 5.11.2 (`pvpython` in the app bundle), Open MPI 5.0.8. Python side:
+CadQuery 2.5.2 (bundled OCCT 7.7 kernel via OCP) and VTK 9.3.1; OCCT 7.9.3
+(brew) and FreeCAD 1.x (`/Applications/FreeCAD.app`) for CAD work.
+
+## Status — v0.1.0 (engine + CLI)
+
+| Concept (spec §) | Module | State |
+|---|---|---|
+| System check (§2) | `aerorare/tools.py` | ✅ detects SU2, SPARTA, Gmsh, ParaView, MPI |
+| Project Setup (§3) | `aerorare/project.py` | ✅ project.yaml, folder layout, run versioning |
+| Geometry Studio (§4) | `aerorare/geometry.py` | ✅ parametric 2D/axisymmetric templates (blunt cone, capsule, sphere, cylinder, wedge, flat plate); CAD import planned |
+| Geometry Health Check (§5) | `Contour.health_check` | ✅ basic checks |
+| Boundary Assignment (§6) | `aerorare/boundaries.py` | ✅ types, auto-detection, consistency check, colour legend |
+| Physics Wizard (§7) | `aerorare/freestream.py`, `aerorare/atmosphere.py`, `aerorare/gas.py` | ✅ US76 atmosphere, altitude & direct modes, gas models |
+| Regime Selector (§8) | `aerorare/regime.py` | ✅ Kn bands, solver recommendation, override warnings |
+| Mesh Studio (§9) | `aerorare/meshing.py`, `aerorare/sparta.py` | ✅ mesh plan + Gmsh .geo + SU2 mesh; DSMC grid plan w/ λ checks |
+| Solver Setup (§10) | `aerorare/su2.py`, `aerorare/sparta.py` | ✅ SU2 .cfg and SPARTA input generation |
+| Case Validation (§11) | `aerorare/validation.py` | ✅ Ready/Warning/Error gate |
+| Run Monitor (§12) | `aerorare/runner.py` | ✅ `aerorare run`: MPI launch + live residual/particle tracking |
+| Results Viewer (§13) | `aerorare/postprocess.py` | ✅ pvpython offscreen contours (percentile-clamped, body-framed) + dependency-free SVG wall/convergence plots |
+| Comparison Studio (§14) | `results.compare_surfaces` | ✅ common arc-length resampling, % differences, overlay plots |
+| Common Result Model (§15) | `aerorare/results.py` | ✅ SU2 CSV/VTU + SPARTA dump parsers → shared surface/volume model |
+| Report Generator (§16) | `aerorare/report.py` | ✅ Markdown case report |
+| 3D geometries (§4) | `aerorare/geometry3d.py` | ✅ CadQuery solids (sphere, blunt cone, capsule, cone-cylinder), revolve-from-contour, STL export, watertight check |
+| CAD import (§4.2) | `aerorare/cad.py` | ✅ STEP/IGES/BREP/STL/OBJ, unit scaling, health report |
+| SPARTA 3D | `sparta.write_surface_file_3d` etc. | ✅ triangle surfaces + 3D grid plan + input (verified with a live 3D run) |
+| SSH / SLURM environments (§12) | `aerorare/hpc.py` | ✅ `aerorare env` + remote stage/submit/fetch, sbatch generation |
+| Desktop GUI | `aerorare/gui.py` | ✅ MVP: PySide6, software-rendered geometry viewport, clickable boundary assignment (§6 colour legend), workflow sidebar, live run log, results gallery (`aerorare gui`) |
+| SU2 NEMO (§7.2) | `su2.py` (`--thermal two-temperature`) | ✅ AIR-5 two-temperature configs patterned on SU2's nonequilibrium test cases; NEMO_EULER verified converging on SU2 8.0.0 |
+| 3D SU2 mesh from STEP | `meshing.py` (`MeshPlan3D`) | ✅ gmsh OpenCASCADE boolean (STEP body − sphere farfield), body/farfield markers, distance-field refinement; verified with a live 3D SU2 run |
+| 3D boundary-layer inflation | `blmesh.py` (`generate --bl`) | ✅ prism layers via gmsh `extrudeBoundaryLayer` (smooth bodies; sharp edges fall back to isotropic); hybrid prism+tet mesh verified in SU2 |
+| 3D results (§13–15) | `results.py` 3D loaders | ✅ meridional collapse (x, r → s) + azimuthal averaging, slice/surface pvpython renders, SU2-vs-SPARTA comparison on the meridian |
+| HTML/PDF reports (§16) | `report.py` (`report --format html/pdf`) | ✅ dependency-free MD→HTML with figures embedded (base64/inline SVG); PDF via Qt QPdfWriter |
+| Geometry auto-repair (§5) | `geometry3d.repair_mesh` (`new --repair`) | ✅ duplicate removal, winding fix, small-hole fill |
+| Docker environment (§12) | `hpc.docker_command` (`env --kind docker`) | ✅ containerised runs with live monitoring (command-generation tested; docker not installed here) |
+| Restart flows | `generate --restart` | ✅ SU2 RESTART_SOL + staged 2nd-order upgrade; SPARTA read_restart continuation (verified live) |
+| Analysis tools (§13.3) | `analysis.py` (`aerorare analyze`) | ✅ stagnation region, shock stand-off vs Billig, centerline probes |
+| Mesh Studio GUI | `gui.py` Mesh page | ✅ plan editor with persisted overrides + live residual/particle charts |
+
+Development history and roadmap: [DEVELOPMENT.md](DEVELOPMENT.md).
+
+## Install
+
+```bash
+cd aerorare_studio
+python3 -m pip install -e ".[dev]"       # engine + tests
+# optional external tools:
+#   gmsh     -> mesh generation      (brew install gmsh / pip install gmsh)
+#   SU2      -> continuum solver     (https://su2code.github.io/download.html)
+#   SPARTA   -> DSMC solver          (https://sparta.github.io/download.html)
+```
+
+### Building SPARTA from source (macOS)
+
+The vendored tree in `../sparta-master` builds with CMake; clang/libc++
+needs the C++11 hash-map flag:
+
+```bash
+cd ../sparta-master && mkdir -p build install && cd build
+cmake -DCMAKE_INSTALL_PREFIX=../install -DBUILD_MPI=ON \
+      -DCMAKE_CXX_FLAGS="-DSPARTA_UNORDERED_MAP" ../cmake
+make -j8 && make install
+ln -sf "$PWD/../install/bin/spa_" /opt/homebrew/bin/spa_
+```
+
+The studio locates SPARTA's species/VSS data files (`air.species`,
+`air.vss`, ...) next to the executable or via `$SPARTA_DATA_DIR`, and
+copies them into each run directory.
+
+### Doc-compliance notes (validated against the vendored sources)
+
+* **SPARTA** — generated inputs follow the manual and the `examples/axi`
+  case: `boundary oo ar pp` + box `ylo=0` + `global ... weight cell radius`
+  for axisymmetric models (manual §6.2); surface files obey the `read_surf`
+  right-hand orientation rule (outward normal `N = z × (p2−p1)`) and the
+  watertight rule (endpoints exactly on a box edge — near-axis points are
+  snapped to `y=0`); open profiles ending off-axis are auto-closed at the
+  base. Dump columns use `xlo/ylo/xhi/yhi` (there is no `xc/yc`).
+* **SU2** — every emitted option exists in `SU2-master/config_template.cfg`;
+  viscous cases set `INIT_OPTION= TD_CONDITIONS`, `FREESTREAM_OPTION=
+  TEMPERATURE_FS` plus `REYNOLDS_NUMBER` (required by SU2 8.x for
+  NAVIER_STOKES). Verified by running SU2_CFD 8.0.0 on a generated case.
+* **Gmsh** — `.geo` scripts use OpenCASCADE factory + `Physical Curve`
+  groups whose names become SU2 markers via `gmsh -2 -format su2`.
+  Verified with Gmsh 4.14 (markers arrive in the `.su2` mesh intact).
+
+## Quick start — Mach 15 blunt-body reentry at 80 km
+
+```bash
+aerorare tools                                  # check SU2/SPARTA/Gmsh/MPI
+aerorare new reentry --template blunt-cone \
+    --param nose_radius=0.05 --param half_angle_deg=15 --param length=0.3
+aerorare physics reentry --mach 15 --altitude 80000 --wall-temp 1000
+aerorare regime reentry                         # -> slip regime, su2+sparta
+aerorare generate reentry --quick               # coarse preview setup (drop --quick for production)
+aerorare validate reentry                       # pre-run gate
+aerorare run reentry --ranks 4                  # SU2 + SPARTA with live monitoring
+aerorare results reentry                        # contour PNGs, wall SVGs, SU2-vs-SPARTA comparison
+aerorare report reentry                         # reports/case_report.md
+```
+
+With the full toolchain the quick demo takes ~20 s of solver time and
+produces, under `results/run_NNN/`: ParaView Mach/pressure/temperature/
+density contours framed on the body, SU2 wall pressure / heat-flux / Cp and
+convergence plots, SPARTA wall distributions, overlaid SU2-vs-SPARTA
+comparison charts and a `comparison.md` with mean/max percentage
+differences.
+
+Everything needed to reproduce a case lives in `project.yaml`; each
+`generate` allocates a fresh `solvers/run_NNN/` so earlier setups are kept.
+
+## Tests
+
+```bash
+python3 -m pytest tests/ -q
+```

aerorare_studio-0.1.1/README.md

@@ -0,0 +1,134 @@
+# AeroRare Studio
+
+Open-source CFD workbench for **hypersonic**, **atmospheric reentry** and
+**rarefied-flow / DSMC** analysis. AeroRare Studio is not a solver: it
+orchestrates [SU2](https://su2code.github.io/) (continuum CFD),
+[SPARTA](https://sparta.github.io/) (DSMC), [Gmsh](https://gmsh.info/)
+(meshing) and ParaView/VTK (post-processing) behind a single physics-first
+workflow. You describe the physical problem; the studio generates geometry,
+meshes, solver input files, run commands and reports.
+
+The full product concept is described (in Turkish) in
+[`docs/hyperrare_studio_spec.md`](docs/hyperrare_studio_spec.md). This package is the
+engine layer: every screen of the planned GUI maps onto a module here.
+
+## Toolchain status (this machine)
+
+All five external tools are installed and detected by `aerorare tools`:
+SU2 8.0.0, SPARTA (24 Sep 2025, built from `../sparta-master`), Gmsh 4.14,
+ParaView 5.11.2 (`pvpython` in the app bundle), Open MPI 5.0.8. Python side:
+CadQuery 2.5.2 (bundled OCCT 7.7 kernel via OCP) and VTK 9.3.1; OCCT 7.9.3
+(brew) and FreeCAD 1.x (`/Applications/FreeCAD.app`) for CAD work.
+
+## Status — v0.1.0 (engine + CLI)
+
+| Concept (spec §) | Module | State |
+|---|---|---|
+| System check (§2) | `aerorare/tools.py` | ✅ detects SU2, SPARTA, Gmsh, ParaView, MPI |
+| Project Setup (§3) | `aerorare/project.py` | ✅ project.yaml, folder layout, run versioning |
+| Geometry Studio (§4) | `aerorare/geometry.py` | ✅ parametric 2D/axisymmetric templates (blunt cone, capsule, sphere, cylinder, wedge, flat plate); CAD import planned |
+| Geometry Health Check (§5) | `Contour.health_check` | ✅ basic checks |
+| Boundary Assignment (§6) | `aerorare/boundaries.py` | ✅ types, auto-detection, consistency check, colour legend |
+| Physics Wizard (§7) | `aerorare/freestream.py`, `aerorare/atmosphere.py`, `aerorare/gas.py` | ✅ US76 atmosphere, altitude & direct modes, gas models |
+| Regime Selector (§8) | `aerorare/regime.py` | ✅ Kn bands, solver recommendation, override warnings |
+| Mesh Studio (§9) | `aerorare/meshing.py`, `aerorare/sparta.py` | ✅ mesh plan + Gmsh .geo + SU2 mesh; DSMC grid plan w/ λ checks |
+| Solver Setup (§10) | `aerorare/su2.py`, `aerorare/sparta.py` | ✅ SU2 .cfg and SPARTA input generation |
+| Case Validation (§11) | `aerorare/validation.py` | ✅ Ready/Warning/Error gate |
+| Run Monitor (§12) | `aerorare/runner.py` | ✅ `aerorare run`: MPI launch + live residual/particle tracking |
+| Results Viewer (§13) | `aerorare/postprocess.py` | ✅ pvpython offscreen contours (percentile-clamped, body-framed) + dependency-free SVG wall/convergence plots |
+| Comparison Studio (§14) | `results.compare_surfaces` | ✅ common arc-length resampling, % differences, overlay plots |
+| Common Result Model (§15) | `aerorare/results.py` | ✅ SU2 CSV/VTU + SPARTA dump parsers → shared surface/volume model |
+| Report Generator (§16) | `aerorare/report.py` | ✅ Markdown case report |
+| 3D geometries (§4) | `aerorare/geometry3d.py` | ✅ CadQuery solids (sphere, blunt cone, capsule, cone-cylinder), revolve-from-contour, STL export, watertight check |
+| CAD import (§4.2) | `aerorare/cad.py` | ✅ STEP/IGES/BREP/STL/OBJ, unit scaling, health report |
+| SPARTA 3D | `sparta.write_surface_file_3d` etc. | ✅ triangle surfaces + 3D grid plan + input (verified with a live 3D run) |
+| SSH / SLURM environments (§12) | `aerorare/hpc.py` | ✅ `aerorare env` + remote stage/submit/fetch, sbatch generation |
+| Desktop GUI | `aerorare/gui.py` | ✅ MVP: PySide6, software-rendered geometry viewport, clickable boundary assignment (§6 colour legend), workflow sidebar, live run log, results gallery (`aerorare gui`) |
+| SU2 NEMO (§7.2) | `su2.py` (`--thermal two-temperature`) | ✅ AIR-5 two-temperature configs patterned on SU2's nonequilibrium test cases; NEMO_EULER verified converging on SU2 8.0.0 |
+| 3D SU2 mesh from STEP | `meshing.py` (`MeshPlan3D`) | ✅ gmsh OpenCASCADE boolean (STEP body − sphere farfield), body/farfield markers, distance-field refinement; verified with a live 3D SU2 run |
+| 3D boundary-layer inflation | `blmesh.py` (`generate --bl`) | ✅ prism layers via gmsh `extrudeBoundaryLayer` (smooth bodies; sharp edges fall back to isotropic); hybrid prism+tet mesh verified in SU2 |
+| 3D results (§13–15) | `results.py` 3D loaders | ✅ meridional collapse (x, r → s) + azimuthal averaging, slice/surface pvpython renders, SU2-vs-SPARTA comparison on the meridian |
+| HTML/PDF reports (§16) | `report.py` (`report --format html/pdf`) | ✅ dependency-free MD→HTML with figures embedded (base64/inline SVG); PDF via Qt QPdfWriter |
+| Geometry auto-repair (§5) | `geometry3d.repair_mesh` (`new --repair`) | ✅ duplicate removal, winding fix, small-hole fill |
+| Docker environment (§12) | `hpc.docker_command` (`env --kind docker`) | ✅ containerised runs with live monitoring (command-generation tested; docker not installed here) |
+| Restart flows | `generate --restart` | ✅ SU2 RESTART_SOL + staged 2nd-order upgrade; SPARTA read_restart continuation (verified live) |
+| Analysis tools (§13.3) | `analysis.py` (`aerorare analyze`) | ✅ stagnation region, shock stand-off vs Billig, centerline probes |
+| Mesh Studio GUI | `gui.py` Mesh page | ✅ plan editor with persisted overrides + live residual/particle charts |
+
+Development history and roadmap: [DEVELOPMENT.md](DEVELOPMENT.md).
+
+## Install
+
+```bash
+cd aerorare_studio
+python3 -m pip install -e ".[dev]"       # engine + tests
+# optional external tools:
+#   gmsh     -> mesh generation      (brew install gmsh / pip install gmsh)
+#   SU2      -> continuum solver     (https://su2code.github.io/download.html)
+#   SPARTA   -> DSMC solver          (https://sparta.github.io/download.html)
+```
+
+### Building SPARTA from source (macOS)
+
+The vendored tree in `../sparta-master` builds with CMake; clang/libc++
+needs the C++11 hash-map flag:
+
+```bash
+cd ../sparta-master && mkdir -p build install && cd build
+cmake -DCMAKE_INSTALL_PREFIX=../install -DBUILD_MPI=ON \
+      -DCMAKE_CXX_FLAGS="-DSPARTA_UNORDERED_MAP" ../cmake
+make -j8 && make install
+ln -sf "$PWD/../install/bin/spa_" /opt/homebrew/bin/spa_
+```
+
+The studio locates SPARTA's species/VSS data files (`air.species`,
+`air.vss`, ...) next to the executable or via `$SPARTA_DATA_DIR`, and
+copies them into each run directory.
+
+### Doc-compliance notes (validated against the vendored sources)
+
+* **SPARTA** — generated inputs follow the manual and the `examples/axi`
+  case: `boundary oo ar pp` + box `ylo=0` + `global ... weight cell radius`
+  for axisymmetric models (manual §6.2); surface files obey the `read_surf`
+  right-hand orientation rule (outward normal `N = z × (p2−p1)`) and the
+  watertight rule (endpoints exactly on a box edge — near-axis points are
+  snapped to `y=0`); open profiles ending off-axis are auto-closed at the
+  base. Dump columns use `xlo/ylo/xhi/yhi` (there is no `xc/yc`).
+* **SU2** — every emitted option exists in `SU2-master/config_template.cfg`;
+  viscous cases set `INIT_OPTION= TD_CONDITIONS`, `FREESTREAM_OPTION=
+  TEMPERATURE_FS` plus `REYNOLDS_NUMBER` (required by SU2 8.x for
+  NAVIER_STOKES). Verified by running SU2_CFD 8.0.0 on a generated case.
+* **Gmsh** — `.geo` scripts use OpenCASCADE factory + `Physical Curve`
+  groups whose names become SU2 markers via `gmsh -2 -format su2`.
+  Verified with Gmsh 4.14 (markers arrive in the `.su2` mesh intact).
+
+## Quick start — Mach 15 blunt-body reentry at 80 km
+
+```bash
+aerorare tools                                  # check SU2/SPARTA/Gmsh/MPI
+aerorare new reentry --template blunt-cone \
+    --param nose_radius=0.05 --param half_angle_deg=15 --param length=0.3
+aerorare physics reentry --mach 15 --altitude 80000 --wall-temp 1000
+aerorare regime reentry                         # -> slip regime, su2+sparta
+aerorare generate reentry --quick               # coarse preview setup (drop --quick for production)
+aerorare validate reentry                       # pre-run gate
+aerorare run reentry --ranks 4                  # SU2 + SPARTA with live monitoring
+aerorare results reentry                        # contour PNGs, wall SVGs, SU2-vs-SPARTA comparison
+aerorare report reentry                         # reports/case_report.md
+```
+
+With the full toolchain the quick demo takes ~20 s of solver time and
+produces, under `results/run_NNN/`: ParaView Mach/pressure/temperature/
+density contours framed on the body, SU2 wall pressure / heat-flux / Cp and
+convergence plots, SPARTA wall distributions, overlaid SU2-vs-SPARTA
+comparison charts and a `comparison.md` with mean/max percentage
+differences.
+
+Everything needed to reproduce a case lives in `project.yaml`; each
+`generate` allocates a fresh `solvers/run_NNN/` so earlier setups are kept.
+
+## Tests
+
+```bash
+python3 -m pytest tests/ -q
+```

aerorare_studio-0.1.1/aerorare/__init__.py

@@ -0,0 +1,25 @@
+"""AeroRare Studio — open-source CFD workbench for hypersonic, reentry and
+rarefied-flow analysis.
+
+AeroRare Studio is not a solver. It orchestrates SU2 (continuum CFD),
+SPARTA (DSMC), Gmsh (meshing) and ParaView/VTK (post-processing) behind a
+single physics-first interface: the user defines the physical problem and
+the studio generates geometry, meshes, solver input files, run commands and
+reports.
+"""
+
+__version__ = "0.1.1"
+
+from .atmosphere import atmosphere_at
+from .freestream import Freestream
+from .regime import FlowRegime, classify_regime
+from .project import Project
+
+__all__ = [
+    "atmosphere_at",
+    "Freestream",
+    "FlowRegime",
+    "classify_regime",
+    "Project",
+    "__version__",
+]

aerorare_studio-0.1.1/aerorare/analysis.py

@@ -0,0 +1,152 @@
+"""One-click analysis tools (spec §13.3): stagnation region, shock
+stand-off distance and centerline probes.
+
+All functions work on the common result model (SurfaceData/VolumeData),
+so they apply to SU2 and SPARTA solutions alike.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+import numpy as np
+
+from .freestream import Freestream
+from .results import SurfaceData, VolumeData
+
+
+@dataclass
+class StagnationResult:
+    """Wall quantities at and near the stagnation point (s = 0)."""
+
+    solver: str
+    x: float
+    y: float
+    pressure: Optional[float]
+    heat_flux: Optional[float]
+    peak_pressure: Optional[float]
+    peak_pressure_s: Optional[float]
+    peak_heat_flux: Optional[float]
+    peak_heat_flux_s: Optional[float]
+
+
+def stagnation_analysis(surface: SurfaceData) -> StagnationResult:
+    """Values at the stagnation point plus surface peaks and their
+    arc-length locations."""
+    i0 = int(np.argmin(surface.s))
+
+    def at0(name):
+        v = surface.fields.get(name)
+        return float(v[i0]) if v is not None else None
+
+    def peak(name):
+        v = surface.fields.get(name)
+        if v is None:
+            return None, None
+        j = int(np.argmax(v))
+        return float(v[j]), float(surface.s[j])
+
+    pk_p, pk_p_s = peak("pressure")
+    pk_q, pk_q_s = peak("heat_flux")
+    return StagnationResult(
+        solver=surface.solver,
+        x=float(surface.x[i0]), y=float(surface.y[i0]),
+        pressure=at0("pressure"), heat_flux=at0("heat_flux"),
+        peak_pressure=pk_p, peak_pressure_s=pk_p_s,
+        peak_heat_flux=pk_q, peak_heat_flux_s=pk_q_s)
+
+
+def centerline_profile(volume: VolumeData, x_nose: float,
+                       upstream_length: float, band: float,
+                       n_samples: int = 200) -> Dict[str, np.ndarray]:
+    """Field profiles along the stagnation line: points within ``band`` of
+    the axis (y ≈ 0, and z ≈ 0 for 3D volumes), upstream of the nose,
+    bin-averaged onto a uniform x grid. Returns {'x': ..., field: ...}."""
+    mask = np.abs(volume.y) <= band
+    if volume.z is not None:
+        mask &= np.abs(volume.z) <= band
+    x = volume.x
+    mask &= (x >= x_nose - upstream_length) & (x <= x_nose)
+    if not np.any(mask):
+        raise ValueError("No volume samples on the stagnation line — "
+                         "increase the search band")
+
+    xs = x[mask]
+    edges = np.linspace(xs.min(), xs.max(), n_samples + 1)
+    idx = np.clip(np.digitize(xs, edges) - 1, 0, n_samples - 1)
+    counts = np.bincount(idx, minlength=n_samples)
+    keep = counts > 0
+    out: Dict[str, np.ndarray] = {
+        "x": (0.5 * (edges[:-1] + edges[1:]))[keep]}
+    for name, values in volume.fields.items():
+        sums = np.bincount(idx, weights=values[mask], minlength=n_samples)
+        out[name] = sums[keep] / counts[keep]
+    return out
+
+
+@dataclass
+class ShockStandoff:
+    """Measured stand-off distance with the Billig correlation reference."""
+
+    distance: float          # m
+    x_shock: float           # m
+    x_nose: float            # m
+    detection_field: str
+    billig_distance: Optional[float]   # m, sphere correlation, None if n/a
+
+    @property
+    def ratio_to_billig(self) -> Optional[float]:
+        if not self.billig_distance:
+            return None
+        return self.distance / self.billig_distance
+
+
+def billig_standoff_sphere(nose_radius: float, mach: float) -> float:
+    """Billig (1967) bow-shock stand-off correlation for a sphere:
+    delta / R = 0.143 * exp(3.24 / M^2)."""
+    return nose_radius * 0.143 * math.exp(3.24 / mach ** 2)
+
+
+def billig_standoff_cylinder(radius: float, mach: float) -> float:
+    """Billig (1967) bow-shock stand-off correlation for a circular
+    cylinder in crossflow: delta / R = 0.386 * exp(4.67 / M^2)."""
+    return radius * 0.386 * math.exp(4.67 / mach ** 2)
+
+
+def shock_standoff(volume: VolumeData, freestream: Freestream,
+                   x_nose: float, body_length: float,
+                   nose_radius: Optional[float] = None,
+                   band: Optional[float] = None) -> ShockStandoff:
+    """Locate the bow shock on the stagnation line and measure its
+    stand-off distance from the nose.
+
+    The shock is taken as the upstream-most centerline sample where the
+    pressure rises above 2x freestream (or, without a pressure field,
+    where Mach drops below 90% of the freestream value).
+    """
+    band = band if band is not None else 0.03 * body_length
+    profile = centerline_profile(volume, x_nose,
+                                 upstream_length=1.5 * body_length,
+                                 band=band)
+    x = profile["x"]
+
+    if "pressure" in profile:
+        field = "pressure"
+        crossed = profile[field] > 2.0 * freestream.pressure
+    elif "mach" in profile:
+        field = "mach"
+        crossed = profile[field] < 0.9 * freestream.mach
+    else:
+        raise ValueError("Centerline profile has neither pressure nor Mach")
+
+    if not np.any(crossed):
+        raise ValueError("No shock detected on the stagnation line "
+                         f"(field '{field}')")
+    x_shock = float(x[crossed].min())
+    billig = (billig_standoff_sphere(nose_radius, freestream.mach)
+              if nose_radius else None)
+    return ShockStandoff(distance=x_nose - x_shock, x_shock=x_shock,
+                         x_nose=x_nose, detection_field=field,
+                         billig_distance=billig)

aerorare_studio-0.1.1/aerorare/archive.py

@@ -0,0 +1,146 @@
+"""Run archive (spec §2) — history and comparison of a project's runs.
+
+Every ``solvers/run_NNN`` directory is summarised into a RunRecord:
+which solvers were set up, whether they finished or failed, headline
+metrics (final SU2 residual and drag, last SPARTA step and particle
+count) and whether the run continued from a restart. The records feed
+the ``aerorare runs`` table and the GUI comparison view.
+"""
+
+from __future__ import annotations
+
+import csv
+import re
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from .project import Project
+
+
+@dataclass
+class RunRecord:
+    name: str
+    path: Path
+    created: Optional[datetime] = None
+    solvers: List[str] = field(default_factory=list)
+    restarted: bool = False
+    su2_status: str = "—"          # finished | failed | no log | —
+    su2_final_rms: Optional[float] = None
+    su2_final_cd: Optional[float] = None
+    sparta_status: str = "—"
+    sparta_last_step: Optional[int] = None
+    sparta_particles: Optional[int] = None
+    has_results: bool = False
+
+
+_SPARTA_STATS = re.compile(r"^\s*(\d+)\s+[\d.eE+-]+\s+(\d+)\s+\d+\s+\d+")
+
+
+def _su2_metrics(run_dir: Path, record: RunRecord) -> None:
+    log = run_dir / "su2.log"
+    if log.exists():
+        tail = log.read_text(errors="replace")[-4000:]
+        if "Exit Success" in tail:
+            record.su2_status = "finished"
+        elif "Error" in tail:
+            record.su2_status = "failed"
+        else:
+            record.su2_status = "interrupted"
+    elif (run_dir / "case.cfg").exists():
+        record.su2_status = "not run"
+
+    history = run_dir / "history.csv"
+    if not history.exists():
+        return
+    try:
+        with open(history, newline="") as fh:
+            reader = csv.reader(fh)
+            header = [h.strip().strip('"') for h in next(reader)]
+            last = None
+            for row in reader:
+                if row:
+                    last = row
+        if last:
+            cols = {name: float(v) for name, v in zip(header, last)}
+            record.su2_final_rms = cols.get("rms[Rho]")
+            record.su2_final_cd = cols.get("CD")
+    except (ValueError, StopIteration):
+        pass
+
+
+def _sparta_metrics(run_dir: Path, record: RunRecord) -> None:
+    log = run_dir / "sparta.log"
+    if not log.exists():
+        log = run_dir / "log.sparta"
+    if log.exists():
+        text = log.read_text(errors="replace")
+        record.sparta_status = ("finished" if "Loop time" in text else
+                                "interrupted")
+        last = None
+        for line in text.splitlines():
+            m = _SPARTA_STATS.match(line)
+            if m:
+                last = m
+        if last:
+            record.sparta_last_step = int(last.group(1))
+            record.sparta_particles = int(last.group(2))
+    elif (run_dir / "in.case").exists():
+        record.sparta_status = "not run"
+
+
+def collect_runs(project: Project) -> List[RunRecord]:
+    """RunRecords for every solvers/run_NNN directory, oldest first."""
+    records: List[RunRecord] = []
+    solvers_dir = project.root / "solvers"
+    for run_dir in sorted(solvers_dir.glob("run_*")):
+        if not run_dir.is_dir():
+            continue
+        record = RunRecord(name=run_dir.name, path=run_dir)
+        record.created = datetime.fromtimestamp(run_dir.stat().st_mtime)
+
+        cfg = run_dir / "case.cfg"
+        if cfg.exists():
+            record.solvers.append("su2")
+            if "RESTART_SOL= YES" in cfg.read_text(errors="replace"):
+                record.restarted = True
+        inp = run_dir / "in.case"
+        if inp.exists():
+            record.solvers.append("sparta")
+            if "read_restart" in inp.read_text(errors="replace"):
+                record.restarted = True
+
+        _su2_metrics(run_dir, record)
+        _sparta_metrics(run_dir, record)
+        record.has_results = (project.root / "results" / run_dir.name).is_dir()
+        records.append(record)
+    return records
+
+
+def _fmt(value, spec: str = "") -> str:
+    if value is None:
+        return "—"
+    return format(value, spec) if spec else str(value)
+
+
+def runs_table(records: List[RunRecord]) -> str:
+    """Markdown comparison table across runs (also readable as plain text)."""
+    header = ("| Run | Date | Solvers | Restart | SU2 status | rms[Rho] | CD "
+              "| SPARTA status | Step | Particles | Results |")
+    sep = "|" + "---|" * 11
+    rows = [header, sep]
+    for r in records:
+        rows.append(
+            f"| {r.name} "
+            f"| {r.created.strftime('%Y-%m-%d %H:%M') if r.created else '—'} "
+            f"| {'+'.join(r.solvers) or '—'} "
+            f"| {'yes' if r.restarted else '—'} "
+            f"| {r.su2_status} "
+            f"| {_fmt(r.su2_final_rms, '.3f')} "
+            f"| {_fmt(r.su2_final_cd, '.5f')} "
+            f"| {r.sparta_status} "
+            f"| {_fmt(r.sparta_last_step)} "
+            f"| {_fmt(r.sparta_particles, ',')} "
+            f"| {'yes' if r.has_results else '—'} |")
+    return "\n".join(rows)