Skip to content

AORC annual storm catalog and batch plan authoring

This notebook builds a complete 2020 NOAA AORC storm catalog for the BaldEagleCrkMulti2D RasExamples model, downloads every qualifying simulation window, authors one HEC-RAS plan per event, verifies each durable precipitation HDF, checks the source gate schedule, and preprocesses every plan serially.

It intentionally stops before hydraulic computation. Computing an annual batch can take hours and produce many gigabytes. Notebook 900 is the bounded end-to-end example that computes one deterministic event and reconciles the source grid to the completed plan HDF.

Timing and validation contract

AORC APCP_surface is a one-hour amount ending at the UTC timestamp. For each plan, the first downloaded frame is therefore sim_start + 1 hour; the import HDF contains a zero cumulative baseline at sim_start. The temporary plan HDF is the pre-compute authority. A completed final plan HDF remains the post-compute authority if a user elects to run a plan.

Manual review is still required before production use: inspect source coverage, storm selection, runtime messages, precipitation maps, hydraulic maps, and mass balance for every plan that is actually computed.

Python
from __future__ import annotations

import os
from pathlib import Path

import h5py
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import xarray as xr

from ras_commander import RasExamples, RasPreprocess, RasUnsteady, init_ras_project
from ras_commander.hdf import HdfMesh, HdfProject
from ras_commander.precip import PrecipAorc

REPO_ROOT = Path.cwd()
if REPO_ROOT.name.lower() == "examples":
    REPO_ROOT = REPO_ROOT.parent

RUN_ROOT = Path(
    os.environ.get(
        "RAS_COMMANDER_EXAMPLE_RUN_ROOT",
        REPO_ROOT / "working" / "example_901_aorc_catalog",
    )
)
RUN_ROOT.mkdir(parents=True, exist_ok=True)

PROJECT_NAME = "BaldEagleCrkMulti2D"
PROJECT_SUFFIX = "aorc_catalog_901"
RAS_VERSION = os.environ.get("RAS_COMMANDER_EXAMPLE_RAS_VERSION", "7.0")
TEMPLATE_PLAN = "06"
CATALOG_YEAR = 2020
BUFFER_HOURS = 48
MIN_DEPTH_INCHES = 0.75
ENABLE_HDF_TIME_SERIES = False
GATE_BOUNDARY_INDEX = 0
GATE_NAME = "Gate #1"
SOURCE_GATE_OPENING_FT = 2.0

plt.rcParams.update({"figure.dpi": 120})
print(f"Run workspace: {RUN_ROOT.name}")
print(f"HEC-RAS version: {RAS_VERSION}; catalog year: {CATALOG_YEAR}")
Text Only
Run workspace: 901_20260926b
HEC-RAS version: 7.0; catalog year: 2020
Python
def interval_hours(interval_text: str) -> float:
    text = str(interval_text).strip().upper().replace(" ", "")
    if text.endswith("HOUR"):
        return float(text.removesuffix("HOUR") or 1)
    if text.endswith("MIN"):
        return float(text.removesuffix("MIN")) / 60.0
    raise ValueError(f"Unsupported interval: {interval_text!r}")


def project_file(ras, extension: str) -> Path:
    return ras.project_folder / f"{ras.project_name}.{extension}"

Extract the model and build the annual catalog

Python
project_path = RasExamples.extract_project(
    PROJECT_NAME,
    output_path=RUN_ROOT,
    suffix=PROJECT_SUFFIX,
)
ras = init_ras_project(project_path, ras_version=RAS_VERSION, load_results_summary=False)

plan_numbers = ras.plan_df["plan_number"].astype(str).str.zfill(2)
template_rows = ras.plan_df.loc[plan_numbers.eq(TEMPLATE_PLAN)]
assert len(template_rows) == 1
template_row = template_rows.iloc[0]
GEOMETRY_NUMBER = str(template_row["geometry_number"]).zfill(2)
GEOMETRY_HDF = project_file(ras, f"g{GEOMETRY_NUMBER}.hdf")
assert GEOMETRY_HDF.exists()

BOUNDS = tuple(
    float(value)
    for value in HdfProject.get_project_bounds_latlon(
        GEOMETRY_HDF,
        buffer_percent=10.0,
        include_1d=True,
        include_2d=True,
        include_storage=True,
    )
)
mesh_areas = HdfMesh.get_mesh_areas(GEOMETRY_HDF)

storm_catalog = PrecipAorc.get_storm_catalog(
    bounds=BOUNDS,
    year=CATALOG_YEAR,
    inter_event_hours=8.0,
    min_depth_inches=MIN_DEPTH_INCHES,
    min_wet_hours=1,
    buffer_hours=BUFFER_HOURS,
)
assert len(storm_catalog) > 0
assert storm_catalog["rank"].min() == 1

precip_folder = ras.project_folder / "Precipitation"
precip_folder.mkdir(exist_ok=True)
catalog_csv = precip_folder / "storm_catalog.csv"
storm_catalog.to_csv(catalog_csv, index=False)

print(f"Cataloged {len(storm_catalog)} storms and exported {catalog_csv.name}")
display(storm_catalog)
Text Only
2026-09-26 01:28:12 - ras_commander.RasExamples - INFO - Successfully extracted project 'BaldEagleCrkMulti2D' to BaldEagleCrkMulti2D_aorc_catalog_901


