Struct ResolvedBounds 

pub struct ResolvedBounds { /* private fields */ }

Pre-resolved bound table for all entities across all stages.

Most tables index data[entity_idx * n_stages + stage_idx]; the thermal table uses an extended n_stages + k_max stride — see thermal_stage_axis_len.

Examples

use cobre_core::resolved::{
    BoundsCountsSpec, BoundsDefaults, ContractBlockBounds, HydroBlockBounds, HydroStageBounds,
    LineBlockBounds, PumpingBlockBounds, ResolvedBounds, ThermalBlockBounds,
    ThermalStageBounds,
};

let hydro_default = HydroStageBounds {
    min_storage_hm3: 0.0, max_storage_hm3: 100.0,
    filling_min_rate_m3s: 0.0, water_withdrawal_m3s: 0.0,
};
let hydro_block_default = HydroBlockBounds {
    min_turbined_m3s: 0.0, max_turbined_m3s: 50.0,
    min_outflow_m3s: 0.0, max_outflow_m3s: None,
    min_generation_mw: 0.0, max_generation_mw: 30.0,
    min_diversion_m3s: None, max_diversion_m3s: None,
    min_spillage_m3s: None, max_spillage_m3s: None,
};
let thermal_default = ThermalStageBounds { cost_per_mwh: 50.0 };
let thermal_block_default = ThermalBlockBounds { min_generation_mw: 0.0, max_generation_mw: 100.0 };
let line_default = LineBlockBounds { direct_mw: 500.0, reverse_mw: 500.0 };
let pumping_default = PumpingBlockBounds { min_flow_m3s: 0.0, max_flow_m3s: 20.0 };
let contract_default = ContractBlockBounds { min_mw: 0.0, max_mw: 50.0, price_per_mwh: 80.0 };

let table = ResolvedBounds::new(
    &BoundsCountsSpec { n_hydros: 2, n_thermals: 1, n_lines: 1, n_pumping: 1, n_contracts: 1, n_stages: 3, k_max: 0 },
    &BoundsDefaults {
        hydro: hydro_default, hydro_block: hydro_block_default,
        thermal: thermal_default, thermal_block: thermal_block_default,
        line_block: line_default, pumping_block: pumping_default, contract_block: contract_default,
    },
);

let b = table.hydro_bounds(0, 2);
assert!((b.max_storage_hm3 - 100.0).abs() < f64::EPSILON);

Implementations

impl ResolvedBounds

pub fn empty() -> Self

Return an empty bounds table with zero entities and zero stages.

The default value in System before bound resolution.

Examples

use cobre_core::ResolvedBounds;

let empty = ResolvedBounds::empty();
assert_eq!(empty.n_stages(), 0);

pub fn new(counts: &BoundsCountsSpec, defaults: &BoundsDefaults) -> Self

Allocate a new resolved-bounds table filled with the given defaults.

counts.n_stages must be > 0. Entity counts may be 0.

pub fn hydro_bounds( &self, hydro_index: usize, stage_index: usize, ) -> &HydroStageBounds

Return the resolved stage-level bounds for a hydro plant at a specific stage.

Returns a reference rather than a copy to avoid copying the struct on hot paths.

HydroStageBounds carries the four stage-boundary-stock columns only; the block-eligible columns live on HydroBlockBounds, read through hydro_bounds_at_block or hydro_block_base:

use cobre_core::ResolvedBounds;

let bounds = ResolvedBounds::empty();
let _ = bounds.hydro_bounds(0, 0).max_turbined_m3s;

The sibling below differs only in the accessor — it reads the same turbined capacity through hydro_bounds_at_block and compiles:

use cobre_core::resolved::{
    BoundsCountsSpec, BoundsDefaults, ContractBlockBounds, HydroBlockBounds, HydroStageBounds,
    LineBlockBounds, PumpingBlockBounds, ResolvedBounds, ThermalBlockBounds,
    ThermalStageBounds,
};

