From b6e86ae64041da642e558750e90e84f8ab378270 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Tue, 18 Oct 2022 12:24:46 -0400 Subject: [PATCH 01/12] updating bounds on the flow for better convergence with idaes2.0 --- .../ultra_supercritical_powerplant.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/ultra_supercritical_powerplant.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/ultra_supercritical_powerplant.py index 256f25b2b..27ebb390a 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/ultra_supercritical_powerplant.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/ultra_supercritical_powerplant.py @@ -34,6 +34,7 @@ __author__ = "Naresh Susarla & E S Rawlings" import os +import logging # Import Pyomo libraries from pyomo.environ import (ConcreteModel, RangeSet, TransformationFactory, @@ -1110,12 +1111,17 @@ def initialize(m, fileinput=None, outlvl=idaeslog.NOTSET, def add_bounds(m): - m.flow_max = m.main_flow * 1.2 # number from Naresh - m.salt_flow_max = 1000 # in kg/s - - for unit_k in [m.fs.boiler, m.fs.reheater[1], - m.fs.reheater[2], m.fs.cond_pump, - m.fs.bfp, m.fs.bfpt]: + m.flow_max = m.main_flow * 3 # number from Naresh + # m.salt_flow_max = 1000 # in kg/s + + for unit_k in [ + m.fs.boiler, + m.fs.reheater[1], + m.fs.reheater[2], + m.fs.cond_pump, + m.fs.bfp, + m.fs.bfpt + ]: unit_k.inlet.flow_mol[:].setlb(0) # mol/s unit_k.inlet.flow_mol[:].setub(m.flow_max) # mol/s unit_k.outlet.flow_mol[:].setlb(0) # mol/s From db25795a6c2711fa056992c053321ce9c76acfd4 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Tue, 18 Oct 2022 12:25:47 -0400 Subject: [PATCH 02/12] removed unnecessary imports, updated bounds on flow, changed constraint on turbine outlet temperature --- ..._design_ultra_supercritical_power_plant.py | 39 +++++++------------ 1 file changed, 14 insertions(+), 25 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ultra_supercritical_power_plant.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ultra_supercritical_power_plant.py index 88415d3c4..5a1a8e0d3 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ultra_supercritical_power_plant.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ultra_supercritical_power_plant.py @@ -34,7 +34,6 @@ Expression, value, log, exp, Var) from pyomo.environ import units as pyunits from pyomo.network import Arc -from pyomo.common.fileutils import this_file_dir from pyomo.util.calc_var_value import calculate_variable_from_constraint from pyomo.gdp import Disjunct, Disjunction from pyomo.network.plugins import expand_arcs @@ -44,21 +43,13 @@ # Import IDAES libraries import idaes.logger as idaeslog import idaes.core.util.scaling as iscale -from idaes.core import MaterialBalanceType from idaes.core.util.initialization import propagate_state from idaes.core.solvers.get_solver import get_solver from idaes.core.util.model_statistics import degrees_of_freedom from idaes.core import UnitModelCostingBlock -from idaes.models.unit_models import (HeatExchanger, - MomentumMixingType, - Heater, - Mixer, - PressureChanger) -from idaes.models.unit_models.heat_exchanger import (delta_temperature_underwood_callback, - HeatExchangerFlowPattern) -from idaes.models.unit_models.pressure_changer import ThermodynamicAssumption -from idaes.models_extra.power_generation.unit_models.helm import (HelmMixer, - HelmTurbineStage, +from idaes.models.unit_models import HeatExchanger +from idaes.models.unit_models.heat_exchanger import delta_temperature_underwood_callback +from idaes.models_extra.power_generation.unit_models.helm import (HelmTurbineStage, HelmSplitter) from idaes.models.costing.SSLW import ( SSLWCosting, @@ -74,7 +65,7 @@ from dispatches.properties import solarsalt_properties -scaling_obj = 1e-7 +scaling_obj = 1 def create_discharge_model(m, add_efficiency=None, power_max=None): """Create flowsheet and add unit models. @@ -272,7 +263,7 @@ def _make_constraints(m, add_efficiency=None, power_max=None): def constraint_esturbine_temperature_out(b, t): return ( b.control_volume.properties_out[t].temperature == - b.control_volume.properties_out[t].temperature_sat + b.control_volume.properties_out[t].temperature_sat + 1 ) m.fs.net_power = pyo.Expression( @@ -463,11 +454,13 @@ def disconnect_arcs(m): """ - for arc_s in [m.fs.condpump_to_fwh1, - m.fs.fwh4_to_fwh5, - m.fs.booster_to_fwh6, - m.fs.bfp_to_fwh8, - m.fs.fwh9_to_boiler]: + for arc_s in [ + m.fs.condpump_to_fwh1, + m.fs.fwh4_to_fwh5, + m.fs.booster_to_fwh6, + m.fs.bfp_to_fwh8, + m.fs.fwh9_to_boiler + ]: arc_s.expanded_block.enth_mol_equality.deactivate() arc_s.expanded_block.flow_mol_equality.deactivate() arc_s.expanded_block.pressure_equality.deactivate() @@ -764,8 +757,6 @@ def set_model_input(m): ########################################################################### # Fix data in storage turbine ########################################################################### - m.fs.discharge.es_turbine.constraint_esturbine_temperature_out.deactivate() - m.fs.discharge.es_turbine.outlet.pressure.fix(6896) m.fs.discharge.es_turbine.efficiency_isentropic.fix(0.8) @@ -805,8 +796,6 @@ def initialize(m, solver=None, optarg=None, outlvl=idaeslog.NOTSET): propagate_state(m.fs.discharge.hxd_to_esturbine) m.fs.discharge.es_turbine.initialize(outlvl=outlvl, optarg=optarg) - m.fs.discharge.es_turbine.constraint_esturbine_temperature_out.activate() - m.fs.discharge.es_turbine.outlet.pressure.unfix() # Check and raise an error if the degrees of freedom are not 0 if not degrees_of_freedom(m) == 0: @@ -1042,7 +1031,7 @@ def add_bounds(m, power_max=None): """ - m.flow_max = m.main_flow * 1.2 # Units in mol/s + m.flow_max = m.main_flow * 3 # Units in mol/s m.storage_flow_max = 0.2 * m.flow_max # Units in mol/s m.salt_flow_max = 1000 # Units in kg/s m.heat_duty_bound = 200e6 # Units in MW @@ -1198,7 +1187,7 @@ def run_gdp(m): nlp_solver='ipopt', call_after_subproblem_solve=print_model, nlp_solver_args=dict( - tee=False, + tee=True, options={ "max_iter": 150} ) From 6ff4f6423304c3e2a811ff16e20360bc7abb0c41 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Fri, 21 Oct 2022 14:38:40 -0400 Subject: [PATCH 03/12] updated design notebook for convergence and tests --- ...sign_ultra_supercritical_power_plant.ipynb | 140 ++++++++---------- 1 file changed, 60 insertions(+), 80 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/design_ultra_supercritical_power_plant.ipynb b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/design_ultra_supercritical_power_plant.ipynb index 4270c4c65..62282f0ef 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/design_ultra_supercritical_power_plant.ipynb +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/design_ultra_supercritical_power_plant.ipynb @@ -1124,24 +1124,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-10-06 10:47:28 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.charge.solar_salt_disjunct.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", - "2022-10-06 10:47:28 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", - "2022-10-06 10:47:28 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.charge.solar_salt_disjunct.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", - "2022-10-06 10:47:28 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", - "2022-10-06 10:47:28 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", - "2022-10-06 10:47:28 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", - "2022-10-06 10:47:29 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: fs.charge.hitec_salt_disjunct.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", - "2022-10-06 10:47:29 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: Initialization Step 1 Complete.\n", - "2022-10-06 10:47:29 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: fs.charge.hitec_salt_disjunct.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", - "2022-10-06 10:47:29 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: Initialization Step 1 Complete.\n", - "2022-10-06 10:47:29 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: State Released.\n", - "2022-10-06 10:47:29 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: State Released.\n", - "2022-10-06 10:47:29 [INFO] idaes.init.dispatches.properties.thermaloil_properties: fs.charge.thermal_oil_disjunct.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", - "2022-10-06 10:47:29 [INFO] idaes.init.dispatches.properties.thermaloil_properties: Initialization Step 1 Complete.\n", - "2022-10-06 10:47:30 [INFO] idaes.init.dispatches.properties.thermaloil_properties: fs.charge.thermal_oil_disjunct.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", - "2022-10-06 10:47:30 [INFO] idaes.init.dispatches.properties.thermaloil_properties: Initialization Step 1 Complete.\n", - "2022-10-06 10:47:30 [INFO] idaes.init.dispatches.properties.thermaloil_properties: State Released.\n", - "2022-10-06 10:47:30 [INFO] idaes.init.dispatches.properties.thermaloil_properties: State Released.\n" + "2022-10-18 12:57:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.charge.solar_salt_disjunct.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-10-18 12:57:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-18 12:57:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.charge.solar_salt_disjunct.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-10-18 12:57:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-18 12:57:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-18 12:57:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-18 12:57:14 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: fs.charge.hitec_salt_disjunct.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-10-18 12:57:14 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-18 12:57:14 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: fs.charge.hitec_salt_disjunct.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-10-18 12:57:14 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-18 12:57:14 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: State Released.\n", + "2022-10-18 12:57:15 [INFO] idaes.init.dispatches.properties.hitecsalt_properties: State Released.\n", + "2022-10-18 12:57:15 [INFO] idaes.init.dispatches.properties.thermaloil_properties: fs.charge.thermal_oil_disjunct.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-10-18 12:57:15 [INFO] idaes.init.dispatches.properties.thermaloil_properties: Initialization Step 1 Complete.\n", + "2022-10-18 12:57:15 [INFO] idaes.init.dispatches.properties.thermaloil_properties: fs.charge.thermal_oil_disjunct.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-10-18 12:57:15 [INFO] idaes.init.dispatches.properties.thermaloil_properties: Initialization Step 1 Complete.\n", + "2022-10-18 12:57:15 [INFO] idaes.init.dispatches.properties.thermaloil_properties: State Released.\n", + "2022-10-18 12:57:15 [INFO] idaes.init.dispatches.properties.thermaloil_properties: State Released.\n" ] } ], @@ -1452,7 +1452,7 @@ "call_after_discrete_problem_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", "call_before_master_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", "call_after_master_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", - "subproblem_initialization_method: \n", + "subproblem_initialization_method: \n", "call_before_subproblem_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", "call_after_subproblem_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", "call_after_subproblem_feasible: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", @@ -1474,27 +1474,28 @@ " Optimization and Engineering, 2021.\n", "Original model has 687 constraints (196 nonlinear) and 2 disjunctions, with 680 variables, of which 5 are binary, 0 are integer, and 675 are continuous.\n", "---Starting GDPopt initialization---\n", - "Finished discrete problem initialization in 2.77s and 0 iterations \n", + "Finished discrete problem initialization in 3.13s and 0 iterations \n", "\n", "=============================================================================================\n", "Iteration | Subproblem Type | Lower Bound | Upper Bound | Gap | Time(s)\n", "\n", - " 1 discrete 7.34967 inf nan% 6.55 \n", - " 1 subproblem 7.34967 9.12066 19.42% 11.00 *\n", - " 2 discrete 7.34967 9.12066 19.42% 11.67 \n", - " 3 discrete 7.34967 9.12066 19.42% 30.40 \n", - " 3 subproblem 7.34967 9.12066 19.42% 51.34 \n", - " 4 discrete 7.34968 9.12066 19.42% 51.99 \n", - " 4 subproblem 7.34968 9.12066 19.42% 64.96 \n", - " 5 discrete 7.34968 9.12066 19.42% 65.69 \n", - " 5 subproblem 7.34968 9.09956 19.23% 74.61 *\n", - " 6 discrete 7.34968 9.09956 19.23% 75.25 \n", - " 6 subproblem 7.34968 9.09956 19.23% 86.80 \n", + " 1 discrete 7.34967 inf nan% 7.04 \n", + " 1 subproblem 7.34967 9.12066 19.42% 12.12 *\n", + " 2 discrete 7.34967 9.12066 19.42% 12.64 \n", + " 2 subproblem 7.34967 9.12066 19.42% 18.57 \n", + " 3 discrete 7.34967 9.12066 19.42% 19.26 \n", + " 3 subproblem 7.34967 9.12066 19.42% 49.24 \n", + " 4 discrete 7.34968 9.12066 19.42% 49.76 \n", + " 4 subproblem 7.34968 9.12066 19.42% 64.67 \n", + " 5 discrete 7.34968 9.12066 19.42% 65.18 \n", + " 5 subproblem 7.34968 9.09956 19.23% 77.49 *\n", + " 6 discrete 7.34968 9.09956 19.23% 78.03 \n", + " 6 subproblem 7.34968 9.09956 19.23% 94.22 \n", "MILP discrete problem is now infeasible. GDPopt has explored or cut off all feasible discrete configurations.\n", - " 7 9.09956 9.09956 0.00% 87.39 \n", + " 7 9.09956 9.09956 0.00% 94.70 \n", "GDPopt exiting--bounds have converged or crossed.\n", "\n", - "Solved in 7 iterations and 87.39356 seconds\n", + "Solved in 7 iterations and 94.70616 seconds\n", "Optimal objective value 9.0995628395\n", "Relative optimality gap 0.00000%\n" ] @@ -1900,7 +1901,7 @@ "id": "16659c7b", "metadata": {}, "source": [ - "Include four constraints to ensure that the units in the storage system and power plant operate at the desired conditions. Include the first constraint to fix the storage turbine pressure to be at the saturation conditions to ensure a saturated steam in the turbine." + "Include four constraints to ensure that the units in the storage system and power plant operate at the desired conditions. Include the following constraint to fix the storage turbine pressure to be above the saturation conditions to ensure a uncondensed steam at the turbine outlet." ] }, { @@ -1913,7 +1914,7 @@ "m.fs.discharge.es_turbine.constraint_esturbine_temperature_out = Constraint(\n", " expr=(\n", " m.fs.discharge.es_turbine.control_volume.properties_out[0].temperature ==\n", - " m.fs.discharge.es_turbine.control_volume.properties_out[0].temperature_sat\n", + " m.fs.discharge.es_turbine.control_volume.properties_out[0].temperature_sat + 1\n", " ),\n", " doc=\"Turbine outlet should be a saturated steam\"\n", ")" @@ -1924,7 +1925,7 @@ "id": "d543ac9c", "metadata": {}, "source": [ - "Include three constraints to calculate the fuel heat duty and the boiler and cycle efficiencies." + "Include the following three constraints to calculate the fuel heat duty and the boiler and cycle efficiencies." ] }, { @@ -2013,8 +2014,6 @@ "\n", "m.fs.discharge.es_split.split_fraction[0, \"to_hxd\"].fix(0.2)\n", "\n", - "m.fs.discharge.es_turbine.constraint_esturbine_temperature_out.deactivate()\n", - "m.fs.discharge.es_turbine.outlet.pressure.fix(6896)\n", "m.fs.discharge.es_turbine.efficiency_isentropic.fix(0.8)" ] }, @@ -2036,12 +2035,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-10-06 10:49:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.discharge.hxd.hot_side.properties_in Initialisation Step 1 Complete.\n", - "2022-10-06 10:49:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", - "2022-10-06 10:49:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.discharge.hxd.hot_side.properties_out Initialisation Step 1 Complete.\n", - "2022-10-06 10:49:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", - "2022-10-06 10:49:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", - "2022-10-06 10:49:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-18 12:59:04 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.discharge.hxd.hot_side.properties_in Initialisation Step 1 Complete.\n", + "2022-10-18 12:59:04 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-18 12:59:04 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.discharge.hxd.hot_side.properties_out Initialisation Step 1 Complete.\n", + "2022-10-18 12:59:04 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-18 12:59:04 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-18 12:59:05 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", " Discharge initialization solver termination: optimal\n" ] } @@ -2056,8 +2055,6 @@ "\n", "propagate_state(m.fs.discharge.hxd_to_esturbine)\n", "m.fs.discharge.es_turbine.initialize(outlvl=outlvl)\n", - "m.fs.discharge.es_turbine.constraint_esturbine_temperature_out.activate()\n", - "m.fs.discharge.es_turbine.outlet.pressure.unfix()\n", "\n", "assert degrees_of_freedom(m) == 0\n", "\n", @@ -2181,7 +2178,7 @@ " expr=(\n", " m.fs.discharge.capital_cost +\n", " m.fs.discharge.operating_cost\n", - " ) * 1e-7\n", + " ) * 1\n", ")" ] }, @@ -2216,11 +2213,7 @@ "cell_type": "code", "execution_count": 62, "id": "aefbf5f0", - "metadata": { - "tags": [ - "nbval-skip" - ] - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -2242,7 +2235,7 @@ "call_after_discrete_problem_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", "call_before_master_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", "call_after_master_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", - "subproblem_initialization_method: \n", + "subproblem_initialization_method: \n", "call_before_subproblem_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", "call_after_subproblem_solve: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", "call_after_subproblem_feasible: !!python/name:pyomo.contrib.gdpopt.util._DoNothing ''\n", @@ -2280,21 +2273,22 @@ " Optimization and Engineering, 2021.\n", "Original model has 567 constraints (153 nonlinear) and 1 disjunctions, with 562 variables, of which 2 are binary, 0 are integer, and 560 are continuous.\n", "---Starting GDPopt initialization---\n", - "Finished discrete problem initialization in 2.64s and 0 iterations \n", + "Finished discrete problem initialization in 2.28s and 0 iterations \n", "\n", "=============================================================================================\n", "Iteration | Subproblem Type | Lower Bound | Upper Bound | Gap | Time(s)\n", "\n", - " 1 discrete 0.00000 inf nan% 5.86 \n", - "fs.coal_heat_duty_eq: body -0.0039469888506573625 < LB 0.0\n", - " 2 discrete 0.00000 inf nan% 105.97 \n", - "fs.production_cons[0.0]: body -4.5299530029296875e-06 < LB 0.0\n", + " 1 discrete 0.00000 inf nan% 6.05 \n", + " 1 subproblem 0.00000 14939735.36835 100.00% 23.20 *\n", + " 2 discrete 1290.87160 14939735.36835 99.99% 26.07 \n", + " 2 subproblem 1290.87160 14641534.89607 99.99% 34.90 *\n", "MILP discrete problem is now infeasible. GDPopt has explored or cut off all feasible discrete configurations.\n", - "GDPopt exiting--problem is infeasible.\n", + " 3 14641534.89607 14641534.89607 0.00% 35.90 \n", + "GDPopt exiting--bounds have converged or crossed.\n", "\n", - "Solved in 3 iterations and 751.96099 seconds\n", - "Optimal objective value inf\n", - "Relative optimality gap nan%\n" + "Solved in 3 iterations and 35.90226 seconds\n", + "Optimal objective value 14641534.8960735332\n", + "Relative optimality gap 0.00000%\n" ] } ], @@ -2324,28 +2318,14 @@ "cell_type": "code", "execution_count": 63, "id": "874b1a30", - "metadata": { - "tags": [ - "nbval-skip" - ] - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "**Discrete design decisions (Disjunction)\n" - ] - }, - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for -: 'NoneType' and 'int'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_1143/3442258283.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mactive\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m sort=True, descend_into=True):\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbinary_indicator_var\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1e-6\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m' should be selected!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'NoneType' and 'int'" + "**Discrete design decisions (Disjunction)\n", + "fs.discharge.condpump_source_disjunct should be selected!\n" ] } ], @@ -2376,7 +2356,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.9.12" }, "vscode": { "interpreter": { From 24ec90afa9f69cf6573304d8062064d4a620f985 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Fri, 28 Oct 2022 12:28:27 -0400 Subject: [PATCH 04/12] adding option to retun a pyomo block with usc model --- .../ultra_supercritical_powerplant.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/ultra_supercritical_powerplant.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/ultra_supercritical_powerplant.py index 27ebb390a..e722c5364 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/ultra_supercritical_powerplant.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/ultra_supercritical_powerplant.py @@ -69,13 +69,15 @@ from idaes.models.properties import iapws95 -def declare_unit_model(): +def declare_unit_model(m=None): """Create flowsheet and add unit models. """ ########################################################################### # Flowsheet and Property Package # ########################################################################### - m = ConcreteModel(name="Ultra Supercritical Power Plant Model") + if m is None: + m = ConcreteModel(name="Ultra Supercritical Power Plant Model") + m.fs = FlowsheetBlock(dynamic=False) m.fs.prop_water = iapws95.Iapws95ParameterBlock() @@ -1290,10 +1292,10 @@ def view_result(outfile, m): svg_tag(svg=f, tag_group=tag_group, outfile=outfile) -def build_plant_model(): +def build_plant_model(m=None): # Create a flowsheet, add properties, unit models, and arcs - m = declare_unit_model() + m = declare_unit_model(m) # Give all the required inputs to the model # Ensure that the degrees of freedom = 0 (model is complete) From 6e0f5d239794a0299d7959f5b5f592986caa9155 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Fri, 28 Oct 2022 12:29:27 -0400 Subject: [PATCH 05/12] updated the multiperiod model with the new multiperiod class --- .../multiperiod_integrated_storage_usc.py | 294 +++++++++++++----- 1 file changed, 218 insertions(+), 76 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_integrated_storage_usc.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_integrated_storage_usc.py index 10b0b2c48..36d856cb6 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_integrated_storage_usc.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_integrated_storage_usc.py @@ -25,22 +25,23 @@ __author__ = "Naresh Susarla and Soraya Rawlings" -from pathlib import Path try: from importlib import resources # Python 3.8+ except ImportError: import importlib_resources as resources # Python 3.7 +from idaes.core.util import from_json, to_json +import idaes.logger as idaeslog - -from pyomo.environ import (NonNegativeReals, ConcreteModel, Constraint, Var) +from pyomo.environ import (NonNegativeReals, Constraint, Var) from idaes.apps.grid_integration.multiperiod.multiperiod import ( MultiPeriodModel) +from dispatches.case_studies.fossil_case.ultra_supercritical_plant import ( + ultra_supercritical_powerplant as usc) from dispatches.case_studies.fossil_case.ultra_supercritical_plant.storage import ( - integrated_storage_with_ultrasupercritical_power_plant as usc) -from dispatches.case_studies.fossil_case.ultra_supercritical_plant import storage + integrated_storage_with_ultrasupercritical_power_plant as usc_w_tes) -def create_usc_model(pmin, pmax): +def create_usc_model(m, pmin, pmax): # Set bounds for plant power min_storage_heat_duty = 10 # in MW @@ -48,70 +49,206 @@ def create_usc_model(pmin, pmax): max_power = 436 # in MW min_power = int(0.65 * max_power) # 283 in MW + if pmin is None: + pmin = int(0.65 * 436) + 1 + if pmax is None: + pmax = 436 + 30 + + m = usc.build_plant_model(m) - m = ConcreteModel() + # Create a flowsheet, add properties, unit models, and arcs + m = usc_w_tes.create_integrated_model(m, max_power=max_power) - with resources.path(storage, "initialized_integrated_storage_usc.json") as data_file_path: - assert data_file_path.is_file() - m.usc_mp = usc.main(max_power=max_power, - load_from_file=str(data_file_path)) + # Give all the required inputs to the model + usc_w_tes.set_model_input(m) - m.usc_mp.fs.plant_min_power_eq = Constraint( - expr=m.usc_mp.fs.plant_power_out[0] >= min_power + # Add scaling factor + usc_w_tes.set_scaling_factors(m) + + # Initialize the model with a sequential initialization and custom + # Add cost correlations + m = usc_w_tes.build_costing(m) + + # Add bounds + usc_w_tes.add_bounds(m) + + + m.fs.plant_min_power_eq = Constraint( + expr=m.fs.plant_power_out[0] >= min_power ) - m.usc_mp.fs.plant_max_power_eq = Constraint( - expr=m.usc_mp.fs.plant_power_out[0] <= max_power + m.fs.plant_max_power_eq = Constraint( + expr=m.fs.plant_power_out[0] <= max_power ) - m.usc_mp.fs.hxc.heat_duty.setlb(min_storage_heat_duty * 1e6) - m.usc_mp.fs.hxd.heat_duty.setlb(min_storage_heat_duty * 1e6) + m.fs.hxc.heat_duty.setlb(min_storage_heat_duty * 1e6) + m.fs.hxd.heat_duty.setlb(min_storage_heat_duty * 1e6) + + m.fs.hxc.heat_duty.setub(max_storage_heat_duty * 1e6) + m.fs.hxd.heat_duty.setub(max_storage_heat_duty * 1e6) + + # Add coupling variables + m.fs.previous_power = Var( + domain=NonNegativeReals, + initialize=300, + bounds=(pmin, pmax), + doc="Previous period power (MW)" + ) - m.usc_mp.fs.hxc.heat_duty.setub(max_storage_heat_duty * 1e6) - m.usc_mp.fs.hxd.heat_duty.setub(max_storage_heat_duty * 1e6) + inventory_max = 1e7 + inventory_min = 75000 + tank_max = 6739292 # Units in kg + m.fs.previous_salt_inventory_hot = Var( + domain=NonNegativeReals, + initialize=inventory_min, + bounds=(0, inventory_max), + doc="Hot salt at the beginning of the hour (or time period), kg" + ) + m.fs.salt_inventory_hot = Var( + domain=NonNegativeReals, + initialize=inventory_min, + bounds=(0, inventory_max), + doc="Hot salt inventory at the end of the hour (or time period), kg" + ) + m.fs.previous_salt_inventory_cold = Var( + domain=NonNegativeReals, + initialize=tank_max-inventory_min, + bounds=(0, inventory_max), + doc="Cold salt at the beginning of the hour (or time period), kg" + ) + m.fs.salt_inventory_cold = Var( + domain=NonNegativeReals, + initialize=tank_max-inventory_min, + bounds=(0, inventory_max), + doc="Cold salt inventory at the end of the hour (or time period), kg" + ) + + @m.fs.Constraint(doc="Plant ramping down constraint") + def constraint_ramp_down(b): + return ( + m.fs.previous_power - 60 <= + m.fs.plant_power_out[0]) + + @m.fs.Constraint(doc="Plant ramping up constraint") + def constraint_ramp_up(b): + return ( + m.fs.previous_power + 60 >= + m.fs.plant_power_out[0]) + + @m.fs.Constraint(doc="Inventory balance at the end of the time period") + def constraint_salt_inventory_hot(b): + return ( + m.fs.salt_inventory_hot == + m.fs.previous_salt_inventory_hot + + (3600*m.fs.hxc.tube_inlet.flow_mass[0] + - 3600*m.fs.hxd.shell_inlet.flow_mass[0]) + ) + + @m.fs.Constraint(doc="Max salt flow to hxd based on available hot salt") + def constraint_salt_maxflow_hot(b): + return ( + 3600*m.fs.hxd.shell_inlet.flow_mass[0] <= + m.fs.previous_salt_inventory_hot + ) + + @m.fs.Constraint(doc="Max salt flow to hxc based on available cold salt") + def constraint_salt_maxflow_cold(b): + return ( + 3600*m.fs.hxc.tube_inlet.flow_mass[0] <= + m.fs.previous_salt_inventory_cold + ) + + @m.fs.Constraint(doc="Maximum salt inventory at any time") + def constraint_salt_inventory(b): + return ( + m.fs.salt_inventory_hot + + m.fs.salt_inventory_cold == m.fs.salt_amount) + + return m + + +def usc_unfix_dof(m): # Unfix data - m.usc_mp.fs.boiler.inlet.flow_mol[0].unfix() + m.fs.boiler.inlet.flow_mol[0].unfix() # Unfix storage system data - m.usc_mp.fs.ess_hp_split.split_fraction[0, "to_hxc"].unfix() - m.usc_mp.fs.ess_bfp_split.split_fraction[0, "to_hxd"].unfix() - for salt_hxc in [m.usc_mp.fs.hxc]: + m.fs.ess_hp_split.split_fraction[0, "to_hxc"].unfix() + m.fs.ess_bfp_split.split_fraction[0, "to_hxd"].unfix() + for salt_hxc in [m.fs.hxc]: salt_hxc.shell_inlet.unfix() salt_hxc.tube_inlet.flow_mass.unfix() # kg/s, 1 DOF salt_hxc.area.unfix() # 1 DOF - for salt_hxd in [m.usc_mp.fs.hxd]: + for salt_hxd in [m.fs.hxd]: salt_hxd.tube_inlet.unfix() salt_hxd.shell_inlet.flow_mass.unfix() # kg/s, 1 DOF salt_hxd.area.unfix() # 1 DOF - for unit in [m.usc_mp.fs.cooler]: + for unit in [m.fs.cooler]: unit.inlet.unfix() - m.usc_mp.fs.cooler.outlet.enth_mol[0].unfix() # 1 DOF + m.fs.cooler.outlet.enth_mol[0].unfix() # 1 DOF # Fix storage heat exchangers area and salt temperatures - m.usc_mp.fs.hxc.area.fix(1904) - m.usc_mp.fs.hxd.area.fix(2830) - m.usc_mp.fs.hxc.tube_outlet.temperature[0].fix(831) - m.usc_mp.fs.hxd.shell_inlet.temperature[0].fix(831) - m.usc_mp.fs.hxd.shell_outlet.temperature[0].fix(513.15) + m.fs.hxc.area.fix(1904) + m.fs.hxd.area.fix(2830) + m.fs.hxc.tube_outlet.temperature[0].fix(831) + m.fs.hxd.shell_inlet.temperature[0].fix(831) + m.fs.hxd.shell_outlet.temperature[0].fix(513.15) + - return m +def usc_custom_init(m): + + blk = usc.build_plant_model() + usc.initialize(blk) + + # Create a flowsheet, add properties, unit models, and arcs + max_power = 436 # in MW + min_power = int(0.65 * 436) + pmin = int(0.65 * 436) + 1 + pmax = 436 + 30 + min_storage_heat_duty = 10 # in MW + max_storage_heat_duty = 200 # in MW + + + blk = usc_w_tes.create_integrated_model(blk, max_power=max_power) + + # Give all the required inputs to the model + usc_w_tes.set_model_input(blk) + + # Add scaling factor + usc_w_tes.set_scaling_factors(blk) -def create_usc_mp_block(pmin=None, pmax=None): - print('>>> Creating USC model and initialization for each time period') + # Initialize the model with a sequential initialization and custom + # routines + usc_w_tes.initialize(blk) + + # Add cost correlations + blk = usc_w_tes.build_costing(blk) + + # Initialize with bounds + usc_w_tes.initialize_with_costing(blk) + + blk.fs.plant_min_power_eq = Constraint( + expr=blk.fs.plant_power_out[0] >= min_power + ) + blk.fs.plant_max_power_eq = Constraint( + expr=blk.fs.plant_power_out[0] <= max_power + ) + + blk.fs.hxc.heat_duty.setlb(min_storage_heat_duty * 1e6) + blk.fs.hxd.heat_duty.setlb(min_storage_heat_duty * 1e6) + + blk.fs.hxc.heat_duty.setub(max_storage_heat_duty * 1e6) + blk.fs.hxd.heat_duty.setub(max_storage_heat_duty * 1e6) if pmin is None: pmin = int(0.65 * 436) + 1 if pmax is None: pmax = 436 + 30 - m = create_usc_model(pmin, pmax) - b1 = m.usc_mp - # Add coupling variables - b1.previous_power = Var( + blk.fs.previous_power = Var( domain=NonNegativeReals, initialize=300, bounds=(pmin, pmax), @@ -122,73 +259,76 @@ def create_usc_mp_block(pmin=None, pmax=None): inventory_min = 75000 tank_max = 6739292 # Units in kg - b1.previous_salt_inventory_hot = Var( + blk.fs.previous_salt_inventory_hot = Var( domain=NonNegativeReals, initialize=inventory_min, bounds=(0, inventory_max), doc="Hot salt at the beginning of the hour (or time period), kg" ) - b1.salt_inventory_hot = Var( + blk.fs.salt_inventory_hot = Var( domain=NonNegativeReals, initialize=inventory_min, bounds=(0, inventory_max), doc="Hot salt inventory at the end of the hour (or time period), kg" ) - b1.previous_salt_inventory_cold = Var( + blk.fs.previous_salt_inventory_cold = Var( domain=NonNegativeReals, initialize=tank_max-inventory_min, bounds=(0, inventory_max), doc="Cold salt at the beginning of the hour (or time period), kg" ) - b1.salt_inventory_cold = Var( + blk.fs.salt_inventory_cold = Var( domain=NonNegativeReals, initialize=tank_max-inventory_min, bounds=(0, inventory_max), doc="Cold salt inventory at the end of the hour (or time period), kg" ) - @b1.fs.Constraint(doc="Plant ramping down constraint") + @blk.fs.Constraint(doc="Plant ramping down constraint") def constraint_ramp_down(b): return ( - b1.previous_power - 60 <= - b1.fs.plant_power_out[0]) + blk.fs.previous_power - 60 <= + blk.fs.plant_power_out[0]) - @b1.fs.Constraint(doc="Plant ramping up constraint") + @blk.fs.Constraint(doc="Plant ramping up constraint") def constraint_ramp_up(b): return ( - b1.previous_power + 60 >= - b1.fs.plant_power_out[0]) + blk.fs.previous_power + 60 >= + blk.fs.plant_power_out[0]) - @b1.fs.Constraint(doc="Inventory balance at the end of the time period") + @blk.fs.Constraint(doc="Inventory balance at the end of the time period") def constraint_salt_inventory_hot(b): return ( - b1.salt_inventory_hot == - b1.previous_salt_inventory_hot - + (3600*b1.fs.hxc.tube_inlet.flow_mass[0] - - 3600*b1.fs.hxd.shell_inlet.flow_mass[0]) + blk.fs.salt_inventory_hot == + blk.fs.previous_salt_inventory_hot + + (3600*blk.fs.hxc.tube_inlet.flow_mass[0] + - 3600*blk.fs.hxd.shell_inlet.flow_mass[0]) ) - @b1.fs.Constraint(doc="Max salt flow to hxd based on available hot salt") + @blk.fs.Constraint(doc="Max salt flow to hxd based on available hot salt") def constraint_salt_maxflow_hot(b): return ( - 3600*b1.fs.hxd.shell_inlet.flow_mass[0] <= - b1.previous_salt_inventory_hot + 3600*blk.fs.hxd.shell_inlet.flow_mass[0] <= + blk.fs.previous_salt_inventory_hot ) - @b1.fs.Constraint(doc="Max salt flow to hxc based on available cold salt") + @blk.fs.Constraint(doc="Max salt flow to hxc based on available cold salt") def constraint_salt_maxflow_cold(b): return ( - 3600*b1.fs.hxc.tube_inlet.flow_mass[0] <= - b1.previous_salt_inventory_cold + 3600*blk.fs.hxc.tube_inlet.flow_mass[0] <= + blk.fs.previous_salt_inventory_cold ) - @b1.fs.Constraint(doc="Maximum salt inventory at any time") + @blk.fs.Constraint(doc="Maximum salt inventory at any time") def constraint_salt_inventory(b): return ( - b1.salt_inventory_hot + - b1.salt_inventory_cold == b1.fs.salt_amount) + blk.fs.salt_inventory_hot + + blk.fs.salt_inventory_cold == blk.fs.salt_amount) - return m + init_model = to_json(blk, return_dict=True) + from_json(m, sd=init_model) + + return # The tank level and power output are linked between the contiguous time periods @@ -197,10 +337,10 @@ def get_usc_link_variable_pairs(b1, b2): b1: current time block b2: next time block """ - return [(b1.usc_mp.salt_inventory_hot, - b2.usc_mp.previous_salt_inventory_hot), - (b1.usc_mp.fs.plant_power_out[0], - b2.usc_mp.previous_power)] + return [(b1.fs.salt_inventory_hot, + b2.fs.previous_salt_inventory_hot), + (b1.fs.plant_power_out[0], + b2.fs.previous_power)] # The tank level at the end of the last time period must be the same as at the @@ -211,8 +351,8 @@ def get_usc_periodic_variable_pairs(b1, b2): b2: first time block """ # return - return [(b1.usc_mp.salt_inventory_hot, - b2.usc_mp.previous_salt_inventory_hot)] + return [(b1.fs.salt_inventory_hot, + b2.fs.previous_salt_inventory_hot)] # Create the multiperiod model object. You can pass arguments to your # "process_model_func" for each time period using a dict of dicts as @@ -228,13 +368,15 @@ def create_multiperiod_usc_model(n_time_points=4, pmin=None, pmax=None): n_time_points: Number of time blocks to create """ multiperiod_usc = MultiPeriodModel( - n_time_points, - lambda: create_usc_mp_block(pmin=None, pmax=None), - get_usc_link_variable_pairs, - get_usc_periodic_variable_pairs + n_time_points=n_time_points, + process_model_func=create_usc_model, + initialization_func=usc_custom_init, + unfix_dof_func=usc_unfix_dof, + linking_variable_func=get_usc_link_variable_pairs, + flowsheet_options={"pmin": pmin, + "pmax": pmax}, + use_stochastic_build=True, + outlvl=idaeslog.INFO, ) - # If you have no arguments, you don't actually need to pass in - # anything. NOTE: building the model will initialize each time block - multiperiod_usc.build_multi_period_model() return multiperiod_usc From 7ed96dbc3b3f83e27f8ad8f5227c5a73fe8b4793 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Fri, 28 Oct 2022 12:30:26 -0400 Subject: [PATCH 06/12] updated nlp model for consistency --- .../integrated_storage_with_ultrasupercritical_power_plant.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/integrated_storage_with_ultrasupercritical_power_plant.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/integrated_storage_with_ultrasupercritical_power_plant.py index 2bfe5b10c..39a2961c0 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/integrated_storage_with_ultrasupercritical_power_plant.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/integrated_storage_with_ultrasupercritical_power_plant.py @@ -605,7 +605,7 @@ def set_model_input(m): m.fs.hx_pump.efficiency_pump.fix(0.80) m.fs.es_turbine.ratioP.fix(0.0286) - m.fs.es_turbine.efficiency_isentropic.fix(0.5) + m.fs.es_turbine.efficiency_isentropic.fix(0.8) ########################################################################### # ESS VHP and HP splitters ########################################################################### From 2a5736282472a5aa52db77314d746042b28fc1d1 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Fri, 28 Oct 2022 12:32:04 -0400 Subject: [PATCH 07/12] updated pricetaker notebook and model to work with the new class and integrated storage notebook to reflect changes to the model --- .../integrated_storage_with_powerplant.ipynb | 429 +++++----- ...rated_ultrasupercritical_power_plant.ipynb | 775 +++++++++++++----- ...with_multiperiod_integrated_storage_usc.py | 111 +-- 3 files changed, 856 insertions(+), 459 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/integrated_storage_with_powerplant.ipynb b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/integrated_storage_with_powerplant.ipynb index 5718e1b1b..fdbcb0ded 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/integrated_storage_with_powerplant.ipynb +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/integrated_storage_with_powerplant.ipynb @@ -166,93 +166,93 @@ "name": "stdout", "output_type": "stream", "text": [ - "2022-06-28 15:58:08 [INFO] idaes.init.fs.boiler.control_volume: Initialization Complete\n", - "2022-06-28 15:58:08 [INFO] idaes.init.fs.boiler: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:08 [INFO] idaes.init.fs.turbine_splitter[1]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.turbine_splitter[2]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.reheater[1].control_volume: Initialization Complete\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.reheater[1]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.turbine_splitter[3]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.turbine_splitter[4]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.reheater[2].control_volume: Initialization Complete\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.reheater[2]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.turbine_splitter[5]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:09 [INFO] idaes.init.fs.turbine_splitter[6]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:10 [INFO] idaes.init.fs.turbine_splitter[7]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:10 [INFO] idaes.init.fs.turbine_splitter[8]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:10 [INFO] idaes.init.fs.turbine_splitter[9]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:10 [INFO] idaes.init.fs.turbine_splitter[10]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:10 [INFO] idaes.init.fs.condenser_mix: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:10 [INFO] idaes.init.fs.condenser.control_volume: Initialization Complete\n", - "2022-06-28 15:58:10 [INFO] idaes.init.fs.condenser: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh_mixer[1]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[1].shell: Initialization Complete\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[1].tube: Initialization Complete\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[1]: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh_mixer[2]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[2].shell: Initialization Complete\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[2].tube: Initialization Complete\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[2]: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh_mixer[3]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[3].shell: Initialization Complete\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[3].tube: Initialization Complete\n", - "2022-06-28 15:58:11 [INFO] idaes.init.fs.fwh[3]: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh_mixer[4]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[4].shell: Initialization Complete\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[4].tube: Initialization Complete\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[4]: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[5].shell: Initialization Complete\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[5].tube: Initialization Complete\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[5]: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.deaerator: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh_mixer[6]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[6].shell: Initialization Complete\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[6].tube: Initialization Complete\n", - "2022-06-28 15:58:12 [INFO] idaes.init.fs.fwh[6]: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh_mixer[7]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[7].shell: Initialization Complete\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[7].tube: Initialization Complete\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[7]: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh_mixer[8]: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[8].shell: Initialization Complete\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[8].tube: Initialization Complete\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[8]: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[9].shell: Initialization Complete\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[9].tube: Initialization Complete\n", - "2022-06-28 15:58:13 [INFO] idaes.init.fs.fwh[9]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.boiler.control_volume: Initialization Complete\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.boiler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.turbine_splitter[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.turbine_splitter[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.reheater[1].control_volume: Initialization Complete\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.reheater[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.turbine_splitter[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.turbine_splitter[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.reheater[2].control_volume: Initialization Complete\n", + "2022-10-28 12:23:07 [INFO] idaes.init.fs.reheater[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:08 [INFO] idaes.init.fs.turbine_splitter[5]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:08 [INFO] idaes.init.fs.turbine_splitter[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:08 [INFO] idaes.init.fs.turbine_splitter[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:08 [INFO] idaes.init.fs.turbine_splitter[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:08 [INFO] idaes.init.fs.turbine_splitter[9]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:08 [INFO] idaes.init.fs.turbine_splitter[10]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.condenser_mix: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.condenser.control_volume: Initialization Complete\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.condenser: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh_mixer[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[1].hot_side: Initialization Complete\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[1].cold_side: Initialization Complete\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[1]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh_mixer[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[2].hot_side: Initialization Complete\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[2].cold_side: Initialization Complete\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[2]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh_mixer[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[3].hot_side: Initialization Complete\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[3].cold_side: Initialization Complete\n", + "2022-10-28 12:23:09 [INFO] idaes.init.fs.fwh[3]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh_mixer[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[4].hot_side: Initialization Complete\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[4].cold_side: Initialization Complete\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[4]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[5].hot_side: Initialization Complete\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[5].cold_side: Initialization Complete\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[5]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.deaerator: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh_mixer[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[6].hot_side: Initialization Complete\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[6].cold_side: Initialization Complete\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[6]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh_mixer[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[7].hot_side: Initialization Complete\n", + "2022-10-28 12:23:10 [INFO] idaes.init.fs.fwh[7].cold_side: Initialization Complete\n", + "2022-10-28 12:23:11 [INFO] idaes.init.fs.fwh[7]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:11 [INFO] idaes.init.fs.fwh_mixer[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:11 [INFO] idaes.init.fs.fwh[8].hot_side: Initialization Complete\n", + "2022-10-28 12:23:11 [INFO] idaes.init.fs.fwh[8].cold_side: Initialization Complete\n", + "2022-10-28 12:23:11 [INFO] idaes.init.fs.fwh[8]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:11 [INFO] idaes.init.fs.fwh[9].hot_side: Initialization Complete\n", + "2022-10-28 12:23:11 [INFO] idaes.init.fs.fwh[9].cold_side: Initialization Complete\n", + "2022-10-28 12:23:11 [INFO] idaes.init.fs.fwh[9]: Initialization Completed, optimal - Optimal Solution Found\n", "Model Initialization = optimal\n", "******************* USC Model Initialized ********************\n", - "2022-06-28 15:58:16 [INFO] idaes.init.fs.ess_hp_split: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:16 [INFO] idaes.init.fs.hxc.shell: Initialization Complete\n", - "2022-06-28 15:58:16 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: fs.hxc.tube.properties_in Initialisation Step 1 Complete.\n", - "2022-06-28 15:58:16 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: Initialization Step 1 Complete.\n", - "2022-06-28 15:58:16 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: fs.hxc.tube.properties_out Initialisation Step 1 Complete.\n", - "2022-06-28 15:58:16 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: Initialization Step 1 Complete.\n", - "2022-06-28 15:58:16 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: State Released.\n", - "2022-06-28 15:58:16 [INFO] idaes.init.fs.hxc.tube: Initialization Complete\n", - "2022-06-28 15:58:17 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: State Released.\n", - "2022-06-28 15:58:17 [INFO] idaes.init.fs.hxc: Initialization Completed, optimal - Optimal Solution Found\n", - "2022-06-28 15:58:17 [INFO] idaes.init.fs.cooler.control_volume: Initialization Complete\n", - "2022-06-28 15:58:17 [INFO] idaes.init.fs.cooler: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:17 [INFO] idaes.init.fs.hx_pump.control_volume: Initialization Complete\n", - "2022-06-28 15:58:17 [INFO] idaes.init.fs.hx_pump: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:17 [INFO] idaes.init.fs.ess_bfp_split: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:17 [INFO] idaes.init.fs.recycle_mixer: Initialization Complete: optimal - Optimal Solution Found\n", - "2022-06-28 15:58:17 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: fs.hxd.shell.properties_in Initialisation Step 1 Complete.\n", - "2022-06-28 15:58:17 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: Initialization Step 1 Complete.\n", - "2022-06-28 15:58:18 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: fs.hxd.shell.properties_out Initialisation Step 1 Complete.\n", - "2022-06-28 15:58:18 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: Initialization Step 1 Complete.\n", - "2022-06-28 15:58:18 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: State Released.\n", - "2022-06-28 15:58:18 [INFO] idaes.init.fs.hxd.shell: Initialization Complete\n", - "2022-06-28 15:58:18 [INFO] idaes.init.fs.hxd.tube: Initialization Complete\n", - "2022-06-28 15:58:18 [INFO] idaes.init.dispatches.models.fossil_case.properties.solarsalt_properties: State Released.\n" + "2022-10-28 12:23:13 [INFO] idaes.init.fs.ess_hp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:13 [INFO] idaes.init.fs.hxc.hot_side: Initialization Complete\n", + "2022-10-28 12:23:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-10-28 12:23:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-28 12:23:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-10-28 12:23:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-28 12:23:13 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-28 12:23:13 [INFO] idaes.init.fs.hxc.cold_side: Initialization Complete\n", + "2022-10-28 12:23:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.hxc: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.cooler.control_volume: Initialization Complete\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.cooler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.hx_pump.control_volume: Initialization Complete\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.hx_pump: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.ess_bfp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.recycle_mixer: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:23:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_in Initialisation Step 1 Complete.\n", + "2022-10-28 12:23:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-28 12:23:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_out Initialisation Step 1 Complete.\n", + "2022-10-28 12:23:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-28 12:23:14 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.hxd.hot_side: Initialization Complete\n", + "2022-10-28 12:23:14 [INFO] idaes.init.fs.hxd.cold_side: Initialization Complete\n", + "2022-10-28 12:23:15 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-28 12:23:15 [INFO] idaes.init.fs.hxd: Initialization Completed, optimal - Optimal Solution Found\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2022-06-28 15:58:18 [INFO] idaes.init.fs.hxd: Initialization Completed, optimal - Optimal Solution Found\n", "Integrated Model Initialization = optimal\n", "*************** Integrated Model Initialized ***************\n", "Cost Initialization = optimal\n", @@ -264,7 +264,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -361,105 +361,128 @@ " inequality constraints with only upper bounds: 5\n", "\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 0 1.1204060e+00 2.83e+08 1.00e+00 -1.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", - " 1 1.1207661e+00 2.82e+08 8.78e+00 -1.0 3.09e+06 - 1.98e-02 2.23e-03h 1\n", - " 2 1.1224973e+00 2.82e+08 5.67e+01 -1.0 3.24e+07 - 1.31e-02 2.19e-03h 1\n", - " 3 1.1347610e+00 2.77e+08 6.83e+02 -1.0 3.28e+07 - 1.60e-01 1.53e-02h 1\n", - " 4 1.9901656e+00 2.96e+08 2.20e+05 -1.0 3.34e+07 - 2.19e-02 1.00e+00h 1\n", - " 5 2.0841051e+00 2.57e+08 1.91e+05 -1.0 3.57e+07 - 6.61e-01 1.34e-01h 1\n", - " 6 2.0843658e+00 2.57e+08 1.73e+06 -1.0 3.09e+07 -4.0 5.72e-02 1.87e-04h 1\n", - " 7 2.2789487e+00 2.21e+08 2.58e+06 -1.0 3.09e+07 -4.5 2.70e-01 1.40e-01h 1\n", - " 8 3.2045263e+00 4.22e+07 3.04e+06 -1.0 2.66e+07 -5.0 5.96e-02 7.65e-01h 1\n", - " 9 3.3039281e+00 2.03e+06 9.06e+06 -1.0 6.24e+06 -5.4 4.40e-02 8.57e-01h 1\n", + " 0 -6.1496664e-01 2.83e+08 1.00e+00 -1.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", + " 1 -6.1438587e-01 2.82e+08 8.68e+00 -1.0 3.09e+06 - 1.95e-02 2.23e-03h 1\n", + " 2 -6.1106486e-01 2.82e+08 6.28e+01 -1.0 3.24e+07 - 1.45e-02 2.17e-03h 1\n", + " 3 -5.8518823e-01 2.77e+08 6.81e+02 -1.0 3.28e+07 - 1.59e-01 1.67e-02h 1\n", + " 4 1.0350043e+00 2.95e+08 2.20e+05 -1.0 3.34e+07 - 2.33e-02 1.00e+00h 1\n", + " 5 1.2311738e+00 2.56e+08 1.90e+05 -1.0 3.56e+07 - 6.54e-01 1.36e-01h 1\n", + " 6 1.2315358e+00 2.56e+08 2.77e+06 -1.0 3.07e+07 -4.0 8.91e-02 1.80e-04h 1\n", + " 7 1.6550837e+00 2.04e+08 2.36e+07 -1.0 3.07e+07 -4.5 3.46e-01 2.11e-01h 1\n", + " 8 2.5130753e+00 8.90e+07 1.42e+08 -1.0 2.42e+07 -5.0 7.07e-02 3.62e-01h 1\n", + " 9 3.3202605e+00 1.98e+07 5.59e+06 -1.0 1.55e+07 -5.4 7.61e-02 9.86e-01h 1\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 10 3.2569455e+00 2.40e+04 3.63e+06 -1.0 8.91e+05 -5.9 3.50e-02 1.00e+00h 1\n", - " 11 3.2558914e+00 3.19e-01 3.66e+04 -1.0 4.80e+03 -6.4 9.90e-01 1.00e+00h 1\n", - " 12 3.2536204e+00 6.54e+01 4.17e+02 -1.0 5.99e+04 - 9.89e-01 1.00e+00f 1\n", - " 13 2.9463217e+00 1.45e+05 2.51e+01 -1.0 2.33e+06 - 9.40e-01 1.00e+00f 1\n", - " 14 1.0171245e+00 6.16e+06 1.29e+01 -1.0 2.42e+07 - 4.86e-01 7.29e-01f 1\n", - " 15 1.0149567e+00 5.99e+06 4.23e+01 -1.0 8.34e+05 -6.9 4.24e-02 3.19e-02h 1\n", - " 16 1.0149268e+00 5.98e+06 4.22e+01 -1.0 6.28e+05 -7.3 3.15e-03 2.53e-04h 1\n", - " 17 1.0148377e+00 5.97e+06 4.37e+01 -1.0 1.07e+06 -7.8 1.24e-01 2.68e-03h 1\n", - " 18 9.8197869e-01 2.76e+06 1.59e+04 -1.0 1.06e+06 -8.3 4.43e-03 1.00e+00f 1\n", - " 19 9.5530740e-01 3.46e+05 1.59e+03 -1.0 1.54e+05 -8.8 9.90e-01 8.19e-01h 1\n", + " 10 3.1394219e+00 1.33e+06 1.70e+07 -1.0 8.67e+05 -5.9 4.55e-02 1.00e+00h 1\n", + " 11 3.0998559e+00 1.37e+06 1.95e+05 -1.0 1.84e+05 -6.4 9.83e-01 1.00e+00h 1\n", + " 12 3.0995517e+00 1.33e+01 7.74e+02 -1.0 1.38e+03 -6.9 9.90e-01 1.00e+00h 1\n", + " 13 2.9721633e+00 1.75e+04 2.61e+01 -1.0 1.17e+06 - 9.66e-01 1.00e+00f 1\n", + " 14 1.9062570e-01 4.58e+05 6.87e+00 -1.0 3.81e+07 - 7.37e-01 1.00e+00f 1\n", + " 15 -1.2634681e+00 4.28e+06 3.61e+00 -1.0 1.64e+08 - 4.75e-01 1.46e-01h 1\n", + " 16 -1.3364941e+00 2.22e+06 2.62e+02 -1.0 5.69e+05 -7.3 1.07e-01 4.51e-01h 1\n", + " 17 -1.3391960e+00 2.19e+06 2.58e+02 -1.0 6.17e+05 -7.8 3.29e-03 1.77e-02h 1\n", + " 18 -1.4453580e+00 4.08e+03 2.41e+03 -1.0 4.46e+05 -8.3 9.91e-01 1.00e+00f 1\n", + " 19 -1.4715549e+00 1.77e+03 2.16e+02 -1.0 1.17e+05 -8.8 9.20e-01 1.00e+00h 1\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 20 9.4910890e-01 5.21e+03 7.71e+01 -1.0 2.81e+04 -9.2 1.00e+00 1.00e+00f 1\n", - " 21 9.4853133e-01 2.35e+00 3.24e-02 -1.0 5.10e+03 -9.7 1.00e+00 1.00e+00f 1\n", - " 22 -1.6284490e+00 2.92e+06 5.01e+00 -2.5 2.67e+08 - 3.63e-01 1.01e-01f 1\n", - " 23 -3.2202779e+00 5.85e+06 7.80e+00 -2.5 8.80e+07 - 6.58e-01 2.11e-01h 1\n", - " 24 -5.1406299e+00 3.34e+06 4.16e+00 -2.5 4.21e+07 - 8.31e-01 8.53e-01h 1\n", - " 25 -5.1145904e+00 8.79e+05 2.49e-01 -2.5 1.11e+06 - 9.34e-01 9.44e-01h 1\n", - " 26 -5.1165908e+00 7.90e+05 6.73e-01 -2.5 3.36e+05 - 7.16e-01 1.03e-01h 1\n", - " 27 -5.1309775e+00 4.79e+05 2.66e-01 -2.5 6.77e+05 - 7.84e-02 4.09e-01h 1\n", - " 28 -5.1363847e+00 3.84e+05 5.35e-01 -2.5 1.98e+05 - 3.25e-02 1.95e-01h 1\n", - " 29 -5.1359045e+00 3.68e+05 4.93e-01 -2.5 8.87e+04 -9.3 4.99e-03 4.11e-02h 1\n", + " 20 -2.1553064e+00 1.63e+05 2.06e+02 -1.0 8.25e+07 - 9.51e-02 4.61e-02f 1\n", + " 21 -4.0182155e+00 1.19e+07 1.49e+03 -1.0 3.75e+07 - 1.00e+00 1.00e+00h 1\n", + " 22 -3.5232387e+00 6.23e+06 8.34e+02 -1.0 2.32e+07 - 6.96e-01 4.40e-01h 2\n", + " 23 -3.5339657e+00 2.49e+04 1.96e-02 -1.0 1.14e+04 -9.2 1.00e+00 1.00e+00h 1\n", + " 24 -3.8631799e+00 1.17e+04 3.67e+00 -1.0 2.31e+07 - 1.00e+00 3.23e-01h 1\n", + " 25 -3.7813088e+00 1.02e+05 6.08e+00 -1.0 5.89e+06 - 1.00e+00 1.00e+00f 1\n", + " 26 -3.5417036e+00 6.73e+05 1.82e-02 -1.0 1.73e+06 - 1.00e+00 1.00e+00h 1\n", + " 27 -3.4144202e+00 2.51e+05 1.95e-02 -1.0 1.56e+06 - 1.00e+00 1.00e+00h 1\n", + " 28 -3.3970510e+00 3.09e+03 1.84e-04 -1.0 3.14e+05 - 1.00e+00 1.00e+00h 1\n", + " 29 -4.7981799e+00 5.68e+06 8.22e+00 -2.5 2.56e+07 - 4.36e-01 6.60e-01f 1\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 30 -5.1236928e+00 3.54e+05 4.56e-01 -2.5 1.86e+06 - 1.05e-01 3.75e-02h 3\n", - " 31 -5.1317184e+00 2.54e+05 3.53e-01 -2.5 3.28e+05 - 2.66e-01 2.91e-01h 1\n", - " 32 -5.1398679e+00 1.29e+05 1.15e+00 -2.5 2.31e+05 - 6.82e-03 5.44e-01h 1\n", - " 33 -5.1406439e+00 9.50e+03 8.66e-01 -2.5 1.12e+05 - 7.36e-01 1.00e+00H 1\n", - " 34 -5.1446582e+00 2.80e+04 5.00e-01 -2.5 3.11e+05 - 6.87e-01 5.95e-01h 1\n", - " 35 -5.1403844e+00 2.03e+04 3.15e-01 -2.5 1.90e+05 - 4.79e-01 5.00e-01h 2\n", - " 36 -5.1275151e+00 9.12e+03 1.81e-01 -2.5 3.10e+05 - 9.68e-01 1.00e+00h 1\n", - " 37 -5.1119901e+00 1.45e+04 6.19e-03 -2.5 3.47e+05 - 1.00e+00 1.00e+00H 1\n", - " 38 -5.1128670e+00 1.57e+03 5.31e-04 -2.5 5.55e+04 - 1.00e+00 1.00e+00h 1\n", - " 39 -5.1130838e+00 7.81e+01 4.89e-04 -2.5 1.75e+04 - 1.00e+00 1.00e+00h 1\n", + " 30 -4.9768896e+00 1.60e+07 1.79e+01 -2.5 1.08e+07 - 1.73e-02 8.72e-01h 1\n", + " 31 -5.0936781e+00 1.49e+06 1.67e+01 -2.5 1.47e+06 - 2.80e-02 8.97e-01h 1\n", + " 32 -5.1112184e+00 7.25e+04 1.52e+01 -2.5 1.62e+05 - 1.01e-01 1.00e+00h 1\n", + " 33 -5.1957960e+00 5.03e+05 3.46e+00 -2.5 1.94e+06 - 7.72e-01 1.00e+00h 1\n", + " 34 -5.1958092e+00 2.36e+02 7.05e-05 -2.5 4.58e+02 -9.7 1.00e+00 1.00e+00h 1\n", + " 35 -5.3343492e+00 1.22e+06 3.52e-02 -3.8 3.22e+07 - 8.31e-02 1.01e-01f 1\n", + " 36 -5.3712928e+00 2.64e+05 1.37e-01 -3.8 7.49e+05 - 9.59e-01 7.91e-01h 1\n", + " 37 -5.3825670e+00 9.52e+03 5.95e-04 -3.8 1.41e+05 - 1.00e+00 1.00e+00h 1\n", + " 38 -5.3823998e+00 1.41e+02 6.74e-07 -3.8 2.04e+03 - 1.00e+00 1.00e+00h 1\n", + " 39 -5.3824002e+00 1.40e-01 2.24e-07 -3.8 7.50e+01 - 1.00e+00 1.00e+00h 1\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 40 -5.1130580e+00 1.18e-01 4.89e-04 -2.5 8.49e+02 - 1.00e+00 1.00e+00h 1\n", - " 41 -5.1667338e+00 2.51e+04 1.04e-01 -3.8 8.19e+05 - 8.85e-01 1.00e+00f 1\n", - " 42 -5.1677924e+00 5.55e+02 2.31e-05 -3.8 1.96e+04 - 1.00e+00 1.00e+00h 1\n", - " 43 -5.1678080e+00 2.49e-01 4.57e-04 -3.8 2.84e+02 - 1.00e+00 1.00e+00h 1\n", - " 44 -5.1709188e+00 1.95e+02 4.56e-04 -5.7 4.56e+04 - 9.92e-01 1.00e+00h 1\n", - " 45 -5.1709220e+00 1.96e-01 7.29e-05 -5.7 1.91e+01 -9.8 1.00e+00 1.00e+00h 1\n", - " 46 -5.1709241e+00 1.08e-03 1.42e-07 -5.7 8.69e+01 - 1.00e+00 1.00e+00h 1\n", - " 47 -5.1709605e+00 7.83e-01 8.55e-07 -7.0 5.39e+02 - 1.00e+00 1.00e+00h 1\n", - " 48 -5.1709605e+00 2.63e-03 1.73e-04 -7.0 5.38e+01 - 1.00e+00 1.00e+00H 1\n", - " 49 -5.1709605e+00 5.44e-06 4.56e-04 -7.0 5.99e+00 - 1.00e+00 1.00e+00h 1\n", + " 40 -5.3855111e+00 1.97e+02 1.97e-04 -5.7 4.58e+04 - 9.96e-01 1.00e+00h 1\n", + " 41 -5.3855147e+00 1.20e+00 1.47e-04 -5.7 1.35e+01 -10.2 1.00e+00 1.00e+00h 1\n", + " 42 -5.3855152e+00 1.16e-02 9.14e-07 -5.7 5.00e+01 - 1.00e+00 1.00e+00h 1\n", + " 43 -5.3855152e+00 3.07e-06 2.21e-09 -5.7 5.62e+00 - 1.00e+00 1.00e+00h 1\n", + " 44 -5.3855520e+00 7.90e-01 5.02e-06 -7.0 5.41e+02 - 1.00e+00 1.00e+00h 1\n", + " 45 -5.3855520e+00 2.65e-03 5.47e-06 -7.0 4.98e+01 - 1.00e+00 1.00e+00H 1\n", + " 46 -5.3855520e+00 4.93e-06 4.04e-05 -7.0 5.89e+00 - 1.00e+00 1.00e+00h 1\n", + " 47 -5.3855520e+00 1.04e-07 4.04e-05 -7.0 2.23e+01 - 1.00e+00 1.00e+00H 1\n", + " 48 -5.3855520e+00 4.47e-08 1.74e-04 -7.0 1.65e-01 - 1.00e+00 1.00e+00h 1\n", + " 49 -5.3855520e+00 6.14e-08 1.74e-04 -7.0 8.61e-06 - 1.00e+00 1.00e+00h 1\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 50 -5.1709605e+00 7.96e-08 4.56e-04 -7.0 2.19e+01 - 1.00e+00 1.00e+00H 1\n", - " 51 -5.1709605e+00 9.19e-08 4.03e-05 -7.0 1.61e-01 - 1.00e+00 1.00e+00h 1\n", - " 52 -5.1709605e+00 4.47e-08 4.03e-05 -7.0 2.70e-06 - 1.00e+00 1.00e+00h 1\n", - " 53 -5.1709605e+00 4.47e-08 3.86e-05 -7.0 3.88e-06 - 1.00e+00 1.00e+00h 1\n", - " 54 -5.1709605e+00 2.98e-08 2.90e-05 -7.0 8.49e-07 - 1.00e+00 2.50e-01h 3\n", - " 55 -5.1709605e+00 1.19e-07 9.09e-13 -7.0 1.00e-06 - 1.00e+00 1.00e+00H 1\n", + " 50 -5.3855520e+00 4.65e-08 1.74e-04 -7.0 4.15e-06 - 1.00e+00 1.00e+00h 1\n", + " 51 -5.3855520e+00 7.45e-08 1.74e-04 -7.0 5.52e-07 - 1.00e+00 1.00e+00h 1\n", + " 52 -5.3855520e+00 4.47e-08 4.04e-05 -7.0 9.04e-07 - 1.00e+00 1.00e+00H 1\n", + " 53 -5.3855520e+00 5.96e-08 2.02e-05 -7.0 1.90e-06 - 1.00e+00 5.00e-01h 2\n", + " 54 -5.3855520e+00 8.94e-08 4.04e-05 -7.0 2.96e-06 - 1.00e+00 1.00e+00h 1\n", + " 55 -5.3855520e+00 4.29e-08 1.74e-04 -7.0 1.02e-05 - 1.00e+00 1.00e+00h 1\n", + " 56 -5.3855520e+00 5.04e-08 8.68e-05 -7.0 5.54e-06 - 1.00e+00 5.00e-01h 2\n", + " 57 -5.3855520e+00 8.94e-08 8.41e-05 -7.0 8.57e-06 - 1.00e+00 3.12e-02h 6\n", + " 58 -5.3855520e+00 2.98e-08 4.20e-05 -7.0 5.11e-06 - 1.00e+00 5.00e-01h 2\n", + " 59 -5.3855520e+00 1.04e-07 1.74e-04 -7.0 1.04e-05 - 1.00e+00 1.00e+00h 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 60 -5.3855520e+00 1.94e-07 1.52e-04 -7.0 1.28e-05 - 1.00e+00 1.25e-01h 4\n", + " 61 -5.3855520e+00 5.96e-08 1.14e-04 -7.0 1.11e-05 - 1.00e+00 2.50e-01h 3\n", + " 62 -5.3855520e+00 5.96e-08 9.97e-05 -7.0 6.69e-06 - 1.00e+00 1.25e-01h 4\n", + " 63 -5.3855520e+00 1.49e-08 7.48e-05 -7.0 2.17e-06 - 1.00e+00 2.50e-01h 3\n", + " 64 -5.3855520e+00 6.14e-08 6.54e-05 -7.0 2.00e-06 - 1.00e+00 1.25e-01h 4\n", + " 65 -5.3855520e+00 9.12e-08 4.91e-05 -7.0 5.75e-06 - 1.00e+00 2.50e-01h 3\n", + " 66 -5.3855520e+00 1.49e-08 3.68e-05 -7.0 1.42e-06 - 1.00e+00 2.50e-01h 3\n", + " 67 -5.3855520e+00 2.41e-08 2.76e-05 -7.0 8.03e-06 - 1.00e+00 2.50e-01h 3\n", + " 68 -5.3855520e+00 6.14e-08 2.07e-05 -7.0 3.83e-06 - 1.00e+00 2.50e-01h 3\n", + " 69 -5.3855520e+00 1.67e-08 2.01e-05 -7.0 2.98e-06 - 1.00e+00 3.12e-02h 6\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 70 -5.3855520e+00 1.49e-08 3.85e-09 -7.0 4.55e-06 - 1.00e+00 1.00e+00w 1\n", "\n", - "Number of Iterations....: 55\n", + "Number of Iterations....: 70\n", "\n", " (scaled) (unscaled)\n", - "Objective...............: -5.1709604695437292e+00 -5.1709604695437292e+00\n", - "Dual infeasibility......: 9.0909224592650162e-13 9.0909224592650162e-13\n", - "Constraint violation....: 1.8626451492309570e-09 1.1920928955078125e-07\n", - "Complementarity.........: 9.0909092075492566e-08 9.0909092075492566e-08\n", - "Overall NLP error.......: 9.0909092075492566e-08 1.1920928955078125e-07\n", - "\n", - "\n", - "Number of objective function evaluations = 69\n", - "Number of objective gradient evaluations = 56\n", - "Number of equality constraint evaluations = 69\n", - "Number of inequality constraint evaluations = 69\n", - "Number of equality constraint Jacobian evaluations = 56\n", - "Number of inequality constraint Jacobian evaluations = 56\n", - "Number of Lagrangian Hessian evaluations = 55\n", - "Total CPU secs in IPOPT (w/o function evaluations) = 0.582\n", - "Total CPU secs in NLP function evaluations = 8.814\n", + "Objective...............: -5.3855520382602888e+00 -5.3855520382602888e+00\n", + "Dual infeasibility......: 3.8460481061476119e-09 3.8460481061476119e-09\n", + "Constraint violation....: 4.6566128730773926e-10 1.4901161193847656e-08\n", + "Complementarity.........: 9.0909091367155361e-08 9.0909091367155361e-08\n", + "Overall NLP error.......: 9.0909091367155361e-08 9.0909091367155361e-08\n", + "\n", + "\n", + "Number of objective function evaluations = 122\n", + "Number of objective gradient evaluations = 71\n", + "Number of equality constraint evaluations = 122\n", + "Number of inequality constraint evaluations = 122\n", + "Number of equality constraint Jacobian evaluations = 71\n", + "Number of inequality constraint Jacobian evaluations = 71\n", + "Number of Lagrangian Hessian evaluations = 70\n", + "Total CPU secs in IPOPT (w/o function evaluations) = 0.536\n", + "Total CPU secs in NLP function evaluations = 8.785\n", "\n", "EXIT: Optimal Solution Found.\n", "================================\n", "\n", "\n", "***************** Optimization Results ******************\n", - "Revenue ($/h): 9627.765289\n", + "Revenue ($/h): 9649.224451\n", "Storage Capital Cost ($/h): 46.535959\n", - "Fuel Cost ($/h): 7388.289769\n", + "Fuel Cost ($/h): 7388.289773\n", "Hot Previous Salt Inventory (kg): 75000.000000\n", - "Hot Salt Inventory (kg): 0.243754\n", + "Hot Salt Inventory (kg): 0.222636\n", "Cold Previous Salt Inventory (kg): 6664292.000000\n", - "Cold Salt Inventory (kg): 6739291.756246\n", + "Cold Salt Inventory (kg): 6739291.777364\n", "Salt Amount (kg): 6739292.000000\n", "\n", "\n", "***************** Costing Results ******************\n", - "Obj (M$/year): 5.170960\n", + "Obj (M$/year): 5.385552\n", "Plant capital cost (M$/y): 63.043181\n", "Plant fixed operating costs (M$/y): 0.470617\n", "Plant variable operating costs (M$/y): 14.617427\n", @@ -469,40 +492,40 @@ "\n", "***************** Power Plant Operation ******************\n", "\n", - "Net Power (MW): 437.625695\n", + "Net Power (MW): 438.601111\n", "Plant Power (MW): 436.000002\n", - "ES turbine Power (MW): 1.625693\n", - "Boiler feed water flow (mol/s): 17889.191735\n", - "Boiler duty (MW_th): 919.470165\n", + "ES turbine Power (MW): 2.601109\n", + "Boiler feed water flow (mol/s): 17889.191749\n", + "Boiler duty (MW_th): 919.470166\n", "Cooling duty (MW_th): 0.000001\n", "HXC heat duty (MW): 0.000027\n", - "HXD heat duty (MW): 10.009721\n", - "Makeup water flow: 239.921403\n", + "HXD heat duty (MW): 10.009724\n", + "Makeup water flow: 239.921458\n", "\n", "\n", "***************** Charge Heat Exchanger (HXC) ******************\n", "\n", - "HXC area (m2): 24.707797\n", + "HXC area (m2): 24.750149\n", "HXC Salt flow (kg/s): 0.000057\n", "HXC Salt temperature in (K): 513.150000\n", "HXC Salt temperature out (K): 831.000000\n", - "HXC Steam flow to storage (mol/s): 0.000633\n", + "HXC Steam flow to storage (mol/s): 0.000636\n", "HXC Water temperature in (K): 866.150000\n", - "HXC Steam temperature out (K): 551.419468\n", + "HXC Steam temperature out (K): 551.387076\n", "HXC Delta temperature at inlet (K): 35.150000\n", - "HXC Delta temperature at outlet (K): 38.269468\n", + "HXC Delta temperature at outlet (K): 38.237076\n", "\n", "\n", "*************** Discharge Heat Exchanger (HXD) ****************\n", "\n", - "HXD area (m2): 2204.883492\n", - "HXD Salt flow (kg/s): 20.833322\n", + "HXD area (m2): 2204.890140\n", + "HXD Salt flow (kg/s): 20.833329\n", "HXD Salt temperature in (K): 831.000000\n", "HXD Salt temperature out (K): 513.150000\n", - "HXD Steam flow to storage (mol/s): 239.921403\n", + "HXD Steam flow to storage (mol/s): 239.921458\n", "HXD Water temperature in (K): 483.857199\n", - "HXD Steam temperature out (K): 826.099818\n", - "HXD Delta temperature at inlet (K): 4.900182\n", + "HXD Steam temperature out (K): 826.099858\n", + "HXD Delta temperature at inlet (K): 4.900142\n", "HXD Delta temperature at outlet (K): 29.292801\n", "\n", "\n", @@ -521,7 +544,7 @@ " Termination condition: optimal\n", " Id: 0\n", " Error rc: 0\n", - " Time: 9.571093559265137\n", + " Time: 9.49144172668457\n", "Solution: \n", "- number of solutions: 0\n", " number of solutions displayed: 0\n", @@ -533,7 +556,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -589,30 +612,30 @@ " Variables: \n", "\n", " Key : Value : Units : Fixed : Bounds\n", - " HX Area : 24.708 : meter ** 2 : False : (0, 6000)\n", - " HX Coefficient : 0.030095 : kilogram / kelvin / second ** 3 : False : (0, 10000)\n", - " Heat Duty : 27.281 : watt : False : (0, 200000000.0)\n", + " HX Area : 24.750 : meter ** 2 : False : (0, 6000)\n", + " HX Coefficient : 0.030221 : kilogram / kelvin / second ** 3 : False : (0, 10000)\n", + " Heat Duty : 27.429 : watt : False : (0, 200000000.0)\n", "\n", " Expressions: \n", "\n", " Key : Value : Units\n", - " Delta T Driving : 36.688 : kelvin\n", + " Delta T Driving : 36.672 : kelvin\n", " Delta T In : 35.150 : kelvin\n", - " Delta T Out : 38.269 : kelvin\n", + " Delta T Out : 38.237 : kelvin\n", "\n", "------------------------------------------------------------------------------------\n", " Stream Table\n", - " Units Hot Inlet Hot Outlet Cold Inlet Cold Outlet\n", - " Molar Flow (mol/s) mole / second 0.00063260 0.00063260 - -\n", - " Mass Flow (kg/s) kilogram / second 1.1397e-05 1.1397e-05 - -\n", - " T (K) kelvin 866.15 551.42 - -\n", - " P (Pa) pascal 8.6047e+06 8.6047e+06 - -\n", - " Vapor Fraction dimensionless 1.0000 0.0000 - -\n", - " Molar Enthalpy (J/mol) Vap joule / mole 65223. 54612. - -\n", - " Molar Enthalpy (J/mol) Liq joule / mole 65223. 22099. - -\n", - " flow_mass kilogram / second - - 5.6779e-05 5.6779e-05\n", - " temperature kelvin - - 513.15 831\n", - " pressure pascal - - 101325 1.0132e+05\n", + " Units shell Inlet shell Outlet tube Inlet tube Outlet\n", + " Molar Flow (mol/s) mole / second 0.00063601 0.00063601 - -\n", + " Mass Flow (kg/s) kilogram / second 1.1458e-05 1.1458e-05 - -\n", + " T (K) kelvin 866.15 551.39 - -\n", + " P (Pa) pascal 8.6047e+06 8.6047e+06 - -\n", + " Vapor Fraction dimensionless 1.0000 0.0000 - -\n", + " Molar Enthalpy (J/mol) Vap joule / mole 65223. -34295. - -\n", + " Molar Enthalpy (J/mol) Liq joule / mole 65223. 22096. - -\n", + " flow_mass kilogram / second - - 5.7089e-05 5.7089e-05\n", + " temperature kelvin - - 513.15 831\n", + " pressure pascal - - 101325 1.0132e+05\n", "====================================================================================\n", "\n", "====================================================================================\n", @@ -631,22 +654,22 @@ "\n", " Key : Value : Units\n", " Delta T Driving : 13.662 : kelvin\n", - " Delta T In : 4.9002 : kelvin\n", + " Delta T In : 4.9001 : kelvin\n", " Delta T Out : 29.293 : kelvin\n", "\n", "------------------------------------------------------------------------------------\n", " Stream Table\n", - " Units Hot Inlet Hot Outlet Cold Inlet Cold Outlet\n", - " flow_mass kilogram / second 20.833 20.833 - -\n", - " temperature kelvin 831 513.15 - -\n", - " pressure pascal 101325 1.0132e+05 - -\n", - " Molar Flow (mol/s) mole / second - - 239.92 239.92\n", - " Mass Flow (kg/s) kilogram / second - - 4.3223 4.3223\n", - " T (K) kelvin - - 483.86 826.10\n", - " P (Pa) pascal - - 3.4958e+07 3.4958e+07\n", - " Vapor Fraction dimensionless - - 0.0000 0.0000\n", - " Molar Enthalpy (J/mol) Vap joule / mole - - 52205. 58189.\n", - " Molar Enthalpy (J/mol) Liq joule / mole - - 16468. 58189.\n", + " Units shell Inlet shell Outlet tube Inlet tube Outlet\n", + " flow_mass kilogram / second 20.833 20.833 - -\n", + " temperature kelvin 831 513.15 - -\n", + " pressure pascal 101325 1.0132e+05 - -\n", + " Molar Flow (mol/s) mole / second - - 239.92 239.92\n", + " Mass Flow (kg/s) kilogram / second - - 4.3223 4.3223\n", + " T (K) kelvin - - 483.86 826.10\n", + " P (Pa) pascal - - 3.4958e+07 3.4958e+07\n", + " Vapor Fraction dimensionless - - 0.0000 0.0000\n", + " Molar Enthalpy (J/mol) Vap joule / mole - - 52205. 58189.\n", + " Molar Enthalpy (J/mol) Liq joule / mole - - 16468. 58189.\n", "====================================================================================\n" ] } diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/pricetaker_integrated_ultrasupercritical_power_plant.ipynb b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/pricetaker_integrated_ultrasupercritical_power_plant.ipynb index 80b45c06f..7aff8c55f 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/pricetaker_integrated_ultrasupercritical_power_plant.ipynb +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/pricetaker_integrated_ultrasupercritical_power_plant.ipynb @@ -39,7 +39,7 @@ "metadata": {}, "outputs": [], "source": [ - "from pyomo.environ import Param, Objective, Expression, SolverFactory, value\n", + "from pyomo.environ import Param, Objective, Expression, SolverFactory, value, Constraint\n", "import numpy as np\n", "from dispatches.case_studies.fossil_case.ultra_supercritical_plant.storage.\\\n", " multiperiod_integrated_storage_usc import create_multiperiod_usc_model\n", @@ -135,42 +135,505 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n", - ">>> Creating USC model and initialization for each time period\n" + "[+ 0.00] Beginning the formulation of the multiperiod optimization problem.\n", + "2022-10-28 12:21:00 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[1]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:04 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[2]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[2]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:08 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[3]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[3]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:12 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[4]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[4]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:16 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[5]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[5]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:20 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[6]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[6]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:24 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[7]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:28 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[8]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:31 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[9]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[9]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:36 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[10]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[10]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:39 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[11]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[11]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:43 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[12]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[12]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:47 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[13]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[13]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:51 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[14]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[14]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:54 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[15]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[15]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:21:59 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[16]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[16]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:03 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[17]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[17]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:06 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[18]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[18]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:10 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[19]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[19]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:15 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[20]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[20]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:18 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[21]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[21]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:22 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[22]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[22]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:26 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[23]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[23]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:31 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for period[24]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for period[24]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 94.80] Completed the formulation of the multiperiod optimization problem.\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.boiler.control_volume: Initialization Complete\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.boiler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.turbine_splitter[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.turbine_splitter[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.reheater[1].control_volume: Initialization Complete\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.reheater[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.turbine_splitter[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.turbine_splitter[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.reheater[2].control_volume: Initialization Complete\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.reheater[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:43 [INFO] idaes.init.fs.turbine_splitter[5]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:44 [INFO] idaes.init.fs.turbine_splitter[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:44 [INFO] idaes.init.fs.turbine_splitter[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:44 [INFO] idaes.init.fs.turbine_splitter[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:44 [INFO] idaes.init.fs.turbine_splitter[9]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:44 [INFO] idaes.init.fs.turbine_splitter[10]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:44 [INFO] idaes.init.fs.condenser_mix: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:44 [INFO] idaes.init.fs.condenser.control_volume: Initialization Complete\n", + "2022-10-28 12:22:44 [INFO] idaes.init.fs.condenser: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh_mixer[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[1].hot_side: Initialization Complete\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[1].cold_side: Initialization Complete\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[1]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh_mixer[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[2].hot_side: Initialization Complete\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[2].cold_side: Initialization Complete\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[2]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh_mixer[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[3].hot_side: Initialization Complete\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[3].cold_side: Initialization Complete\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[3]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh_mixer[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[4].hot_side: Initialization Complete\n", + "2022-10-28 12:22:45 [INFO] idaes.init.fs.fwh[4].cold_side: Initialization Complete\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[4]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[5].hot_side: Initialization Complete\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[5].cold_side: Initialization Complete\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[5]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.deaerator: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh_mixer[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[6].hot_side: Initialization Complete\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[6].cold_side: Initialization Complete\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[6]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh_mixer[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[7].hot_side: Initialization Complete\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[7].cold_side: Initialization Complete\n", + "2022-10-28 12:22:46 [INFO] idaes.init.fs.fwh[7]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:47 [INFO] idaes.init.fs.fwh_mixer[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:47 [INFO] idaes.init.fs.fwh[8].hot_side: Initialization Complete\n", + "2022-10-28 12:22:47 [INFO] idaes.init.fs.fwh[8].cold_side: Initialization Complete\n", + "2022-10-28 12:22:47 [INFO] idaes.init.fs.fwh[8]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:47 [INFO] idaes.init.fs.fwh[9].hot_side: Initialization Complete\n", + "2022-10-28 12:22:47 [INFO] idaes.init.fs.fwh[9].cold_side: Initialization Complete\n", + "2022-10-28 12:22:47 [INFO] idaes.init.fs.fwh[9]: Initialization Completed, optimal - Optimal Solution Found\n", + "Model Initialization = optimal\n", + "******************* USC Model Initialized ********************\n", + "2022-10-28 12:22:49 [INFO] idaes.init.fs.ess_hp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:49 [INFO] idaes.init.fs.hxc.hot_side: Initialization Complete\n", + "2022-10-28 12:22:49 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-10-28 12:22:49 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-28 12:22:49 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-10-28 12:22:49 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-28 12:22:49 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-28 12:22:49 [INFO] idaes.init.fs.hxc.cold_side: Initialization Complete\n", + "2022-10-28 12:22:50 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.hxc: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.cooler.control_volume: Initialization Complete\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.cooler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.hx_pump.control_volume: Initialization Complete\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.hx_pump: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.ess_bfp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.recycle_mixer: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-10-28 12:22:50 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_in Initialisation Step 1 Complete.\n", + "2022-10-28 12:22:50 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-28 12:22:50 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_out Initialisation Step 1 Complete.\n", + "2022-10-28 12:22:50 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-10-28 12:22:50 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.hxd.hot_side: Initialization Complete\n", + "2022-10-28 12:22:50 [INFO] idaes.init.fs.hxd.cold_side: Initialization Complete\n", + "2022-10-28 12:22:51 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-28 12:22:51 [INFO] idaes.init.fs.hxd: Initialization Completed, optimal - Optimal Solution Found\n", + "Integrated Model Initialization = optimal\n", + "*************** Integrated Model Initialized ***************\n", + "Cost Initialization = optimal\n", + "******************** Costing Initialized *************************\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyomo.core:Setting Var 'fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.0629934683431687` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[1].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 22.33] Created an instance of the flowsheet and initialized it.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyomo.core:Setting Var 'period[2].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[3].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[4].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[5].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[6].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[7].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[8].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[9].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[10].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[11].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[12].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[13].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[14].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[15].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[16].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[17].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[18].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[19].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[20].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[21].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[22].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[23].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'period[24].fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 3.42] Initialized the entire multiperiod optimization model.\n", + "[+ 0.02] Unfixed the degrees of freedom from each period model.\n" ] } ], "source": [ "# Create the multiperiod model object\n", - "multiperiod_usc = create_multiperiod_usc_model(\n", + "m = create_multiperiod_usc_model(\n", " n_time_points=n_time_points, pmin=None, pmax=None\n", ")\n", "\n", "# Retrieve pyomo model and active time blocks\n", - "m = multiperiod_usc.pyomo_model\n", - "blks = multiperiod_usc.get_active_process_blocks()" + "blks = [m.period[t] for t in m.set_period]\n", + "\n", + "# Add periodic linking constraint\n", + "m.periodic_variable_pair_costraint = Constraint(\n", + " expr=(m.period[24].fs.salt_inventory_hot ==\n", + " m.period[1].fs.previous_salt_inventory_hot))\n" ] }, { @@ -190,14 +653,13 @@ "source": [ "count = 0\n", "for blk in blks:\n", - " blk_usc_mp = blk.usc_mp\n", " blk.lmp_signal = Param(default=0, mutable=True)\n", - " blk.revenue = lmp[count]*blk.usc_mp.fs.net_power\n", + " blk.revenue = lmp[count]*blk.fs.net_power\n", " blk.operating_cost = Expression(\n", " expr=(\n", - " (blk_usc_mp.fs.operating_cost\n", - " + blk_usc_mp.fs.plant_fixed_operating_cost\n", - " + blk_usc_mp.fs.plant_variable_operating_cost) / (365 * 24)\n", + " (blk.fs.operating_cost\n", + " + blk.fs.plant_fixed_operating_cost\n", + " + blk.fs.plant_variable_operating_cost) / (365 * 24)\n", " )\n", " )\n", " blk.cost = Expression(expr=-(blk.revenue - blk.operating_cost))\n", @@ -239,19 +701,19 @@ "source": [ "# Initial state for Solar salt tank for differrent tank scenarios:\"hot_empty\",\"hot_full\",\"hot_half_full\"\n", "if tank_status == \"hot_empty\":\n", - " blks[0].usc_mp.previous_salt_inventory_hot.fix(1103053.48)\n", - " blks[0].usc_mp.previous_salt_inventory_cold.fix(tank_max-1103053.48)\n", + " blks[0].fs.previous_salt_inventory_hot.fix(1103053.48)\n", + " blks[0].fs.previous_salt_inventory_cold.fix(tank_max-1103053.48)\n", "elif tank_status == \"half_full\":\n", - " blks[0].usc_mp.previous_salt_inventory_hot.fix(tank_max/2)\n", - " blks[0].usc_mp.previous_salt_inventory_cold.fix(tank_max/2)\n", + " blks[0].fs.previous_salt_inventory_hot.fix(tank_max/2)\n", + " blks[0].fs.previous_salt_inventory_cold.fix(tank_max/2)\n", "elif tank_status == \"hot_full\":\n", - " blks[0].usc_mp.previous_salt_inventory_hot.fix(tank_max-tank_min)\n", - " blks[0].usc_mp.previous_salt_inventory_cold.fix(tank_min)\n", + " blks[0].fs.previous_salt_inventory_hot.fix(tank_max-tank_min)\n", + " blks[0].fs.previous_salt_inventory_cold.fix(tank_min)\n", "else:\n", " print(\"Unrecognized scenario! Try hot_empty, hot_full, or half_full\")\n", "\n", "# Initial state for power linking variable\n", - "blks[0].usc_mp.previous_power.fix(447.66)" + "blks[0].fs.previous_power.fix(447.66)" ] }, { @@ -305,9 +767,9 @@ "Number of nonzeros in Lagrangian Hessian.............: 11880\n", "\n", "Total number of variables............................: 14685\n", - " variables with only lower bounds: 0\n", - " variables with lower and upper bounds: 11997\n", - " variables with only upper bounds: 24\n", + " variables with only lower bounds: 144\n", + " variables with lower and upper bounds: 10053\n", + " variables with only upper bounds: 0\n", "Total number of equality constraints.................: 14567\n", "Total number of inequality constraints...............: 168\n", " inequality constraints with only lower bounds: 24\n", @@ -315,156 +777,71 @@ " inequality constraints with only upper bounds: 144\n", "\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 0 -3.6195143e+05 3.34e+08 1.00e+02 -1.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", - " 1 -3.7026756e+05 3.46e+08 1.25e+06 -1.0 4.01e+07 - 1.25e-06 9.48e-01f 1\n", - " 2 -3.7025319e+05 3.45e+08 1.24e+06 -1.0 7.47e+07 - 9.36e-05 1.65e-03h 1\n", - " 3 -3.7023560e+05 3.44e+08 1.24e+06 -1.0 4.95e+07 - 2.26e-04 1.94e-03h 1\n", - " 4 -3.6961337e+05 3.30e+08 1.16e+06 -1.0 4.62e+07 - 2.36e-04 6.82e-02h 1\n", - " 5 -3.6957659e+05 3.29e+08 1.15e+06 -1.0 3.90e+07 - 7.22e-04 4.11e-03h 1\n", - " 6 -3.6183421e+05 4.56e+08 9.37e+04 -1.0 3.69e+07 - 7.23e-05 8.66e-01h 1\n", - " 7 -3.6136822e+05 3.19e+08 6.57e+04 -1.0 4.23e+06 - 8.26e-03 3.00e-01h 1\n", - " 8 -3.6022203e+05 9.52e+06 1.19e+04 -1.0 2.83e+06 - 1.48e-02 1.00e+00h 1\n", - " 9 -3.6015086e+05 3.53e+05 3.85e+02 -1.0 8.53e+05 - 7.40e-01 1.00e+00h 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 10 -3.6027717e+05 4.42e+02 1.21e+01 -1.0 2.00e+05 - 9.12e-01 1.00e+00f 1\n", - " 11 -3.6177457e+05 1.30e+03 2.34e+00 -1.0 2.18e+06 - 2.70e-01 1.00e+00f 1\n", - " 12 -3.6383428e+05 2.44e+03 3.85e-01 -1.0 3.00e+06 - 6.01e-01 1.00e+00f 1\n", - " 13 -3.6905559e+05 1.56e+04 6.76e-01 -1.0 7.60e+06 - 4.55e-01 1.00e+00f 1\n", - " 14 -3.7885905e+05 5.37e+04 1.12e+00 -1.0 1.43e+07 - 5.19e-01 1.00e+00f 1\n", - " 15 -4.0022144e+05 2.46e+05 2.43e+00 -1.0 3.12e+07 - 5.86e-01 1.00e+00f 1\n", - " 16 -4.1081688e+05 2.57e+05 3.19e+00 -1.0 8.53e+07 - 5.45e-01 1.82e-01f 1\n", - " 17 -4.1094134e+05 2.57e+05 1.42e+01 -1.0 2.02e+08 - 4.93e-01 9.95e-04f 1\n", - " 18 -4.1119824e+05 2.43e+05 3.05e+01 -1.0 2.79e+07 - 2.78e-01 5.44e-02f 1\n", - " 19 -4.1251280e+05 1.61e+05 1.97e+01 -1.0 3.80e+07 - 3.24e-01 3.35e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 20 -4.1810215e+05 7.56e+05 2.67e+01 -1.0 5.42e+07 - 3.71e-01 1.00e+00f 1\n", - " 21 -4.1966467e+05 6.78e+05 8.99e+00 -1.0 7.66e+07 - 6.63e-01 1.86e-01f 1\n", - " 22 -4.1982865e+05 6.73e+05 9.09e+00 -1.0 1.95e+08 - 3.42e-01 7.92e-03f 1\n", - " 23 -4.2176974e+05 7.08e+05 2.09e+01 -1.0 3.74e+08 - 3.47e-01 6.71e-02f 1\n", - " 24 -4.2325496e+05 7.21e+05 1.95e+01 -1.0 5.47e+08 - 1.32e-01 3.82e-02f 1\n", - " 25 -4.2476372e+05 7.44e+05 1.72e+01 -1.0 4.52e+08 - 1.46e-01 4.16e-02f 1\n", - " 26 -4.2605895e+05 7.61e+05 2.34e+01 -1.0 4.50e+08 - 2.66e-01 3.66e-02f 1\n", - " 27 -4.2849793e+05 9.79e+05 2.19e+01 -1.0 3.32e+08 - 2.10e-02 7.40e-02f 1\n", - " 28 -4.2939062e+05 1.05e+06 2.14e+01 -1.0 2.39e+08 - 2.26e-02 3.17e-02f 1\n", - " 29 -4.2960216e+05 1.05e+06 2.12e+01 -1.0 2.35e+08 - 9.25e-03 1.30e-02f 1\n", + " 0 -3.7484174e+05 2.83e+08 1.00e+02 -1.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", + " 1 -3.7398759e+05 9.17e+07 2.36e+04 -1.0 5.31e+06 - 2.10e-01 1.00e+00h 1\n", + " 2 -3.6768264e+05 1.70e+07 6.36e+02 -1.0 1.05e+07 - 8.29e-01 1.00e+00H 1\n", + " 3 -3.7083347e+05 1.66e+06 7.72e+02 -1.0 3.42e+06 - 8.97e-01 1.00e+00f 1\n", + " 4 -3.9294910e+05 5.79e+05 2.80e+02 -1.0 3.61e+07 - 5.25e-01 6.53e-01f 1\n", + " 5 -3.9354218e+05 5.73e+05 2.77e+02 -1.0 6.16e+07 - 7.50e-01 1.07e-02f 1\n", + " 6 -4.2233025e+05 6.15e+05 9.12e+01 -1.0 2.63e+08 - 4.85e-01 1.54e-01f 1\n", + " 7 -4.2267571e+05 6.14e+05 9.11e+01 -1.0 3.11e+08 - 1.51e-01 1.79e-03f 1\n", + " 8 -4.2431513e+05 5.55e+05 8.24e+01 -1.0 6.85e+07 - 2.84e-01 9.59e-02f 1\n", + " 9 -4.2601993e+05 5.02e+05 7.46e+01 -1.0 6.43e+07 - 3.00e-01 9.45e-02f 1\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 30 -4.3233755e+05 3.86e+06 1.68e+01 -1.0 2.36e+08 - 2.05e-01 1.71e-01f 1\n", - " 31 -4.3245657e+05 3.84e+06 1.38e+01 -1.0 2.39e+08 - 1.57e-01 7.67e-03f 1\n", - " 32 -4.3339951e+05 4.04e+06 9.05e+00 -1.0 1.85e+08 - 5.32e-01 6.01e-02f 1\n", - " 33 -4.3702388e+05 1.04e+07 7.45e+00 -1.0 8.82e+07 - 5.42e-01 2.06e-01f 1\n", - " 34 -4.5216928e+05 9.77e+07 3.02e+00 -1.0 7.08e+07 - 6.95e-01 9.48e-01f 1\n", - " 35 -4.5420008e+05 3.17e+07 3.29e+00 -1.0 4.62e+07 - 7.51e-01 7.55e-01f 1\n", - " 36 -4.5422349e+05 3.05e+07 5.02e+00 -1.0 5.57e+07 - 4.08e-01 3.84e-02h 1\n", - " 37 -4.5428523e+05 2.72e+07 6.68e+00 -1.0 1.20e+08 - 4.33e-01 1.14e-01h 1\n", - " 38 -4.5436396e+05 2.28e+07 6.54e+00 -1.0 1.61e+08 - 4.84e-01 1.64e-01h 1\n", - " 39 -4.5445361e+05 1.67e+07 5.42e+00 -1.0 9.24e+07 - 6.97e-01 2.57e-01h 1\n", + " 10 -4.2710321e+05 4.48e+05 6.65e+01 -1.0 7.41e+07 - 5.61e-01 1.09e-01f 1\n", + " 11 -4.2965855e+05 3.77e+05 5.64e+01 -1.0 1.49e+08 - 5.09e-01 1.54e-01f 1\n", + " 12 -4.3295879e+05 4.12e+05 4.93e+01 -1.0 2.54e+08 - 6.40e-01 1.28e-01f 1\n", + " 13 -4.3415151e+05 4.16e+05 4.82e+01 -1.0 7.46e+08 - 8.47e-02 2.25e-02f 1\n", + " 14 -4.3609164e+05 4.46e+05 4.62e+01 -1.0 4.74e+08 - 1.61e-01 4.21e-02f 1\n", + " 15 -4.3838276e+05 5.72e+05 4.40e+01 -1.0 4.60e+08 - 3.18e-01 4.96e-02f 1\n", + " 16 -4.4061801e+05 6.79e+05 4.22e+01 -1.0 4.81e+08 - 3.36e-01 4.17e-02f 1\n", + " 17 -4.4523398e+05 3.04e+06 3.94e+01 -1.0 4.38e+08 - 1.94e-01 7.87e-02f 1\n", + " 18 -4.4649611e+05 3.43e+06 3.82e+01 -1.0 1.40e+08 - 2.92e-03 3.14e-02f 1\n", + " 19 -4.4768178e+05 3.73e+06 3.71e+01 -1.0 4.71e+08 - 9.41e-02 2.97e-02f 1\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 40 -4.5449047e+05 1.28e+07 4.51e+00 -1.0 2.61e+07 - 9.01e-01 2.29e-01h 1\n", - " 41 -4.5448693e+05 1.23e+07 4.38e+03 -1.0 3.09e+05 -4.0 2.83e-02 3.98e-02h 1\n", - " 42 -4.5448689e+05 1.23e+07 4.37e+03 -1.0 2.96e+05 -4.5 1.39e-01 4.11e-04h 1\n", - " 43 -4.5448689e+05 1.23e+07 8.03e+06 -1.0 1.12e+06 -5.0 1.05e-01 3.60e-05h 1\n", - " 44 -4.5448656e+05 1.22e+07 1.31e+07 -1.0 1.26e+06 -5.4 2.48e-01 3.43e-03h 1\n", - " 45 -4.5448532e+05 1.21e+07 1.28e+07 -1.0 1.34e+06 -5.9 8.16e-02 9.55e-03h 1\n", - " 46 -4.5447754e+05 1.15e+07 9.93e+06 -1.0 1.33e+06 -6.4 2.87e-01 5.11e-02h 1\n", - " 47 -4.5447672e+05 1.14e+07 8.67e+06 -1.0 1.29e+06 -6.9 1.38e-01 5.58e-03h 1\n", - " 48 -4.5447277e+05 1.11e+07 3.32e+06 -1.0 1.29e+06 -7.3 6.21e-01 2.52e-02h 1\n", - " 49 -4.5443704e+05 8.58e+06 2.88e+06 -1.0 1.27e+06 -7.8 1.38e-01 2.27e-01h 1\n", + " 20 -4.5076845e+05 6.17e+06 3.47e+01 -1.0 4.26e+08 - 8.36e-03 7.72e-02f 1\n", + " 21 -4.5123435e+05 6.15e+06 3.43e+01 -1.0 5.40e+08 - 7.61e-03 1.24e-02f 1\n", + " 22 -4.5425817e+05 8.22e+06 3.19e+01 -1.0 5.36e+08 - 9.19e-02 8.16e-02f 1\n", + " 23 -4.5467634e+05 8.17e+06 3.15e+01 -1.0 1.20e+08 - 4.59e-01 1.35e-02f 1\n", + " 24 -4.7432263e+05 1.49e+08 3.24e+01 -1.0 1.13e+08 - 4.95e-01 6.74e-01f 1\n", + " 25 -4.7641571e+05 3.45e+07 8.06e+00 -1.0 1.87e+07 - 8.78e-01 7.52e-01f 1\n", + " 26 -4.7821359e+05 2.06e+07 1.28e+01 -1.0 4.37e+07 - 4.61e-01 9.77e-01f 1\n", + " 27 -4.7840008e+05 1.06e+07 1.28e+00 -1.0 1.48e+07 - 9.20e-01 1.00e+00h 1\n", + " 28 -4.7847555e+05 8.52e+06 1.21e-01 -1.0 1.46e+07 - 9.99e-01 1.00e+00h 1\n", + " 29 -4.7848089e+05 3.65e+06 1.56e-02 -1.0 6.36e+06 - 1.00e+00 1.00e+00h 1\n", "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 50 -4.5433013e+05 8.46e+05 1.47e+06 -1.0 1.08e+06 -8.3 5.20e-01 8.80e-01h 1\n", - " 51 -4.5432975e+05 7.92e+05 8.29e+04 -1.0 2.97e+05 -8.8 9.93e-01 6.45e-02h 1\n", - " 52 -4.5434596e+05 3.95e+05 4.76e+04 -1.0 2.77e+05 -9.2 1.00e+00 5.02e-01h 1\n", - " 53 -4.5436542e+05 3.18e+05 3.94e+04 -1.0 1.39e+05 -9.7 1.00e+00 1.94e-01h 1\n", - " 54 -4.5437694e+05 1.30e+03 5.84e+02 -1.0 1.13e+05 -10.2 1.00e+00 1.00e+00h 1\n", - " 55 -4.5441945e+05 6.52e+02 2.29e+02 -1.0 2.13e+05 -10.7 1.00e+00 6.08e-01f 1\n", - " 56 -4.5447296e+05 7.47e+02 1.50e+02 -1.0 5.26e+05 -11.2 1.00e+00 3.47e-01f 1\n", - " 57 -4.5449740e+05 1.00e+03 1.14e+02 -1.0 6.68e+05 -11.6 1.00e+00 2.39e-01f 1\n", - " 58 -4.5450659e+05 3.20e+04 4.28e+01 -1.0 1.05e+06 -12.1 1.00e+00 6.25e-01h 1\n", - " 59 -4.5451163e+05 5.39e+04 3.00e+01 -1.0 2.13e+06 -12.6 1.00e+00 3.02e-01h 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 60 -4.5452071e+05 2.94e+04 4.37e-01 -1.0 1.14e+06 -13.1 1.00e+00 1.00e+00h 1\n", - " 61 -4.5454348e+05 2.11e+05 4.06e-02 -1.0 3.06e+06 -13.5 1.00e+00 1.00e+00h 1\n", - " 62 -4.5456536e+05 3.25e+05 1.22e+00 -1.0 5.87e+06 -14.0 1.00e+00 5.03e-01h 1\n", - " 63 -4.5457458e+05 1.38e+06 1.27e+00 -1.0 1.59e+07 -14.5 1.00e+00 5.43e-01h 1\n", - " 64 -4.5458411e+05 5.28e+06 3.73e-01 -1.0 2.47e+07 -15.0 1.00e+00 9.05e-01h 1\n", - " 65 -4.5458287e+05 2.50e+06 7.68e-02 -1.0 1.24e+07 -15.5 1.00e+00 1.00e+00h 1\n", - " 66 -4.5458556e+05 2.39e+05 1.70e-02 -1.0 3.73e+06 -15.0 1.00e+00 1.00e+00h 1\n", - " 67 -4.5459207e+05 1.42e+07 2.01e+00 -1.0 4.17e+07 -15.5 1.00e+00 1.00e+00H 1\n", - " 68 -4.5459536e+05 8.22e+06 6.16e-01 -1.0 2.19e+07 -15.1 1.00e+00 1.00e+00h 1\n", - " 69 -4.5459781e+05 1.76e+05 1.16e-01 -1.0 8.15e+06 -14.7 1.00e+00 1.00e+00h 1\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 70 -4.5459986e+05 8.63e+05 2.62e-01 -1.0 2.24e+07 -15.1 1.00e+00 4.00e-01h 1\n", - " 71 -4.5459964e+05 1.72e+05 3.58e-02 -1.0 3.94e+06 -14.7 1.00e+00 1.00e+00h 1\n", - " 72 -4.5460169e+05 3.55e+06 3.98e-01 -1.0 1.75e+07 -15.2 1.00e+00 1.00e+00h 1\n", - " 73 -4.5460339e+05 3.64e+05 7.96e-02 -1.0 7.50e+06 -14.8 1.00e+00 1.00e+00h 1\n", - " 74 -4.5460864e+05 1.12e+07 1.38e+00 -1.0 3.74e+07 -15.2 1.00e+00 8.51e-01h 1\n", - " 75 -4.5460624e+05 4.80e+06 6.25e-01 -1.0 1.92e+07 - 1.00e+00 1.00e+00h 1\n", - " 76 -4.5460938e+05 1.81e+06 1.95e-01 -1.0 1.10e+07 - 1.00e+00 1.00e+00h 1\n", - " 77 -4.5460958e+05 8.58e+04 2.33e-02 -1.0 4.17e+06 - 1.00e+00 1.00e+00h 1\n", - " 78 -4.5460960e+05 6.07e+02 8.30e-05 -1.0 2.43e+05 - 1.00e+00 1.00e+00h 1\n", - " 79 -4.5462293e+05 1.01e+05 1.85e+01 -2.5 3.69e+06 - 9.72e-01 5.41e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 80 -4.5462888e+05 5.24e+04 6.09e+00 -2.5 1.29e+06 -14.8 1.00e+00 6.91e-01h 1\n", - " 81 -4.5463144e+05 2.75e+06 2.30e-01 -2.5 1.43e+07 -15.3 1.00e+00 9.86e-01h 1\n", - " 82 -4.5463183e+05 5.06e+05 1.52e-02 -2.5 4.03e+06 -14.9 1.00e+00 1.00e+00h 1\n", - " 83 -4.5463266e+05 4.99e+06 3.33e-01 -2.5 1.24e+08 -15.3 2.60e-01 1.39e-01h 1\n", - " 84 -4.5463404e+05 1.67e+06 1.68e-01 -2.5 1.15e+07 -14.9 1.00e+00 8.68e-01h 1\n", - " 85 -4.5463454e+05 2.41e+05 4.24e-02 -2.5 3.17e+06 -14.5 1.00e+00 8.58e-01h 1\n", - " 86 -4.5463568e+05 1.53e+06 1.50e-01 -2.5 1.42e+07 -15.0 1.00e+00 7.70e-01h 1\n", - " 87 -4.5463672e+05 6.25e+05 3.88e-02 -2.5 5.53e+06 -14.5 1.00e+00 1.00e+00h 1\n", - " 88 -4.5463780e+05 1.29e+06 1.86e-01 -2.5 2.58e+07 -15.0 1.00e+00 2.56e-01h 1\n", - " 89 -4.5463786e+05 3.26e+05 4.34e-02 -2.5 6.68e+05 - 1.00e+00 7.24e-01h 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 90 -4.5463797e+05 1.67e+04 2.38e-03 -2.5 4.70e+05 - 1.00e+00 1.00e+00h 1\n", - " 91 -4.5463797e+05 6.73e-01 1.73e-06 -2.5 1.11e+03 - 1.00e+00 1.00e+00h 1\n", - " 92 -4.5463850e+05 3.15e+01 4.15e-02 -3.8 4.36e+04 - 1.00e+00 9.65e-01f 1\n", - " 93 -4.5463851e+05 1.51e+00 3.39e-07 -3.8 1.19e+04 - 1.00e+00 1.00e+00h 1\n", - " 94 -4.5463854e+05 7.42e-02 7.69e-08 -5.7 2.39e+03 - 1.00e+00 1.00e+00h 1\n", - " 95 -4.5463854e+05 1.06e-05 1.84e-11 -5.7 3.08e+01 - 1.00e+00 1.00e+00h 1\n", - " 96 -4.5463854e+05 1.11e-05 1.22e-11 -8.6 2.96e+01 - 1.00e+00 1.00e+00h 1\n", - " 97 -4.5463854e+05 9.54e-07 7.69e-13 -9.0 2.81e-02 - 1.00e+00 1.00e+00h 1\n", - " 98 -4.5463854e+05 4.77e-07 9.03e-13 -9.0 6.97e-06 - 1.00e+00 1.00e+00h 1\n", - " 99 -4.5463854e+05 9.54e-07 1.16e-12 -9.0 6.42e-06 - 1.00e+00 1.00e+00h 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 100 -4.5463854e+05 9.54e-07 1.00e-12 -9.0 4.75e-06 - 1.00e+00 1.00e+00H 1\n", - " 101 -4.5463854e+05 4.77e-07 1.12e-12 -9.0 4.91e-06 - 1.00e+00 2.50e-01h 3\n", - " 102 -4.5463854e+05 4.77e-07 8.62e-13 -9.0 4.54e-06 - 1.00e+00 1.56e-02h 7\n", - " 103 -4.5463854e+05 4.77e-07 8.16e-13 -9.0 4.71e-06 - 1.00e+00 1.00e+00h 1\n", - " 104 -4.5463854e+05 1.43e-06 1.32e-12 -9.0 4.69e-06 - 1.00e+00 1.00e+00h 1\n", - " 105 -4.5463854e+05 7.15e-07 1.32e-12 -9.0 6.95e-06 - 1.00e+00 2.50e-01h 3\n", - " 106 -4.5463854e+05 7.15e-07 1.32e-12 -9.0 4.64e-06 - 1.00e+00 1.56e-02h 7\n", - " 107 -4.5463854e+05 5.07e-07 1.32e-12 -9.0 4.41e-06 - 1.00e+00 3.12e-02h 6\n", - " 108 -4.5463854e+05 5.07e-07 1.32e-12 -9.0 3.54e-06 - 1.00e+00 2.44e-04h 13\n", - " 109 -4.5463854e+05 5.07e-07 1.32e-12 -9.0 3.54e-06 - 1.00e+00 1.22e-04h 14\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 110 -4.5463854e+05 4.77e-07 8.50e-13 -9.0 3.54e-06 - 1.00e+00 1.00e+00h 1\n", + " 30 -4.7848126e+05 4.56e+05 5.57e-04 -1.0 1.49e+06 - 1.00e+00 1.00e+00h 1\n", + " 31 -4.7848129e+05 7.15e+03 7.19e-06 -1.0 1.63e+05 - 1.00e+00 1.00e+00h 1\n", + " 32 -4.7849224e+05 1.20e+05 3.33e+00 -1.7 1.39e+06 - 1.00e+00 9.09e-01f 1\n", + " 33 -4.7849311e+05 1.04e+03 3.44e-04 -1.7 1.85e+05 - 1.00e+00 1.00e+00h 1\n", + " 34 -4.7849561e+05 2.72e+03 7.61e-04 -2.5 1.82e+05 - 1.00e+00 1.00e+00f 1\n", + " 35 -4.7849560e+05 6.30e+00 3.38e-08 -2.5 1.01e+04 - 1.00e+00 1.00e+00h 1\n", + " 36 -4.7849598e+05 4.94e+01 1.57e-05 -3.8 2.44e+04 - 1.00e+00 1.00e+00f 1\n", + " 37 -4.7849598e+05 3.14e-03 1.50e-09 -3.8 2.20e+02 - 1.00e+00 1.00e+00h 1\n", + " 38 -4.7849600e+05 1.47e-01 4.74e-08 -5.7 1.33e+03 - 1.00e+00 1.00e+00f 1\n", + " 39 -4.7849600e+05 2.09e-05 6.96e-12 -8.6 1.58e+01 - 1.00e+00 1.00e+00h 1\n", "\n", - "Number of Iterations....: 110\n", + "Number of Iterations....: 39\n", "\n", " (scaled) (unscaled)\n", - "Objective...............: -2.2731927239529302e+05 -4.5463854479058605e+05\n", - "Dual infeasibility......: 8.4954444442330601e-13 1.6990888888466120e-12\n", - "Constraint violation....: 2.1287373134068081e-08 4.7683715820312500e-07\n", - "Complementarity.........: 9.1066538784262700e-10 1.8213307756852540e-09\n", - "Overall NLP error.......: 2.1287373134068081e-08 4.7683715820312500e-07\n", + "Objective...............: -2.3924800234502272e+05 -4.7849600469004543e+05\n", + "Dual infeasibility......: 6.9581892714587593e-12 1.3916378542917519e-11\n", + "Constraint violation....: 3.7252902984619141e-09 2.0906329154968262e-05\n", + "Complementarity.........: 2.5088482622969778e-09 5.0176965245939555e-09\n", + "Overall NLP error.......: 3.7252902984619141e-09 2.0906329154968262e-05\n", "\n", "\n", - "Number of objective function evaluations = 162\n", - "Number of objective gradient evaluations = 111\n", - "Number of equality constraint evaluations = 162\n", - "Number of inequality constraint evaluations = 162\n", - "Number of equality constraint Jacobian evaluations = 111\n", - "Number of inequality constraint Jacobian evaluations = 111\n", - "Number of Lagrangian Hessian evaluations = 110\n", - "Total CPU secs in IPOPT (w/o function evaluations) = 9.717\n", - "Total CPU secs in NLP function evaluations = 314.856\n", + "Number of objective function evaluations = 41\n", + "Number of objective gradient evaluations = 40\n", + "Number of equality constraint evaluations = 41\n", + "Number of inequality constraint evaluations = 41\n", + "Number of equality constraint Jacobian evaluations = 40\n", + "Number of inequality constraint Jacobian evaluations = 40\n", + "Number of Lagrangian Hessian evaluations = 39\n", + "Total CPU secs in IPOPT (w/o function evaluations) = 1.846\n", + "Total CPU secs in NLP function evaluations = 91.459\n", "\n", - "EXIT: Solved To Acceptable Level.\n" + "EXIT: Optimal Solution Found.\n" ] } ], @@ -486,15 +863,15 @@ " # Solve the multi-period model\n", " opt.solve(m, tee=True)\n", "\n", - " hot_tank_level.append([(value(blks[i].usc_mp.salt_inventory_hot)) * 1e-3\n", + " hot_tank_level.append([(value(blks[i].fs.salt_inventory_hot)) * 1e-3\n", " for i in range(n_time_points)])\n", - " cold_tank_level.append([(value(blks[i].usc_mp.salt_inventory_cold)) * 1e-3\n", + " cold_tank_level.append([(value(blks[i].fs.salt_inventory_cold)) * 1e-3\n", " for i in range(n_time_points)])\n", - " net_power.append([value(blks[i].usc_mp.fs.net_power)\n", + " net_power.append([value(blks[i].fs.net_power)\n", " for i in range(n_time_points)])\n", - " hxc_duty.append([value(blks[i].usc_mp.fs.hxc.heat_duty[0]) * 1e-6\n", + " hxc_duty.append([value(blks[i].fs.hxc.heat_duty[0]) * 1e-6\n", " for i in range(n_time_points)])\n", - " hxd_duty.append([value(blks[i].usc_mp.fs.hxd.heat_duty[0]) * 1e-6\n", + " hxd_duty.append([value(blks[i].fs.hxd.heat_duty[0]) * 1e-6\n", " for i in range(n_time_points)])" ] }, @@ -544,7 +921,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -562,8 +939,8 @@ "cold_tank_array = np.asarray(cold_tank_level[0:nweeks]).flatten()\n", "\n", "# Convert array to list to include hot tank level at time zero\n", - "hot_tank_array0 = value(blks[0].usc_mp.previous_salt_inventory_hot) * 1e-3\n", - "cold_tank_array0 = value(blks[0].usc_mp.previous_salt_inventory_cold) * 1e-3\n", + "hot_tank_array0 = value(blks[0].fs.previous_salt_inventory_hot) * 1e-3\n", + "cold_tank_array0 = value(blks[0].fs.previous_salt_inventory_cold) * 1e-3\n", "hours_list = hours.tolist() + [n_time_points]\n", "hot_tank_list = [hot_tank_array0] + hot_tank_array.tolist()\n", "cold_tank_list = [cold_tank_array0] + cold_tank_array.tolist()\n", @@ -631,7 +1008,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -649,7 +1026,7 @@ "power_array = np.asarray(net_power[0:nweeks]).flatten()\n", "\n", "# Convert array to list to include net power at time zero\n", - "power_array0 = value(blks[0].usc_mp.previous_power)\n", + "power_array0 = value(blks[0].fs.previous_power)\n", "power_list = [power_array0] + power_array.tolist()\n", "\n", "fig2, ax3 = plt.subplots(figsize=(12, 8))\n", @@ -663,15 +1040,9 @@ "plt.text(n_time_points / 2 - 3, max_power - 5.5,\n", " 'max plant power',\n", " color=color[4])\n", - "plt.text(n_time_points / 2 - 2.8, max_power_total + 1,\n", - " 'max net power',\n", - " color=color[4])\n", "plt.axhline(max_power, \n", " ls='-.', lw=1.75, \n", " color=color[4])\n", - "plt.axhline(max_power_total, \n", - " ls=':', lw=1.75, \n", - " color=color[4])\n", "ax3.step(hours_list, power_list,\n", " marker='o', ms=4,\n", " lw=1, color=color[1])\n", @@ -710,7 +1081,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -800,7 +1171,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.5" + "version": "3.9.12" }, "vscode": { "interpreter": { diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/pricetaker_with_multiperiod_integrated_storage_usc.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/pricetaker_with_multiperiod_integrated_storage_usc.py index bd02918d0..2358e369a 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/pricetaker_with_multiperiod_integrated_storage_usc.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/pricetaker_with_multiperiod_integrated_storage_usc.py @@ -24,7 +24,8 @@ __author__ = "Naresh Susarla and Soraya Rawlings" -from pyomo.environ import Param, Objective, Expression, SolverFactory, value +from pyomo.environ import (Param, Objective, + Expression, SolverFactory, value, Constraint) import numpy as np from dispatches.case_studies.fossil_case.ultra_supercritical_plant.storage.\ multiperiod_integrated_storage_usc import create_multiperiod_usc_model @@ -49,11 +50,11 @@ def _get_lmp(number_hours): price = np.load(f) elif use_mod_rts_data: price = [22.9684, 21.1168, 20.4, 20.419, - 20.419, 21.2877, 23.07, 25, - 18.4634, 0, 0, 0, - 0, 0, 0, 0, - 19.0342, 23.07, 200, 200, - 200, 200, 200, 200] + 20.419, 21.2877, 23.07, 25, + 18.4634, 0, 0, 0, + 0, 0, 0, 0, + 19.0342, 23.07, 200, 200, + 200, 200, 200, 200] else: print('>>>>>> Using NREL lmp data') price = np.load("nrel_scenario_average_hourly.npy") @@ -78,25 +79,27 @@ def run_pricetaker_analysis(ndays, nweeks, tank_status, tank_min, tank_max): # "process_model_func" for each time period using a dict of dicts as # shown here. In this case, it is setting up empty dictionaries for # each time period. - multiperiod_usc = create_multiperiod_usc_model( + m = create_multiperiod_usc_model( n_time_points=n_time_points, pmin=None, pmax=None ) - # Retrieve pyomo model and active process blocks (i.e. time blocks) - m = multiperiod_usc.pyomo_model - blks = multiperiod_usc.get_active_process_blocks() + # Retrieve active process blocks (i.e. time blocks) + blks = [m.period[t] for t in m.set_period] + + m.periodic_variable_pair_costraint = Constraint( + expr=(m.period[24].fs.salt_inventory_hot == + m.period[1].fs.previous_salt_inventory_hot)) # Add lmp market data for each block count = 0 for blk in blks: - blk_usc_mp = blk.usc_mp blk.lmp_signal = Param(default=0, mutable=True) - blk.revenue = lmp[count]*blk.usc_mp.fs.net_power * scaling_factor + blk.revenue = lmp[count]*blk.fs.net_power * scaling_factor blk.operating_cost = Expression( expr=( - (blk_usc_mp.fs.operating_cost - + blk_usc_mp.fs.plant_fixed_operating_cost - + blk_usc_mp.fs.plant_variable_operating_cost) / (365 * 24) + (blk.fs.operating_cost + + blk.fs.plant_fixed_operating_cost + + blk.fs.plant_variable_operating_cost) / (365 * 24) ) * scaling_factor ) blk.cost = Expression(expr=-(blk.revenue - blk.operating_cost)) @@ -107,18 +110,18 @@ def run_pricetaker_analysis(ndays, nweeks, tank_status, tank_min, tank_max): # Initial state for salt tank for different scenarios # Tank initial scenarios:"hot_empty","hot_full","hot_half_full" if tank_status == "hot_empty": - blks[0].usc_mp.previous_salt_inventory_hot.fix(1103053.48) - blks[0].usc_mp.previous_salt_inventory_cold.fix(tank_max-1103053.48) + blks[0].fs.previous_salt_inventory_hot.fix(1103053.48) + blks[0].fs.previous_salt_inventory_cold.fix(tank_max-1103053.48) elif tank_status == "half_full": - blks[0].usc_mp.previous_salt_inventory_hot.fix(tank_max/2) - blks[0].usc_mp.previous_salt_inventory_cold.fix(tank_max/2) + blks[0].fs.previous_salt_inventory_hot.fix(tank_max/2) + blks[0].fs.previous_salt_inventory_cold.fix(tank_max/2) elif tank_status == "hot_full": - blks[0].usc_mp.previous_salt_inventory_hot.fix(tank_max-tank_min) - blks[0].usc_mp.previous_salt_inventory_cold.fix(tank_min) + blks[0].fs.previous_salt_inventory_hot.fix(tank_max-tank_min) + blks[0].fs.previous_salt_inventory_cold.fix(tank_min) else: print("Unrecognized scenario! Try hot_empty, hot_full, or half_full") - blks[0].usc_mp.previous_power.fix(447.66) + blks[0].fs.previous_power.fix(447.66) # Plot results opt = SolverFactory('ipopt') @@ -135,19 +138,19 @@ def run_pricetaker_analysis(ndays, nweeks, tank_status, tank_min, tank_max): opt.solve(m, tee=True) hot_tank_level.append( - [(value(blks[i].usc_mp.salt_inventory_hot) / scaling_factor)*1e-3 + [(value(blks[i].fs.salt_inventory_hot) / scaling_factor)*1e-3 for i in range(n_time_points)]) cold_tank_level.append( - [(value(blks[i].usc_mp.salt_inventory_cold) / scaling_factor)*1e-3 + [(value(blks[i].fs.salt_inventory_cold) / scaling_factor)*1e-3 for i in range(n_time_points)]) net_power.append( - [value(blks[i].usc_mp.fs.net_power) + [value(blks[i].fs.net_power) for i in range(n_time_points)]) hxc_duty.append( - [value(blks[i].usc_mp.fs.hxc.heat_duty[0])*1e-6 + [value(blks[i].fs.hxc.heat_duty[0])*1e-6 for i in range(n_time_points)]) hxd_duty.append( - [value(blks[i].usc_mp.fs.hxd.heat_duty[0])*1e-6 + [value(blks[i].fs.hxd.heat_duty[0])*1e-6 for i in range(n_time_points)]) return (lmp, m, blks, hot_tank_level, cold_tank_level, @@ -161,13 +164,13 @@ def print_results(m, blks): print() print('Period {}'.format(c+1)) print(' Net power: {:.4f}'.format( - value(blks[c].usc_mp.fs.net_power))) + value(blks[c].fs.net_power))) print(' Plant Power Out: {:.4f}'.format( - value(blks[c].usc_mp.fs.plant_power_out[0]))) + value(blks[c].fs.plant_power_out[0]))) print(' ES Turbine Power: {:.4f}'.format( - value(blks[c].usc_mp.fs.es_turbine.work_mechanical[0])*(-1e-6))) + value(blks[c].fs.es_turbine.work_mechanical[0])*(-1e-6))) print(' Plant heat duty: {:.4f}'.format( - value(blks[c].usc_mp.fs.plant_heat_duty[0]))) + value(blks[c].fs.plant_heat_duty[0]))) print(' Cost ($): {:.4f}'.format(value(blks[c].cost) / scaling_factor)) print(' Revenue ($): {:.4f}' .format(value(blks[c].revenue) / scaling_factor)) @@ -175,46 +178,46 @@ def print_results(m, blks): .format(value(blks[c].operating_cost) / scaling_factor)) print(' Specific Operating cost ($/MWh): {:.4f}'.format( (value(blks[c].operating_cost) / scaling_factor) / - value(blks[c].usc_mp.fs.net_power))) + value(blks[c].fs.net_power))) print(' Cycle efficiency (%): {:.4f}'.format( - value(blks[c].usc_mp.fs.cycle_efficiency))) + value(blks[c].fs.cycle_efficiency))) print(' Boiler efficiency (%): {:.4f}'.format( - value(blks[c].usc_mp.fs.boiler_eff) * 100)) + value(blks[c].fs.boiler_eff) * 100)) print(' Boiler heat duty: {:.4f}'.format( - value(blks[c].usc_mp.fs.boiler.heat_duty[0]) * 1e-6)) + value(blks[c].fs.boiler.heat_duty[0]) * 1e-6)) print(' Boiler flow mol (mol/s): {:.4f}'.format( - value(blks[c].usc_mp.fs.boiler.outlet.flow_mol[0]))) + value(blks[c].fs.boiler.outlet.flow_mol[0]))) print(' Previous salt inventory (mton): {:.4f}'.format( - (value(blks[c].usc_mp.previous_salt_inventory_hot) / + (value(blks[c].fs.previous_salt_inventory_hot) / scaling_factor) * 1e-3)) print(' Salt from HXC (mton): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxc.tube_outlet.flow_mass[0]) * 3600 * 1e-3)) + value(blks[c].fs.hxc.tube_outlet.flow_mass[0]) * 3600 * 1e-3)) print(' Salt from HXD (mton): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxd.shell_outlet.flow_mass[0]) * 3600 * 1e-3)) + value(blks[c].fs.hxd.shell_outlet.flow_mass[0]) * 3600 * 1e-3)) print(' HXC Duty (MW): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxc.heat_duty[0]) * 1e-6)) + value(blks[c].fs.hxc.heat_duty[0]) * 1e-6)) print(' HXD Duty (MW): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxd.heat_duty[0]) * 1e-6)) + value(blks[c].fs.hxd.heat_duty[0]) * 1e-6)) print(' Split fraction to HXC: {:.4f}'.format( - value(blks[c].usc_mp.fs.ess_hp_split.split_fraction[0, "to_hxc"]))) + value(blks[c].fs.ess_hp_split.split_fraction[0, "to_hxc"]))) print(' Split fraction to HXD: {:.4f}'.format( - value(blks[c].usc_mp.fs.ess_bfp_split.split_fraction[0, "to_hxd"]))) + value(blks[c].fs.ess_bfp_split.split_fraction[0, "to_hxd"]))) print(' Salt flow HXC (kg/s): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxc.tube_outlet.flow_mass[0]))) + value(blks[c].fs.hxc.tube_outlet.flow_mass[0]))) print(' Salt flow HXD (kg/s): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxd.shell_outlet.flow_mass[0]))) + value(blks[c].fs.hxd.shell_outlet.flow_mass[0]))) print(' Steam flow HXC (mol/s): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxc.shell_outlet.flow_mol[0]))) + value(blks[c].fs.hxc.shell_outlet.flow_mol[0]))) print(' Steam flow HXD (mol/s): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxd.tube_outlet.flow_mol[0]))) + value(blks[c].fs.hxd.tube_outlet.flow_mol[0]))) print(' Delta T in HXC (kg): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxc.delta_temperature_in[0]))) + value(blks[c].fs.hxc.delta_temperature_in[0]))) print(' Delta T out HXC (kg): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxc.delta_temperature_out[0]))) + value(blks[c].fs.hxc.delta_temperature_out[0]))) print(' Delta T in HXD (kg): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxd.delta_temperature_in[0]))) + value(blks[c].fs.hxd.delta_temperature_in[0]))) print(' Delta T out HXD (kg): {:.4f}'.format( - value(blks[c].usc_mp.fs.hxd.delta_temperature_out[0]))) + value(blks[c].fs.hxd.delta_temperature_out[0]))) c += 1 @@ -233,9 +236,9 @@ def plot_results(ndays, nweeks, lmp, m, blks, hot_tank_level, cold_tank_level, cold_tank_array = np.asarray(cold_tank_level[0:nweeks]).flatten() # Convert array to list to include hot tank level at time zero - hot_tank_array0 = (value(blks[0].usc_mp.previous_salt_inventory_hot) / + hot_tank_array0 = (value(blks[0].fs.previous_salt_inventory_hot) / scaling_factor) * 1e-3 - cold_tank_array0 = (value(blks[0].usc_mp.previous_salt_inventory_cold) / + cold_tank_array0 = (value(blks[0].fs.previous_salt_inventory_cold) / scaling_factor) * 1e-3 hours_list = hours.tolist() + [n_time_points] hot_tank_list = [hot_tank_array0] + hot_tank_array.tolist() @@ -286,7 +289,7 @@ def plot_results(ndays, nweeks, lmp, m, blks, hot_tank_level, cold_tank_level, power_array = np.asarray(net_power[0:nweeks]).flatten() # Convert array to list to include net power at time zero - power_array0 = value(blks[0].usc_mp.previous_power) + power_array0 = value(blks[0].fs.previous_power) power_list = [power_array0] + power_array.tolist() fig2, ax3 = plt.subplots(figsize=(12, 8)) From c7180052cb946336fd9b8dcce21560dc8cd871eb Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Fri, 28 Oct 2022 14:48:04 -0400 Subject: [PATCH 08/12] updated tests for the integrated and multiperiod model to align with the changes to the models for idaes 2 update --- ...age_with_ultrasupercritical_power_plant.py | 4 +- ...test_multiperiod_integrated_storage_usc.py | 128 +++++++++++------- 2 files changed, 82 insertions(+), 50 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/tests/test_integrated_storage_with_ultrasupercritical_power_plant.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/tests/test_integrated_storage_with_ultrasupercritical_power_plant.py index 30e8ed50c..33b3bb39e 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/tests/test_integrated_storage_with_ultrasupercritical_power_plant.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/tests/test_integrated_storage_with_ultrasupercritical_power_plant.py @@ -96,8 +96,8 @@ def test_main_function(): tank_scenario="hot_empty", fix_power=False) - assert value(model.fs.revenue) == pytest.approx(9627.76, abs=1e-1) - assert value(model.obj) == pytest.approx(5.17, abs=1e-1) + assert value(model.fs.revenue) == pytest.approx(9649.22, abs=1e-1) + assert value(model.obj) == pytest.approx(5.386, abs=1e-1) assert value(model.fs.hxd.area) == pytest.approx(2204.88, abs=1e-1) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/tests/test_multiperiod_integrated_storage_usc.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/tests/test_multiperiod_integrated_storage_usc.py index a2c608ae0..9a10436ab 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/tests/test_multiperiod_integrated_storage_usc.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/tests/test_multiperiod_integrated_storage_usc.py @@ -23,6 +23,8 @@ import pytest from pyomo.environ import (value, Constraint, Var) +from dispatches.case_studies.fossil_case.ultra_supercritical_plant import ( + ultra_supercritical_powerplant as usc) from dispatches.case_studies.fossil_case.ultra_supercritical_plant.storage \ import multiperiod_integrated_storage_usc as mp_usc @@ -32,71 +34,101 @@ @pytest.fixture(scope="module") -def usc_model(): +def multiperiod_model(): - # Build ultra-supercritical plant base model - m = mp_usc.create_usc_model(pmin, pmax) - return m + # Build multiperiod integrated power plant base model + m = None + model = mp_usc.create_usc_model(m, pmin, pmax) + return model + +@pytest.fixture(scope="module") +def initialized_model(): + # Build ultra-supercritical plant base model + m = None + model = mp_usc.create_usc_model(m, pmin, pmax) + mp_usc.usc_custom_init(model) + return model @pytest.mark.unit -def test_usc_model(usc_model): +def test_usc_model(multiperiod_model): - assert isinstance(usc_model.usc_mp.fs.plant_min_power_eq, Constraint) - assert isinstance(usc_model.usc_mp.fs.plant_max_power_eq, Constraint) + assert isinstance(multiperiod_model.fs.plant_min_power_eq, Constraint) + assert isinstance(multiperiod_model.fs.plant_max_power_eq, Constraint) - assert usc_model.usc_mp.fs.hxc.area.fixed - assert value(usc_model.usc_mp.fs.hxc.area) == 1904 - assert usc_model.usc_mp.fs.hxd.area.fixed - assert value(usc_model.usc_mp.fs.hxd.area) == 2830 - assert usc_model.usc_mp.fs.hxc.tube_outlet.temperature[0].fixed - assert value(usc_model.usc_mp.fs.hxc.tube_outlet.temperature[0]) == 831 - assert usc_model.usc_mp.fs.hxd.shell_inlet.temperature[0].fixed - assert value(usc_model.usc_mp.fs.hxd.shell_inlet.temperature[0]) == 831 - assert usc_model.usc_mp.fs.hxd.shell_outlet.temperature[0].fixed - assert value(usc_model.usc_mp.fs.hxd.shell_outlet.temperature[0]) == 513.15 + assert isinstance(multiperiod_model.fs.previous_power, Var) + assert value(multiperiod_model.fs.previous_power) == 300 + assert isinstance(multiperiod_model.fs.previous_salt_inventory_hot, Var) + assert value(multiperiod_model.fs.previous_salt_inventory_hot) == 75000 -@pytest.fixture(scope="module") -def mp_model(): + assert isinstance(multiperiod_model.fs.salt_inventory_hot, Var) + assert value(multiperiod_model.fs.salt_inventory_hot) == 75000 - # Build the multi-period usc model - m = mp_usc.create_usc_mp_block(pmin=pmin, pmax=pmax) - return m + assert isinstance(multiperiod_model.fs.previous_salt_inventory_cold, Var) + assert value(multiperiod_model.fs.previous_salt_inventory_cold) == 6739292 - 75000 -@pytest.mark.unit -def test_mp_model(mp_model): + assert isinstance(multiperiod_model.fs.salt_inventory_cold, Var) + assert value(multiperiod_model.fs.salt_inventory_cold) == 6739292 - 75000 - assert isinstance(mp_model.usc_mp.previous_power, Var) - assert value(mp_model.usc_mp.previous_power) == 300 + assert isinstance(multiperiod_model.fs.constraint_ramp_down, Constraint) + assert isinstance(multiperiod_model.fs.constraint_ramp_up, Constraint) + assert isinstance(multiperiod_model.fs.constraint_salt_inventory_hot, Constraint) + assert isinstance(multiperiod_model.fs.constraint_salt_maxflow_hot, Constraint) + assert isinstance(multiperiod_model.fs.constraint_salt_maxflow_cold, Constraint) + assert isinstance(multiperiod_model.fs.constraint_salt_inventory, Constraint) - assert isinstance(mp_model.usc_mp.previous_salt_inventory_hot, Var) - assert value(mp_model.usc_mp.previous_salt_inventory_hot) == 75000 - assert isinstance(mp_model.usc_mp.salt_inventory_hot, Var) - assert value(mp_model.usc_mp.salt_inventory_hot) == 75000 +@pytest.mark.unit +def test_unfix_dof(multiperiod_model): - assert isinstance(mp_model.usc_mp.previous_salt_inventory_cold, Var) - assert value(mp_model.usc_mp.previous_salt_inventory_cold) == 6739292 - 75000 + # Verify the degrees of freedom are unfixed and the variables are fixed - assert isinstance(mp_model.usc_mp.salt_inventory_cold, Var) - assert value(mp_model.usc_mp.salt_inventory_cold) == 6739292 - 75000 + mp_usc.usc_unfix_dof(multiperiod_model) - assert isinstance(mp_model.usc_mp.fs.constraint_ramp_down, Constraint) - assert isinstance(mp_model.usc_mp.fs.constraint_ramp_up, Constraint) - assert isinstance(mp_model.usc_mp.fs.constraint_salt_inventory_hot, Constraint) - assert isinstance(mp_model.usc_mp.fs.constraint_salt_maxflow_hot, Constraint) - assert isinstance(mp_model.usc_mp.fs.constraint_salt_maxflow_cold, Constraint) - assert isinstance(mp_model.usc_mp.fs.constraint_salt_inventory, Constraint) + assert multiperiod_model.fs.hxc.area.fixed + assert value(multiperiod_model.fs.hxc.area) == 1904 + assert multiperiod_model.fs.hxd.area.fixed + assert value(multiperiod_model.fs.hxd.area) == 2830 + assert multiperiod_model.fs.hxc.tube_outlet.temperature[0].fixed + assert value(multiperiod_model.fs.hxc.tube_outlet.temperature[0]) == 831 + assert multiperiod_model.fs.hxd.shell_inlet.temperature[0].fixed + assert value(multiperiod_model.fs.hxd.shell_inlet.temperature[0]) == 831 + assert multiperiod_model.fs.hxd.shell_outlet.temperature[0].fixed + assert value(multiperiod_model.fs.hxd.shell_outlet.temperature[0]) == 513.15 @pytest.mark.unit -def test_get_usc_link_variable_pairs(): - assert str('[(blk1.usc_mp.salt_inventory_hot,' - 'blk2.usc_mp.previous_salt_inventory_hot),' - '(blk1.usc_mp.fs.plant_power_out[0],' - 'blk2.usc_mp.previous_power)]') +def test_custom_initialization(initialized_model): + + # Verify the model structure for the model after custom initialization + + assert isinstance(initialized_model.fs.plant_min_power_eq, Constraint) + assert isinstance(initialized_model.fs.plant_max_power_eq, Constraint) + assert isinstance(initialized_model.fs.previous_power, Var) + assert value(initialized_model.fs.previous_power) == 300 + + assert isinstance(initialized_model.fs.previous_salt_inventory_hot, Var) + assert value(initialized_model.fs.previous_salt_inventory_hot) == 75000 + + assert isinstance(initialized_model.fs.salt_inventory_hot, Var) + assert value(initialized_model.fs.salt_inventory_hot) == 75000 + + assert isinstance(initialized_model.fs.previous_salt_inventory_cold, Var) + assert value(initialized_model.fs.previous_salt_inventory_cold) == 6739292 - 75000 + + assert isinstance(initialized_model.fs.salt_inventory_cold, Var) + assert value(initialized_model.fs.salt_inventory_cold) == 6739292 - 75000 + + assert isinstance(initialized_model.fs.constraint_ramp_down, Constraint) + assert isinstance(initialized_model.fs.constraint_ramp_up, Constraint) + assert isinstance(initialized_model.fs.constraint_salt_inventory_hot, Constraint) + assert isinstance(initialized_model.fs.constraint_salt_maxflow_hot, Constraint) + assert isinstance(initialized_model.fs.constraint_salt_maxflow_cold, Constraint) + assert isinstance(initialized_model.fs.constraint_salt_inventory, Constraint) @pytest.mark.unit -def test_get_usc_periodic_variable_pairs(): - assert str('[(b1.usc_mp.salt_inventory_hot,' - 'b2.usc_mp.previous_salt_inventory_hot)]') +def test_get_usc_link_variable_pairs(): + assert str('[(blk1.fs.salt_inventory_hot,' + 'blk2.fs.previous_salt_inventory_hot),' + '(blk1.fs.plant_power_out[0],' + 'blk2.fs.previous_power)]') From 0cae78a66b00f558901f947957742803dcc201db Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Wed, 2 Nov 2022 11:01:52 -0400 Subject: [PATCH 09/12] updating the multiperiod code for running the double loop analysis --- .../storage/multiperiod_double_loop_usc.py | 111 ++++++++++++------ .../multiperiod_integrated_storage_usc.py | 7 +- 2 files changed, 79 insertions(+), 39 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_double_loop_usc.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_double_loop_usc.py index e5029bd8e..30ee49fcd 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_double_loop_usc.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_double_loop_usc.py @@ -24,8 +24,46 @@ import pyomo.environ as pyo import pandas as pd from collections import deque +import idaes.logger as idaeslog + +# IDAES imports +from idaes.apps.grid_integration.multiperiod.multiperiod import MultiPeriodModel + +# DISPATCHES imports from dispatches.case_studies.fossil_case.ultra_supercritical_plant \ - .storage.multiperiod_integrated_storage_usc import create_multiperiod_usc_model + .storage.multiperiod_integrated_storage_usc import (create_usc_model, + usc_unfix_dof, + usc_custom_init, + get_usc_link_variable_pairs) + + +def create_multiperiod_usc_model(n_time_points=4, pmin=None, pmax=None): + """ + Create a multi-period usc_mp cycle object. This object contains a pyomo + model with a block for each time instance. + + n_time_points: Number of time blocks to create + """ + multiperiod_usc = MultiPeriodModel( + n_time_points=n_time_points, + process_model_func=create_usc_model, + initialization_func=usc_custom_init, + unfix_dof_func=usc_unfix_dof, + linking_variable_func=get_usc_link_variable_pairs, + use_stochastic_build=False, + outlvl=idaeslog.INFO, + ) + + flowsheet_options={"pmin": pmin, + "pmax": pmax} + + # create the multiperiod object + multiperiod_usc.build_multi_period_model( + model_data_kwargs={t: flowsheet_options for t in range(n_time_points)}, + flowsheet_options=flowsheet_options, + ) + + return multiperiod_usc class MultiPeriodUsc: @@ -44,7 +82,7 @@ def __init__( self.result_listimp = [] self.model_data = model_data - def populate_model(self, b, horizon): + def populate_model(self, blk, horizon): """ Create a integrated ultra-supercritical power plant and molten salt thermal energy storage model using the `MultiPeriod` package. @@ -58,7 +96,6 @@ def populate_model(self, b, horizon): tank_min = 76000 # in kg tank_max = 6739292 # in kg - blk = b if not blk.is_constructed(): blk.construct() @@ -69,9 +106,9 @@ def populate_model(self, b, horizon): blk.usc_mp = multiperiod_usc active_blks = multiperiod_usc.get_active_process_blocks() - active_blks[0].usc_mp.previous_salt_inventory_hot.fix(tank_min) - active_blks[0].usc_mp.previous_salt_inventory_cold.fix(tank_max-tank_min) - active_blks[0].usc_mp.previous_power.fix(380) + active_blks[0].fs.previous_salt_inventory_hot.fix(tank_min) + active_blks[0].fs.previous_salt_inventory_cold.fix(tank_max-tank_min) + active_blks[0].fs.previous_power.fix(380) # create expression that references underlying power variables blk.HOUR = pyo.Set(initialize=range(horizon)) @@ -92,33 +129,34 @@ def populate_model(self, b, horizon): blk.hxd_steam_Tout = pyo.Expression(blk.HOUR) blk.hxd_steam_vfrac = pyo.Expression(blk.HOUR) for (t, b) in enumerate(active_blks): - blk.P_T[t] = b.usc_mp.fs.net_power - blk.hot_level[t] = b.usc_mp.salt_inventory_hot + blk.P_T[t] = b.fs.net_power + blk.hot_level[t] = b.fs.salt_inventory_hot blk.storage_power[t] = ((-1e-6) - * b.usc_mp.fs.es_turbine.work_mechanical[0]) - blk.plant_duty[t] = b.usc_mp.fs.plant_heat_duty[0] + * b.fs.es_turbine.work_mechanical[0]) + blk.plant_duty[t] = b.fs.plant_heat_duty[0] blk.tot_cost[t] = ( - b.usc_mp.fs.operating_cost - + (b.usc_mp.fs.plant_fixed_operating_cost - + b.usc_mp.fs.plant_variable_operating_cost) / (365 * 24) + b.fs.operating_cost + + (b.fs.plant_fixed_operating_cost + + b.fs.plant_variable_operating_cost) / (365 * 24) ) - blk.plant_power[t] = b.usc_mp.fs.plant_power_out[0] - blk.hxc_salt[t] = b.usc_mp.fs.hxc.tube_inlet.flow_mass[0] - blk.hxc_duty[t] = b.usc_mp.fs.hxc.heat_duty[0] - blk.hxc_salt_Tin[t] = b.usc_mp.fs.hxc.tube_inlet.temperature[0] - blk.hxc_salt_Tout[t] = b.usc_mp.fs.hxc.tube_outlet.temperature[0] - blk.hxd_salt[t] = b.usc_mp.fs.hxd.shell_inlet.flow_mass[0] - blk.hxd_duty[t] = b.usc_mp.fs.hxd.heat_duty[0] - blk.hxd_salt_Tin[t] = b.usc_mp.fs.hxd.shell_inlet.temperature[0] - blk.hxd_salt_Tout[t] = b.usc_mp.fs.hxd.shell_outlet.temperature[0] - blk.hxd_steam_Tout[t] = b.usc_mp.fs.hxd.cold_side.properties_out[0].temperature - blk.hxd_steam_vfrac[t] = b.usc_mp.fs.hxd.cold_side.properties_out[0].vapor_frac + blk.plant_power[t] = b.fs.plant_power_out[0] + blk.hxc_salt[t] = b.fs.hxc.tube_inlet.flow_mass[0] + blk.hxc_duty[t] = b.fs.hxc.heat_duty[0] + blk.hxc_salt_Tin[t] = b.fs.hxc.tube_inlet.temperature[0] + blk.hxc_salt_Tout[t] = b.fs.hxc.tube_outlet.temperature[0] + blk.hxd_salt[t] = b.fs.hxd.shell_inlet.flow_mass[0] + blk.hxd_duty[t] = b.fs.hxd.heat_duty[0] + blk.hxd_salt_Tin[t] = b.fs.hxd.shell_inlet.temperature[0] + blk.hxd_salt_Tout[t] = b.fs.hxd.shell_outlet.temperature[0] + blk.hxd_steam_Tout[t] = b.fs.hxd.cold_side.properties_out[0].temperature + blk.hxd_steam_vfrac[t] = b.fs.hxd.cold_side.properties_out[0].vapor_frac self.multiperiod_usc = multiperiod_usc return - def update_model(self, b, implemented_power_output, realized_soc): + @staticmethod + def update_model(b, implemented_power_output, realized_soc): """ Update `blk` variables using the actual implemented power output. @@ -131,8 +169,7 @@ def update_model(self, b, implemented_power_output, realized_soc): Returns: None """ - blk = b - multiperiod_usc = blk.usc_mp + multiperiod_usc = b.usc_mp active_blks = multiperiod_usc.get_active_process_blocks() implemented_power = round(implemented_power_output[-1]) @@ -140,8 +177,8 @@ def update_model(self, b, implemented_power_output, realized_soc): print("Implemented Power (MPC)", implemented_power) print("Realized SOC (MPC)", realized_soc) - active_blks[0].usc_mp.previous_power.fix(implemented_power) - active_blks[0].usc_mp.previous_salt_inventory_hot.fix(realized_soc) + active_blks[0].fs.previous_power.fix(implemented_power) + active_blks[0].fs.previous_salt_inventory_hot.fix(realized_soc) return @@ -159,8 +196,8 @@ def get_last_delivered_power(b, last_implemented_time_step): Returns: Float64: Value of power output in last time step """ - blk = b - return pyo.value(blk.P_T[last_implemented_time_step]) + # blk = b + return pyo.value(b.P_T[last_implemented_time_step]) @staticmethod def get_implemented_profile(b, last_implemented_time_step): @@ -175,18 +212,18 @@ def get_implemented_profile(b, last_implemented_time_step): Returns: profile: the intended profile, {unit: [...]} """ - blk = b - multiperiod_usc = blk.usc_mp + # blk = b + multiperiod_usc = b.usc_mp active_blks = multiperiod_usc.get_active_process_blocks() implemented_power_output = deque( [ - pyo.value(active_blks[t].usc_mp.fs.net_power) + pyo.value(active_blks[t].fs.net_power) for t in range(last_implemented_time_step + 1) ] ) realized_soc = deque( [ - pyo.value(active_blks[t].usc_mp.salt_inventory_hot) + pyo.value(active_blks[t].fs.salt_inventory_hot) for t in range(last_implemented_time_step + 1) ] ) @@ -196,7 +233,7 @@ def get_implemented_profile(b, last_implemented_time_step): "realized_soc": realized_soc, } - def record_results(self, b, date=None, hour=None, **kwargs): + def record_results(self, blk, date=None, hour=None, **kwargs): """ Record the operations stats for the model. @@ -210,7 +247,7 @@ def record_results(self, b, date=None, hour=None, **kwargs): None """ - blk = b + # blk = b df_list = [] df_listimp = [] for t in blk.HOUR: diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_integrated_storage_usc.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_integrated_storage_usc.py index 36d856cb6..c9d1ee902 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_integrated_storage_usc.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/multiperiod_integrated_storage_usc.py @@ -32,7 +32,7 @@ from idaes.core.util import from_json, to_json import idaes.logger as idaeslog -from pyomo.environ import (NonNegativeReals, Constraint, Var) +from pyomo.environ import (NonNegativeReals, Constraint, Var, ConcreteModel) from idaes.apps.grid_integration.multiperiod.multiperiod import ( MultiPeriodModel) from dispatches.case_studies.fossil_case.ultra_supercritical_plant import ( @@ -41,7 +41,10 @@ integrated_storage_with_ultrasupercritical_power_plant as usc_w_tes) -def create_usc_model(m, pmin, pmax): +def create_usc_model(m=None, pmin=None, pmax=None): + + if m is None: + m = ConcreteModel(name="Integrated Model") # Set bounds for plant power min_storage_heat_duty = 10 # in MW From 5a4f11ff82ac4c50f327f55bba699d45c3bdbf27 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Wed, 2 Nov 2022 11:02:40 -0400 Subject: [PATCH 10/12] double loop notebook using the latest multiperiod codes --- ...rated_ultrasupercritical_power_plant.ipynb | 2329 +++++++++++++---- 1 file changed, 1775 insertions(+), 554 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/double_loop_integrated_ultrasupercritical_power_plant.ipynb b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/double_loop_integrated_ultrasupercritical_power_plant.ipynb index 975bee8aa..7320fe679 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/double_loop_integrated_ultrasupercritical_power_plant.ipynb +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/double_loop_integrated_ultrasupercritical_power_plant.ipynb @@ -189,7 +189,8 @@ "outputs": [], "source": [ "tracking_horizon = 4 # hours\n", - "bidding_horizon = 4 # hours\n", + "bidding_horizon = 48 # hours\n", + "hourly_bidding_horizon = 4 # hours\n", "n_scenario = 1 # for bidding\n", "n_tracking_hour = 1 # advance n_tracking_hour (i.e. assume we solve every hour)\n", "num_days = 1" @@ -239,7 +240,7 @@ "output_type": "stream", "text": [ "[+ 0.00] Beginning the formulation of the multiperiod optimization problem.\n", - "2022-10-26 16:26:20 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[0]\n" + "2022-11-02 09:40:04 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[0]\n" ] }, { @@ -253,8 +254,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:23 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[1]\n" + "2022-11-02 09:40:08 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[1]\n" ] }, { @@ -268,8 +268,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:27 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[2]\n" + "2022-11-02 09:40:11 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[2]\n" ] }, { @@ -283,8 +282,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:30 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[3]\n" + "2022-11-02 09:40:15 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[3]\n" ] }, { @@ -298,38 +296,134 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "[+ 13.93] Completed the formulation of the multiperiod optimization problem.\n", - "2022-10-26 16:26:34 [WARNING] idaes.apps.grid_integration.multiperiod.multiperiod: Initialization function is not provided. Returning the multiperiod model without initialization.\n" + "[+ 15.23] Completed the formulation of the multiperiod optimization problem.\n", + "2022-11-02 09:40:27 [INFO] idaes.init.fs.boiler.control_volume: Initialization Complete\n", + "2022-11-02 09:40:27 [INFO] idaes.init.fs.boiler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:27 [INFO] idaes.init.fs.turbine_splitter[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:27 [INFO] idaes.init.fs.turbine_splitter[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:27 [INFO] idaes.init.fs.reheater[1].control_volume: Initialization Complete\n", + "2022-11-02 09:40:27 [INFO] idaes.init.fs.reheater[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:27 [INFO] idaes.init.fs.turbine_splitter[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:28 [INFO] idaes.init.fs.turbine_splitter[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:28 [INFO] idaes.init.fs.reheater[2].control_volume: Initialization Complete\n", + "2022-11-02 09:40:28 [INFO] idaes.init.fs.reheater[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:28 [INFO] idaes.init.fs.turbine_splitter[5]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:28 [INFO] idaes.init.fs.turbine_splitter[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:28 [INFO] idaes.init.fs.turbine_splitter[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:28 [INFO] idaes.init.fs.turbine_splitter[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:28 [INFO] idaes.init.fs.turbine_splitter[9]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.turbine_splitter[10]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.condenser_mix: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.condenser.control_volume: Initialization Complete\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.condenser: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.fwh_mixer[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.fwh[1].hot_side: Initialization Complete\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.fwh[1].cold_side: Initialization Complete\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.fwh[1]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.fwh_mixer[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.fwh[2].hot_side: Initialization Complete\n", + "2022-11-02 09:40:29 [INFO] idaes.init.fs.fwh[2].cold_side: Initialization Complete\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[2]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh_mixer[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[3].hot_side: Initialization Complete\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[3].cold_side: Initialization Complete\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[3]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh_mixer[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[4].hot_side: Initialization Complete\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[4].cold_side: Initialization Complete\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[4]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[5].hot_side: Initialization Complete\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[5].cold_side: Initialization Complete\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.fwh[5]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:30 [INFO] idaes.init.fs.deaerator: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh_mixer[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[6].hot_side: Initialization Complete\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[6].cold_side: Initialization Complete\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[6]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh_mixer[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[7].hot_side: Initialization Complete\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[7].cold_side: Initialization Complete\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[7]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh_mixer[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[8].hot_side: Initialization Complete\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[8].cold_side: Initialization Complete\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[8]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[9].hot_side: Initialization Complete\n", + "2022-11-02 09:40:31 [INFO] idaes.init.fs.fwh[9].cold_side: Initialization Complete\n", + "2022-11-02 09:40:32 [INFO] idaes.init.fs.fwh[9]: Initialization Completed, optimal - Optimal Solution Found\n", + "Model Initialization = optimal\n", + "******************* USC Model Initialized ********************\n", + "2022-11-02 09:40:34 [INFO] idaes.init.fs.ess_hp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:34 [INFO] idaes.init.fs.hxc.hot_side: Initialization Complete\n", + "2022-11-02 09:40:34 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-11-02 09:40:34 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:40:34 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-11-02 09:40:34 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:40:34 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:40:34 [INFO] idaes.init.fs.hxc.cold_side: Initialization Complete\n", + "2022-11-02 09:40:34 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:40:34 [INFO] idaes.init.fs.hxc: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:40:34 [INFO] idaes.init.fs.cooler.control_volume: Initialization Complete\n", + "2022-11-02 09:40:34 [INFO] idaes.init.fs.cooler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:34 [INFO] idaes.init.fs.hx_pump.control_volume: Initialization Complete\n", + "2022-11-02 09:40:35 [INFO] idaes.init.fs.hx_pump: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:35 [INFO] idaes.init.fs.ess_bfp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:35 [INFO] idaes.init.fs.recycle_mixer: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:40:35 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_in Initialisation Step 1 Complete.\n", + "2022-11-02 09:40:35 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:40:35 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_out Initialisation Step 1 Complete.\n", + "2022-11-02 09:40:35 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:40:35 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:40:35 [INFO] idaes.init.fs.hxd.hot_side: Initialization Complete\n", + "2022-11-02 09:40:35 [INFO] idaes.init.fs.hxd.cold_side: Initialization Complete\n", + "2022-11-02 09:40:36 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:40:36 [INFO] idaes.init.fs.hxd: Initialization Completed, optimal - Optimal Solution Found\n", + "Integrated Model Initialization = optimal\n", + "*************** Integrated Model Initialized ***************\n", + "Cost Initialization = optimal\n", + "******************** Costing Initialized *************************\n", + "\n", + "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:idaes.apps.grid_integration.multiperiod.multiperiod:Initialization function is not provided. Returning the multiperiod model without initialization.\n" + "WARNING:pyomo.core:Setting Var 'fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.0629934683431687` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[0].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2022-10-26 16:26:34 [WARNING] idaes.apps.grid_integration.multiperiod.multiperiod: unfix_dof function is not provided. Returning the model without unfixing degrees of freedom\n" + "[+ 23.20] Created an instance of the flowsheet and initialized it.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:idaes.apps.grid_integration.multiperiod.multiperiod:unfix_dof function is not provided. Returning the model without unfixing degrees of freedom\n" + "WARNING:pyomo.core:Setting Var 'blocks[1].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[2].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[3].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ + "[+ 0.59] Initialized the entire multiperiod optimization model.\n", + "[+ 0.01] Unfixed the degrees of freedom from each period model.\n", "[+ 0.00] Beginning the formulation of the multiperiod optimization problem.\n", - "2022-10-26 16:26:34 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[0]\n" + "2022-11-02 09:40:43 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[0]\n" ] }, { @@ -343,8 +437,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:37 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[1]\n" + "2022-11-02 09:40:47 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[1]\n" ] }, { @@ -358,8 +451,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:41 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[2]\n" + "2022-11-02 09:40:51 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[2]\n" ] }, { @@ -373,8 +465,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:44 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[3]\n" + "2022-11-02 09:40:54 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[3]\n" ] }, { @@ -388,38 +479,134 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "[+ 13.86] Completed the formulation of the multiperiod optimization problem.\n", - "2022-10-26 16:26:47 [WARNING] idaes.apps.grid_integration.multiperiod.multiperiod: Initialization function is not provided. Returning the multiperiod model without initialization.\n" + "[+ 16.11] Completed the formulation of the multiperiod optimization problem.\n", + "2022-11-02 09:41:08 [INFO] idaes.init.fs.boiler.control_volume: Initialization Complete\n", + "2022-11-02 09:41:08 [INFO] idaes.init.fs.boiler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:08 [INFO] idaes.init.fs.turbine_splitter[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:08 [INFO] idaes.init.fs.turbine_splitter[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:08 [INFO] idaes.init.fs.reheater[1].control_volume: Initialization Complete\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.reheater[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.turbine_splitter[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.turbine_splitter[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.reheater[2].control_volume: Initialization Complete\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.reheater[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.turbine_splitter[5]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.turbine_splitter[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.turbine_splitter[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.turbine_splitter[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:09 [INFO] idaes.init.fs.turbine_splitter[9]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.turbine_splitter[10]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.condenser_mix: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.condenser.control_volume: Initialization Complete\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.condenser: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.fwh_mixer[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.fwh[1].hot_side: Initialization Complete\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.fwh[1].cold_side: Initialization Complete\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.fwh[1]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.fwh_mixer[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.fwh[2].hot_side: Initialization Complete\n", + "2022-11-02 09:41:10 [INFO] idaes.init.fs.fwh[2].cold_side: Initialization Complete\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[2]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh_mixer[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[3].hot_side: Initialization Complete\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[3].cold_side: Initialization Complete\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[3]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh_mixer[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[4].hot_side: Initialization Complete\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[4].cold_side: Initialization Complete\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[4]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[5].hot_side: Initialization Complete\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[5].cold_side: Initialization Complete\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[5]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.deaerator: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh_mixer[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[6].hot_side: Initialization Complete\n", + "2022-11-02 09:41:11 [INFO] idaes.init.fs.fwh[6].cold_side: Initialization Complete\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[6]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh_mixer[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[7].hot_side: Initialization Complete\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[7].cold_side: Initialization Complete\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[7]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh_mixer[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[8].hot_side: Initialization Complete\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[8].cold_side: Initialization Complete\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[8]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[9].hot_side: Initialization Complete\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[9].cold_side: Initialization Complete\n", + "2022-11-02 09:41:12 [INFO] idaes.init.fs.fwh[9]: Initialization Completed, optimal - Optimal Solution Found\n", + "Model Initialization = optimal\n", + "******************* USC Model Initialized ********************\n", + "2022-11-02 09:41:15 [INFO] idaes.init.fs.ess_hp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:15 [INFO] idaes.init.fs.hxc.hot_side: Initialization Complete\n", + "2022-11-02 09:41:15 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-11-02 09:41:15 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:41:15 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-11-02 09:41:15 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:41:15 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:41:15 [INFO] idaes.init.fs.hxc.cold_side: Initialization Complete\n", + "2022-11-02 09:41:15 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:41:15 [INFO] idaes.init.fs.hxc: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:41:15 [INFO] idaes.init.fs.cooler.control_volume: Initialization Complete\n", + "2022-11-02 09:41:15 [INFO] idaes.init.fs.cooler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:15 [INFO] idaes.init.fs.hx_pump.control_volume: Initialization Complete\n", + "2022-11-02 09:41:16 [INFO] idaes.init.fs.hx_pump: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:16 [INFO] idaes.init.fs.ess_bfp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:16 [INFO] idaes.init.fs.recycle_mixer: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:41:16 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_in Initialisation Step 1 Complete.\n", + "2022-11-02 09:41:16 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:41:16 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_out Initialisation Step 1 Complete.\n", + "2022-11-02 09:41:16 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:41:16 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:41:16 [INFO] idaes.init.fs.hxd.hot_side: Initialization Complete\n", + "2022-11-02 09:41:16 [INFO] idaes.init.fs.hxd.cold_side: Initialization Complete\n", + "2022-11-02 09:41:16 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:41:16 [INFO] idaes.init.fs.hxd: Initialization Completed, optimal - Optimal Solution Found\n", + "Integrated Model Initialization = optimal\n", + "*************** Integrated Model Initialized ***************\n", + "Cost Initialization = optimal\n", + "******************** Costing Initialized *************************\n", + "\n", + "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:idaes.apps.grid_integration.multiperiod.multiperiod:Initialization function is not provided. Returning the multiperiod model without initialization.\n" + "WARNING:pyomo.core:Setting Var 'fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.0629934683431687` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[0].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2022-10-26 16:26:47 [WARNING] idaes.apps.grid_integration.multiperiod.multiperiod: unfix_dof function is not provided. Returning the model without unfixing degrees of freedom\n" + "[+ 25.51] Created an instance of the flowsheet and initialized it.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:idaes.apps.grid_integration.multiperiod.multiperiod:unfix_dof function is not provided. Returning the model without unfixing degrees of freedom\n" + "WARNING:pyomo.core:Setting Var 'blocks[1].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[2].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[3].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ + "[+ 0.67] Initialized the entire multiperiod optimization model.\n", + "[+ 0.01] Unfixed the degrees of freedom from each period model.\n", "[+ 0.00] Beginning the formulation of the multiperiod optimization problem.\n", - "2022-10-26 16:26:47 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[0]\n" + "2022-11-02 09:41:25 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[0]\n" ] }, { @@ -433,8 +620,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:50 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[1]\n" + "2022-11-02 09:41:30 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[1]\n" ] }, { @@ -448,8 +634,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:54 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[2]\n" + "2022-11-02 09:41:35 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[2]\n" ] }, { @@ -463,8 +648,7 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:26:57 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[3]\n" + "2022-11-02 09:41:40 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[3]\n" ] }, { @@ -478,694 +662,1731 @@ "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "[+ 13.83] Completed the formulation of the multiperiod optimization problem.\n", - "2022-10-26 16:27:01 [WARNING] idaes.apps.grid_integration.multiperiod.multiperiod: Initialization function is not provided. Returning the multiperiod model without initialization.\n" + "2022-11-02 09:41:44 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[4]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:idaes.apps.grid_integration.multiperiod.multiperiod:Initialization function is not provided. Returning the multiperiod model without initialization.\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[4]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2022-10-26 16:27:01 [WARNING] idaes.apps.grid_integration.multiperiod.multiperiod: unfix_dof function is not provided. Returning the model without unfixing degrees of freedom\n" + "2022-11-02 09:41:50 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[5]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:idaes.apps.grid_integration.multiperiod.multiperiod:unfix_dof function is not provided. Returning the model without unfixing degrees of freedom\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[5]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "[+ 0.00] Beginning the formulation of the multiperiod optimization problem.\n", - "2022-10-26 16:27:01 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[0]\n" + "2022-11-02 09:41:54 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[6]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[0]\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[6]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:27:04 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[1]\n" + "2022-11-02 09:41:58 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[7]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[1]\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[7]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:27:07 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[2]\n" + "2022-11-02 09:42:01 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[8]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[2]\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[8]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "2022-10-26 16:27:12 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[3]\n" + "2022-11-02 09:42:06 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[9]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[3]\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[9]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - ">>> Creating USC model and initialization for each time period\n", - "[+ 13.16] Completed the formulation of the multiperiod optimization problem.\n", - "2022-10-26 16:27:14 [WARNING] idaes.apps.grid_integration.multiperiod.multiperiod: Initialization function is not provided. Returning the multiperiod model without initialization.\n" + "2022-11-02 09:42:11 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[10]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:idaes.apps.grid_integration.multiperiod.multiperiod:Initialization function is not provided. Returning the multiperiod model without initialization.\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[10]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2022-10-26 16:27:14 [WARNING] idaes.apps.grid_integration.multiperiod.multiperiod: unfix_dof function is not provided. Returning the model without unfixing degrees of freedom\n" + "2022-11-02 09:42:15 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[11]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:idaes.apps.grid_integration.multiperiod.multiperiod:unfix_dof function is not provided. Returning the model without unfixing degrees of freedom\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[11]\n" ] - } - ], - "source": [ - "# Tracker\n", - "mp_usc_tracker = MultiPeriodUsc(\n", - " model_data=model_data\n", - ")\n", - "\n", - "thermal_tracker = Tracker(\n", - " tracking_model_object=mp_usc_tracker,\n", - " n_tracking_hour=n_tracking_hour,\n", - " solver=solver,\n", - " tracking_horizon=tracking_horizon,\n", - ")\n", - "\n", - "# Projection Tracker\n", - "mp_usc_projection_tracker = MultiPeriodUsc(\n", - " model_data=model_data\n", - ")\n", - "\n", - "thermal_projection_tracker = Tracker(\n", - " tracking_model_object=mp_usc_projection_tracker,\n", - " n_tracking_hour=n_tracking_hour,\n", - " solver=solver,\n", - " tracking_horizon=tracking_horizon,\n", - ")\n", - "\n", - "# Bidder\n", - "mp_usc_bidder = MultiPeriodUsc(\n", - " model_data=model_data\n", - ")\n", - "thermal_bidder = Bidder(\n", - " bidding_model_object=mp_usc_bidder,\n", - " n_scenario=n_scenario,\n", - " solver=solver,\n", - " forecaster=forecaster,\n", - " day_ahead_horizon=bidding_horizon,\n", - " real_time_horizon=tracking_horizon,\n", - ")\n", - "\n", - "# Coordinator\n", - "coordinator = DoubleLoopCoordinator(\n", - " bidder=thermal_bidder,\n", - " tracker=thermal_tracker,\n", - " projection_tracker=thermal_projection_tracker,\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "6b2f211a", - "metadata": {}, - "source": [ - "Set up the `plugin_module` needed for the Prescient simulator" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "4a3b70af", - "metadata": {}, - "outputs": [], - "source": [ - "class PrescientPluginModule(ModuleType):\n", - " def __init__(self, get_configuration, register_plugins):\n", - " self.get_configuration = get_configuration\n", - " self.register_plugins = register_plugins\n", - "\n", - "\n", - "plugin_module = PrescientPluginModule(\n", - " get_configuration=coordinator.get_configuration,\n", - " register_plugins=coordinator.register_plugins,\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "a6e289b9", - "metadata": {}, - "source": [ - "**IMPORTANT** Before proceeding with the rest of the notebook:\n", - "1. Install the `dispatches-sample-data` package by running `pip install dispatches-sample-data` in the working conda environment\n", - "\n", - "OR\n", - "\n", - "1. Download the RTS-GMLC dataset from [https://github.com/GridMod/RTS-GMLC] (or directly as a zipfile here) to your local machine\n", - "2. Update the value of the `rst_gmlc_data_dir` variable in the cell below to the appropriate location of the `RTS_Data/SourceData` subfolder on your local machine" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "86fac6ca", - "metadata": {}, - "outputs": [], - "source": [ - "# If installing the dispatches-sample-data\n", - "rts_gmlc_data_dir = str(rts_gmlc.source_data_path)\n", - "\n", - "# If downloading the data to the local machine use the following option with appropriate path\n", - "# rts_gmlc_data_dir = \"/projects/gmihybridsys/dguittet/data/RTS-GMLC/RTS_Data/SourceData\"\n" - ] - }, - { - "cell_type": "markdown", - "id": "61a63971", - "metadata": {}, - "source": [ - "Declare the options for Prescient simulator" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "6e46669f", - "metadata": {}, - "outputs": [], - "source": [ - "options = {\n", - " \"data_path\": rts_gmlc_data_dir,\n", - " \"input_format\": \"rts-gmlc\",\n", - " \"simulate_out_of_sample\": True,\n", - " \"run_sced_with_persistent_forecast_errors\": True,\n", - " \"output_directory\": \"bidding_multiperiod_usc\",\n", - " \"start_date\": \"2020-07-10\",\n", - " \"num_days\": num_days,\n", - " \"sced_horizon\": tracking_horizon,\n", - " \"ruc_horizon\": bidding_horizon,\n", - " \"ruc_every_hours\": bidding_horizon,\n", - " \"compute_market_settlements\": True,\n", - " \"day_ahead_pricing\": \"LMP\",\n", - " \"ruc_mipgap\": 0.01,\n", - " \"symbolic_solver_labels\": True,\n", - " \"reserve_factor\": 0.0,\n", - " \"deterministic_ruc_solver\": \"gurobi\",\n", - " \"output_ruc_solutions\": True,\n", - " \"sced_solver\": \"gurobi\",\n", - " \"print_sced\": True,\n", - " \"enforce_sced_shutdown_ramprate\": True,\n", - " \"plugin\": {\n", - " \"doubleloop\": {\n", - " \"module\": plugin_module,\n", - " \"bidding_generator\": \"102_STEAM_3\",\n", - " }\n", - " }\n", - "}\n" - ] - }, - { - "cell_type": "markdown", - "id": "89675ac5", - "metadata": {}, - "source": [ - "Run Prescient simulator." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "02298741", - "metadata": { - "tags": [ - "nbval-skip" - ] - }, - "outputs": [ + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:42:20 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[12]\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:gurobipy.gurobipy:Restricted license - for non-production use only - expires 2023-10-25\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[12]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Initializing simulation...\n", - "Did not find reserves.csv; assuming no reserves\n" + "2022-11-02 09:42:27 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[13]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:egret:Did not find reserves.csv; assuming no reserves\n", - "/home/dguittet/.conda-envs/hybrid/lib/python3.7/site-packages/pandas/io/parsers/base_parser.py:1055: FutureWarning: \n", - " Use pd.to_datetime instead.\n", - "\n", - " return generic_parser(date_parser, *date_cols)\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[13]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Setting default t0 state in RTS-GMLC parser\n" + "2022-11-02 09:42:32 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[14]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:egret:Setting default t0 state in RTS-GMLC parser\n" + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[14]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Dates to simulate: 2020-07-10 to 2020-07-10\n", - "RUC activation hours: 0, 4, 8, 12, 16, 20\n", - "Final RUC date: 2020-07-10\n", - "Using current day's forecasts for RUC solves\n", - "Using persistent forecast error model when projecting demand and renewables in SCED\n", - "\n", - "\n", - "Extracting scenario to simulate\n", - "Ipopt 3.13.2: max_iter=200\n", - "\n", - "\n", - "******************************************************************************\n", - "This program contains Ipopt, a library for large-scale nonlinear optimization.\n", - " Ipopt is released as open source code under the Eclipse Public License (EPL).\n", - " For more information visit http://projects.coin-or.org/Ipopt\n", - "\n", - "This version of Ipopt was compiled from source code available at\n", - " https://github.com/IDAES/Ipopt as part of the Institute for the Design of\n", - " Advanced Energy Systems Process Systems Engineering Framework (IDAES PSE\n", - " Framework) Copyright (c) 2018-2019. See https://github.com/IDAES/idaes-pse.\n", - "\n", - "This version of Ipopt was compiled using HSL, a collection of Fortran codes\n", - " for large-scale scientific computation. All technical papers, sales and\n", - " publicity material resulting from use of the HSL codes within IPOPT must\n", - " contain the following acknowledgement:\n", - " HSL, a collection of Fortran codes for large-scale scientific\n", - " computation. See http://www.hsl.rl.ac.uk.\n", - "******************************************************************************\n", - "\n", - "This is Ipopt version 3.13.2, running with linear solver ma27.\n", - "\n", - "Number of nonzeros in equality constraint Jacobian...: 6388\n", - "Number of nonzeros in inequality constraint Jacobian.: 56\n", - "Number of nonzeros in Lagrangian Hessian.............: 1980\n", - "\n", - "Total number of variables............................: 2449\n", - " variables with only lower bounds: 4\n", - " variables with lower and upper bounds: 1997\n", - " variables with only upper bounds: 4\n", - "Total number of equality constraints.................: 2427\n", - "Total number of inequality constraints...............: 32\n", - " inequality constraints with only lower bounds: 4\n", - " inequality constraints with lower and upper bounds: 0\n", - " inequality constraints with only upper bounds: 28\n", - "\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 0 2.6320488e+08 1.27e+08 2.46e+01 -1.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", - " 1r 2.6320488e+08 1.27e+08 9.99e+02 8.0 0.00e+00 - 0.00e+00 1.15e-10R 2\n", - " 2r 2.6320489e+08 1.37e+08 1.89e+07 8.0 9.61e+07 - 1.99e-03 1.03e-06f 1\n", - " 3r 2.6320517e+08 1.37e+08 8.11e+06 8.0 2.20e+07 - 5.74e-01 3.97e-03f 1\n", - " 4r 2.6321040e+08 9.92e+07 6.94e+06 5.2 1.11e+07 - 1.44e-01 9.12e-01f 1\n", - " 5 2.6320397e+08 9.92e+07 2.46e+01 -1.0 8.01e+11 - 5.91e-09 3.00e-08f 1\n", - " 6r 2.6320397e+08 9.92e+07 9.99e+02 7.9 0.00e+00 - 0.00e+00 1.57e-10R 2\n", - " 7r 2.6320397e+08 9.95e+07 1.59e+07 7.9 4.74e+07 - 1.88e-03 1.08e-06f 1\n", - " 8r 2.6320327e+08 9.91e+07 1.00e+07 5.1 1.03e+07 - 3.71e-01 4.81e-01f 1\n", - " 9r 2.6320329e+08 1.51e+08 7.66e+06 5.1 7.59e+04 0.0 2.39e-01 1.00e+00f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 10r 2.6320332e+08 1.68e+08 2.30e+06 5.1 3.27e+03 -0.5 6.99e-01 1.00e+00f 1\n", - " 11r 2.6320332e+08 1.77e+08 2.18e+06 5.1 2.51e+08 - 5.52e-02 7.18e-03f 1\n", - " 12r 2.6320325e+08 1.85e+08 2.07e+06 4.4 2.49e+08 - 5.18e-02 4.73e-02f 1\n", - " 13r 2.6320325e+08 1.85e+08 9.99e+02 7.8 0.00e+00 - 0.00e+00 1.79e-07R 2\n", - " 14r 2.6320326e+08 1.87e+08 1.84e+06 7.8 2.38e+07 - 6.72e-03 1.71e-05f 2\n", - " 15r 2.6320325e+08 1.83e+08 1.55e+06 5.0 9.10e+06 - 1.46e-01 2.54e-01f 1\n", - " 16r 2.6320327e+08 1.81e+08 6.45e+04 5.0 1.36e+03 0.0 9.76e-01 1.00e+00f 1\n", - " 17r 2.6320338e+08 2.42e+08 1.05e+05 4.3 3.44e+03 -0.5 7.16e-01 1.00e+00f 1\n", - " 18r 2.6320353e+08 3.04e+08 4.65e+03 4.3 9.08e+03 -1.0 9.94e-01 1.00e+00f 1\n", - " 19r 2.6320344e+08 3.06e+08 5.26e+03 2.9 5.05e+08 - 4.21e-03 2.68e-03f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 20r 2.6320344e+08 3.06e+08 3.68e+03 2.9 2.70e+04 -1.4 7.27e-01 2.21e-02f 1\n", - " 21r 2.6320343e+08 3.03e+08 6.37e+03 2.9 1.10e+04 -1.0 1.00e+00 1.46e-01f 1\n", - " 22r 2.6320334e+08 3.00e+08 1.10e+03 2.9 5.23e+02 0.3 1.00e+00 1.00e+00f 1\n", - " 23r 2.6320330e+08 2.85e+08 1.10e+03 2.9 1.57e+03 -0.2 1.00e+00 1.00e+00f 1\n", - " 24r 2.6320331e+08 2.93e+08 1.10e+03 2.9 2.54e+09 - 5.47e-04 1.53e-04f 1\n", - " 25r 2.6320332e+08 2.93e+08 1.10e+03 2.9 2.53e+09 - 4.83e-04 3.32e-04f 1\n", - " 26r 2.6320332e+08 2.93e+08 1.10e+03 2.9 2.53e+09 - 3.03e-04 3.34e-04f 1\n", - " 27r 2.6320332e+08 2.93e+08 1.10e+03 2.9 4.70e+03 -0.6 1.00e+00 1.19e-02f 1\n", - " 28r 2.6320332e+08 2.92e+08 1.61e+03 2.9 1.40e+04 -1.1 1.00e+00 1.58e-02f 1\n", - " 29r 2.6320332e+08 2.74e+08 1.47e+04 2.9 3.86e+04 -1.6 5.89e-02 2.41e-02f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 30r 2.6320332e+08 2.74e+08 7.76e+03 2.9 2.66e+02 2.5 1.51e-01 8.62e-02f 1\n", - " 31r 2.6320332e+08 2.74e+08 1.59e+04 2.9 2.43e+02 2.0 3.72e-01 7.46e-02f 1\n", - " 32r 2.6320332e+08 2.74e+08 1.65e+04 2.9 2.39e+02 1.5 5.71e-01 9.85e-01f 1\n", - " 33r 2.6320332e+08 2.74e+08 5.55e+03 2.9 1.06e+02 1.0 1.00e+00 9.12e-01f 1\n", - " 34r 2.6320332e+08 2.73e+08 8.29e+03 2.9 3.17e+02 0.5 1.00e+00 3.62e-01f 1\n", - " 35r 2.6320332e+08 2.73e+08 8.15e+03 2.9 2.53e+09 - 6.56e-04 4.70e-04f 1\n", - " 36r 2.6320332e+08 2.73e+08 9.99e+02 7.8 0.00e+00 - 0.00e+00 2.77e-07R 2\n", - " 37r 2.6320340e+08 2.92e+08 2.41e+06 7.8 4.86e+07 - 5.09e-03 5.92e-04f 1\n", - " 38r 2.6320347e+08 2.87e+08 2.38e+06 5.7 3.00e+07 - 2.12e-02 9.67e-02f 1\n", - " 39r 2.6320354e+08 2.01e+08 1.90e+06 5.7 1.22e+05 -2.0 2.09e-01 2.61e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 40r 2.6320355e+08 1.75e+08 5.14e+05 5.0 2.98e+05 -2.5 7.06e-01 1.11e-01f 1\n", - " 41r 2.6320362e+08 1.87e+08 1.61e+06 5.0 1.37e+03 1.6 9.16e-03 4.48e-01f 1\n", - " 42r 2.6320365e+08 1.93e+08 8.43e+05 5.0 1.09e+03 1.1 1.48e-02 1.71e-01f 1\n", - " 43r 2.6320365e+08 1.93e+08 1.02e+06 5.0 2.31e+03 2.4 4.68e-01 2.69e-03h 1\n", - " 44r 2.6320378e+08 8.33e+08 1.90e+08 5.0 2.68e+03 1.9 3.50e-02 1.00e+00f 1\n", - " 45r 2.6320379e+08 7.81e+08 6.88e+07 5.0 9.73e+01 3.3 3.33e-01 1.00e+00f 1\n", - " 46r 2.6320382e+08 7.86e+08 2.33e+06 5.0 1.78e+01 2.8 9.91e-01 1.00e+00f 1\n", - " 47r 2.6320379e+08 7.86e+08 4.72e+03 3.6 5.91e+00 2.3 9.95e-01 1.00e+00f 1\n", - " 48r 2.6320378e+08 7.85e+08 1.04e+03 2.2 1.53e+01 1.8 1.00e+00 1.00e+00f 1\n", - " 49r 2.6320377e+08 7.85e+08 1.01e+03 2.2 4.44e+01 1.4 1.00e+00 1.00e+00f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 50r 2.6320376e+08 7.85e+08 1.01e+03 1.5 1.33e+02 0.9 1.00e+00 8.10e-02f 1\n", - " 51r 2.6320373e+08 7.84e+08 1.00e+03 1.5 3.97e+02 0.4 1.00e+00 9.28e-01f 1\n", - " 52r 2.6320365e+08 7.82e+08 1.00e+03 1.5 1.19e+03 -0.1 1.00e+00 1.00e+00f 1\n", - " 53r 2.6320354e+08 7.74e+08 1.00e+03 1.5 3.57e+03 -0.6 1.00e+00 1.00e+00f 1\n", - " 54r 2.6320346e+08 7.54e+08 1.00e+03 1.5 1.07e+04 -1.0 1.00e+00 1.00e+00f 1\n", - " 55r 2.6320346e+08 7.54e+08 1.00e+03 1.5 7.72e+11 - 8.27e-06 8.04e-07f 1\n", - " 56r 2.6320346e+08 7.54e+08 1.00e+03 1.5 9.89e+11 - 7.68e-06 1.21e-06f 1\n", - " 57r 2.6320346e+08 7.54e+08 1.00e+03 1.5 1.20e+12 - 8.08e-06 7.22e-07f 1\n", - " 58r 2.6320346e+08 7.54e+08 1.00e+03 1.5 8.47e+11 - 8.58e-06 1.64e-06f 1\n", - " 59r 2.6320346e+08 7.54e+08 1.00e+03 1.5 9.05e+11 - 8.41e-06 1.35e-06f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 60r 2.6320346e+08 7.54e+08 1.00e+03 1.5 9.05e+10 - 2.51e-05 1.61e-06f 1\n", - " 61r 2.6320347e+08 7.53e+08 1.00e+03 1.5 1.32e+10 - 2.59e-05 1.59e-05f 1\n", - " 62r 2.6320347e+08 7.53e+08 1.00e+03 1.5 1.09e+10 - 9.52e-05 3.29e-06f 1\n", - " 63r 2.6320347e+08 7.40e+08 1.00e+03 1.5 1.09e+10 - 2.86e-04 9.23e-05f 1\n", - " 64r 2.6320347e+08 7.12e+08 1.00e+03 1.5 1.09e+10 - 3.73e-04 2.04e-04f 1\n", - " 65r 2.6320347e+08 7.01e+08 3.02e+03 1.5 1.09e+10 - 9.27e-04 8.02e-05f 1\n", - " 66r 2.6320347e+08 6.82e+08 5.89e+03 1.5 1.09e+10 - 8.88e-04 1.27e-04f 1\n", - " 67r 2.6320347e+08 6.82e+08 9.99e+02 7.7 0.00e+00 - 0.00e+00 1.54e-09R 2\n", - " 68r 2.6320347e+08 6.82e+08 9.27e+06 7.7 1.38e+11 - 2.77e-05 4.35e-06f 2\n", - " 69r 2.6320354e+08 6.98e+08 6.18e+06 6.3 7.32e+07 - 3.39e-01 1.14e-02f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 70r 2.6320357e+08 6.65e+08 6.13e+06 4.9 2.63e+08 - 6.40e-03 6.06e-02f 1\n", - " 71r 2.6320358e+08 6.57e+08 5.24e+06 4.9 1.81e+08 - 1.47e-01 5.84e-03f 1\n", - " 72r 2.6320394e+08 4.56e+08 5.20e+06 4.9 1.80e+08 - 6.65e-03 1.52e-01f 1\n", - " 73r 2.6320394e+08 4.56e+08 9.99e+02 7.5 0.00e+00 - 0.00e+00 2.93e-07R 6\n", - " 74r 2.6320395e+08 4.57e+08 1.18e+06 7.5 1.14e+07 - 3.20e-02 5.24e-05f 3\n", - " 75r 2.6320396e+08 4.47e+08 1.05e+06 4.7 4.91e+06 - 1.93e-01 1.04e-01f 1\n", - " 76r 2.6320398e+08 4.48e+08 2.73e+04 4.7 1.00e+03 0.0 9.74e-01 1.00e+00f 1\n", - " 77r 2.6320399e+08 4.43e+08 3.60e+04 4.7 1.05e+08 - 1.27e-02 4.24e-03f 1\n", - " 78r 2.6320399e+08 4.41e+08 3.78e+04 4.7 1.04e+08 - 3.69e-03 1.87e-03f 1\n", - " 79r 2.6320400e+08 4.38e+08 3.96e+04 4.7 1.04e+08 - 4.60e-03 2.74e-03f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 80r 2.6320401e+08 4.32e+08 7.30e+04 4.7 1.04e+08 - 3.85e-02 5.22e-03f 1\n", - " 81r 2.6320412e+08 3.67e+08 3.80e+04 4.7 1.03e+08 - 1.68e-02 5.10e-02f 1\n", - " 82r 2.6320422e+08 3.42e+08 1.48e+05 4.7 9.80e+07 - 1.65e-01 4.40e-02f 1\n", - " 83r 2.6320422e+08 3.41e+08 3.01e+05 4.7 9.36e+07 - 2.64e-01 7.34e-04f 1\n", - " 84r 2.6320437e+08 2.93e+08 3.61e+05 4.7 9.34e+07 - 2.78e-01 7.38e-02f 1\n", - " 85r 2.6320443e+08 2.95e+08 2.99e+05 4.7 3.28e+04 1.3 1.72e-01 1.84e-01f 1\n", - " 86r 2.6320443e+08 2.95e+08 1.92e+05 4.7 2.91e+04 1.8 3.99e-01 2.85e-03h 1\n", - " 87r 2.6320451e+08 2.99e+08 2.95e+05 4.7 3.76e+04 1.3 4.30e-01 2.80e-01f 1\n", - " 88r 2.6320451e+08 2.99e+08 8.59e+05 4.7 2.77e+04 1.7 7.73e-01 1.77e-02h 1\n", - " 89r 2.6320467e+08 3.06e+08 4.09e+05 4.7 2.77e+04 1.2 1.00e+00 6.15e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 90r 2.6320466e+08 3.06e+08 3.89e+05 4.0 1.10e+04 0.7 8.99e-01 5.74e-02f 1\n", - " 91r 2.6320466e+08 3.06e+08 8.37e+05 4.0 1.05e+04 2.1 1.00e+00 3.71e-02h 1\n", - " 92r 2.6320468e+08 3.07e+08 4.04e+05 4.0 1.01e+04 1.6 1.00e+00 1.00e+00f 1\n", - " 93r 2.6320463e+08 3.07e+08 3.74e+03 3.3 1.89e+02 1.1 9.95e-01 1.00e+00f 1\n", - " 94r 2.6320455e+08 3.06e+08 6.99e+03 1.9 2.64e+02 0.6 1.00e+00 1.00e+00f 1\n", - " 95r 2.6320455e+08 3.06e+08 5.00e+03 1.9 1.24e+01 2.0 1.00e+00 1.00e+00f 1\n", - " 96r 2.6320455e+08 3.06e+08 1.24e+04 1.9 4.64e+00 2.4 1.00e+00 1.00e+00f 1\n", - " 97r 2.6320455e+08 3.06e+08 6.66e+03 1.9 1.39e+01 1.9 1.00e+00 1.00e+00f 1\n", - " 98r 2.6320455e+08 3.06e+08 2.67e+04 1.9 4.18e+01 1.4 1.00e+00 1.00e+00f 1\n", - " 99r 2.6320454e+08 3.06e+08 1.09e+04 1.9 1.25e+02 1.0 1.00e+00 1.00e+00f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 100r 2.6320454e+08 3.06e+08 2.72e+04 1.9 1.38e+01 2.3 1.00e+00 1.00e+00f 1\n", - " 101r 2.6320454e+08 3.06e+08 4.79e+03 1.9 1.90e+01 1.8 1.00e+00 1.00e+00f 1\n", - " 102r 2.6320453e+08 3.05e+08 1.17e+03 1.9 5.29e+01 1.3 1.00e+00 1.00e+00f 1\n", - " 103r 2.6320453e+08 3.05e+08 1.17e+03 1.9 1.59e+02 0.9 1.00e+00 1.00e+00f 1\n", - " 104r 2.6320451e+08 3.05e+08 1.17e+03 1.9 4.76e+02 0.4 1.00e+00 9.86e-01f 1\n", - " 105r 2.6320451e+08 3.05e+08 1.17e+03 1.9 1.43e+03 -0.1 1.00e+00 3.74e-03f 1\n", - " 106r 2.6320449e+08 3.05e+08 1.17e+03 1.9 4.29e+03 -0.6 1.00e+00 1.57e-01f 1\n", - " 107r 2.6320449e+08 3.05e+08 1.17e+03 1.9 1.29e+04 -1.0 1.00e+00 3.04e-03f 1\n", - " 108r 2.6320449e+08 3.05e+08 1.17e+03 1.9 3.87e+04 -1.5 1.00e+00 3.52e-02f 1\n", - " 109r 2.6320449e+08 3.06e+08 1.17e+03 1.9 1.17e+05 -2.0 2.00e-01 1.45e-02f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 110r 2.6320448e+08 3.03e+08 1.17e+03 1.9 3.27e+05 -2.5 6.95e-03 2.69e-03f 1\n", - " 111r 2.6320448e+08 2.96e+08 1.17e+03 1.9 9.18e+05 -2.9 6.24e-04 1.72e-03f 1\n", - " 112r 2.6320448e+08 2.95e+08 1.17e+03 1.9 2.61e+09 - 1.59e-03 1.34e-04f 1\n", - " 113r 2.6320448e+08 2.94e+08 1.78e+03 1.9 2.61e+09 - 2.67e-03 1.33e-04f 1\n", - " 114r 2.6320448e+08 2.92e+08 4.04e+03 1.9 2.61e+09 - 5.84e-03 2.43e-04f 1\n", - " 115r 2.6320448e+08 2.89e+08 4.11e+03 1.9 2.60e+09 - 4.75e-04 2.84e-04f 1\n", - " 116r 2.6320447e+08 2.84e+08 4.21e+03 1.9 2.60e+09 - 7.20e-04 4.34e-04f 1\n", - " 117r 2.6320447e+08 2.81e+08 4.80e+03 1.9 2.60e+09 - 1.90e-03 3.16e-04f 1\n", - " 118r 2.6320447e+08 2.81e+08 4.47e+03 1.9 5.60e+03 -0.7 1.26e-01 5.21e-03f 1\n", - " 119r 2.6320445e+08 2.72e+08 4.71e+03 1.9 1.49e+04 -1.2 4.29e-02 3.00e-02f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 120r 2.6320445e+08 2.72e+08 4.25e+03 1.9 1.05e+02 1.9 5.83e-01 4.00e-01f 1\n", - " 121r 2.6320445e+08 2.71e+08 3.80e+03 1.9 9.54e+01 1.5 9.75e-01 3.12e-01f 1\n", - " 122r 2.6320445e+08 2.71e+08 5.74e+03 1.9 1.48e+02 1.0 1.00e+00 8.63e-03f 1\n", - " 123r 2.6320445e+08 2.71e+08 2.69e+04 1.9 1.17e+02 1.4 4.69e-02 1.04e-02f 1\n", - " 124r 2.6320445e+08 2.71e+08 3.83e+04 1.9 1.60e+02 0.9 1.53e-02 4.86e-01f 1\n", - " 125r 2.6320445e+08 2.71e+08 6.77e+05 1.9 2.58e+01 4.1 1.00e+00 1.05e-03f 1\n", - " 126r 2.6320445e+08 2.71e+08 2.91e+07 1.9 4.20e+01 3.6 8.56e-01 2.99e-02f 1\n", - " 127r 2.6320445e+08 2.71e+08 8.03e+06 1.9 4.08e+01 3.1 1.00e+00 8.68e-01f 1\n", - " 128r 2.6320445e+08 2.71e+08 4.92e+06 1.9 2.22e+01 2.6 2.73e-02 2.55e-01f 1\n", - " 129r 2.6320445e+08 2.71e+08 4.91e+07 1.9 1.23e+01 6.7 1.00e+00 5.20e-04h 1\n", - "Error in an AMPL evaluation. Run with \"halt_on_ampl_error yes\" to see details.\n", - "Warning: Cutting back alpha due to evaluation error\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 130r 2.6320445e+08 2.71e+08 2.25e+09 1.9 9.04e+00 6.2 1.00e+00 1.45e-02h 2\n", - " 131r 2.6320445e+08 2.71e+08 8.13e+06 1.9 1.17e+01 5.7 1.00e+00 1.00e+00f 1\n", - " 132r 2.6320445e+08 2.71e+08 8.41e+06 1.9 7.77e-01 5.2 8.19e-01 1.00e+00f 1\n", - " 133r 2.6320445e+08 2.71e+08 2.13e+05 1.9 3.47e+00 4.8 9.62e-01 1.00e+00f 1\n", - " 134r 2.6320445e+08 2.71e+08 3.03e+05 1.9 6.52e+00 4.3 1.00e+00 1.00e+00f 1\n", - " 135r 2.6320445e+08 2.71e+08 1.12e+05 1.9 9.99e+00 3.8 9.23e-01 1.00e+00f 1\n", - " 136r 2.6320445e+08 2.71e+08 2.75e+04 1.9 3.82e+00 3.3 1.00e+00 1.00e+00f 1\n", - " 137r 2.6320445e+08 2.71e+08 4.47e+03 1.9 3.89e+00 2.9 9.70e-01 8.17e-01f 1\n", - " 138r 2.6320445e+08 2.71e+08 3.49e+03 1.9 4.72e+00 2.4 1.00e+00 2.80e-01f 1\n", - " 139r 2.6320445e+08 2.71e+08 5.15e+03 1.9 1.41e+01 1.9 9.68e-01 1.55e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 140r 2.6320445e+08 2.71e+08 1.14e+03 1.9 5.30e+00 2.3 1.00e+00 1.00e+00f 1\n", - " 141r 2.6320445e+08 2.71e+08 1.14e+03 1.9 1.59e+01 1.9 1.00e+00 1.00e+00f 1\n", - " 142r 2.6320445e+08 2.71e+08 1.14e+03 1.9 4.77e+01 1.4 1.00e+00 1.36e-01f 1\n", - " 143r 2.6320445e+08 2.71e+08 1.14e+03 1.9 1.44e+02 0.9 1.00e+00 8.64e-02f 1\n", - " 144r 2.6320444e+08 2.71e+08 1.14e+03 1.9 4.44e+02 0.4 1.00e+00 5.26e-02f 1\n", - " 145r 2.6320444e+08 2.71e+08 1.12e+03 1.9 1.30e+03 -0.1 2.94e-01 4.50e-02f 1\n", - " 146r 2.6320444e+08 2.71e+08 1.12e+03 1.9 5.24e+02 0.4 1.00e+00 6.37e-02f 1\n", - " 147r 2.6320444e+08 2.71e+08 1.12e+03 1.9 1.62e+03 -0.1 2.20e-01 6.16e-02f 1\n", - " 148r 2.6320444e+08 2.71e+08 1.12e+03 1.9 4.77e+03 -0.6 2.23e-01 2.29e-02f 1\n", - " 149r 2.6320444e+08 2.71e+08 1.14e+03 1.9 2.24e+02 0.7 1.00e+00 1.21e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 150r 2.6320444e+08 2.71e+08 1.15e+03 1.9 6.64e+02 0.3 3.90e-01 1.18e-01f 1\n", - " 151r 2.6320443e+08 2.71e+08 1.13e+03 1.9 1.88e+03 -0.2 2.35e-01 4.35e-02f 1\n", - " 152r 2.6320443e+08 2.71e+08 1.08e+03 1.9 7.03e+02 0.2 8.71e-01 6.54e-02f 1\n", - " 153r 2.6320442e+08 2.71e+08 1.07e+03 1.9 2.04e+03 -0.3 6.62e-02 5.81e-02f 1\n", - " 154r 2.6320442e+08 2.71e+08 7.27e+03 1.9 7.67e+02 0.2 3.86e-01 3.94e-02f 1\n", - " 155r 2.6320441e+08 2.74e+08 1.97e+04 1.9 2.88e+02 0.6 6.58e-01 1.27e-01f 1\n", - " 156r 2.6320432e+08 2.66e+08 2.15e+04 1.9 8.55e+02 0.1 1.76e-01 8.07e-02f 1\n", - " 157r 2.6320426e+08 2.59e+08 1.94e+04 1.9 5.53e+02 0.5 5.52e-02 6.72e-02f 1\n", - " 158r 2.6320424e+08 2.57e+08 3.51e+04 1.9 1.23e+02 1.0 5.17e-01 6.92e-02f 1\n", - " 159r 2.6320420e+08 2.54e+08 3.62e+04 1.9 4.65e+01 1.4 1.00e+00 2.31e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 160r 2.6320412e+08 2.52e+08 5.06e+04 1.9 1.35e+02 0.9 7.31e-01 1.62e-01f 1\n", - " 161r 2.6320403e+08 2.49e+08 7.92e+04 1.9 3.71e+02 0.4 2.70e-01 6.95e-02f 1\n", - " 162r 2.6320400e+08 2.48e+08 1.95e+05 1.9 1.38e+02 0.9 9.28e-01 8.75e-02f 1\n", - " 163r 2.6320398e+08 2.39e+08 1.70e+05 1.9 4.17e+02 0.4 3.29e-01 1.13e-01f 1\n", - " 164r 2.6320397e+08 2.37e+08 1.39e+05 1.9 1.55e+02 0.8 1.00e+00 9.32e-02f 1\n", - " 165r 2.6320396e+08 2.34e+08 8.73e+04 1.9 5.78e+01 1.2 1.00e+00 2.93e-01f 1\n", - " 166r 2.6320396e+08 2.31e+08 8.04e+04 1.9 2.66e+02 0.8 8.03e-02 7.78e-02f 1\n", - " 167r 2.6320396e+08 2.31e+08 8.00e+04 1.9 5.03e+02 1.2 2.41e-02 7.98e-03f 1\n", - " 168r 2.6320396e+08 2.31e+08 7.80e+04 1.9 7.26e+01 1.6 5.77e-02 1.76e-02f 1\n", - " 169r 2.6320396e+08 2.31e+08 6.47e+04 1.9 8.00e+01 2.0 1.22e-01 4.73e-02f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 170r 2.6320396e+08 2.31e+08 6.62e+04 1.9 7.02e+01 2.5 4.24e-02 5.72e-02f 1\n", - " 171r 2.6320396e+08 2.31e+08 8.57e+04 1.9 5.08e+01 2.9 5.96e-02 9.97e-02f 1\n", - " 172r 2.6320396e+08 2.31e+08 6.71e+04 1.9 2.87e+01 3.3 8.03e-02 6.99e-02f 1\n", - " 173r 2.6320396e+08 2.31e+08 9.48e+04 1.9 4.59e+01 2.8 2.67e-01 3.97e-01f 1\n", - " 174r 2.6320395e+08 2.31e+08 5.64e+04 1.9 2.00e+01 2.4 9.58e-01 4.43e-01f 1\n", - " 175r 2.6320395e+08 2.31e+08 4.65e+04 1.9 1.31e+01 1.9 6.62e-01 1.76e-01f 1\n", - " 176r 2.6320395e+08 2.30e+08 1.53e+05 1.9 4.00e+01 1.4 1.00e+00 1.04e-01f 1\n", - " 177r 2.6320395e+08 2.29e+08 1.15e+05 1.9 1.49e+01 1.8 9.52e-01 3.38e-01f 1\n", - " 178r 2.6320395e+08 2.28e+08 1.21e+05 1.9 7.72e+01 1.4 1.00e+00 1.68e-01f 1\n", - " 179r 2.6320394e+08 2.27e+08 6.58e+04 1.9 1.70e+01 1.8 1.00e+00 4.25e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 180r 2.6320394e+08 2.27e+08 6.54e+04 1.9 6.44e+03 1.3 7.07e-03 5.61e-03f 1\n", - " 181r 2.6320394e+08 2.26e+08 8.69e+04 1.9 2.04e+01 1.7 1.00e+00 2.29e-02f 1\n", - " 182r 2.6320394e+08 2.26e+08 8.25e+04 1.9 9.17e+02 1.3 6.84e-02 3.72e-02f 1\n", - " 183r 2.6320394e+08 2.26e+08 7.62e+04 1.9 2.14e+01 1.7 1.00e+00 2.64e-02f 1\n", - " 184r 2.6320394e+08 2.23e+08 6.27e+04 1.9 6.44e+01 1.2 1.00e+00 2.07e-01f 1\n", - " 185r 2.6320394e+08 2.10e+08 1.64e+05 1.9 1.93e+02 0.7 9.49e-01 8.80e-02f 1\n", - " 186r 2.6320394e+08 2.10e+08 1.22e+04 1.9 1.09e+01 3.0 7.63e-01 1.79e-01f 1\n", - " 187r 2.6320394e+08 2.10e+08 3.21e+04 1.9 1.20e+01 2.5 1.00e+00 2.63e-01f 1\n", - " 188r 2.6320394e+08 2.09e+08 2.32e+04 1.9 1.02e+01 2.0 1.00e+00 5.03e-01f 1\n", - " 189r 2.6320394e+08 2.07e+08 2.64e+04 1.9 3.06e+01 1.5 1.00e+00 2.15e-01f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 190r 2.6320394e+08 2.03e+08 1.44e+05 1.9 9.17e+01 1.1 1.00e+00 1.01e-01f 1\n", - " 191r 2.6320394e+08 1.99e+08 4.33e+04 1.9 3.44e+01 1.5 1.00e+00 3.49e-01f 1\n", - " 192r 2.6320394e+08 1.85e+08 1.96e+05 1.9 1.03e+02 1.0 1.00e+00 1.85e-01f 1\n", - " 193r 2.6320394e+08 1.85e+08 4.47e+05 1.9 8.95e+01 4.1 1.42e-02 1.84e-02h 1\n", - " 194r 2.6320394e+08 1.85e+08 4.34e+05 1.9 9.35e+00 4.6 6.43e-02 3.59e-02h 1\n", - " 195r 2.6320394e+08 1.85e+08 3.17e+05 1.9 9.13e+00 4.1 1.30e-01 2.74e-01h 1\n", - " 196r 2.6320394e+08 1.86e+08 2.42e+05 1.9 7.27e+00 3.6 6.82e-01 3.14e-01f 1\n", - " 197r 2.6320394e+08 1.86e+08 2.10e+05 1.9 1.86e+01 3.1 5.40e-01 7.11e-02f 1\n", - " 198r 2.6320394e+08 1.86e+08 1.22e+05 1.9 5.04e+00 2.7 1.00e+00 4.20e-01f 1\n", - " 199r 2.6320394e+08 1.83e+08 2.77e+03 1.9 6.88e+00 2.2 1.00e+00 1.00e+00f 1\n", - "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", - " 200r 2.6320394e+08 1.80e+08 1.03e+04 1.2 2.95e+01 1.7 7.82e-01 2.70e-01f 1\n", - "\n", - "Number of Iterations....: 200\n", - "\n", - " (scaled) (unscaled)\n", - "Objective...............: 2.6320394014834476e+08 2.6320394014834476e+08\n", - "Dual infeasibility......: 1.0324431258664568e+04 1.0324431258664568e+04\n", - "Constraint violation....: 3.0859154910812795e+07 1.8000638959976041e+08\n", - "Complementarity.........: 6.2631084426618898e+01 6.2631084426618898e+01\n", - "Overall NLP error.......: 3.0859154910812795e+07 1.8000638959976041e+08\n", + "2022-11-02 09:42:35 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[15]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[15]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:42:39 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[16]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[16]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:42:43 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[17]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[17]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:42:49 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[18]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[18]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:42:53 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[19]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[19]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:42:57 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[20]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[20]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:01 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[21]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[21]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:05 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[22]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[22]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:09 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[23]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[23]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:13 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[24]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[24]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:20 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[25]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[25]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:24 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[26]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[26]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:29 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[27]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[27]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:33 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[28]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[28]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:37 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[29]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[29]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:41 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[30]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[30]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:46 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[31]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[31]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:51 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[32]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[32]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:43:57 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[33]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[33]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:01 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[34]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[34]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:05 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[35]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[35]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:09 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[36]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[36]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:13 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[37]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[37]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:17 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[38]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[38]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:21 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[39]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[39]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:25 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[40]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[40]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:30 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[41]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[41]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:34 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[42]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[42]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:38 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[43]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[43]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:45 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[44]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[44]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:49 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[45]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[45]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:53 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[46]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[46]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:44:58 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[47]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[47]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 216.90] Completed the formulation of the multiperiod optimization problem.\n", + "2022-11-02 09:45:10 [INFO] idaes.init.fs.boiler.control_volume: Initialization Complete\n", + "2022-11-02 09:45:10 [INFO] idaes.init.fs.boiler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:10 [INFO] idaes.init.fs.turbine_splitter[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:10 [INFO] idaes.init.fs.turbine_splitter[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:10 [INFO] idaes.init.fs.reheater[1].control_volume: Initialization Complete\n", + "2022-11-02 09:45:10 [INFO] idaes.init.fs.reheater[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.turbine_splitter[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.turbine_splitter[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.reheater[2].control_volume: Initialization Complete\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.reheater[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.turbine_splitter[5]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.turbine_splitter[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.turbine_splitter[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.turbine_splitter[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.turbine_splitter[9]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:11 [INFO] idaes.init.fs.turbine_splitter[10]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.condenser_mix: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.condenser.control_volume: Initialization Complete\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.condenser: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.fwh_mixer[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.fwh[1].hot_side: Initialization Complete\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.fwh[1].cold_side: Initialization Complete\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.fwh[1]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.fwh_mixer[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.fwh[2].hot_side: Initialization Complete\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.fwh[2].cold_side: Initialization Complete\n", + "2022-11-02 09:45:12 [INFO] idaes.init.fs.fwh[2]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh_mixer[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[3].hot_side: Initialization Complete\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[3].cold_side: Initialization Complete\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[3]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh_mixer[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[4].hot_side: Initialization Complete\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[4].cold_side: Initialization Complete\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[4]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[5].hot_side: Initialization Complete\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[5].cold_side: Initialization Complete\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[5]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.deaerator: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh_mixer[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[6].hot_side: Initialization Complete\n", + "2022-11-02 09:45:13 [INFO] idaes.init.fs.fwh[6].cold_side: Initialization Complete\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[6]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh_mixer[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[7].hot_side: Initialization Complete\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[7].cold_side: Initialization Complete\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[7]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh_mixer[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[8].hot_side: Initialization Complete\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[8].cold_side: Initialization Complete\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[8]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[9].hot_side: Initialization Complete\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[9].cold_side: Initialization Complete\n", + "2022-11-02 09:45:14 [INFO] idaes.init.fs.fwh[9]: Initialization Completed, optimal - Optimal Solution Found\n", + "Model Initialization = optimal\n", + "******************* USC Model Initialized ********************\n", + "2022-11-02 09:45:16 [INFO] idaes.init.fs.ess_hp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:16 [INFO] idaes.init.fs.hxc.hot_side: Initialization Complete\n", + "2022-11-02 09:45:16 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-11-02 09:45:16 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.hxc.cold_side: Initialization Complete\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.hxc: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.cooler.control_volume: Initialization Complete\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.cooler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.hx_pump.control_volume: Initialization Complete\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.hx_pump: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.ess_bfp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.recycle_mixer: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_in Initialisation Step 1 Complete.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_out Initialisation Step 1 Complete.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.hxd.hot_side: Initialization Complete\n", + "2022-11-02 09:45:17 [INFO] idaes.init.fs.hxd.cold_side: Initialization Complete\n", + "2022-11-02 09:45:18 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:45:18 [INFO] idaes.init.fs.hxd: Initialization Completed, optimal - Optimal Solution Found\n", + "Integrated Model Initialization = optimal\n", + "*************** Integrated Model Initialized ***************\n", + "Cost Initialization = optimal\n", + "******************** Costing Initialized *************************\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyomo.core:Setting Var 'fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.0629934683431687` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[0].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 22.47] Created an instance of the flowsheet and initialized it.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyomo.core:Setting Var 'blocks[1].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[2].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[3].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[4].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[5].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[6].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[7].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[8].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[9].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[10].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[11].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[12].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[13].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[14].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[15].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[16].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[17].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[18].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[19].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[20].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[21].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[22].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[23].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[24].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[25].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[26].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[27].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[28].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[29].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[30].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[31].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[32].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[33].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[34].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[35].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[36].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[37].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[38].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[39].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[40].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[41].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[42].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[43].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[44].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[45].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[46].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[47].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 7.38] Initialized the entire multiperiod optimization model.\n", + "[+ 0.04] Unfixed the degrees of freedom from each period model.\n", + "[+ 0.00] Beginning the formulation of the multiperiod optimization problem.\n", + "2022-11-02 09:45:32 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[0]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[0]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:45:36 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[1]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:45:40 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[2]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[2]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:45:44 [INFO] idaes.apps.grid_integration.multiperiod.multiperiod: ...Constructing the flowsheet model for blocks[3]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:idaes.apps.grid_integration.multiperiod.multiperiod:...Constructing the flowsheet model for blocks[3]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 16.36] Completed the formulation of the multiperiod optimization problem.\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.boiler.control_volume: Initialization Complete\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.boiler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.turbine_splitter[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.turbine_splitter[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.reheater[1].control_volume: Initialization Complete\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.reheater[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.turbine_splitter[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.turbine_splitter[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.reheater[2].control_volume: Initialization Complete\n", + "2022-11-02 09:45:57 [INFO] idaes.init.fs.reheater[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:58 [INFO] idaes.init.fs.turbine_splitter[5]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:58 [INFO] idaes.init.fs.turbine_splitter[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:58 [INFO] idaes.init.fs.turbine_splitter[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:45:58 [INFO] idaes.init.fs.turbine_splitter[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:02 [INFO] idaes.init.fs.turbine_splitter[9]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.turbine_splitter[10]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.condenser_mix: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.condenser.control_volume: Initialization Complete\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.condenser: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.fwh_mixer[1]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.fwh[1].hot_side: Initialization Complete\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.fwh[1].cold_side: Initialization Complete\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.fwh[1]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.fwh_mixer[2]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.fwh[2].hot_side: Initialization Complete\n", + "2022-11-02 09:46:03 [INFO] idaes.init.fs.fwh[2].cold_side: Initialization Complete\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[2]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh_mixer[3]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[3].hot_side: Initialization Complete\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[3].cold_side: Initialization Complete\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[3]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh_mixer[4]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[4].hot_side: Initialization Complete\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[4].cold_side: Initialization Complete\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[4]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[5].hot_side: Initialization Complete\n", + "2022-11-02 09:46:04 [INFO] idaes.init.fs.fwh[5].cold_side: Initialization Complete\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[5]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.deaerator: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh_mixer[6]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[6].hot_side: Initialization Complete\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[6].cold_side: Initialization Complete\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[6]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh_mixer[7]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[7].hot_side: Initialization Complete\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[7].cold_side: Initialization Complete\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[7]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh_mixer[8]: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[8].hot_side: Initialization Complete\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[8].cold_side: Initialization Complete\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[8]: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[9].hot_side: Initialization Complete\n", + "2022-11-02 09:46:05 [INFO] idaes.init.fs.fwh[9].cold_side: Initialization Complete\n", + "2022-11-02 09:46:06 [INFO] idaes.init.fs.fwh[9]: Initialization Completed, optimal - Optimal Solution Found\n", + "Model Initialization = optimal\n", + "******************* USC Model Initialized ********************\n", + "2022-11-02 09:46:08 [INFO] idaes.init.fs.ess_hp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:08 [INFO] idaes.init.fs.hxc.hot_side: Initialization Complete\n", + "2022-11-02 09:46:08 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_in Initialisation Step 1 Complete.\n", + "2022-11-02 09:46:08 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:46:08 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxc.cold_side.properties_out Initialisation Step 1 Complete.\n", + "2022-11-02 09:46:08 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:46:08 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:46:08 [INFO] idaes.init.fs.hxc.cold_side: Initialization Complete\n", + "2022-11-02 09:46:09 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.hxc: Initialization Completed, optimal - Optimal Solution Found\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.cooler.control_volume: Initialization Complete\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.cooler: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.hx_pump.control_volume: Initialization Complete\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.hx_pump: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.ess_bfp_split: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.recycle_mixer: Initialization Complete: optimal - Optimal Solution Found\n", + "2022-11-02 09:46:09 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_in Initialisation Step 1 Complete.\n", + "2022-11-02 09:46:09 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:46:09 [INFO] idaes.init.dispatches.properties.solarsalt_properties: fs.hxd.hot_side.properties_out Initialisation Step 1 Complete.\n", + "2022-11-02 09:46:09 [INFO] idaes.init.dispatches.properties.solarsalt_properties: Initialization Step 1 Complete.\n", + "2022-11-02 09:46:09 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.hxd.hot_side: Initialization Complete\n", + "2022-11-02 09:46:09 [INFO] idaes.init.fs.hxd.cold_side: Initialization Complete\n", + "2022-11-02 09:46:10 [INFO] idaes.init.dispatches.properties.solarsalt_properties: State Released.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-02 09:46:10 [INFO] idaes.init.fs.hxd: Initialization Completed, optimal - Optimal Solution Found\n", + "Integrated Model Initialization = optimal\n", + "*************** Integrated Model Initialized ***************\n", + "Cost Initialization = optimal\n", + "******************** Costing Initialized *************************\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyomo.core:Setting Var 'fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.0629934683431687` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[0].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 30.37] Created an instance of the flowsheet and initialized it.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyomo.core:Setting Var 'blocks[1].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[2].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n", + "WARNING:pyomo.core:Setting Var 'blocks[3].process.fs.hxd.delta_temperature_in[0.0]' to a numeric value `0.06299346834317004` outside the bounds (4.9, 300).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[+ 0.65] Initialized the entire multiperiod optimization model.\n", + "[+ 0.00] Unfixed the degrees of freedom from each period model.\n" + ] + } + ], + "source": [ + "# Tracker\n", + "mp_usc_tracker = MultiPeriodUsc(\n", + " model_data=model_data\n", + ")\n", + "\n", + "thermal_tracker = Tracker(\n", + " tracking_model_object=mp_usc_tracker,\n", + " n_tracking_hour=n_tracking_hour,\n", + " solver=solver,\n", + " tracking_horizon=tracking_horizon,\n", + ")\n", + "\n", + "# Projection Tracker\n", + "mp_usc_projection_tracker = MultiPeriodUsc(\n", + " model_data=model_data\n", + ")\n", + "\n", + "thermal_projection_tracker = Tracker(\n", + " tracking_model_object=mp_usc_projection_tracker,\n", + " n_tracking_hour=n_tracking_hour,\n", + " solver=solver,\n", + " tracking_horizon=tracking_horizon,\n", + ")\n", + "\n", + "# Bidder\n", + "mp_usc_bidder = MultiPeriodUsc(\n", + " model_data=model_data\n", + ")\n", + "thermal_bidder = Bidder(\n", + " bidding_model_object=mp_usc_bidder,\n", + " n_scenario=n_scenario,\n", + " solver=solver,\n", + " forecaster=forecaster,\n", + " day_ahead_horizon=bidding_horizon,\n", + " real_time_horizon=tracking_horizon,\n", + ")\n", + "\n", + "# Coordinator\n", + "coordinator = DoubleLoopCoordinator(\n", + " bidder=thermal_bidder,\n", + " tracker=thermal_tracker,\n", + " projection_tracker=thermal_projection_tracker,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "6b2f211a", + "metadata": {}, + "source": [ + "Set up the `plugin_module` needed for the Prescient simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4a3b70af", + "metadata": {}, + "outputs": [], + "source": [ + "class PrescientPluginModule(ModuleType):\n", + " def __init__(self, get_configuration, register_plugins):\n", + " self.get_configuration = get_configuration\n", + " self.register_plugins = register_plugins\n", + "\n", + "\n", + "plugin_module = PrescientPluginModule(\n", + " get_configuration=coordinator.get_configuration,\n", + " register_plugins=coordinator.register_plugins,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "a6e289b9", + "metadata": {}, + "source": [ + "**IMPORTANT** Before proceeding with the rest of the notebook:\n", + "1. Install the `dispatches-sample-data` package by running `pip install dispatches-sample-data` in the working conda environment\n", + "\n", + "OR\n", + "\n", + "1. Download the RTS-GMLC dataset from [https://github.com/GridMod/RTS-GMLC] (or directly as a zipfile here) to your local machine\n", + "2. Update the value of the `rst_gmlc_data_dir` variable in the cell below to the appropriate location of the `RTS_Data/SourceData` subfolder on your local machine" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "86fac6ca", + "metadata": {}, + "outputs": [], + "source": [ + "# If installing the dispatches-sample-data\n", + "rts_gmlc_data_dir = str(rts_gmlc.source_data_path)\n", + "\n", + "# If downloading the data to the local machine use the following option with appropriate path\n", + "# rts_gmlc_data_dir = \"/projects/gmihybridsys/dguittet/data/RTS-GMLC/RTS_Data/SourceData\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "61a63971", + "metadata": {}, + "source": [ + "Declare the options for Prescient simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6e46669f", + "metadata": {}, + "outputs": [], + "source": [ + "options = {\n", + " \"data_path\": rts_gmlc_data_dir,\n", + " \"input_format\": \"rts-gmlc\",\n", + " \"simulate_out_of_sample\": True,\n", + " \"run_sced_with_persistent_forecast_errors\": True,\n", + " \"output_directory\": \"bidding_multiperiod_usc\",\n", + " \"start_date\": \"2020-07-10\",\n", + " \"num_days\": num_days,\n", + " \"sced_horizon\": tracking_horizon,\n", + " \"ruc_horizon\": bidding_horizon,\n", + " \"ruc_every_hours\": hourly_bidding_horizon,\n", + " \"compute_market_settlements\": True,\n", + " \"day_ahead_pricing\": \"LMP\",\n", + " \"ruc_mipgap\": 0.01,\n", + " \"symbolic_solver_labels\": True,\n", + " \"reserve_factor\": 0.0,\n", + " \"deterministic_ruc_solver\": \"gurobi\",\n", + " \"output_ruc_solutions\": True,\n", + " \"sced_solver\": \"gurobi\",\n", + " \"print_sced\": True,\n", + " \"enforce_sced_shutdown_ramprate\": True,\n", + " \"output_solver_logs\": True,\n", + " \"plugin\": {\n", + " \"doubleloop\": {\n", + " \"module\": plugin_module,\n", + " \"bidding_generator\": \"102_STEAM_3\",\n", + " }\n", + " }\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "id": "89675ac5", + "metadata": {}, + "source": [ + "Run Prescient simulator." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "02298741", + "metadata": { + "tags": [ + "nbval-skip" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initializing simulation...\n", + "Did not find reserves.csv; assuming no reserves\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:egret:Did not find reserves.csv; assuming no reserves\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:304: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:304: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:304: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:304: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:304: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:304: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n", + "C:\\Users\\susarlan\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\parsers\\rts_gmlc\\parser.py:256: FutureWarning: \n", + " Use pd.to_datetime instead.\n", + "\n", + " df = pd.read_csv(file_name,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting default t0 state in RTS-GMLC parser\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:egret:Setting default t0 state in RTS-GMLC parser\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dates to simulate: 2020-07-10 to 2020-07-10\n", + "RUC activation hours: 0, 4, 8, 12, 16, 20\n", + "Final RUC date: 2020-07-10\n", + "Using current day's forecasts for RUC solves\n", + "Using persistent forecast error model when projecting demand and renewables in SCED\n", + "\n", + "\n", + "Extracting scenario to simulate\n", + "Ipopt 3.13.2: max_iter=200\n", + "\n", + "\n", + "******************************************************************************\n", + "This program contains Ipopt, a library for large-scale nonlinear optimization.\n", + " Ipopt is released as open source code under the Eclipse Public License (EPL).\n", + " For more information visit http://projects.coin-or.org/Ipopt\n", + "\n", + "This version of Ipopt was compiled from source code available at\n", + " https://github.com/IDAES/Ipopt as part of the Institute for the Design of\n", + " Advanced Energy Systems Process Systems Engineering Framework (IDAES PSE\n", + " Framework) Copyright (c) 2018-2019. See https://github.com/IDAES/idaes-pse.\n", + "\n", + "This version of Ipopt was compiled using HSL, a collection of Fortran codes\n", + " for large-scale scientific computation. All technical papers, sales and\n", + " publicity material resulting from use of the HSL codes within IPOPT must\n", + " contain the following acknowledgement:\n", + " HSL, a collection of Fortran codes for large-scale scientific\n", + " computation. See http://www.hsl.rl.ac.uk.\n", + "******************************************************************************\n", "\n", + "This is Ipopt version 3.13.2, running with linear solver ma27.\n", + "\n", + "Number of nonzeros in equality constraint Jacobian...: 76699\n", + "Number of nonzeros in inequality constraint Jacobian.: 716\n", + "Number of nonzeros in Lagrangian Hessian.............: 23760\n", + "\n", + "Total number of variables............................: 29421\n", + " variables with only lower bounds: 336\n", + " variables with lower and upper bounds: 20109\n", + " variables with only upper bounds: 0\n", + "Total number of equality constraints.................: 29134\n", + "Total number of inequality constraints...............: 384\n", + " inequality constraints with only lower bounds: 48\n", + " inequality constraints with lower and upper bounds: 0\n", + " inequality constraints with only upper bounds: 336\n", + "\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 0 3.1311302e+09 2.83e+08 2.71e+01 -1.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", + " 1 3.1248284e+09 2.82e+08 5.22e+01 -1.0 4.17e+08 - 5.07e-02 2.84e-03f 1\n", + " 2 3.1018934e+09 2.80e+08 3.00e+02 -1.0 4.26e+08 - 5.32e-04 8.58e-03f 1\n", + " 3 3.0773563e+09 2.77e+08 5.53e+02 -1.0 4.22e+08 - 4.45e-05 9.13e-03f 1\n", + " 4 2.9761183e+09 2.67e+08 4.56e+03 -1.0 4.19e+08 - 4.06e-02 3.76e-02f 1\n", + " 5 2.9744249e+09 2.67e+08 4.56e+03 -1.0 4.14e+08 - 4.41e-04 7.30e-04f 1\n", + " 6 2.9735828e+09 2.67e+08 4.56e+03 -1.0 4.26e+08 - 5.68e-05 4.85e-04f 1\n", + " 7 2.9727907e+09 2.67e+08 4.56e+03 -1.0 4.26e+08 - 6.53e-03 5.08e-04f 1\n", + " 8 2.9637978e+09 2.65e+08 4.96e+03 -1.0 4.31e+08 - 8.30e-05 5.87e-03f 1\n", + " 9 2.9540949e+09 2.63e+08 5.41e+03 -1.0 4.30e+08 - 3.11e-03 6.34e-03f 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 10 2.9083730e+09 2.56e+08 1.60e+04 -1.0 4.30e+08 - 1.72e-02 2.99e-02f 1\n", + " 11 2.8476151e+09 2.46e+08 3.38e+04 -1.0 4.27e+08 - 1.00e-01 3.96e-02f 1\n", + " 12 2.5845274e+09 2.11e+08 3.44e+05 -1.0 4.40e+08 - 1.18e-03 1.64e-01f 1\n", + " 13 2.5817572e+09 2.11e+08 3.44e+05 -1.0 3.98e+08 - 1.25e-01 1.80e-03f 1\n", + " 14 2.5803763e+09 2.10e+08 3.43e+05 -1.0 4.20e+08 - 1.66e-03 8.68e-04f 1\n", + " 15 2.5763865e+09 2.10e+08 3.43e+05 -1.0 4.20e+08 - 6.70e-04 2.51e-03f 1\n", + " 16 2.3872042e+09 1.87e+08 4.38e+05 -1.0 4.19e+08 - 6.79e-03 1.19e-01f 1\n", + " 17 2.3852502e+09 1.87e+08 4.38e+05 -1.0 3.87e+08 - 1.30e-02 1.30e-03f 1\n", + " 18 2.3850512e+09 1.87e+08 4.38e+05 -1.0 3.89e+08 - 3.10e-03 2.15e-04f 1\n", + " 19 2.3847938e+09 1.87e+08 4.37e+05 -1.0 3.89e+08 - 2.30e-01 1.24e-03f 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 20 2.3839366e+09 1.84e+08 4.33e+05 -1.0 4.11e+08 - 5.82e-03 1.43e-02f 1\n", + " 21 2.3839107e+09 1.84e+08 4.32e+05 -1.0 7.15e+07 - 1.43e-02 8.37e-04f 1\n", + " 22 2.3835947e+09 1.82e+08 4.27e+05 -1.0 3.87e+07 - 2.41e-01 1.25e-02f 1\n", + " 23 2.3755596e+09 1.40e+08 3.35e+05 -1.0 3.85e+07 - 3.62e-03 2.96e-01f 1\n", + " 24 2.3753755e+09 1.38e+08 3.32e+05 -1.0 3.42e+07 - 1.11e-01 1.02e-02f 1\n", + " 25 2.3735451e+09 1.26e+08 3.02e+05 -1.0 3.40e+07 - 3.22e-03 9.70e-02f 1\n", + " 26 2.3715101e+09 1.12e+08 2.68e+05 -1.0 3.20e+07 - 8.86e-02 1.18e-01f 1\n", + " 27 2.3630602e+09 7.21e+07 1.70e+05 -1.0 2.94e+07 - 1.03e-02 5.03e-01f 1\n", + " 28 2.3579060e+09 4.75e+07 1.10e+05 -1.0 1.79e+07 - 2.15e-01 4.16e-01f 1\n", + " 29 2.3477175e+09 2.31e+07 6.20e+04 -1.0 1.12e+07 - 7.39e-01 6.73e-01f 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 30 2.3007298e+09 1.02e+07 6.14e+04 -1.0 1.70e+07 - 4.53e-01 9.42e-01f 1\n", + " 31 2.2467541e+09 1.19e+07 1.88e+04 -1.0 1.81e+07 - 6.10e-01 1.00e+00f 1\n", + " 32 2.2064254e+09 1.12e+07 1.04e+04 -1.0 1.60e+07 - 8.62e-01 1.00e+00f 1\n", + " 33 2.1941641e+09 4.94e+06 2.30e+03 -1.0 8.04e+06 - 4.70e-01 9.11e-01f 1\n", + " 34 2.1938838e+09 4.11e+06 1.91e+03 -1.0 1.05e+06 - 9.52e-03 1.71e-01f 1\n", + " 35 2.1938774e+09 4.09e+06 1.90e+03 -1.0 8.64e+05 - 1.39e-03 4.67e-03f 1\n", + " 36 2.1934146e+09 2.72e+06 1.26e+03 -1.0 8.58e+05 - 9.86e-01 3.39e-01f 1\n", + " 37 2.1933491e+09 2.53e+06 1.17e+03 -1.0 5.07e+05 - 3.11e-01 7.03e-02f 1\n", + " 38 2.1927682e+09 8.63e+05 3.87e+02 -1.0 4.66e+05 - 7.06e-01 6.71e-01f 1\n", + " 39 2.1924951e+09 3.69e+04 1.38e+01 -1.0 1.44e+05 - 9.50e-01 9.66e-01f 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 40 2.1924901e+09 1.28e+04 1.95e+01 -1.0 7.85e+05 - 2.54e-01 6.53e-01f 1\n", + " 41 2.1924901e+09 6.30e+03 3.88e+01 -1.0 8.44e+05 - 1.29e-01 5.09e-01h 1\n", + " 42 2.1924902e+09 2.81e+03 4.39e+01 -1.0 7.94e+05 - 3.42e-01 5.54e-01h 1\n", + " 43 2.1924902e+09 3.56e-02 7.55e+01 -1.0 8.62e+05 - 5.63e-03 1.00e+00f 1\n", + " 44 2.1924881e+09 7.84e-01 2.92e+00 -1.0 5.34e+05 - 7.22e-02 9.95e-01f 1\n", + " 45 2.1924879e+09 9.59e-03 3.92e-02 -1.0 3.57e+05 - 9.30e-01 1.00e+00f 1\n", + " 46 2.1924879e+09 2.38e-07 1.00e-06 -1.0 5.52e+05 - 1.00e+00 1.00e+00f 1\n", + " 47 2.1924879e+09 3.05e-06 2.57e-07 -2.5 2.74e+03 - 1.00e+00 1.00e+00f 1\n", + " 48 2.1924879e+09 2.01e-07 1.12e-08 -3.8 5.05e+03 - 1.00e+00 1.00e+00f 1\n", + " 49 2.1924879e+09 1.86e-07 1.36e-08 -5.7 1.10e+03 - 1.00e+00 1.00e+00f 1\n", + "In iteration 49, 48 Slacks too small, adjusting variable bounds\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 50 2.1924879e+09 1.94e-07 1.28e-08 -8.6 1.21e+02 - 1.00e+00 1.00e+00h 1\n", + "\n", + "Number of Iterations....: 50\n", + "\n", + " (scaled) (unscaled)\n", + "Objective...............: 2.1924878859498258e+09 2.1924878859498258e+09\n", + "Dual infeasibility......: 1.2774603908291213e-08 1.2774603908291213e-08\n", + "Constraint violation....: 2.5611370801925659e-09 1.9371509552001953e-07\n", + "Complementarity.........: 2.5457100086287576e-09 2.5457100086287576e-09\n", + "Overall NLP error.......: 2.5611370801925659e-09 1.9371509552001953e-07\n", "\n", - "Number of objective function evaluations = 227\n", - "Number of objective gradient evaluations = 14\n", - "Number of equality constraint evaluations = 228\n", - "Number of inequality constraint evaluations = 227\n", - "Number of equality constraint Jacobian evaluations = 207\n", - "Number of inequality constraint Jacobian evaluations = 207\n", - "Number of Lagrangian Hessian evaluations = 200\n", - "Total CPU secs in IPOPT (w/o function evaluations) = 4.479\n", - "Total CPU secs in NLP function evaluations = 858.796\n", "\n", - "EXIT: Maximum Number of Iterations Exceeded.\n" + "Number of objective function evaluations = 51\n", + "Number of objective gradient evaluations = 51\n", + "Number of equality constraint evaluations = 51\n", + "Number of inequality constraint evaluations = 51\n", + "Number of equality constraint Jacobian evaluations = 51\n", + "Number of inequality constraint Jacobian evaluations = 51\n", + "Number of Lagrangian Hessian evaluations = 50\n", + "Total CPU secs in IPOPT (w/o function evaluations) = 6.552\n", + "Total CPU secs in NLP function evaluations = 246.980\n", + "\n", + "EXIT: Optimal Solution Found.\n", + "Calculating PTDF Matrix Factorization\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:pyomo.core:Loading a SolverResults object with a warning status into model.name=\"unknown\";\n", - " - termination condition: maxIterations\n", - " - message from solver: Ipopt 3.13.2\\x3a Maximum Number of Iterations Exceeded.\n" + "INFO:egret:Calculating PTDF Matrix Factorization\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Calculating PTDF Matrix Factorization\n" + "\n", + "Pyomo model construction time: 6.12\n", + "\n", + "Set parameter MIPGap to value 0.01\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:egret:Calculating PTDF Matrix Factorization\n" + "INFO:gurobipy.gurobipy:Set parameter MIPGap to value 0.01\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gurobi Optimizer version 9.5.1 build v9.5.1rc2 (win64)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Gurobi Optimizer version 9.5.1 build v9.5.1rc2 (win64)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thread count: 4 physical cores, 8 logical processors, using up to 8 threads\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Thread count: 4 physical cores, 8 logical processors, using up to 8 threads\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimize a model with 79109 rows, 80702 columns and 323765 nonzeros\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Optimize a model with 79109 rows, 80702 columns and 323765 nonzeros\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model fingerprint: 0x9728f68e\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Model fingerprint: 0x9728f68e\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficient statistics:\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Coefficient statistics:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Matrix range [7e-03, 6e+04]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy: Matrix range [7e-03, 6e+04]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Objective range [1e+00, 1e+08]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy: Objective range [1e+00, 1e+08]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Bounds range [1e-03, 1e+01]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy: Bounds range [1e-03, 1e+01]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " RHS range [7e-03, 6e+01]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy: RHS range [7e-03, 6e+01]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concurrent LP optimizer: dual simplex and barrier\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Concurrent LP optimizer: dual simplex and barrier\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Showing barrier log only...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Showing barrier log only...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Presolve removed 19480 rows and 19122 columns\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Presolve removed 19480 rows and 19122 columns\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Presolve time: 0.10s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Presolve time: 0.10s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solved with barrier\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Solved with barrier\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solved in 0 iterations and 0.10 seconds (0.01 work units)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Solved in 0 iterations and 0.10 seconds (0.01 work units)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Infeasible or unbounded model\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:gurobipy.gurobipy:Infeasible or unbounded model\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "Pyomo model construction time: 0.41\n", - "\n", "Failed to solve deterministic RUC instance - likely because no feasible solution exists!\n", "Wrote failed RUC data to file=bad_ruc.json\n" ] }, { - "ename": "GurobiError", - "evalue": "Model too large for size-limited license; visit https://www.gurobi.com/free-trial for a full license", + "ename": "Exception", + "evalue": "Problem encountered during solve, termination_condition infeasibleOrUnbounded", "output_type": "error", "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mGurobiError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mPrescient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimulate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/simulator/prescient.py\u001b[0m in \u001b[0;36msimulate\u001b[0;34m(self, **options)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_simulate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_simulate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mPrescientConfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/simulator/prescient.py\u001b[0m in \u001b[0;36m_simulate\u001b[0;34m(self, options)\u001b[0m\n\u001b[1;32m 80\u001b[0m \"If you wish to simulate again create a new Prescient object.\")\n\u001b[1;32m 81\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimulate_called\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 82\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimulate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 83\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/simulator/simulator.py\u001b[0m in \u001b[0;36msimulate\u001b[0;34m(self, options)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0mfirst_time_step\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_first_time_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 95\u001b[0;31m \u001b[0moracle_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_initialization_oracle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfirst_time_step\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 96\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mtime_step\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtime_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime_steps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/simulator/oracle_manager.py\u001b[0m in \u001b[0;36mcall_initialization_oracle\u001b[0;34m(self, options, time_step)\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0;31m#################################################################\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 125\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_generate_pending_ruc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtime_step\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtime_step\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhour\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 126\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactivate_pending_ruc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/simulator/oracle_manager.py\u001b[0m in \u001b[0;36m_generate_pending_ruc\u001b[0;34m(self, options, uc_date, uc_hour, sim_state_for_ruc)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[0muc_hour\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 216\u001b[0m \u001b[0mdeterministic_ruc_instance\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 217\u001b[0;31m \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute_market_settlements\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 218\u001b[0m )\n\u001b[1;32m 219\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/simulator/oracle_manager.py\u001b[0m in \u001b[0;36m_solve_ruc\u001b[0;34m(self, options, uc_date, uc_hour, deterministic_ruc_instance, compute_market_settlements)\u001b[0m\n\u001b[1;32m 164\u001b[0m \u001b[0mdeterministic_ruc_instance\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0muc_date\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 166\u001b[0;31m \u001b[0muc_hour\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 167\u001b[0m )\n\u001b[1;32m 168\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcompute_market_settlements\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/engine/egret/engine.py\u001b[0m in \u001b[0;36msolve_deterministic_ruc\u001b[0;34m(self, options, ruc_instance, uc_date, uc_hour)\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[0mnetwork_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_network_type_to_egret_network_constraints\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mruc_network_type\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 107\u001b[0m \u001b[0mslack_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_slack_type_to_egret_slack_type\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mruc_slack_type\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 108\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_p\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve_deterministic_ruc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_ruc_solver\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mruc_instance\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muc_date\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muc_hour\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnetwork_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslack_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_ptdf_manager\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 109\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 110\u001b[0m def create_and_solve_day_ahead_pricing(self,\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/engine/egret/egret_plugin.py\u001b[0m in \u001b[0;36msolve_deterministic_ruc\u001b[0;34m(solver, options, ruc_instance_for_this_period, this_date, this_hour, network_type, slack_type, ptdf_manager)\u001b[0m\n\u001b[1;32m 285\u001b[0m \u001b[0mslack_type\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 286\u001b[0m ptdf_manager):\n\u001b[0;32m--> 287\u001b[0;31m \u001b[0mruc_instance_for_this_period\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdeterministic_ruc_solver\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mruc_instance_for_this_period\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnetwork_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslack_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mptdf_manager\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 288\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite_deterministic_ruc_instances\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/engine/egret/egret_plugin.py\u001b[0m in \u001b[0;36m_solve_deterministic_ruc\u001b[0;34m(deterministic_ruc_data, solver, options, network_type, slack_type, ptdf_manager)\u001b[0m\n\u001b[1;32m 350\u001b[0m \u001b[0mpyo_model\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 351\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 352\u001b[0;31m options.deterministic_ruc_solver_options)\n\u001b[0m\u001b[1;32m 353\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Pyomo model solve time:\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mst\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 354\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Prescient/prescient/engine/egret/egret_plugin.py\u001b[0m in \u001b[0;36mcall_solver\u001b[0;34m(solver, instance, options, solver_options, relaxed, set_instance)\u001b[0m\n\u001b[1;32m 51\u001b[0m m, results, solver = _solve_unit_commitment(instance, solver, mipgap, None,\n\u001b[1;32m 52\u001b[0m \u001b[0mtee\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbolic_solver_labels\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m solver_options, None, relaxed, set_instance=set_instance)\n\u001b[0m\u001b[1;32m 54\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0mmd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_save_uc_results\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrelaxed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Egret/egret/models/unit_commitment.py\u001b[0m in \u001b[0;36m_solve_unit_commitment\u001b[0;34m(m, solver, mipgap, timelimit, solver_tee, symbolic_solver_labels, solver_options, solve_method_options, relaxed, set_instance)\u001b[0m\n\u001b[1;32m 1608\u001b[0m \u001b[0mnetwork\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'branch'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodel_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'elements'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'elements'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'branch'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1609\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpower_balance\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'ptdf_power_flow'\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_ptdf_options\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'lazy'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mnetwork\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1610\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_outer_lazy_ptdf_solve_loop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmipgap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimelimit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msolver_tee\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbolic_solver_labels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msolver_options\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msolve_method_options\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrelaxed\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset_instance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mset_instance\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1611\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1612\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_solve_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msolver\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmipgap\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtimelimit\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msolver_tee\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msymbolic_solver_labels\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msolver_options\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msolve_method_options\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_solver\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset_instance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mset_instance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Egret/egret/models/unit_commitment.py\u001b[0m in \u001b[0;36m_outer_lazy_ptdf_solve_loop\u001b[0;34m(m, solver, mipgap, timelimit, solver_tee, symbolic_solver_labels, solver_options, solve_method_options, relaxed, set_instance)\u001b[0m\n\u001b[1;32m 915\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 916\u001b[0m \u001b[0mlpu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muc_instance_binary_relaxer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 917\u001b[0;31m \u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresults_init\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msolver\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_solve_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msolver\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmipgap\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtimelimit\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msolver_tee\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msymbolic_solver_labels\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msolver_options\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msolve_method_options\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_solver\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvars_to_load\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvars_to_load\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset_instance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mset_instance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 918\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlp_warmstart_iter_limit\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 919\u001b[0m \u001b[0mlp_warmstart_termination_cond\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlp_warmstart_iterations\u001b[0m \u001b[0;34m=\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/lustre/eaglefs/projects/gmihybridsys/dguittet/Egret/egret/common/solver_interface.py\u001b[0m in \u001b[0;36m_solve_model\u001b[0;34m(model, solver, mipgap, timelimit, solver_tee, symbolic_solver_labels, solver_options, solve_method_options, return_solver, vars_to_load, set_instance)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mset_instance\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_instance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbolic_solver_labels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msymbolic_solver_labels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtee\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msolver_tee\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mload_solutions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave_results\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0msolve_method_options\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 154\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 155\u001b[0m results = solver.solve(model, tee=solver_tee, \\\n", - "\u001b[0;32m~/.conda-envs/hybrid/lib/python3.7/site-packages/pyomo/solvers/plugins/solvers/persistent_solver.py\u001b[0m in \u001b[0;36msolve\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 466\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_initialize_callbacks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pyomo_model\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 467\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 468\u001b[0;31m \u001b[0m_status\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_apply_solver\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 469\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'_transformation_data'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transformation_data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.conda-envs/hybrid/lib/python3.7/site-packages/pyomo/solvers/plugins/solvers/gurobi_direct.py\u001b[0m in \u001b[0;36m_apply_solver\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_solver_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msetParam\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgurobipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGRB\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mParam\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mQCPDual\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 201\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 202\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_solver_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_callback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 203\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_needs_updated\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32msrc/gurobipy/model.pxi\u001b[0m in \u001b[0;36mgurobipy.Model.optimize\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mGurobiError\u001b[0m: Model too large for size-limited license; visit https://www.gurobi.com/free-trial for a full license" + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mException\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_19176\\3063286072.py\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mPrescient\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msimulate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\simulator\\prescient.py\u001b[0m in \u001b[0;36msimulate\u001b[1;34m(self, **options)\u001b[0m\n\u001b[0;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_value\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 74\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 75\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_simulate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 76\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 77\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m_simulate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mPrescientConfig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\simulator\\prescient.py\u001b[0m in \u001b[0;36m_simulate\u001b[1;34m(self, options)\u001b[0m\n\u001b[0;32m 80\u001b[0m \"If you wish to simulate again create a new Prescient object.\")\n\u001b[0;32m 81\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msimulate_called\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 82\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msimulate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 83\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 84\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mmain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\simulator\\simulator.py\u001b[0m in \u001b[0;36msimulate\u001b[1;34m(self, options)\u001b[0m\n\u001b[0;32m 93\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 94\u001b[0m \u001b[0mfirst_time_step\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime_manager\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_first_time_step\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 95\u001b[1;33m \u001b[0moracle_manager\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcall_initialization_oracle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfirst_time_step\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 96\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 97\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mtime_step\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mtime_manager\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime_steps\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\simulator\\oracle_manager.py\u001b[0m in \u001b[0;36mcall_initialization_oracle\u001b[1;34m(self, options, time_step)\u001b[0m\n\u001b[0;32m 123\u001b[0m \u001b[1;31m#################################################################\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 124\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 125\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_generate_pending_ruc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime_step\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdate\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime_step\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhour\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 126\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mactivate_pending_ruc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 127\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\simulator\\oracle_manager.py\u001b[0m in \u001b[0;36m_generate_pending_ruc\u001b[1;34m(self, options, uc_date, uc_hour, sim_state_for_ruc)\u001b[0m\n\u001b[0;32m 210\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 211\u001b[0m \u001b[1;31m# Solve RUC\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 212\u001b[1;33m deterministic_ruc_instance, ruc_market = self._solve_ruc(\n\u001b[0m\u001b[0;32m 213\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 214\u001b[0m \u001b[0muc_date\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\simulator\\oracle_manager.py\u001b[0m in \u001b[0;36m_solve_ruc\u001b[1;34m(self, options, uc_date, uc_hour, deterministic_ruc_instance, compute_market_settlements)\u001b[0m\n\u001b[0;32m 160\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m_solve_ruc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0muc_date\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0muc_hour\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdeterministic_ruc_instance\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcompute_market_settlements\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mbool\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 161\u001b[0m \u001b[1;34m''' Solve a RUC, and generate and solve market RUC if options indicate we should '''\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 162\u001b[1;33m deterministic_ruc_instance = self.engine.solve_deterministic_ruc(\n\u001b[0m\u001b[0;32m 163\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 164\u001b[0m \u001b[0mdeterministic_ruc_instance\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\engine\\egret\\engine.py\u001b[0m in \u001b[0;36msolve_deterministic_ruc\u001b[1;34m(self, options, ruc_instance, uc_date, uc_hour)\u001b[0m\n\u001b[0;32m 106\u001b[0m \u001b[0mnetwork_type\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_network_type_to_egret_network_constraints\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mruc_network_type\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 107\u001b[0m \u001b[0mslack_type\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_slack_type_to_egret_slack_type\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0moptions\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mruc_slack_type\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 108\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_p\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msolve_deterministic_ruc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_ruc_solver\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mruc_instance\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0muc_date\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0muc_hour\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnetwork_type\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mslack_type\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_ptdf_manager\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 109\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 110\u001b[0m def create_and_solve_day_ahead_pricing(self,\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\engine\\egret\\egret_plugin.py\u001b[0m in \u001b[0;36msolve_deterministic_ruc\u001b[1;34m(solver, options, ruc_instance_for_this_period, this_date, this_hour, network_type, slack_type, ptdf_manager)\u001b[0m\n\u001b[0;32m 278\u001b[0m \u001b[0mslack_type\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 279\u001b[0m ptdf_manager):\n\u001b[1;32m--> 280\u001b[1;33m \u001b[0mruc_instance_for_this_period\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdeterministic_ruc_solver\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mruc_instance_for_this_period\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msolver\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnetwork_type\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mslack_type\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mptdf_manager\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 281\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 282\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwrite_deterministic_ruc_instances\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\engine\\egret\\egret_plugin.py\u001b[0m in \u001b[0;36m_solve_deterministic_ruc\u001b[1;34m(deterministic_ruc_data, solver, options, network_type, slack_type, ptdf_manager)\u001b[0m\n\u001b[0;32m 334\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 335\u001b[0m \u001b[0mst\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 336\u001b[1;33m ruc_results, pyo_results, _ = call_solver(solver,\n\u001b[0m\u001b[0;32m 337\u001b[0m \u001b[0mpyo_model\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 338\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\prescient\\engine\\egret\\egret_plugin.py\u001b[0m in \u001b[0;36mcall_solver\u001b[1;34m(solver, instance, options, solver_options, relaxed, set_instance)\u001b[0m\n\u001b[0;32m 48\u001b[0m \u001b[0mmipgap\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mruc_mipgap\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 49\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 50\u001b[1;33m m, results, solver = _solve_unit_commitment(instance, solver, mipgap, None,\n\u001b[0m\u001b[0;32m 51\u001b[0m \u001b[0mtee\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msymbolic_solver_labels\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 52\u001b[0m solver_options, None, relaxed, set_instance=set_instance)\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\models\\unit_commitment.py\u001b[0m in \u001b[0;36m_solve_unit_commitment\u001b[1;34m(m, solver, mipgap, timelimit, solver_tee, symbolic_solver_labels, solver_options, solve_method_options, relaxed, set_instance)\u001b[0m\n\u001b[0;32m 1584\u001b[0m \u001b[0mnetwork\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'branch'\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mmodel_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'elements'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mbool\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'elements'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'branch'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1585\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpower_balance\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'ptdf_power_flow'\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_ptdf_options\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'lazy'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mnetwork\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1586\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0m_outer_lazy_ptdf_solve_loop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msolver\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmipgap\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtimelimit\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msolver_tee\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msymbolic_solver_labels\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msolver_options\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msolve_method_options\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mrelaxed\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mset_instance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mset_instance\u001b[0m \u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 1587\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1588\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0m_solve_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolver\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmipgap\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtimelimit\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolver_tee\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msymbolic_solver_labels\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolver_options\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolve_method_options\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreturn_solver\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mset_instance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mset_instance\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\models\\unit_commitment.py\u001b[0m in \u001b[0;36m_outer_lazy_ptdf_solve_loop\u001b[1;34m(m, solver, mipgap, timelimit, solver_tee, symbolic_solver_labels, solver_options, solve_method_options, relaxed, set_instance)\u001b[0m\n\u001b[0;32m 915\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 916\u001b[0m \u001b[0mlpu\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0muc_instance_binary_relaxer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 917\u001b[1;33m \u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresults_init\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msolver\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_solve_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolver\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmipgap\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtimelimit\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolver_tee\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msymbolic_solver_labels\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolver_options\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolve_method_options\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreturn_solver\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvars_to_load\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mvars_to_load\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mset_instance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mset_instance\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 918\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mlp_warmstart_iter_limit\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 919\u001b[0m \u001b[0mlp_warmstart_termination_cond\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresults\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlp_warmstart_iterations\u001b[0m \u001b[1;33m=\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\envs\\gmlc\\lib\\site-packages\\egret\\common\\solver_interface.py\u001b[0m in \u001b[0;36m_solve_model\u001b[1;34m(model, solver, mipgap, timelimit, solver_tee, symbolic_solver_labels, solver_options, solve_method_options, return_solver, vars_to_load, set_instance)\u001b[0m\n\u001b[0;32m 158\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 159\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mresults\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msolver\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtermination_condition\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0msafe_termination_conditions\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 160\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Problem encountered during solve, termination_condition {}'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msolver\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtermination_condition\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 161\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 162\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msolver\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mPersistentSolver\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mException\u001b[0m: Problem encountered during solve, termination_condition infeasibleOrUnbounded" ] } ], "source": [ "Prescient().simulate(**options)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "111446a3", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.7.10 ('hybrid')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1179,7 +2400,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.9.12" }, "vscode": { "interpreter": { From cbd11eb3d1813bc75f10bf65177676aad9aeaeac Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Mon, 7 Nov 2022 05:04:55 -0500 Subject: [PATCH 11/12] FE case design with CCS models --- .../storage/discharge_design_ccs.py | 1614 +++++++++++++++++ 1 file changed, 1614 insertions(+) create mode 100644 dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ccs.py diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ccs.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ccs.py new file mode 100644 index 000000000..1730ed179 --- /dev/null +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ccs.py @@ -0,0 +1,1614 @@ +################################################################################# +# DISPATCHES was produced under the DOE Design Integration and Synthesis +# Platform to Advance Tightly Coupled Hybrid Energy Systems program (DISPATCHES), +# and is copyright (c) 2022 by the software owners: The Regents of the University +# of California, through Lawrence Berkeley National Laboratory, National +# Technology & Engineering Solutions of Sandia, LLC, Alliance for Sustainable +# Energy, LLC, Battelle Energy Alliance, LLC, University of Notre Dame du Lac, et +# al. All rights reserved. +# +# Please see the files COPYRIGHT.md and LICENSE.md for full copyright and license +# information, respectively. Both files are also available online at the URL: +# "https://github.com/gmlc-dispatches/dispatches". +# +################################################################################# + +"""This is a Generalized Disjunctive Programming model for the +conceptual design of an ultra supercritical coal-fired power plant +integrated with a discharge storage system + +""" + +__author__ = "Naresh Susarla and Soraya Rawlings" + +import logging + +# Import Python libraries +from math import pi +from IPython import embed + +# Import Pyomo libraries +import pyomo.environ as pyo +from pyomo.environ import (Block, Param, Constraint, Objective, + TransformationFactory, SolverFactory, + Expression, value, log, exp, Var) +from pyomo.environ import units as pyunits +from pyomo.network import Arc +from pyomo.util.calc_var_value import calculate_variable_from_constraint +from pyomo.gdp import Disjunct, Disjunction +from pyomo.network.plugins import expand_arcs +from pyomo.contrib.fbbt.fbbt import _prop_bnds_root_to_leaf_map +from pyomo.core.expr.numeric_expr import ExternalFunctionExpression + +# Import IDAES libraries +import idaes.logger as idaeslog +import idaes.core.util.scaling as iscale +from idaes.core.util.initialization import propagate_state +from idaes.core.solvers.get_solver import get_solver +from idaes.core.util.model_statistics import degrees_of_freedom +from idaes.core import UnitModelCostingBlock +from idaes.models.unit_models import HeatExchanger, Heater, MomentumMixingType +from idaes.models.unit_models.heat_exchanger import delta_temperature_underwood_callback +from idaes.models_extra.power_generation.unit_models.helm import (HelmTurbineStage, + HelmSplitter, + HelmMixer) +from idaes.models.costing.SSLW import ( + SSLWCosting, + SSLWCostingData +) +from idaes.core.util.exceptions import ConfigurationError + +# Import ultra supercritical power plant model +from dispatches.case_studies.fossil_case.ultra_supercritical_plant import ( + ultra_supercritical_powerplant as usc) + +# Import properties package for Solar salt +from dispatches.properties import solarsalt_properties + + +scaling_obj = 1 + +def create_discharge_model(m, add_efficiency=None, power_max=None): + """Create flowsheet and add unit models. + + """ + + # Create a block to add charge storage model + m.fs.discharge = Block() + + # Add model data + _add_data(m) + + # Add Solar salt properties + m.fs.solar_salt_properties = solarsalt_properties.SolarsaltParameterBlock() + + ########################################################################### + # Add unit models + ########################################################################### + + # Declare splitter to divert condensate to discharge storage heat + # exchanger + m.fs.discharge.es_split = HelmSplitter( + property_package=m.fs.prop_water, + outlet_list=["to_fwh", "to_hxd"], + ) + + # Declare discharge storage heat exchanger + m.fs.discharge.hxd = HeatExchanger( + delta_temperature_callback=delta_temperature_underwood_callback, + hot_side_name="shell", + cold_side_name="tube", + shell={"property_package": m.fs.solar_salt_properties}, + tube={"property_package": m.fs.prop_water}, + ) + + + ########################################################################### + # Add constraints + ########################################################################### + _make_constraints(m, add_efficiency=add_efficiency, power_max=power_max) + + _solar_salt_ohtc_calculation(m) + + ########################################################################### + # Declare disjuncts + ########################################################################### + # Disjunction 1 for the sink of discharge HX consists of 2 disjuncts: + # 1. condpump_source_disjunct ======> condensate from condenser pump + # 2. fwh4_source_disjunct ======> condensate from feed water heater 4 + # 3. booster_source_disjunct ======> condensate from booster pump + # 4. bfp_source_disjunct ======> condensate from boiler feed water pump + # 5. fwh9_source_disjunct ======> condensate from feed water heater 9 + + # Declare disjuncts in disjunction 1 + m.fs.discharge.condpump_source_disjunct = Disjunct( + rule=condpump_source_disjunct_equations) + m.fs.discharge.fwh4_source_disjunct = Disjunct( + rule=fwh4_source_disjunct_equations) + m.fs.discharge.booster_source_disjunct = Disjunct( + rule=booster_source_disjunct_equations) + m.fs.discharge.bfp_source_disjunct = Disjunct( + rule=bfp_source_disjunct_equations) + m.fs.discharge.fwh9_source_disjunct = Disjunct( + rule=fwh9_source_disjunct_equations) + + # Declare disjuncts in disjunction 2 + m.fs.discharge.iplp_source_disjunct = Disjunct( + rule=iplp_source_disjunct_equations) + m.fs.discharge.hxd_source_disjunct = Disjunct( + rule=hxd_source_disjunct_equations) + + ########################################################################### + # Create stream arcs + ########################################################################### + + m.fs.discharge.essplit_to_hxd = Arc( + source=m.fs.discharge.es_split.to_hxd, + destination=m.fs.discharge.hxd.tube_inlet, + doc="Connection from ES splitter to HXD" + ) + TransformationFactory("network.expand_arcs").apply_to(m.fs.discharge) + + return m + + +def _add_data(m): + """Add data to the model + """ + + # Add Chemical Engineering cost index for 2019 + m.CE_index = 607.5 + + # Add operating hours + m.fs.discharge.hours_per_day = pyo.Param( + initialize=6, + doc='Number of hours of charging per day' + ) + + # Define number of years over which the costs are annualized + m.fs.discharge.num_of_years = pyo.Param( + initialize=30, + doc='Number of years for cost annualization') + + # Add data to compute overall heat transfer coefficient for the + # Solar salt storage heat exchanger using the Sieder-Tate + # correlation. Parameters for tube diameter and thickness assumed + # from the data in (2017) He et al., Energy Procedia 105, 980-985 + m.fs.discharge.data_hxd = { + 'tube_inner_dia': 0.032, + 'tube_outer_dia': 0.036, + 'k_steel': 21.5, + 'number_tubes': 20, + 'shell_inner_dia': 1 + } + m.fs.discharge.hxd_tube_inner_dia = pyo.Param( + initialize=m.fs.discharge.data_hxd['tube_inner_dia'], + doc='Tube inner diameter in m') + m.fs.discharge.hxd_tube_outer_dia = pyo.Param( + initialize=m.fs.discharge.data_hxd['tube_outer_dia'], + doc='Tube outer diameter in m') + m.fs.discharge.hxd_k_steel = pyo.Param( + initialize=m.fs.discharge.data_hxd['k_steel'], + doc='Thermal conductivity of steel in W/m.K') + m.fs.discharge.hxd_n_tubes = pyo.Param( + initialize=m.fs.discharge.data_hxd['number_tubes'], + doc='Number of tubes') + m.fs.discharge.hxd_shell_inner_dia = pyo.Param( + initialize=m.fs.discharge.data_hxd['shell_inner_dia'], + doc='Shell inner diameter in m') + + # Calculate sectional area of storage heat exchanger + m.fs.discharge.hxd_tube_cs_area = pyo.Expression( + expr=(pi / 4) * + (m.fs.discharge.hxd_tube_inner_dia**2), + doc="Tube inside cross sectional area in m2") + m.fs.discharge.hxd_tube_out_area = pyo.Expression( + expr=(pi / 4) * + (m.fs.discharge.hxd_tube_outer_dia**2), + doc="Tube cross sectional area including thickness in m2") + m.fs.discharge.hxd_shell_eff_area = pyo.Expression( + expr=( + (pi / 4) * + m.fs.discharge.hxd_shell_inner_dia**2 - + m.fs.discharge.hxd_n_tubes * + m.fs.discharge.hxd_tube_out_area + ), + doc="Effective shell cross sectional area in m2") + + m.fs.discharge.hxd_tube_dia_ratio = ( + m.fs.discharge.hxd_tube_outer_dia / m.fs.discharge.hxd_tube_inner_dia) + m.fs.discharge.hxd_log_tube_dia_ratio = log(m.fs.discharge.hxd_tube_dia_ratio) + + # Add fuel cost data + m.data_cost = { + 'coal_price': 2.11e-9, + } + m.fs.discharge.coal_price = pyo.Param( + initialize=m.data_cost['coal_price'], + doc='Coal price based on HHV in $/J') + + # Add parameters to calculate the Solar salt pump costing. Since + # the unit is not explicitly modeled, the IDAES cost method is not + # used for this equipment. The primary purpose of the salt pump + # is to move the molten salt without changing the pressure. Thus, + # the pressure head is computed assuming that the salt is moved on + # an average of 5m linear distance. + m.data_salt_pump = { + 'FT': 1.5, + 'FM': 2.0, + 'head': 3.281*5, + 'motor_FT': 1, + 'nm': 1 + } + m.fs.discharge.spump_FT = pyo.Param( + initialize=m.data_salt_pump['FT'], + doc='Pump Type Factor for vertical split case') + m.fs.discharge.spump_FM = pyo.Param( + initialize=m.data_salt_pump['FM'], + doc='Pump Material Factor Stainless Steel') + m.fs.discharge.spump_head = pyo.Param( + initialize=m.data_salt_pump['head'], + doc='Pump Head 5m in ft.') + m.fs.discharge.spump_motorFT = pyo.Param( + initialize=m.data_salt_pump['motor_FT'], + doc='Motor Shaft Type Factor') + m.fs.discharge.spump_nm = pyo.Param( + initialize=m.data_salt_pump['nm'], + doc='Motor Shaft Type Factor') + + +def _make_constraints(m, add_efficiency=None, power_max=None): + """Declare constraints for the discharge model + + """ + + m.fs.discharge_power_out = pyo.Var( + initialize=30, + bounds=(0, 200), + doc="Coal heat duty supplied to boiler in MW") + + m.fs.net_power = pyo.Expression( + expr=(m.fs.plant_power_out[0] + m.fs.discharge_power_out) + ) + + m.fs.boiler_efficiency = pyo.Var(initialize=0.9, + bounds=(0, 1), + doc="Boiler efficiency") + m.fs.boiler_efficiency_eq = pyo.Constraint( + expr=m.fs.boiler_efficiency == ( + 0.2143 * + (m.fs.net_power / power_max) + + 0.7357 + ), + doc="Boiler efficiency in fraction" + ) + m.fs.coal_heat_duty = pyo.Var( + initialize=1000, + bounds=(0, 1e5), + doc="Coal heat duty supplied to boiler in MW") + + if add_efficiency: + m.fs.coal_heat_duty_eq = pyo.Constraint( + expr=m.fs.coal_heat_duty * + m.fs.boiler_efficiency == + m.fs.plant_heat_duty[0] + ) + else: + m.fs.coal_heat_duty_eq = pyo.Constraint( + expr=m.fs.coal_heat_duty == m.fs.plant_heat_duty[0] + ) + + m.fs.cycle_efficiency = pyo.Var(initialize=0.4, + bounds=(0, 1), + doc="Cycle efficiency") + m.fs.cycle_efficiency_eq = pyo.Constraint( + expr=( + m.fs.cycle_efficiency * + m.fs.coal_heat_duty + ) == m.fs.net_power, + doc="Cycle efficiency" + ) + + +def _solar_salt_ohtc_calculation(m): + """Block of equations to compute overall heat transfer coefficient for + Solar salt heat exchanger + + """ + + # Calculate Reynolds number for the salt + m.fs.discharge.hxd.salt_reynolds_number = pyo.Expression( + expr=( + (m.fs.discharge.hxd.shell_inlet.flow_mass[0] * + m.fs.discharge.hxd_tube_outer_dia) / + (m.fs.discharge.hxd_shell_eff_area * + m.fs.discharge.hxd.hot_side.properties_in[0].visc_d_phase["Liq"]) + ), + doc="Salt Reynolds Number") + + # Calculate Prandtl number for the salt + m.fs.discharge.hxd.salt_prandtl_number = pyo.Expression( + expr=( + m.fs.discharge.hxd.hot_side.properties_in[0].cp_mass["Liq"] * + m.fs.discharge.hxd.hot_side.properties_in[0].visc_d_phase["Liq"] / + m.fs.discharge.hxd.hot_side.properties_in[0].therm_cond_phase["Liq"] + ), + doc="Salt Prandtl Number") + + # Calculate Prandtl Wall number for the salt + m.fs.discharge.hxd.salt_prandtl_wall = pyo.Expression( + expr=( + m.fs.discharge.hxd.hot_side.properties_out[0].cp_mass["Liq"] * + m.fs.discharge.hxd.hot_side.properties_out[0].visc_d_phase["Liq"] / + m.fs.discharge.hxd.hot_side.properties_out[0].therm_cond_phase["Liq"] + ), + doc="Salt Prandtl Number at wall") + + # Calculate Nusselt number for the salt + m.fs.discharge.hxd.salt_nusselt_number = pyo.Expression( + expr=( + 0.35 * + (m.fs.discharge.hxd.salt_reynolds_number**0.6) * + (m.fs.discharge.hxd.salt_prandtl_number**0.4) * + ((m.fs.discharge.hxd.salt_prandtl_number / + m.fs.discharge.hxd.salt_prandtl_wall) ** 0.25) * + (2**0.2) + ), + doc="Salt Nusslet Number from 2019, App Ener (233-234), 126") + + # Calculate Reynolds number for the steam + m.fs.discharge.hxd.steam_reynolds_number = pyo.Expression( + expr=( + m.fs.discharge.hxd.tube_inlet.flow_mol[0] * + m.fs.discharge.hxd.cold_side.properties_in[0].mw * + m.fs.discharge.hxd_tube_inner_dia / + (m.fs.discharge.hxd_tube_cs_area * + m.fs.discharge.hxd_n_tubes * + m.fs.discharge.hxd.cold_side.properties_in[0].visc_d_phase["Vap"]) + ), + doc="Steam Reynolds Number") + + # Calculate Reynolds number for the steam + m.fs.discharge.hxd.steam_prandtl_number = pyo.Expression( + expr=( + (m.fs.discharge.hxd.cold_side.properties_in[0].cp_mol / + m.fs.discharge.hxd.cold_side.properties_in[0].mw) * + m.fs.discharge.hxd.cold_side. + properties_in[0].visc_d_phase["Vap"] / + m.fs.discharge.hxd.cold_side.properties_in[0].therm_cond_phase["Vap"] + ), + doc="Steam Prandtl Number") + + # Calculate Reynolds number for the steam + m.fs.discharge.hxd.steam_nusselt_number = pyo.Expression( + expr=( + 0.023 * + (m.fs.discharge.hxd.steam_reynolds_number**0.8) * + (m.fs.discharge.hxd.steam_prandtl_number**(0.33)) * + ( + (m.fs.discharge.hxd.cold_side.properties_in[0].visc_d_phase["Vap"] / + m.fs.discharge.hxd.cold_side.properties_out[0].visc_d_phase["Liq"]) ** 0.14 + ) + ), + doc="Steam Nusslet Number from 2001 Zavoico, Sandia") + + # Calculate heat transfer coefficients for the salt and steam + # sides of discharge heat exchanger + m.fs.discharge.hxd.h_salt = pyo.Expression( + expr=( + m.fs.discharge.hxd.hot_side.properties_in[0].therm_cond_phase["Liq"] * + m.fs.discharge.hxd.salt_nusselt_number / + m.fs.discharge.hxd_tube_outer_dia + ), + doc="Salt side convective heat transfer coefficient in W/m.K") + m.fs.discharge.hxd.h_steam = pyo.Expression( + expr=( + m.fs.discharge.hxd.cold_side.properties_in[0].therm_cond_phase["Vap"] * + m.fs.discharge.hxd.steam_nusselt_number / + m.fs.discharge.hxd_tube_inner_dia + ), + doc="Steam side convective heat transfer coefficient in W/m.K") + + # Calculate overall heat transfer coefficient for Solar salt heat + # exchanger + @m.fs.discharge.hxd.Constraint(m.fs.time) + def constraint_hxd_ohtc(b, t): + return ( + m.fs.discharge.hxd.overall_heat_transfer_coefficient[t] * ( + 2 * m.fs.discharge.hxd_k_steel * + m.fs.discharge.hxd.h_steam + + m.fs.discharge.hxd_tube_outer_dia * + m.fs.discharge.hxd_log_tube_dia_ratio * + m.fs.discharge.hxd.h_salt * + m.fs.discharge.hxd.h_steam + + m.fs.discharge.hxd_tube_dia_ratio * + m.fs.discharge.hxd.h_salt * + 2 * m.fs.discharge.hxd_k_steel + ) + ) == (2 * m.fs.discharge.hxd_k_steel * + m.fs.discharge.hxd.h_salt * + m.fs.discharge.hxd.h_steam) + + +def disconnect_arcs(m): + """Disconnect arcs from ultra-supercritical plant base model to + connect the Solar salt discharge storage system + + """ + + for arc_s in [ + m.fs.condpump_to_fwh1, + m.fs.fwh4_to_fwh5, + m.fs.booster_to_fwh6, + m.fs.bfp_to_fwh8, + m.fs.fwh9_to_boiler, + m.fs.t6split_to_bfpt, + m.fs.bfpt_to_condmix + ]: + arc_s.expanded_block.enth_mol_equality.deactivate() + arc_s.expanded_block.flow_mol_equality.deactivate() + arc_s.expanded_block.pressure_equality.deactivate() + + +def add_disjunction(m): + """Add disjunction for the selection of condensate source to integrate + the discharge storage system to the power plant model + + """ + + # Add disjunction 2 for ccs steam source selection + m.fs.ccs_source_disjunction = Disjunction( + expr=[ + m.fs.discharge.iplp_source_disjunct, + m.fs.discharge.hxd_source_disjunct + ] + ) + + # Add disjunction 1 for condensate source selection + m.fs.hxd_source_disjunction = Disjunction( + expr=[ + m.fs.discharge.booster_source_disjunct, + m.fs.discharge.bfp_source_disjunct, + m.fs.discharge.fwh4_source_disjunct, + m.fs.discharge.fwh9_source_disjunct, + m.fs.discharge.condpump_source_disjunct + ] + ) + + # Expand arcs within the disjuncts + expand_arcs.obj_iter_kwds['descend_into'] = (Block, Disjunct) + TransformationFactory("network.expand_arcs").apply_to(m.fs.discharge) + + return m + + +def iplp_source_disjunct_equations(disj): + """Block of equations for disjunct 1 in disjunction 1 for the selection + of condensate water source from condenser pump + + """ + + m = disj.model() + + # Declare turbine for storage system + m.fs.discharge.iplp_source_disjunct.es_turbine = HelmTurbineStage( + property_package=m.fs.prop_water + ) + + m.fs.discharge.iplp_source_disjunct.es_turbine.efficiency_isentropic.fix(0.8) + + for est in [m.fs.discharge.iplp_source_disjunct.es_turbine.control_volume]: + iscale.set_scaling_factor(est.work, 1e-6) + + # + (m.fs.discharge.es_turbine.control_volume.work[0] * (-1e-6)) + # Add a constraint to storage turbine to ensure that the outlet + # temperature is at the saturation temperature + @m.fs.discharge.iplp_source_disjunct.es_turbine.Constraint( + m.fs.time, + doc="Turbine outlet should be a saturated steam") + def constraint_esturbine_temperature_out(b, t): + return ( + b.control_volume.properties_out[t].temperature == + b.control_volume.properties_out[t].temperature_sat + 1 + ) + @m.fs.discharge.iplp_source_disjunct.Constraint( + m.fs.time, + doc="Turbine outlet should be a saturated steam") + def constraint_storage_power_out(b, t): + return ( + m.fs.discharge_power_out == + (b.es_turbine.control_volume.work[0] * (-1e-6)) + ) + + m.fs.discharge.iplp_source_disjunct.hxd_to_esturbine = Arc( + source=m.fs.discharge.hxd.tube_outlet, + destination=m.fs.discharge.iplp_source_disjunct.es_turbine.inlet, + doc="Connection from HXD to ES turbine" + ) + + # Add splitter to send a fraction of steam to the charge storage + # system + m.fs.discharge.iplp_source_disjunct.bfpt_split = HelmSplitter( + property_package=m.fs.prop_water, + outlet_list=["to_ccs", "to_bfpt"], + ) + m.fs.discharge.iplp_source_disjunct.bfpt_mixer = HelmMixer( + momentum_mixing_type=MomentumMixingType.minimize, + inlet_list=["bfpt", "ccs"], + property_package=m.fs.prop_water, + ) + + m.fs.discharge.iplp_source_disjunct.t6split_to_bfptsplit = Arc( + source=m.fs.turbine_splitter[6].outlet_3, + destination=m.fs.discharge.iplp_source_disjunct.bfpt_split.inlet, + doc="Connection from Turbine 6 outlet 3 to bfpt split" + ) + m.fs.discharge.iplp_source_disjunct.bfptsplit_to_bfpt = Arc( + source=m.fs.discharge.iplp_source_disjunct.bfpt_split.to_bfpt, + destination=m.fs.bfpt.inlet, + doc="Connection from bfpt split to bfpt" + ) + m.fs.discharge.iplp_source_disjunct.bfptsplit_to_ccs = Arc( + source=m.fs.discharge.iplp_source_disjunct.bfpt_split.to_ccs, + destination=m.fs.ccs_reboiler.inlet, + doc="Connection from bfpt split to ccs reboiler" + ) + + m.fs.discharge.iplp_source_disjunct.ccs_to_mix = Arc( + source=m.fs.ccs_reboiler.outlet, + destination=m.fs.discharge.iplp_source_disjunct.bfpt_mixer.ccs, + doc="Connection from ccs split to ccs reboiler" + ) + m.fs.discharge.iplp_source_disjunct.bfpt_to_mix = Arc( + source=m.fs.bfpt.outlet, + destination=m.fs.discharge.iplp_source_disjunct.bfpt_mixer.bfpt, + doc="Connection from ccs split to ccs reboiler" + ) + m.fs.discharge.iplp_source_disjunct.mix_to_cond = Arc( + source=m.fs.discharge.iplp_source_disjunct.bfpt_mixer.outlet, + destination=m.fs.condenser_mix.bfpt, + doc="Connection from ccs split to ccs reboiler" + ) + + m.fs.discharge.iplp_source_disjunct.bfpt_mixer.bfpt.flow_mol[0].setlb(0) + m.fs.discharge.iplp_source_disjunct.bfpt_mixer.bfpt.flow_mol[0].setub(15000) + m.fs.discharge.iplp_source_disjunct.bfpt_mixer.ccs.flow_mol[0].setlb(0) + m.fs.discharge.iplp_source_disjunct.bfpt_mixer.ccs.flow_mol[0].setub(15000) + m.fs.discharge.iplp_source_disjunct.bfpt_mixer.outlet.flow_mol[0].setlb(0) + m.fs.discharge.iplp_source_disjunct.bfpt_mixer.outlet.flow_mol[0].setub(15000) + m.fs.condenser_mix.bfpt.flow_mol[0].setlb(0) + m.fs.condenser_mix.bfpt.flow_mol[0].setub(15000) + for unit_k in [m.fs.discharge.iplp_source_disjunct.es_turbine]: + unit_k.inlet.flow_mol[:].setlb(0) + unit_k.inlet.flow_mol[:].setub(5000) + unit_k.outlet.flow_mol[:].setlb(0) + unit_k.outlet.flow_mol[:].setub(5000) + + unit_k.control_volume.work[:].setub(0) + unit_k.control_volume.work[:].setlb(-1e8) + # unit_k.inlet.pressure[:].setlb(0) + # unit_k.inlet.pressure[:].setub(1e12) + # unit_k.outlet.pressure[:].setlb(0) + # unit_k.outlet.pressure[:].setub(1e12) + unit_k.deltaP[:].setlb(0) + unit_k.deltaP[:].setub(1e9) + + +# def hxd_source_disjunct_equations(m): +def hxd_source_disjunct_equations(disj): + """Block of equations for disjunct 1 in disjunction 1 for the selection + of condensate water source from condenser pump + + """ + + m = disj.model() + + # Define arcs to connect units within disjunct + m.fs.discharge_power_out.fix(0) + + m.fs.discharge.hxd_source_disjunct.t6split_to_bfpt = Arc( + source=m.fs.turbine_splitter[6].outlet_3, + destination=m.fs.bfpt.inlet + ) + m.fs.discharge.hxd_source_disjunct.bfpt_to_cond = Arc( + source=m.fs.bfpt.outlet, + destination=m.fs.condenser_mix.bfpt, + doc="Connection from ccs split to ccs reboiler" + ) + m.fs.discharge.hxd_source_disjunct.hxd_to_ccs = Arc( + source=m.fs.discharge.hxd.tube_outlet, + destination=m.fs.ccs_reboiler.inlet, + doc="Connection from Turbine 6 outlet 3 to ccs split" + ) + + # m.fs.discharge.hxd_source_disjunct.ccs_split = HelmSplitter( + # property_package=m.fs.prop_water, + # outlet_list=["to_ccs", "to_esturb"], + # ) + # m.fs.discharge.hxd_source_disjunct.hxd_to_ccsplit = Arc( + # source=m.fs.discharge.hxd.tube_outlet, + # destination=m.fs.discharge.hxd_source_disjunct.ccs_split.inlet, + # doc="Connection from Turbine 6 outlet 3 to ccs split" + # ) + # m.fs.discharge.hxd_source_disjunct.ccsplit_to_turbine = Arc( + # source=m.fs.discharge.hxd_source_disjunct.ccs_split.to_esturb, + # destination=m.fs.discharge.es_turbine.inlet, + # doc="Connection from ccs split to es turbine" + # ) + # m.fs.discharge.hxd_source_disjunct.ccsplit_to_ccs = Arc( + # source=m.fs.discharge.hxd_source_disjunct.ccs_split.to_ccs, + # destination=m.fs.ccs_reboiler.inlet, + # doc="Connection from ccs split to ccs reboiler" + # ) + + # # m.fs.discharge.hxd_source_disjunct.hxd_to_ccs = Arc( + # # source=m.fs.discharge.hxd.tube_outlet, + # # destination=m.fs.ccs_reboiler.inlet, + # # doc="Connection from hxd to ccs reboiler" + # # ) + +def condpump_source_disjunct_equations(disj): + """Block of equations for disjunct 1 in disjunction 1 for the selection + of condensate water source from condenser pump + + """ + + m = disj.model() + + # Define arcs to connect units within disjunct + m.fs.discharge.condpump_source_disjunct.condpump_to_essplit = Arc( + source=m.fs.cond_pump.outlet, + destination=m.fs.discharge.es_split.inlet, + doc="Connection from Condenser pump to ES splitter" + ) + m.fs.discharge.condpump_source_disjunct.essplit_to_fwh1 = Arc( + source=m.fs.discharge.es_split.to_fwh, + destination=m.fs.fwh[1].tube_inlet, + doc="Connection from ES splitter to FWH1" + ) + + m.fs.discharge.condpump_source_disjunct.fwh4_to_fwh5 = Arc( + source=m.fs.fwh[4].tube_outlet, + destination=m.fs.fwh[5].tube_inlet, + doc="Connection from FWH4 to FWH5" + ) + + m.fs.discharge.condpump_source_disjunct.booster_to_fwh6 = Arc( + source=m.fs.booster.outlet, + destination=m.fs.fwh[6].tube_inlet, + doc="Connection from booster pump to FWH6" + ) + + m.fs.discharge.condpump_source_disjunct.bfp_to_fwh8 = Arc( + source=m.fs.bfp.outlet, + destination=m.fs.fwh[8].tube_inlet, + doc="Connection from BFP to FWH8" + ) + + m.fs.discharge.condpump_source_disjunct.fwh9_to_boiler = Arc( + source=m.fs.fwh[9].tube_outlet, + destination=m.fs.boiler.inlet, + doc="Connection from FWH9 to boiler" + ) + + +def fwh4_source_disjunct_equations(disj): + """Block of equations for disjunct 2 in disjunction 1 for the selection + of condensate water source from feed water heater 4 + + """ + + m = disj.model() + + # Define arcs to connect units within disjunct + m.fs.discharge.fwh4_source_disjunct.fwh4_to_essplit = Arc( + source=m.fs.fwh[4].tube_outlet, + destination=m.fs.discharge.es_split.inlet, + doc="Connection from FWH4 to ES splitter" + ) + m.fs.discharge.fwh4_source_disjunct.essplit_to_fwh5 = Arc( + source=m.fs.discharge.es_split.to_fwh, + destination=m.fs.fwh[5].tube_inlet, + doc="Connection from ES splitter to FWH5" + ) + + m.fs.discharge.fwh4_source_disjunct.condpump_to_fwh1 = Arc( + source=m.fs.cond_pump.outlet, + destination=m.fs.fwh[1].tube_inlet, + doc="Connection from condenser pump to FWH1" + ) + + m.fs.discharge.fwh4_source_disjunct.booster_to_fwh6 = Arc( + source=m.fs.booster.outlet, + destination=m.fs.fwh[6].tube_inlet, + doc="Connection from booster pump to FWH6" + ) + + m.fs.discharge.fwh4_source_disjunct.bfp_to_fwh8 = Arc( + source=m.fs.bfp.outlet, + destination=m.fs.fwh[8].tube_inlet, + doc="Connection from BFP to FWH8" + ) + + m.fs.discharge.fwh4_source_disjunct.fwh9_to_boiler = Arc( + source=m.fs.fwh[9].tube_outlet, + destination=m.fs.boiler.inlet, + doc="Connection from FWH9 to boiler" + ) + + +def booster_source_disjunct_equations(disj): + """Block of equations for disjunct 3 in disjunction 1 for the + selection of condensate water source from booster pump + + """ + + m = disj.model() + + # Define arcs to connect units within disjunct + m.fs.discharge.booster_source_disjunct.booster_to_essplit = Arc( + source=m.fs.booster.outlet, + destination=m.fs.discharge.es_split.inlet, + doc="Connection from Booster pump to ES splitter" + ) + m.fs.discharge.booster_source_disjunct.essplit_to_fwh6 = Arc( + source=m.fs.discharge.es_split.to_fwh, + destination=m.fs.fwh[6].tube_inlet, + doc="Connection from ES splitter to FWH6" + ) + + m.fs.discharge.booster_source_disjunct.fwh4_to_fwh5 = Arc( + source=m.fs.fwh[4].tube_outlet, + destination=m.fs.fwh[5].tube_inlet, + doc="Connection from FWH4 to FWH5" + ) + + m.fs.discharge.booster_source_disjunct.condpump_to_fwh1 = Arc( + source=m.fs.cond_pump.outlet, + destination=m.fs.fwh[1].tube_inlet, + doc="Connection from condenser pump to FWH1" + ) + + m.fs.discharge.booster_source_disjunct.bfp_to_fwh8 = Arc( + source=m.fs.bfp.outlet, + destination=m.fs.fwh[8].tube_inlet, + doc="Connection from BFP to FWH8" + ) + + m.fs.discharge.booster_source_disjunct.fwh9_to_boiler = Arc( + source=m.fs.fwh[9].tube_outlet, + destination=m.fs.boiler.inlet, + doc="Connection from FWH9 to boiler" + ) + + +def bfp_source_disjunct_equations(disj): + """Block of equations for disjunct 2 in disjunction 1 for the + selection of condensate water source from boiler feed water pump + + """ + + m = disj.model() + + # Define arcs to connect units within disjunct + m.fs.discharge.bfp_source_disjunct.bfp_to_essplit = Arc( + source=m.fs.bfp.outlet, + destination=m.fs.discharge.es_split.inlet, + doc="Connection from BFP to ES splitter" + ) + m.fs.discharge.bfp_source_disjunct.essplit_to_fwh8 = Arc( + source=m.fs.discharge.es_split.to_fwh, + destination=m.fs.fwh[8].tube_inlet, + doc="Connection from ES splitter to FWH8" + ) + + m.fs.discharge.bfp_source_disjunct.fwh4_to_fwh5 = Arc( + source=m.fs.fwh[4].tube_outlet, + destination=m.fs.fwh[5].tube_inlet, + doc="Connection from FWH4 to FWH5" + ) + + m.fs.discharge.bfp_source_disjunct.condpump_to_fwh1 = Arc( + source=m.fs.cond_pump.outlet, + destination=m.fs.fwh[1].tube_inlet, + doc="Connection from condenser pump to FWH1" + ) + + m.fs.discharge.bfp_source_disjunct.booster_to_fwh6 = Arc( + source=m.fs.booster.outlet, + destination=m.fs.fwh[6].tube_inlet, + doc="Connection from booster pump to FWH6" + ) + + m.fs.discharge.bfp_source_disjunct.fwh9_to_boiler = Arc( + source=m.fs.fwh[9].tube_outlet, + destination=m.fs.boiler.inlet, + doc="Connection from FWH9 to boiler" + ) + + +def fwh9_source_disjunct_equations(disj): + """Block of equations for disjunct 2 in disjunction 1 for the + selection of condensate water source from feed water heater 9 + + """ + + m = disj.model() + + # Define arcs to connect units within disjunct + m.fs.discharge.fwh9_source_disjunct.fwh9_to_essplit = Arc( + source=m.fs.fwh[9].tube_outlet, + destination=m.fs.discharge.es_split.inlet, + doc="Connection from FWH9 to the ES SPlitter" + ) + m.fs.discharge.fwh9_source_disjunct.essplit_to_boiler = Arc( + source=m.fs.discharge.es_split.to_fwh, + destination=m.fs.boiler.inlet, + doc="Connection from ES splitter to Boiler" + ) + + m.fs.discharge.fwh9_source_disjunct.fwh4_to_fwh5 = Arc( + source=m.fs.fwh[4].tube_outlet, + destination=m.fs.fwh[5].tube_inlet, + doc="Connection from FWH4 to FWH5" + ) + + m.fs.discharge.fwh9_source_disjunct.condpump_to_fwh1 = Arc( + source=m.fs.cond_pump.outlet, + destination=m.fs.fwh[1].tube_inlet, + doc="Connection from condenser pump to FWH1" + ) + + m.fs.discharge.fwh9_source_disjunct.booster_to_fwh6 = Arc( + source=m.fs.booster.outlet, + destination=m.fs.fwh[6].tube_inlet, + doc="Connection from booster to FWH6" + ) + + m.fs.discharge.fwh9_source_disjunct.bfp_to_fwh8 = Arc( + source=m.fs.bfp.outlet, + destination=m.fs.fwh[8].tube_inlet, + doc="Connection from BFP to FWH8" + ) + + +def set_model_input(m): + """Define model inputs such as fixed variables and parameter + values. The arameter values in this block, unless otherwise stated + explicitly, are either assumed or estimated for a total power out + of 437 MW. The inputs fixed in this function are the necessary + inputs to obtain a square model (0 degrees of freedom). + + Unless stated otherwise, the units are: temperature in K, pressure + in Pa, flow in mol/s, massic flow in kg/s, and heat and heat duty + in W + + """ + + ########################################################################### + # Fix data in discharge system + ########################################################################### + # Add heat exchanger area from supercritical plant model_input. For + # conceptual design optimization, area is unfixed and optimized + m.fs.discharge.hxd.area.fix(2000) + + # Define storage fluid conditions. The fluid inlet flow is fixed + # during initialization, but is unfixed and determined during + # optimization + m.fs.discharge.hxd.shell_inlet.flow_mass.fix(200) + m.fs.discharge.hxd.shell_inlet.temperature.fix(831.15) + m.fs.discharge.hxd.shell_inlet.pressure.fix(101325) + + m.fs.discharge.es_split.inlet.flow_mol.fix(17854) + m.fs.discharge.es_split.inlet.enth_mol.fix(52232) + m.fs.discharge.es_split.inlet.pressure.fix(3.4958e7) + + ########################################################################### + # Fix data in condensate source splitter + ########################################################################### + # The model is built for a fixed flow of condensate through the + # discharge heat exchanger. This condensate flow is unfixed and + # determined during design optimization + m.fs.discharge.es_split.split_fraction[0, "to_hxd"].fix(0.2) + + ########################################################################### + # Inputs for flue gas and capture units + ########################################################################### + m.fs.fg_to_ccs_splitfraction[:].fix(0.5) + m.fs.ccs_reboiler.inlet.pressure[0].fix(620984) + m.fs.ccs_reboiler.inlet.enth_mol[0].fix(58740) + m.fs.ccs_reboiler.inlet.flow_mol[0].fix(10740) + m.fs.ccs_reboiler.outlet.pressure[0].fix(7000) + # m.fs.ccs_reboiler.outlet.enth_mol[0].fix(3000) + +def set_scaling_factors(m): + """Scaling factors in the flowsheet + + """ + + # Include scaling factors for solar discharge heat exchanger + iscale.set_scaling_factor( + m.fs.ccs_reboiler.control_volume.heat, 1e-6) + for htf in [m.fs.discharge.hxd]: + iscale.set_scaling_factor(htf.area, 1e-2) + iscale.set_scaling_factor( + htf.overall_heat_transfer_coefficient, 1e-3) + iscale.set_scaling_factor(htf.tube.heat, 1e-6) + iscale.set_scaling_factor(htf.shell.heat, 1e-6) + + + +def initialize(m, solver=None, optarg=None, outlvl=idaeslog.NOTSET): + """Initialize the units included in the discharge model + + """ + + # Include scaling factors + iscale.calculate_scaling_factors(m) + + # Initialize splitter + m.fs.discharge.es_split.initialize(outlvl=outlvl, + optarg=optarg) + + propagate_state(m.fs.discharge.essplit_to_hxd) + m.fs.discharge.hxd.initialize(outlvl=outlvl, + optarg=optarg) + + # propagate_state(m.fs.discharge.hxd_to_esturbine) + # m.fs.discharge.es_turbine.initialize(outlvl=outlvl, + # optarg=optarg) + + # Check and raise an error if the degrees of freedom are not 0 + if not degrees_of_freedom(m) == 0: + raise ConfigurationError( + "The degrees of freedom after building the model are not 0. " + "You have {} degrees of freedom. " + "Please check your inputs to ensure a square problem " + "before initializing the model.".format(degrees_of_freedom(m)) + ) + + # Solve initialization + init_results = solver.solve(m, options=optarg) + print("Discharge model initialization solver termination:", + init_results.solver.termination_condition) + print("************* Discharge Model Initialized ******************") + + +def build_costing(m, solver=None): + """Add cost correlations for the storage design analysis + + This function is used to estimate the capital and operating cost + of integrating a discharge storage system to the power plant and + it contains cost correlations to estimate: (i) the capital cost of + discharge heat exchanger and Solar salt pump, and (ii) the + operating costs for 1 year + + """ + + ########################################################################### + # Add capital cost + # 1. Calculate discharge heat exchanger cost + # 2. Calculate Solar salt pump purchase cost + # 3. Calculate total capital cost of discharge system + + # Main assumptions + # 1. Salt life is assumed to outlast the plant life + # 2. The economic objective is to minimize total annualized cost. So, cash + # flows, discount rate, and NPV are not included in this study. + ########################################################################### + # Add capital cost: 1. Calculate discharge heat exchanger cost + ########################################################################### + # Calculate and initialize Solar salt discharge heat exchanger + # cost, which is estimated using the IDAES costing method with + # default options, i.e. a U-tube heat exchanger, stainless steel + # material, and a tube length of 12ft. Refer to costing + # documentation to change any of the default options. The purchase + # cost of heat exchanger has to be annualized when used + m.fs.costing = SSLWCosting() + + m.fs.discharge.hxd.costing = UnitModelCostingBlock( + flowsheet_costing_block=m.fs.costing, + costing_method=SSLWCostingData.cost_heat_exchanger, + ) + + ########################################################################### + # Add capital cost: 2. Calculate Solar salt pump purchase cost + ########################################################################### + # Pump for moving Solar salt is not explicity modeled. To compute + # the capital costs for this pump the capital cost expressions are + # added below. All cost expressions are from the same reference + # as the IDAES costing framework and is given below: Seider, + # Seader, Lewin, Windagdo, 3rd Ed. John Wiley and Sons, Chapter + # 22. Cost Accounting and Capital Cost Estimation, Section 22.2 Cost + # Indexes and Capital Investment + + # ---------- Solar salt ---------- + # Calculate purchase cost of Solar salt pump + m.fs.discharge.spump_Qgpm = pyo.Expression( + expr=(m.fs.discharge.hxd. + hot_side.properties_in[0].flow_mass * + (264.17 * pyo.units.gallon / pyo.units.m**3) * + (60 * pyo.units.s / pyo.units.min) / + (m.fs.discharge.hxd. + hot_side.properties_in[0].dens_mass["Liq"])), + doc="Conversion of Solar salt flow mass to volumetric flow in gallons/min" + ) + m.fs.discharge.dens_lbft3 = pyo.units.convert( + m.fs.discharge.hxd.hot_side.properties_in[0].dens_mass["Liq"], + to_units=pyo.units.pound / pyo.units.foot**3 + ) + m.fs.discharge.spump_sf = pyo.Expression( + expr=(m.fs.discharge.spump_Qgpm * + (m.fs.discharge.spump_head ** 0.5)), + doc="Pump size factor" + ) + # Expression for pump base purchase cost + m.fs.discharge.pump_CP = pyo.Expression( + expr=( + m.fs.discharge.spump_FT * m.fs.discharge.spump_FM * + exp( + 9.7171 - + 0.6019 * log(m.fs.discharge.spump_sf) + + 0.0519 * ((log(m.fs.discharge.spump_sf))**2) + ) + ), + doc="Base purchase cost of Solar salt pump in $" + ) + # Expression for pump efficiency + m.fs.discharge.spump_np = pyo.Expression( + expr=( + -0.316 + + 0.24015 * log(m.fs.discharge.spump_Qgpm) - + 0.01199 * ((log(m.fs.discharge.spump_Qgpm))**2) + ), + doc="Fractional efficiency of the pump in horsepower" + ) + m.fs.discharge.motor_pc = pyo.Expression( + expr=( + (m.fs.discharge.spump_Qgpm * + m.fs.discharge.spump_head * + m.fs.discharge.dens_lbft3) / + (33000 * + m.fs.discharge.spump_np * + m.fs.discharge.spump_nm) + ), + doc="Power consumption of motor in horsepower" + ) + + # Defining a local variable for the log of motor's power consumption + # This will help writing the motor's purchase cost expressions conciesly + _log_motor_pc = log(m.fs.discharge.motor_pc) + + # Expression for motor's purchase cost + m.fs.discharge.motor_CP = pyo.Expression( + expr=( + m.fs.discharge.spump_motorFT * + exp( + 5.8259 + + 0.13141 * _log_motor_pc + + 0.053255 * (_log_motor_pc**2) + + 0.028628 * (_log_motor_pc**3) - + 0.0035549 * (_log_motor_pc**4) + ) + ), + doc="Base cost of Solar salt pump's motor in $" + ) + + # Calculate and initialize total cost of Solar salt pump + m.fs.discharge.spump_purchase_cost = pyo.Var( + initialize=100000, + bounds=(0, 1e7), + doc="Total purchase cost of Solar salt pump in $" + ) + + def solar_spump_purchase_cost_rule(b): + return ( + m.fs.discharge.spump_purchase_cost == ( + m.fs.discharge.pump_CP + + m.fs.discharge.motor_CP) * + (m.CE_index / 394) + ) + m.fs.discharge.spump_purchase_cost_eq = pyo.Constraint( + rule=solar_spump_purchase_cost_rule) + + calculate_variable_from_constraint( + m.fs.discharge.spump_purchase_cost, + m.fs.discharge.spump_purchase_cost_eq) + + ########################################################################### + # Add capital cost: 3. Calculate total capital cost for discharge system + ########################################################################### + + # Add capital cost variable at flowsheet level to handle the Solar + # salt capital cost + m.fs.discharge.capital_cost = pyo.Var( + initialize=1000000, + bounds=(0, 1e10), + doc="Annualized capital cost in $/year") + + # Calculate and initialize annualized capital cost for the Solar + # salt discharge storage system + def solar_cap_cost_rule(b): + return ( + m.fs.discharge.capital_cost * + m.fs.discharge.num_of_years + ) == (m.fs.discharge.spump_purchase_cost + + m.fs.discharge.hxd.costing.capital_cost) + m.fs.discharge.cap_cost_eq = pyo.Constraint( + rule=solar_cap_cost_rule) + + calculate_variable_from_constraint( + m.fs.discharge.capital_cost, + m.fs.discharge.cap_cost_eq) + + ########################################################################### + # Add operating cost + ########################################################################### + m.fs.discharge.operating_hours = pyo.Expression( + expr=365 * 3600 * m.fs.discharge.hours_per_day, + doc="Number of operating hours per year") + m.fs.discharge.operating_cost = pyo.Var( + initialize=1000000, + bounds=(0, 1e11), + doc="Operating cost in $/year") + + def op_cost_rule(b): + return m.fs.discharge.operating_cost == ( + m.fs.discharge.operating_hours * + m.fs.discharge.coal_price * + m.fs.coal_heat_duty * 1e6 + ) + m.fs.discharge.op_cost_eq = pyo.Constraint(rule=op_cost_rule) + + # Initialize operating cost + calculate_variable_from_constraint( + m.fs.discharge.operating_cost, + m.fs.discharge.op_cost_eq) + + # Check and raise an error if the degrees of freedom are not 0 + if not degrees_of_freedom(m) == 0: + raise ConfigurationError( + "The degrees of freedom after building costing block are not 0. " + "You have {} degrees of freedom. " + "Please check your inputs to ensure a square problem " + "before initializing the model.".format(degrees_of_freedom(m)) + ) + + # Solve cost initialization + print() + # Add options to NLP solver + optarg = {"tol": 1e-8, + "max_iter": 300} + cost_results = solver.solve(m, options=optarg) + print("Cost initialization solver termination:", + cost_results.solver.termination_condition) + print("******************** Costing Initialized *************************") + print() + print() + + +def add_bounds(m, power_max=None): + """Add bounds to all units in discharge model + + """ + + m.flow_max = m.main_flow * 1.2 # Units in mol/s + m.storage_flow_max = 0.5 * m.flow_max # Units in mol/s + m.salt_flow_max = 1000 # Units in kg/s + m.heat_duty_bound = 200e6 # Units in MW + m.power_max = power_max # Units in MW + + # Add bounds to Solar salt discharge heat exchanger + for hxd in [m.fs.discharge.hxd]: + hxd.tube_inlet.flow_mol.setlb(0) + hxd.tube_inlet.flow_mol.setub(m.storage_flow_max) + hxd.shell_inlet.flow_mass.setlb(0) + hxd.shell_inlet.flow_mass.setub(m.salt_flow_max) + hxd.tube_outlet.flow_mol.setlb(0) + hxd.tube_outlet.flow_mol.setub(m.storage_flow_max) + hxd.shell_outlet.flow_mass.setlb(0) + hxd.shell_outlet.flow_mass.setub(m.salt_flow_max) + hxd.shell_inlet.pressure.setlb(101320) + hxd.shell_inlet.pressure.setub(101330) + hxd.shell_outlet.pressure.setlb(101320) + hxd.shell_outlet.pressure.setub(101330) + hxd.heat_duty.setlb(0) + hxd.heat_duty.setub(m.heat_duty_bound) + hxd.shell.heat.setlb(-m.heat_duty_bound) + hxd.shell.heat.setub(0) + hxd.tube.heat.setlb(0) + hxd.tube.heat.setub(m.heat_duty_bound) + hxd.shell.properties_in[0].enth_mass.setlb(0) + hxd.shell.properties_in[0].enth_mass.setub(1.5e6) + hxd.shell.properties_out[0].enth_mass.setlb(0) + hxd.shell.properties_out[0].enth_mass.setub(1.5e6) + hxd.overall_heat_transfer_coefficient.setlb(0) + hxd.overall_heat_transfer_coefficient.setub(10000) + hxd.area.setlb(0) + hxd.area.setub(5000) + hxd.costing.pressure_factor.setlb(0) + hxd.costing.pressure_factor.setub(1e5) + hxd.costing.capital_cost.setlb(0) + hxd.costing.capital_cost.setub(1e7) + hxd.costing.base_cost_per_unit.setlb(0) + hxd.costing.base_cost_per_unit.setub(1e6) + hxd.costing.material_factor.setlb(0) + hxd.costing.material_factor.setub(10) + hxd.delta_temperature_in.setlb(10) + hxd.delta_temperature_out.setlb(9) + hxd.delta_temperature_in.setub(298) + hxd.delta_temperature_out.setub(500) + + # Add bounds needed in units declared in condensate source + # disjunction + for split in [m.fs.discharge.es_split]: + split.inlet.flow_mol[:].setlb(0) + split.inlet.flow_mol[:].setub(m.flow_max) + split.to_hxd.flow_mol[:].setlb(0) + split.to_hxd.flow_mol[:].setub(m.storage_flow_max) + split.to_fwh.flow_mol[:].setlb(0) + split.to_fwh.flow_mol[:].setub(m.flow_max) + split.split_fraction[0.0, "to_hxd"].setlb(0) + split.split_fraction[0.0, "to_hxd"].setub(1) + split.split_fraction[0.0, "to_fwh"].setlb(0) + split.split_fraction[0.0, "to_fwh"].setub(1) + + # m.fs.plant_power_out[0].setlb(300) + # m.fs.plant_power_out[0].setub(m.power_max) + + # m.fs.turbine_splitter[6].split_fraction[0.0, "outlet_3"].setlb(0) + # m.fs.turbine_splitter[6].split_fraction[0.0, "outlet_3"].setub(1) + m.fs.turbine_splitter[6].outlet_3.flow_mol.setlb(0) + m.fs.turbine_splitter[6].outlet_3.flow_mol.setub(m.flow_max) + + for unit_k in [m.fs.booster]: + unit_k.inlet.flow_mol[:].setlb(0) + unit_k.inlet.flow_mol[:].setub(m.flow_max) + unit_k.outlet.flow_mol[:].setlb(0) + unit_k.outlet.flow_mol[:].setub(m.flow_max) + + # for unit_k in [m.fs.discharge.iplp_source_disjunct.es_turbine]: + # unit_k.inlet.flow_mol[:].setlb(0) + # unit_k.inlet.flow_mol[:].setub(m.storage_flow_max) + # unit_k.outlet.flow_mol[:].setlb(0) + # unit_k.outlet.flow_mol[:].setub(m.storage_flow_max) + + # unit_k.inlet.pressure[:].setlb(0) + # unit_k.inlet.pressure[:].setub(1e12) + # unit_k.outlet.pressure[:].setlb(0) + # unit_k.outlet.pressure[:].setub(1e12) + # unit_k.ratioP[:].setlb(0) + # unit_k.ratioP[:].setub(1e12) + + for unit_k in [m.fs.ccs_reboiler]: + unit_k.inlet.flow_mol[:].setlb(0) + unit_k.inlet.flow_mol[:].setub(m.flow_max) + unit_k.outlet.flow_mol[:].setlb(0) + unit_k.outlet.flow_mol[:].setub(m.flow_max) + + for k in m.set_turbine: + m.fs.turbine[k].work.setlb(-1e10) + m.fs.turbine[k].work.setub(0) + + for split1 in [m.fs.discharge.iplp_source_disjunct.bfpt_split]: + split1.inlet.flow_mol[:].setlb(0) + split1.inlet.flow_mol[:].setub(m.flow_max) + split1.to_ccs.flow_mol[:].setlb(0) + split1.to_ccs.flow_mol[:].setub(m.flow_max) + split1.to_bfpt.flow_mol[:].setlb(0) + split1.to_bfpt.flow_mol[:].setub(m.flow_max) + split1.split_fraction[0.0, "to_ccs"].setlb(0) + split1.split_fraction[0.0, "to_ccs"].setub(1) + split1.split_fraction[0.0, "to_bfpt"].setlb(0) + split1.split_fraction[0.0, "to_bfpt"].setub(1) + + # for split2 in [m.fs.discharge.hxd_source_disjunct.ccs_split]: + # split2.inlet.flow_mol[:].setlb(0) + # split2.inlet.flow_mol[:].setub(m.storage_flow_max) + # split2.to_ccs.flow_mol[:].setlb(0) + # split2.to_ccs.flow_mol[:].setub(m.storage_flow_max) + # split2.to_esturb.flow_mol[:].setlb(0) + # split2.to_esturb.flow_mol[:].setub(m.storage_flow_max) + # split2.split_fraction[0.0, "to_ccs"].setlb(0) + # split2.split_fraction[0.0, "to_ccs"].setub(1) + # split2.split_fraction[0.0, "to_esturb"].setlb(0) + # split2.split_fraction[0.0, "to_esturb"].setub(1) + + +def main(m_usc, solver=None, optarg=None): + + # Add boiler and cycle efficiencies to the model + add_efficiency = True + + # Add maximum power produced by power plant in MW. For this + # analysis, the maximum power is fixed to 436 MW + power_max = 436 + + # Create a flowsheet, add properties, unit models, and arcs + m = create_discharge_model(m_usc, + add_efficiency=add_efficiency, + power_max=power_max) + + # Give all the required inputs to the model + set_model_input(m) + + # Add scaling factor + set_scaling_factors(m) + + # Initialize the model with a sequential initialization + initialize(m, solver=solver, optarg=optarg) + + # Add cost correlations + build_costing(m, solver=solver) + + # Add bounds + add_bounds(m, power_max=power_max) + + # Disconnect arcs to include discharge storage system + disconnect_arcs(m) + + # Add disjunction + add_disjunction(m) + + return m + + +def print_model(_, nlp_model, nlp_data): + """Print the disjunction selected during the solution of the NLP + subproblem + + """ + + nlp = nlp_model.fs.discharge + print(' ___________________________________________') + print(' Disjunction 1:') + if nlp.condpump_source_disjunct.binary_indicator_var.value == 1: + print(' Condensate from condenser pump is selected') + elif nlp.booster_source_disjunct.binary_indicator_var.value == 1: + print(' Condensate from booster pump is selected') + elif nlp.bfp_source_disjunct.binary_indicator_var.value == 1: + print(' Condensate from boiler feed pump is selected') + elif nlp.fwh9_source_disjunct.binary_indicator_var.value == 1: + print(' Condensate from FWH9 is selected') + elif nlp.fwh4_source_disjunct.binary_indicator_var.value == 1: + print(' Condensate from FWH4 is selected') + else: + print(' Error: There are no more alternatives') + print(' ___________________________________________') + print(' Disjunction 2:') + if nlp.iplp_source_disjunct.binary_indicator_var.value == 1: + print(' CCS Steam from IP LP crossover is selected') + elif nlp.hxd_source_disjunct.binary_indicator_var.value == 1: + print(' CCS Steam from HXD is selected') + else: + print(' Error: There are no more alternatives') + print(' ___________________________________________') + print() + + +def run_gdp(m): + """Declare solver GDPopt and its options + """ + + # Add options to GDPopt + opt = SolverFactory('gdpopt') + _prop_bnds_root_to_leaf_map[ExternalFunctionExpression] = lambda x, y, z: None + + # Solve model + results = opt.solve( + m, + tee=True, + algorithm='LOA', + init_algorithm="no_init", + subproblem_presolve=False, + mip_solver='gurobi', + nlp_solver='ipopt', + call_after_subproblem_solve=print_model, + nlp_solver_args=dict( + tee=True, + options={ + "max_iter": 150} + ) + ) + + return results + + +def print_results(m, results): + + print('====================================================') + print('Results ') + print() + print('Obj (M$/year): {:.2f}'.format( + (pyo.value(m.obj) / scaling_obj) * 1e-6)) + print('Discharge capital cost (M$/y): {:.2f}'.format( + pyo.value(m.fs.discharge.capital_cost) * 1e-6)) + print('Net Power (MW): {:.2f}'.format( + pyo.value(m.fs.net_power))) + print('Plant Power (MW): {:.2f}'.format( + pyo.value(m.fs.plant_power_out[0]))) + print('Discharge Turbine Power (MW): {:.2f}'.format( + pyo.value(m.fs.discharge.iplp_source_disjunct.es_turbine.control_volume.work[0]) * (-1e-6))) + print('Boiler Efficiency (%): {:.2f}'.format( + pyo.value(m.fs.boiler_efficiency) * 100)) + print('CCS Reboiler Steam Flow: {:.2f}'.format( + pyo.value(m.fs.ccs_reboiler.inlet.flow_mol[0]))) + print('Flue Gas Flow: {:.2f}'.format( + pyo.value(m.fs.fg_flow_mol[0]))) + print('CO2 captured: {:.2f}'.format( + pyo.value(m.fs.co2_captured))) + print() + print("**Discrete design decisions (Disjunction)") + for d in m.component_data_objects(ctype=Disjunct, + active=True, + sort=True, descend_into=True): + if abs(d.binary_indicator_var.value - 1) < 1e-6: + print(d.name, ' should be selected!') + print('Discharge heat exchanger area (m2): {:.2f}'.format( + pyo.value(m.fs.discharge.hxd.area))) + print('Discharge heat exchanger heat duty (MW): {:.2f}'.format( + pyo.value(m.fs.discharge.hxd.heat_duty[0]) * 1e-6)) + print('====================================================') + print() + print('Solver details') + print(results) + print() + + +def add_flugas_calculations(m): + m.fs.co2_mw = Param( + initialize=44.01, + doc='molar weight of CO2 in g/mol' + ) + m.fs.SR = Param( + initialize=1.2, + doc='Stoichiometric ratio used to calculate coal flow rate' + ) + m.fs.coal_LHV = Param( + initialize=29544, + doc='LHV for Illinois no. 6 Bituminous coal from Baseline Rev 4, J/g' + ) + m.fs.carbon_wt = Param( + initialize=0.4972, + doc='Carbon in dry weight basis of the coal from Baseline Rev 4' + ) + m.fs.co2_molefrac = Param( + initialize=0.14, + doc='Mole fraction of CO2 in the flue gas of USC, 1999 DOE report' + ) + m.fs.fg_flow_mol = Var( + m.fs.config.time, + initialize=1000, + bounds=(0, 1e6), + doc='Molar flow rate of flue gas') + + @m.fs.Constraint(m.fs.time, + doc="Mole flow of flue gas constraint") + def eq_fluegas_flow(b, t): + return ( + m.fs.fg_flow_mol[t] * (m.fs.co2_mw * + m.fs.coal_LHV * + m.fs.co2_molefrac) == + (m.fs.carbon_wt * m.fs.SR * (m.fs.reheater[2].heat_duty[t] + + m.fs.reheater[1].heat_duty[t] + + m.fs.boiler.heat_duty[t])) + ) + + return m + +def add_capture_calculations(m): + + m.fs.fg_to_ccs_splitfraction = Var( + m.fs.config.time, + initialize=0.5, + bounds=(0, 1), + doc='Split of total flue gas sent to CCS') + + # m.fs.co2_captured = Var( + # m.fs.config.time, + # initialize=500, + # bounds=(0, 1e5), + # doc='Weight of CO2 captured CCS') + + # A specific reboiler duty of 3 GJ/tonne of CO2 captured is assumed for the + # CCS unit performing at 95% capture rate and using an advanced solvent + # such as Gen2 + # Units: 3 GJ/tonne = 3000 J/g + m.fs.SRD = Param( + initialize=3000, + doc='Specific Reboiler Duty for 95% Capture in J/g CO2 captured' + ) + + m.fs.ccs_reboiler = Heater( + property_package=m.fs.prop_water, + has_pressure_change=True, + ) + + m.fs.co2_captured = Expression( + expr=(m.fs.co2_molefrac * m.fs.fg_flow_mol[0] + * m.fs.fg_to_ccs_splitfraction[0] * m.fs.co2_mw), + doc="Weight of CO2 captured") + + # @m.fs.Constraint(m.fs.time, + # doc="Weight of CO2 captured") + # def eq_min_co2_captured(b, t): + # return ( + # m.fs.fg_to_ccs_splitfraction[t] >= 0.5) + + @m.fs.Constraint(m.fs.time, + doc="Reboiler heat duty constraint") + def eq_reboiler_heat_duty(b, t): + return ( + m.fs.ccs_reboiler.heat_duty[t] == + m.fs.co2_captured * m.fs.SRD) + + return m + +def model_analysis(m, heat_duty=None): + """Solve the conceptual design optimization problem + + """ + + # Fix variables in the flowsheet + m.fs.plant_power_out.fix(400) + m.fs.boiler.outlet.pressure.fix(m.main_steam_pressure) + m.fs.discharge.hxd.heat_duty.fix(heat_duty * 1e6) + + # Unfix variables that were fixed iduring initialization + m.fs.boiler.inlet.flow_mol.unfix() + m.fs.discharge.es_split.split_fraction[0, "to_hxd"].unfix() + m.fs.discharge.es_split.inlet.unfix() + m.fs.discharge.hxd.shell_inlet.flow_mass.unfix() + m.fs.discharge.hxd.area.unfix() + + # m.fs.fg_to_ccs_splitfraction[:].fix(0.1) + m.fs.fg_to_ccs_splitfraction[:].unfix() + m.fs.ccs_reboiler.inlet.pressure[0].unfix() + m.fs.ccs_reboiler.inlet.enth_mol[0].unfix() + m.fs.ccs_reboiler.inlet.flow_mol[0].unfix() + # m.fs.ccs_reboiler.inlet.enth_mol[0].fix(3000) + + # Add total cost as the objective function + m.obj = Objective( + expr=( + m.fs.discharge.capital_cost + + m.fs.discharge.operating_cost - + m.fs.co2_captured * m.fs.discharge.operating_hours * 100 * 1e-3 + ) * scaling_obj + ) + + +if __name__ == "__main__": + + # optarg = {"max_iter": 300} + optarg = {"tol": 1e-8, + "max_iter": 300, + "halt_on_ampl_error": "yes"} + solver = get_solver('ipopt', optarg) + + # Build ultra-supercritical plant base model + m_usc = usc.build_plant_model() + + # Initialize ultra-supercritical plant base model + usc.initialize(m_usc) + + # Add boiler fireside + m_usc = add_flugas_calculations(m_usc) + m_usc = add_capture_calculations(m_usc) + + # Build discharge model + m = main(m_usc, solver=solver, optarg=optarg) + + # Solve design model optimization problem + heat_duty_data = 148.5 + model_analysis(m, heat_duty=heat_duty_data) + + # Solve model using GDPopt + print() + print('**********Start solution of GDP discharge model using GDPopt') + print('DOFs before GDP discharge model solution: ', degrees_of_freedom(m)) + print() + results = run_gdp(m) + + # Print results + print_results(m, results) From 53b3c1412280c3962dfcbeaa18ef5c46171456f8 Mon Sep 17 00:00:00 2001 From: Naresh Susarla Date: Fri, 11 Nov 2022 12:42:55 -0500 Subject: [PATCH 12/12] updated the disjunct for iplp crossover steam extraction --- .../storage/discharge_design_ccs.py | 370 +++++++++++++----- 1 file changed, 263 insertions(+), 107 deletions(-) diff --git a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ccs.py b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ccs.py index 1730ed179..c51f55d64 100644 --- a/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ccs.py +++ b/dispatches/case_studies/fossil_case/ultra_supercritical_plant/storage/discharge_design_ccs.py @@ -64,6 +64,10 @@ # Import properties package for Solar salt from dispatches.properties import solarsalt_properties +from pyomo.util.infeasible import (log_infeasible_constraints, + log_close_to_bounds) +from IPython import embed +logging.basicConfig(level=logging.INFO) scaling_obj = 1 @@ -443,7 +447,9 @@ def disconnect_arcs(m): m.fs.bfp_to_fwh8, m.fs.fwh9_to_boiler, m.fs.t6split_to_bfpt, - m.fs.bfpt_to_condmix + # m.fs.rh2_to_turb5, + # m.fs.cond_to_condpump + # m.fs.bfpt_to_condmix ]: arc_s.expanded_block.enth_mol_equality.deactivate() arc_s.expanded_block.flow_mol_equality.deactivate() @@ -482,6 +488,89 @@ def add_disjunction(m): return m +# def rh2_source_disjunct_equations(disj): +# """Block of equations for disjunct 1 in disjunction 1 for the selection +# of condensate water source from condenser pump + +# """ + +# m = disj.model() + +# # Declare turbine for storage system +# m.fs.discharge.rh2_source_disjunct.es_turbine = HelmTurbineStage( +# property_package=m.fs.prop_water +# ) + +# m.fs.discharge.rh2_source_disjunct.es_turbine.efficiency_isentropic.fix(0.8) + +# for est in [m.fs.discharge.rh2_source_disjunct.es_turbine.control_volume]: +# iscale.set_scaling_factor(est.work, 1e-6) + +# # + (m.fs.discharge.es_turbine.control_volume.work[0] * (-1e-6)) +# # Add a constraint to storage turbine to ensure that the outlet +# # temperature is at the saturation temperature +# @m.fs.discharge.rh2_source_disjunct.es_turbine.Constraint( +# m.fs.time, +# doc="Turbine outlet should be a saturated steam") +# def constraint_esturbine_temperature_out(b, t): +# return ( +# b.control_volume.properties_out[t].temperature == +# b.control_volume.properties_out[t].temperature_sat + 1 +# ) +# @m.fs.discharge.rh2_source_disjunct.Constraint( +# m.fs.time, +# doc="Turbine outlet should be a saturated steam") +# def constraint_storage_power_out(b, t): +# return ( +# m.fs.discharge_power_out == +# (b.es_turbine.control_volume.work[0] * (-1e-6)) +# ) + +# m.fs.discharge.rh2_source_disjunct.hxd_to_esturbine = Arc( +# source=m.fs.discharge.hxd.tube_outlet, +# destination=m.fs.discharge.rh2_source_disjunct.es_turbine.inlet, +# doc="Connection from HXD to ES turbine" +# ) + +# # Add splitter to send a fraction of steam to the charge storage +# # system +# m.fs.discharge.rh2_source_disjunct.ccs_split = HelmSplitter( +# property_package=m.fs.prop_water, +# outlet_list=["to_ccs", "to_turb"], +# ) + +# m.fs.discharge.rh2_source_disjunct.rh2_to_rhsplit = Arc( +# source=m.fs.reheater[2].outlet, +# destination=m.fs.discharge.rh2_source_disjunct.ccs_split.inlet, +# doc="Connection from RH2 to T5 split" +# ) +# m.fs.discharge.rh2_source_disjunct.rhsplit_to_bfpt = Arc( +# source=m.fs.discharge.rh2_source_disjunct.ccs_split.to_turb, +# destination=m.fs.turbine[5].inlet, +# doc="Connection from RH split to T5" +# ) +# m.fs.discharge.rh2_source_disjunct.rhsplit_to_ccs = Arc( +# source=m.fs.discharge.rh2_source_disjunct.ccs_split.to_ccs, +# destination=m.fs.ccs_reboiler.inlet, +# doc="Connection from bfpt split to ccs reboiler" +# ) + +# for unit_k in [m.fs.discharge.rh2_source_disjunct.es_turbine]: +# unit_k.inlet.flow_mol[:].setlb(0) +# unit_k.inlet.flow_mol[:].setub(10000) +# unit_k.outlet.flow_mol[:].setlb(0) +# unit_k.outlet.flow_mol[:].setub(10000) + +# unit_k.control_volume.work[:].setub(0) +# unit_k.control_volume.work[:].setlb(-1e9) +# # unit_k.inlet.pressure[:].setlb(0) +# # unit_k.inlet.pressure[:].setub(1e12) +# # unit_k.outlet.pressure[:].setlb(0) +# # unit_k.outlet.pressure[:].setub(1e12) +# unit_k.deltaP[:].setlb(0) +# unit_k.deltaP[:].setub(1e9) + + def iplp_source_disjunct_equations(disj): """Block of equations for disjunct 1 in disjunction 1 for the selection of condensate water source from condenser pump @@ -511,6 +600,8 @@ def constraint_esturbine_temperature_out(b, t): b.control_volume.properties_out[t].temperature == b.control_volume.properties_out[t].temperature_sat + 1 ) + # m.fs.discharge.iplp_source_disjunct.es_turbine.control_volume.properties_out[0].enth_mol.fix(20000) + # m.fs.discharge.iplp_source_disjunct.es_turbine.ratioP[0].fix(0.02) @m.fs.discharge.iplp_source_disjunct.Constraint( m.fs.time, doc="Turbine outlet should be a saturated steam") @@ -528,73 +619,28 @@ def constraint_storage_power_out(b, t): # Add splitter to send a fraction of steam to the charge storage # system - m.fs.discharge.iplp_source_disjunct.bfpt_split = HelmSplitter( - property_package=m.fs.prop_water, - outlet_list=["to_ccs", "to_bfpt"], - ) - m.fs.discharge.iplp_source_disjunct.bfpt_mixer = HelmMixer( - momentum_mixing_type=MomentumMixingType.minimize, - inlet_list=["bfpt", "ccs"], + m.fs.discharge.iplp_source_disjunct.ccs_split = HelmSplitter( property_package=m.fs.prop_water, + outlet_list=["to_ccs", "to_turb"], ) - m.fs.discharge.iplp_source_disjunct.t6split_to_bfptsplit = Arc( + m.fs.discharge.iplp_source_disjunct.t6split_to_ccsplit = Arc( source=m.fs.turbine_splitter[6].outlet_3, - destination=m.fs.discharge.iplp_source_disjunct.bfpt_split.inlet, - doc="Connection from Turbine 6 outlet 3 to bfpt split" + destination=m.fs.discharge.iplp_source_disjunct.ccs_split.inlet, + doc="Connection from Turbine 6 outlet 3 to ccs split" ) m.fs.discharge.iplp_source_disjunct.bfptsplit_to_bfpt = Arc( - source=m.fs.discharge.iplp_source_disjunct.bfpt_split.to_bfpt, + source=m.fs.discharge.iplp_source_disjunct.ccs_split.to_turb, destination=m.fs.bfpt.inlet, - doc="Connection from bfpt split to bfpt" + doc="Connection from ccs split to bfpt" ) - m.fs.discharge.iplp_source_disjunct.bfptsplit_to_ccs = Arc( - source=m.fs.discharge.iplp_source_disjunct.bfpt_split.to_ccs, + m.fs.discharge.iplp_source_disjunct.ccsplit_to_ccs = Arc( + source=m.fs.discharge.iplp_source_disjunct.ccs_split.to_ccs, destination=m.fs.ccs_reboiler.inlet, doc="Connection from bfpt split to ccs reboiler" ) - m.fs.discharge.iplp_source_disjunct.ccs_to_mix = Arc( - source=m.fs.ccs_reboiler.outlet, - destination=m.fs.discharge.iplp_source_disjunct.bfpt_mixer.ccs, - doc="Connection from ccs split to ccs reboiler" - ) - m.fs.discharge.iplp_source_disjunct.bfpt_to_mix = Arc( - source=m.fs.bfpt.outlet, - destination=m.fs.discharge.iplp_source_disjunct.bfpt_mixer.bfpt, - doc="Connection from ccs split to ccs reboiler" - ) - m.fs.discharge.iplp_source_disjunct.mix_to_cond = Arc( - source=m.fs.discharge.iplp_source_disjunct.bfpt_mixer.outlet, - destination=m.fs.condenser_mix.bfpt, - doc="Connection from ccs split to ccs reboiler" - ) - m.fs.discharge.iplp_source_disjunct.bfpt_mixer.bfpt.flow_mol[0].setlb(0) - m.fs.discharge.iplp_source_disjunct.bfpt_mixer.bfpt.flow_mol[0].setub(15000) - m.fs.discharge.iplp_source_disjunct.bfpt_mixer.ccs.flow_mol[0].setlb(0) - m.fs.discharge.iplp_source_disjunct.bfpt_mixer.ccs.flow_mol[0].setub(15000) - m.fs.discharge.iplp_source_disjunct.bfpt_mixer.outlet.flow_mol[0].setlb(0) - m.fs.discharge.iplp_source_disjunct.bfpt_mixer.outlet.flow_mol[0].setub(15000) - m.fs.condenser_mix.bfpt.flow_mol[0].setlb(0) - m.fs.condenser_mix.bfpt.flow_mol[0].setub(15000) - for unit_k in [m.fs.discharge.iplp_source_disjunct.es_turbine]: - unit_k.inlet.flow_mol[:].setlb(0) - unit_k.inlet.flow_mol[:].setub(5000) - unit_k.outlet.flow_mol[:].setlb(0) - unit_k.outlet.flow_mol[:].setub(5000) - - unit_k.control_volume.work[:].setub(0) - unit_k.control_volume.work[:].setlb(-1e8) - # unit_k.inlet.pressure[:].setlb(0) - # unit_k.inlet.pressure[:].setub(1e12) - # unit_k.outlet.pressure[:].setlb(0) - # unit_k.outlet.pressure[:].setub(1e12) - unit_k.deltaP[:].setlb(0) - unit_k.deltaP[:].setub(1e9) - - -# def hxd_source_disjunct_equations(m): def hxd_source_disjunct_equations(disj): """Block of equations for disjunct 1 in disjunction 1 for the selection of condensate water source from condenser pump @@ -606,47 +652,20 @@ def hxd_source_disjunct_equations(disj): # Define arcs to connect units within disjunct m.fs.discharge_power_out.fix(0) + # m.fs.discharge.hxd_source_disjunct.rh2_to_turb5 = Arc( + # source=m.fs.reheater[2].outlet, + # destination=m.fs.turbine[5].inlet + # ) m.fs.discharge.hxd_source_disjunct.t6split_to_bfpt = Arc( source=m.fs.turbine_splitter[6].outlet_3, destination=m.fs.bfpt.inlet ) - m.fs.discharge.hxd_source_disjunct.bfpt_to_cond = Arc( - source=m.fs.bfpt.outlet, - destination=m.fs.condenser_mix.bfpt, - doc="Connection from ccs split to ccs reboiler" - ) m.fs.discharge.hxd_source_disjunct.hxd_to_ccs = Arc( source=m.fs.discharge.hxd.tube_outlet, destination=m.fs.ccs_reboiler.inlet, doc="Connection from Turbine 6 outlet 3 to ccs split" ) - # m.fs.discharge.hxd_source_disjunct.ccs_split = HelmSplitter( - # property_package=m.fs.prop_water, - # outlet_list=["to_ccs", "to_esturb"], - # ) - # m.fs.discharge.hxd_source_disjunct.hxd_to_ccsplit = Arc( - # source=m.fs.discharge.hxd.tube_outlet, - # destination=m.fs.discharge.hxd_source_disjunct.ccs_split.inlet, - # doc="Connection from Turbine 6 outlet 3 to ccs split" - # ) - # m.fs.discharge.hxd_source_disjunct.ccsplit_to_turbine = Arc( - # source=m.fs.discharge.hxd_source_disjunct.ccs_split.to_esturb, - # destination=m.fs.discharge.es_turbine.inlet, - # doc="Connection from ccs split to es turbine" - # ) - # m.fs.discharge.hxd_source_disjunct.ccsplit_to_ccs = Arc( - # source=m.fs.discharge.hxd_source_disjunct.ccs_split.to_ccs, - # destination=m.fs.ccs_reboiler.inlet, - # doc="Connection from ccs split to ccs reboiler" - # ) - - # # m.fs.discharge.hxd_source_disjunct.hxd_to_ccs = Arc( - # # source=m.fs.discharge.hxd.tube_outlet, - # # destination=m.fs.ccs_reboiler.inlet, - # # doc="Connection from hxd to ccs reboiler" - # # ) - def condpump_source_disjunct_equations(disj): """Block of equations for disjunct 1 in disjunction 1 for the selection of condensate water source from condenser pump @@ -914,9 +933,9 @@ def set_model_input(m): ########################################################################### # Inputs for flue gas and capture units ########################################################################### - m.fs.fg_to_ccs_splitfraction[:].fix(0.5) - m.fs.ccs_reboiler.inlet.pressure[0].fix(620984) - m.fs.ccs_reboiler.inlet.enth_mol[0].fix(58740) + m.fs.fg_to_ccs_splitfraction[:].fix(1) + m.fs.ccs_reboiler.inlet.pressure[0].fix(31126000) + m.fs.ccs_reboiler.inlet.enth_mol[0].fix(61493) m.fs.ccs_reboiler.inlet.flow_mol[0].fix(10740) m.fs.ccs_reboiler.outlet.pressure[0].fix(7000) # m.fs.ccs_reboiler.outlet.enth_mol[0].fix(3000) @@ -1192,8 +1211,8 @@ def add_bounds(m, power_max=None): """ - m.flow_max = m.main_flow * 1.2 # Units in mol/s - m.storage_flow_max = 0.5 * m.flow_max # Units in mol/s + m.flow_max = m.main_flow * 3 # Units in mol/s + m.storage_flow_max = 0.2 * m.flow_max # Units in mol/s m.salt_flow_max = 1000 # Units in kg/s m.heat_duty_bound = 200e6 # Units in MW m.power_max = power_max # Units in MW @@ -1267,11 +1286,11 @@ def add_bounds(m, power_max=None): unit_k.outlet.flow_mol[:].setlb(0) unit_k.outlet.flow_mol[:].setub(m.flow_max) - # for unit_k in [m.fs.discharge.iplp_source_disjunct.es_turbine]: - # unit_k.inlet.flow_mol[:].setlb(0) - # unit_k.inlet.flow_mol[:].setub(m.storage_flow_max) - # unit_k.outlet.flow_mol[:].setlb(0) - # unit_k.outlet.flow_mol[:].setub(m.storage_flow_max) + for unit_k in [m.fs.discharge.iplp_source_disjunct.es_turbine]: + unit_k.inlet.flow_mol[:].setlb(0) + unit_k.inlet.flow_mol[:].setub(m.storage_flow_max) + unit_k.outlet.flow_mol[:].setlb(0) + unit_k.outlet.flow_mol[:].setub(m.storage_flow_max) # unit_k.inlet.pressure[:].setlb(0) # unit_k.inlet.pressure[:].setub(1e12) @@ -1290,17 +1309,44 @@ def add_bounds(m, power_max=None): m.fs.turbine[k].work.setlb(-1e10) m.fs.turbine[k].work.setub(0) - for split1 in [m.fs.discharge.iplp_source_disjunct.bfpt_split]: + for unit_k in [m.fs.discharge.iplp_source_disjunct.es_turbine]: + unit_k.inlet.flow_mol[:].setlb(20) + unit_k.inlet.flow_mol[:].setub(m.storage_flow_max) + unit_k.outlet.flow_mol[:].setlb(20) + unit_k.outlet.flow_mol[:].setub(m.storage_flow_max) + + unit_k.control_volume.work[:].setub(0) + unit_k.control_volume.work[:].setlb(-1e8) + # unit_k.inlet.pressure[:].setlb(0) + # unit_k.inlet.pressure[:].setub(1e12) + # unit_k.outlet.pressure[:].setlb(0) + # unit_k.outlet.pressure[:].setub(1e12) + unit_k.deltaP[:].setlb(0) + unit_k.deltaP[:].setub(1e12) + + for split1 in [m.fs.discharge.iplp_source_disjunct.ccs_split]: split1.inlet.flow_mol[:].setlb(0) split1.inlet.flow_mol[:].setub(m.flow_max) split1.to_ccs.flow_mol[:].setlb(0) split1.to_ccs.flow_mol[:].setub(m.flow_max) - split1.to_bfpt.flow_mol[:].setlb(0) - split1.to_bfpt.flow_mol[:].setub(m.flow_max) + split1.to_turb.flow_mol[:].setlb(0) + split1.to_turb.flow_mol[:].setub(m.flow_max) split1.split_fraction[0.0, "to_ccs"].setlb(0) split1.split_fraction[0.0, "to_ccs"].setub(1) - split1.split_fraction[0.0, "to_bfpt"].setlb(0) - split1.split_fraction[0.0, "to_bfpt"].setub(1) + split1.split_fraction[0.0, "to_turb"].setlb(0) + split1.split_fraction[0.0, "to_turb"].setub(1) + + # for split1 in [m.fs.discharge.iplp_source_disjunct.bfpt_split]: + # split1.inlet.flow_mol[:].setlb(0) + # split1.inlet.flow_mol[:].setub(m.flow_max) + # split1.to_ccs.flow_mol[:].setlb(0) + # split1.to_ccs.flow_mol[:].setub(m.flow_max) + # split1.to_bfpt.flow_mol[:].setlb(0) + # split1.to_bfpt.flow_mol[:].setub(m.flow_max) + # split1.split_fraction[0.0, "to_ccs"].setlb(0) + # split1.split_fraction[0.0, "to_ccs"].setub(1) + # split1.split_fraction[0.0, "to_bfpt"].setlb(0) + # split1.split_fraction[0.0, "to_bfpt"].setub(1) # for split2 in [m.fs.discharge.hxd_source_disjunct.ccs_split]: # split2.inlet.flow_mol[:].setlb(0) @@ -1386,6 +1432,77 @@ def print_model(_, nlp_model, nlp_data): print() +def run_nlps(m, + solver=None, + fluid=None, + source=None): + """This function fixes the indicator variables of the disjuncts so to + solve NLP problems + + """ + + # Disjunction 1 for the water source selection + if fluid == "cond_pump": + m.fs.discharge.condpump_source_disjunct.indicator_var.fix(1) + m.fs.discharge.fwh4_source_disjunct.indicator_var.fix(0) + m.fs.discharge.booster_source_disjunct.indicator_var.fix(0) + m.fs.discharge.bfp_source_disjunct.indicator_var.fix(0) + m.fs.discharge.fwh9_source_disjunct.indicator_var.fix(0) + elif fluid == "fwh4": + m.fs.discharge.condpump_source_disjunct.indicator_var.fix(0) + m.fs.discharge.fwh4_source_disjunct.indicator_var.fix(1) + m.fs.discharge.booster_source_disjunct.indicator_var.fix(0) + m.fs.discharge.bfp_source_disjunct.indicator_var.fix(0) + m.fs.discharge.fwh9_source_disjunct.indicator_var.fix(0) + elif fluid == "booster": + m.fs.discharge.condpump_source_disjunct.indicator_var.fix(0) + m.fs.discharge.fwh4_source_disjunct.indicator_var.fix(0) + m.fs.discharge.booster_source_disjunct.indicator_var.fix(1) + m.fs.discharge.bfp_source_disjunct.indicator_var.fix(0) + m.fs.discharge.fwh9_source_disjunct.indicator_var.fix(0) + elif fluid == "bfp": + m.fs.discharge.condpump_source_disjunct.indicator_var.fix(0) + m.fs.discharge.fwh4_source_disjunct.indicator_var.fix(0) + m.fs.discharge.booster_source_disjunct.indicator_var.fix(0) + m.fs.discharge.bfp_source_disjunct.indicator_var.fix(1) + m.fs.discharge.fwh9_source_disjunct.indicator_var.fix(0) + elif fluid == "fwh9": + m.fs.discharge.condpump_source_disjunct.indicator_var.fix(0) + m.fs.discharge.fwh4_source_disjunct.indicator_var.fix(0) + m.fs.discharge.booster_source_disjunct.indicator_var.fix(0) + m.fs.discharge.bfp_source_disjunct.indicator_var.fix(0) + m.fs.discharge.fwh9_source_disjunct.indicator_var.fix(1) + else: + print('Unrecognized storage fluid name!') + + # Disjunction 2 for the ccs source selection + if source == "iplp": + m.fs.discharge.iplp_source_disjunct.indicator_var.fix(1) + m.fs.discharge.hxd_source_disjunct.indicator_var.fix(0) + elif source == "hxd": + m.fs.discharge.iplp_source_disjunct.indicator_var.fix(0) + m.fs.discharge.hxd_source_disjunct.indicator_var.fix(1) + else: + print('Unrecognized source unit name!') + + TransformationFactory('gdp.fix_disjuncts').apply_to(m) + print("The degrees of freedom after gdp transformation ", + degrees_of_freedom(m)) + + results = solver.solve( + m, + tee=True, + symbolic_solver_labels=True, + options={ + "linear_solver": "ma27", + "max_iter": 150 + } + ) + log_close_to_bounds(m) + + + return m, results + def run_gdp(m): """Declare solver GDPopt and its options """ @@ -1431,12 +1548,24 @@ def print_results(m, results): pyo.value(m.fs.discharge.iplp_source_disjunct.es_turbine.control_volume.work[0]) * (-1e-6))) print('Boiler Efficiency (%): {:.2f}'.format( pyo.value(m.fs.boiler_efficiency) * 100)) + print('Boiler Steam Flow: {:.2f}'.format( + pyo.value(m.fs.boiler.inlet.flow_mol[0]))) + print('Makeup Water Flow: {:.2f}'.format( + pyo.value(m.fs.condenser_mix.makeup.flow_mol[0]))) print('CCS Reboiler Steam Flow: {:.2f}'.format( pyo.value(m.fs.ccs_reboiler.inlet.flow_mol[0]))) print('Flue Gas Flow: {:.2f}'.format( pyo.value(m.fs.fg_flow_mol[0]))) print('CO2 captured: {:.2f}'.format( pyo.value(m.fs.co2_captured))) + print('CCS Inlet Steam Temperature: {:.2f}'.format( + pyo.value(m.fs.ccs_reboiler.control_volume.properties_in[0].temperature))) + print('CCS Outlet Steam Temperature: {:.2f}'.format( + pyo.value(m.fs.ccs_reboiler.control_volume.properties_out[0].temperature))) + print('HXD Inlet Water Temperature: {:.2f}'.format( + pyo.value(m.fs.discharge.hxd.cold_side.properties_in[0].temperature))) + print('HXD Outlet Water Temperature: {:.2f}'.format( + pyo.value(m.fs.discharge.hxd.cold_side.properties_out[0].temperature))) print() print("**Discrete design decisions (Disjunction)") for d in m.component_data_objects(ctype=Disjunct, @@ -1519,6 +1648,11 @@ def add_capture_calculations(m): doc='Specific Reboiler Duty for 95% Capture in J/g CO2 captured' ) + m.fs.emission_tax = Param( + initialize=150e-6, + doc='Assumed carbon emission tax of $150/tonne or $150e-6/g of CO2' + ) + m.fs.ccs_reboiler = Heater( property_package=m.fs.prop_water, has_pressure_change=True, @@ -1529,6 +1663,11 @@ def add_capture_calculations(m): * m.fs.fg_to_ccs_splitfraction[0] * m.fs.co2_mw), doc="Weight of CO2 captured") + m.fs.co2_emitted = Expression( + expr=(m.fs.co2_molefrac * m.fs.fg_flow_mol[0] + * (1 - m.fs.fg_to_ccs_splitfraction[0]) * m.fs.co2_mw), + doc="Weight of CO2 captured") + # @m.fs.Constraint(m.fs.time, # doc="Weight of CO2 captured") # def eq_min_co2_captured(b, t): @@ -1540,7 +1679,7 @@ def add_capture_calculations(m): def eq_reboiler_heat_duty(b, t): return ( m.fs.ccs_reboiler.heat_duty[t] == - m.fs.co2_captured * m.fs.SRD) + -1 * m.fs.co2_captured * m.fs.SRD) return m @@ -1550,6 +1689,7 @@ def model_analysis(m, heat_duty=None): """ # Fix variables in the flowsheet + # m.fs.net_power.fix(400) m.fs.plant_power_out.fix(400) m.fs.boiler.outlet.pressure.fix(m.main_steam_pressure) m.fs.discharge.hxd.heat_duty.fix(heat_duty * 1e6) @@ -1561,19 +1701,21 @@ def model_analysis(m, heat_duty=None): m.fs.discharge.hxd.shell_inlet.flow_mass.unfix() m.fs.discharge.hxd.area.unfix() - # m.fs.fg_to_ccs_splitfraction[:].fix(0.1) + # m.fs.fg_to_ccs_splitfraction[:].fix(1) m.fs.fg_to_ccs_splitfraction[:].unfix() m.fs.ccs_reboiler.inlet.pressure[0].unfix() m.fs.ccs_reboiler.inlet.enth_mol[0].unfix() m.fs.ccs_reboiler.inlet.flow_mol[0].unfix() # m.fs.ccs_reboiler.inlet.enth_mol[0].fix(3000) - + # m.fs.ccs_reboiler.outlet.enth_mol[0].unfix() + # m.fs.discharge_power_out.fix(10) # Add total cost as the objective function m.obj = Objective( expr=( m.fs.discharge.capital_cost + - m.fs.discharge.operating_cost - - m.fs.co2_captured * m.fs.discharge.operating_hours * 100 * 1e-3 + m.fs.discharge.operating_cost + + m.fs.co2_emitted * m.fs.discharge.operating_hours * m.fs.emission_tax + # - m.fs.net_power * 20 ) * scaling_obj ) @@ -1608,7 +1750,21 @@ def model_analysis(m, heat_duty=None): print('**********Start solution of GDP discharge model using GDPopt') print('DOFs before GDP discharge model solution: ', degrees_of_freedom(m)) print() - results = run_gdp(m) + # results = run_gdp(m) + + # fluid = "cond_pump" + # fluid = "fwh4" + # fluid = "booster" + fluid = "bfp" + # fluid = "fwh9" + + source = "iplp" + # source = "hxd" + + results = run_nlps(m, + solver=solver, + fluid=fluid, + source=source) # Print results print_results(m, results)