Add fuel cost time series parameters methods

src/core/device_model.jl

@@ -49,7 +49,7 @@ mutable struct DeviceModel{D <: PSY.Device, B <: AbstractDeviceFormulation}
     use_slacks::Bool
     duals::Vector{DataType}
     services::Vector{ServiceModel}
-    time_series_names::Dict{Type{<:TimeSeriesParameter}, String}
+    time_series_names::Dict{Type{<:PSI.ParameterType}, String}
     attributes::Dict{String, Any}
     subsystem::Union{Nothing, String}
 

src/core/expressions.jl

@@ -8,6 +8,7 @@ struct EmergencyUp <: ExpressionType end
 struct EmergencyDown <: ExpressionType end
 struct RawACE <: ExpressionType end
 struct ProductionCostExpression <: CostExpressions end
+struct FuelConsumptionExpression <: ExpressionType end
 struct ActivePowerRangeExpressionLB <: RangeConstraintLBExpressions end
 struct ActivePowerRangeExpressionUB <: RangeConstraintUBExpressions end
 struct ComponentReserveUpBalanceExpression <: ExpressionType end

src/core/parameters.jl

@@ -303,6 +303,11 @@ Parameter to define cost function coefficient
 """
 struct CostFunctionParameter <: ObjectiveFunctionParameter end
 
+"""
+Parameter to define fuel cost time series
+"""
+struct FuelCostParameter <: ObjectiveFunctionParameter end
+
 abstract type AuxVariableValueParameter <: RightHandSideParameter end
 
 struct EventParameter <: ParameterType end

src/devices_models/device_constructors/thermalgeneration_constructor.jl

@@ -789,6 +789,10 @@ function construct_device!(
 
     add_variables!(container, ActivePowerVariable, devices, D())
 
+    if haskey(get_time_series_names(model), FuelCostParameter)
+        add_parameters!(container, FuelCostParameter, devices, model)
+    end
+
     add_to_expression!(
         container,
         ActivePowerBalance,
@@ -800,6 +804,8 @@ function construct_device!(
 
     add_expressions!(container, ProductionCostExpression, devices, model)
 
+    add_expressions!(container, FuelConsumptionExpression, devices, model)
+
     add_to_expression!(
         container,
         ActivePowerRangeExpressionLB,
@@ -816,6 +822,13 @@ function construct_device!(
         model,
         network_model,
     )
+    add_to_expression!(
+        container,
+        FuelConsumptionExpression,
+        ActivePowerVariable,
+        devices,
+        model,
+    )
 
     add_feedforward_arguments!(container, model, devices)
     return

src/devices_models/devices/common/add_to_expression.jl

@@ -26,6 +26,25 @@ function add_expressions!(
     return
 end
 
+function add_expressions!(
+    container::OptimizationContainer,
+    ::Type{T},
+    devices::U,
+    model::DeviceModel{D, W},
+) where {
+    T <: FuelConsumptionExpression,
+    U <: Union{Vector{D}, IS.FlattenIteratorWrapper{D}},
+    W <: AbstractDeviceFormulation,
+} where {D <: PSY.Component}
+    time_steps = get_time_steps(container)
+    names = [
+        PSY.get_name(d) for
+        d in devices if PSY.get_variable(PSY.get_operation_cost(d)) isa PSY.FuelCurve
+    ]
+    add_expression_container!(container, T(), D, names, time_steps)
+    return
+end
+
 function add_expressions!(
     container::OptimizationContainer,
     ::Type{T},
@@ -1533,6 +1552,52 @@ function add_to_expression!(
     return
 end
 
+function add_to_expression!(
+    container::OptimizationContainer,
+    ::Type{T},
+    ::Type{U},
+    devices::IS.FlattenIteratorWrapper{V},
+    model::DeviceModel{V, W},
+) where {
+    T <: FuelConsumptionExpression,
+    U <: ActivePowerVariable,
+    V <: PSY.ThermalGen,
+    W <: AbstractThermalDispatchFormulation,
+}
+    expression = get_expression(container, T(), V)
+    variable = get_variable(container, U(), V)
+    time_steps = get_time_steps(container)
+    base_power = get_base_power(container)
+    for d in devices
+        var_cost = PSY.get_variable(PSY.get_operation_cost(d))
+        if !(var_cost isa PSY.FuelCurve)
+            continue
+        end
+        name = PSY.get_name(d)
+        device_base_power = PSY.get_base_power(d)
+        value_curve = PSY.get_value_curve(var_cost)
+        if value_curve isa PSY.LinearCurve
+            power_units = PSY.get_power_units(var_cost)
+            proportional_term = PSY.get_proportional_term(value_curve)
+            prop_term_per_unit = get_proportional_cost_per_system_unit(
+                proportional_term,
+                power_units,
+                base_power,
+                device_base_power,
+            )
+            for t in time_steps
+                fuel_expr = variable[name, t] * prop_term_per_unit
+                JuMP.add_to_expression!(
+                    expression[name, t],
+                    fuel_expr,
+                )
+            end
+        else
+            error("Not implemented yet")
+        end
+    end
+end
+
 #=
 function add_to_expression!(
     container::OptimizationContainer,

src/devices_models/devices/common/objective_function/linear_curve.jl

@@ -115,12 +115,26 @@ end
 function _add_fuel_linear_variable_cost!(
     container::OptimizationContainer,
     ::T,
-    component::PSY.Component,
-    fuel_curve::Float64,
+    component::V,
+    heat_rate::Float64, # already normalized in MMBTU/p.u.
     fuel_cost::IS.TimeSeriesKey,
-) where {T <: VariableType}
-    error("Not implemented yet")
-    _add_linearcurve_variable_cost!(container, T(), component, fuel_curve)
+) where {T <: VariableType, V <: PSY.Component}
+    parameter = get_parameter_array(container, FuelCostParameter(), V)
+    multiplier = get_parameter_multiplier_array(container, FuelCostParameter(), V)
+    expression = get_expression(container, FuelConsumptionExpression(), V)
+    name = PSY.get_name(component)
+    for t in get_time_steps(container)
+        cost_expr = expression[name, t] * parameter[name, t] * multiplier[name, t]
+        add_to_expression!(
+            container,
+            ProductionCostExpression,
+            cost_expr,
+            component,
+            t,
+        )
+        add_to_objective_variant_expression!(container, cost_expr)
+    end
+    return
 end
 
 """