let bounds = ResolvedBounds::new(
    &BoundsCountsSpec {
        n_hydros: 1, n_thermals: 0, n_lines: 0, n_pumping: 0, n_contracts: 0,
        n_stages: 1, k_max: 0,
    },
    &BoundsDefaults {
        hydro: HydroStageBounds {
            min_storage_hm3: 0.0, max_storage_hm3: 0.0,
            filling_min_rate_m3s: 0.0, water_withdrawal_m3s: 0.0,
        },
        hydro_block: HydroBlockBounds {
            min_turbined_m3s: 0.0, max_turbined_m3s: 500.0,
            min_outflow_m3s: 0.0, max_outflow_m3s: None,
            min_generation_mw: 0.0, max_generation_mw: 0.0,
            min_diversion_m3s: None, max_diversion_m3s: None,
            min_spillage_m3s: None, max_spillage_m3s: None,
        },
        thermal: ThermalStageBounds { cost_per_mwh: 0.0 },
        thermal_block: ThermalBlockBounds { min_generation_mw: 0.0, max_generation_mw: 0.0 },
        line_block: LineBlockBounds { direct_mw: 0.0, reverse_mw: 0.0 },
        pumping_block: PumpingBlockBounds { min_flow_m3s: 0.0, max_flow_m3s: 0.0 },
        contract_block: ContractBlockBounds { min_mw: 0.0, max_mw: 0.0, price_per_mwh: 0.0 },
    },
);

let block = bounds.hydro_bounds_at_block(0, 0, 0);
assert!((block.max_turbined_m3s - 500.0).abs() < f64::EPSILON);

pub fn thermal_bounds( &self, thermal_index: usize, stage_index: usize, ) -> ThermalStageBounds

Return the resolved cost bounds for a thermal unit at a specific stage.

stage_index is valid in [0, thermal_stage_axis_len()); indices >= n_stages() access the padded delivery-stage region.

ThermalStageBounds carries cost_per_mwh only; the block-eligible generation capacity lives on ThermalBlockBounds, read through thermal_bounds_at_block or thermal_block_base:

use cobre_core::ResolvedBounds;

let bounds = ResolvedBounds::empty();
let _ = bounds.thermal_bounds(0, 0).max_generation_mw;

The sibling below differs only in the accessor — it reads the same capacity pair through thermal_bounds_at_block and compiles:

use cobre_core::resolved::{
    BoundsCountsSpec, BoundsDefaults, ContractBlockBounds, HydroBlockBounds, HydroStageBounds,
    LineBlockBounds, PumpingBlockBounds, ResolvedBounds, ThermalBlockBounds,
    ThermalStageBounds,
};

let hydro_default = HydroStageBounds {
    min_storage_hm3: 0.0, max_storage_hm3: 0.0,
    filling_min_rate_m3s: 0.0, water_withdrawal_m3s: 0.0,
};
let hydro_block_default = HydroBlockBounds {
    min_turbined_m3s: 0.0, max_turbined_m3s: 0.0,
    min_outflow_m3s: 0.0, max_outflow_m3s: None,
    min_generation_mw: 0.0, max_generation_mw: 0.0,
    min_diversion_m3s: None, max_diversion_m3s: None,
    min_spillage_m3s: None, max_spillage_m3s: None,
};

let bounds = ResolvedBounds::new(
    &BoundsCountsSpec {
        n_hydros: 0, n_thermals: 1, n_lines: 0, n_pumping: 0, n_contracts: 0,
        n_stages: 1, k_max: 0,
    },
    &BoundsDefaults {
        hydro: hydro_default,
        hydro_block: hydro_block_default,
        thermal: ThermalStageBounds { cost_per_mwh: 50.0 },
        thermal_block: ThermalBlockBounds { min_generation_mw: 0.0, max_generation_mw: 400.0 },
        line_block: LineBlockBounds { direct_mw: 0.0, reverse_mw: 0.0 },
        pumping_block: PumpingBlockBounds { min_flow_m3s: 0.0, max_flow_m3s: 0.0 },
        contract_block: ContractBlockBounds { min_mw: 0.0, max_mw: 0.0, price_per_mwh: 0.0 },
    },
);

let block = bounds.thermal_bounds_at_block(0, 0, 0);
assert!((block.max_generation_mw - 400.0).abs() < f64::EPSILON);

pub fn hydro_bounds_mut( &mut self, hydro_index: usize, stage_index: usize, ) -> &mut HydroStageBounds

Return a mutable reference to the hydro stage-level bounds cell for in-place update.

pub fn hydro_block_base_mut( &mut self, hydro_index: usize, stage_index: usize, ) -> &mut HydroBlockBounds

Return a mutable reference to the hydro block-base cell for in-place update; see hydro_block_base for the overlay-ignoring read this writes through to.

pub fn thermal_bounds_mut( &mut self, thermal_index: usize, stage_index: usize, ) -> &mut ThermalStageBounds

Return a mutable reference to the thermal cost cell for in-place update.

stage_index is valid in [0, thermal_stage_axis_len()); indices >= n_stages() write into the padded delivery-stage region.

pub fn thermal_block_base_mut( &mut self, thermal_index: usize, stage_index: usize, ) -> &mut ThermalBlockBounds

Return a mutable reference to the thermal block-base cell for in-place update; see thermal_block_base for the overlay-ignoring read this writes through to.

