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

simulator_core/solver/matrix/matrix.py

@@ -0,0 +1,125 @@
+#  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/>.
+"""Module containing a matrix class to store the matrix and solve it using numpy."""
+import numpy as np
+import csv
+from simulator_core.solver.matrix.equation_object import EquationObject
+from simulator_core.solver.matrix.utility import absolute_difference, relative_difference
+
+
+class Matrix:
+    """Class which stores the matrix and can be used to solve it."""
+
+    def __init__(self) -> None:
+        """Constructor of matrix class."""
+        self.num_unknowns: int = 0
+        self.mat: list[list[float]] = []
+        self.rhs: list[float] = []
+        self.sol_new: list[float] = []
+        self.sol_old: list[float] = []
+        self.relative_convergence: float = 1e-6
+        self.absolute_convergence: float = 1e-6
+
+    def add_unknowns(self, number_unknowns: int) -> int:
+        """Method to add unknowns to the matrix.
+
+        Adds unknowns to the matrix and returns the location of the unknowns in the solution.
+        :param int number_unknowns: Number of unknowns to add
+        :return: int Starting index of the added unknowns.
+        """
+        if number_unknowns < 1:
+            raise ValueError("Number of unknowns should be at least 1.")
+        self.num_unknowns += number_unknowns
+        self.sol_new += [1.0] * number_unknowns
+        self.sol_old += [0.0] * number_unknowns
+        return self.num_unknowns - number_unknowns
+
+    def add_equation(self, equation_object: EquationObject) -> None:
+        """Method to add an equation to the matrix.
+
+        Add equation to the matrix it returns a unique id to the equation for easy access.
+        :param EquationObject equation_object: Object containing all information of the equation
+        :return:
+        """
+        row = len(self.rhs)
+        self.rhs.append(0.0)
+        self.mat.append([])
+        self.mat[row] = equation_object.to_list(self.num_unknowns)
+        self.rhs[row] = equation_object.rhs
+
+    def solve(self, equations: list[EquationObject], dumb: bool = False) -> list[float]:
+        """Method to solve the system of equation given in the matrix.
+
+        Solves the system of equations and returns the solution. The numpy linalg
+        library solve method is used. For this the matrix is converted to np arrays.
+        :return: list containing the solution of the system of equations.
+        """
+        # TODO add checks if enough equations have been supplied.
+        # TODO check if matrix is solvable.
+        self.rhs = []
+        self.mat = []
+        for equation in equations:
+            self.add_equation(equation)
+        if dumb:
+            self.dump_matrix()
+        self.sol_old = self.sol_new
+        a = np.array(self.mat)
+        b = np.array(self.rhs)
+        self.sol_new = np.linalg.solve(a, b).tolist()
+        return self.sol_new
+
+    def is_converged(self) -> bool:
+        """Returns true when the solution has converged and false when not.
+
+        This method uses both the absolute difference and the relative difference to determine if
+        the solution has converged. If one of them is converged true is returned.
+        :return: Bool whether the solution has converged based on the given convergence criteria.
+        """
+        if self.num_unknowns == 0:
+            raise ValueError("No unknowns have been added to the matrix.")
+        rel_dif = max(
+            [relative_difference(old, new) for old, new in zip(self.sol_old, self.sol_new)])
+        abs_dif = max(
+            [absolute_difference(old, new) for old, new in zip(self.sol_old, self.sol_new)])
+        return rel_dif < self.relative_convergence or abs_dif < self.absolute_convergence
+
+    def get_solution(self, index: int, number_of_unknowns: int) -> list[float]:
+        """Method to get the solution of an asset.
+
+        Returns the solution starting at the given index and for the number of
+        unknowns supplied at the input.
+
+        :param int index:Start position for which to supply the solution
+        :param int number_of_unknowns: Number of elements for which the solution needs to
+        be provided
+        :return: list with teh solution
+        """
+        #  TODO add checks if the index and number of unknowns are within the range of the solution.
+        return self.sol_new[index:index + number_of_unknowns]
+
+    def dump_matrix(self, file_name: str = 'dump.csv') -> None:
+        """Method to dump the matrix to a csv file.
+
+        :param str file_name: File name to dump the matrix in default=dump.csv
+        :return:
+        """
+        with open(file_name, 'w', newline='') as f:
+            write = csv.writer(f)
+            for row, rhs in zip(self.mat, self.rhs):
+                write.writerow(row + [rhs])
+
+    def reset_solution(self) -> None:
+        """Method to reset the solution to 1, so the new iteration can start."""
+        self.sol_new = [1.0] * len(self.sol_new)

