Hydraulic Subdomains¶

Split a large 2D parent model, typically rain-on-grid, into breakout subdomains whose boundaries sit where normal depth holds. Each subdomain can then run on its own with simple normal-depth and inflow-hydrograph boundaries instead of backwater-driven forcing.

Placing a model boundary where normal depth can be assumed is standard practice. What RasSubdomain adds is a numerical way to find those places, directly from the parent's own plan HDF:

Pour points: candidate boundaries come from terrain-derived channels. Each pour point is the outlet of a TauDEM stream link (RasTauDem.delineate), and its contributing area is the union of that link's catchment and every catchment upstream.
Scoring: each candidate line is scored against the parent's native Face Flow and cell stage, through the conveyance of the parent's own face property tables.
Extent: each subdomain's extent is traced from the parent's cell-to-cell flow.

The method is expected to suit steep and moderate-slope domains. Where backwater controls (flat, tidal or reservoir-influenced reaches), few lines pass and the remainder stays large; the search reports that rather than forcing a split.

Python

from ras_commander.terrain import RasTauDem
from ras_commander.subdomain import RasSubdomain

taudem = RasTauDem.delineate("Terrain/dem.tif", "work/taudem",
                             stream_area_sqmi=0.5, cell_size=100.0)
search = RasSubdomain.find_split_lines(
    ["Model.p01.hdf", "Model.p02.hdf"],      # events of one geometry, with native Face Flow
    taudem.streams, taudem.catchments)
partition = RasSubdomain.build_subdomains(search)
partition.subdomains[["subdomain_id", "tier", "upstream_subdomain_ids", "area_sqmi", "labels"]]

Requirements¶

Parent plan HDFs: one or more events of one geometry, each with native Face Flow output. Add it with RasPlan.add_hdf_output_variable(plan, "Face Flow") and rerun the plan. Face flow is never estimated from Face Velocity.
Units: US Customary (feet) models only in this release; SI raises NotImplementedError.
Python packages: geopandas, shapely 2 and pyproj (pip install ras-commander[full]).
TauDEM: TauDEM 5 for the stream network (see Terrain Modules).

Finding split lines¶

RasSubdomain.find_split_lines(plan_hdf_paths, streams, catchments, *, mesh_name=None, growth_plan_hdf_path=None, criteria=None, link_ids=None)

Walk-up. From each pour point whose contributing area is at least min_contributing_area_sqmi, the search walks up the link (and its larger upstream link) in step_spacing_ft steps, out to walk_length_ft.
Line growth. At each step a line grows across the valley from the face the channel crosses. It follows the faces carrying the most downstream volume in the growth event (default: the event with the most volume) and stops at the edge of the wet_depth_ft wet extent.
Scoring. In every event the line is scored as a normal-depth boundary. Native Q(t) across the line is set against the stage of the cell above the seed face through K(z) = sum (1.486/n) A R^(2/3), at the best single slope. The scores are RMSE, peak error, rising/falling loop width, reverse fraction and the share of the contributing area's outflow.
Acceptance. A line passes in an event when all of these hold:
both banks close;
reverse flow is at most 5%;
RMSE, peak error and loop width are each at most 0.5 ft;
the best slope is within 1/3 to 3 times the link slope;
the line carries 80% to 120% of the contributing area's outflow.

A split line must pass in every event at its step and at a neighbouring step; the lowest mean RMSE wins.

These defaults are the project-engineer values of 2026-10-14 (SplitLineCriteria). link_ids limits the search to chosen TauDEM links, for example one headwater.

SplitLineSearch.split_lines (schema subdomain_split_lines) holds the accepted lines. candidates (schema subdomain_split_candidates) holds every scored step and event, with the criteria it failed.

Building subdomains¶

RasSubdomain.build_subdomains(search, *, split_line_ids=None)

Footprints: the footprint of a split line is every cell whose drainage path (each cell to the neighbour receiving most of its event volume) crosses the line, in any event, with holes filled.
Nesting: footprints nest, and each cell goes to the smallest footprint holding it. Tier 1 has nothing upstream; cells no line drains form the remainder.
Outputs: subdomains (schema subdomain_partition) and cell_owner (schema subdomain_cell_owner, every physical cell once).

Labels are information, not gates:

