flow-props 0.2.1__tar.gz → 0.3.0__tar.gz

{flow_props-0.2.1 → flow_props-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flow-props
-Version: 0.2.1
+Version: 0.3.0
 Summary: Extract flow properties from CFD data: boundary layer, entropy layer, shock
 Author-email: Christoph Hader <christoph.hader@gmail.com>
 License-Expression: GPL-3.0-or-later

{flow_props-0.2.1 → flow_props-0.3.0}/docs/api/shock.md

@@ -11,7 +11,8 @@ writes the shock curve (see [Shock Extraction](../theory/shock.md) for the metho
 
 - `find_shock_on_line(values, level=0.5, min_rise=0.05, max_thickness=20.0, method="walk",
   indicator_threshold=0.0025)`: the shock on one line, as a `ShockCrossing` (fractional
-  `j`, `j_tail`, `j_foot`, `thickness_cells`, `detected_by`), or `None`
+  `j`, `j_tail`, the outer edge `j_foot`, `thickness_cells`, `detected_by`, and each
+  detector's own point `j_walk`, `j_indicator`, whatever the method), or `None`
 - `extract_shock(ds, quantity="pressure", ..., method="walk", indicator_threshold=0.0025)`:
   every line of a dataset, as a `ShockExtraction` (station, x, y, j, distance,
   thickness_cells, detected_by, and the stations without a shock)

{flow_props-0.2.1 → flow_props-0.3.0}/docs/theory/shock.md

@@ -65,6 +65,41 @@ On a shock-line grid the shock is meant to lie on grid line `shock_line_j`. The
 gives each line's offset $j_\text{shock} - j_s$ in cells, and the run summary the range of
 offsets and the number of lines more than a quarter cell off.
 
+## Checks in the Report
+
+Both detectors run on every line, whichever the method, so each result can be checked
+against the other. The run summary warns when
+
+- the shock's outer edge (where $q$ crosses 10 % of the jump) lies within 5 cells of the
+  outer boundary: too little freestream outside it to read $q_\infty$ from, or a
+  disturbance ahead of the shock was taken for it;
+- the walk and the indicator differ by more than 3 cells on a line: one of them found
+  something else. A smooth compression ahead of the shock (e.g. freestream compressed
+  against a bent symmetry line) is met first by the walk, while the indicator, which
+  only flags sharp jumps, finds the shock.
+
+It also counts how often the shock's outer edge changes grid row along the body and, on
+a shock-line grid, how often it crosses the shock line `shock_line_j`. A captured shock
+that moves between rows makes a solver's wall quantities wave; on a converged
+shock-line grid the edge stays on one side of the shock line.
+
+## Solutions at Cell Centres
+
+A finite-volume solution holds cell values. Read through cfd-io as fields at the cell
+centres of the vertex grid (association `cell`: one point fewer than the grid in each
+direction), they are put on a grid of the cell centres, each the mean of its cell's
+corners, and the shock is found along the lines through them. Those lines lie half a
+cell from the vertex grid's lines, so:
+
+- the shock line `shock_line_j` counts vertices, and cell $j$ lies at $j + 0.5$ on the
+  vertex grid; the report's `j_shock` and the offsets use that, and the run summary
+  says the solution was at cell centres;
+- the first line runs half a cell off the symmetry axis, so the curve starts there;
+  grid-generator continues a curve that starts slightly off the axis to it.
+
+A solution whose grid is the cell centres themselves (stored as an ordinary grid)
+can't be told from vertex data; write cell values on the vertex grid instead.
+
 ## Smoothing the Curve
 
 The extracted curve becomes a grid line of the next grid, so line-to-line jitter of the

{flow_props-0.2.1 → flow_props-0.3.0}/docs/user-guide/config-files.md

@@ -27,6 +27,10 @@ dx  = 0.05
 # Mode 3: list = [10, 50, 100]
 ```
 
+A solution with cell values (a finite-volume solver's, read by cfd-io as fields at the
+cell centres of the vertex grid) is handled by every calculation: the profiles run
+through the cell centres, starting at the first one, half a cell off the wall.
+
 `bl` (with the `htot_derivative` criterion) and `entropy-layer` need $\gamma$ and $R$.
 They come from the solution's HDF5 attributes (`gamma`, `r_gas`), then a
 `flow_conditions.json` next to the solution file, and can be overridden:

{flow_props-0.2.1 → flow_props-0.3.0}/docs/user-guide/output.md

@@ -28,7 +28,8 @@ in the local wall frame).
 - `shock_report.dat`: the shock location for Tecplot, one I-ordered zone with one row per
   grid line with a shock. `x`, `y` are the shock points as found, so loading the file
   over the flow field draws the shock; then the wall point `x_wall`, `y_wall`, `station`,
-  the shock point's fractional grid index `j_shock`, the `distance` from the wall along
+  the shock point's fractional grid index `j_shock`, its outer edge `j_foot` (where the
+  quantity crosses 10 % of the jump), the `distance` from the wall along
   the grid line, the captured `thickness_cells`, and,
   when a shock line is known, `offset_cells` (`j_shock - shock_line_j`; positive means the
   solution's shock lies outside the grid's shock line). With smoothing, also the smoothed

{flow_props-0.2.1 → flow_props-0.3.0}/src/flow_props/calculators/bl.py

@@ -18,6 +18,7 @@ import numpy as np
 from pydantic import BaseModel, ConfigDict, Field
 
 from flow_props.calculators.common import (
+    AT_CELL_CENTRES,
     GAS_BLOCK,
     INPUT_BLOCK,
     STATIONS_BLOCK,
@@ -29,6 +30,7 @@ from flow_props.calculators.common import (
     load_dataset,
     resolve_gas_properties,
     resolve_stations,
+    solution_points,
 )
 
 logger = logging.getLogger(__name__)
@@ -109,8 +111,8 @@ def run_case(cfg: BLCaseConfig, config_dir: Path) -> list[str]:
     # -- resolve file paths relative to config directory --
     fname, gname = input_paths(cfg, config_dir)
 
-    # -- load CFD dataset via cfd_io --
-    ds = load_dataset(fname, gname)
+    # -- load CFD dataset via cfd_io (cell values go on a grid of the cell centres) --
+    ds, location = solution_points(load_dataset(fname, gname))
 
     # -- resolve station list --
     stations = resolve_stations(ds, cfg.stations)
@@ -144,6 +146,13 @@ def run_case(cfg: BLCaseConfig, config_dir: Path) -> list[str]:
         f"Wrote: {output_path}",
     ]
 
+    if location == AT_CELL_CENTRES:
+        report.insert(
+            1,
+            "  solution at cell centres: profiles run through them, from the first cell "
+            "centre (half a cell off the wall)",
+        )
+
     return report
 
 

{flow_props-0.2.1 → flow_props-0.3.0}/src/flow_props/calculators/common.py

@@ -21,6 +21,8 @@ from typing import TypeVar
 
 import numpy as np
 from cfd_io.dataset import Dataset, StructuredGrid
+from cfd_io.dataset import Field as FlowField
+from numpy.typing import NDArray
 from pydantic import BaseModel, ConfigDict, Field, ValidationError, model_validator
 
 logger = logging.getLogger(__name__)
@@ -28,6 +30,10 @@ logger = logging.getLogger(__name__)
 # any calculation's config model (load_config returns the model it is given)
 ConfigModel = TypeVar("ConfigModel", bound=BaseModel)
 
+# where a solution's fields sit (see solution_points)
+AT_VERTICES = "vertices"
+AT_CELL_CENTRES = "cell centres"
+
 # --------------------------------------------------
 # config models (input boundary)
 # --------------------------------------------------
@@ -230,6 +236,60 @@ def load_dataset(fname: Path, gname: Path | None) -> Dataset:
     return read_file(fname)
 
 
+def solution_points(ds: Dataset) -> tuple[Dataset, str]:
+    """The dataset whose grid points carry the flow fields, and where those points are.
+
+    Fields at the grid points (cfd-io association "node", e.g. SU2's vertex data) are
+    used as they are. Fields at the cell centres ("cell": a finite-volume solution's
+    cell values on its vertex grid, e.g. Eilmer's) are put on a grid of the cell
+    centres, each the mean of its cell's corners. That grid's lines run through the
+    cell centres, so a profile starts at the first cell centre (half a cell off the
+    wall), and its j counts cells: cell j lies at j + 0.5 on the vertex grid.
+
+    Args:
+        ds: Dataset as read by cfd-io.
+
+    Returns:
+        The dataset to take profiles from, and AT_VERTICES or AT_CELL_CENTRES.
+
+    Raises:
+        ValueError: If the fields sit at different places (some at the grid points,
+            some at the cell centres), or the cell fields don't fit the grid.
+    """
+
+    # where the fields sit
+    associations = {field.association for field in ds.flow.values()}
+    if not associations or associations == {"node"}:
+        return ds, AT_VERTICES
+    if associations != {"cell"}:
+        places = ", ".join(sorted(associations))
+        raise ValueError(
+            f"the solution's fields sit at different places ({places}); flow-props needs "
+            "them all at the grid points or all at the cell centres"
+        )
+
+    # the cell-centre grid: each centre the mean of its cell's corners
+    centre_x = _cell_centres(np.asarray(ds.grid.x, dtype=float))
+    centre_y = _cell_centres(np.asarray(ds.grid.y, dtype=float))
+    centre_z = _cell_centres(np.asarray(ds.grid.z, dtype=float))
+    grid = StructuredGrid(x=centre_x, y=centre_y, z=centre_z)
+
+    # the cell values, now at the points of that grid
+    flow: dict[str, FlowField] = {}
+    for name, field in ds.flow.items():
+        if field.data.shape != centre_x.shape:
+            raise ValueError(
+                f"cell field {name} has shape {field.data.shape}; the grid's cells are "
+                f"{centre_x.shape}"
+            )
+        flow[name] = FlowField(data=field.data, association="node")
+
+    # debug output for devs
+    logger.debug("solution at cell centres: profiles on a %s grid of cell centres", grid.shape)
+
+    return Dataset(grid=grid, flow=flow, attrs=ds.attrs), AT_CELL_CENTRES
+
+
 def input_paths(config: CaseConfig, config_dir: Path) -> tuple[Path, Path | None]:
     """Resolve the solution and grid file paths relative to the config file's folder.
 
@@ -345,6 +405,21 @@ def resolve_gas_properties(
 # --------------------------------------------------
 
 
+def _cell_centres(corners: NDArray[np.float64]) -> NDArray[np.float64]:
+    """Cell centres of a structured (ni, nj, nk) array: the mean of each cell's corners.
+
+    A 2D grid (nk = 1) keeps its single k-plane.
+    """
+
+    # average neighbours along i, then j, then k (if the grid has cells in k)
+    centres = 0.5 * (corners[:-1, :, :] + corners[1:, :, :])
+    centres = 0.5 * (centres[:, :-1, :] + centres[:, 1:, :])
+    if centres.shape[2] > 1:
+        centres = 0.5 * (centres[:, :, :-1] + centres[:, :, 1:])
+
+    return centres
+
+
 def _metadata_number(value: object) -> float | None:
     """Read a scalar or unit-tagged value from cfd-io attributes or JSON."""
     if value is None:

{flow_props-0.2.1 → flow_props-0.3.0}/src/flow_props/calculators/entropy_layer.py

@@ -16,6 +16,7 @@ from pathlib import Path
 from pydantic import BaseModel, ConfigDict, Field
 
 from flow_props.calculators.common import (
+    AT_CELL_CENTRES,
     GAS_BLOCK,
     INPUT_BLOCK,
     STATIONS_BLOCK,
@@ -27,6 +28,7 @@ from flow_props.calculators.common import (
     load_dataset,
     resolve_gas_properties,
     resolve_stations,
+    solution_points,
 )
 
 logger = logging.getLogger(__name__)
@@ -115,9 +117,10 @@ def run_case(cfg: EntropyLayerCaseConfig, config_dir: Path) -> list[str]:
     from flow_props.entropy_layer import run_entropy
     from flow_props.output import write_station_output
 
-    # resolve file paths relative to the config directory, then load the dataset
+    # resolve file paths relative to the config directory, then load the dataset (cell
+    # values go on a grid of the cell centres)
     fname, gname = input_paths(cfg, config_dir)
-    ds = load_dataset(fname, gname)
+    ds, location = solution_points(load_dataset(fname, gname))
 
     # resolve the stations and the gas constants (the entropy rise needs both)
     stations = resolve_stations(ds, cfg.stations)
@@ -159,4 +162,11 @@ def run_case(cfg: EntropyLayerCaseConfig, config_dir: Path) -> list[str]:
         f"Wrote: {output_path}",
     ]
 
+    if location == AT_CELL_CENTRES:
+        report.insert(
+            1,
+            "  solution at cell centres: profiles run through them, from the first cell "
+            "centre (half a cell off the wall)",
+        )
+
     return report

{flow_props-0.2.1 → flow_props-0.3.0}/src/flow_props/calculators/profiles.py

@@ -17,6 +17,7 @@ from typing import Literal
 from pydantic import BaseModel, ConfigDict, Field
 
 from flow_props.calculators.common import (
+    AT_CELL_CENTRES,
     INPUT_BLOCK,
     STATIONS_BLOCK,
     CaseConfig,
@@ -25,6 +26,7 @@ from flow_props.calculators.common import (
     input_paths,
     load_dataset,
     resolve_stations,
+    solution_points,
 )
 
 logger = logging.getLogger(__name__)
@@ -108,9 +110,10 @@ def run_case(cfg: ProfilesCaseConfig, config_dir: Path) -> list[str]:
     from flow_props.output import write_profiles_output
     from flow_props.profiles import extract_profiles
 
-    # resolve file paths relative to the config directory, then load the dataset
+    # resolve file paths relative to the config directory, then load the dataset (cell
+    # values go on a grid of the cell centres)
     fname, gname = input_paths(cfg, config_dir)
-    ds = load_dataset(fname, gname)
+    ds, location = solution_points(load_dataset(fname, gname))
 
     # resolve the stations
     stations = resolve_stations(ds, cfg.stations)
@@ -134,4 +137,11 @@ def run_case(cfg: ProfilesCaseConfig, config_dir: Path) -> list[str]:
         f"Wrote: {output_path}",
     ]
 
+    if location == AT_CELL_CENTRES:
+        report.insert(
+            1,
+            "  solution at cell centres: profiles run through them, from the first cell "
+            "centre (half a cell off the wall)",
+        )
+
     return report

{flow_props-0.2.1 → flow_props-0.3.0}/src/flow_props/calculators/shock.py

@@ -10,6 +10,9 @@ finds the shock on every wall-normal grid line (see flow_props.shock) and writes
   with per line the wall point, distance from the wall, captured thickness in cells and,
   on a shock-line grid, the offset from the grid line meant to hold the shock.
 
+A solution with cell values is taken along the lines through the cell centres, whose j
+counts cells; the offsets from shock_line_j (a vertex index) use j + 0.5 for them.
+
 Detection (``method``): walk (the first rise of min_rise over freestream, from outside),
 indicator (the first point whose WENO smoothness indicator reaches indicator_threshold)
 or hybrid (the outermost jump either finds); the point is where the quantity crosses
@@ -29,11 +32,13 @@ import numpy as np
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from flow_props.calculators.common import (
+    AT_CELL_CENTRES,
     INPUT_BLOCK,
     CaseConfig,
     build_template,
     input_paths,
     load_dataset,
+    solution_points,
 )
 
 logger = logging.getLogger(__name__)
@@ -45,6 +50,14 @@ logger = logging.getLogger(__name__)
 # within a quarter cell of its grid line, the shock counts as sitting on it
 ALIGNED_OFFSET_CELLS = 0.25
 
+# fewer cells than this between the shock's outer edge and the outer boundary leave too
+# little freestream to read q_inf from, or mean a disturbance ahead of the shock was
+# taken for it (e.g. freestream compressed against a bent symmetry line)
+OUTER_EDGE_CELLS = 5
+
+# walk and indicator farther apart than this found different things on a line
+DISAGREEMENT_CELLS = 3.0
+
 # --------------------------------------------------
 # config models (input boundary)
 # --------------------------------------------------
@@ -206,11 +219,15 @@ def run_case(cfg: ShockCaseConfig, config_dir: Path) -> list[str]:
         write_shock_curve,
     )
 
-    # resolve file paths relative to the config directory, then load the dataset
+    # resolve file paths relative to the config directory, then load the dataset (cell
+    # values go on a grid of the cell centres)
     fname, gname = input_paths(cfg, config_dir)
-    ds = load_dataset(fname, gname)
+    ds, location = solution_points(load_dataset(fname, gname))
     options = cfg.shock
 
+    # j on the grid the shock line counts (the vertex grid): cell j lies at j + 0.5
+    j_to_vertex = 0.5 if location == AT_CELL_CENTRES else 0.0
+
     # extract: one shock point per grid line
     extraction = extract_shock(
         ds,
@@ -222,7 +239,8 @@ def run_case(cfg: ShockCaseConfig, config_dir: Path) -> list[str]:
         indicator_threshold=options.indicator_threshold,
     )
     ni = ds.grid.shape[0]
-    nj = ds.grid.shape[1]
+    nj_vertices = ds.grid.shape[1] + (1 if location == AT_CELL_CENTRES else 0)
+    j_shock = extraction.j + j_to_vertex
 
     # the grid line meant to hold the shock: config first, then the solution's attributes
     shock_line_j = options.shock_line_j
@@ -230,8 +248,10 @@ def run_case(cfg: ShockCaseConfig, config_dir: Path) -> list[str]:
     if shock_line_j is None and ds.attrs.get("shock_line_j") is not None:
         shock_line_j = int(ds.attrs["shock_line_j"])
         source = "the solution file"
-    if shock_line_j is not None and shock_line_j >= nj:
-        raise ValueError(f"shock_line_j = {shock_line_j} lies outside the grid (j = 0 to {nj - 1})")
+    if shock_line_j is not None and shock_line_j >= nj_vertices:
+        raise ValueError(
+            f"shock_line_j = {shock_line_j} lies outside the grid (j = 0 to {nj_vertices - 1})"
+        )
 
     # debug output for devs
     logger.debug("shock line: %s (from %s)", shock_line_j, source)
@@ -244,7 +264,8 @@ def run_case(cfg: ShockCaseConfig, config_dir: Path) -> list[str]:
         "x_wall": ds.grid.x[extraction.station, 0, 0],
         "y_wall": ds.grid.y[extraction.station, 0, 0],
         "station": extraction.station.astype(float),
-        "j_shock": extraction.j,
+        "j_shock": j_shock,
+        "j_foot": extraction.j_foot + j_to_vertex,
         "distance": extraction.distance,
         "thickness_cells": extraction.thickness_cells,
     }
@@ -254,7 +275,7 @@ def run_case(cfg: ShockCaseConfig, config_dir: Path) -> list[str]:
     offsets = None
     if shock_line_j is not None:
         # positive: the solution's shock lies outside the grid's shock line
-        offsets = extraction.j - shock_line_j
+        offsets = j_shock - shock_line_j
         table["offset_cells"] = offsets
 
     # smooth: the curve that is written becomes a grid line
@@ -265,7 +286,7 @@ def run_case(cfg: ShockCaseConfig, config_dir: Path) -> list[str]:
         moved = curve.j - extraction.j
         table["x_smooth"] = curve.x
         table["y_smooth"] = curve.y
-        table["j_smooth"] = curve.j
+        table["j_smooth"] = curve.j + j_to_vertex
         table["smoothing_cells"] = moved
 
     # write: the curve, then the report
@@ -298,6 +319,11 @@ def run_case(cfg: ShockCaseConfig, config_dir: Path) -> list[str]:
             f"  found by the walk on {by_walk} lines, by the indicator on {by_indicator} "
             f"(both on {both})"
         )
+    if location == AT_CELL_CENTRES:
+        report.append(
+            "  solution at cell centres: lines run through them, j is counted on the vertex "
+            "grid (cell j + 0.5)"
+        )
     if extraction.stations_without_shock:
         report.append(f"  no shock on i = {_index_ranges(extraction.stations_without_shock)}")
     thickness = extraction.thickness_cells
@@ -306,7 +332,43 @@ def run_case(cfg: ShockCaseConfig, config_dir: Path) -> list[str]:
         f"{thickness.max():.1f} cells (median {np.median(thickness):.1f})"
     )
 
+    # warn: the shock's outer edge close to the outer boundary
+    nj = ds.grid.shape[1]
+    cells_outside = (nj - 1) - extraction.j_foot
+    near_outer = extraction.station[cells_outside < OUTER_EDGE_CELLS].tolist()
+    if near_outer:
+        report.append(
+            f"  warning: the shock lies within {OUTER_EDGE_CELLS} cells of the outer boundary "
+            f"on {len(near_outer)} lines (i = {_index_ranges(near_outer)}): too little "
+            "freestream outside it, or a disturbance ahead of the shock was taken for it"
+        )
+
+    # warn: walk and indicator found different jumps (both run on every line)
+    both_found = ~np.isnan(extraction.j_walk) & ~np.isnan(extraction.j_indicator)
+    gap = np.abs(extraction.j_walk - extraction.j_indicator)
+    apart = both_found & (gap > DISAGREEMENT_CELLS)
+    if np.any(apart):
+        walk_outside = int(np.count_nonzero(apart & (extraction.j_walk > extraction.j_indicator)))
+        apart_lines = extraction.station[apart].tolist()
+        report.append(
+            f"  warning: walk and indicator differ by more than {DISAGREEMENT_CELLS:g} cells "
+            f"on {len(apart_lines)} lines (i = {_index_ranges(apart_lines)}); the walk's "
+            f"shock lies farther out on {walk_outside} of them"
+        )
+
+    # report: the shock's outer edge, row by row (row changes along the body make the
+    # captured shock jump between cells, which a solver feels at the wall)
+    edge_j = extraction.j_foot + j_to_vertex
+    edge_row = np.floor(edge_j).astype(int)
+    row_changes = int(np.count_nonzero(np.diff(edge_row)))
+    edge_text = f"  shock edge (10 % of the jump): grid row changes along the body {row_changes}"
+
     # report: how the shock sits on the grid's shock line
+    if shock_line_j is not None:
+        outside = edge_j > shock_line_j
+        crossings = int(np.count_nonzero(np.diff(outside.astype(int))))
+        edge_text += f", crossings of the shock line {crossings}"
+    report.append(edge_text)
     if offsets is None:
         report.append("  no shock line to compare with (set [shock] shock_line_j)")
     else:

{flow_props-0.2.1 → flow_props-0.3.0}/src/flow_props/shock.py

@@ -103,12 +103,16 @@ class ShockCrossing:
     j: float
     # last grid point of the jump on the post-shock side (q there is the post-shock value)
     j_tail: int
-    # first grid point on the freestream side of the jump (outside its 10 % crossing)
-    j_foot: int
+    # the shock's outer edge: fractional j where q crosses 10 % of the jump
+    j_foot: float
     # captured shock thickness: from 10 % to 90 % of the jump, in cells
     thickness_cells: float
     # which detector found it: DETECTED_BY_WALK, DETECTED_BY_INDICATOR, or their sum
     detected_by: int
+    # each detector's own shock point, whatever the method (nan: it found none); a
+    # cross-check: far apart, one of them took something else for the shock
+    j_walk: float = float("nan")
+    j_indicator: float = float("nan")
 
 
 @dataclass(slots=True)
@@ -128,6 +132,11 @@ class ShockExtraction:
     thickness_cells: NDArray[np.float64]
     # which detector found each line's shock (see ShockCrossing.detected_by)
     detected_by: NDArray[np.int64]
+    # the shock's outer edge (10 % of the jump), fractional j
+    j_foot: NDArray[np.float64]
+    # each detector's own shock point, fractional j (nan: it found none on that line)
+    j_walk: NDArray[np.float64]
+    j_indicator: NDArray[np.float64]
     # i of the grid lines without a shock
     stations_without_shock: list[int]
 
@@ -233,13 +242,17 @@ def find_shock_on_line(
     if not q_inf > 0.0:
         raise ValueError(f"the freestream value (outer end of the line) is {q_inf}; expected > 0")
 
-    # each detector of the method: its first jump from outside that is a shock
-    crossings: list[ShockCrossing] = []
-    for detector in METHODS[method]:
+    # every detector: its first jump from outside that is a shock (the method picks
+    # among them; the others are kept as a cross-check)
+    found: dict[str, ShockCrossing] = {}
+    for name, detector in DETECTORS.items():
         detection = detector(values, q_inf, min_rise, indicator_threshold)
         crossing = _first_shock(values, detection, q_inf, level, max_thickness)
         if crossing is not None:
-            crossings.append(crossing)
+            found[name] = crossing
+
+    # the method's detectors
+    crossings = [found[name] for name in METHODS[method] if name in found]
     if not crossings:
         return None
 
@@ -256,6 +269,8 @@ def find_shock_on_line(
         j_foot=outermost.j_foot,
         thickness_cells=outermost.thickness_cells,
         detected_by=detected_by,
+        j_walk=found["walk"].j if "walk" in found else float("nan"),
+        j_indicator=found["indicator"].j if "indicator" in found else float("nan"),
     )
 
     return shock
@@ -322,6 +337,9 @@ def extract_shock(
     distance_values: list[float] = []
     thickness_values: list[float] = []
     detected_values: list[int] = []
+    foot_values: list[float] = []
+    walk_values: list[float] = []
+    indicator_values: list[float] = []
     without_shock: list[int] = []
 
     # find the shock on each line
@@ -354,6 +372,9 @@ def extract_shock(
         distance_values.append(distance)
         thickness_values.append(crossing.thickness_cells)
         detected_values.append(crossing.detected_by)
+        foot_values.append(crossing.j_foot)
+        walk_values.append(crossing.j_walk)
+        indicator_values.append(crossing.j_indicator)
 
     # check: at least one line crosses the shock
     if not found_stations:
@@ -374,6 +395,9 @@ def extract_shock(
         distance=np.asarray(distance_values, dtype=float),
         thickness_cells=np.asarray(thickness_values, dtype=float),
         detected_by=np.asarray(detected_values, dtype=np.int64),
+        j_foot=np.asarray(foot_values, dtype=float),
+        j_walk=np.asarray(walk_values, dtype=float),
+        j_indicator=np.asarray(indicator_values, dtype=float),
         stations_without_shock=without_shock,
     )
 
@@ -484,6 +508,9 @@ def smooth_shock(ds: Dataset, extraction: ShockExtraction, length: float) -> Sho
         distance=smoothed_distance,
         thickness_cells=extraction.thickness_cells.copy(),
         detected_by=extraction.detected_by.copy(),
+        j_foot=extraction.j_foot.copy(),
+        j_walk=extraction.j_walk.copy(),
+        j_indicator=extraction.j_indicator.copy(),
         stations_without_shock=list(extraction.stations_without_shock),
     )
 
@@ -571,10 +598,10 @@ DETECTORS: dict[str, Detector] = {
     "walk": _detect_by_walk,
     "indicator": _detect_by_indicator,
 }
-METHODS: dict[str, tuple[Detector, ...]] = {
-    "walk": (DETECTORS["walk"],),
-    "indicator": (DETECTORS["indicator"],),
-    "hybrid": (DETECTORS["walk"], DETECTORS["indicator"]),
+METHODS: dict[str, tuple[str, ...]] = {
+    "walk": ("walk",),
+    "indicator": ("indicator",),
+    "hybrid": ("walk", "indicator"),
 }
 
 
@@ -643,7 +670,7 @@ def _first_shock(
         crossing = ShockCrossing(
             j=j_shock,
             j_tail=j_tail,
-            j_foot=int(j_outer) + 1,
+            j_foot=j_outer,
             thickness_cells=thickness_cells,
             detected_by=detection.code,
         )

{flow_props-0.2.1 → flow_props-0.3.0}/src/flow_props.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flow-props
-Version: 0.2.1
+Version: 0.3.0
 Summary: Extract flow properties from CFD data: boundary layer, entropy layer, shock
 Author-email: Christoph Hader <christoph.hader@gmail.com>
 License-Expression: GPL-3.0-or-later

{flow_props-0.2.1 → flow_props-0.3.0}/src/flow_props.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.2.1",
+  "tag": "0.3.0",
   "distance": 0,
-  "node": "g7d2d8d8d7e8897e8f6d88f6b053492c04e8db282",
+  "node": "gda4867c5e8d65682efe0809b4a9c7561de6cbcad",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-11-05"

{flow_props-0.2.1 → flow_props-0.3.0}/tests/synthetic.py

@@ -103,3 +103,17 @@ def shock_solution(ni: int = 21, nj: int = 81, width: float = 1.0) -> tuple[Data
     dataset = Dataset(grid=StructuredGrid(x=x, y=y, z=np.zeros_like(x)), flow=flow, attrs={})
 
     return dataset, j_true
+
+
+def shock_behind_a_bump(nj: int = 81) -> np.ndarray:
+    """A strong, sharp shock at j = 40.3, and a smooth 18 % compression near the outer end.
+
+    Like the freestream compressed against a bent symmetry line ahead of the shock: the
+    walk meets the compression first; the indicator, which only flags sharp jumps,
+    doesn't see it and finds the shock.
+    """
+    j = np.arange(nj, dtype=float)
+    shock = 20.0 * 0.5 * (1.0 - np.tanh((j - 40.3) / 0.8))
+    bump = 0.18 * 0.5 * (1.0 - np.tanh((j - 75.0) / 2.5))
+    values = 1.0 + shock + bump
+    return values

{flow_props-0.2.1 → flow_props-0.3.0}/tests/test_calculators.py

@@ -9,11 +9,14 @@ from cfd_io.dataset import Dataset, Field, StructuredGrid
 
 from flow_props.calculators import CALCULATORS
 from flow_props.calculators.common import (
+    AT_CELL_CENTRES,
+    AT_VERTICES,
     GasConfig,
     StationsConfig,
     load_config,
     resolve_gas_properties,
     resolve_stations,
+    solution_points,
 )
 from flow_props.cli.examples_command import list_examples
 
@@ -143,3 +146,39 @@ def test_gas_metadata_missing_names_who_needs_it(tmp_path):
         resolve_gas_properties(
             GasConfig(), {}, tmp_path / "a.h5", required=True, needed_for="the entropy layer"
         )
+
+
+# --------------------------------------------------
+# solutions at the vertices or at the cell centres
+# --------------------------------------------------
+def test_vertex_solution_is_used_as_it_is():
+    ds = _make_dataset()
+
+    points, location = solution_points(ds)
+
+    assert points is ds
+    assert location == AT_VERTICES
+
+
+def test_cell_solution_moves_to_a_grid_of_cell_centres():
+    """Cell values on a vertex grid: the grid becomes the cell centres (corner means)."""
+    ds = _make_dataset(ni=8, nj=4)
+    cell_values = np.arange(7 * 3, dtype=float).reshape(7, 3, 1)
+    ds.flow = {"pres": Field(data=cell_values, association="cell")}
+
+    points, location = solution_points(ds)
+
+    assert location == AT_CELL_CENTRES
+    assert points.grid.shape == (7, 3, 1)
+    np.testing.assert_allclose(points.grid.x[:, 0, 0], 0.1 * (np.arange(7) + 0.5))
+    np.testing.assert_allclose(points.grid.y[0, :, 0], 0.01 * (np.arange(3) + 0.5))
+    np.testing.assert_array_equal(points.flow["pres"].data, cell_values)
+    assert points.flow["pres"].association == "node"
+
+
+def test_fields_in_different_places_are_refused():
+    ds = _make_dataset(ni=8, nj=4)
+    ds.flow["pres"] = Field(data=np.zeros((7, 3, 1)), association="cell")
+
+    with pytest.raises(ValueError, match="different places"):
+        solution_points(ds)

{flow_props-0.2.1 → flow_props-0.3.0}/tests/test_cli.py

@@ -6,7 +6,8 @@ from pathlib import Path
 import numpy as np
 import pytest
 from cfd_io import write_file
-from synthetic import boundary_layer_solution, shock_solution
+from cfd_io.dataset import Dataset, Field
+from synthetic import boundary_layer_solution, shock_behind_a_bump, shock_solution
 from typer.testing import CliRunner
 
 from flow_props.calculators import CALCULATORS
@@ -245,6 +246,100 @@ def test_shock_run_names_its_method(method, tmp_path):
         assert '"detected_by"' not in report_text
 
 
+def _analytic_shock(at_cells: bool, shock_j: float = 50.3) -> Dataset:
+    """The same captured shock (at vertex index shock_j) at the vertices or the cell centres.
+
+    The vertex grid is the synthetic solution's; at the cell centres, the pressure is the
+    same function evaluated at cell index j + 0.5, as a finite-volume solution holds it.
+    """
+    vertex_dataset, _ = shock_solution(width=1.5)
+    grid = vertex_dataset.grid
+    ni, nj, _ = grid.shape
+
+    # pressure as a function of the vertex index: a captured jump centred at shock_j
+    def pressure(j_vertex: np.ndarray) -> np.ndarray:
+        shape = 0.5 * (1.0 - np.tanh((j_vertex - shock_j) / 1.5))
+        return 1000.0 * (1.0 + 4.0 * shape)
+
+    # at the vertices, or at the cell centres (one fewer per direction)
+    if at_cells:
+        j_index = np.arange(nj - 1, dtype=float) + 0.5
+        values = np.broadcast_to(pressure(j_index)[None, :, None], (ni - 1, nj - 1, 1)).copy()
+        flow = {"pres": Field(data=values, association="cell")}
+    else:
+        j_index = np.arange(nj, dtype=float)
+        values = np.broadcast_to(pressure(j_index)[None, :, None], (ni, nj, 1)).copy()
+        flow = {"pres": Field(data=values, association="node")}
+
+    return Dataset(grid=grid, flow=flow, attrs={})
+
+
+def test_shock_offsets_agree_on_vertex_and_cell_centre_input(tmp_path, monkeypatch):
+    """Cell j counts on the vertex grid as j + 0.5, so both inputs give the same offsets."""
+    offsets = {}
+    outputs = {}
+    for label, at_cells in (("vertices", False), ("cells", True)):
+        dataset = _analytic_shock(at_cells)
+        monkeypatch.setattr(
+            "flow_props.calculators.shock.load_dataset", lambda fname, gname, ds=dataset: ds
+        )
+        folder = tmp_path / label
+        folder.mkdir()
+        path = _write_config(folder, "shock", "[shock]\nshock_line_j = 52\n")
+
+        result = runner.invoke(app, ["shock", "run", "-c", str(path)])
+
+        assert result.exit_code == 0, result.output
+        outputs[label] = result.output
+        lines = (folder / "shock_report.dat").read_text().splitlines()
+        variables = [name.strip('" ') for name in lines[1].split("=")[1].split(",")]
+        rows = np.loadtxt(lines[3:], ndmin=2)
+        offsets[label] = rows[:, variables.index("offset_cells")]
+
+    # check: the true offset is 50.3 - 52 on every line, from either input
+    np.testing.assert_allclose(offsets["vertices"], -1.7, atol=0.05)
+    np.testing.assert_allclose(offsets["cells"], -1.7, atol=0.05)
+    assert abs(np.mean(offsets["cells"]) - np.mean(offsets["vertices"])) < 0.05
+
+    # check: the report says which was used
+    assert "solution at cell centres" in outputs["cells"]
+    assert "solution at cell centres" not in outputs["vertices"]
+
+
+def test_shock_run_warns_about_a_disturbance_ahead_of_the_shock(tmp_path, monkeypatch):
+    """A compression near the outer boundary: both warnings name the lines."""
+    # every line: the shock at j = 40.3, a smooth compression near the outer end
+    dataset, _ = shock_solution()
+    ni, nj, _ = dataset.grid.shape
+    values = 1000.0 * shock_behind_a_bump(nj)
+    dataset.flow["pres"].data[:] = values[None, :, None]
+    monkeypatch.setattr("flow_props.calculators.shock.load_dataset", lambda fname, gname: dataset)
+    path = _write_config(tmp_path, "shock", "")
+
+    result = runner.invoke(app, ["shock", "run", "-c", str(path)])
+
+    assert result.exit_code == 0, result.output
+    assert (
+        f"warning: the shock lies within 5 cells of the outer boundary on {ni} lines"
+        in result.output
+    )
+    assert f"warning: walk and indicator differ by more than 3 cells on {ni} lines" in result.output
+    assert f"the walk's shock lies farther out on {ni} of them" in result.output
+
+
+def test_shock_run_counts_row_changes_of_the_shock_edge(tmp_path):
+    """The synthetic shock climbs 10 cells along the body; it crosses j = 55 once."""
+    dataset, _ = shock_solution()
+    _write_solution(tmp_path, dataset)
+    path = _write_config(tmp_path, "shock", "[shock]\nshock_line_j = 55\n")
+
+    result = runner.invoke(app, ["shock", "run", "-c", str(path)])
+
+    assert result.exit_code == 0, result.output
+    assert "grid row changes along the body 10, crossings of the shock line 1" in result.output
+    assert "warning" not in result.output
+
+
 def test_shock_run_reads_the_shock_line_from_the_solution_attributes(tmp_path):
     dataset, _ = shock_solution()
     dataset.attrs["shock_line_j"] = 52

{flow_props-0.2.1 → flow_props-0.3.0}/tests/test_shock.py

@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 from cfd_io.dataset import Dataset, StructuredGrid
-from synthetic import shock_solution
+from synthetic import shock_behind_a_bump, shock_solution
 
 from flow_props.calculators.shock import _index_ranges
 from flow_props.shock import (
@@ -116,6 +116,26 @@ def test_no_shock_on_a_line_without_a_jump():
     assert find_shock_on_line(np.linspace(1.04, 1.0, 50)) is None
 
 
+def test_each_detector_reports_its_own_point():
+    """Whatever the method, the crossing carries the walk's and the indicator's points."""
+    crossing = find_shock_on_line(_captured_shock(1.0, 4.0), method="walk")
+    assert crossing.j_walk == crossing.j
+    assert crossing.j_indicator == pytest.approx(crossing.j, abs=1e-12)
+    assert crossing.j < crossing.j_foot < crossing.j + 3.0
+
+    weak = find_shock_on_line(_captured_shock(4.0, 0.3), method="walk")
+    assert np.isnan(weak.j_indicator)
+
+
+def test_walk_and_indicator_part_ways_at_a_disturbance_ahead_of_the_shock():
+    """The walk takes the compression for the shock; the indicator finds the real one."""
+    crossing = find_shock_on_line(shock_behind_a_bump(), method="walk")
+
+    assert crossing.j > 70.0
+    assert abs(crossing.j_indicator - 40.3) < TOLERANCE_CELLS
+    assert crossing.j_walk - crossing.j_indicator > 30.0
+
+
 def test_a_smooth_compression_is_not_a_shock():
     """A rise spread over many cells (a line ending inside the shock layer) is rejected."""
     values = np.linspace(1.5, 1.0, 60)
@@ -273,6 +293,9 @@ def _with_distance(dataset, extraction: ShockExtraction, distance: np.ndarray) -
         distance=distance,
         thickness_cells=extraction.thickness_cells,
         detected_by=extraction.detected_by,
+        j_foot=extraction.j_foot,
+        j_walk=extraction.j_walk,
+        j_indicator=extraction.j_indicator,
         stations_without_shock=[],
     )
 
@@ -305,6 +328,9 @@ def test_smoothing_keeps_a_straight_shock_over_lines_that_turn_at_a_junction():
         distance=distance,
         thickness_cells=np.full(ni, 2.0),
         detected_by=np.full(ni, DETECTED_BY_WALK),
+        j_foot=distance / (2.0 * height) * (nj - 1) + 1.0,
+        j_walk=distance / (2.0 * height) * (nj - 1),
+        j_indicator=np.full(ni, np.nan),
         stations_without_shock=[],
     )