simulator_core/solver/matrix/utility.py

@@ -0,0 +1,38 @@
+#  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/>.
+"""module containing utility functions for the matrix."""
+
+
+def relative_difference(value_1: float, value_2: float) -> float:
+    """Calculates the relative difference between two points.
+
+    :param value_1: first value to be used
+    :param value_2: second value to be used
+    :return: Relative difference, return 0 when the difference is 0.
+    """
+    diff = absolute_difference(value_1, value_2)
+    if diff > 0.0:
+        return diff / max(abs(value_1), abs(value_2))
+    return 0.0
+
+
+def absolute_difference(value_1: float, value_2: float) -> float:
+    """Calculates the absolute difference between two points.
+
+    :param value_1: first value to be used
+    :param value_2: second value to be used
+    :return: Absolute difference between value 1 and 2
+    """
+    return abs(value_1 - value_2)

simulator_core/solver/network/__init__.py

@@ -0,0 +1,15 @@
+#  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."""

simulator_core/solver/network/assets/__init__.py

@@ -0,0 +1,15 @@
+#  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."""

simulator_core/solver/network/assets/base_asset.py

@@ -0,0 +1,303 @@
+#  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/>.
+
+"""Module containing BaseAsset class."""
+import math
+import uuid
+from typing import Dict
+
+import numpy as np
+
+from simulator_core.solver.matrix.core_enum import NUMBER_CORE_QUANTITIES, IndexEnum
+from simulator_core.solver.matrix.equation_object import EquationObject
+from simulator_core.solver.network.assets.base_item import BaseItem
+from simulator_core.solver.network.assets.base_node_item import BaseNodeItem
+from simulator_core.solver.utils.fluid_properties import fluid_props
+
+
+class BaseAsset(BaseItem):
+    """A base class for assets in a network.
+
+    This class inherits from BaseItem and provides methods for connecting nodes, checking connection
+    status, and adding thermal and pressure equations.
+    """
+
+    connected_nodes: Dict[int, BaseNodeItem]
+
+    def __init__(
+        self,
+        name: uuid.UUID,
+        number_of_unknowns: int = 6,
+        number_connection_points: int = 2,
+        supply_temperature: float = 293.15,
+    ):
+        """Initializes the BaseAsset object with the given parameters.
+
+        :param uuid.UUID name: The unique identifier of the node.
+        :param int, optional number_of_unknowns: The number of unknown variables for the node.
+        The default is 3.
+        :param int, optional number_connection_points: The number of connection points for the
+            asset. The default is 2, which corresponds to the inlet and outlet.
+        """
+        super().__init__(
+            name=name,
+            number_of_unknowns=number_of_unknowns,
+            number_connection_points=number_connection_points,
+        )
+        self.supply_temperature = supply_temperature
+        self.connected_nodes = {}
+
+    def check_connection_point_valid(self, connection_point: int) -> bool:
+        """Checks if the connection point is valid for the asset.
+
+        :param connection_point: The index of the connection point to check.
+        :type connection_point: int
+        :return: True if the connection point is valid, otherwise raises an IndexError.
+        :rtype: bool
+        """
+        if connection_point > self.number_of_connection_point - 1:
+            raise IndexError(
+                f"Asset {self.name} only has {self.number_of_connection_point - 1}. "
+                f"{connection_point} is too high"
+            )
+        else:
+            return True
+
+    def connect_node(self, connection_point: int, node: BaseNodeItem) -> None:
+        """Connects a node to a connection point of the asset.
+
+        :param connection_point: The index of the connection point to connect.
+        :type connection_point: int
+        :param node: The node to connect.
+        :type node: Node
+        :raises ValueError: If the connection point is already connected to a node.
+        """
+        self.check_connection_point_valid(connection_point)
+        if connection_point in self.connected_nodes:
+            raise ValueError(
+                f" connection point {connection_point}  of asset {self.name} "
+                f" already connected to a node"
+            )
+
+        self.connected_nodes[connection_point] = node
+
+    def disconnect_node(self, connection_point: int) -> None:
+        """Disconnects a node from a connection point of the asset.
+
+        :param connection_point: The index of the connection point to disconnect.
+        :type connection_point: int
+        :raises ValueError: If the connection point is not connected to a node.
+        """
+        self.check_connection_point_valid(connection_point)
+        del self.connected_nodes[connection_point]
+
+    def is_connected(self, connection_point: int) -> bool:
+        """Checks if a connection point is connected to a node.
+
+        :param connection_point: The index of the connection point to check.
+        :type connection_point: int
+        :return: True if the connection point is connected, False otherwise.
+        :rtype: bool
+        """
+        if self.check_connection_point_valid(connection_point):
+            return connection_point in self.connected_nodes
+        else:
+            return False
+
+    def get_connected_node(self, connection_point: int) -> BaseNodeItem:
+        """Checks if a connection point is connected to a node.
+
+        :param connection_point: The index of the connection point to check.
+        :type connection_point: int
+        :return: True if the connection point is connected, False otherwise.
+        :rtype: bool
+        """
+        self.check_connection_point_valid(connection_point)
+
+        if self.is_connected(connection_point):
+            return self.connected_nodes[connection_point]
+        raise ValueError(str(connection_point) + " is not connected")
+
+    def is_all_connected(self) -> bool:
+        """Checks if all connection points are connected to nodes.
+
+        :return: True if all connection points are connected, False otherwise.
+        :rtype: bool
+        """
+        result = [self.is_connected(i) for i in range(self.number_of_connection_point)]
+        return all(result)
+
+    def add_thermal_equations(self, connection_point: int) -> EquationObject:
+        """Adds a thermal equation for a connection point of the asset.
+
+        :param connection_point: The index of the connection point to add the equation for.
+        :type connection_point: int
+        :return: An equation object representing the thermal equation.
+        :rtype: EquationObject
+        """
+        if self.prev_sol[IndexEnum.discharge + connection_point * NUMBER_CORE_QUANTITIES] > 0:
+            return self.add_prescribe_temp(connection_point)
+        else:
+            return self.add_temp_to_node_equation(connection_point)
+
+    def add_prescribe_temp(self, connection_point: int) -> EquationObject:
+        """Adds a prescribed temperature equation for a connection point of the asset.
+
+        :param connection_point: The index of the connection point to add the equation for.
+        :type connection_point: int
+        :return: An equation object representing the prescribed temperature equation.
+        :rtype: EquationObject
+        """
+        if not self.is_connected(connection_point=connection_point):
+            raise ValueError(
+                f"Connection point {connection_point} of asset {self.name} is not connected to a"
+                + " node."
+            )
+        equation_object = EquationObject()
+        equation_object.indices = np.array(
+            [
+                self.matrix_index
+                + IndexEnum.internal_energy
+                + connection_point * NUMBER_CORE_QUANTITIES
+            ]
+        )
+        equation_object.coefficients = np.array([1.0])
+        equation_object.rhs = fluid_props.get_ie(self.supply_temperature)
+        return equation_object
+
+    def add_temp_to_node_equation(self, connection_point: int) -> EquationObject:
+        """Adds a temperature to node equation for a connection point of the asset.
+
+        :param connection_point: The index of the connection point to add the equation for.
+        :type connection_point: int
+        :return: An equation object representing the temperature to node equation.
+        :rtype: EquationObject
+        """
+        # Check if the connection point is connected to a node
+        if not self.is_connected(connection_point=connection_point):
+            raise ValueError(
+                f"Connection point {connection_point} of asset {self.name} is not connected to a"
+                + " node."
+            )
+
+        equation_object = EquationObject()
+        equation_object.indices = np.array(
+            [
+                self.matrix_index
+                + IndexEnum.internal_energy
+                + connection_point * NUMBER_CORE_QUANTITIES,
+                self.get_connected_node(connection_point).matrix_index + IndexEnum.internal_energy,
+            ]
+        )
+        equation_object.coefficients = np.array([1.0, -1.0])
+        equation_object.rhs = 0.0
+        return equation_object
+
+    def set_physical_properties(self, physical_properties: Dict[str, float]) -> None:
+        """Method to set the physical properties of the asset.
+
+        This method is implemented in the derived classes of this class.
+        """
+
+    def add_press_to_node_equation(self, connection_point: int) -> EquationObject:
+        """Adds a pressure to node equation for a connection point of the asset.
+
+        :param connection_point: The index of the connection point to add the equation for.
+        :type connection_point: int
+        :return: An equation object representing the pressure to node equation.
+        :rtype: EquationObject
+        """
+        # Check if the connection point is connected to a node
+        if not self.is_connected(connection_point=connection_point):
+            raise ValueError(
+                f"Connection point {connection_point} of asset {self.name} is not connected to a"
+                + " node."
+            )
+
+        equation_object = EquationObject()
+        equation_object.indices = np.array(
+            [
+                self.matrix_index + IndexEnum.pressure + connection_point * NUMBER_CORE_QUANTITIES,
+                self.connected_nodes[connection_point].matrix_index + IndexEnum.pressure,
+            ]
+        )
+        equation_object.coefficients = np.array([1.0, -1.0])
+        equation_object.rhs = 0.0
+        return equation_object
+
+    def get_result(self) -> list[float]:
+        """Method to get the result of the asset.
+
+        :return: a list of the unknowns which are solved.
+        """
+        results = []
+        for i in range(self.number_of_connection_point):
+            for j in range(math.floor(self.number_of_unknowns / self.number_of_connection_point)):
+                if j == 2:
+                    results.append(
+                        fluid_props.get_t(
+                            self.prev_sol[
+                                i
+                                * math.floor(
+                                    self.number_of_unknowns / self.number_of_connection_point
+                                )
+                                + j
+                            ]
+                        )
+                    )
+                else:
+                    results.append(
+                        self.prev_sol[
+                            i
+                            * math.floor(self.number_of_unknowns / self.number_of_connection_point)
+                            + j
+                        ]
+                    )
+        return results
+
+    def get_equations(self) -> list[EquationObject]:
+        """Method to get the equations of the asset.
+
+        This method is implemented in the derived classes of this class.
+
+        :return: A list of equation objects representing the equations of the asset.
+        """
+        return []
+
+    def get_mass_flow_rate(self, connection_point: int) -> float:
+        """Method to get the mass flow rate of a connection point.
+
+        :param int connection_point: The connection point for which to get the mass flow rate.
+        :return: The mass flow rate of the connection point.
+        """
+        return self.prev_sol[IndexEnum.discharge + connection_point * NUMBER_CORE_QUANTITIES]
+
+    def get_pressure(self, connection_point: int) -> float:
+        """Method to get the pressure of a connection point.
+
+        :param int connection_point: The connection point for which to get the pressure.
+        :return: The pressure of the connection point.
+        """
+        return self.prev_sol[IndexEnum.pressure + connection_point * NUMBER_CORE_QUANTITIES]
+
+    def get_temperature(self, connection_point: int) -> float:
+        """Method to get the temperature of a connection point.
+
+        :param int connection_point: The connection point for which to get the temperature.
+        :return: The temperature of the connection point.
+        """
+        return fluid_props.get_t(
+            self.prev_sol[IndexEnum.internal_energy + connection_point * NUMBER_CORE_QUANTITIES]
+        )