CLOSED_EDGE_LEAKAGE: gross exchange across closed edges is over 5% of outlet volume.
FOOTPRINT_OVERLAP
FOOTPRINT_PARTS_DROPPED
MULTIPART
STRUCTURE_ON_SPLIT_LINE
INTERIOR_SUBDOMAIN: touches no parent perimeter face (for example a band between two split lines on one stem). It can still be cut.
HOLES: a nested subdomain lies wholly inside this one, so this one has a hole.

The authoring step refuses HOLES, MULTIPART and STRUCTURE_ON_SPLIT_LINE in this release.

On the Salt Draw HEC-RAS 6.6 parent (794,332 cells, 1% AEP, native Face Flow) with TauDEM links at 100 ft and 0.5 sq mi, the search scored 1,304 pour points in 27,188 walk-up steps. It accepted 148 split lines, which nest into 30 tiers. The search took 16 minutes and the partition 5 more on a workstation; most of the time goes to streaming the 12.6 GB of face flow.

Authoring, running and comparing breakouts¶

Python

breakout_plan = RasSubdomain.plan_breakouts(partition, "01", ras_object=parent, subdomain_ids=["2568"])
assert breakout_plan.is_ready
breakouts = RasSubdomain.apply_breakouts(breakout_plan, "work/breakouts")
checks = RasSubdomain.validate_breakouts(breakouts)
runs = RasSubdomain.compute_subdomains(breakouts, max_workers=2, num_cores=4)
comparison = RasSubdomain.compare_to_parent(breakouts, "Model.p01.hdf")

`plan_breakouts`¶

plan_breakouts(partition, plan_number, *, ras_object, perimeter_friction_slope=0.01, subdomain_ids=None, closed_edge_outflow=False, closed_edge_friction_slope=0.00033, boundary_gap_cells=2) writes nothing. Per subdomain it records:

the exact parent cells to keep;
the BC lines:
the outlet split line as Normal Depth at its fitted slope;
one Flow Hydrograph line per upstream subdomain, carrying the parent's own flow across that split line until the upstream child has run. The flow comes from the parent run of the same plan: the search event whose plan HDF was forced by that plan's unsteady file. Without one, the inflow_event_matches_plan check blocks the plan;
Normal Depth along each stretch of the parent perimeter.

Every other edge, the divide with a neighbouring subdomain, is a closed wall unless closed_edge_outflow is set. It runs RasBreakout2D.preflight against the parent and checks that the parent geometry HDF is the mesh that was searched. HOLES, MULTIPART and STRUCTURE_ON_SPLIT_LINE become blocking checks.

Optional closed-edge outflow¶

In a rain-on-grid parent, sheet flow does not respect a terrain-derived divide exactly, and some water leaves the subdomain across its closed edges. A wall holds that water back: on Salt Draw headwater 2864, cells just inside the walls peaked up to 0.53 ft higher than in the parent.

closed_edge_outflow=True puts Normal Depth outflow lines along the closed edges so that water can leave as it does in the parent:

Slope: closed_edge_friction_slope, default 0.00033. This is a conservative minimum that stays numerically stable while letting water escape.
Spacing: each line stops boundary_gap_cells cell faces (default 2) short of the outlet, inflow and perimeter lines along the perimeter. No two BC lines then share a boundary face, which HEC-RAS rejects.
Outflow only: a normal-depth edge only lets water out. Inflow the parent received across the divide is still not represented.

It is off by default because it is not always appropriate. Where significant flow passes between basins in both directions, extend the breakout domain to include both basins instead.

On Salt Draw headwater 2864 (HEC-RAS 6.4.1, 1% AEP) the option made agreement with the parent worse, so the walled default is kept there:

Headwater 2864 vs parent	Walled (default)	`closed_edge_outflow=True`
Max-WSE diff p95 / p99 / max (ft)	0.017 / 0.083 / 1.15	0.032 / 0.42 / 2.98
Cells within 300 ft of a closed edge, p95 (ft)	0.26	1.23 (mean −0.28)
Outlet volume	+2.0%	−1.8%

The three closed-edge lines passed 4.1% of the outlet volume, against the parent's net 1.7% (2.6% out, 0.8% in) across the same edges. They also drained a 4.7 ft pond that the parent's terrain and the water on the far side of the divide hold. Use the option where the parent shows mostly one-way spill across a divide with no ponded storage against it.

