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

simulator_core/entities/assets/asset_abstract.py

@@ -0,0 +1,116 @@
+#  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/>.
+
+"""Abstract class for asset."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, List
+
+from pandas import DataFrame
+
+from simulator_core.entities.assets.esdl_asset_object import EsdlAssetObject
+from simulator_core.entities.assets.junction import Junction
+from simulator_core.solver.network.assets.base_asset import BaseAsset
+
+
+class AssetAbstract(ABC):
+    """Abstract class for Asset."""
+
+    from_junction: Junction | None
+    """The junction where the asset starts."""
+
+    to_junction: Junction | None
+    """The junction where the asset ends."""
+
+    name: str
+    """The name of the asset."""
+
+    asset_id: str
+    """The unique identifier of the asset."""
+
+    output: List[Dict[str, float]]
+    """The output of the asset as a list with a dictionary per timestep."""
+    solver_asset: BaseAsset
+
+    def __init__(self, asset_name: str, asset_id: str):
+        """Basic constructor for asset objects.
+
+        :param str asset_name: The name of the asset.
+        :param str asset_id: The unique identifier of the asset.
+        :param PandapipesNet pandapipe_net: Pnadapipes network object to register asset to.
+        """
+        self.from_junction = None
+        self.to_junction: Junction = None
+        self.name: str = asset_name
+        self.asset_id: str = asset_id
+        self.output: List[Dict[str, float]] = []
+
+    @abstractmethod
+    def set_setpoints(self, setpoints: Dict) -> None:
+        """Placeholder to set the setpoints of an asset prior to a simulation.
+
+        :param Dict setpoints: The setpoints that should be set for the asset.
+            The keys of the dictionary are the names of the setpoints and the values are the values
+        """
+
+    def get_setpoints(self) -> Dict[str, float]:
+        """Placeholder to get the setpoint attributes of an asset.
+
+        :return Dict: The setpoints of the asset. The keys of the dictionary are the names of the
+            setpoints and the values are the values.
+        """
+        return {}
+
+    @abstractmethod
+    def add_physical_data(self, esdl_asset: EsdlAssetObject) -> None:
+        """Placeholder method to add physical data to an asset."""
+
+    def set_from_junction(self, from_junction: Junction) -> None:
+        """Method to set the from junction of an asset.
+
+        :param Junction from_junction: The junction where the asset starts.
+        """
+        self.from_junction = from_junction
+
+    def set_to_junction(self, to_junction: Junction) -> None:
+        """Method to set the to junction of an asset.
+
+        :param Junction to_junction: The junction where the asset ends.
+        """
+        self.to_junction = to_junction
+
+    @abstractmethod
+    def write_to_output(self) -> None:
+        """Placeholder to get data from pandapipes and store it in the asset."""
+
+    def get_output(self) -> List[Dict[str, float]]:
+        """Returns all the output of the asset.
+
+        :return: A dict of property name and list of values.
+        """
+        return self.output
+
+    def get_timeseries(self) -> DataFrame:
+        """Get timeseries as a dataframe from a pandapipes asset.
+
+        The header is a tuple of the asset id and the property name.
+        """
+        # Create dataframe
+        temp_dataframe = DataFrame(self.output)
+        # Set header
+        temp_dataframe.columns = [
+            (self.asset_id, column_name) for column_name in temp_dataframe.columns
+        ]
+        return temp_dataframe

simulator_core/entities/assets/asset_defaults.py

@@ -0,0 +1,68 @@
+#  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/>.
+
+"""Define default values and names for assets."""
+from dataclasses import dataclass
+
+# Default values
+DEFAULT_DIAMETER = 1.2  # [m]
+DEFAULT_PRESSURE = 10.0e5  # [bar]
+DEFAULT_PRESSURE_DIFFERENCE = 5e5  # [bar]
+DEFAULT_TEMPERATURE = 300.0  # [K]
+DEFAULT_TEMPERATURE_DIFFERENCE = 30.0  # [K]
+DEFAULT_NODE_HEIGHT = 0.0  # [m]
+DEFAULT_MASS_FLOW_RATE = 1.0  # [kg/s]
+DEFAULT_POWER = 500000.0  # [W]
+DEFAULT_MISSING_VALUE = -9999.99  # [-]
+
+
+@dataclass
+class PipeDefaults:
+    """Class containing the default values for a pipe.
+
+    :param float k_value: The k value of the pipe [m].
+    :param float alpha_value: The alpha value of the pipe [W/(m2 K)].
+    :param float minor_loss_coefficient: The minor loss coefficient of the pipe [-].
+    :param float external_temperature: The external temperature of the pipe [K].
+    :param float qheat_external: The external heat flow of the pipe [W].
+    """
+
+    k_value: float = 2e-3
+    alpha_value: float = 0.0
+    minor_loss_coefficient: float = 0.0
+    external_temperature: float = 273.15 + 20.0
+    qheat_external: float = 0.0
+    length: float = 1.0
+    diameter: float = DEFAULT_DIAMETER
+
+
+# Default names
+PROPERTY_HEAT_DEMAND = "heat_demand"
+PROPERTY_TEMPERATURE_SUPPLY = "temperature_supply"
+PROPERTY_TEMPERATURE_RETURN = "temperature_return"
+PROPERTY_PRESSURE_SUPPLY = "pressure_supply"
+PROPERTY_PRESSURE_RETURN = "pressure_return"
+PROPERTY_MASSFLOW = "mass_flow"
+PROPERTY_VOLUMEFLOW = "volume_flow"
+PROPERTY_THERMAL_POWER = "thermal_power"
+PROPERTY_VELOCITY_SUPPLY = "velocity_supply"
+PROPERTY_VELOCITY_RETURN = "velocity_return"
+PROPERTY_SET_PRESSURE = "set_pressure"
+PROPERTY_LENGTH = "length"
+PROPERTY_DIAMETER = "diameter"
+PROPERTY_ROUGHNESS = "roughness"
+
+# Static members
+PIPE_DEFAULTS = PipeDefaults()

simulator_core/entities/assets/controller_classes.py

@@ -0,0 +1,81 @@
+#  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 the classes for the controller."""
+
+import datetime
+
+import pandas as pd
+from simulator_core.entities.assets.asset_defaults import (DEFAULT_TEMPERATURE,
+                                                           DEFAULT_TEMPERATURE_DIFFERENCE)
+
+
+class AssetControllerAbstract:
+    """Abstract class for the asset controller."""
+
+    def __init__(self, name: str, identifier: str):
+        """Constructor for the asset controller.
+
+        :param str name: Name of the controller object.
+        :param str identifier: Unique identifier of the controller asset.
+        """
+        self.name = name
+        self.id = identifier
+
+
+class ControllerConsumer(AssetControllerAbstract):
+    """Class to store the consumer for the controller asset."""
+
+    def __init__(self, name: str, identifier: str):
+        """Constructor for the consumer.
+
+        :param str name: Name of the consumer.
+        :param str identifier: Unique identifier of the consumer.
+        """
+        super().__init__(name, identifier)
+        self.temperature_return = DEFAULT_TEMPERATURE
+        self.temperature_supply = DEFAULT_TEMPERATURE + DEFAULT_TEMPERATURE_DIFFERENCE
+        self.profile: pd.DataFrame = pd.DataFrame()
+        self.start_index = 0
+
+    def get_heat_demand(self, time: datetime.datetime) -> float:
+        """Method to get the heat demand of the consumer.
+
+        :param datetime.datetime time: Time for which to get the heat demand.
+        :return: float with the heat demand.
+        """
+        for index in range(self.start_index, len(self.profile)):
+            if abs((self.profile["date"][index].to_pydatetime() - time).total_seconds()) < 3600:
+                self.start_index = index
+                return float(self.profile["values"][index])
+        return 0
+
+    def add_profile(self, profile: pd.DataFrame) -> None:
+        """Method to add a profile to the consumer."""
+        self.profile = profile
+
+
+class ControllerSource(AssetControllerAbstract):
+    """Class to store the source for the controller."""
+
+    def __init__(self, name: str, identifier: str):
+        """Constructor for the source.
+
+        :param str name: Name of the source.
+        :param str identifier: Unique identifier of the source.
+        """
+        super().__init__(name, identifier)
+        self.temperature_return: float = DEFAULT_TEMPERATURE
+        self.temperature_supply: float = DEFAULT_TEMPERATURE + DEFAULT_TEMPERATURE_DIFFERENCE
+        self.power: float = 5000000000

