Unit Commitment Data Modeling

Unit Commitment Structured Data Parsing

Use this skill when a unit commitment task provides structured data and you need to map fields into UC concepts. The source may be JSON, CSV, spreadsheets, database tables, or nested dictionaries. The prompt and schema are the source of truth; do not assume one benchmark or package.

Parsing Workflow

1. Load data with structured parsers: JSON as objects, CSV/sheets as tables, databases as query results.
2. Inspect schema: top-level keys, tables/sheets, resource groups, time-series fields, cost curves, startup tiers, and initial-condition fields.
3. Identify the time axis: number of periods, labels, duration, and report convention.
4. Identify resource sets: thermal, renewable, storage, imports, zones, reserve products, or network objects.
5. Normalize fields into arrays/tables with explicit shapes.
6. Preserve original names and source ordering for final reports.
7. Run parser-level checks before modeling.

Map Concepts, Not Names

Different sources use different names. Map by meaning, units, shape, and context.

| UC concept | Look for | | --- | --- | | Horizon | periods, hours, timestamps, interval count | | Demand | load, system demand, net load, zone load | | Reserve requirement | spinning, operating, contingency, regulation reserve | | Resource sets | thermal, renewable, storage, import/export | | Commitment status | on/off, online, active, unit status | | Output limits | minimum stable output, maximum output, availability | | Ramping | ramp up/down, startup capability, shutdown capability | | Minimum up/down | required duration after start/stop | | Initial conditions | initial status, initial output, time already on/off | | Must-run | forced online, fixed status | | Startup data | fixed costs or tiers by prior offline duration | | Production cost | linear coefficients, heat rate, piecewise or total-cost curves | | Renewable availability | hourly min/max output or forecast bounds |

Common Data Shapes

• Scalar by resource: min up/down, ramp rates, startup ramp, must-run.
• Time series by system/zone: demand and reserve requirement.
• Time series by resource: renewable availability or outage status.
• Curve/tier tables: startup costs and production-cost breakpoints.
• Nested resource objects: generator-specific limits, status, and costs.

Normalize into a small representation:

case = {
    "periods": periods,                  # length T
    "thermal_names": thermal_names,      # length G, source order
    "renewable_names": renewable_names,  # length R, source order
    "demand": demand,                    # shape (T,)
    "reserve_requirement": reserve,       # shape (T,)
    "thermal": thermal_params,
    "renewable_min": renewable_min,       # shape (R, T)
    "renewable_max": renewable_max,       # shape (R, T)
}

Time, Ordering, And Units

• Use the input horizon as authoritative.
• Preserve source period order.
• Keep zero-based internal indexes separate from one-based/timestamped report labels.
• Verify every time-series length equals T.
• Preserve resource order unless the prompt requires sorting.
• Treat resource IDs as opaque strings.
• Keep thermal and renewable sets separate when constraints differ.
• Check power units, period duration, ramp-rate units, and cost units before converting anything.

Basic checks:

assert len(demand) == T
assert len(reserve_requirement) == T
for r in renewable_resources:
    assert len(r["min"]) == T
    assert len(r["max"]) == T

Production Convention

Many UC models use output above minimum internally, while reports often require actual MW.

actual_output = pmin * commitment + output_above_min
output_above_min = actual_output - pmin * commitment

Pick one internal convention and convert carefully for reporting, ramping, reserve deliverability, and cost.

Startup Tiers

Startup tiers are usually keyed by prior offline duration. Parse thresholds and costs without assuming order.

def choose_startup_tier(tiers, prior_offline_duration):
    tiers = sorted(tiers, key=lambda x: x["lag"])
    chosen = tiers[0]
    for tier in tiers:
        if tier["lag"] = pts[-1][0]:
        return pts[-1][1]
    for (x0, y0), (x1, y1) in zip(pts, pts[1:]):
        if x0 = 2 for curve in production_curves.values())
assert all(len(tiers) >= 1 for tiers in startup_tiers.values())

Also check missing required fields, duplicate IDs, mismatched lengths, negative impossible limits, repeated cost points, nonmonotone startup lags, and inconsistent initial status/output.

Common Mistakes

• Hard-coding a familiar schema instead of inspecting the data.
• Losing ordering when converting dictionaries or tables into arrays.
• Joining tables on the wrong key or duplicating resources.
• Confusing total output with output above minimum.
• Confusing reserve, capacity, availability, and dispatch.
• Treating every cost curve as marginal cost.
• Ignoring startup tier lags or initial offline duration.
• Assuming renewable maximum output must always be used.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: xuansenpa1
• Source: xuansenpa1/skillrevise
• License: MIT
• Homepage: https://arxiv.org/abs/2606.01139

Install and usage instructions live in the source repository linked above.