`apply_breakouts`¶

apply_breakouts(breakout_plan, dest_folder, *, overwrite_dest=False, hecras_version=None, time_step="parent_minimum"):

Working copy: copies the parent project to dest_folder. The copy roots at the smallest folder holding the project file and its RAS Mapper assets (so eBFE layouts with Terrain/ beside Input/ keep resolving), and leaves out parent result HDFs.
Per subdomain:
clones plan, geometry and unsteady file (RasBreakout2D.clone_plan_components);
removes the parent's perimeter BC lines from the cloned geometry;
cuts the clone to the exact parent cells in the parent's HEC-RAS version (6.4.1 or 6.6) (prepare_cloned_geometry(parent_cell_ids=...));
writes the BC lines and their forcing (GeomBcLines.replace_bc_lines).
BC line placement: HEC-RAS can misclassify a line drawn on the perimeter or assign a short line to the whole ring. After each full preprocess, a line that HEC-RAS rejects, that attaches to no face, that shares faces with another line, or that spreads over the whole perimeter moves to its next placement. The placements, in order: on the perimeter; offset 1 ft outward with ends trimmed; extended 50 ft; following the perimeter 200, 400 or 800 ft past each end.
Time step: time_step="parent_minimum" fixes each child at the shortest step the parent can take, with the Courant-adaptive step off. A child must not out-step its parent, whose adaptive step is set by its most restrictive cells anywhere in the domain.

`validate_breakouts`, `compute_subdomains` and `compare_to_parent`¶

validate_breakouts preprocesses every child and checks each line against its compiled external faces (schema subdomain_breakout_checks).
compute_subdomains runs one tier at a time through RasCmdr.compute_parallel. Before each tier, each upstream child's outlet flow is written into the matching inflow line downstream (schema subdomain_compute_runs).
compare_to_parent compares each child cell with the same parent cell (schema subdomain_parent_comparison):
maximum-WSE difference percentiles over cells wet in both;
wet-extent IoU;
outlet peak, timing, volume and NSE against the parent's native flow across the same faces.

Salt Draw headwater 2568¶

5.1 sq mi, 2,407 parent cells, 1% AEP. The breakout ran in 1 min on a workstation (4 cores).

Child time step	Max-WSE diff p50 / p95 / p99 / max (ft)	Outlet peak	Outlet volume	Outlet NSE
Inherited adaptive (30 s, Courant 2)	0.007 / 0.67 / 1.53 / 3.10	+2.1%	-0.4%	0.58
Parent minimum (fixed 15 s), the default	0.0015 / 0.018 / 0.079 / 0.26	+2.6%	+2.0%	0.89

The parent dropped to 15 s at 12:03 on the event day, forced by its most restrictive cells elsewhere in the HUC. The child alone stayed at 30 s until 12:30, and a transient at its wetting front set summary maxima up to 3 ft high.

Salt Draw headwater 2864, run in the delivered version (HEC-RAS 6.4.1)¶

The parent is the delivered 6.4.1 model with its delivered mesh, re-run in 6.4.1 with native Face Flow for the 1% and 0.2% AEP events. The two-event search accepted 116 split lines in 25 tiers. Headwater 2864 (5.9 sq mi, 2,592 cells) was cut, preprocessed and run in 6.4.1, held at the parent's 15 s:

Max-WSE diff p50 / p95 / p99 / max (ft)	Outlet peak	Outlet volume	Outlet NSE
0.0005 / 0.017 / 0.083 / 1.15	+2.1%	+2.0%	0.9994

Running in the parent's own version needs no mesh repair. HEC-RAS 6.6 rejects 48 cells of the delivered mesh that have more than eight sides.

Example notebook¶

examples/237_hydraulic_subdomain_breakout.ipynb runs the whole workflow on Salt Draw in the delivered version, HEC-RAS 6.4.1:

organize the eBFE delivery;
run the delivered parent once with native Face Flow for the 1% and 0.2% AEP events (cached; no re-mesh);
delineate TauDEM links;
search the HUC for split lines that pass in both events;
author, validate and run one headwater subdomain;
compare it with the parent.

Provenance¶

