Fixed issues, now have mode for normal and bypass operation

Author: samvanderzwan

src/omotes_simulator_core/entities/assets/ates_cluster.py

@@ -147,9 +147,9 @@ def _calculate_massflowrate(self) -> None:
     def _set_solver_asset_setpoint(self) -> None:
         """Set the setpoint of solver asset."""
         if self.mass_flowrate >= 0:
-            self.solver_asset.supply_temperature = self.cold_well_temperature  # injection
-        else:
             self.solver_asset.supply_temperature = self.hot_well_temperature  # production
+        else:
+            self.solver_asset.supply_temperature = self.cold_well_temperature  # injection
         self.solver_asset.mass_flow_rate_set_point = self.mass_flowrate  # type: ignore
 
     def set_setpoints(self, setpoints: dict) -> None:
@@ -169,19 +169,23 @@ def set_setpoints(self, setpoints: dict) -> None:
         setpoints_set = set(setpoints.keys())
         # Check if all setpoints are in the setpoints
         if necessary_setpoints.issubset(setpoints_set):
-            self.thermal_power_allocation = -1 * setpoints[PROPERTY_HEAT_DEMAND]
+            self.thermal_power_allocation = -setpoints[PROPERTY_HEAT_DEMAND]
             if self.first_time_step:
-                self.temperature_in = setpoints[PROPERTY_TEMPERATURE_IN]
-                self.temperature_out = setpoints[PROPERTY_TEMPERATURE_OUT]
+                if self.thermal_power_allocation >= 0:
+                    self.temperature_in = setpoints[PROPERTY_TEMPERATURE_OUT]
+                    self.temperature_out = setpoints[PROPERTY_TEMPERATURE_IN]
+                else:
+                    self.temperature_in = setpoints[PROPERTY_TEMPERATURE_IN]
+                    self.temperature_out = setpoints[PROPERTY_TEMPERATURE_OUT]
                 self.first_time_step = False
             else:
                 # After the first time step: use solver temperature
                 if self.thermal_power_allocation >= 0:
+                    self.temperature_out = self.solver_asset.get_temperature(0)
                     self.temperature_in = self.hot_well_temperature
-                    self.temperature_out = self.solver_asset.get_temperature(1)
                 else:
-                    self.temperature_in = self.solver_asset.get_temperature(0)
-                    self.temperature_out = self.cold_well_temperature
+                    self.temperature_in = self.cold_well_temperature
+                    self.temperature_out = self.solver_asset.get_temperature(1)
 
             self._calculate_massflowrate()
             if self.current_time != self.time:
@@ -331,6 +335,6 @@ def is_converged(self) -> bool:
 
         :return: True if the asset has converged, False otherwise
         """
-        return abs(self.get_heat_supplied() + self.thermal_power_allocation) < (
-            self.thermal_power_allocation * 0.001
+        return abs(self.get_heat_supplied() - self.thermal_power_allocation) < (
+            abs(self.thermal_power_allocation) * 0.001
         )

src/omotes_simulator_core/entities/assets/controller/controller_heat_transfer.py

@@ -57,20 +57,22 @@ def set_asset(self, heat_demand: float, bypass: bool = False) -> dict[str, dict[
                     SECONDARY + PROPERTY_HEAT_DEMAND: heat_demand * -1,
                     SECONDARY + PROPERTY_TEMPERATURE_OUT: 273.15 + 80,
                     SECONDARY + PROPERTY_TEMPERATURE_IN: 273.15 + 50,
-                    PROPERTY_SET_PRESSURE: False,
+                    SECONDARY + PROPERTY_SET_PRESSURE: False,
+                    PRIMARY + PROPERTY_SET_PRESSURE: False,
                     PROPERTY_BYPASS: True,
                 }
             }
         else:
             return {
                 self.id: {
-                    PRIMARY + PROPERTY_HEAT_DEMAND: heat_demand,
+                    PRIMARY + PROPERTY_HEAT_DEMAND: heat_demand / self.factor,
                     PRIMARY + PROPERTY_TEMPERATURE_OUT: 273.15 + 30,
-                    PRIMARY + PROPERTY_TEMPERATURE_IN: 273.15 + 40,
-                    SECONDARY + PROPERTY_HEAT_DEMAND: -heat_demand * self.factor,
+                    PRIMARY + PROPERTY_TEMPERATURE_IN: 273.15 + 50,
+                    SECONDARY + PROPERTY_HEAT_DEMAND: -heat_demand,
                     SECONDARY + PROPERTY_TEMPERATURE_OUT: 273.15 + 80,
-                    SECONDARY + PROPERTY_TEMPERATURE_IN: 273.15 + 50,
-                    PROPERTY_SET_PRESSURE: False,
+                    SECONDARY + PROPERTY_TEMPERATURE_IN: 273.15 + 40,
+                    SECONDARY + PROPERTY_SET_PRESSURE: False,
+                    PRIMARY + PROPERTY_SET_PRESSURE: False,
                     PROPERTY_BYPASS: False,
                 }
             }

src/omotes_simulator_core/entities/assets/controller/controller_network.py

@@ -23,6 +23,8 @@
     PROPERTY_SET_PRESSURE,
     PROPERTY_TEMPERATURE_IN,
     PROPERTY_TEMPERATURE_OUT,
+    SECONDARY,
+    PRIMARY,
 )
 from omotes_simulator_core.entities.assets.controller.controller_consumer import ControllerConsumer
 from omotes_simulator_core.entities.assets.controller.controller_heat_transfer import (
@@ -232,17 +234,17 @@ def get_total_supply_priority(self, priority: int) -> float:
             sum([producer.power for producer in self.producers if producer.priority == priority])
         )
 
-    def set_pressure(self) -> str:
-        """Returns the id of the asset for which the pressure can be set for this network.
+    def set_pressure(self) -> tuple[str, str]:
+        """Returns the id of the asset for which the pressure can be set for this network and the key in the set points dict.
 
         The controller needs to set per hydraulic separated part of the system the pressure.
         The network can thus pass back the id for which asset the pressure needs to be set.
         The controller can then do this.
         """
         if self.producers:
