CST version check

setup.py

@@ -12,7 +12,7 @@
         "watertap==1.0.0rc0",
         "idaes-pse==2.5.0",
         "pyomo==6.7.3",
-        "nrel-pysam == 5.1.0",
+        "nrel-pysam == 6.0.0",
     ],
     extras_require={
         "dev": [

src/watertap_contrib/reflo/analysis/case_studies/KBHDP/components/CST.py

@@ -6,6 +6,7 @@
     Block,
     Constraint,
     SolverFactory,
+    Param,
 )
 import os
 
@@ -30,6 +31,8 @@
     EnergyCosting,
 )
 
+import pickle
+
 __all__ = [
     "build_cst",
     "init_cst",
@@ -58,67 +61,101 @@ def build_cst(blk, __file__=None):
 
     if __file__ == None:
         cwd = os.getcwd()
-        __file__ = cwd + r"\src\watertap_contrib\reflo\solar_models\surrogate\trough\\"
+        __file__ = (
+            cwd + "/src/watertap_contrib/reflo/analysis/case_studies/KBHDP/data/cst/"
+        )
 
     dataset_filename = os.path.join(
-        os.path.dirname(__file__), r"data\test_trough_data.pkl"
+        os.path.dirname(__file__),
+        r"trough_kbhdp_heat_load_1_50_hours_storage_24_T_loop_out_300.pkl",
     )
+
+    # Updating pickle file output column names
+    with open(dataset_filename, "rb") as f:
+        df = pickle.load(f)
+
+    # Rename the columns
+    df.rename(columns={"annual_energy": "heat_annual"}, inplace=True)
+    df.rename(columns={"electrical_load": "electricity_annual"}, inplace=True)
+
+    # Save the modified DataFrame back as a pickle
+    with open(dataset_filename, "wb") as f:
+        pickle.dump(df, f)
+
     surrogate_filename = os.path.join(
         os.path.dirname(__file__),
-        r"data\test_trough_data_heat_load_100_500_hours_storage_0_26.json",
+        r"trough_kbhdp_heat_load_1_50_hours_storage_24_T_loop_out_300.json",
     )
 
-    input_bounds = dict(heat_load=[100, 500], hours_storage=[0, 26])
-    input_units = dict(heat_load="MW", hours_storage="hour")
+    input_bounds = dict(heat_load=[1, 50])  # , hours_storage=[23, 24])
+    input_units = dict(heat_load="MW")  # , hours_storage="hour")
     input_variables = {
-        "labels": ["heat_load", "hours_storage"],
+        "labels": ["heat_load"],  # "hours_storage"],
         "bounds": input_bounds,
         "units": input_units,
     }
 
-    output_units = dict(heat_annual_scaled="kWh", electricity_annual_scaled="kWh")
+    output_units = dict(
+        heat_annual_scaled="kWh",
+        electricity_annual_scaled="kWh",
+        total_aperture_area_scaled="m**2",
+    )
     output_variables = {
-        "labels": ["heat_annual_scaled", "electricity_annual_scaled"],
+        "labels": [
+            "heat_annual_scaled",
+            "electricity_annual_scaled",
+            "total_aperture_area_scaled",
+        ],
         "units": output_units,
     }
 
     blk.unit = TroughSurrogate(
-        surrogate_model_file=surrogate_filename,
+        # surrogate_model_file=surrogate_filename,
+        surrogate_filename_save=surrogate_filename,
         dataset_filename=dataset_filename,
         input_variables=input_variables,
         output_variables=output_variables,
         scale_training_data=True,
     )
 
+    if hasattr(blk.unit, "hours_storage"):
+        print("Hours of storage is already any input parameter")
+    else:
+        print("Creating hours of storage parameter")
+        blk.unit.hours_storage = Param(initialize=24, units=pyunits.h, mutable=True)
+
 
 def init_cst(blk):
     # Fix input variables for initialization
-    blk.unit.hours_storage.fix()
-    blk.unit.heat_load.fix()
     blk.unit.initialize()
 
-    blk.unit.heat_load.unfix()
-
 
 def set_system_op_conditions(m):
     m.fs.system_capacity.fix()
 
 
-def set_cst_op_conditions(blk, hours_storage=6):
-    blk.unit.hours_storage.fix(hours_storage)
+def set_cst_op_conditions(blk, heat_load=10, hours_storage=6):
+
+    if isinstance(m.fs.cst.unit.hours_storage, pyo.Param):
+        blk.unit.hours_storage.set_value(hours_storage)
+
+    if isinstance(m.fs.cst.unit.hours_storage, pyo.Var):
+        blk.unit.hours_storage.fix(hours_storage)
+    blk.unit.heat_load.fix(heat_load)
 
 
 def add_cst_costing(blk, costing_block):
     blk.unit.costing = UnitModelCostingBlock(flowsheet_costing_block=costing_block)
 
 
 def calc_costing(m, blk):
-    blk.costing.heat_cost.set_value(0)
     blk.costing.cost_process()
+    # Updated to be 0 because this factor is not included in SAM
+    blk.costing.maintenance_labor_chemical_factor.fix(0)
     blk.costing.initialize()
 
     # TODO: Connect to the treatment volume
-    blk.costing.add_LCOW(m.fs.system_capacity)
+    # blk.costing.add_LCOW(m.fs.system_capacity)
 
 
 def report_cst(m, blk):
@@ -149,9 +186,9 @@ def report_cst_costing(m, blk):
     print(f"\n\n-------------------- CST Costing Report --------------------\n")
     print("\n")
 
-    print(
-        f'{"LCOW":<30s}{value(blk.costing.LCOW):<20,.2f}{pyunits.get_units(blk.costing.LCOW)}'
-    )
+    # print(
+    #     f'{"LCOW":<30s}{value(blk.costing.LCOW):<20,.2f}{pyunits.get_units(blk.costing.LCOW)}'
+    # )
 
     print(
         f'{"Capital Cost":<30s}{value(blk.costing.total_capital_cost):<20,.2f}{pyunits.get_units(blk.costing.total_capital_cost)}'
@@ -181,14 +218,6 @@ def report_cst_costing(m, blk):
     #     f'{"Heat Cost":<30s}{value(blk.costing.aggregate_flow_costs["heat"]):<20,.2f}{pyunits.get_units(blk.costing.aggregate_flow_costs["heat"])}'
     # )
 
-    # print(
-    #     f'{"Elec Flow":<30s}{value(blk.costing.aggregate_flow_electricity):<20,.2f}{pyunits.get_units(blk.costing.aggregate_flow_electricity)}'
-    # )
-
-    # print(
-    #     f'{"Elec Cost":<30s}{value(blk.costing.aggregate_flow_costs["electricity"]):<20,.2f}{pyunits.get_units(blk.costing.aggregate_flow_costs["electricity"])}'
-    # )
-
 
 if __name__ == "__main__":
 
@@ -199,17 +228,47 @@ def report_cst_costing(m, blk):
 
     build_cst(m.fs.cst)
 
+    set_cst_op_conditions(m.fs.cst, heat_load=50, hours_storage=24)
     init_cst(m.fs.cst)
 
-    set_cst_op_conditions(m.fs.cst)
-
     add_cst_costing(m.fs.cst, costing_block=m.fs.costing)
     calc_costing(m, m.fs)
-    m.fs.costing.aggregate_flow_heat.fix(-70000)
     results = solver.solve(m)
 
     print(degrees_of_freedom(m))
     report_cst(m, m.fs.cst.unit)
     report_cst_costing(m, m.fs)
 
-    # m.fs.costing.used_flows.display()
+    print(
+        f'{"Elec Flow":<30s}{value(m.fs.costing.aggregate_flow_electricity):<20,.2f}{pyunits.get_units(m.fs.costing.aggregate_flow_electricity)}'
+    )
+
+    print(
+        f'{"Elec Cost":<30s}{value(m.fs.costing.aggregate_flow_costs["electricity"]):<20,.2f}{pyunits.get_units(m.fs.costing.aggregate_flow_costs["electricity"])}'
+    )
+
+    m.fs.costing.add_LCOH()
+    print("LCOH:", m.fs.costing.LCOH())
+    print("Hours of storage:", m.fs.cst.unit.hours_storage())
+    print("Aperture area:", m.fs.cst.unit.total_aperture_area())
+
+    print("CST fixed cost:", m.fs.cst.unit.costing.fixed_operating_cost())
+
+    # Calcualating LCOH like SAM
+    cost = m.fs.costing
+    lcoh = (
+        cost.total_capital_cost * cost.capital_recovery_factor
+        + cost.total_operating_cost
+    ) / m.fs.cst.unit.heat_annual
+
+    print("\nManual LCOH check\n")
+    print("CRF:", cost.capital_recovery_factor())
+    print(
+        "Numerator:",
+        (
+            cost.total_capital_cost * cost.capital_recovery_factor
+            + cost.total_operating_cost
+        )(),
+    )
+    print("Denominator:", m.fs.cst.unit.heat_annual())
+    print("Calculated LCOH:", lcoh())

src/watertap_contrib/reflo/analysis/case_studies/KBHDP/components/MD.py

@@ -225,27 +225,31 @@ def init_md(blk, verbose=True, solver=None):
     # Build connection to permeate state junction
     blk.permeate.properties[0]._flow_vol_phase
 
-    @blk.Constraint(
-        doc="Assign the permeate flow rate to its respective state junction"
-    )
     def get_permeate_flow(b):
-        num_modules = b.mp.get_active_process_blocks()[-1].fs.vagmd.num_modules
+        # num_modules = b.unit.mp.get_active_process_blocks()[-1].fs.vagmd.num_modules
 
-        return (
-            b.permeate.properties[0].flow_vol_phase["Liq"]
-            ==
-            # pyunits.convert(
-            pyunits.convert(
-                (
-                    num_modules
-                    * b.mp.get_active_process_blocks()[-1].fs.acc_distillate_volume
-                    / (
-                        b.mp.get_active_process_blocks()[-1].fs.dt
-                        * (blk.n_time_points - 1)
-                    )
-                ),
-                to_units=pyunits.m**3 / pyunits.s,
+        vagmd = b.unit.mp.get_active_process_blocks()[-1].fs.vagmd
+        num_modules = pyunits.convert(
+            vagmd.system_capacity
+            / sum(
+                b.unit.mp.get_active_process_blocks()[i].fs.vagmd.permeate_flux
+                for i in range(blk.n_time_points)
             )
+            * blk.n_time_points
+            / b.unit.mp.get_active_process_blocks()[0].fs.vagmd.module_area,
+            to_units=pyunits.dimensionless,
+        )
+
+        return b.permeate.properties[0].flow_vol_phase["Liq"] == pyunits.convert(
+            (
+                num_modules
+                * b.unit.mp.get_active_process_blocks()[-1].fs.acc_distillate_volume
+                / (
+                    b.unit.mp.get_active_process_blocks()[-1].fs.dt
+                    * (blk.n_time_points - 1)
+                )
+            ),
+            to_units=pyunits.m**3 / pyunits.s,
         )
 
     blk.permeate.properties[0].flow_mass_phase_comp["Liq", "TDS"].fix(0)
@@ -261,15 +265,18 @@ def get_permeate_flow(b):
         doc="Assign the concentrate flow rate to its respective state junction"
     )
     def get_concentrate_flow(b):
-        num_modules = b.mp.get_active_process_blocks()[-1].fs.vagmd.num_modules
+        num_modules = b.unit.mp.get_active_process_blocks()[-1].fs.vagmd.num_modules
 
         return b.concentrate.properties[0].flow_vol_phase["Liq"] == pyunits.convert(
             (
-                num_modules
-                * blk.model_options["initial_batch_volume"]
-                * pyunits.L
-                * (1 - b.mp.get_active_process_blocks()[-1].fs.acc_recovery_ratio)
-                / (b.mp.get_active_process_blocks()[-1].fs.dt * (blk.n_time_points - 1))
+                b.unit.mp.get_active_process_blocks()[-1].fs.vagmd.system_capacity
+                * (1 - m.water_recovery)
+                / m.water_recovery
+                #     num_modules
+                #     * blk.model_input["initial_batch_volume"]
+                #     * pyunits.L
+                #     * (1 - b.unit.mp.get_active_process_blocks()[-1].fs.acc_recovery_ratio)
+                #     / (b.unit.mp.get_active_process_blocks()[-1].fs.dt * (blk.n_time_points - 1))
             ),
             to_units=pyunits.m**3 / pyunits.s,
         )