Ported from fim-commander's rain-on-grid subdomain research on Salt Draw (HUC-8 13070004, one HEC-RAS 6.6 parent of about 794,000 cells). Six cookie-cut children plus the main channel reproduced the parent's 1% AEP results:

Main channel: maximum WSE p95 within 0.008 ft over 466,000 cells; HUC outlet peak within 0.2%, volume within 0.13%, NSE 0.99999.
Wall clock: the subdomain runs took about 28% less time than the parent run.

That research took its pour points from the NextGen hydrofabric. This port uses TauDEM links and catchments instead.

Source reference¶

Hydraulic subdomains of a 2D parent model: normal-depth split lines and nested footprints.

A large 2D (often rain-on-grid) parent is divided into breakout subdomains whose boundaries sit where normal depth holds. Placing a model boundary where normal depth can be assumed is standard practice; here the locations are found numerically from the parent's own plan HDF (native Face Flow and cell stage) along terrain-derived (TauDEM) stream links, and each subdomain's extent is traced from the parent's own cell-to-cell flow.

Workflow::

Text Only

streams + catchments  = RasTauDem.delineate(dem, folder)
search    = RasSubdomain.find_split_lines(plan_hdf_paths, streams, catchments)
partition = RasSubdomain.build_subdomains(search)

Labels are information, not gates; nothing here is hydraulic approval.

Ported from fim-commander fim_commander.methods.pic.split_lines and fim_commander.step.rog_split_lines (same owner), with TauDEM pour points and contributing areas in place of the NextGen hydrofabric.

RasSubdomain ¶

Static methods for finding and building hydraulic subdomains of a 2D parent model.

find_split_lines `staticmethod` ¶

Python

find_split_lines(plan_hdf_paths: Union[str, Path, Sequence[Union[str, Path]]], streams: Any, catchments: Any, *, mesh_name: Optional[str] = None, growth_plan_hdf_path: Union[str, Path, None] = None, criteria: Optional[SplitLineCriteria] = None, link_ids: Optional[Sequence[int]] = None) -> SplitLineSearch

Find normal-depth split lines in a parent's native face flow.

Pour points are the downstream ends (outlets) of the TauDEM stream links inside the mesh whose contributing area is at least criteria.min_contributing_area_sqmi. A pour point's contributing area U is the union of the catchments of its link and every link upstream. From each pour point the search walks up the link (and its larger upstream link) in step_spacing_ft steps to walk_length_ft. At each step a line grows across the valley from the face the channel crosses, along the faces carrying the most downstream volume in the growth event, to the edge of the wet_depth_ft wet extent. Each line is then scored in every event as a normal-depth boundary: native Q(t) across it against the stage of the cell above the seed face, through the conveyance K(z) of the line's face property tables, at the best single slope.

A line passes in an event when both banks close; reverse flow is at most max_reverse_fraction; RMSE, peak error and loop width are each at most max_fit_error_ft; the best slope is within slope_ratio_bounds of the link slope; and the line carries outflow_share_bounds of U's outflow. A split line passes in every event at its step and at a neighbouring step; the lowest mean RMSE wins.

Parameters:

Name	Type	Description	Default
`plan_hdf_paths`	`Union[str, Path, Sequence[Union[str, Path]]]`	One or more plan HDFs (events) of one geometry, each with native `Face Flow` output. Two events of different magnitude are recommended; a line must pass in every event.	required
`streams`	`Any`	TauDEM links (`RasTauDem.delineate(...).streams`, schema `taudem_streams`), any CRS.	required
`catchments`	`Any`	TauDEM catchments (schema `taudem_catchments`), any CRS.	required
`mesh_name`	`Optional[str]`	2D flow area; required when the plan has more than one.	`None`
`growth_plan_hdf_path`	`Union[str, Path, None]`	Event the lines grow on; default the event with the largest total face volume (widest wet extent).	`None`
`criteria`	`Optional[SplitLineCriteria]`	Thresholds; default :class:`SplitLineCriteria`.	`None`
`link_ids`	`Optional[Sequence[int]]`	Limit pour points to these TauDEM `LINKNO` values.	`None`

Returns:

Type	Description
`SplitLineSearch`	SplitLineSearch

Raises:

Type	Description
`ValueError`	Missing Face Flow, differing geometries, or no 2D area.
`NotImplementedError`	SI-unit parent.

build_subdomains `staticmethod` ¶