-            return self.producers[0].id
+            return (self.producers[0].id, PROPERTY_SET_PRESSURE)
         if self.heat_transfer_assets_sec:
-            return self.heat_transfer_assets_sec[0].id
+            return (self.heat_transfer_assets_sec[0].id, SECONDARY + PROPERTY_SET_PRESSURE)
         if self.heat_transfer_assets_prim:
-            return self.heat_transfer_assets_prim[0].id
+            return (self.heat_transfer_assets_prim[0].id, PRIMARY + PROPERTY_SET_PRESSURE)
         raise ValueError("No asset found for which the pressure can be set.")

src/omotes_simulator_core/entities/assets/heat_pump.py

@@ -118,7 +118,7 @@ def _set_setpoints_secondary(self, setpoints_secondary: Dict) -> None:
             SECONDARY + PROPERTY_TEMPERATURE_IN,
             SECONDARY + PROPERTY_TEMPERATURE_OUT,
             SECONDARY + PROPERTY_HEAT_DEMAND,
-            PROPERTY_SET_PRESSURE,
+            SECONDARY + PROPERTY_SET_PRESSURE,
             PROPERTY_BYPASS,
         }
         # Dict to set
@@ -138,14 +138,13 @@ def _set_setpoints_secondary(self, setpoints_secondary: Dict) -> None:
 
         # self.temperature_in_secondary = setpoints_secondary[SECONDARY + PROPERTY_TEMPERATURE_IN]
         self.temperature_out_secondary = setpoints_secondary[SECONDARY + PROPERTY_TEMPERATURE_OUT]
-        self.mass_flow_secondary = heat_demand_and_temperature_to_mass_flow(
+        self.mass_flow_secondary = -heat_demand_and_temperature_to_mass_flow(
             thermal_demand=setpoints_secondary[SECONDARY + PROPERTY_HEAT_DEMAND],
             temperature_in=self.temperature_in_secondary,
             temperature_out=self.temperature_out_secondary,
         )
         self.control_mass_flow_secondary = not (
-            setpoints_secondary[PROPERTY_SET_PRESSURE]
-            & (setpoints_secondary[SECONDARY + PROPERTY_HEAT_DEMAND] < 0)
+            setpoints_secondary[SECONDARY + PROPERTY_SET_PRESSURE]
         )
 
         # Assign setpoints to the HeatTransferAsset solver asset
@@ -178,6 +177,7 @@ def _set_setpoints_primary(self, setpoints_primary: Dict) -> None:
             PRIMARY + PROPERTY_TEMPERATURE_IN,
             PRIMARY + PROPERTY_TEMPERATURE_OUT,
             PRIMARY + PROPERTY_HEAT_DEMAND,
+            PRIMARY + PROPERTY_SET_PRESSURE,
         }
         # Dict to set
         setpoints_set = set(setpoints_primary.keys())