stage_index is valid in [0, thermal_stage_axis_len()); indices >= n_stages() write into the padded delivery-stage region.

pub fn line_bounds_mut( &mut self, line_index: usize, stage_index: usize, ) -> &mut LineBlockBounds

Return a mutable reference to the line bounds cell for in-place update.

pub fn pumping_bounds_mut( &mut self, pumping_index: usize, stage_index: usize, ) -> &mut PumpingBlockBounds

Return a mutable reference to the pumping bounds cell for in-place update.

pub fn contract_bounds_mut( &mut self, contract_index: usize, stage_index: usize, ) -> &mut ContractBlockBounds

Return a mutable reference to the contract bounds cell for in-place update.

pub fn set_block_overlay(&mut self, block: ResolvedBlockBounds)

Install the per-block override overlay (bound-precedence layer 1).

The overlay stays ResolvedBlockBounds::empty — every *_bounds_at_block call falls through to the stage cell — until this is called.

pub fn block_overlay(&self) -> &ResolvedBlockBounds

Return the installed per-block override overlay.

pub fn block_overlay_mut(&mut self) -> &mut ResolvedBlockBounds

Return a mutable handle to the per-block override overlay.

pub fn set_group_overlay(&mut self, group: ResolvedHydroUnitGroupBounds)

Install the hydro unit group override overlay (bound-precedence layers 1 and 2 on the group axis).

The overlay stays ResolvedHydroUnitGroupBounds::empty until this is called; no reader here consults it — the group axis has no consumer on ResolvedBounds itself.

pub fn group_overlay(&self) -> &ResolvedHydroUnitGroupBounds

Return the installed hydro unit group override overlay.

pub fn group_overlay_mut(&mut self) -> &mut ResolvedHydroUnitGroupBounds

Return a mutable handle to the hydro unit group override overlay.

pub fn hydro_bounds_at_block( &self, hydro_index: usize, stage_index: usize, block_index: usize, ) -> HydroBlockBounds

Return the resolved hydro block-eligible bounds for (hydro_index, stage_index, block_index), applying the block overlay over the block-base cell from hydro_block_base: each block-eligible column takes the overlay’s value when Some, otherwise falls through to the block-base cell. With an empty overlay this returns a value bit-identical to hydro_block_base for every block_index — never special-case the empty-overlay path.

pub fn thermal_bounds_at_block( &self, thermal_index: usize, stage_index: usize, block_index: usize, ) -> ThermalBlockBounds

Return the resolved thermal generation bounds for a specific block; see hydro_bounds_at_block for the overlay contract. Thermal cost has no overlay column and no per-block reader — read it stage-level via thermal_bounds.

pub fn line_bounds_at_block( &self, line_index: usize, stage_index: usize, block_index: usize, ) -> LineBlockBounds

Return the resolved line bounds for a specific block; see hydro_bounds_at_block for the overlay contract.

Lines have no stage-level bound column — there is no line_bounds accessor to call. Read capacity through this accessor or line_block_base:

use cobre_core::ResolvedBounds;

let bounds = ResolvedBounds::empty();
let _ = bounds.line_bounds(0, 0).direct_mw;

The sibling below differs only in the accessor — it reads the same line capacity through this method and compiles:

use cobre_core::resolved::{
    BoundsCountsSpec, BoundsDefaults, ContractBlockBounds, HydroBlockBounds, HydroStageBounds,
    LineBlockBounds, PumpingBlockBounds, ResolvedBounds, ThermalBlockBounds,
    ThermalStageBounds,
};

let hydro_default = HydroStageBounds {
    min_storage_hm3: 0.0, max_storage_hm3: 0.0,
    filling_min_rate_m3s: 0.0, water_withdrawal_m3s: 0.0,
};
let hydro_block_default = HydroBlockBounds {
    min_turbined_m3s: 0.0, max_turbined_m3s: 0.0,
    min_outflow_m3s: 0.0, max_outflow_m3s: None,
    min_generation_mw: 0.0, max_generation_mw: 0.0,
    min_diversion_m3s: None, max_diversion_m3s: None,
    min_spillage_m3s: None, max_spillage_m3s: None,
};

let bounds = ResolvedBounds::new(
    &BoundsCountsSpec {
        n_hydros: 0, n_thermals: 0, n_lines: 1, n_pumping: 0, n_contracts: 0,
        n_stages: 1, k_max: 0,
    },
    &BoundsDefaults {
        hydro: hydro_default,
        hydro_block: hydro_block_default,
        thermal: ThermalStageBounds { cost_per_mwh: 0.0 },
        thermal_block: ThermalBlockBounds { min_generation_mw: 0.0, max_generation_mw: 0.0 },
        line_block: LineBlockBounds { direct_mw: 1000.0, reverse_mw: 800.0 },
        pumping_block: PumpingBlockBounds { min_flow_m3s: 0.0, max_flow_m3s: 0.0 },
        contract_block: ContractBlockBounds { min_mw: 0.0, max_mw: 0.0, price_per_mwh: 0.0 },
    },
);