simulator_core/solver/network/assets/base_item.py

@@ -0,0 +1,63 @@
+#  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/>.
+
+"""Module containing abstract BaseItem class."""
+import uuid
+from abc import ABC, abstractmethod
+
+from simulator_core.solver.matrix.equation_object import EquationObject
+
+
+class BaseItem(ABC):
+    """A base class for items in a network."""
+
+    def __init__(self, number_of_unknowns: int, name: uuid.UUID, number_connection_points: int):
+        """Initializes the BaseItem object with the given parameters.
+
+        :param int number_of_unknowns: The number of unknown variables for the item.
+        :param uuid.UUID name: The unique identifier of the item.
+        :param int number_connection_points: The number of connection points of the item.
+        """
+        self.name = name
+        self.number_of_unknowns = number_of_unknowns
+        self.number_of_connection_point = number_connection_points
+        self.matrix_index = 0
+        self.prev_sol: list[float] = [0.0] * self.number_of_unknowns
+
+    def __repr__(self) -> str:
+        """Returns the string representation of the item."""
+        return str(self.name)
+
+    def set_matrix_index(self, index: int) -> None:
+        """Sets the matrix index of the item.
+
+        :param int index: The index of the item in the matrix.
+        """
+        self.matrix_index = index
+
+    @abstractmethod
+    def get_equations(self) -> list[EquationObject]:
+        """Returns the equations for the item.
+
+        :return: The equations for the item.
+        :rtype: list[EquationObject]
+        """
+
+    @abstractmethod
+    def disconnect_node(self, connection_point: int) -> None:
+        """Disconnects a node from the item.
+
+        :param int connection_point: The connection point to disconnect.
+        """