@@ -201,10 +201,7 @@ def _set_setpoints_primary(self, setpoints_primary: Dict) -> None:
             temperature_in=self.temperature_in_primary,
             temperature_out=self.temperature_out_primary,
         )
-        self.control_mass_flow_primary = not (
-            setpoints_primary[PROPERTY_SET_PRESSURE]
-            & (setpoints_primary[PRIMARY + PROPERTY_HEAT_DEMAND] < 0)
-        )
+        self.control_mass_flow_primary = not (setpoints_primary[PRIMARY + PROPERTY_SET_PRESSURE])
 
         # Assign setpoints to the HeatTransferAsset solver asset
         self.solver_asset.temperature_in_primary = self.temperature_in_primary  # type: ignore

src/omotes_simulator_core/entities/assets/utils.py

@@ -35,8 +35,9 @@ def heat_demand_and_temperature_to_mass_flow(
     :param float temperature_in: The temperature that the asset receives from the
         "from_junction". The temperature should be supplied in Kelvin.
     """
-    heat_capacity = fluid_props.get_heat_capacity((temperature_in + temperature_out) / 2)
-    return thermal_demand / ((temperature_out - temperature_in) * float(heat_capacity))
+    internal_energy1 = fluid_props.get_ie(temperature_in)
+    internal_energy2 = fluid_props.get_ie(temperature_out)
+    return thermal_demand / (internal_energy2 - internal_energy1)
 
 
 def mass_flow_and_temperature_to_heat_demand(

src/omotes_simulator_core/entities/network_controller.py

@@ -60,13 +60,12 @@ def update_networks_factor(self) -> None:
                 for asset in current_network.heat_transfer_assets_prim:
                     if self.networks[int(step)].exists(asset.id):
                         network.factor_to_first_network.append(asset.factor)
-                        current_network = self.networks[int(step)]
                         break
                 for asset in current_network.heat_transfer_assets_sec:
                     if self.networks[int(step)].exists(asset.id):
                         network.factor_to_first_network.append(1 / asset.factor)
-                        current_network = self.networks[int(step)]
                         break
+                current_network = self.networks[int(step)]
 
     def update_setpoints(self, time: datetime.datetime) -> dict:
         """Method to get the controller inputs for the network.
@@ -181,8 +180,8 @@ def update_setpoints(self, time: datetime.datetime) -> dict:
 
         # Set the pressure.
         for network in self.networks:
-            pressure_set_asset = network.set_pressure()
-            asset_setpoints[pressure_set_asset][PROPERTY_SET_PRESSURE] = True
+            pressure_set_asset, key = network.set_pressure()
+            asset_setpoints[pressure_set_asset][key] = True
 
         return asset_setpoints
 

src/omotes_simulator_core/infrastructure/app.py

@@ -41,9 +41,9 @@ def run(file_path: str | None = None) -> pd.DataFrame:
     config = SimulationConfiguration(
         simulation_id=uuid.uuid1(),
         name="test run",
-        timestep=3600,
-        start=datetime.strptime("2019-01-01T00:00:00", "%Y-%m-%dT%H:%M:%S"),
-        stop=datetime.strptime("2019-01-01T01:00:00", "%Y-%m-%dT%H:%M:%S"),
+        timestep=24 * 3600,
+        start=datetime.strptime("2019-01-18T00:00:00", "%Y-%m-%dT%H:%M:%S"),
+        stop=datetime.strptime("2019-02-01T00:00:00", "%Y-%m-%dT%H:%M:%S"),
     )
 
     esdl_file_path = sys.argv[1] if file_path is None else file_path
@@ -63,9 +63,10 @@ def run(file_path: str | None = None) -> pd.DataFrame:
         level=logging.INFO, format="%(asctime)s [%(levelname)s]:%(name)s - %(message)s"
     )
     t1 = datetime.now()
-    result = run(r".\testdata\test1.esdl")
+    result = run(r".\testdata\heat_pump_bypass.esdl")
     t2 = datetime.now()
 
     logger.info(f"Results dataframe shape=({result.shape})")
+    result.to_csv(r".\testdata\heat_pump_bypass_results.csv", index=False)
     logger.info(f"Execution time: {t2 - t1}")
     logger.debug(result.head())