Merge remote-tracking branch 'origin/pv' into pv

Author: pmohanty943

src/pandaprosumer/controller/converter.py

@@ -50,14 +50,17 @@ def control_step(self, prosumer):
         deltaT = t_supply_c - t_required_in_c
 
         q_received_kw = self._get_input('q_received_kw')
-        #print(q_received_kw)
-        if abs(deltaT) < 1e-6:
-            mdot_received_kg_per_s = 0.0
+
+        if abs(deltaT) < 1e-10:
+            raise ValueError(
+                f"Invalid temperature configuration: supply temperature ({t_supply_c} °C) "
+                f"is lower than return temperature ({t_required_in_c} °C). "
+            )
+
         else:
             t_mean_K = CELSIUS_TO_K + 0.5 * (t_supply_c + t_required_in_c)
             cp = self.fluid.get_heat_capacity(t_mean_K)
             mdot_received_kg_per_s = q_received_kw * 1e3/ (cp * deltaT)
-            #print(mdot_received_kg_per_s)
 
         result = np.array([])
 

src/pandaprosumer/controller/data_model/ice_chp.py

@@ -27,5 +27,5 @@ class IceChpControllerData:
     element_index: List[int]
     period_index: int = None
     element_name: str = 'ice_chp'
-    input_columns: List[str] = field(default_factory=lambda: ['cycle', 't_intake_k'])
+    input_columns: List[str] = field(default_factory=lambda: ['cycle', 't_intake_k', 'p_requested_kw'])
     result_columns: List[str] = field(default_factory=lambda: ['load', 'p_in_kw', 'p_el_out_kw', 'p_th_out_kw', 'p_rad_out_kw', 'ice_chp_efficiency', 'mdot_fuel_in_kg_per_s', 'acc_m_fuel_in_kg', 'acc_co2_equiv_kg', 'acc_co2_inst_kg', 'acc_nox_mg', 'acc_time_ice_chp_oper_s'])

src/pandaprosumer/controller/models/booster_heat_pump.py

@@ -58,6 +58,7 @@ def _q_received_kw(self):
     def _p_received_kw(self):
         return self._get_input("p_received_kw")
 
