omotes-simulator-core 0.0.3.dev0__py3-none-any.whl

simulator_core/entities/assets/production_cluster.py

@@ -0,0 +1,222 @@
+#  Copyright (c) 2023. Deltares & TNO
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""ProductionCluster class."""
+import uuid
+from typing import Dict
+
+from simulator_core.entities.assets.asset_abstract import AssetAbstract
+from simulator_core.entities.assets.asset_defaults import (
+    DEFAULT_NODE_HEIGHT,
+    DEFAULT_PRESSURE,
+    DEFAULT_TEMPERATURE,
+    DEFAULT_TEMPERATURE_DIFFERENCE,
+    PROPERTY_HEAT_DEMAND,
+    PROPERTY_MASSFLOW,
+    PROPERTY_PRESSURE_RETURN,
+    PROPERTY_PRESSURE_SUPPLY,
+    PROPERTY_SET_PRESSURE,
+    PROPERTY_TEMPERATURE_RETURN,
+    PROPERTY_TEMPERATURE_SUPPLY,
+)
+from simulator_core.entities.assets.esdl_asset_object import EsdlAssetObject
+from simulator_core.entities.assets.utils import (
+    heat_demand_and_temperature_to_mass_flow,
+)
+from simulator_core.solver.network.assets.production_asset import ProductionAsset
+
+
+class ProductionCluster(AssetAbstract):
+    """A ProductionCluster represents an asset that produces heat."""
+
+    thermal_production_required: float | None
+    """The thermal production required by the asset [W]."""
+
+    temperature_supply: float
+    """The supply temperature of the asset [K]."""
+
+    temperature_return: float
+    """The return temperature of the asset [K]."""
+
+    pressure_supply: float
+    """The supply pressure of the asset [Pa]."""
+
+    control_mass_flow: bool
+    """Flag to indicate whether the mass flow rate is controlled.
+    If True, the mass flow rate is controlled. If False, the mass flow rate is not controlled
+    and the pressure is predescribed.
+    """
+
+    controlled_mass_flow: float | None
+    """The controlled mass flow of the asset [kg/s]."""
+
+    def __init__(self, asset_name: str, asset_id: str):
+        """Initialize a ProductionCluster object.
+
+        :param str asset_name: The name of the asset.
+        :param str asset_id: The unique identifier of the asset.
+        :param PandapipesNet pandapipe_net: Pandapipes network object to register asset to.
+        """
+        super().__init__(asset_name=asset_name, asset_id=asset_id)
+        self.height_m = DEFAULT_NODE_HEIGHT
+        # DemandCluster thermal and mass flow specifications
+        self.thermal_production_required = None
+        self.temperature_supply = DEFAULT_TEMPERATURE
+        self.temperature_return = DEFAULT_TEMPERATURE - DEFAULT_TEMPERATURE_DIFFERENCE
+        # DemandCluster pressure specifications
+        self.pressure_supply = DEFAULT_PRESSURE
+        self.control_mass_flow = False
+        # Controlled mass flow
+        self.controlled_mass_flow = None
+        self.solver_asset = ProductionAsset(
+            name=uuid.uuid4(),
+            pre_scribe_mass_flow=False,
+            set_pressure=self.pressure_supply,
+        )
+
+    def add_physical_data(self, esdl_asset: EsdlAssetObject) -> None:
+        """Method to add physical data to the asset.
+
+        :param EsdlAssetObject esdl_asset: The ESDL asset object containing the physical data.
+        :return:
+        """
+
+    def _set_supply_temperature(self, temperature_supply: float) -> None:
+        """Set the supply temperature of the asset.
+
+        :param float temperature_supply: The supply temperature of the asset.
+            The temperature should be supplied in Kelvin.
+        """
+        # Set the temperature of the circulation pump mass flow
+        self.temperature_supply = temperature_supply
+        self.solver_asset.supply_temperature = self.temperature_supply
+
+    def _set_return_temperature(self, temperature_return: float) -> None:
+        """Set the return temperature of the asset.
+
+        :param float temperature_return: The return temperature of the asset.
+            The temperature should be supplied in Kelvin.
+        """
+        # Set the return temperature of the asset
+        self.temperature_return = temperature_return
+
+    def _set_heat_demand(self, heat_demand: float) -> None:
+        """Set the heat demand of the asset.
+
+        :param float heat_demand: The heat demand of the asset.
+            The heat demand should be supplied in Watts.
+        """
+        # Calculate the mass flow rate
+        self.controlled_mass_flow = heat_demand_and_temperature_to_mass_flow(
+            thermal_demand=heat_demand,
+            temperature_supply=self.temperature_supply,
+            temperature_return=self.temperature_return,
+        )
+
+        # Check if the mass flow rate is positive
+        if self.controlled_mass_flow < 0.0:
+            raise ValueError(
+                f"The mass flow rate {self.controlled_mass_flow} of the asset {self.name}"
+                + " is negative."
+            )
+        else:
+            # Set the mass flow rate of the control valve
+            self.solver_asset.mass_flow_rate_set_point = self.controlled_mass_flow  # type: ignore
+
+    def _set_pressure_or_mass_flow_control(self, pressure_supply: bool) -> None:
+        """Set the asset to predescribe either the pressure or the mass flow rate.
+
+        :param bool pressure_supply: True when the pressure needs to be set
+        """
+        if pressure_supply:
+            self.solver_asset.pre_scribe_mass_flow = False  # type: ignore
+        else:
+            self.solver_asset.pre_scribe_mass_flow = True   # type: ignore
+
+    def set_pressure_supply(self, pressure_supply: float) -> None:
+        """Set the supply pressure of the asset.
+
+        :param float pressure_supply: The supply pressure of the asset.
+            The pressure should be supplied in Pascal.
+        """
+        # Check if the pressure is positive
+        if pressure_supply < 0.0:
+            raise ValueError(
+                f"The pressure {pressure_supply} of the asset {self.name} can not be negative."
+            )
+        # Set the supply pressure of the asset
+        self.pressure_supply = pressure_supply
+        # Set the pressure of the solver asset
+        self.solver_asset.set_pressure = self.pressure_supply   # type: ignore
+
+    def set_setpoints(self, setpoints: Dict) -> None:
+        """Set the setpoints of the asset.
+
+        :param Dict setpoints: The setpoints of the asset in a dictionary,
+            as "property_name": value pairs.
+
+        """
+        # Default keys required
+        necessary_setpoints = {
+            PROPERTY_TEMPERATURE_SUPPLY,
+            PROPERTY_TEMPERATURE_RETURN,
+            PROPERTY_HEAT_DEMAND,
+            PROPERTY_SET_PRESSURE,
+        }
+        # Dict to set
+        setpoints_set = set(setpoints.keys())
+        # Check if all setpoints are in the setpoints
+        if necessary_setpoints.issubset(setpoints_set):
+            # Set the setpoints
+            self._set_pressure_or_mass_flow_control(setpoints[PROPERTY_SET_PRESSURE])
+            self._set_supply_temperature(setpoints[PROPERTY_TEMPERATURE_SUPPLY])
+            self._set_return_temperature(setpoints[PROPERTY_TEMPERATURE_RETURN])
+            self._set_heat_demand(setpoints[PROPERTY_HEAT_DEMAND])
+        else:
+            # Print missing setpoints
+            raise ValueError(
+                f"The setpoints {necessary_setpoints.difference(setpoints_set)} are missing."
+            )
+
+    def update(self) -> None:
+        """Update the asset properties to the results from the previous (timestep) simulation.
+
+        Sets the values of the supply temperature, return temperature and heat demand
+        to the values of the previous simulation. In addition, the mass flow rate is set
+        to the value of the previous simulation.
+        """
+
+    def write_to_output(self) -> None:
+        """Write the output of the asset to the output list.
+
+        The output list is a list of dictionaries, where each dictionary
+        represents the output of its asset for a specific timestep.
+
+        The output of the asset is a dictionary with the following keys:
+        - PROPERTY_HEAT_DEMAND: The heat demand of the asset.
+        - PROPERTY_TEMPERATURE_SUPPLY: The supply temperature of the asset.
+        - PROPERTY_TEMPERATURE_RETURN: The return temperature of the asset.
+        - PROPERTY_PRESSURE_SUPPLY: The supply pressure of the asset.
+        - PROPERTY_PRESSURE_RETURN: The return pressure of the asset.
+        - PROPERTY_MASSFLOW: The mass flow rate of the asset.
+        """
+        output_dict = {
+            PROPERTY_MASSFLOW: self.solver_asset.get_mass_flow_rate(1),
+            PROPERTY_PRESSURE_SUPPLY: self.solver_asset.get_pressure(0),
+            PROPERTY_PRESSURE_RETURN: self.solver_asset.get_pressure(1),
+            PROPERTY_TEMPERATURE_SUPPLY: self.solver_asset.get_temperature(0),
+            PROPERTY_TEMPERATURE_RETURN: self.solver_asset.get_temperature(1),
+        }
+        self.output.append(output_dict)

simulator_core/entities/assets/utils.py

@@ -0,0 +1,154 @@
+#  Copyright (c) 2023. Deltares & TNO
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Utility functions for assets."""
+from enum import IntEnum
+
+from pandapipes import pandapipesNet
+import numpy as np
+from simulator_core.entities.assets.esdl_asset_object import EsdlAssetObject
+from typing import List, Tuple
+from simulator_core.solver.utils.fluid_properties import fluid_props
+
+
+def heat_demand_and_temperature_to_mass_flow(
+        thermal_demand: float,
+        temperature_supply: float,
+        temperature_return: float
+) -> float:
+    """Calculate the mass flow rate that is required to meet the thermal demand.
+
+    :param float thermal_demand: The thermal demand of the asset. The thermal demand should be
+        supplied in Watts.
+    :param float temperature_supply: The temperature that the asset delivers to the "to_junction".
+        The temperature should be supplied in Kelvin. The supply temperature is used to calculate
+        the specific heat capacity of the fluid.
+    :param float temperature_return: 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_return + temperature_supply) / 2)
+    return thermal_demand / ((temperature_supply - temperature_return) * float(heat_capacity))
+
+
+def mass_flow_and_temperature_to_heat_demand(
+        temperature_supply: float,
+        temperature_return: float,
+        mass_flow: float,
+) -> float:
+    """Calculate the thermal demand that is met by the mass flow rate.
+
+    :param float temperature_supply: The temperature that the asset delivers to the "to_junction".
+        The temperature should be supplied in Kelvin. The supply temperature is used to calculate
+        the specific heat capacity of the fluid.
+    :param float temperature_return: The temperature that the asset receives from the
+        "from_junction". The temperature should be supplied in Kelvin.
+    :param float mass_flow: The mass flow rate that is used to meet the thermal demand. The mass
+        flow rate should be supplied in kg/s.
+    """
+    internal_energy1 = fluid_props.get_ie(temperature_supply)
+    internal_energy2 = fluid_props.get_ie(temperature_return)
+    return mass_flow * (internal_energy1 - internal_energy2)
+
+
+def get_thermal_conductivity_table(esdl_asset: EsdlAssetObject) -> Tuple[List[float], List[float]]:
+    """Retrieve the thermal conductivity table of the asset.
+
+    :param EsdlAssetObject esdl_asset: The asset of which the heat transfer table should be
+        retrieved.
+    :return: The diameters and thermal conductivities of the asset in a tuple with the diameters
+        as the first element and the thermal conductivities as the second element. Each element
+        represents a layer of the asset.
+    """
+    # create heat transfer table
+    layer_thicknesses = []
+    diameters = []
+    heat_coef = []
+    if esdl_asset.esdl_asset.material is not None:
+        if hasattr(esdl_asset.esdl_asset.material, "component"):
+            material_object = esdl_asset.esdl_asset.material.component
+        elif hasattr(esdl_asset.esdl_asset.material, "reference"):
+            material_object = esdl_asset.esdl_asset.material.reference.component
+        else:
+            raise NotImplementedError("Unknown material type or reference.")
+        # Append initial internal diameter
+        diameters.append(esdl_asset.esdl_asset.innerDiameter)
+        # Loop over material object
+        for layer in material_object:
+            layer_thicknesses.append(layer.layerWidth * 2)
+            diameters.append(sum(layer_thicknesses) + esdl_asset.esdl_asset.innerDiameter)
+            heat_coef.append(layer.matter.thermalConductivity)
+    return diameters, heat_coef
+
+
+def calculate_inverse_heat_transfer_coefficient(
+        inner_diameter: np.ndarray, outer_diameter: np.ndarray, thermal_conductivity: np.ndarray
+) -> np.ndarray:
+    """Calculate the inverse heat transfer coefficient of a pipe.
+
+    :param inner_diameter: Inner diameter of the pipe in m
+    :param outer_diameter: Outer diameter of the pipe in m
+    :param thermal_conductivity: Thermal conductivity of the pipe material in W/(m K)
+    :return: Inverse heat transfer coefficient in W/(m^2 K)
+    """
+    return np.array((inner_diameter * np.log(outer_diameter / inner_diameter))
+                    / (2.0 * thermal_conductivity))
+
+
+def mass_flow_to_volume_flow(
+        mass_flow_rate: float,
+        temperature_fluid: float,
+        pandapipes_net: pandapipesNet,
+) -> float:
+    """Calculate the volume flow rate from mass flow rate.
+
+    :param float mass_flow_rate: the mass flow rate in kg/s
+    :param float temperature_fluid: the fluid temperature in K
+    :param pandapipesNet pandapipes_net: The pandapipes network used to calculate
+    the specific density.
+
+    :return float volume_flow rate: the volume flow rate in m3/s
+    """
+    density_fluid = pandapipes_net.fluid.get_density(temperature_fluid)
+    if (density_fluid == 0) | (density_fluid is None):
+        raise ValueError("The density of the fluid is zero or None.")
+    volume_flowrate = mass_flow_rate / density_fluid
+    return float(volume_flowrate)
+
+
+def volume_flow_to_mass_flow(
+        volume_flowrate: float,
+        temperature_fluid: float,
+        pandapipes_net: pandapipesNet,
+) -> float:
+    """Calculate the mass flowrate from volume flowrate.
+
+    :param float volume_flowrate: the volume flowrate in m3/s
+    :param float temperature_fluid: the fluid temperature in K
+    :param pandapipesNet net: The pandapipes network used to calculate the specific density.
+
+    :return float mass_flowrate: the mass flowrate in kg/s
+    """
+    density_fluid = pandapipes_net.fluid.get_density(temperature_fluid)
+    mass_flowrate = volume_flowrate * density_fluid
+
+    return float(mass_flowrate)
+
+
+class Port(IntEnum):
+    """Simple enumeration class to set if it is In (from) or out(to) port of asset."""
+
+    In = 0
+    Out = 1

simulator_core/entities/esdl_object.py

@@ -0,0 +1,90 @@
+#  Copyright (c) 2023. Deltares & TNO
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Esdl asset wrapper class."""
+
+import logging
+from typing import List, Tuple
+
+from esdl import InPort, OutPort
+from esdl.esdl_handler import EnergySystemHandler
+
+from simulator_core.adapter.transforms.string_to_esdl import StringEsdlAssetMapper
+from simulator_core.entities.assets.esdl_asset_object import EsdlAssetObject
+from simulator_core.entities.assets.utils import Port
+
+logger = logging.getLogger(__name__)
+
+
+class EsdlObject:
+    """EsdlObject class is a wrapper around PyEsdl."""
+
+    energy_system_handler: EnergySystemHandler
+
+    def __init__(self, esdl_energysystem_handler: EnergySystemHandler) -> None:
+        """
+        Constructor for EsdlObject.
+
+        :param esdl_energysystem: PyEsdl EnergySystem object
+        """
+        self.energy_system_handler = esdl_energysystem_handler
+
+    def __repr__(self) -> str:
+        """Returns a string describing the esdl file object."""
+        return str(self.energy_system_handler)
+
+    def get_all_assets_of_type(self, esdl_asset_type: str) -> list[EsdlAssetObject]:
+        """
+        Returns a list of all the esdl assets of the specified type in the esdl file.
+
+        If the type is not found an empty list is returned.
+        :param esdl_asset_type: str of the asset type assets need to be gathered.
+        """
+        output_list = []
+        for asset_type in StringEsdlAssetMapper().to_esdl(esdl_asset_type):
+            output_list += [
+                EsdlAssetObject(asset)
+                for asset in self.energy_system_handler.get_all_instances_of_type(asset_type)
+            ]
+        return output_list
+
+    def get_connected_assets(self, asset_id: str, port: Port) -> List[Tuple[str, Port]]:
+        """Method to get the id's of connected assets from the esdl.
+
+        This returns a list of list with the connected asset id and the port to which it is
+        connected to the asset.
+        First it is set if the request is an in or outport. Then the connected ports to the asset
+        are added to a list. In the final step all assets elong to the ports are listed together
+        with the type of port they are connected to.
+
+        :param str id: id of the asset for which we want to know the connected assets
+        :param Port port: port for which the connected assets need to be returned.
+        :return: List of list which the id of the connected assets and the connected port.
+        """
+        # TODO 1. Add support for components with multiple in and outports, like heat exchanger
+        # TODO 2. What if it is connected to a joint?
+        connected_assets = []
+        esdl_asset = self.energy_system_handler.get_by_id(asset_id)
+
+        type_port = OutPort if port == Port.Out else InPort
+        connected_port_ids = []
+        for esdl_port in esdl_asset.port:
+            if isinstance(esdl_port, type_port):
+                connected_port_ids = esdl_port.connectedTo
+                break
+        for connected_port_id in connected_port_ids:
+            connected_port_type = Port.Out if isinstance(connected_port_id, OutPort) else Port.In
+            connected_assets.append((connected_port_id.energyasset.id, connected_port_type))
+        return connected_assets

