Internal API

Storage energy balance: $e^{\text{st}}_t = e^{\text{st}}_{t-1} + \Delta t(\eta_{\text{ch}} p^{\text{ch}}_t - p^{\text{ds}}_t/\eta_{\text{ds}})$.

Charge power upper bound when not discharging: $p^{\text{ch}}_t \leq (1 - ss^{\text{st}}_t) P_{\max,\text{ch}}$.

Discharge power upper bound when discharging: $p^{\text{ds}}_t \leq ss^{\text{st}}_t P_{\max,\text{ds}}$.

Regularization on charge power changes (when "regularization" => true): penalizes $|\Delta p^{\text{ch}}_t|$-style changes. See formulation docstrings for full constraint.

Upper bound on charging power allocated to ancillary services.

ComplementarySlacknessRenewableActivePowerLimitConstraintLb

Complementary slackness (lower bound) for renewable active power limit.

Cumulative charging energy over horizon ≤ $C_{\text{st}} E_{\max,\text{st}}$.

Cumulative discharging energy over horizon ≤ $C_{\text{st}} E_{\max,\text{st}}$.

Regularization on discharge power changes (when "regularization" => true): penalizes $|\Delta p^{\text{ds}}_t|$-style changes. See formulation docstrings for full constraint.

Upper bound on discharging power allocated to ancillary services.

Net internal power (thermal + renewable + discharge − charge − load) equals net PCC power (out − in).

Links day-ahead energy bids to internal asset power (upper level).

Links component reserve variables to total reserve at the PCC.

Renewable power upper bound: $p^{\text{re}}_t \leq P^{*,\text{re}}_t$.

Upper bound on renewable power allocated to ancillary services.

Total reserve at PCC equals sum of component reserve allocations.

Ensures storage has sufficient energy to meet ancillary service commitments.

End-of-period energy coverage for ancillary services.

End-of-horizon storage energy target (when "energy_target" => true): $e^{\text{st}}_T = E^{\text{st}}_T$.

Binary status for hybrid input (consumption) direction at the PCC.

Binary status for hybrid output (generation) direction at the PCC.

Thermal power lower bound: $p^{\text{th}}_t \geq u^{\text{th}}_t P_{\min,\text{th}}$.

Thermal power upper bound: $p^{\text{th}}_t \leq u^{\text{th}}_t P_{\max,\text{th}}$.

Upper bound on thermal power allocated to ancillary services.

Storage Energy Balance Equation Upper Bound Dual

Storage Energy Balance Equation Lower Bound Dual

Storage Charging Cycling Limit Dual

Storage Discharging Cycling Limit Dual

Internal Merchant Model Devices EnergyAssetBalance Equation Lower Bound Dual

Internal Merchant Model Devices EnergyAssetBalance Equation Upper Bound Dual

Storage Charge Variable Lower Bound Dual

Storage Charge Variable Upper Bound Dual

Storage Discharge Variable Lower Bound Dual

Storage Discharge Variable Upper Bound Dual

RenewableGeneration Lower Bound Dual

RenewableGeneration Upper Bound Dual

ThermalGeneration Lower Bound Dual

ThermalGeneration Upper Bound Dual

Storage Energy Variable Lower Bound Dual

Storage Energy Variable Upper Bound Dual

_hybrid_profile_parameter_slice(
    container::PowerSimulations.OptimizationContainer,
    device::PowerSystems.HybridSystem,
    ts_name::String,
    start_time::Dates.DateTime;
    feat_kw
) -> Any

Read injection profile points (RenewableDispatch__max_active_power, PowerLoad__max_active_power) from the wrapped SingleTimeSeries stored on the hybrid, slicing length(time_steps) contiguous values from start_time. This avoids DeterministicSingleTimeSeries forecast windows that may only span a short sub-interval of the underlying data.

_map_rt_to_da_index(
    rt_t::Int64,
    rt_count::Int64,
    da_count::Int64
) -> Int64

Map RT step rt_t to a DA index when RT and DA horizon lengths need not divide evenly.

_merchant_hybrid_price_parameter_key(
    container::PowerSimulations.OptimizationContainer,
    parameter_array,
    _::Type{P<:Union{DayAheadEnergyPrice, RealTimeEnergyPrice}}
) -> Union{Nothing, InfrastructureSystems.Optimization.ParameterKey}

During Simulation execution, PSI calls _update_parameter_values!(..., ::ObjectiveFunctionParameter, ...) from update_cost_parameters.jl, which uses handle_variable_cost_parameter with PSY.get_operation_cost(component). Merchant hybrids use MarketBidCost(nothing); energy prices are read from hybrid-attached scalar "HybridSystem__energy_price" time series (keyed DA/RT) instead. This hooks the generic simulation update path into the same hybrid scalar forecast logic as update_parameter_values!(..., ::InMemoryDataset).

first_matching_hybrid_scalar_metadata(
    hybrid::PowerSystems.HybridSystem,
    ts_name::AbstractString
) -> Any

Match metadata whether the series is still SingleTimeSeries or already transformed.

hybrid_ancillary_service_price_time_series_name(
    service_name::AbstractString
) -> Any
hybrid_ancillary_service_price_time_series_name(
    service_name::AbstractString,
    key::AbstractString
) -> Any

Scalar ancillary price time series name; include the key in the name so DA/RT copies stay distinct after transform_single_time_series! (metadata features are not preserved on the Deterministic record in InfrastructureSystems).

hybrid_energy_price_time_series_name(
    key::AbstractString
) -> Any

Scalar energy price time series name for a given user key (e.g. DAY_AHEAD_TIME_SERIES_KEY).

merchant_da_time_step_range(
    container::PowerSimulations.OptimizationContainer,
    hybrid::PowerSystems.HybridSystem
) -> UnitRange{Int64}

Day-ahead energy price indices 1:n_DA aligned with hourly DA slots and attached DA metadata.

merchant_rt_to_da_tmap(
    rt_len::Int64,
    da_len::Int64
) -> Vector{Int64}

Integer-safe DA index for each RT step when DA and RT horizons need not divide evenly.

update_decision_state!(
    state::PowerSimulations.SimulationState,
    key::InfrastructureSystems.Optimization.ParameterKey{T<:Union{DayAheadEnergyPrice, RealTimeEnergyPrice}, PowerSystems.HybridSystem},
    store_data::JuMP.Containers.DenseAxisArray{Float64, 2, Ax, L} where {Ax, L<:Tuple{JuMP.Containers._AxisLookup, JuMP.Containers._AxisLookup}},
    simulation_time::Dates.DateTime,
    model_params::PowerSimulations.ModelStoreParams
)

Clamp decision-state writes for merchant hybrid price parameters when store horizon extends beyond the state buffer length during rolling simulation updates.