pyflightstream 0.43.0__tar.gz → 0.44.0__tar.gz

{pyflightstream-0.43.0/src/pyflightstream.egg-info → pyflightstream-0.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyflightstream
-Version: 0.43.0
+Version: 0.44.0
 Summary: Version-aware, didactic Python driver for the FlightStream panel-method solver
 Author: Geovana Neves
 License: MIT
@@ -19,10 +19,11 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.2
-Requires-Dist: pandas>=2.3
 Requires-Dist: pydantic>=2
 Requires-Dist: pyyaml
 Requires-Dist: trimesh<6,>=4.12
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.3; extra == "pandas"
 Provides-Extra: plot
 Requires-Dist: matplotlib; extra == "plot"
 Provides-Extra: geom

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyflightstream"
-version = "0.43.0"
+version = "0.44.0"
 description = "Version-aware, didactic Python driver for the FlightStream panel-method solver"
 readme = "README.md"
 license = {text = "MIT"}
@@ -75,13 +75,13 @@ classifiers = [
 # is written against (field_validator, model_validator).
 dependencies = [
     "numpy>=2.2",
-    "pandas>=2.3",
     "pydantic>=2",
     "pyyaml",
     "trimesh>=4.12,<6",
 ]
 
 [project.optional-dependencies]
+pandas = ["pandas>=2.3"]
 # matplotlib is PSF/BSD-style, MIT-compatible (NFR-02); it backs the
 # plotting examples only, no core code imports it.
 plot = ["matplotlib"]
@@ -170,6 +170,10 @@ Issues = "https://github.com/nevesgeovana/pyflightstream/issues"
 [tool.setuptools.packages.find]
 where = ["src"]
 
+# Keep the artifact scanner and its policy available with the distribution.
+[tool.setuptools.data-files]
+"share/pyflightstream/tools" = ["tools/check_shipped_surface.py", "tools/shipped_surface.conf"]
+
 [tool.setuptools.package-data]
 "pyflightstream.commands" = ["*.yaml"]
 "pyflightstream.qa" = ["references/*.yaml", "references/pressure-drag/*.yaml"]

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/_textio.py

@@ -119,6 +119,17 @@ def append_text(path: str | Path, text: str, *, encoding: str = "utf-8") -> int:
         return stream.write(text)
 
 
+def write_bytes(path: str | Path, data: bytes) -> int:
+    """Replace a complete byte payload atomically through a sibling temporary file.
+
+    Keep the same permission and symlink policy as :func:`atomic_text`.
+    Latin-1 maps each byte to one character; the explicit LF newline policy
+    leaves CR, LF and CRLF bytes unchanged, including non-UTF-8 matrix comments.
+    """
+    with atomic_text(path, encoding="latin-1") as stream:
+        return stream.write(data.decode("latin-1"))
+
+
 def open_text(
     path: str | Path, mode: str = "w", *, encoding: str = "utf-8", errors: str | None = None
 ) -> IO[str]:

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/_fsi_external.py

@@ -201,7 +201,7 @@ def wire_external_fsi(
             "from pyflightstream.fsi.cli import main\n"
             "raise SystemExit(main(['external', '--out', '.']))\n"
         ),
-        "fsi-provenance.json": json.dumps(structure.provenance(), indent=2) + "\n",
+        "fsi-provenance.json": json.dumps(structure.provenance(portable=True), indent=2) + "\n",
         # FR-1095: the input itself, under the digest the record states for it
         # (the run refuses a source changed after the plan).
         Path(structure.source).name: Path(structure.source).read_bytes(),

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/_matrix_upgrade.py

@@ -6,6 +6,7 @@ import re
 from collections.abc import Mapping
 from pathlib import Path
 
+import pyflightstream._textio as _textio
 from pyflightstream.cases._matrix_layouts import (
     _COLUMNS,
     _LAYOUT_0_9_0,
@@ -209,5 +210,5 @@ def rewrite_codes(
         raise MatrixError(f"{source} holds no matrix content: no line carries a cell separator")
     rewritten = b"".join(rebuilt)
     if in_place:
-        Path(path).write_bytes(rewritten)
+        _textio.write_bytes(path, rewritten)
     return rewritten, counts

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/_setup_keys.py

@@ -372,7 +372,7 @@ class CustomFlag(BaseModel):
         if not self.command:
             raise ValueError(
                 f"the flag {self.name!r} names no command; write the FlightStream "
-                'command it becomes, bare, as command = "SET_WAKE_LENGTH"'
+                'command it becomes, bare, as command = "SET_SIGNIFICANT_DIGITS"'
             )
         if len(self.command.split()) > 1:
             raise ValueError(

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/matrix.py

@@ -56,10 +56,11 @@ from collections.abc import Mapping
 from dataclasses import dataclass, field
 from pathlib import Path
 
+import pyflightstream._textio as _textio
 from pyflightstream._errors import PyflightstreamError as PyflightstreamError
 from pyflightstream._tokens import NOT_APPLICABLE as NOT_APPLICABLE
+from pyflightstream.cases import ROTATION_OFFSET_KEY as ROTATION_OFFSET_KEY
 from pyflightstream.cases import (
-    ROTATION_OFFSET_KEY,
     ROTATION_SWEEP_KEY,
     Campaign,
     RawCommand,
@@ -904,7 +905,7 @@ def _check_one_sweep_per_row(pol: str, sweep: SweepAxis, variables: dict[str, st
 
     The refusal names the fixed-offset form, because the user asking for
     both almost always wants one rotation held fixed across an alpha
-    sweep, which is what ``angle_deg`` already does.
+    sweep, which is what a single ``ROTATE`` entry's ``ANGLE`` does.
     """
     rotation = multiplied_sweep(sweep, variables)
     if not rotation:
@@ -916,7 +917,8 @@ def _check_one_sweep_per_row(pol: str, sweep: SweepAxis, variables: dict[str, st
         f"two would multiply into {len(sweep.values) * len(rotation)} runs this row "
         "does not name and whose points cannot "
         "be told apart. A rotation held FIXED across an aerodynamic sweep is written "
-        f"{ROTATION_OFFSET_KEY}: <angle>, one value; a sweep OF the rotation is a row "
+        "ROTATE: {ANGLE: <angle> / AXIS: MRP-Y / ALIAS: <boundary label>}, one angle; "
+        "a sweep OF the rotation is a row "
         "of its own with a single-point SWEEP_VALUES."
     )
 
@@ -964,9 +966,22 @@ def _unknown_columns_sentence(header: tuple[str, ...]) -> str:
     return "".join(sentences)
 
 
+def matrix_content_line(line: str) -> bool:
+    """Classify UTF-8 matrix text for both execution and byte-preserving Excel sync.
+
+    Blank lines, hash comments and rules containing only whitespace, pipes,
+    dashes, colons and plus signs carry no cells. All other lines need parsing.
+    """
+    stripped = line.strip()
+    return bool(stripped) and not stripped.startswith("#") and not set(stripped) <= set("-:+| \t")
+
+
 def read_matrix(path: str | Path, *, active_only: bool = True) -> list[MatrixRow]:
     """Read a pipe-delimited ``matrix.fs`` run matrix.
 
+    Decode strict UTF-8 with an optional BOM. Skip hash comments, blank lines
+    and separator rules using the same classifier as Excel sync.
+
     Parameters
     ----------
     path : str or Path
@@ -1008,13 +1023,13 @@ def read_matrix(path: str | Path, *, active_only: bool = True) -> list[MatrixRow
     [('9001', 1)]
     """
     try:
-        lines = Path(path).read_text(encoding="utf-8").splitlines()
+        lines = Path(path).read_text(encoding="utf-8-sig").splitlines()
     except UnicodeDecodeError as error:
         raise MatrixError(
             f"{path} is not valid UTF-8 (byte {error.start}); a replaced character would alter "
             "a declared input, so save the matrix as UTF-8."
         ) from None
-    content = [line for line in lines if line.strip() and not set(line.strip()) <= {"-"}]
+    content = [line for line in lines if matrix_content_line(line)]
     if not content:
         raise MatrixError(f"{path} holds no matrix content")
     header = tuple(cell.strip() for cell in content[0].split("|"))
@@ -1331,7 +1346,7 @@ def renumber_pols(
         )
     rewritten = b"".join(rebuilt)
     if in_place:
-        Path(path).write_bytes(rewritten)
+        _textio.write_bytes(path, rewritten)
     return rewritten
 
 

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/mesh.py

@@ -7,9 +7,9 @@ how its trailing edges are found; :class:`RawMeshConditions` the boundary
 conditions a raw mesh's sidecar declares; and :class:`BaseRegionOperation` and
 :class:`PortBoundary` the base regions and the ports a setup declares.
 
-The package root re-exports these models (AD-16). This module imports none of the other five model
-modules and never the package root; :mod:`pyflightstream.cases.settings`
-imports it.
+The package root re-exports these models (AD-16). This module imports the shared
+configuration error from reference_blocks and never the package root;
+:mod:`pyflightstream.cases.settings` imports it.
 """
 
 from __future__ import annotations
@@ -18,12 +18,20 @@ import math
 from collections.abc import Mapping, Sequence
 from typing import Annotated, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+    model_serializer,
+    model_validator,
+)
 
 # The CCS geometry table, a table of a geometry sidecar's [import]; its
 # module imports only pydantic and the script row, so the package may import it
 # while it loads.
 from pyflightstream.cases._ccs import CcsImportOptions
+from pyflightstream.cases.reference_blocks import CampaignConfigError
 
 __all__ = [
     "EVERY_SURFACE",
@@ -279,6 +287,20 @@ class MeshImport(BaseModel):
 TrailingEdgeRoute = Literal["file", "detect", "none"]
 
 
+class TrailingEdgeSet(BaseModel):
+    """One points file and the type applied to its trailing edges, in metres."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True, allow_inf_nan=False)
+    edge_type: Literal["STANDARD", "RELAXED", "JET_OUTFLOW", "VORTEX_SHEDDING"] = "STANDARD"
+    points_m: tuple[tuple[float, float, float], ...] = ()
+    points_file: str | None = Field(default=None, exclude=True)
+
+    @field_validator("edge_type", mode="before")
+    @classmethod
+    def _uppercase(cls, value: object) -> object:
+        return value.strip().upper() if isinstance(value, str) else value
+
+
 class TrailingEdgeMarking(BaseModel):
     """How a raw mesh's trailing edges are marked: its sidecar's ``[trailing_edges]`` (G02).
 
@@ -313,17 +335,66 @@ class TrailingEdgeMarking(BaseModel):
     model_config = ConfigDict(extra="forbid", frozen=True)
 
     route: TrailingEdgeRoute
-    edge_type: str = "STANDARD"
     tolerance: float = 0.0001
-    points_m: tuple[tuple[float, float, float], ...] = ()
-    points_file: str | None = Field(default=None, exclude=True)
+    sets: tuple[TrailingEdgeSet, ...] = ()
     detect_surfaces: tuple[str, ...] = ()
     sweep_angle_deg: float | None = None
 
-    @field_validator("edge_type", mode="before")
+    @model_validator(mode="before")
     @classmethod
-    def _one_word_in_capitals(cls, value: object) -> object:
-        return value.strip().upper() if isinstance(value, str) else value
+    def _legacy_file(cls, value: object) -> object:
+        if not isinstance(value, Mapping):
+            return value
+        data = dict(value)
+        legacy = {
+            key: data.pop(key) for key in ("edge_type", "points_m", "points_file") if key in data
+        }
+        if "sets" not in data and (data.get("route") == "file" or legacy):
+            data["sets"] = (legacy,)
+        return data
+
+    @property
+    def edge_type(self) -> str:
+        """Return the first file's type for single-file callers."""
+        return self.sets[0].edge_type if self.sets else "STANDARD"
+
+    @property
+    def points_m(self) -> tuple[tuple[float, float, float], ...]:
+        """Return the first file's points in metres."""
+        return self.sets[0].points_m if self.sets else ()
+
+    @property
+    def points_file(self) -> str | None:
+        """Return the first file's local path, excluded from records."""
+        return self.sets[0].points_file if self.sets else None
+
+    def model_copy(self, *, update=None, deep=False):
+        """Preserve the legacy first-file update spelling for existing callers."""
+        values = dict(update or {})
+        first = {
+            key: values.pop(key)
+            for key in ("edge_type", "points_m", "points_file")
+            if key in values
+        }
+        if first:
+            entry = self.sets[0] if self.sets else TrailingEdgeSet()
+            values["sets"] = (entry.model_copy(update=first, deep=deep), *self.sets[1:])
+        return super().model_copy(update=values, deep=deep)
+
+    @model_serializer(mode="wrap")
+    def _record(self, handler):
+        data = handler(self)
+        sets = data.pop("sets")
+        record = {
+            "route": data.pop("route"),
+            "edge_type": self.edge_type,
+            "tolerance": data.pop("tolerance"),
+            "points_m": sets[0]["points_m"] if sets else [],
+            **data,
+        }
+        if len(sets) > 1:
+            record["sets"] = sets
+        return record
 
     @model_validator(mode="after")
     def _one_route_and_sound_values(self) -> TrailingEdgeMarking:
@@ -385,7 +456,7 @@ class BaseRegionOperation(BaseModel):
         "remesh",
         "select_faces",
     ]
-    #: Mesh boundary for creation or outflow marking; all is only allowed for outflow marking.
+    #: Mesh boundary for creation/outflow marking, or an earlier region's boundary name.
     boundary: str | Annotated[int, Field(ge=1)] | None = None
     #: Current base-region index; all is only allowed for trailing-edge marking or face selection.
     index: Annotated[int, Field(ge=1)] | Literal["all"] | None = None
@@ -401,9 +472,9 @@ class BaseRegionOperation(BaseModel):
         allowed = {
             "create": {"boundary", "model", "cp"},
             "mark_outflow_edges": {"boundary"},
-            "set_pressure": {"index", "model", "cp"},
-            "remesh": {"index", "mesh"},
-        }.get(self.operation, {"index"})
+            "set_pressure": {"index", "boundary", "model", "cp"},
+            "remesh": {"index", "boundary", "mesh"},
+        }.get(self.operation, {"index", "boundary"})
         for name in ("boundary", "index", "model", "cp", "mesh"):
             if name not in allowed and getattr(self, name) is not None:
                 raise ValueError(f"{name} does not apply to base-region {self.operation}")
@@ -415,8 +486,14 @@ class BaseRegionOperation(BaseModel):
         elif self.operation == "mark_outflow_edges":
             if self.boundary is None or self.boundary == "":
                 raise ValueError("base-region mark_outflow_edges requires boundary")
-        elif self.index is None:
-            raise ValueError(f"base-region {self.operation} requires index")
+        elif self.operation in {
+            "set_pressure",
+            "delete",
+            "mark_trailing_edges",
+            "remesh",
+            "select_faces",
+        }:
+            self._followup_selector()
         if self.boundary == "all" and self.operation != "mark_outflow_edges":
             raise ValueError("base-region create has no documented all form")
         if self.index == "all" and self.operation not in {"mark_trailing_edges", "select_faces"}:
@@ -432,6 +509,19 @@ class BaseRegionOperation(BaseModel):
             raise ValueError("base-region remesh requires mesh parameters")
         return self
 
+    def _followup_selector(self) -> None:
+        """Require one explicit index or one previously created/declared boundary name."""
+        if self.boundary is None:
+            if self.index is None:
+                raise CampaignConfigError(
+                    f"base-region {self.operation} requires index or boundary"
+                )
+            return
+        if self.index is not None:
+            raise CampaignConfigError("base-region selection requires index or boundary, not both")
+        if not isinstance(self.boundary, str) or not self.boundary.strip():
+            raise CampaignConfigError("a follow-up base-region boundary must be a nonempty name")
+
 
 class PortBoundary(BaseModel):
     """A normal-velocity inlet or outlet; an inlet may also bind a native profile."""
@@ -472,6 +562,15 @@ class PortBoundary(BaseModel):
         return self
 
 
+class WakeTerminationMarking(BaseModel):
+    """Explicit wake-termination vertices, matched in metres before emission."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True, allow_inf_nan=False)
+    points_file: str = Field(exclude=True)
+    tolerance: float = Field(default=0.0001, gt=0)
+    nodes: tuple[int, ...] = ()
+
+
 class RawMeshConditions(BaseModel):
     """The boundary conditions a raw mesh's sidecar declares (G02, Q1).
 
@@ -495,7 +594,7 @@ class RawMeshConditions(BaseModel):
     #: Stable geometric port identities mapped to exact surface names after import renames.
     ports: dict[str, str] = Field(default_factory=dict)
     trailing_edges: TrailingEdgeMarking | None = None
-    wake_termination: Literal["auto"] | tuple[str, ...] | None = None
+    wake_termination: Literal["auto"] | tuple[str, ...] | WakeTerminationMarking | None = None
     base_regions: Literal["auto"] | None = None
     inlets: tuple[PortBoundary, ...] = ()
     outlets: tuple[PortBoundary, ...] = ()

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/pproc.py

@@ -1561,7 +1561,7 @@ class PhaseLockedSpec(BaseModel):
     of THAT rotor, and never the length of the exported window.
 
     ``last_revolutions_avg`` is how many of the last revolutions enter the mean
-    at each azimuth. It may not exceed ``min_revolutions``: a reduction may not
+    at each azimuth, at least one. It may not exceed ``min_revolutions``: a reduction may not
     average over more history than it required in order to exist.
 
     NOT REACHING THE MINIMUM NEVER REFUSES ANOTHER PRODUCT. This is a gate on
@@ -1581,7 +1581,7 @@ class PhaseLockedSpec(BaseModel):
     #: Total revolutions the matrix must specify before this is generated.
     min_revolutions: float = Field(gt=0.0, allow_inf_nan=False)
     #: How many of the LAST revolutions the average uses.
-    last_revolutions_avg: float = Field(gt=0.0, allow_inf_nan=False)
+    last_revolutions_avg: float = Field(ge=1.0, allow_inf_nan=False)
 
     @model_validator(mode="after")
     def _averages_no_more_than_it_required(self) -> PhaseLockedSpec:
@@ -1952,6 +1952,17 @@ class _NoiseSpec(BaseModel):
     #: Explicit in-plane loading radius in metres; omitted uses the inferred centroid.
     inplane_radius_m: float | None = Field(default=None, gt=0.0)
 
+    #: Number of blade-passage orders in the exploratory harmonic table.
+    gutin_orders: int = Field(default=4, ge=1, strict=True)
+    #: Workspace-relative reference CSV per observer; an empty string omits one.
+    reference: list[str] | None = None
+
+    @model_validator(mode="after")
+    def _noise_references(self):
+        if self.reference is not None and len(self.reference) != len(self.observers_m):
+            raise ValueError("noise.reference needs one CSV path or empty string per observer")
+        return self
+
 
 class PprocSpec(BaseModel):
     """The post-processing specification a matrix row's PPROC cell names.

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/qsteady.py

@@ -397,6 +397,7 @@ def reduced_frequencies(
     omega_rad_s: float,
     velocity_m_per_s: float,
     source: str,
+    band_widths_m: Sequence[float] | None = None,
 ) -> ReducedFrequencies:
     """Return the reduced frequency of every station, sorted by radius.
 
@@ -412,6 +413,9 @@ def reduced_frequencies(
         The free-stream speed in metres per second.
     source : str
         Where the chords came from, ``mesh`` or ``sections``.
+    band_widths_m : sequence of float, optional
+        Full widths of mesh bands, in station order. Nodal sections omit this
+        and retain midpoint strips with half-width end stations.
 
     Returns
     -------
@@ -440,7 +444,15 @@ def reduced_frequencies(
         )
         for radius, chord in zip(radii, chords, strict=True)
     )
-    return ReducedFrequencies(radii, chords, values, strip_lengths(radii), source)
+    strips = strip_lengths(radii) if band_widths_m is None else _band_widths(radii_m, band_widths_m)
+    return ReducedFrequencies(radii, chords, values, strips, source)
+
+
+def _band_widths(radii: Sequence[float], widths: Sequence[float]) -> tuple[float, ...]:
+    """Validate full-band weights and sort them with their station radii."""
+    if len(widths) != len(radii) or any(not math.isfinite(w) or w <= 0 for w in widths):
+        raise CampaignConfigError("band_widths_m needs one finite positive width per station")
+    return tuple(w for _, w in sorted(zip(radii, widths, strict=True), key=lambda row: abs(row[0])))
 
 
 def _sub(a: Sequence[float], b: Sequence[float]) -> Vector:
@@ -468,7 +480,7 @@ def blade_stations(
     hub: Sequence[float],
     axis: Sequence[float],
     count: int = DEFAULT_STATIONS,
-) -> tuple[tuple[float, ...], tuple[float, ...]]:
+) -> tuple[tuple[float, ...], tuple[float, ...], tuple[float, ...]]:
     """Estimate a blade's chord at ``count`` radial stations from its surface vertices.
 
     The blade's span, from its innermost to its outermost vertex measured from
@@ -492,9 +504,9 @@ def blade_stations(
 
     Returns
     -------
-    tuple of (radii, chords)
+    tuple of (radii, chords, band_widths)
         Per station with two vertices or more, the band's mid radius and the
-        chord estimate, in metres, in ascending radius.
+        chord estimate and full band width, in metres, in ascending radius.
 
     Raises
     ------
@@ -543,7 +555,7 @@ def blade_stations(
             chord = max(chord, max(projections) - min(projections))
         radii.append(r_low + (index + 0.5) * width)
         chords.append(chord)
-    return tuple(radii), tuple(chords)
+    return tuple(radii), tuple(chords), (width,) * len(radii)
 
 
 def obj_group_vertices(path: str | Path, *, metres_per_unit: float) -> dict[str, list[Vector]]:
@@ -994,6 +1006,8 @@ class QsteadyRecord:
     blade1_azimuth_deg: float
     positions: tuple[QsteadyClocking, ...]
     validity: Mapping[str, Any] | None
+    #: MRP origin in geometry coordinates, metres; None for historical records without it.
+    moment_point_m: tuple[float, float, float] | None = None
 
     def solve_order(self) -> tuple[QsteadyClocking, ...]:
         """Return the clockings in the order the run solved them: 1 to k - 1, then 0.
@@ -1023,6 +1037,7 @@ class QsteadyRecord:
             "blade1_azimuth_deg": self.blade1_azimuth_deg,
             "positions": [clocking.as_json() for clocking in self.positions],
             "validity": self.validity,
+            "moment_point_m": self.moment_point_m and list(self.moment_point_m),
         }
 
     def to_text(self) -> str:
@@ -1177,7 +1192,7 @@ def _parse_record(data: object) -> QsteadyRecord:
             f"is of schema {version!r}; this package writes and reads schema "
             f"{RECORD_SCHEMA_VERSION} only"
         )
-    _exact_keys(data, _RECORD_KEYS, "record")
+    _exact_keys(data, _RECORD_KEYS, "record", optional=("moment_point_m",))
     if data["run_type"] != RECORD_RUN_TYPE:
         raise QsteadyRecordError(f"is of run type {data['run_type']!r}, not {RECORD_RUN_TYPE!r}")
     case = data["case"]
@@ -1205,6 +1220,11 @@ def _parse_record(data: object) -> QsteadyRecord:
         blade1_azimuth_deg=_record_number(data["blade1_azimuth_deg"], "blade1_azimuth_deg"),
         positions=tuple(_record_clocking(value, at) for at, value in enumerate(positions)),
         validity=validity,
+        moment_point_m=(
+            _record_vector(data["moment_point_m"], "moment_point_m")
+            if data.get("moment_point_m") is not None
+            else None
+        ),
     )
 
 

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/settings.py

@@ -110,8 +110,8 @@ class ReferenceData(BaseModel):
     rotor_position_m: tuple[float, float, float] | None = None
     #: WHICH MODEL AXIS EACH BODY RATE TURNS ABOUT, from the
     #: reference artifact's ``[body_axes]`` table: ``roll``, ``pitch`` and
-    #: ``yaw`` to ``X``, ``Y`` or ``Z``. A mesh is built in whatever
-    #: orientation its author chose, and a rotating free stream has to be
+    #: ``yaw`` to ``X``, ``Y`` and ``Z``, respectively. Only that mapping's
+    #: signs are measured (RPT-052/RPT-060). A rotating free stream has to be
     #: given an AXIS of a frame, so the row cannot state one without the
     #: reference saying which axis is which. Empty for a reference that
     #: declares none, and a row stating a rate against such a reference is
@@ -157,6 +157,18 @@ class ReferenceData(BaseModel):
             )
         return axes
 
+    @field_validator("body_axes")
+    @classmethod
+    def _axes_have_measured_rate_signs(cls, axes: dict[str, str]) -> dict[str, str]:
+        """Keep rate signs within the axis mapping measured by RPT-052 and RPT-060."""
+        standard = {"roll": "X", "pitch": "Y", "yaw": "Z"}
+        if any(axis != standard[rate] for rate, axis in axes.items()):
+            raise ValueError(
+                "body_axes supports only roll=X, pitch=Y, yaw=Z: RPT-052 and RPT-060 "
+                "did not measure a permuted mesh, so its rate signs are unavailable"
+            )
+        return axes
+
 
 def _resolve_settings_toggle(value: object) -> object:
     """Resolve a settings toggle in either vocabulary, before validation.
@@ -472,16 +484,19 @@ class SolverSettings(BaseModel):
     #: setting a run applied: by the build guard naming the command on 25.100
     #: onward, and on 25.000 by the INITIALIZE_SOLVER helper, as every case is.
     legacy_solver_model: str | None = None
-    #: Explicit BC overrides, emitted before runtime/init settings. RELAXED remains deferred.
+    #: Explicit BC overrides, emitted before runtime/init settings and checked per build.
     trailing_edge_types: (
-        dict[Annotated[int, Field(ge=1)], Literal["STANDARD", "JET_OUTFLOW", "VORTEX_SHEDDING"]]
+        dict[
+            Annotated[int, Field(ge=1)],
+            Literal["STANDARD", "RELAXED", "JET_OUTFLOW", "VORTEX_SHEDDING"],
+        ]
         | None
     ) = None
     #: One-based trailing-edge indices whose wake nodes are disabled.
     disabled_wake_trailing_edges: list[Annotated[int, Field(ge=1)]] | None = None
     #: Boundary labels or indices on which leading-edge wakes are detected.
     leading_edge_wake_boundaries: list[int | str] | None = Field(default=None, min_length=1)
-    #: Explicitly mark wake termination nodes; no implicit detection is requested.
+    #: Refused: selects no node. Use the geometry sidecar's [wake_termination] file route.
     mark_wake_termination_nodes: Literal[True] | None = None
     #: Ports selected by setup; surface identity is bound from the geometry and values from MATRIX.
     ports: tuple[PortBoundary, ...] = ()
@@ -666,8 +681,8 @@ class SolverSettings(BaseModel):
     #: not carry is left out, and a list that resolves to none is refused.
     analysis_families: list[str] | None = None
     #: SET_LOADS_AND_MOMENTS_UNITS: the unit the loads table prints, one of the
-    #: tokens the command takes on the row's build. The polar and every product
-    #: read coefficients, so a point exported in another unit writes no product.
+    #: tokens the command takes on the row's build. Load-table polars, superfiles
+    #: and rotor coefficients need COEFFICIENTS; independent exports remain available.
     load_units: str | None = None
     #: SET_INVISCID_LOADS: the loads and moments without their viscous part.
     inviscid_loads: SolverToggle | None = None

{pyflightstream-0.43.0 → pyflightstream-0.44.0}/src/pyflightstream/cases/setup_surfaces.py

@@ -1,8 +1,8 @@
 """Setup operations on a point's surfaces: removing surfaces, and the wake option it emits.
 
 Pipeline role: the cases row, where a row's solver commands are emitted.
-It emits the removal of the surfaces a setup names, with the renumbering
-of the surface inventory that removal causes, and the slipstream wake
+It emits the removal of the surfaces a setup names, preserving survivor
+IDs in the surface inventory, and the slipstream wake
 stabilization a setup states.
 
 Two setup keys reach the solver here, each through a short hook in
@@ -10,15 +10,11 @@ Two setup keys reach the solver here, each through a short hook in
 
 ``delete_surfaces``
     Boundaries named by NAME, alias or family, never by index. Each is
-    removed with ``DELETE_SURFACES``. The solver renumbers the surfaces
-    after a deleted one, so the inventory the script holds is rewritten
-    to the surviving names at their new indices, and every later command
-    and the run record's inventory read the new numbering. Licensed
-    probe round 1 on 26.124 (probe ``D1_delete_surfaces``):
-    ``DELETE_SURFACES 3`` on a four-surface mesh (Body, Base, Blade1,
-    Blade2) left Body, Base, Blade2, and only Blade2 moved, to index 3.
-    A family is removed from its last member so no index shifts under
-    the next command. Where the row's reference declares the study's
+    removed with ``DELETE_SURFACES``. Survivors keep their original IDs,
+    as measured on 26.124 and 26.125 in the committed fixture
+    ``pfs2119_016_delete_surfaces_ids_2026-10-16.md``. Tree position after
+    deletion is not an ID. Later selections use the retained IDs.
+    Families are removed in descending ID order. Where the row's reference declares the study's
     vocabulary (FR-435), a name the study holds and the row's model lacks
     is skipped and said, and a list every name of which is skipped emits
     no removal.
@@ -79,7 +75,7 @@ _OPENED: WeakKeyDictionary[Script, tuple[str, ...]] = WeakKeyDictionary()
 
 
 def emit_setup_surfaces(script: Script, case: SimCase) -> None:
-    """Emit the removal of the surfaces the case's setup names, and renumber the inventory.
+    """Emit removal of the named surfaces, preserving every surviving boundary ID.
 
     Nothing is emitted, and the script is left as it was, when the setup
     states no ``delete_surfaces``.
@@ -146,14 +142,7 @@ def emit_setup_surfaces(script: Script, case: SimCase) -> None:
     _OPENED.setdefault(script, tuple(ordered))
     for index in sorted(doomed, reverse=True):
         script.emit(_DELETE, index)
-    survivors = tuple(name for position, name in enumerate(inventory, 1) if position not in doomed)
-    script.boundary_inventory = survivors
-    renumbered = {
-        name: new_index
-        for new_index, name in enumerate(survivors, 1)
-        if name in labels and survivors.count(name) == 1
-    }
-    script.entities.renumber_boundaries(renumbered, len(survivors))
+    script.boundary_inventory = tuple(name for name in inventory if labels.get(name) not in doomed)
 
 
 def emit_wake_stabilization(