simulator_core/entities/heat_network.py

@@ -0,0 +1,82 @@
+#  Copyright (c) 2023. Deltares & TNO
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""HeatNetwork entity class."""
+import datetime
+from typing import Callable, List, Tuple
+
+import pandas as pd
+
+from simulator_core.entities.assets.asset_abstract import AssetAbstract
+from simulator_core.entities.assets.junction import Junction
+from simulator_core.solver.network.network import Network
+from simulator_core.solver.solver import Solver
+
+
+class HeatNetwork:
+    """Class to store information on the heat network."""
+
+    def __init__(self, conversion_factory: Callable[[Network], Tuple[List[AssetAbstract],
+                                                                     List[Junction]]]) -> None:
+        """Constructor of heat network class.
+
+        :param conversion_factory: method to convert the esdl network to pandapipes
+        assets and junctions and returns list of both
+        """
+        self.network = Network()
+        self.assets, self.junctions = conversion_factory(self.network)
+        self.solver = Solver(self.network)
+
+    def run_time_step(self, time: datetime.datetime, controller_input: dict) -> None:
+        """Method to simulate a time step.
+
+        It first sets the controller input to the assets and then simulates the time step.
+
+        :param float time: Timestep for which to simulate the model
+        :param dict controller_input: Dict specifying the heat demand for the different assets.
+        :return: None
+        """
+        for py_asset in self.assets:
+            if py_asset.asset_id in controller_input:
+                py_asset.set_setpoints(controller_input[py_asset.asset_id])
+        self.solver.solve()
+
+    def plot_network(self) -> None:
+        """Method to plot the network.
+
+        plots the network in a simple plot all junctions are translated to a circle.
+        :return:
+        """
+    def store_output(self) -> None:
+        """Method to store the output data.
+
+        This method takes the data from the pandapipes dataframe and stores it into our own
+        dataframe. This is needed since we have the possibility to redo a timestep when results are
+        not converged for the input of the controller.
+        :return: None
+        """
+        for py_asset in self.assets:
+            py_asset.write_to_output()
+
+    def gather_output(self) -> pd.DataFrame:
+        """Method to gather output of all assets and return it as a dict.
+
+        :return: Dict with for all asset a dict with all outputs.
+        """
+        # Todo what do we do with the junction output do we need it?
+        result = pd.DataFrame()
+        for py_asset in self.assets:
+            result = pd.concat([result, py_asset.get_timeseries()], axis=1)
+        return result

simulator_core/entities/network_controller.py

@@ -0,0 +1,67 @@
+#  Copyright (c) 2023. Deltares & TNO
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""NetworkController entity."""
+import datetime
+
+from simulator_core.entities.assets.asset_defaults import (PROPERTY_TEMPERATURE_SUPPLY,
+                                                           PROPERTY_TEMPERATURE_RETURN,
+                                                           PROPERTY_HEAT_DEMAND,
+                                                           PROPERTY_SET_PRESSURE)
+from simulator_core.entities.assets.controller_classes import ControllerSource, ControllerConsumer
+from typing import List
+
+
+class NetworkController:
+    """Class to store the network controller."""
+
+    def __init__(self, consumers: List[ControllerConsumer], sources: List[ControllerSource]) \
+            -> None:
+        """Constructor for controller for a heat network."""
+        self.sources = sources
+        self.consumers = consumers
+
+    def run_time_step(self, time: datetime.datetime) -> dict:
+        """Method to get the controller inputs for the network.
+
+        :param float time: Time step for which to run the controller.
+        :return: dict with the key the asset id and the heat demand for that asset.
+        """
+        # TODO add also the possibility to return mass flow rate instead of heat demand.
+
+        controller_input = {}
+        for consumer in self.consumers:
+            controller_input[consumer.id] = {PROPERTY_HEAT_DEMAND: consumer.get_heat_demand(time),
+                                             PROPERTY_TEMPERATURE_RETURN:
+                                                 consumer.temperature_return,
+                                             PROPERTY_TEMPERATURE_SUPPLY:
+                                                 consumer.temperature_supply}
+        for source in self.sources:
+            controller_input[source.id] = {PROPERTY_HEAT_DEMAND: self.get_total_demand(time)
+                                           / len(self.sources),
+                                           PROPERTY_TEMPERATURE_RETURN: source.temperature_return,
+                                           PROPERTY_TEMPERATURE_SUPPLY: source.temperature_supply,
+                                           PROPERTY_SET_PRESSURE: False}
+            # setting the first source to set the pressure for now.
+            controller_input[self.sources[0].id][PROPERTY_SET_PRESSURE] = True
+        return controller_input
+
+    def get_total_demand(self, time: datetime.datetime) -> float:
+        """Method to get the total heat demand of the network."""
+        return sum([consumer.get_heat_demand(time) for consumer in self.consumers])
+
+    def get_total_supply(self) -> float:
+        """Method to get the total heat supply of the network."""
+        return float(sum([source.power for source in self.sources]))

simulator_core/entities/simulation_configuration.py

@@ -0,0 +1,31 @@
+#  Copyright (c) 2023. Deltares & TNO
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Configuration parameters for the simulation that are not included in the ESDL."""
+
+from dataclasses import dataclass
+from datetime import datetime
+import uuid
+
+
+@dataclass
+class SimulationConfiguration:
+    """Class to store configuration parameters of the simulations."""
+
+    simulation_id: uuid.UUID
+    name: str
+    timestep: int
+    start: datetime
+    stop: datetime

simulator_core/entities/utility/__init__.py

@@ -0,0 +1,16 @@
+#  Copyright (c) 2023. Deltares & TNO
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""__init__.py file for initialization code."""