Expand get_decision_problem_results with kwargs

src/simulation/simulation_problem_results.jl

@@ -65,6 +65,7 @@
 get_resolution(res::SimulationProblemResults) = res.resolution
 get_execution_path(res::SimulationProblemResults) = res.execution_path
 get_model_base_power(res::SimulationProblemResults) = res.base_power
+get_system_uuid(results::PSI.SimulationProblemResults) = results.system_uuid
 IS.get_timestamp(result::SimulationProblemResults) = result.results_timestamps
 get_interval(res::SimulationProblemResults) = res.timestamps.step
 IS.get_base_power(result::SimulationProblemResults) = result.base_power

src/simulation/simulation_results.jl

@@ -193,12 +193,43 @@ Base.length(res::SimulationResults) =
     mapreduce(length, +, values(res.decision_problem_results))
 get_exports_folder(x::SimulationResults) = joinpath(x.path, "exports")
 
-function get_decision_problem_results(results::SimulationResults, problem)
+"""
+# Arguments
+ - `sim_results::PSI.SimulationResults`: the simulation results to read from
+ - `problem::String`: the name of the problem (e.g., "UC", "ED")
+ - `populate_system::Bool = true`: whether to set the results' system using
+ [`read_serialized_system`](@ref)
+ - `populate_units::Union{IS.UnitSystem, String, Nothing} = IS.UnitSystem.NATURAL_UNITS`:
+   the units system with which to populate the results' system, if any (requires
+   `populate_system=true`)
+"""
+
+function get_decision_problem_results(
+    results::SimulationResults,
+    problem::String;
+    populate_system::Bool = false,
+    populate_units::Union{IS.UnitSystem, String, Nothing} = IS.UnitSystem.NATURAL_UNITS,
+)
     if !haskey(results.decision_problem_results, problem)
         throw(IS.InvalidValue("$problem is not stored"))
     end
 
-    return results.decision_problem_results[problem]
+    results = results.decision_problem_results[problem]
+
+    if populate_system
+        get_system!(results)
+        (populate_units !== nothing) &&
+            PSY.set_units_base_system!(PSI.get_system(results), populate_units)
+    else
+        (populate_units !== nothing) && (populate_units !== IS.UnitSystem.NATURAL_UNITS) &&
+            throw(
+                ArgumentError(
+                    "populate_units=$populate_units is unaccepted when populate_system=$populate_system",
+                ),
+            )
+    end
+
+    return results
 end
 
 function get_emulation_problem_results(results::SimulationResults)

test/test_simulation_results.jl

@@ -220,7 +220,6 @@ function test_simulation_results(file_path::String, export_path; in_memory = fal
         @test isempty(results)
 
         verify_export_results(results, export_path)
-
         @test length(readdir(export_realized_results(results_ed))) === 17
 
         # Test that you can't read a failed simulation.
@@ -690,10 +689,26 @@ function test_simulation_results_from_file(path::AbstractString, c_sys5_hy_ed, c
     @test get_system(results_uc) === nothing
     @test length(read_realized_variables(results_uc)) == length(UC_EXPECTED_VARS)
 
+    results_ed = get_decision_problem_results(results, "ED")
+    @test isnothing(get_system(results_ed))
+
+    results_ed = get_decision_problem_results(results, "ED"; populate_system = true)
+    @test !isnothing(get_system(results_ed))
+    @test PSY.get_units_base(get_system(results_ed)) == "NATURAL_UNITS"
+
     @test_throws IS.InvalidValue set_system!(results_uc, c_sys5_hy_ed)
     set_system!(results_ed, c_sys5_hy_ed)
     set_system!(results_uc, c_sys5_hy_uc)
 
+    results_ed = get_decision_problem_results(
+        results,
+        "ED";
+        populate_system = true,
+        populate_units = IS.UnitSystem.DEVICE_BASE,
+    )
+    @test !isnothing(PSI.get_system(results_ed))
+    @test PSY.get_units_base(get_system(results_ed)) == "DEVICE_BASE"
+
     test_decision_problem_results_values(results_ed, results_uc, c_sys5_hy_ed, c_sys5_hy_uc)
 end