2026-09-26 01:28:13 - ras_commander.RasPrj - INFO - ras-commander v0.102.0 | An open-source project of CLB Engineering Corporation (https://clbengineering.com/) | Docs: https://rascommander.info | GitHub: https://github.com/gpt-cmdr/ras-commander


2026-09-26 01:28:13 - ras_commander.RasPrj - INFO - Project initialized: BaldEagleDamBrk


2026-09-26 01:28:13 - ras_commander.RasPrj - INFO - Using HEC-RAS version 7.0


2026-09-26 01:28:13 - ras_commander.RasPrj - INFO - 
═══════════════════════════════════════════════════════════════════════
ras-commander | HEC-RAS Automation Library
Docs: https://rascommander.info/ras/
Repo: https://github.com/gpt-cmdr/ras-commander
LLM agents: https://rascommander.info/ras/llms.txt
═══════════════════════════════════════════════════════════════════════

SUPPORT OPEN-SOURCE DEVELOPMENT:
  Using RAS Commander? Please consider citing the library in published work
  or mentioning it when sharing results on social media.
  Agents are encouraged to suggest a RAS Commander v0.102.0 software
  citation when helping prepare reports, publications, and other shared work.
  Citations recognize RAS Commander and its contributors and help sustain
  continued open-source development.
  Citation and sharing guidance: https://rascommander.info/ras/cite/

PROJECT DATAFRAMES (single source of truth — use these, not file globbing):
  ras.plan_df        Plans, HDF paths, geometry/flow associations
  ras.geom_df        Geometry files and HDF preprocessor paths
  ras.flow_df        Steady flow files
  ras.unsteady_df    Unsteady flow files and configurations
  ras.boundaries_df  Boundary conditions (type, name, location)
  ras.results_df     Lightweight HDF results summaries
  ras.rasmap_df      RASMapper layers, terrain, land cover paths

KEY APIS (static classes — call directly, never instantiate):
  Execution:    RasCmdr.compute_plan() / compute_parallel() / compute_test_mode()
  Plan Files:   RasPlan.clone_plan() / clone_geom() / set_geom()
  Unsteady:     RasUnsteady — IC/BC management, gate openings, precipitation
  Geometry:     GeomCrossSection, GeomBridge, GeomStorage, GeomLateral, GeomMesh
  HDF Results:  HdfResultsPlan.get_wse() / get_compute_messages()
                HdfResultsMesh.get_mesh_max_ws() / get_mesh_cells_timeseries()
                HdfMesh.get_mesh_cell_points()
  QA/QC:        RasCheck.run_check() / RasFixit (geometry repair)
  DSS:          RasDss.get_timeseries() / check_pathname()
  USGS:         UsgsGaugeSpatial, GaugeMatcher, RasUsgsBoundaryGeneration
  Precipitation: StormGenerator, Atlas14Storm, PrecipAorc, Atlas14Variance
  Terrain:      RasTerrain.create_terrain_hdf() / RasTerrainMod

MULTI-PROJECT: Pass ras_object= to all API calls when using local RasPrj instances.

EXAMPLES: 100+ notebooks in examples/ (100s=execution, 200s=geometry, 300s=unsteady,
  400s=HDF results, 500s=remote, 800s=QA/QC, 900s=data integration).
  Review relevant notebooks before assembling new workflows.

PLATFORM: Most HEC-RAS operations require Windows. Linux/Wine support for
  headless execution, data access, geometry modification, and preprocessing
  is available via RasProcess (HEC-RAS 6.6+). See ras_commander/RasProcess.py.
  Remote distributed execution: ras_commander/remote/ (PsExec, Docker, SSH, cloud).
═══════════════════════════════════════════════════════════════════════


2026-09-26 01:28:13 - ras_commander.precip.PrecipAorc - INFO - Generating AORC storm catalog for 2020: bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961; inter_event=8.0h, min_depth=0.75in, buffer=48h


2026-09-26 01:28:16 - ras_commander.precip.PrecipAorc - INFO - Storm catalog complete: 13 storms; depth 0.76-2.76 in; largest 2020-12-24 12:00 (2.76 in)


Cataloged 13 storms and exported storm_catalog.csv
storm_id start_time end_time sim_start sim_end total_depth_in peak_intensity_in_hr duration_hours wet_hours rank
0 1 2020-02-07 09:00:00 2020-02-07 17:00:00 2020-02-05 09:00:00 2020-02-09 17:00:00 1.019 0.280 9 9 8
1 2 2020-03-19 01:00:00 2020-03-19 10:00:00 2020-03-17 01:00:00 2020-03-21 10:00:00 0.776 0.215 10 8 11
2 3 2020-03-28 08:00:00 2020-03-29 11:00:00 2020-03-26 08:00:00 2020-03-31 11:00:00 1.555 0.167 28 20 6
3 4 2020-04-17 17:00:00 2020-04-18 08:00:00 2020-04-15 17:00:00 2020-04-20 08:00:00 0.770 0.094 16 16 12
4 5 2020-04-26 09:00:00 2020-04-27 02:00:00 2020-04-24 09:00:00 2020-04-29 02:00:00 0.758 0.090 18 17 13
5 6 2020-04-30 04:00:00 2020-05-01 00:00:00 2020-04-28 04:00:00 2020-05-03 00:00:00 2.126 0.204 21 20 2
6 7 2020-05-28 12:00:00 2020-05-29 02:00:00 2020-05-26 12:00:00 2020-05-31 02:00:00 0.952 0.348 15 7 9
7 8 2020-06-03 06:00:00 2020-06-03 21:00:00 2020-06-01 06:00:00 2020-06-05 21:00:00 0.875 0.368 16 8 10
8 9 2020-09-29 11:00:00 2020-09-30 08:00:00 2020-09-27 11:00:00 2020-10-02 08:00:00 1.271 0.197 22 19 7
9 10 2020-10-29 07:00:00 2020-10-30 18:00:00 2020-10-27 07:00:00 2020-11-01 18:00:00 1.734 0.128 36 25 5
10 11 2020-11-11 13:00:00 2020-11-11 22:00:00 2020-11-09 13:00:00 2020-11-13 22:00:00 2.010 0.532 10 10 3
11 12 2020-12-16 17:00:00 2020-12-17 09:00:00 2020-12-14 17:00:00 2020-12-19 09:00:00 1.824 0.171 17 17 4
12 13 2020-12-24 12:00:00 2020-12-25 12:00:00 2020-12-22 12:00:00 2020-12-27 12:00:00 2.760 0.226 25 24 1
Python
fig, axes = plt.subplots(2, 2, figsize=(13, 9), constrained_layout=True)
colors = ["#D39A2C" if rank == 1 else "#2D7FA3" for rank in storm_catalog["rank"]]

axes[0, 0].bar(storm_catalog["storm_id"], storm_catalog["total_depth_in"], color=colors)
axes[0, 0].set_title("Event depth")
axes[0, 0].set_ylabel("Spatial-mean depth (in)")

axes[0, 1].bar(storm_catalog["storm_id"], storm_catalog["peak_intensity_in_hr"], color=colors)
axes[0, 1].set_title("Peak hourly intensity")
axes[0, 1].set_ylabel("Intensity (in/hr)")

axes[1, 0].bar(storm_catalog["storm_id"], storm_catalog["duration_hours"], color=colors)
axes[1, 0].set_title("Wet-event duration")
axes[1, 0].set_ylabel("Hours")

axes[1, 1].scatter(storm_catalog["start_time"], storm_catalog["total_depth_in"], c=colors, s=55)
axes[1, 1].set_title(f"{CATALOG_YEAR} event timeline")
axes[1, 1].set_ylabel("Depth (in)")
axes[1, 1].tick_params(axis="x", rotation=35)

for ax in axes.ravel():
    ax.set_xlabel("Storm ID" if ax is not axes[1, 1] else "Event start")
    ax.grid(True, alpha=0.25)
fig.suptitle("AORC annual storm catalog; gold marks rank 1", fontweight="bold")
plt.show()

png

Download every exact window and author the batch

Python
plan_results = PrecipAorc.create_storm_plans(
    storm_catalog=storm_catalog,
    bounds=BOUNDS,
    template_plan=TEMPLATE_PLAN,
    precip_folder="Precipitation",
    ras_object=ras,
    download_data=True,
    enable_timeseries=ENABLE_HDF_TIME_SERIES,
)
assert len(plan_results) == len(storm_catalog)
assert plan_results["status"].eq("success").all(), plan_results[["storm_id", "status"]]
display(plan_results[[
    "storm_id", "rank", "start_time", "sim_start", "sim_end",
    "total_depth_in", "plan_number", "unsteady_number", "status",
]])
Text Only
2026-09-26 01:28:16 - ras_commander.precip.PrecipAorc - INFO - Creating storm plans from template plan 06 (unsteady 03); processing 13 storms


2026-09-26 01:28:16 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-02-05 10:00:00 to 2020-02-09 17:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:17 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200207.nc (0.1 MB, 104 timesteps)


2026-09-26 01:28:18 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u04.hdf: 105 timesteps, 414 cells, range=0.0-38.0 mm


2026-09-26 01:28:18 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u04: source=.\Precipitation\storm_20200207.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:19 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p07


2026-09-26 01:28:19 - ras_commander.precip.PrecipAorc - INFO - Created storm 1: 2020-02-07 (1.02 in) -> plan 07, unsteady 04, without HDF time series


2026-09-26 01:28:19 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-03-17 02:00:00 to 2020-03-21 10:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:20 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200319.nc (0.1 MB, 105 timesteps)


2026-09-26 01:28:21 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u05.hdf: 106 timesteps, 414 cells, range=0.0-45.9 mm


2026-09-26 01:28:21 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u05: source=.\Precipitation\storm_20200319.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:22 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p08


2026-09-26 01:28:22 - ras_commander.precip.PrecipAorc - INFO - Created storm 2: 2020-03-19 (0.78 in) -> plan 08, unsteady 05, without HDF time series


2026-09-26 01:28:22 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-03-26 09:00:00 to 2020-03-31 11:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:23 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200328.nc (0.1 MB, 123 timesteps)


2026-09-26 01:28:24 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u06.hdf: 124 timesteps, 414 cells, range=0.0-62.0 mm


2026-09-26 01:28:24 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u06: source=.\Precipitation\storm_20200328.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:25 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p09


2026-09-26 01:28:25 - ras_commander.precip.PrecipAorc - INFO - Created storm 3: 2020-03-28 (1.55 in) -> plan 09, unsteady 06, without HDF time series


2026-09-26 01:28:25 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-04-15 18:00:00 to 2020-04-20 08:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:26 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200417.nc (0.1 MB, 111 timesteps)


2026-09-26 01:28:27 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u14.hdf: 112 timesteps, 414 cells, range=0.0-29.0 mm


2026-09-26 01:28:27 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u14: source=.\Precipitation\storm_20200417.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:27 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p10


2026-09-26 01:28:27 - ras_commander.precip.PrecipAorc - INFO - Created storm 4: 2020-04-17 (0.77 in) -> plan 10, unsteady 14, without HDF time series


2026-09-26 01:28:27 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-04-24 10:00:00 to 2020-04-29 02:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:29 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200426.nc (0.1 MB, 113 timesteps)


2026-09-26 01:28:29 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u15.hdf: 114 timesteps, 414 cells, range=0.0-30.6 mm


2026-09-26 01:28:29 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u15: source=.\Precipitation\storm_20200426.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:30 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p11


2026-09-26 01:28:30 - ras_commander.precip.PrecipAorc - INFO - Created storm 5: 2020-04-26 (0.76 in) -> plan 11, unsteady 15, without HDF time series


2026-09-26 01:28:30 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-04-28 05:00:00 to 2020-05-03 00:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:32 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200430.nc (0.1 MB, 116 timesteps)


2026-09-26 01:28:32 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u16.hdf: 117 timesteps, 414 cells, range=0.0-68.9 mm


2026-09-26 01:28:32 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u16: source=.\Precipitation\storm_20200430.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:33 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p12


2026-09-26 01:28:33 - ras_commander.precip.PrecipAorc - INFO - Created storm 6: 2020-04-30 (2.13 in) -> plan 12, unsteady 16, without HDF time series


2026-09-26 01:28:33 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-05-26 13:00:00 to 2020-05-31 02:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:34 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200528.nc (0.1 MB, 110 timesteps)


2026-09-26 01:28:35 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u17.hdf: 111 timesteps, 414 cells, range=0.0-57.7 mm


2026-09-26 01:28:35 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u17: source=.\Precipitation\storm_20200528.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:36 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p14


2026-09-26 01:28:36 - ras_commander.precip.PrecipAorc - INFO - Created storm 7: 2020-05-28 (0.95 in) -> plan 14, unsteady 17, without HDF time series


2026-09-26 01:28:36 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-06-01 07:00:00 to 2020-06-05 21:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:37 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200603.nc (0.1 MB, 111 timesteps)


2026-09-26 01:28:38 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u18.hdf: 112 timesteps, 414 cells, range=0.0-45.9 mm


2026-09-26 01:28:38 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u18: source=.\Precipitation\storm_20200603.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:39 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p16


2026-09-26 01:28:39 - ras_commander.precip.PrecipAorc - INFO - Created storm 8: 2020-06-03 (0.88 in) -> plan 16, unsteady 18, without HDF time series


2026-09-26 01:28:39 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-09-27 12:00:00 to 2020-10-02 08:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:40 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20200929.nc (0.1 MB, 117 timesteps)


2026-09-26 01:28:41 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u19.hdf: 118 timesteps, 414 cells, range=0.0-39.6 mm


2026-09-26 01:28:41 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u19: source=.\Precipitation\storm_20200929.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:42 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p20


2026-09-26 01:28:42 - ras_commander.precip.PrecipAorc - INFO - Created storm 9: 2020-09-29 (1.27 in) -> plan 20, unsteady 19, without HDF time series


2026-09-26 01:28:42 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-10-27 08:00:00 to 2020-11-01 18:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:43 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20201029.nc (0.1 MB, 131 timesteps)


2026-09-26 01:28:44 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u20.hdf: 132 timesteps, 414 cells, range=0.0-56.1 mm


2026-09-26 01:28:44 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u20: source=.\Precipitation\storm_20201029.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:45 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p21


2026-09-26 01:28:45 - ras_commander.precip.PrecipAorc - INFO - Created storm 10: 2020-10-29 (1.73 in) -> plan 21, unsteady 20, without HDF time series


2026-09-26 01:28:45 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-11-09 14:00:00 to 2020-11-13 22:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:46 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20201111.nc (0.1 MB, 105 timesteps)


2026-09-26 01:28:46 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u21.hdf: 106 timesteps, 414 cells, range=0.0-77.9 mm


2026-09-26 01:28:46 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u21: source=.\Precipitation\storm_20201111.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:47 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p22


2026-09-26 01:28:47 - ras_commander.precip.PrecipAorc - INFO - Created storm 11: 2020-11-11 (2.01 in) -> plan 22, unsteady 21, without HDF time series


2026-09-26 01:28:47 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-12-14 18:00:00 to 2020-12-19 09:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:49 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20201216.nc (0.1 MB, 112 timesteps)


2026-09-26 01:28:49 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u22.hdf: 113 timesteps, 414 cells, range=0.0-60.2 mm


2026-09-26 01:28:49 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u22: source=.\Precipitation\storm_20201216.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:50 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p23


2026-09-26 01:28:50 - ras_commander.precip.PrecipAorc - INFO - Created storm 12: 2020-12-16 (1.82 in) -> plan 23, unsteady 22, without HDF time series


2026-09-26 01:28:50 - ras_commander.precip.PrecipAorc - INFO - Downloading AORC APCP_surface: 2020-12-22 13:00:00 to 2020-12-27 12:00:00, bounds W=-77.7807, S=40.9494, E=-77.3059, N=41.1961


2026-09-26 01:28:52 - ras_commander.precip.PrecipAorc - INFO - AORC download complete: storm_20201224.nc (0.1 MB, 120 timesteps)


2026-09-26 01:28:52 - ras_commander.RasUnsteady - INFO - Imported gridded precipitation into BaldEagleDamBrk.u23.hdf: 121 timesteps, 414 cells, range=0.0-84.0 mm


2026-09-26 01:28:52 - ras_commander.RasUnsteady - INFO - Configured gridded precipitation in BaldEagleDamBrk.u23: source=.\Precipitation\storm_20201224.nc, interpolation=Bilinear, dataset=APCP_surface


2026-09-26 01:28:53 - ras_commander.RasPlan - INFO - Updated simulation date in plan file: BaldEagleDamBrk.p24


2026-09-26 01:28:53 - ras_commander.precip.PrecipAorc - INFO - Created storm 13: 2020-12-24 (2.76 in) -> plan 24, unsteady 23, without HDF time series


2026-09-26 01:28:53 - ras_commander.precip.PrecipAorc - INFO - Storm plan creation complete: 13/13 successful
storm_id rank start_time sim_start sim_end total_depth_in plan_number unsteady_number status
0 1 8 2020-02-07 09:00:00 2020-02-05 09:00:00 2020-02-09 17:00:00 1.019 07 04 success
1 2 11 2020-03-19 01:00:00 2020-03-17 01:00:00 2020-03-21 10:00:00 0.776 08 05 success
2 3 6 2020-03-28 08:00:00 2020-03-26 08:00:00 2020-03-31 11:00:00 1.555 09 06 success
3 4 12 2020-04-17 17:00:00 2020-04-15 17:00:00 2020-04-20 08:00:00 0.770 10 14 success
4 5 13 2020-04-26 09:00:00 2020-04-24 09:00:00 2020-04-29 02:00:00 0.758 11 15 success
5 6 2 2020-04-30 04:00:00 2020-04-28 04:00:00 2020-05-03 00:00:00 2.126 12 16 success
6 7 9 2020-05-28 12:00:00 2020-05-26 12:00:00 2020-05-31 02:00:00 0.952 14 17 success
7 8 10 2020-06-03 06:00:00 2020-06-01 06:00:00 2020-06-05 21:00:00 0.875 16 18 success
8 9 7 2020-09-29 11:00:00 2020-09-27 11:00:00 2020-10-02 08:00:00 1.271 20 19 success
9 10 5 2020-10-29 07:00:00 2020-10-27 07:00:00 2020-11-01 18:00:00 1.734 21 20 success
10 11 3 2020-11-11 13:00:00 2020-11-09 13:00:00 2020-11-13 22:00:00 2.010 22 21 success
11 12 4 2020-12-16 17:00:00 2020-12-14 17:00:00 2020-12-19 09:00:00 1.824 23 22 success
12 13 1 2020-12-24 12:00:00 2020-12-22 12:00:00 2020-12-27 12:00:00 2.760 24 23 success
Python
forcing_checks = []
hyetographs = []
for _, row in plan_results.iterrows():
    precip_file = ras.project_folder / row["precip_file"]
    with xr.open_dataset(precip_file) as dataset:
        amount_mm = dataset["APCP_surface"].load()

    times = pd.to_datetime(amount_mm["time"].values)
    sim_start = pd.Timestamp(row["sim_start"])
    sim_end = pd.Timestamp(row["sim_end"])
    expected_frames = int((sim_end - sim_start).total_seconds() / 3600)
    event_amount = amount_mm.sel(time=slice(row["start_time"], row["end_time"]))
    projected_event_depth_in = float(event_amount.mean(("x", "y")).sum() / 25.4)
    catalog_delta_in = projected_event_depth_in - float(row["total_depth_in"])

    assert times[0] == sim_start + pd.Timedelta(hours=1)
    assert times[-1] == sim_end
    assert len(times) == expected_frames
    assert amount_mm.attrs["value_type"] == "amount"
    assert float(np.nanmin(amount_mm.values)) >= 0.0
    assert float(np.nanmax(amount_mm.values)) > 0.0
    assert abs(catalog_delta_in) <= 0.10

    hourly_mean_in = amount_mm.mean(("x", "y")) / 25.4
    hyetographs.append((row, times, hourly_mean_in.values))
    forcing_checks.append({
        "storm_id": int(row["storm_id"]),
        "plan_number": str(row["plan_number"]).zfill(2),
        "first_valid": times[0],
        "last_valid": times[-1],
        "frames": len(times),
        "catalog_depth_in": float(row["total_depth_in"]),
        "projected_depth_in": projected_event_depth_in,
        "difference_in": catalog_delta_in,
    })

forcing_checks_df = pd.DataFrame(forcing_checks)
display(forcing_checks_df)
assert forcing_checks_df["difference_in"].abs().max() <= 0.10
storm_id plan_number first_valid last_valid frames catalog_depth_in projected_depth_in difference_in
0 1 07 2020-02-05 10:00:00 2020-02-09 17:00:00 104 1.019 1.019891 0.000891
1 2 08 2020-03-17 02:00:00 2020-03-21 10:00:00 105 0.776 0.776134 0.000134
2 3 09 2020-03-26 09:00:00 2020-03-31 11:00:00 123 1.555 1.558938 0.003938
3 4 10 2020-04-15 18:00:00 2020-04-20 08:00:00 111 0.770 0.770992 0.000992
4 5 11 2020-04-24 10:00:00 2020-04-29 02:00:00 113 0.758 0.756949 -0.001051
5 6 12 2020-04-28 05:00:00 2020-05-03 00:00:00 116 2.126 2.124486 -0.001514
6 7 14 2020-05-26 13:00:00 2020-05-31 02:00:00 110 0.952 0.949612 -0.002388
7 8 16 2020-06-01 07:00:00 2020-06-05 21:00:00 111 0.875 0.874941 -0.000059
8 9 20 2020-09-27 12:00:00 2020-10-02 08:00:00 117 1.271 1.271727 0.000727
9 10 21 2020-10-27 08:00:00 2020-11-01 18:00:00 131 1.734 1.734443 0.000443
10 11 22 2020-11-09 14:00:00 2020-11-13 22:00:00 105 2.010 2.008726 -0.001274
11 12 23 2020-12-14 18:00:00 2020-12-19 09:00:00 112 1.824 1.821718 -0.002282
12 13 24 2020-12-22 13:00:00 2020-12-27 12:00:00 120 2.760 2.762355 0.002355
Python
ncols = 3
nrows = int(np.ceil(len(hyetographs) / ncols))
fig, axes = plt.subplots(nrows, ncols, figsize=(14, 2.7 * nrows), constrained_layout=True)
for ax, (row, times, hourly_mean_in) in zip(np.asarray(axes).ravel(), hyetographs):
    ax.bar(times, hourly_mean_in, width=0.04, color="#2D7FA3")
    ax.axvspan(row["start_time"], row["end_time"], color="#D39A2C", alpha=0.18)
    ax.set_title(
        f"Storm {int(row['storm_id'])} / rank {int(row['rank'])}: "
        f"{row['total_depth_in']:.2f} in"
    )
    ax.set_ylabel("Mean hourly depth (in)")
    ax.grid(True, axis="y", alpha=0.25)
    ax.tick_params(axis="x", rotation=25)
for ax in np.asarray(axes).ravel()[len(hyetographs):]:
    ax.set_visible(False)
fig.suptitle("Exact-window AORC forcing for every authored plan", fontweight="bold")
plt.show()

png

Check gate coverage and durable precipitation imports

Python
gate_checks = []
import_checks = []
for _, row in plan_results.iterrows():
    plan_number = str(row["plan_number"]).zfill(2)
    unsteady_number = str(row["unsteady_number"]).zfill(2)
    sim_start = pd.Timestamp(row["sim_start"])
    sim_end = pd.Timestamp(row["sim_end"])
    duration_hours = (sim_end - sim_start).total_seconds() / 3600

    gate_before = RasUnsteady.get_gate_openings(
        unsteady_number,
        boundary_index=GATE_BOUNDARY_INDEX,
        ras_object=ras,
    )
    gate_interval_hours = interval_hours(gate_before["interval"])
    required_gate_values = int(np.ceil(duration_hours / gate_interval_hours)) + 1
    action = "already covered"
    if int(gate_before["count"]) < required_gate_values:
        RasUnsteady.set_gate_openings(
            unsteady_number,
            values=[SOURCE_GATE_OPENING_FT] * required_gate_values,
            boundary_index=GATE_BOUNDARY_INDEX,
            gate_name=GATE_NAME,
            interval=gate_before["interval"],
            ras_object=ras,
        )
        action = "extended"
    gate_after = RasUnsteady.get_gate_openings(
        unsteady_number,
        boundary_index=GATE_BOUNDARY_INDEX,
        ras_object=ras,
    )
    assert int(gate_after["count"]) >= required_gate_values
    assert np.allclose(gate_after["values"], SOURCE_GATE_OPENING_FT)
    gate_checks.append({
        "storm_id": int(row["storm_id"]),
        "plan_number": plan_number,
        "required_values": required_gate_values,
        "values_written": int(gate_after["count"]),
        "interval": gate_after["interval"],
        "action": action,
    })

    expected_frames = int(duration_hours)
    unsteady_hdf = project_file(ras, f"u{unsteady_number}.hdf")
    values_path = "Event Conditions/Meteorology/Precipitation/Imported Raster Data/Values"
    with h5py.File(unsteady_hdf, "r") as hdf:
        imported_cumulative = hdf[values_path][:]
    assert imported_cumulative.shape[0] == expected_frames + 1
    assert np.allclose(imported_cumulative[0], 0.0)
    assert float(np.nanmin(np.diff(imported_cumulative, axis=0))) >= -1e-7
    assert float(np.nanmax(imported_cumulative[-1])) > 0.0
    import_checks.append({
        "storm_id": int(row["storm_id"]),
        "plan_number": plan_number,
        "unsteady_number": unsteady_number,
        "HDF_rows": imported_cumulative.shape[0],
        "HDF_grid_cells": imported_cumulative.shape[1],
        "maximum_cumulative_mm": float(np.nanmax(imported_cumulative[-1])),
    })

gate_checks_df = pd.DataFrame(gate_checks)
import_checks_df = pd.DataFrame(import_checks)
display(gate_checks_df)
display(import_checks_df)
storm_id plan_number required_values values_written interval action
0 1 07 19 100 6HOUR already covered
1 2 08 19 100 6HOUR already covered
2 3 09 22 100 6HOUR already covered
3 4 10 20 100 6HOUR already covered
4 5 11 20 100 6HOUR already covered
5 6 12 21 100 6HOUR already covered
6 7 14 20 100 6HOUR already covered
7 8 16 20 100 6HOUR already covered
8 9 20 21 100 6HOUR already covered
9 10 21 23 100 6HOUR already covered
10 11 22 19 100 6HOUR already covered
11 12 23 20 100 6HOUR already covered
12 13 24 21 100 6HOUR already covered
storm_id plan_number unsteady_number HDF_rows HDF_grid_cells maximum_cumulative_mm
0 1 07 04 105 414 38.000000
1 2 08 05 106 414 45.900002
2 3 09 06 124 414 62.000000
3 4 10 14 112 414 29.000000
4 5 11 15 114 414 30.600002
5 6 12 16 117 414 68.900002
6 7 14 17 111 414 57.700005
7 8 16 18 112 414 45.899998
8 9 20 19 118 414 39.599998
9 10 21 20 132 414 56.100002
10 11 22 21 106 414 77.900002
11 12 23 22 113 414 60.200001
12 13 24 23 121 414 84.000008

Preprocess every authored plan serially

Python
preprocess_checks = []
for _, row in plan_results.iterrows():
    plan_number = str(row["plan_number"]).zfill(2)
    expected_frames = int(
        (pd.Timestamp(row["sim_end"]) - pd.Timestamp(row["sim_start"])).total_seconds()
        / 3600
    )
    prepared = RasPreprocess.preprocess_plan(plan_number, ras_object=ras, max_wait=600)
    assert bool(prepared), prepared.error
    with h5py.File(prepared.tmp_hdf_path, "r") as hdf:
        solver_values = hdf["Event Conditions/Meteorology/Precipitation/Values"][:]
        solver_times = hdf["Event Conditions/Meteorology/Precipitation/Timestamp"][:]

    assert solver_values.shape[0] == expected_frames + 1
    assert solver_values.shape[0] == len(solver_times)
    assert np.isfinite(solver_values).all()
    assert float(np.nanmin(solver_values)) >= 0.0
    assert float(np.nanmax(solver_values)) > 0.0
    assert np.allclose(solver_values[0], 0.0)
    preprocess_checks.append({
        "storm_id": int(row["storm_id"]),
        "plan_number": plan_number,
        "frames": solver_values.shape[0],
        "solver_grid_cells": solver_values.shape[1],
        "mean_total_depth": float(np.nanmean(solver_values.sum(axis=0))),
        "maximum_interval_depth": float(np.nanmax(solver_values)),
        "preprocess_seconds": float(prepared.elapsed_seconds),
    })
    print(
        f"Plan {plan_number}: {solver_values.shape[0]} frames x "
        f"{solver_values.shape[1]} cells; max interval {np.nanmax(solver_values):.4f}"
    )

preprocess_checks_df = pd.DataFrame(preprocess_checks)
display(preprocess_checks_df)
Text Only
2026-09-26 01:28:56 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 07


2026-09-26 01:28:56 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco07 for 'Starting Unsteady Flow Computations' signal...


2026-09-26 01:29:10 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:29:10 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 07 in 14.0s: tmp.hdf=11.2MB, b=3KB, x=5KB


2026-09-26 01:29:10 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 08


2026-09-26 01:29:10 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco08 for 'Starting Unsteady Flow Computations' signal...


Plan 07: 105 frames x 414 cells; max interval 0.3504


2026-09-26 01:29:24 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:29:24 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 08 in 13.4s: tmp.hdf=12.1MB, b=3KB, x=5KB


2026-09-26 01:29:24 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 09


2026-09-26 01:29:24 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco09 for 'Starting Unsteady Flow Computations' signal...


Plan 08: 106 frames x 414 cells; max interval 0.2638


2026-09-26 01:29:36 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:29:36 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 09 in 12.5s: tmp.hdf=11.4MB, b=3KB, x=5KB


2026-09-26 01:29:36 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 10


2026-09-26 01:29:36 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco10 for 'Starting Unsteady Flow Computations' signal...


Plan 09: 124 frames x 414 cells; max interval 0.5866


2026-09-26 01:29:48 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:29:49 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 10 in 12.5s: tmp.hdf=12.3MB, b=3KB, x=5KB


2026-09-26 01:29:49 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 11


2026-09-26 01:29:49 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco11 for 'Starting Unsteady Flow Computations' signal...


Plan 10: 112 frames x 414 cells; max interval 0.1811


2026-09-26 01:30:01 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:30:01 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 11 in 12.5s: tmp.hdf=11.4MB, b=3KB, x=5KB


2026-09-26 01:30:01 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 12


2026-09-26 01:30:01 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco12 for 'Starting Unsteady Flow Computations' signal...


Plan 11: 114 frames x 414 cells; max interval 0.1654


2026-09-26 01:30:13 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:30:13 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 12 in 12.4s: tmp.hdf=12.3MB, b=3KB, x=5KB


2026-09-26 01:30:13 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 14


2026-09-26 01:30:14 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco14 for 'Starting Unsteady Flow Computations' signal...


Plan 12: 117 frames x 414 cells; max interval 0.3780


2026-09-26 01:30:26 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:30:26 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 14 in 12.5s: tmp.hdf=11.4MB, b=3KB, x=5KB


2026-09-26 01:30:26 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 16


2026-09-26 01:30:26 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco16 for 'Starting Unsteady Flow Computations' signal...


Plan 14: 111 frames x 414 cells; max interval 1.3425


2026-09-26 01:30:39 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:30:39 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 16 in 13.0s: tmp.hdf=12.2MB, b=3KB, x=5KB


2026-09-26 01:30:39 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 20


2026-09-26 01:30:39 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco20 for 'Starting Unsteady Flow Computations' signal...


Plan 16: 112 frames x 414 cells; max interval 0.5472


2026-09-26 01:30:52 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:30:52 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 20 in 13.0s: tmp.hdf=12.2MB, b=3KB, x=5KB


2026-09-26 01:30:52 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 21


2026-09-26 01:30:52 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco21 for 'Starting Unsteady Flow Computations' signal...


Plan 20: 118 frames x 414 cells; max interval 0.2953


2026-09-26 01:31:05 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:31:05 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 21 in 13.0s: tmp.hdf=12.2MB, b=3KB, x=5KB


2026-09-26 01:31:05 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 22


2026-09-26 01:31:05 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco22 for 'Starting Unsteady Flow Computations' signal...


Plan 21: 132 frames x 414 cells; max interval 0.2677


2026-09-26 01:31:09 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:31:09 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 22 in 3.7s: tmp.hdf=12.2MB, b=3KB, x=5KB


2026-09-26 01:31:09 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 23


2026-09-26 01:31:09 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco23 for 'Starting Unsteady Flow Computations' signal...


Plan 22: 106 frames x 414 cells; max interval 1.0512


2026-09-26 01:31:12 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:31:12 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 23 in 3.7s: tmp.hdf=12.2MB, b=3KB, x=5KB


2026-09-26 01:31:12 - ras_commander.RasPreprocess - INFO - Starting HEC-RAS preprocessing for plan 24


2026-09-26 01:31:12 - ras_commander.RasBco - INFO - Monitoring BaldEagleDamBrk.bco24 for 'Starting Unsteady Flow Computations' signal...


Plan 23: 113 frames x 414 cells; max interval 0.3189


2026-09-26 01:31:16 - ras_commander.RasBco - INFO - Detected fresh preprocessing artifacts with materialized gridded precipitation


2026-09-26 01:31:16 - ras_commander.RasPreprocess - INFO - Preprocessing complete for plan 24 in 3.7s: tmp.hdf=12.2MB, b=3KB, x=5KB


Plan 24: 121 frames x 414 cells; max interval 0.3110
storm_id plan_number frames solver_grid_cells mean_total_depth maximum_interval_depth preprocess_seconds
0 1 07 105 414 0.798053 0.350394 13.986862
1 2 08 106 414 0.987895 0.263780 13.440540
2 3 09 124 414 1.222822 0.586615 12.462591
3 4 10 112 414 0.578141 0.181102 12.471151
4 5 11 114 414 0.622837 0.165354 12.459123
5 6 12 117 414 1.392075 0.377953 12.444133
6 7 14 111 414 0.803835 1.342520 12.473811
7 8 16 112 414 0.825954 0.547244 12.964296
8 9 20 118 414 0.829768 0.295276 13.024937
9 10 21 132 414 1.219018 0.267717 12.974853
10 11 22 106 414 1.315076 1.051182 3.668051
11 12 23 113 414 1.179838 0.318898 3.669434
12 13 24 121 414 1.815000 0.311024 3.676010
Python
fig, (depth_ax, runtime_ax) = plt.subplots(1, 2, figsize=(12.5, 4.3), constrained_layout=True)
depth_ax.scatter(
    forcing_checks_df["catalog_depth_in"],
    forcing_checks_df["projected_depth_in"],
    c=storm_catalog["rank"],
    cmap="viridis_r",
    s=65,
)
limits = [
    min(forcing_checks_df["catalog_depth_in"].min(), forcing_checks_df["projected_depth_in"].min()),
    max(forcing_checks_df["catalog_depth_in"].max(), forcing_checks_df["projected_depth_in"].max()),
]
depth_ax.plot(limits, limits, "--", color="#B64C3B", label="1:1")
depth_ax.set_title("Catalog vs reprojected event depth")
depth_ax.set_xlabel("Native-grid catalog depth (in)")
depth_ax.set_ylabel("Projected NetCDF depth (in)")
depth_ax.grid(True, alpha=0.25)
depth_ax.legend()

runtime_ax.bar(preprocess_checks_df["storm_id"], preprocess_checks_df["preprocess_seconds"], color="#2D7FA3")
runtime_ax.set_title("Serial HEC-RAS preprocessing time")
runtime_ax.set_xlabel("Storm ID")
runtime_ax.set_ylabel("Seconds")
runtime_ax.grid(True, axis="y", alpha=0.25)
plt.show()

completion_checks = pd.Series(
    {
        "annual catalog is non-empty": len(storm_catalog) > 0,
        "every exact forcing window validated": len(forcing_checks_df) == len(storm_catalog),
        "all projected event depths agree with catalog": forcing_checks_df["difference_in"].abs().max() <= 0.10,
        "every storm plan authored": plan_results["status"].eq("success").all(),
        "every gate schedule covers its simulation": (gate_checks_df["values_written"] >= gate_checks_df["required_values"]).all(),
        "every durable import begins at zero": len(import_checks_df) == len(storm_catalog),
        "every plan preprocesses with nonzero rainfall": len(preprocess_checks_df) == len(storm_catalog),
        "serial workflow retained": True,
    },
    name="passed",
).to_frame()
display(completion_checks)
assert completion_checks["passed"].all()
print(
    "AORC annual catalog and batch pre-compute QA complete. "
    "No hydraulic computations were launched; manual review remains required."
)

png

passed
annual catalog is non-empty True
every exact forcing window validated True
all projected event depths agree with catalog True
every storm plan authored True
every gate schedule covers its simulation True
every durable import begins at zero True
every plan preprocesses with nonzero rainfall True
serial workflow retained True
Text Only
AORC annual catalog and batch pre-compute QA complete. No hydraulic computations were launched; manual review remains required.