src/devices_models/devices/thermal_generation.jl

@@ -51,6 +51,7 @@ get_variable_binary(::Union{ColdStartVariable, WarmStartVariable, HotStartVariab
 
 ########################### Parameter related set functions ################################
 get_multiplier_value(::ActivePowerTimeSeriesParameter, d::PSY.ThermalGen, ::AbstractThermalFormulation) = PSY.get_max_active_power(d)
+get_multiplier_value(::FuelCostParameter, d::PSY.ThermalGen, ::AbstractThermalFormulation) = 1.0
 get_parameter_multiplier(::VariableValueParameter, d::PSY.ThermalGen, ::AbstractThermalFormulation) = 1.0
 get_initial_parameter_value(::VariableValueParameter, d::PSY.ThermalGen, ::AbstractThermalFormulation) = 1.0
 get_expression_multiplier(::OnStatusParameter, ::ActivePowerRangeExpressionUB, d::PSY.ThermalGen, ::AbstractThermalFormulation) = PSY.get_active_power_limits(d).max
@@ -194,7 +195,9 @@ function get_default_time_series_names(
     ::Type{U},
     ::Type{V},
 ) where {U <: PSY.ThermalGen, V <: Union{FixedOutput, AbstractThermalFormulation}}
-    return Dict{Type{<:TimeSeriesParameter}, String}()
+    return Dict{Any, String}(
+        FuelCostParameter => "fuel_cost",
+    )
 end
 
 function get_default_attributes(

src/parameters/add_parameters.jl

@@ -34,6 +34,23 @@ function add_parameters!(
     return
 end
 
+function add_parameters!(
+    container::OptimizationContainer,
+    ::Type{T},
+    devices::U,
+    model::DeviceModel{D, W},
+) where {
+    T <: FuelCostParameter,
+    U <: Union{Vector{D}, IS.FlattenIteratorWrapper{D}},
+    W <: AbstractDeviceFormulation,
+} where {D <: PSY.Component}
+    if get_rebuild_model(get_settings(container)) && has_container_key(container, T, D)
+        return
+    end
+    _add_parameters!(container, T(), devices, model)
+    return
+end
+
 function add_parameters!(
     container::OptimizationContainer,
     ::Type{T},
@@ -256,7 +273,51 @@ function _add_parameters!(
     U <: Union{Vector{D}, IS.FlattenIteratorWrapper{D}},
     W <: AbstractDeviceFormulation,
 } where {D <: PSY.Component}
-    _add_time_series_parameters!(container, param, devices, model)
+    ts_type = get_default_time_series_type(container)
+    if !(ts_type <: Union{PSY.AbstractDeterministic, PSY.StaticTimeSeries})
+        error("add_parameters! for TimeSeriesParameter is not compatible with $ts_type")
+    end
+    time_steps = get_time_steps(container)
+    # TODO: Check for timeseries only for fuel cost
+    device_names = [PSY.get_name(x) for x in devices if PSY.has_time_series(x)]
+    jump_model = get_jump_model(container)
+
+    param_container = add_param_container!(
+        container,
+        param,
+        D,
+        ActivePowerVariable,
+        PSI.SOSStatusVariable.NO_VARIABLE,
+        false,
+        Float64,
+        device_names,
+        time_steps,
+    )
+
+    ts_name = get_time_series_names(model)[T]
+
+    for device in devices
+        if !PSY.has_time_series(device)
+            continue
+        end
+        ts_vals = get_time_series_initial_values!(container, ts_type, device, ts_name)
+        name = PSY.get_name(device)
+        for step in time_steps
+            PSI.set_parameter!(
+                param_container,
+                jump_model,
+                ts_vals[step],
+                name,
+                step,
+            )
+            PSI.set_multiplier!(
+                param_container,
+                get_multiplier_value(T(), device, W()),
+                name,
+                step,
+            )
+        end
+    end
     return
 end