brainstorming
Structured design dialogue that validates ideas before implementation begins.
hecras_compute_plans
Executes HEC-RAS plans using RasCmdr.compute_plan(), handles parallel execution across multiple plans, manages destination folders, and monitors real-time progress with callbacks. Use when running HEC-RAS simulations, computing plans, executing models, parallel workflows, setting up distributed c...
Full skill instructions
This skill helps you execute HEC-RAS plans using ras-commander. It serves as a navigator to primary sources containing comprehensive documentation and working examples.
Location: C:\GH\ras-commander\ras_commander\CLAUDE.md
See sections:
Key execution modes:
# Single plan
RasCmdr.compute_plan("01", dest_folder="run1", num_cores=4)
# Parallel local
RasCmdr.compute_parallel(["01", "02", "03"], max_workers=3)
# Sequential test
RasCmdr.compute_test_mode(["01", "02"])
Core execution notebooks:
examples/110_single_plan_execution.ipynb - Complete single plan workflowexamples/111_executing_plan_sets.ipynb - Plan sets and batch processingexamples/112_sequential_plan_execution.ipynb - Test mode executionexamples/113_parallel_execution.ipynb - Parallel execution with performance analysisAdvanced workflows:
examples/500_remote_execution_psexec.ipynb - Distributed executionstream_callback usage)Location: C:\GH\ras-commander\ras_commander\RasCmdr.py
Read docstrings for:
RasCmdr.compute_plan() - Lines 139-250+ (comprehensive parameter docs)RasCmdr.compute_parallel() - Parallel execution detailsRasCmdr.compute_test_mode() - Sequential debugging modeCallback protocol: C:\GH\ras-commander\ras_commander\callbacks.py
ExecutionCallback - Protocol definitionConsoleCallback, FileLoggerCallback, ProgressBarCallback - ImplementationsBasic pattern:
from ras_commander import init_ras_project, RasCmdr
# Initialize
init_ras_project(r"C:\Models\MyProject", "6.6")
# Execute
RasCmdr.compute_plan("01")
With destination folder (preserves original):
RasCmdr.compute_plan("01", dest_folder="computation_folder")
With monitoring:
from ras_commander.callbacks import ConsoleCallback
RasCmdr.compute_plan(
"01",
stream_callback=ConsoleCallback(verbose=True)
)
Key parameters:
plan_number - "01", "02", etc. (use strings)dest_folder - None = in-place, path = separate foldernum_cores - CPU cores to use (None = plan default)clear_geompre - True after geometry changesverify - True to check completionskip_existing - True to resume interrupted runsstream_callback - Real-time monitoring objectExecute multiple plans:
# All plans with 3 workers
RasCmdr.compute_parallel(max_workers=3, num_cores=2)
# Specific plans
RasCmdr.compute_parallel(
plans_to_run=["01", "02", "03"],
max_workers=3,
num_cores=2
)
Worker allocation:
max_workers - Parallel plan executionsnum_cores - Cores per planmax_workers × num_coresFor debugging:
# Run plans one at a time in test folder
RasCmdr.compute_test_mode(["01", "02", "03"])
Difference from parallel:
Use this decision matrix to select the appropriate execution mode:
| Scenario | Recommended Mode | Rationale |
|---|---|---|
| Single plan, need full control | compute_plan() | Direct control, callback monitoring, parameter tuning |
| Single plan, quick run | compute_plan() | Simplest API, minimal overhead |
| Multiple plans, debugging issues | compute_test_mode() | Sequential execution, single folder, easier diagnosis |
| Multiple plans, production runs | compute_parallel() | Fastest throughput, worker isolation, parallel HDF writes |
| Distributed across machines | compute_parallel_remote() | Scale-out to multiple computers |
| HEC-RAS 3.x-5.x legacy | RasControl | COM-based automation (see rascontrol documentation) |
| Resume interrupted batch | compute_parallel(..., skip_existing=True) | Skips completed plans |
| Scenario comparison study | compute_parallel() with dest_folder | Each scenario in separate folder |
Quick Decision Tree:
compute_plan(), Multiple → continuecompute_test_mode(), No → continuecompute_parallel_remote(), No → compute_parallel()See: .claude/rules/hec-ras/execution.md for complete mode documentation.
For complex projects, chain execution with inspection and analysis:
1. Project Inspector → Understand project structure
2. Mode Selection → Choose execution approach
3. Execute → Run plans
4. Results Analyst → Interpret outputs
Before executing unfamiliar projects, gather intelligence:
# Step 1: Inspect project (via hecras-project-inspector agent or manual)
# - Get plan count and types
# - Identify dependencies between plans
# - Check geometry complexity (1D vs 2D vs mixed)
# - Review execution recommendations
# Step 2: Based on inspection, select mode
# Example: Inspector finds 5 independent 2D plans
plans = ["01", "02", "03", "04", "05"]
mode = "compute_parallel" # Independent plans → parallel
# Step 3: Execute with appropriate parameters
RasCmdr.compute_parallel(
plans_to_run=plans,
max_workers=3, # Based on system resources
num_cores=4, # 2D models benefit from multiple cores
verify=True
)
# Step 4: Dispatch to results analysis
# - Extract WSE, velocity, depth from HDF files
# - Generate comparison plots
# - Create summary report
Execution typically follows these upstream skills:
hecras_parse_geometry → After geometry modificationsdss_read_boundary-data → After validating boundary conditionsusgs_integrate_gauges → After setting up gauge-based boundariesExecution typically precedes these downstream skills:
hecras_extract_results → Parse HDF outputsFor workflows spanning multiple HEC-RAS projects:
from ras_commander import RasPrj, init_ras_project, RasCmdr
# Create separate project contexts
projects = {}
for project_name in ["upstream", "downstream", "tributary"]:
projects[project_name] = RasPrj()
init_ras_project(
f"C:/Models/{project_name}",
"6.6",
ras_object=projects[project_name]
)
# Execute in dependency order
RasCmdr.compute_plan("01", ras_object=projects["upstream"])
RasCmdr.compute_plan("01", ras_object=projects["tributary"])
RasCmdr.compute_plan("01", ras_object=projects["downstream"])
Critical: Pass ras_object when working with multiple projects. See .claude/rules/python/ras-commander-patterns.md for context object discipline.
# Run in separate folder, leave original untouched
RasCmdr.compute_plan(
"01",
dest_folder="results/run_2024_12_11",
overwrite_dest=True,
verify=True
)
from ras_commander.RasGeo import RasGeo
# Modify geometry
RasGeo.update_mannings_n(geom_file="g01", landcover_map={...})
# Run with forced reprocessing
RasCmdr.compute_plan("01", clear_geompre=True) # CRITICAL
scenarios = {
"baseline": {"plan": "01", "dest": "output/baseline"},
"mitigation": {"plan": "02", "dest": "output/mitigation"},
}
for name, config in scenarios.items():
RasCmdr.compute_plan(
config["plan"],
dest_folder=config["dest"],
verify=True
)
# Resume interrupted batch run
for plan in ["01", "02", "03"]:
RasCmdr.compute_plan(
plan,
skip_existing=True, # Skip if already complete
verify=True
)
from ras_commander.callbacks import ConsoleCallback
callback = ConsoleCallback(verbose=True)
RasCmdr.compute_plan("01", stream_callback=callback)
Output example:
[Plan 01] Starting execution...
[Plan 01] Geometry Preprocessor Version 6.6
[Plan 01] Computing Plan: 01
[Plan 01] SUCCESS in 45.2s
from ras_commander.callbacks import FileLoggerCallback
from pathlib import Path
callback = FileLoggerCallback(output_dir=Path("logs"))
RasCmdr.compute_plan("01", stream_callback=callback)
# Creates: logs/plan_01_execution.log
from ras_commander.callbacks import ProgressBarCallback
# Requires: pip install tqdm
callback = ProgressBarCallback()
RasCmdr.compute_plan("01", stream_callback=callback)
from ras_commander.callbacks import ExecutionCallback
class AlertCallback(ExecutionCallback):
def on_exec_complete(self, plan_number: str, success: bool, duration: float):
send_email(subject=f"Plan {plan_number} {'SUCCESS' if success else 'FAILED'}")
RasCmdr.compute_plan("01", stream_callback=AlertCallback())
Available callback methods (all optional):
on_prep_start() - Before geometry preprocessingon_prep_complete() - After preprocessingon_exec_start() - HEC-RAS subprocess startson_exec_message() - Each .bco file message (real-time)on_exec_complete() - Execution finisheson_verify_result() - After verification (if verify=True)Thread safety: Use SynchronizedCallback wrapper for parallel execution
success = RasCmdr.compute_plan("01", verify=True)
if not success:
print("Execution failed or incomplete")
from ras_commander.hdf import HdfResultsPlan
messages = HdfResultsPlan.get_compute_messages("01")
if "Complete Process" in messages:
print("Success!")
wse = HdfResultsPlan.get_wse("01", time_index=-1)
if wse is not None:
print(f"WSE range: {wse.min():.2f} to {wse.max():.2f} ft")
| Setting | Recommendation | When |
|---|---|---|
clear_geompre=False | 2x-10x faster | Geometry unchanged |
clear_geompre=True | Required | After ANY geometry edit |
num_cores=2-4 | Best balance | Most models |
num_cores=1-2 | Highest efficiency | Resource-limited |
See: .claude/rules/hec-ras/execution.md for detailed performance guidance.
Plan doesn't execute - Check: init_ras_project() called? Plan in ras.plan_df? HEC-RAS installed? Write permissions?
HDF not created - Enable ConsoleCallback(verbose=True), check compute messages, try HEC-RAS GUI manually.
Debug command:
from ras_commander import ras
print(f"Project: {ras.project_folder}")
print(f"RAS: {ras.ras_exe_path}")
print(ras.plan_df)
Remember: This skill is a navigator. For detailed documentation, comprehensive examples, and complete API reference, always consult the Primary Sources section above.
Structured design dialogue that validates ideas before implementation begins.
Comprehensive design intelligence for web and mobile UI/UX across 10 technology stacks.
Comprehensive implementation plans for multi-step tasks, breaking down specs into bite-sized, testable steps.
Introduction to the obra skills system with mandatory skill invocation rules and best practices.
Execute a written implementation plan with critical review and task checkpoints.
Delegate independent tasks to specialized agents working concurrently with isolated context.
Isolated git worktrees with smart directory selection and safety verification.
Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.
Plan searchable and shareable content that drives traffic, builds authority, and generates leads.
README-first repository scanner that extracts commands and classifies reproduction candidates without executing them.
Brainstorm and prioritize marketing strategies tailored to your SaaS stage, budget, and goals.
Plan and optimize your website's page hierarchy, navigation, URL structure, and internal linking.
The world's fastest calendar for remote work
Capture, organize, and utilize your knowledge effortlessly.
Instant Summaries of Audio & Video Interviews with AnySummary
Transform PDFs into engaging mind maps.
Chat with any PDF instantly
Create an optimal daily plan using your voice
A productivity platform to centralize organizational knowledge and workflows with contextual AI assistance.
AskYourPDF Pricing Plans: Tailored to Your Needs