Python

build_subdomains(search: SplitLineSearch, *, split_line_ids: Optional[Sequence[int]] = None) -> SubdomainPartition

Trace each split line's footprint and nest the footprints into subdomains.

The footprint of a split line is every cell whose drainage path (each cell to the neighbour receiving most of its event volume) crosses the line in any event, with holes filled. Footprints nest; each cell goes to the smallest footprint holding it, so a subdomain is its footprint less the subdomains upstream of it. Tier 1 has nothing upstream. Cells no line drains form the remainder.

Parameters:

Name	Type	Description	Default
`search`	`SplitLineSearch`	From :meth:`find_split_lines` (same session; the parent arrays it read are reused).	required
`split_line_ids`	`Optional[Sequence[int]]`	Keep only these split lines (default: all).	`None`

Returns:

Type	Description
`SubdomainPartition. Labels (information only`	`CLOSED_EDGE_LEAKAGE`,
`SubdomainPartition`	`FOOTPRINT_OVERLAP`, `FOOTPRINT_PARTS_DROPPED`, `MULTIPART`,
`SubdomainPartition`	`STRUCTURE_ON_SPLIT_LINE`, `INTERIOR_SUBDOMAIN` (touches no
`SubdomainPartition`	parent perimeter face) and `HOLES`.

plan_breakouts `staticmethod` ¶

Python

plan_breakouts(partition: SubdomainPartition, plan_number: Union[str, int], *, ras_object: Any, perimeter_friction_slope: float = 0.01, subdomain_ids: Optional[Sequence[str]] = None, closed_edge_outflow: bool = False, closed_edge_friction_slope: float = 0.00033, boundary_gap_cells: int = 2) -> SubdomainBreakoutPlan

Plan one exact-cell breakout per subdomain; nothing is written.

For each subdomain (default: all, including the remainder) this records the parent cell ids to keep and the BC lines to author, and runs the read-only :meth:RasBreakout2D.preflight against ras_object:

the outlet split line as Normal Depth at the fitted slope;
one Flow Hydrograph line per upstream subdomain, carrying the parent's own flow across that split line until the upstream child has run. The flow is taken from the search event forced by this plan's unsteady file; without one, the inflow_event_matches_plan check blocks;
Normal Depth at perimeter_friction_slope along each stretch of the parent perimeter.

Every other edge (the divide with a neighbouring subdomain) is a closed wall unless closed_edge_outflow is set. Labels this release cannot cut (HOLES, MULTIPART, STRUCTURE_ON_SPLIT_LINE) become blocking checks.

Closed-edge outflow (optional). In a rain-on-grid parent, sheet flow crosses a terrain-derived divide; a wall there holds back water the parent let leave. closed_edge_outflow=True puts Normal Depth outflow lines at closed_edge_friction_slope (0.00033 by default, a conservative minimum that stays stable while letting water escape) along those edges. Each line stops boundary_gap_cells cell faces short of the outlet, inflow and perimeter lines along the perimeter, so no two BC lines share a boundary face. A normal-depth edge only lets water out. It is off by default because it is not always appropriate: where significant flow passes between basins in both directions, extend the model domain to include both basins instead.

Parameters:

Name	Type	Description	Default
`partition`	`SubdomainPartition`	From :meth:`build_subdomains` (same session).	required
`plan_number`	`Union[str, int]`	Parent plan whose geometry the cells come from. Its geometry HDF must be the compiled geometry of the searched events.	required
`ras_object`	`Any`	Initialized parent project (read only).	required
`perimeter_friction_slope`	`float`	Normal-depth slope on parent-perimeter stretches.	`0.01`
`subdomain_ids`	`Optional[Sequence[str]]`	Plan only these subdomains.	`None`
`closed_edge_outflow`	`bool`	Add Normal Depth outflow lines along closed edges.	`False`
`closed_edge_friction_slope`	`float`	Friction slope of those lines.	`0.00033`
`boundary_gap_cells`	`int`	Minimum cell faces, along the perimeter, between a closed-edge outflow line and any other BC line.	`2`

Returns:

Type	Description
`SubdomainBreakoutPlan`	SubdomainBreakoutPlan; `is_ready` is False while a blocking check fails.

apply_breakouts `staticmethod` ¶

Python