simulator_core/entities/assets/demand_cluster.py

@@ -0,0 +1,117 @@
+#  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/>.
+
+"""demandCluster 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_DIAMETER,
+    DEFAULT_POWER,
+    DEFAULT_PRESSURE,
+    DEFAULT_TEMPERATURE,
+    DEFAULT_TEMPERATURE_DIFFERENCE,
+    PROPERTY_HEAT_DEMAND,
+    PROPERTY_MASSFLOW,
+    PROPERTY_PRESSURE_RETURN,
+    PROPERTY_PRESSURE_SUPPLY,
+    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 DemandCluster(AssetAbstract):
+    """A DemandCluster represents an asset that consumes heat."""
+
+    def __init__(
+        self,
+        asset_name: str,
+        asset_id: str,
+    ):
+        """Initialize a DemandCluster 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._internal_diameter = DEFAULT_DIAMETER
+        self.temperature_supply = DEFAULT_TEMPERATURE
+        self.temperature_return: float = DEFAULT_TEMPERATURE - DEFAULT_TEMPERATURE_DIFFERENCE
+        self.temperature_return_target = self.temperature_return
+        self.pressure_input = DEFAULT_PRESSURE
+        self.thermal_power_allocation = DEFAULT_POWER
+        self.mass_flowrate = 0
+        self.solver_asset = ProductionAsset(uuid.uuid4())
+        # Output list
+        self.output: list = []
+
+    def set_setpoints(self, setpoints: Dict) -> None:
+        """Placeholder to set the setpoints of an asset prior to a simulation.
+
+        :param Dict setpoints: The setpoints that should be set for the asset.
+            The keys of the dictionary are the names of the setpoints and the values are the values
+        """
+        # Default keys required
+        necessary_setpoints = {
+            PROPERTY_TEMPERATURE_SUPPLY,
+            PROPERTY_TEMPERATURE_RETURN,
+            PROPERTY_HEAT_DEMAND,
+        }
+        # Dict to set
+        setpoints_set = set(setpoints.keys())
+        # Check if all setpoints are in the setpoints
+        if not necessary_setpoints.issubset(setpoints_set):
+            # Print missing setpoints
+            raise ValueError(
+                f"The setpoints {necessary_setpoints.difference(setpoints_set)} are missing."
+            )
+        self.thermal_power_allocation = setpoints[PROPERTY_HEAT_DEMAND]
+        self.temperature_return_target = setpoints[PROPERTY_TEMPERATURE_RETURN]
+        self.temperature_supply = setpoints[PROPERTY_TEMPERATURE_SUPPLY]
+        adjusted_mass_flowrate = heat_demand_and_temperature_to_mass_flow(
+            self.thermal_power_allocation, self.temperature_supply, self.temperature_return_target
+        )
+        self.solver_asset.supply_temperature = self.temperature_return_target
+        self.solver_asset.mass_flow_rate_set_point = adjusted_mass_flowrate  # type: ignore
+
+    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 to add the physical data from.
+         :return:
+        """
+
+    def write_to_output(self) -> None:
+        """Placeholder to write the asset to the output.
+
+        The output list is a list of dictionaries, where each dictionary
+        represents the output of its asset for a specific timestep.
+        """
+        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/esdl_asset_object.py

@@ -0,0 +1,60 @@
+#  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 classes to be able to interact with esdl objects."""
+import logging
+from typing import Any, Tuple
+
+import pandas as pd
+from esdl import esdl
+from simulator_core.entities.utility.influxdb_reader import get_data_from_profile
+
+logger = logging.getLogger(__name__)
+
+
+class EsdlAssetObject:
+    """
+    Class to hold an esdl asset and convert it to local class objects.
+
+    Conversion is done based on the classes in the conversion_dict.
+    """
+
+    esdl_asset: esdl.Asset
+
+    def __init__(self, asset: esdl.Asset) -> None:
+        """
+        Constructor for EsdlAssetObject class.
+
+        :param asset, esdl.Asset: PyEsdl Asset object
+        """
+        self.esdl_asset = asset
+
+    def get_property(self, esdl_property_name: str, default_value: Any) -> Tuple[Any, bool]:
+        """Get property value from the esdl_asset based on the "ESDL" name.
+
+        :return: Tuple with the value of the property and a boolean indicating whether the property
+        was found in the esdl_asset.
+        """
+        try:
+            return getattr(self.esdl_asset, esdl_property_name), True
+        except AttributeError:
+            return default_value, False
+
+    def get_profile(self) -> pd.DataFrame:
+        """Get the profile of the asset."""
+        for esdl_port in self.esdl_asset.port:
+            if esdl_port.profile:
+                return get_data_from_profile(esdl_port.profile[0])
+        raise ValueError("No profile found for asset: " + self.esdl_asset.name)