let block = bounds.line_bounds_at_block(0, 0, 0);
assert!((block.direct_mw - 1000.0).abs() < f64::EPSILON);

pub fn pumping_bounds_at_block( &self, pumping_index: usize, stage_index: usize, block_index: usize, ) -> PumpingBlockBounds

Return the resolved pumping bounds for a specific block; see hydro_bounds_at_block for the overlay contract.

Pumping stations have no stage-level bound column — there is no pumping_bounds accessor to call. Read flow limits through this accessor or pumping_block_base:

use cobre_core::ResolvedBounds;

let bounds = ResolvedBounds::empty();
let _ = bounds.pumping_bounds(0, 0).max_flow_m3s;

The sibling below differs only in the accessor — it reads the same pumping flow limit through this method and compiles:

use cobre_core::resolved::{
    BoundsCountsSpec, BoundsDefaults, ContractBlockBounds, HydroBlockBounds, HydroStageBounds,
    LineBlockBounds, PumpingBlockBounds, ResolvedBounds, ThermalBlockBounds,
    ThermalStageBounds,
};

let hydro_default = HydroStageBounds {
    min_storage_hm3: 0.0, max_storage_hm3: 0.0,
    filling_min_rate_m3s: 0.0, water_withdrawal_m3s: 0.0,
};
let hydro_block_default = HydroBlockBounds {
    min_turbined_m3s: 0.0, max_turbined_m3s: 0.0,
    min_outflow_m3s: 0.0, max_outflow_m3s: None,
    min_generation_mw: 0.0, max_generation_mw: 0.0,
    min_diversion_m3s: None, max_diversion_m3s: None,
    min_spillage_m3s: None, max_spillage_m3s: None,
};

let bounds = ResolvedBounds::new(
    &BoundsCountsSpec {
        n_hydros: 0, n_thermals: 0, n_lines: 0, n_pumping: 1, n_contracts: 0,
        n_stages: 1, k_max: 0,
    },
    &BoundsDefaults {
        hydro: hydro_default,
        hydro_block: hydro_block_default,
        thermal: ThermalStageBounds { cost_per_mwh: 0.0 },
        thermal_block: ThermalBlockBounds { min_generation_mw: 0.0, max_generation_mw: 0.0 },
        line_block: LineBlockBounds { direct_mw: 0.0, reverse_mw: 0.0 },
        pumping_block: PumpingBlockBounds { min_flow_m3s: 0.0, max_flow_m3s: 50.0 },
        contract_block: ContractBlockBounds { min_mw: 0.0, max_mw: 0.0, price_per_mwh: 0.0 },
    },
);

let block = bounds.pumping_bounds_at_block(0, 0, 0);
assert!((block.max_flow_m3s - 50.0).abs() < f64::EPSILON);

pub fn contract_bounds_at_block( &self, contract_index: usize, stage_index: usize, block_index: usize, ) -> ContractBlockBounds

Return the resolved contract bounds for a specific block; see hydro_bounds_at_block for the overlay contract. price_per_mwh IS block-eligible, deliberately asymmetric with thermal_bounds_at_block’s cost_per_mwh.

Contracts have no stage-level bound column — there is no contract_bounds accessor to call. Read all three columns through this accessor or contract_block_base:

use cobre_core::ResolvedBounds;

let bounds = ResolvedBounds::empty();
let _ = bounds.contract_bounds(0, 0).price_per_mwh;

The sibling below differs only in the accessor — it reads the same contract price through this method and compiles:

use cobre_core::resolved::{
    BoundsCountsSpec, BoundsDefaults, ContractBlockBounds, HydroBlockBounds, HydroStageBounds,
    LineBlockBounds, PumpingBlockBounds, ResolvedBounds, ThermalBlockBounds,
    ThermalStageBounds,
};

let hydro_default = HydroStageBounds {
    min_storage_hm3: 0.0, max_storage_hm3: 0.0,
    filling_min_rate_m3s: 0.0, water_withdrawal_m3s: 0.0,
};
let hydro_block_default = HydroBlockBounds {
    min_turbined_m3s: 0.0, max_turbined_m3s: 0.0,
    min_outflow_m3s: 0.0, max_outflow_m3s: None,
    min_generation_mw: 0.0, max_generation_mw: 0.0,
    min_diversion_m3s: None, max_diversion_m3s: None,
    min_spillage_m3s: None, max_spillage_m3s: None,
};

