Mb/ward compat

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

@@ -455,11 +455,13 @@ function _add_pwl_term!(
     pwl_cost_expressions = Vector{JuMP.AffExpr}(undef, time_steps[end])
     break_points = PSY.get_x_coords(data)
     sos_val = _get_sos_value(container, V, component)
+    temp_cost_function =
+        create_temporary_cost_function_in_system_per_unit(cost_function, data)
     for t in time_steps
         _add_pwl_variables!(container, T, name, t, data)
         _add_pwl_constraint!(container, component, U(), break_points, sos_val, t)
         pwl_cost =
-            _get_pwl_cost_expression(container, component, t, cost_function, U(), V())
+            _get_pwl_cost_expression(container, component, t, temp_cost_function, U(), V())
         pwl_cost_expressions[t] = pwl_cost
     end
     return pwl_cost_expressions

src/feedforward/feedforward_arguments.jl

@@ -23,6 +23,23 @@ function add_feedforward_arguments!(
     return
 end
 
+function add_feedforward_arguments!(
+    ::OptimizationContainer,
+    model::ServiceModel,
+    ::PSY.TransmissionInterface,
+)
+    # Currently we do not support feedforwards for TransmissionInterface
+    ffs = get_feedforwards(model)
+    if !isempty(ffs)
+        throw(
+            ArgumentError(
+                "TransmissionInterface data types currently do not support feedforwards.",
+            ),
+        )
+    end
+    return
+end
+
 function _add_feedforward_arguments!(
     container::OptimizationContainer,
     model::DeviceModel{T, U},

src/services_models/services_constructor.jl

@@ -548,8 +548,8 @@ function construct_service!(
         PSY.get_name.(interfaces),
         get_time_steps(container),
     )
-    # TODO:broken
-    # add_feedforward_arguments!(container, model, interface)
+
+    add_feedforward_arguments!(container, model, interface)
     return
 end
 
@@ -641,7 +641,8 @@ function construct_service!(
             add_parameters!(container, MaxInterfaceFlowLimitParameter, device, model)
         end
     end
-    #add_feedforward_arguments!(container, model, service)
+    interface = PSY.get_component(T, sys, get_service_name(model))
+    add_feedforward_arguments!(container, model, interface)
     return
 end
 

src/utils/powersystems_utils.jl

@@ -342,6 +342,29 @@ function is_time_variant(cost_function::PSY.FuelCurve{PSY.PiecewisePointCurve})
     return isa(PSY.get_fuel_cost(cost_function), IS.TimeSeriesKey)
 end
 
+function create_temporary_cost_function_in_system_per_unit(
+    original_cost_function::PSY.CostCurve,
+    new_data::PSY.PiecewiseLinearData,
+)
+    return PSY.CostCurve(
+        PSY.PiecewisePointCurve(new_data),
+        PSY.UnitSystem.SYSTEM_BASE,
+        PSY.get_vom_cost(original_cost_function),
+    )
+end
+
+function create_temporary_cost_function_in_system_per_unit(
+    original_cost_function::PSY.FuelCurve,
+    new_data::PSY.PiecewiseLinearData,
+)
+    return PSY.FuelCurve(
+        PSY.PiecewisePointCurve(new_data),
+        PSY.UnitSystem.SYSTEM_BASE,
+        PSY.get_fuel_cost(original_cost_function),
+        PSY.get_vom_cost(original_cost_function),
+    )
+end
+
 function get_deterministic_time_series_type(sys::PSY.System)
     time_series_types = IS.get_time_series_counts_by_type(sys.data)
     existing_types = Set(d["type"] for d in time_series_types)

test/test_device_thermal_generation_constructors.jl

@@ -1144,3 +1144,44 @@ end
     moi_tests(model, 360, 0, 120, 120, 0, false)
     psi_checkobjfun_test(model, GQEVF)
 end
+
+@testset "ThermalDispatchNoMin with PWL Costs" begin
+    sys = build_system(PSISystems, "modified_RTS_GMLC_DA_sys")
+
+    template = ProblemTemplate(NetworkModel(PTDFPowerModel))
+    set_device_model!(template, ThermalStandard, ThermalDispatchNoMin)
+    set_device_model!(template, Line, StaticBranchBounds)
+    set_device_model!(template, TapTransformer, StaticBranchBounds)
+    set_device_model!(template, Transformer2W, StaticBranchBounds)
+    set_device_model!(template, PowerLoad, StaticPowerLoad)
+
+    solver = HiGHS_optimizer
+    problem = DecisionModel(template, sys;
+        optimizer = solver,
+        horizon = Hour(1),
+        optimizer_solve_log_print = true,
+        calculate_conflict = true,
+        store_variable_names = true,
+        detailed_optimizer_stats = false,
+    )
+
+    build!(problem; output_dir = mktempdir())
+
+    solve!(problem)
+
+    res = OptimizationProblemResults(problem)
+
+    # Test that plant 101_STEAM_3 (using max power) have proper cost expression
+    cost = read_expression(res, "ProductionCostExpression__ThermalStandard")
+    p_th = read_variable(res, "ActivePowerVariable__ThermalStandard")
+    steam3 = get_component(ThermalStandard, sys, "101_STEAM_3")
+    val_curve = PSY.get_value_curve(PSY.get_variable(PSY.get_operation_cost(steam3)))
+    io_curve = InputOutputCurve(val_curve)
+    fuel_cost = PSY.get_fuel_cost(steam3)
+    x_last = last(io_curve.function_data.points).x
+    y_last = last(io_curve.function_data.points).y * fuel_cost
+    p_steam3 = p_th[!, "101_STEAM_3"]
+    cost_steam3 = cost[!, "101_STEAM_3"]
+    @test isapprox(p_steam3[1], x_last) # max
+    @test isapprox(cost_steam3[1], y_last) # last cost
+end

test/test_services_constructor.jl

@@ -522,3 +522,67 @@ end
           PSI.ModelBuildStatus.BUILT
     moi_tests(model, 312, 0, 288, 288, 168, false)
 end
+
+@testset "Test Transmission Interface with Feedforwards" begin
+    c_sys5_uc = PSB.build_system(PSITestSystems, "c_sys5_uc"; add_reserves = true)
+    interface = TransmissionInterface(;
+        name = "west_east",
+        available = true,
+        active_power_flow_limits = (min = 0.0, max = 400.0),
+    )
+    interface_lines = [
+        get_component(Line, c_sys5_uc, "1"),
+        get_component(Line, c_sys5_uc, "2"),
+        get_component(Line, c_sys5_uc, "6"),
+    ]
+    add_service!(c_sys5_uc, interface, interface_lines)
+    c_sys5_uc2 = PSB.build_system(PSITestSystems, "c_sys5_uc"; add_reserves = true)
+    interface2 = TransmissionInterface(;
+        name = "west_east",
+        available = true,
+        active_power_flow_limits = (min = 0.0, max = 400.0),
+    )
+    interface_lines2 = [
+        get_component(Line, c_sys5_uc2, "1"),
+        get_component(Line, c_sys5_uc2, "2"),
+        get_component(Line, c_sys5_uc2, "6"),
+    ]
+    add_service!(c_sys5_uc2, interface2, interface_lines2)
+
+    template = get_thermal_dispatch_template_network(DCPPowerModel)
+    set_service_model!(
+        template,
+        ServiceModel(TransmissionInterface, ConstantMaxInterfaceFlow; use_slacks = true),
+    )
+    models = SimulationModels(;
+        decision_models = [
+            DecisionModel(template, c_sys5_uc; optimizer = HiGHS_optimizer, name = "Sys1"),
+            DecisionModel(template, c_sys5_uc2; optimizer = HiGHS_optimizer, name = "Sys2"),
+        ],
+    )
+
+    feedforward = Dict(
+        "Sys2" => [
+            FixValueFeedforward(;
+                component_type = TransmissionInterface,
+                source = PSI.FlowActivePowerVariable,
+                affected_values = [PSI.FlowActivePowerVariable],
+            ),
+        ],
+    )
+
+    sequence = SimulationSequence(;
+        models = models,
+        ini_cond_chronology = InterProblemChronology(),
+        feedforwards = feedforward,
+    )
+
+    sim = Simulation(;
+        name = "interface-fail",
+        steps = 2,
+        models = models,
+        sequence = sequence,
+        simulation_folder = mktempdir(; cleanup = true),
+    )
+    @test_throws ArgumentError build!(sim)
+end