simulator_core/entities/assets/junction.py

@@ -0,0 +1,64 @@
+#  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/>.
+
+"""Junction classes."""
+
+from typing import Any, List, Optional
+
+from simulator_core.entities.assets.asset_defaults import (DEFAULT_NODE_HEIGHT,
+                                                           DEFAULT_PRESSURE,
+                                                           DEFAULT_TEMPERATURE)
+from simulator_core.solver.network.assets.node import Node
+
+
+class Junction:
+    """Wrapper class for pandapipes junctions."""
+
+    def __init__(
+        self,
+        solver_node: Node,
+        pn_bar: float = DEFAULT_PRESSURE,
+        tfluid_k: float = DEFAULT_TEMPERATURE,
+        height_m: float = DEFAULT_NODE_HEIGHT,
+        geodata: Optional[List[Any]] = None,
+        name: str = "None",
+        in_service: bool = True,
+        index: Optional[int] = None,
+    ):
+        """Initialize a Junction object.
+
+        :param pn_bar: The pressure at the junction [bar], defaults to DEFAULT_PRESSURE
+        :type pn_bar: float, optional
+        :param tfluid_k: The temperature at the junction [K], defaults to DEFAULT_TEMPERATURE
+        :type tfluid_k: float, optional
+        :param height_m: The height of the junction [m], defaults to DEFAULT_NODE_HEIGHT
+        :type height_m: float, optional
+
+        """
+        self.pn_bar = pn_bar
+        self.tfluid_k = tfluid_k
+        self.height_m = height_m
+        self.name = name
+        self.index = index
+        # Initialize the junction
+        self.solver_junction = solver_node
+
+    def write_to_output(self) -> None:
+        """Placeholder to write the asset to the output.
+
+        The output list is a list of dictionaries, where each dictionary
+        represents the output of its asset for a specific timestep.
+        """
+        return