let bounds = ResolvedBounds::new(
    &BoundsCountsSpec {
        n_hydros: 0, n_thermals: 0, n_lines: 0, n_pumping: 0, n_contracts: 1,
        n_stages: 1, k_max: 0,
    },
    &BoundsDefaults {
        hydro: hydro_default,
        hydro_block: hydro_block_default,
        thermal: ThermalStageBounds { cost_per_mwh: 0.0 },
        thermal_block: ThermalBlockBounds { min_generation_mw: 0.0, max_generation_mw: 0.0 },
        line_block: LineBlockBounds { direct_mw: 0.0, reverse_mw: 0.0 },
        pumping_block: PumpingBlockBounds { min_flow_m3s: 0.0, max_flow_m3s: 0.0 },
        contract_block: ContractBlockBounds { min_mw: 0.0, max_mw: 0.0, price_per_mwh: 80.0 },
    },
);

let block = bounds.contract_bounds_at_block(0, 0, 0);
assert!((block.price_per_mwh - 80.0).abs() < f64::EPSILON);

pub fn hydro_block_base( &self, hydro_index: usize, stage_index: usize, ) -> HydroBlockBounds

Return the block-eligible hydro columns at (hydro_index, stage_index), ignoring the per-block overlay. This is not the value that applies at a block — see hydro_bounds_at_block for the block-resolved reader. Only the dictionary path (write_bounds_parquet) calls this one — see the module docs for the two-caller *_block_base contract.

pub fn thermal_block_base( &self, thermal_index: usize, stage_index: usize, ) -> ThermalBlockBounds

Return the block-eligible thermal columns at (thermal_index, stage_index), ignoring the per-block overlay. This is not the value that applies at a block — see thermal_bounds_at_block for the block-resolved reader. *_block_base accessors exist for exactly two sanctioned caller categories: the dictionary report path (write_bounds_parquet’s null-block_id base row) and the anticipated-commitment decision column (fill_anticipated_columns, reading the delivery stage’s bounds); this accessor serves both. Any other caller is a design question, not an implementation detail. stage_index may land in the padded delivery-stage region.

pub fn line_block_base( &self, line_index: usize, stage_index: usize, ) -> LineBlockBounds

Return the block-eligible line columns at (line_index, stage_index), ignoring the per-block overlay. This is not the value that applies at a block — see line_bounds_at_block for the block-resolved reader. Only the dictionary path (write_bounds_parquet) calls this one — see the module docs for the two-caller *_block_base contract.

pub fn pumping_block_base( &self, pumping_index: usize, stage_index: usize, ) -> PumpingBlockBounds

Return the block-eligible pumping columns at (pumping_index, stage_index), ignoring the per-block overlay. This is not the value that applies at a block — see pumping_bounds_at_block for the block-resolved reader. Only the dictionary path (write_bounds_parquet) calls this one — see the module docs for the two-caller *_block_base contract.

pub fn contract_block_base( &self, contract_index: usize, stage_index: usize, ) -> ContractBlockBounds

Return the block-eligible contract columns at (contract_index, stage_index), ignoring the per-block overlay. This is not the value that applies at a block — see contract_bounds_at_block for the block-resolved reader. Only the dictionary path (write_bounds_parquet) calls this one — see the module docs for the two-caller *_block_base contract.

pub fn n_stages(&self) -> usize

Return the number of stages in this table.

pub fn n_pumping(&self) -> usize

Return the number of pumping stations.

Derived from the pumping Vec length and n_stages rather than a stored count, since n_pumping is never serialized. The n_stages == 0 guard avoids divide-by-zero on ResolvedBounds::empty.

pub fn n_contracts(&self) -> usize

Return the number of energy contracts.

Derived from the contract Vec length and n_stages rather than a stored count, since n_contracts is never serialized. The n_stages == 0 guard avoids divide-by-zero on ResolvedBounds::empty.

pub fn thermal_stage_axis_len(&self) -> usize

Return the stride used to index the thermal Vec; equals n_stages() + k_max.

k_max is the maximum lead-stages across anticipated thermals. The thermal table reserves indices [n_stages(), thermal_stage_axis_len()) for delivery-stage lookups by anticipated-decision columns.

Trait Implementations

impl Clone for ResolvedBounds

fn clone(&self) -> ResolvedBounds

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ResolvedBounds

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ResolvedBounds

fn eq(&self, other: &ResolvedBounds) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ResolvedBounds