apply_breakouts(breakout_plan: SubdomainBreakoutPlan, dest_folder: Union[str, Path], *, overwrite_dest: bool = False, hecras_version: Optional[str] = None, time_step: str = 'parent_minimum', timeout: int = 1800) -> SubdomainBreakoutSet

Author every planned breakout in one staged working copy of the parent.

RasProject.stage_project copies the parent project to dest_folder. In that copy each subdomain becomes a cloned plan, geometry and unsteady file (:meth:RasBreakout2D.clone_plan_components), cut to its exact parent cells (prepare_cloned_geometry(parent_cell_ids=...), HEC-RAS 6.6), with its BC lines and forcing written by :meth:GeomBcLines.replace_bc_lines. Meteorology, initial conditions and solver settings are inherited from the parent plan. The parent is never modified.

Every BC line is checked against its compiled external faces after a full preprocess; a line HEC-RAS rejects, attaches to no face, shares faces with another line, or spreads over the whole perimeter moves to its next placement (on the perimeter; offset 1 ft outward with ends trimmed; extended; following the perimeter 200, 400 or 800 ft past each end).

Parameters:

Name	Type	Description	Default
`breakout_plan`	`SubdomainBreakoutPlan`	From :meth:`plan_breakouts`, with `is_ready` True.	required
`dest_folder`	`Union[str, Path]`	New folder for the working copy. The copied root is the smallest folder holding the project and its RAS Mapper assets; parent result HDFs are not copied.	required
`overwrite_dest`	`bool`	Replace an existing `dest_folder`.	`False`
`hecras_version`	`Optional[str]`	Version for the working project (default the parent's).	`None`
`time_step`	`str`	`"parent_minimum"` (default) fixes each child at the shortest step the parent can take (its base interval halved `Max Halving` times) with the Courant-adaptive step off. A child must not out-step the parent: on Salt Draw headwater 2568 the inherited adaptive step gave maximum-WSE differences up to 3.1 ft (p95 0.67 ft); the parent minimum, 15 s, gave 0.26 ft (p95 0.018 ft). `"inherit"` keeps the cloned plan's settings.	`'parent_minimum'`
`timeout`	`int`	Seconds allowed per native step.	`1800`

Returns:

Type	Description
`SubdomainBreakoutSet`	SubdomainBreakoutSet

validate_breakouts `staticmethod` ¶

Python

validate_breakouts(breakout_set: SubdomainBreakoutSet, *, max_wait: int = 3600) -> pd.DataFrame

Preprocess every child and check each BC line against its compiled external faces.

A BC line HEC-RAS attaches to no face, or spreads over the whole perimeter, fails. Returns a checks DataFrame (subdomain_id, check, passed, blocking, detail).

compute_subdomains `staticmethod` ¶

Python

compute_subdomains(breakout_set: SubdomainBreakoutSet, *, max_workers: int = 2, num_cores: int = 2) -> pd.DataFrame

Run the children tier by tier, handing each outlet hydrograph downstream.

Each tier is one :meth:RasCmdr.compute_parallel call in the working project. Before a tier runs, the summed flow of each upstream child's outlet BC line is written as the inline hydrograph of the matching inflow line (:meth:RasUnsteady.set_boundary_inline_hydrograph). Returns one row per subdomain: subdomain_id, tier, plan_number, success, tier_wall_clock_s, plan_hdf_path.

compare_to_parent `staticmethod` ¶

Python

compare_to_parent(breakout_set: SubdomainBreakoutSet, parent_plan_hdf_path: Union[str, Path], *, depth_threshold_ft: float = 0.1) -> pd.DataFrame

Compare each computed child with the parent on the same cells and outlet.

Child cells are the parent's own cells, matched by centre. Per subdomain: maximum-WSE difference (p50, p95, p99, max, mean) over cells wet above depth_threshold_ft in both, wet-extent IoU, and the outlet hydrograph's peak, peak time, volume and NSE against the parent's native flow across the same split line. No pass/fail: the table reports.

SplitLineCriteria `dataclass` ¶

Thresholds of the split-line search. Defaults are the project-engineer values of 2026-10-14.

Distances are feet; slopes and fractions are dimensionless.

SplitLineSearch `dataclass` ¶

Result of :meth:RasSubdomain.find_split_lines.

Attributes:

Name	Type	Description
`split_lines`	`Any`	One row per accepted split line (schema `subdomain_split_lines`).
`candidates`	`Any`	Every scored walk-up step and event (schema `subdomain_split_candidates`).
`criteria`	`SplitLineCriteria`	The thresholds used.
`mesh_name`	`str`	Parent 2D flow area.
`events`	`Tuple[str, ...]`	Event labels, in `plan_hdf_paths` order.
`plan_hdf_paths`	`Tuple[Path, ...]`	Parent plan HDFs.
`plan_hdf_sha256`	`Tuple[str, ...]`	SHA-256 of each plan HDF, in the same order.
`growth_event`	`str`	The event the lines grew on.

to_dict ¶

Python

to_dict() -> Dict[str, Any]

JSON-ready summary (frames summarized by row count).

SubdomainPartition `dataclass` ¶

Result of :meth:RasSubdomain.build_subdomains.

Attributes:

Name	Type	Description
`subdomains`	`Any`	One row per subdomain plus the remainder (schema `subdomain_partition`).
`cell_owner`	`Any`	`cell_id` to `subdomain_id`, every physical parent cell once.
`remainder_id`	`str`	`subdomain_id` of the cells no split line drains.
`run_order`	`Tuple[Tuple[str, ...], ...]`	Subdomain ids by tier, upstream first; the remainder runs last.
`search`	`SplitLineSearch`	The split-line search this partition was built from.

Breakout authoring, execution and comparison for hydraulic subdomains.

Builds on :class:RasBreakout2D (clone and exact cell-subset cut), :meth:GeomBcLines.replace_bc_lines (BC lines with their forcing), and :meth:RasCmdr.compute_parallel. The parent project is never modified: every child is a cloned plan, geometry and unsteady file inside one staged working copy of the parent.

SubdomainBreakout `dataclass` ¶

One planned breakout: the parent cells it keeps and the BC lines it gets.

SubdomainBreakoutPlan `dataclass` ¶

Read-only plan of :meth:RasSubdomain.plan_breakouts.

checks uses the ras_breakout_2d_checks columns plus subdomain_id. is_ready is False while any blocking check fails for a planned subdomain.

SubdomainBreakoutSet `dataclass` ¶

Authored breakouts in one staged working project (:meth:RasSubdomain.apply_breakouts).

children has one row per subdomain: subdomain_id, tier, plan_number, geometry_number, unsteady_number, geometry_path, unsteady_path, plan_path.

Hydraulic Subdomains¶

Requirements¶

Finding split lines¶

Building subdomains¶

Authoring, running and comparing breakouts¶

plan_breakouts¶

Optional closed-edge outflow¶

apply_breakouts¶

validate_breakouts, compute_subdomains and compare_to_parent¶

Salt Draw headwater 2568¶

Salt Draw headwater 2864, run in the delivered version (HEC-RAS 6.4.1)¶

Example notebook¶

Provenance¶

Source reference¶

RasSubdomain ¶

find_split_lines staticmethod ¶

build_subdomains staticmethod ¶

plan_breakouts staticmethod ¶

apply_breakouts staticmethod ¶

validate_breakouts staticmethod ¶

compute_subdomains staticmethod ¶

compare_to_parent staticmethod ¶

SplitLineCriteria dataclass ¶

SplitLineSearch dataclass ¶

to_dict ¶

SubdomainPartition dataclass ¶

SubdomainBreakout dataclass ¶

SubdomainBreakoutPlan dataclass ¶

SubdomainBreakoutSet dataclass ¶

`plan_breakouts`¶

`apply_breakouts`¶

`validate_breakouts`, `compute_subdomains` and `compare_to_parent`¶

find_split_lines `staticmethod` ¶

build_subdomains `staticmethod` ¶

plan_breakouts `staticmethod` ¶

apply_breakouts `staticmethod` ¶

validate_breakouts `staticmethod` ¶

compute_subdomains `staticmethod` ¶

compare_to_parent `staticmethod` ¶

SplitLineCriteria `dataclass` ¶

SplitLineSearch `dataclass` ¶

SubdomainPartition `dataclass` ¶

SubdomainBreakout `dataclass` ¶

SubdomainBreakoutPlan `dataclass` ¶

SubdomainBreakoutSet `dataclass` ¶