simulator_core/entities/assets/pipe.py

@@ -0,0 +1,174 @@
+#  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 pipe class."""
+import uuid
+from typing import Dict, List
+
+import numpy as np
+
+from simulator_core.entities.assets.asset_abstract import AssetAbstract
+from simulator_core.entities.assets.asset_defaults import (
+    PIPE_DEFAULTS,
+    PROPERTY_MASSFLOW,
+    PROPERTY_PRESSURE_RETURN,
+    PROPERTY_PRESSURE_SUPPLY,
+    PROPERTY_TEMPERATURE_RETURN,
+    PROPERTY_TEMPERATURE_SUPPLY,
+)
+from simulator_core.entities.assets.esdl_asset_object import EsdlAssetObject
+from simulator_core.entities.assets.utils import (
+    calculate_inverse_heat_transfer_coefficient,
+    get_thermal_conductivity_table,
+)
+from simulator_core.solver.network.assets.solver_pipe import SolverPipe
+
+
+class Pipe(AssetAbstract):
+    """A class representing a pipe in a heat network."""
+
+    _minor_loss_coefficient: float
+    """The minor loss coefficient of the pipe [-]."""
+    _external_temperature: float
+    """The external temperature surrounding the pipe [K]."""
+    _qheat_external: float
+    """The external heat flow into the pipe [W]."""
+    length: float
+    """The length of the pipe [m]."""
+    diameter: float
+    """The diameter of the pipe [m]."""
+    roughness: float
+    """The wall roughness of the pipe [m]."""
+    alpha_value: float
+    """The alpha value of the pipe [W/(m2 K)]."""
+    _initialized: bool
+    """Flag to indicate whether the pipe has been initialized in pandapipes."""
+    output: List[Dict[str, float]]
+    """The output list of the pipe with a dictionaries for each timestep."""
+
+    def __init__(self, asset_name: str, asset_id: str):
+        """Initialize a Pipe 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)
+        # Initialize the default values of the pipe
+        self._minor_loss_coefficient = PIPE_DEFAULTS.minor_loss_coefficient
+        self._external_temperature = PIPE_DEFAULTS.external_temperature
+        self._qheat_external = PIPE_DEFAULTS.qheat_external
+        # Define properties of the pipe
+        self.length = PIPE_DEFAULTS.length
+        self.diameter = PIPE_DEFAULTS.diameter
+        self.roughness = PIPE_DEFAULTS.k_value
+        self.alpha_value = PIPE_DEFAULTS.alpha_value
+        # Objects of the pandapipes network
+        self.solver_asset = SolverPipe(
+            uuid.uuid4(), length=self.length, diameter=self.diameter, roughness=self.roughness
+        )
+        self.output = []
+
+    def _get_diameter(self, esdl_asset: EsdlAssetObject) -> float:
+        """Retrieve the diameter of the pipe and convert it if necessary."""
+        temp_diameter, property_available = esdl_asset.get_property("innerDiameter", self.diameter)
+        if property_available:
+            if temp_diameter == 0:
+                return self.diameter
+            return float(temp_diameter)
+        else:
+            # Implement DN-conversion
+            raise NotImplementedError(
+                f"The innderDiamter property is unavailable for {esdl_asset.esdl_asset.name}. \
+                    Conversion from DN to diameter is not yet implemented."
+            )
+
+    def _get_heat_transfer_coefficient(self, esdl_asset: EsdlAssetObject) -> float:
+        """Calculate the heat transfer coefficient of the pipe.
+
+        :param EsdlAssetObject esdl_asset: The ESDL asset object associated with the
+                current pipe object.
+
+        :return: The heat transfer coefficient of the pipe [W/(m2 K)]. If the heat transfer
+                coefficient cannot be calculated - for example when the material table is
+                not specified - , the default alpha value is returned.
+        """
+        diameters, heat_coefficients = get_thermal_conductivity_table(esdl_asset=esdl_asset)
+        if diameters:
+            # Create a numpy array of the diameters and heat coefficients
+            diameters_np = np.array(diameters)
+            heat_coefficients_np = np.array(heat_coefficients)
+            # Calculate the heat transfer coefficient from the heat transfer table
+            inverse_heat_transfer_coefficient = np.sum(
+                calculate_inverse_heat_transfer_coefficient(
+                    inner_diameter=diameters_np[:-1],
+                    outer_diameter=diameters_np[1:],
+                    thermal_conductivity=heat_coefficients_np,
+                )
+            )
+            return 1.0 / float(inverse_heat_transfer_coefficient)
+        else:
+            return self.alpha_value
+
+    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 associated with the
+                current pipe object.
+        """
+        # Error handling is performed in EsdlAssetObject.get_asset_parameters
+        self.length, _ = esdl_asset.get_property(
+            esdl_property_name="length", default_value=self.length
+        )
+        self.roughness, _ = esdl_asset.get_property(
+            esdl_property_name="roughness", default_value=self.roughness
+        )
+        self.roughness = PIPE_DEFAULTS.k_value if self.roughness == 0 else self.roughness
+        self.diameter = self._get_diameter(esdl_asset=esdl_asset)
+
+        self.alpha_value = self._get_heat_transfer_coefficient(esdl_asset=esdl_asset)
+        prop_dict = {"length": self.length, "diameter": self.diameter, "roughness": self.roughness}
+        self.solver_asset.set_physical_properties(physical_properties=prop_dict)
+
+    def set_setpoints(self, setpoints: Dict) -> None:
+        """Set the setpoints of the pipe prior to a simulation.
+
+        :param Dict setpoints: The setpoints that should be set for the pipe.
+            The keys of the dictionary are the names of the setpoints and the values are the values
+        """
+
+    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.
+        - PROPERTY_VELOCITY_SUPPLY: The supply velocity of the asset.
+        - PROPERTY_VELOCITY_RETURN: The return velocity 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)