simulator_core/solver/network/assets/base_node_item.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/>.
+
+"""Module containing abstract BaseNodeItem class."""
+import uuid
+from abc import ABC, abstractmethod
+
+from simulator_core.solver.matrix.equation_object import EquationObject
+from simulator_core.solver.network.assets.base_item import BaseItem
+
+
+class BaseNodeItem(ABC):
+    """A base class for node items in a network."""
+
+    def __init__(self, number_of_unknowns: int, name: uuid.UUID):
+        """Initializes the BaseNodeItem object with the given parameters.
+
+        :param int number_of_unknowns: The number of unknown variables for the item.
+        :param uuid.UUID name: The unique identifier of the item.
+        """
+        self.name = name
+        self.number_of_unknowns = number_of_unknowns
+        self.matrix_index = 0
+        self.prev_sol: list[float] = [0.0] * self.number_of_unknowns
+
+    def set_matrix_index(self, index: int) -> None:
+        """Sets the matrix index of the item.
+
+        :param int index: The index of the item in the matrix.
+        """
+        self.matrix_index = index
+
+    @abstractmethod
+    def get_equations(self) -> list[EquationObject]:
+        """Returns the equations for the item.
+
+        :return: The equations for the item.
+        :rtype: list[EquationObject]
+        """
+
+    @abstractmethod
+    def connect_asset(self, asset: BaseItem, connection_point: int) -> None:
+        """Connects the asset to the node item.
+
+        :param BaseItem asset: The asset to connect to the node item.
+        :param int connection_point: The connection point of the asset to connect to.
+        """
+
+    @abstractmethod
+    def get_connected_assets(self) -> list[tuple[BaseItem, int]]:
+        """Returns the connected assets of the node item.
+
+        :return: The connected assets of the node item.
+        :rtype: Tuple[BaseItem, int]
+        """