+
     def q_to_receive_kw(self, prosumer):
         """
         Calculates the heat to receive in kW.
@@ -114,6 +115,7 @@ def control_step(self, prosumer):
         t_sink_k = self._t_sink_k
         bhp_type = self._get_element_param(prosumer, "bhp_type")
         mode = self._mode
+        q_max_kw = self._get_element_param(prosumer, "q_max_kw")
 
         t_source_k = t_source_k - 273.0  # in celsius
         t_amb_k = t_amb_k - 273.0  # in celsius
@@ -128,7 +130,8 @@ def control_step(self, prosumer):
             else:
                 t_sink_floor_heating_k = t_sink_k - 273.0
                 t_sink_radiator_heating_k = t_sink_k - 273.0
-            q_max_kw = 5.8 + 0.21 * t_source_k
+            if pd.isna(q_max_kw):
+                q_max_kw = 5.8 + 0.21 * t_source_k
         elif bhp_type == "water-water1":
             t_min_source_k = -10.0
             t_max_source_k = 25.0
@@ -139,7 +142,8 @@ def control_step(self, prosumer):
             else:
                 t_sink_floor_heating_k = t_sink_k - 273.0
                 t_sink_radiator_heating_k = t_sink_k - 273.0
-            q_max_kw = 5.8 + 0.21 * t_source_k
+            if pd.isna(q_max_kw):
+                q_max_kw = 5.8 + 0.21 * t_source_k
         elif bhp_type == "water-water2":
             t_min_source_k = 10.0
             t_max_source_k = 80.0
@@ -150,7 +154,8 @@ def control_step(self, prosumer):
             else:
                 t_sink_floor_heating_k = t_sink_k - 273.0
                 t_sink_radiator_heating_k = t_sink_k - 273.0
-            q_max_kw = 25.308 + 0.963 * t_source_k
+            if pd.isna(q_max_kw):
+                q_max_kw = 25.308 + 0.963 * t_source_k
         elif bhp_type == "water-water3":
             t_min_source_k = 10.0
             t_max_source_k = 80.0
@@ -161,7 +166,8 @@ def control_step(self, prosumer):
             else:
                 t_sink_floor_heating_k = t_sink_k - 273.0
                 t_sink_radiator_heating_k = t_sink_k - 273.0
-            q_max_kw = 29.005 + 1.035 * t_source_k
+            if pd.isna(q_max_kw):
+                q_max_kw = 29.005 + 1.035 * t_source_k
 
         else:
             raise ValueError(f"Unknown heat pump type: {bhp_type}")
@@ -214,6 +220,7 @@ def control_step(self, prosumer):
                         logging.warning(f"Heat pump is not operating due to the heat source "
                                         f"temperature being out of range: {float(t_source_k)} celsius")
                     else:
+
                         q_remain_kw, q_floor_kw, q_radiator_kw, cop_floor, cop_radiator = (
                             self.first_mode_calc(q_kw, demand_kw, p_el_kw, q_max_kw,
                                                  t_sink_floor_heating_k, t_sink_radiator_heating_k, t_source_k, cop_coeff))
@@ -329,6 +336,17 @@ def control_step(self, prosumer):
                   pd.Series(q_radiator_kw)
                   ])
 
+        self.last_result = {
+            "cop_floor": cop_floor,
+            "cop_radiator": cop_radiator,
+            "pel_floor_kw": pel_floor_kw,
+            "pel_radiator_kw": pel_radiator_kw,
+            "q_remain_kw": q_remain_kw,
+            "q_floor_kw": q_floor_kw,
+            "q_radiator_kw": q_radiator_kw
+        }
+
+
         self.finalize(prosumer, result.T)
 
         self.applied = True

src/pandaprosumer/controller/models/dry_cooler.py

@@ -246,12 +246,32 @@ def _calculate_dry_cooler(self, prosumer, mdot_fluid_kg_per_s, t_in_required_c,
                 mdot_air_kg_per_s, t_air_in_c, t_air_out_c,
                 mdot_fluid_kg_per_s, t_fluid_in_c, t_fluid_out_c)
 
+    def _save_state(self):
+        """Backup states before Run"""
+        self._backup_state = {
+            "t_previous_out_c": self.t_previous_out_c,
+            "t_previous_in_c": self.t_previous_in_c,
+            "mdot_previous_in_kg_per_s": self.mdot_previous_in_kg_per_s,
+        }
+
+    def _restore_state(self):
+        """Restore states before Rerun"""
+        if hasattr(self, "_backup_state"):
+            self.t_previous_out_c = self._backup_state["t_previous_out_c"]
+            self.t_previous_in_c = self._backup_state["t_previous_in_c"]
+            self.mdot_previous_in_kg_per_s = self._backup_state["mdot_previous_in_kg_per_s"]
+
     def control_step(self, prosumer):
         """
         Executes the control step for the controller.
 
         :param prosumer: The prosumer object
         """
+        if not prosumer.rerun:
+            self._save_state()
+        else:
+            self._restore_state()
+
         if not (self.in_service and getattr(prosumer, self.obj.element_name).iloc[self.obj.element_index[0]].in_service):
             self.applied = True
             return
@@ -300,6 +320,19 @@ def control_step(self, prosumer):
                             mdot_air_kg_per_s, t_air_in_c, t_air_out_c,
                             mdot_fluid_kg_per_s, t_fluid_in_c, t_fluid_out_c]])
 
+        self.last_result = {
+            "q_exchanged_kw": q_exchanged_kw,
+            "p_fans_kw": p_fans_kw,
+            "n_rpm": n_rpm,
+            "mdot_air_m3_per_h": mdot_air_m3_per_h,
+            "mdot_air_kg_per_s": mdot_air_kg_per_s,
+            "t_air_in_c": t_air_in_c,
+            "t_air_out_c": t_air_out_c,
+            "mdot_fluid_kg_per_s": mdot_fluid_kg_per_s,
+            "t_fluid_in_c": t_fluid_in_c,
+            "t_fluid_out_c": t_fluid_out_c,
+        }
+
         assert round(t_fluid_out_c, 4) <= round(t_fluid_in_c, 4), f"Dry Cooler {self.name} t_fluid_out_c > t_fluid_in_c ({t_fluid_out_c} > {t_fluid_in_c}) for timestep {self.time} in prosumer {prosumer.name}"
 
         # ToDo: Add a condition to check whether the mass flows are equal

src/pandaprosumer/controller/models/electric_boiler.py

@@ -139,6 +139,14 @@ def control_step(self, prosumer):
 
         result = np.array([[q_kw, mdot_delivered_kg_per_s, t_in_c, t_out_c, p_kw]])
 
+        self.last_result = {
+            "q_kw": q_kw,
+            "mdot_delivered_kg_per_s": mdot_delivered_kg_per_s,
+            "t_in_c": t_in_c,
+            "t_out_c": t_out_c,
+            "p_kw": p_kw,
+        }
+
         self.finalize(prosumer, result, result_fluid_mix)
 
         self.applied = True

src/pandaprosumer/controller/models/gas_boiler.py

@@ -121,6 +121,14 @@ def control_step(self, prosumer):
 
         result = np.array([[q_kw, mdot_delivered_kg_per_s, t_in_c, t_out_c, mdot_gas_kg_per_s]])
 
+        self.last_result = {
+            "q_kw": q_kw,
+            "mdot_delivered_kg_per_s": mdot_delivered_kg_per_s,
+            "t_in_c": t_in_c,
+            "t_out_c": t_out_c,
+            "mdot_gas_kg_per_s": mdot_gas_kg_per_s,
+        }
+
         self.finalize(prosumer, result, result_fluid_mix)
 
         self.applied = True

src/pandaprosumer/controller/models/heat_demand.py

@@ -161,12 +161,32 @@ def _t_m_to_receive_init(self, prosumer):
             assert t_feed_demand_c >= t_return_demand_c
             return t_feed_demand_c, t_return_demand_c, mdot_demand_kg_per_s
 
+    def _save_state(self):
+        """Backup states before Run"""
+        self._backup_state = {
+            "t_previous_out_c": self.t_previous_out_c,
+            "t_previous_in_c": self.t_previous_in_c,
+            "mdot_previous_in_kg_per_s": self.mdot_previous_in_kg_per_s,
+        }
+
+    def _restore_state(self):
+        """Restore states before Rerun"""
+        if hasattr(self, "_backup_state"):
+            self.t_previous_out_c = self._backup_state["t_previous_out_c"]
+            self.t_previous_in_c = self._backup_state["t_previous_in_c"]
+            self.mdot_previous_in_kg_per_s = self._backup_state["mdot_previous_in_kg_per_s"]
+
     def control_step(self, prosumer):
         """
         Executes the control step for the controller.
 
         :param prosumer: The prosumer object
         """
+        if not prosumer.rerun:
+            self._save_state()
+        else:
+            self._restore_state()
+
         if not (self.in_service and getattr(prosumer, self.obj.element_name).iloc[self.obj.element_index[0]].in_service):
             self.applied = True
             return
@@ -184,6 +204,14 @@ def control_step(self, prosumer):
             q_received_kw = self._get_input('q_received_kw')
             q_uncovered_kw = self._q_demand_kw - q_received_kw
             result = np.array([[q_received_kw, q_uncovered_kw, 0, 0, 0]])
+            self.last_result = {
+                "q_received_kw": q_received_kw,
+                "q_uncovered_kw": q_uncovered_kw,
+                "mdot_received_kg_per_s": 0,
+                "t_in_c": 0,
+                "t_out_c": 0
+            }
+
             self.finalize(prosumer, result)
             self.applied = True
             return
@@ -211,6 +239,13 @@ def control_step(self, prosumer):
         # FixMe: Consider the temperature level in the output
         q_uncovered_kw = q_demand_kw - q_received_kw
         result = np.array([[q_received_kw, q_uncovered_kw, mdot_received_kg_per_s, self._t_in_c, t_out_c]])
+        self.last_result = {
+            "q_received_kw": q_received_kw,
+            "q_uncovered_kw": q_uncovered_kw,
+            "mdot_received_kg_per_s": mdot_received_kg_per_s,
+            "t_in_c": self._t_in_c,
+            "t_out_c": t_out_c
+        }
         if np.isnan(result).any():
             self.input_mass_flow_with_temp = {FluidMixMapping.TEMPERATURE_KEY: np.nan,
                                               FluidMixMapping.MASS_FLOW_KEY: np.nan}

src/pandaprosumer/controller/models/heat_exchanger.py

@@ -253,12 +253,32 @@ def calculate_heat_exchanger_reverse(self, prosumer, t_1_in_c, t_1_out_c, mdot_1
 
         return mdot_1_kg_per_s, t_1_in_c, t_1_out_c, mdot_2_kg_per_s, t_2_in_c, t_2_out_c
 
+    def _save_state(self):
+        """Backup states before Run"""
+        self._backup_state = {
+            "t_previous_1_out_c": self.t_previous_1_out_c,
+            "t_previous_1_in_c": self.t_previous_1_in_c,
+            "mdot_previous_1_kg_per_s": self.mdot_previous_1_kg_per_s,
+        }
+
+    def _restore_state(self):
+        """Restore states before Rerun"""
+        if hasattr(self, "_backup_state"):
+            self.t_previous_1_out_c = self._backup_state["t_previous_1_out_c"]
+            self.t_previous_1_in_c = self._backup_state["t_previous_1_in_c"]
+            self.mdot_previous_1_kg_per_s = self._backup_state["mdot_previous_1_kg_per_s"]
+
     def control_step(self, prosumer):
         """
         Executes the control step for the controller.
 
         :param prosumer: The prosumer object
         """
+        if not prosumer.rerun:
+            self._save_state()
+        else:
+            self._restore_state()
+
         if not (self.in_service and getattr(prosumer, self.obj.element_name).iloc[
             self.obj.element_index[0]].in_service):  # FixMe: use gettattr element
             self.applied = True
@@ -396,6 +416,16 @@ def control_step(self, prosumer):
             [[q_exchanged_kw, mdot_1_kg_per_s, t_1_in_c, t_1_out_c, mdot_2_kg_per_s, t_2_in_c, t_2_out_c]]
         )
 
+        self.last_result = {
+            "q_exchanged_kw": q_exchanged_kw,
+            "mdot_1_kg_per_s": mdot_1_kg_per_s,
+            "t_1_in_c": t_1_in_c,
+            "t_1_out_c": t_1_out_c,
+            "mdot_2_kg_per_s": mdot_2_kg_per_s,
+            "t_2_in_c": t_2_in_c,
+            "t_2_out_c": t_2_out_c,
+        }
+
         result_fluid_mix = []
         for mdot_kg_per_s in result_mdot_tab_kg_per_s:
             result_fluid_mix.append({FluidMixMapping.TEMPERATURE_KEY: t_2_out_c,

src/pandaprosumer/controller/models/heat_pump.py

@@ -229,12 +229,30 @@ def _calculate_heat_pump_reverse(self, prosumer, mdot_evap_kg_per_s, t_evap_in_c
                 mdot_cond_kg_per_s, t_cond_in_c, t_cond_out_c,
                 mdot_evap_kg_per_s, t_evap_in_c, t_evap_out_c)
 
+    def _save_state(self):
+        self._backup_state = {
+            "t_previous_evap_out_c": self.t_previous_evap_out_c,
+            "t_previous_evap_in_c": self.t_previous_evap_in_c,
+            "mdot_previous_evap_kg_per_s": self.mdot_previous_evap_kg_per_s,
+        }
+
+    def _restore_state(self):
+        if hasattr(self, "_backup_state"):
+            self.t_previous_evap_out_c = self._backup_state["t_previous_evap_out_c"]
+            self.t_previous_evap_in_c = self._backup_state["t_previous_evap_in_c"]
+            self.mdot_previous_evap_kg_per_s = self._backup_state["mdot_previous_evap_kg_per_s"]
+
     def control_step(self, prosumer):
         """
         Executes the control step for the controller.
 
         :param prosumer: The prosumer object
         """
+        if not prosumer.rerun:
+            self._save_state()
+        else:
+            self._restore_state()
+
         if not (self.in_service and getattr(prosumer, self.obj.element_name).iloc[self.obj.element_index[0]].in_service):
             self.applied = True
             return
@@ -328,6 +346,19 @@ def control_step(self, prosumer):
                             mdot_cond_kg_per_s, t_cond_in_c, t_cond_out_c,
                             mdot_evap_kg_per_s, t_evap_in_c, t_evap_out_c]])
 
+        self.last_result = {
+            "q_cond_kw": q_cond_kw,
+            "p_comp_kw": p_comp_kw,
+            "q_evap_kw": q_evap_kw,
+            "cop_hp": cop_hp,
+            "mdot_cond_kg_per_s": mdot_cond_kg_per_s,
+            "t_cond_in_c": t_cond_in_c,
+            "t_cond_out_c": t_cond_out_c,
+            "mdot_evap_kg_per_s": mdot_evap_kg_per_s,
+            "t_evap_in_c": t_evap_in_c,
+            "t_evap_out_c": t_evap_out_c,
+        }
+
         assert cop_hp >= 0, f"Heat Pump {self.name} COP is negative ({cop_hp}) for timestep {self.time} in prosumer {prosumer.name}"
         assert mdot_evap_kg_per_s >= 0, f"Heat Pump {self.name} mdot_evap_kg_per_s is negative ({mdot_evap_kg_per_s}) for timestep {self.time} in prosumer {prosumer.name}"
         assert mdot_cond_kg_per_s >= 0, f"Heat Pump {self.name} mdot_cond_kg_per_s is negative ({mdot_cond_kg_per_s}) for timestep {self.time} in prosumer {prosumer.name}"