weac 3.2.0__tar.gz → 3.3.0__tar.gz

{weac-3.2.0 → weac-3.3.0}/CITATION.cff

@@ -8,7 +8,7 @@ authors:
   - family-names: "Weissgraeber"
     given-names: "Philipp"
     orcid: "https://orcid.org/0000-0001-8320-8672"
-version: 3.2.0
+version: 3.3.0
 date-released: 2026-08-06
 identifiers:
   - description: Collection of archived snapshots of all versions of WEAC

{weac-3.2.0/src/weac.egg-info → weac-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weac
-Version: 3.2.0
+Version: 3.3.0
 Summary: Weak layer anticrack nucleation model
 Author-email: 2phi GbR <mail@2phi.de>
 License-Expression: MIT
@@ -21,6 +21,7 @@ Requires-Dist: numpy<2.4.0,>=2.3.5
 Requires-Dist: scipy>=1.14.0
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: snowpylot>=1.1.5
+Requires-Dist: snowmicropyn>=1.4.0
 Provides-Extra: interactive
 Requires-Dist: jupyter; extra == "interactive"
 Requires-Dist: ipython>=8.37.0; extra == "interactive"
@@ -53,7 +54,7 @@ Requires-Dist: pyzmq>=27.0.1; extra == "dev"
 Requires-Dist: tornado>=6.5.2; extra == "dev"
 Requires-Dist: traitlets>=5.14.3; extra == "dev"
 Requires-Dist: ruff>=0.4.0; extra == "dev"
-Requires-Dist: pylint>=3.2.0; extra == "dev"
+Requires-Dist: pylint>=3.3.0; extra == "dev"
 Requires-Dist: pycodestyle>=2.11.1; extra == "dev"
 Requires-Dist: black>=24.4.0; extra == "dev"
 Requires-Dist: isort>=5.13.0; extra == "dev"
@@ -193,7 +194,8 @@ Needs (runtime dependencies are declared in [pyproject.toml](https://github.com/
 - [Scipy](https://www.scipy.org/) ≥ 1.14.0
 - [Matplotlib](https://matplotlib.org/) ≥ 3.9.1
 - [Pydantic](https://docs.pydantic.dev/latest/) ≥ 2.11.7
-- [Snowpylot](https://github.com/connellymk/snowpylot) ≥ 1.1.3
+- [Snowpylot](https://github.com/connellymk/snowpylot) ≥ 1.1.5
+- [snowmicropyn](https://github.com/slf-dot-ch/snowmicropyn) ≥ 1.4.0
 
 <!-- DEVELOPMENT SETUP -->
 ## Development Setup
@@ -428,6 +430,44 @@ u_bot = skier_system.fq.u(Z=z_skier, h0=bot, unit='um')
 psi = skier_system.fq.psi(Z=z_skier, unit='deg')
 ```
 
+### Parsing field profiles into layers
+
+Instead of hand-building `Layer` lists, WEAC ships parsers in `weac.parser` that convert common field-profile formats into slope-normal WEAC layers (ordered surface → ground). All parsers expose `extract_layers(...)` returning `(layers, density_methods)`, so the output plugs directly into `ModelInput`. See [`demo/parser_demo.ipynb`](https://github.com/2phi/weac/blob/main/demo/parser_demo.ipynb) for side-by-side plots of the three parsers on a co-located Weissfluhjoch pit.
+
+```python
+from weac.parser import SMPParser, SnowScopeParser, SnowPilotParser
+```
+
+**SnowMicroPen** (`.PNT`) — `SMPParser` derives density and SSA from the force signal via [snowmicropyn](https://github.com/slf-dot-ch/snowmicropyn)'s Löwe 2012 shot-noise model plus a parameterization (`P2015`, `CR2020`, `K2020a`, `K2020b`). Surface and ground are auto-detected at construction.
+
+```python
+smp = SMPParser("profile.PNT", density_method="CR2020")
+# "bin" groups at a fixed thickness; "gradient" cuts on density-gradient jumps
+layers, density_methods = smp.extract_layers(method="bin", layer_thickness_mm=20.0)
+```
+
+**SnowScope** (`.csv`) — `SnowScopeParser` reads penetration hardness (kPa) and derives density from a semilog model `D = a·ln(F) + b` (default `HAGENMULLER2018`). It exposes the same `extract_layers` interface as the SMP parser.
+
+```python
+scope = SnowScopeParser("profile.csv", density_method="HAGENMULLER2018")
+layers, density_methods = scope.extract_layers(method="gradient", gradient_threshold=12.0)
+
+scope_custom = SnowScopeParser(
+    "profile.csv",
+    semilog_slope=50.0,
+    semilog_intercept=100.0,
+)
+```
+
+**SnowPilot / CAAML** (`.xml`) — `SnowPilotParser` uses [snowpylot](https://github.com/connellymk/snowpylot) to read CAAML snowpits, emitting hand-hardness / density-observation layers. Densities come from measured observations where available, falling back to the Geldsetzer estimate from grain type and hand hardness.
+
+```python
+pilot = SnowPilotParser("profile.xml")
+# pass a known slope angle to scale plumb depths to slope-normal, e.g.:
+# pilot.extract_layers(slope_angle_deg=pilot.pit_slope_angle_deg() or 0.0)
+layers, density_methods = pilot.extract_layers()
+```
+
 <!-- ROADMAP -->
 ## Roadmap
 

{weac-3.2.0 → weac-3.3.0}/README.md

@@ -130,7 +130,8 @@ Needs (runtime dependencies are declared in [pyproject.toml](https://github.com/
 - [Scipy](https://www.scipy.org/) ≥ 1.14.0
 - [Matplotlib](https://matplotlib.org/) ≥ 3.9.1
 - [Pydantic](https://docs.pydantic.dev/latest/) ≥ 2.11.7
-- [Snowpylot](https://github.com/connellymk/snowpylot) ≥ 1.1.3
+- [Snowpylot](https://github.com/connellymk/snowpylot) ≥ 1.1.5
+- [snowmicropyn](https://github.com/slf-dot-ch/snowmicropyn) ≥ 1.4.0
 
 <!-- DEVELOPMENT SETUP -->
 ## Development Setup
@@ -365,6 +366,44 @@ u_bot = skier_system.fq.u(Z=z_skier, h0=bot, unit='um')
 psi = skier_system.fq.psi(Z=z_skier, unit='deg')
 ```
 
+### Parsing field profiles into layers
+
+Instead of hand-building `Layer` lists, WEAC ships parsers in `weac.parser` that convert common field-profile formats into slope-normal WEAC layers (ordered surface → ground). All parsers expose `extract_layers(...)` returning `(layers, density_methods)`, so the output plugs directly into `ModelInput`. See [`demo/parser_demo.ipynb`](https://github.com/2phi/weac/blob/main/demo/parser_demo.ipynb) for side-by-side plots of the three parsers on a co-located Weissfluhjoch pit.
+
+```python
+from weac.parser import SMPParser, SnowScopeParser, SnowPilotParser
+```
+
+**SnowMicroPen** (`.PNT`) — `SMPParser` derives density and SSA from the force signal via [snowmicropyn](https://github.com/slf-dot-ch/snowmicropyn)'s Löwe 2012 shot-noise model plus a parameterization (`P2015`, `CR2020`, `K2020a`, `K2020b`). Surface and ground are auto-detected at construction.
+
+```python
+smp = SMPParser("profile.PNT", density_method="CR2020")
+# "bin" groups at a fixed thickness; "gradient" cuts on density-gradient jumps
+layers, density_methods = smp.extract_layers(method="bin", layer_thickness_mm=20.0)
+```
+
+**SnowScope** (`.csv`) — `SnowScopeParser` reads penetration hardness (kPa) and derives density from a semilog model `D = a·ln(F) + b` (default `HAGENMULLER2018`). It exposes the same `extract_layers` interface as the SMP parser.
+
+```python
+scope = SnowScopeParser("profile.csv", density_method="HAGENMULLER2018")
+layers, density_methods = scope.extract_layers(method="gradient", gradient_threshold=12.0)
+
+scope_custom = SnowScopeParser(
+    "profile.csv",
+    semilog_slope=50.0,
+    semilog_intercept=100.0,
+)
+```
+
+**SnowPilot / CAAML** (`.xml`) — `SnowPilotParser` uses [snowpylot](https://github.com/connellymk/snowpylot) to read CAAML snowpits, emitting hand-hardness / density-observation layers. Densities come from measured observations where available, falling back to the Geldsetzer estimate from grain type and hand hardness.
+
+```python
+pilot = SnowPilotParser("profile.xml")
+# pass a known slope angle to scale plumb depths to slope-normal, e.g.:
+# pilot.extract_layers(slope_angle_deg=pilot.pit_slope_angle_deg() or 0.0)
+layers, density_methods = pilot.extract_layers()
+```
+
 <!-- ROADMAP -->
 ## Roadmap
 

{weac-3.2.0 → weac-3.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weac"
-version = "3.2.0"
+version = "3.3.0"
 authors = [{ name = "2phi GbR", email = "mail@2phi.de" }]
 description = "Weak layer anticrack nucleation model"
 readme = "README.md"
@@ -24,6 +24,7 @@ dependencies = [
     "scipy>=1.14.0",
     "pydantic>=2.11.7",
     "snowpylot>=1.1.5",
+    "snowmicropyn>=1.4.0",
 ]
 
 [project.urls]
@@ -67,7 +68,7 @@ dev = [
 
     # Linters/formatters aligned with configured tools
     "ruff>=0.4.0",
-    "pylint>=3.2.0",
+    "pylint>=3.3.0",
     "pycodestyle>=2.11.1",
     "black>=24.4.0",
     "isort>=5.13.0",
@@ -132,7 +133,7 @@ ignore = [
 ]
 
 [tool.bumpversion]
-current_version = "3.2.0"
+current_version = "3.3.0"
 
 [[tool.bumpversion.files]]
 filename = "pyproject.toml"

{weac-3.2.0 → weac-3.3.0}/src/weac/__init__.py

@@ -2,4 +2,4 @@
 WEAC - Weak Layer Anticrack Nucleation Model
 """
 
-__version__ = "3.2.0"
+__version__ = "3.3.0"

weac-3.3.0/src/weac/parser/__init__.py

@@ -0,0 +1,13 @@
+"""Parsers that convert field-profile formats into WEAC layers."""
+
+from weac.parser.smp_parser import SMPParser, SMPProfile
+from weac.parser.snowpilot_parser import SnowPilotParser
+from weac.parser.snowscope_parser import SnowScopeParser, SnowScopeProfile
+
+__all__ = [
+    "SMPParser",
+    "SMPProfile",
+    "SnowPilotParser",
+    "SnowScopeParser",
+    "SnowScopeProfile",
+]

weac-3.3.0/src/weac/parser/plotting/__init__.py

@@ -0,0 +1,19 @@
+"""Debug plotting for penetration-resistance-first parsers (SMP, SnowScope)."""
+
+from weac.parser.plotting.force_penetration_layers import ForcePenetrationProfile
+from weac.parser.plotting.force_penetration_plot import (
+    ForcePenetrationParser,
+    plot_force_penetration_layers,
+    plot_force_penetration_parser,
+    plot_smp_penetration_parser,
+    plot_snowscope_penetration_parser,
+)
+
+__all__ = [
+    "ForcePenetrationParser",
+    "ForcePenetrationProfile",
+    "plot_force_penetration_layers",
+    "plot_force_penetration_parser",
+    "plot_smp_penetration_parser",
+    "plot_snowscope_penetration_parser",
+]

weac-3.3.0/src/weac/parser/plotting/force_penetration_layers.py

@@ -0,0 +1,148 @@
+"""Shared four-panel penetration-resistance / density / layer plots."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Protocol
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.figure import Figure
+
+from weac.components import Layer
+from weac.parser.utils import plumb_to_slope_normal
+
+
+class ForcePenetrationProfile(Protocol):
+    """Profile from SMP or SnowScope (resistance–depth signal plus derived density)."""
+
+    depth_mm: np.ndarray
+    penetration_resistance_kPa: np.ndarray
+    density_kg_m3: np.ndarray
+    density_method: str
+
+
+def _layer_staircase(
+    layers: list[Layer], surface_mm: float
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return (density, depth) staircase points for a top-down layer list.
+
+    Boundaries accumulate ``Layer.h`` from ``surface_mm`` (the profile's first
+    sample depth). Consecutive vertical segments share a boundary depth, so a
+    single ``plot`` call renders them as a density-vs-depth staircase. Because
+    ``Layer.h`` is slope-normal, the staircase belongs on the slope-normal axis.
+    """
+    if not layers:
+        return np.array([]), np.array([])
+    thicknesses = np.array([layer.h for layer in layers], dtype=np.float64)
+    densities = np.array([layer.rho for layer in layers], dtype=np.float64)
+    tops = surface_mm + np.concatenate(([0.0], np.cumsum(thicknesses)[:-1]))
+    bottoms = surface_mm + np.cumsum(thicknesses)
+    rho = np.repeat(densities, 2)
+    depth = np.empty(rho.size, dtype=np.float64)
+    depth[0::2] = tops
+    depth[1::2] = bottoms
+    return rho, depth
+
+
+def plot_force_penetration_layers(
+    profile: ForcePenetrationProfile,
+    layers: list[Layer],
+    *,
+    slope_angle_deg: float = 0.0,
+    title: str | None = None,
+    layer_label: str = "layers",
+    save_path: str | Path | None = None,
+    show: bool = True,
+    figsize: tuple[float, float] = (13.0, 6.5),
+) -> Figure:
+    """Plot penetration resistance, density, slope-normal density, and layers on a depth axis.
+
+    Args:
+        profile: :class:`~weac.parser.smp_parser.SMPProfile` or
+            :class:`~weac.parser.snowscope_parser.SnowScopeProfile` (must expose
+            ``depth_mm``, ``penetration_resistance_kPa``, ``density_kg_m3``,
+            ``density_method``).
+        layers: WEAC layers ordered surface -> ground (from ``extract_layers``).
+            ``Layer.h`` is slope-normal, so the reconstructed staircase is drawn
+            on the slope-normal axis (panels 3-4). Pass the same
+            ``slope_angle_deg`` used to extract the layers so the slope-normal
+            density panel and the staircase share one axis. The staircase bottom
+            overshoots the last sample by one cell because the binning helpers
+            repeat the final sample spacing (an intentional part of their cell
+            model, see ``layer_binning``).
+        slope_angle_deg: Slope angle [deg] used when the layers were extracted;
+            sets the ``cos(phi)`` compression of the slope-normal depth axis.
+        title: Figure suptitle; defaults to the density method name.
+        layer_label: Legend/title label for the segmented panel.
+        save_path: If given, save the figure (PNG) to this path.
+        show: Call ``plt.show()`` before returning (default ``True``).
+        figsize: Figure size in inches.
+
+    Returns:
+        The created :class:`~matplotlib.figure.Figure`.
+    """
+    depth = np.asarray(profile.depth_mm, dtype=np.float64)
+    resistance = np.asarray(profile.penetration_resistance_kPa, dtype=np.float64)
+    density = np.asarray(profile.density_kg_m3, dtype=np.float64)
+    surface_mm = float(depth[0]) if depth.size else 0.0
+
+    phi = float(slope_angle_deg)
+    scale = plumb_to_slope_normal(phi) if phi != 0.0 else 1.0
+    # Anchor at the surface; compress only the below-surface span (matches how
+    # the layer staircase accumulates slope-normal thicknesses from surface_mm).
+    depth_sn = surface_mm + (depth - surface_mm) * scale
+    rho_step, depth_step = _layer_staircase(layers, surface_mm)
+
+    fig, (ax_resistance, ax_density, ax_density_sn, ax_layers) = plt.subplots(
+        1, 4, figsize=figsize, sharey=True
+    )
+
+    ax_resistance.plot(resistance, depth, color="#004E8A", lw=0.9)
+    ax_resistance.set_xlabel("Penetration resistance [kPa]")
+    ax_resistance.set_ylabel("Depth [mm]")
+    ax_resistance.set_title("Penetration resistance\n(plumb)")
+
+    ax_density.plot(density, depth, color="#00689D", lw=0.9)
+    ax_density.set_xlabel("Density [kg m$^{-3}$]")
+    ax_density.set_title("Sample density\n(plumb)")
+
+    ax_density_sn.plot(density, depth_sn, color="#009D81", lw=0.9)
+    ax_density_sn.set_xlabel("Density [kg m$^{-3}$]")
+    ax_density_sn.set_title(f"Sample density\n(slope-normal, φ={phi:g}°)")
+
+    # Segmented layers (slope-normal) with the slope-normal density overlaid.
+    ax_layers.plot(
+        density,
+        depth_sn,
+        color="#B5B5B5",
+        lw=0.8,
+        alpha=0.7,
+        label="sample density",
+    )
+    if rho_step.size:
+        ax_layers.plot(rho_step, depth_step, color="#EC6500", lw=1.6, label=layer_label)
+        # Boundary ticks (every other point is a shared top/bottom depth).
+        for boundary in depth_step[1::2]:
+            ax_layers.axhline(boundary, color="#EC6500", lw=0.3, alpha=0.3)
+    ax_layers.set_xlabel("Density [kg m$^{-3}$]")
+    ax_layers.set_title(f"Segmented {layer_label}\n(slope-normal, n={len(layers)})")
+    ax_layers.legend(loc="lower right", fontsize=8, frameon=False)
+
+    # Depth increases downward: surface at the top. Plumb depth is the deepest.
+    if depth.size:
+        max_depth = float(np.nanmax(depth))
+        if depth_step.size:
+            max_depth = max(max_depth, float(np.nanmax(depth_step)))
+        ax_resistance.set_ylim(max_depth, surface_mm)
+    for ax in (ax_resistance, ax_density, ax_density_sn, ax_layers):
+        ax.grid(True, alpha=0.25, lw=0.4)
+
+    fig.suptitle(title or f"Penetration resistance profile ({profile.density_method})")
+    fig.tight_layout()
+
+    if save_path is not None:
+        fig.savefig(save_path, dpi=200, bbox_inches="tight", facecolor="white")
+    if show:
+        plt.show()
+    return fig

weac-3.3.0/src/weac/parser/plotting/force_penetration_plot.py

@@ -0,0 +1,107 @@
+"""SMP and SnowScope penetration-resistance debug plotting (unified entry points).
+
+Penetration parsers record **penetration resistance first**, then derive sample
+density (SnowMicroPen via snowmicropyn; SnowScope via a semilog hardness model).
+SnowPilot pits are layer lists only — they do not expose this resistance–depth
+signal, so this package does not apply to
+:class:`~weac.parser.snowpilot_parser.SnowPilotParser`.
+
+Four depth-aligned panels (see :func:`plot_force_penetration_layers`):
+
+1. Penetration resistance vs plumb depth.
+2. Sample density vs plumb depth.
+3. Sample density vs slope-normal depth (plumb depth compressed by ``cos(phi)``).
+4. Segmented WEAC layers (``bin`` or ``gradient``) vs slope-normal depth, with
+   the slope-normal density faintly overlaid.
+
+Parser-specific extract-and-plot helpers live in
+:mod:`weac.parser.plotting.smp_penetration_plot` and
+:mod:`weac.parser.plotting.snowscope_penetration_plot`.
+"""
+
+from __future__ import annotations
+
+from typing import Literal, Protocol
+
+from matplotlib.figure import Figure
+
+from weac.components import Layer
+from weac.parser.plotting.force_penetration_layers import (
+    ForcePenetrationProfile,
+    plot_force_penetration_layers,
+)
+from weac.parser.plotting.smp_penetration_plot import plot_smp_penetration_parser
+from weac.parser.plotting.snowscope_penetration_plot import (
+    plot_snowscope_penetration_parser,
+)
+from weac.parser.smp_parser import SMPParser
+from weac.parser.snowscope_parser import SnowScopeParser
+
+__all__ = [
+    "ForcePenetrationParser",
+    "ForcePenetrationProfile",
+    "plot_force_penetration_layers",
+    "plot_force_penetration_parser",
+    "plot_smp_penetration_parser",
+    "plot_snowscope_penetration_parser",
+]
+
+
+class ForcePenetrationParser(Protocol):
+    """SMP or SnowScope parser with ``extract_profile`` / ``extract_layers``."""
+
+    def extract_profile(self, **kwargs) -> ForcePenetrationProfile: ...
+
+    def extract_layers(self, *args, **kwargs) -> tuple[list[Layer], list[str]]: ...
+
+
+def plot_force_penetration_parser(
+    parser: ForcePenetrationParser,
+    *,
+    method: Literal["bin", "gradient"] = "bin",
+    slope_angle_deg: float = 0.0,
+    density_method: str | None = None,
+    semilog_slope: float | None = None,
+    semilog_intercept: float | None = None,
+    layer_thickness_mm: float | None = None,
+    gradient_threshold: float = 12.0,
+    **plot_kwargs,
+) -> Figure:
+    """Extract from an SMP or SnowScope parser and plot the debug view.
+
+    Dispatches to :func:`plot_smp_penetration_parser` or
+    :func:`plot_snowscope_penetration_parser`. ``semilog_slope`` /
+    ``semilog_intercept`` apply only to SnowScope. ``**plot_kwargs`` (e.g.
+    ``title``, ``save_path``, ``show``) pass through to
+    :func:`plot_force_penetration_layers`.
+    """
+    if isinstance(parser, SnowScopeParser):
+        return plot_snowscope_penetration_parser(
+            parser,
+            method=method,
+            slope_angle_deg=slope_angle_deg,
+            density_method=density_method,  # type: ignore[arg-type]
+            semilog_slope=semilog_slope,
+            semilog_intercept=semilog_intercept,
+            layer_thickness_mm=layer_thickness_mm,
+            gradient_threshold=gradient_threshold,
+            **plot_kwargs,
+        )
+    if isinstance(parser, SMPParser):
+        if semilog_slope is not None or semilog_intercept is not None:
+            raise TypeError(
+                "semilog_slope and semilog_intercept apply only to SnowScopeParser"
+            )
+        return plot_smp_penetration_parser(
+            parser,
+            method=method,
+            slope_angle_deg=slope_angle_deg,
+            density_method=density_method,  # type: ignore[arg-type]
+            layer_thickness_mm=layer_thickness_mm,
+            gradient_threshold=gradient_threshold,
+            **plot_kwargs,
+        )
+    raise TypeError(
+        "plot_force_penetration_parser expects SMPParser or SnowScopeParser, "
+        f"got {type(parser).__name__}"
+    )

weac-3.3.0/src/weac/parser/plotting/smp_penetration_plot.py

@@ -0,0 +1,34 @@
+"""Extract-and-plot helper for :class:`~weac.parser.smp_parser.SMPParser`."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from matplotlib.figure import Figure
+
+from weac.parser.plotting.force_penetration_layers import plot_force_penetration_layers
+from weac.parser.smp_parser import DensityMethod, SMPParser
+
+
+def plot_smp_penetration_parser(
+    parser: SMPParser,
+    *,
+    method: Literal["bin", "gradient"] = "bin",
+    slope_angle_deg: float = 0.0,
+    density_method: DensityMethod | None = None,
+    layer_thickness_mm: float | None = None,
+    gradient_threshold: float = 12.0,
+    **plot_kwargs,
+) -> Figure:
+    """Extract from an SMP parser and plot the penetration-resistance debug view."""
+    profile = parser.extract_profile(density_method=density_method)
+    layers, _ = parser.extract_layers(
+        slope_angle_deg,
+        method=method,
+        density_method=density_method,
+        layer_thickness_mm=layer_thickness_mm,
+        gradient_threshold=gradient_threshold,
+    )
+    plot_kwargs.setdefault("layer_label", method)
+    plot_kwargs.setdefault("slope_angle_deg", slope_angle_deg)
+    return plot_force_penetration_layers(profile, layers, **plot_kwargs)

weac-3.3.0/src/weac/parser/plotting/snowscope_penetration_plot.py

@@ -0,0 +1,42 @@
+"""Extract-and-plot helper for :class:`~weac.parser.snowscope_parser.SnowScopeParser`."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from matplotlib.figure import Figure
+
+from weac.parser.plotting.force_penetration_layers import plot_force_penetration_layers
+from weac.parser.snowscope_parser import DensityMethod, SnowScopeParser
+
+
+def plot_snowscope_penetration_parser(
+    parser: SnowScopeParser,
+    *,
+    method: Literal["bin", "gradient"] = "bin",
+    slope_angle_deg: float = 0.0,
+    density_method: DensityMethod | None = None,
+    semilog_slope: float | None = None,
+    semilog_intercept: float | None = None,
+    layer_thickness_mm: float | None = None,
+    gradient_threshold: float = 12.0,
+    **plot_kwargs,
+) -> Figure:
+    """Extract from a SnowScope parser and plot the penetration-resistance debug view."""
+    profile = parser.extract_profile(
+        density_method=density_method,
+        semilog_slope=semilog_slope,
+        semilog_intercept=semilog_intercept,
+    )
+    layers, _ = parser.extract_layers(
+        slope_angle_deg,
+        method=method,
+        density_method=density_method,
+        semilog_slope=semilog_slope,
+        semilog_intercept=semilog_intercept,
+        layer_thickness_mm=layer_thickness_mm,
+        gradient_threshold=gradient_threshold,
+    )
+    plot_kwargs.setdefault("layer_label", method)
+    plot_kwargs.setdefault("slope_angle_deg", slope_angle_deg)
+    return plot_force_penetration_layers(profile, layers, **plot_kwargs)