Features/tespy simulation

.flake8

@@ -1,6 +1,6 @@
 [flake8]
 exclude = meta/migrations/
-ignore = E265, W503
+ignore = E265, W503, W605
 max-line-length = 100
 per-file-ignores =
     __init__.py : F401

.gitignore

@@ -1,5 +1,7 @@
 *.pyc
 *.png
+*.pdf
+*.nc
 *.egg-info
 *.html
 .idea

dhnx/model.py

@@ -18,7 +18,7 @@ class Model():
     Abstract base class for different kind of models.
     """
     def __init__(self, thermal_network):
-        self.network = thermal_network
+        self.thermal_network = thermal_network
         self.setup()
         self.results = Dict()
 

dhnx/simulation.py

@@ -11,6 +11,16 @@
 SPDX-License-Identifier: MIT
 """
 
+from tespy.components import pipe, heat_exchanger_simple
+from tespy.connections import bus
+from tespy.networks import network
+
+from dhnx.tespy_facades import (
+    HeatProducer,
+    HeatConsumer,
+    DistrictHeatingPipe,
+)
+
 from .model import SimulationModel
 
 
@@ -22,13 +32,97 @@ def __init__(self, thermal_network):
         super().__init__(thermal_network)
         self.results = {}
 
+    def _setup_tespy_network(self):
+        r"""
+        Initializes a tespy network
+        """
+        self.tespy_network = network(
+            fluids=['water'], T_unit='C', p_unit='bar', h_unit='kJ / kg', m_unit='kg / s'
+        )
+
+    def _build_tespy_componenents(self):
+        temp_inlet = 90
+        p_inlet = 15
+        pump_efficiency = 0.8
+        pr_producer = 0.99
+
+        # producer
+        heat_producer = HeatProducer(
+            'heat_producer',
+            temp_inlet=temp_inlet,
+            p_inlet=p_inlet,
+            eta_s=pump_efficiency
+        )
+
+        # # consumer data
+        heat_demand = 50000
+        temp_return_heat_exchanger = 60
+        pr_heat_exchanger = 0.99
+        pr_valve = 1
+
+        # consumer
+        consumer_0 = HeatConsumer(
+            'consumer_0',
+            Q=-heat_demand,
+            temp_return_heat_exchanger=temp_return_heat_exchanger,
+            pr_heat_exchanger=pr_heat_exchanger,
+            pr_valve=pr_valve
+        )
+
+        # piping
+        pipes = []
+        for edge, data in self.thermal_network.components.edges.iterrows():
+            pipes.append(
+                DistrictHeatingPipe(
+                    'label',
+                    heat_producer,  # TODO
+                    consumer_0,  # TODO
+                    length=data['length'],
+                    diameter=data['diameter'],
+                    ks=7e-5,  # TODO
+                    kA=10,
+                    temp_env=data['temp_env']
+                )
+            )
+
+        tespy_components = [heat_producer, consumer_0, *pipes]
+
+        return tespy_components
+
+    def _build_heat_accounting(self):
+        # collect lost and consumed heat
+        heat_losses = bus('network losses')
+        heat_consumer = bus('network consumer')
+
+        for comp in self.tespy_network.comps.index:
+            if isinstance(comp, pipe):
+                heat_losses.add_comps({'c': comp})
+
+            if (isinstance(comp, heat_exchanger_simple) and '_consumer' in comp.label):
+                heat_consumer.add_comps({'c': comp})
+
+                self.tespy_network.add_busses(heat_losses, heat_consumer)
+
     def setup(self):
-        pass
+        self._setup_tespy_network()
+
+        self.tespy_components = self._build_tespy_componenents()
+
+        self.tespy_network.add_subsys(*self.tespy_components)
+
+        self.tespy_network.check_network()
+
+        self._build_heat_accounting()
+
+        # silence warnings
+        for comp in self.tespy_network.comps.index:
+            comp.char_warnings = False
 
     def solve(self):
-        pass
+        self.tespy_network.solve('design')
 
     def get_results(self):
+        self.tespy_network.print_results()
         return self.results
 
 

dhnx/tespy_facades.py

@@ -0,0 +1,171 @@
+import logging
+
+from tespy.components import (
+    subsystem as Subsystem,
+    cycle_closer,
+    pump,
+    heat_exchanger_simple,
+    valve,
+    pipe,
+)
+from tespy.connections import connection
+
+
+class Facade(Subsystem):
+    def __init__(self, label):
+        if not isinstance(label, str):
+            msg = 'Subsystem label must be of type str!'
+            logging.error(msg)
+            raise ValueError(msg)
+
+        elif len([x for x in [';', ', ', '.'] if x in label]) > 0:
+            msg = 'Can\'t use ' + str([';', ', ', '.']) + ' in label.'
+            logging.error(msg)
+            raise ValueError(msg)
+
+        else:
+            self.label = label
+
+        self.input = None
+        self.output = None
+        self.comps = {}
+        self.conns = {}
+        self.create_comps()
+        self.create_conns()
+
+
+class HeatProducer(Facade):
+    r"""
+    A subsystem for a heat producer, comprising a source and a sink.
+    """
+    def __init__(self, label, temp_inlet, p_inlet, eta_s, pr=0.99):
+        if not isinstance(label, str):
+            msg = 'Subsystem label must be of type str!'
+            logging.error(msg)
+            raise ValueError(msg)
+
+        elif len([x for x in [';', ', ', '.'] if x in label]) > 0:
+            msg = 'Can\'t use ' + str([';', ', ', '.']) + ' in label.'
+            logging.error(msg)
+            raise ValueError(msg)
+
+        else:
+            self.label = label
+
+        self.comps = {}
+        self.conns = {}
+        self.create_comps(pr, eta_s)
+        self.create_conns(temp_inlet, p_inlet)
+
+    def create_comps(self, pr, eta_s):
+        self.comps['cycle_closer'] = cycle_closer(self.label + '_cycle_closer')
+        self.comps['heat_exchanger'] = heat_exchanger_simple(self.label + '_heat_exchanger', pr=pr)
+        self.comps['pump'] = pump(self.label + '_pump', eta_s=eta_s)
+        self.output = self.comps['cycle_closer']
+        self.input = self.comps['heat_exchanger']
+
+    def create_conns(self, temp_inlet, p_inlet):
+        self.conns['heat_exchanger_pump'] = connection(
+            self.comps['heat_exchanger'], 'out1', self.comps['pump'], 'in1',
+            T=temp_inlet, fluid={'water': 1}
+        )
+        self.conns['pump_cycle_closer'] = connection(
+            self.comps['pump'], 'out1', self.comps['cycle_closer'], 'in1',
+            p=p_inlet
+        )
+
+
+class HeatConsumer(Facade):
+    r"""
+    A subsystem for a heat consumer, comprising a heat exchanger and a valve.
+    """
+    def __init__(self, label, Q, temp_return_heat_exchanger, pr_valve, pr_heat_exchanger):
+        if not isinstance(label, str):
+            msg = 'Subsystem label must be of type str!'
+            logging.error(msg)
+            raise ValueError(msg)
+
+        elif len([x for x in [';', ', ', '.'] if x in label]) > 0:
+            msg = 'Can\'t use ' + str([';', ', ', '.']) + ' in label.'
+            logging.error(msg)
+            raise ValueError(msg)
+
+        else:
+            self.label = label
+
+        self.comps = {}
+        self.conns = {}
+        self.create_comps(Q, pr_valve, pr_heat_exchanger)
+        self.create_conns(temp_return_heat_exchanger)
+
+    def create_comps(self, Q, pr_valve, pr_heat_exchanger):
+        self.comps['heat_exchanger'] = heat_exchanger_simple(
+            self.label + '_consumer', Q=Q, pr=pr_heat_exchanger
+        )
+        self.comps['valve'] = valve(self.label + '_valve', pr=pr_valve)
+        self.output = self.comps['valve']
+        self.input = self.comps['heat_exchanger']
+
+    def create_conns(self, temp_return_heat_exchanger):
+        self.conns['heat_exchanger_valve'] = connection(
+            self.comps['heat_exchanger'], 'out1', self.comps['valve'], 'in1',
+            T=temp_return_heat_exchanger,
+        )
+
+
+class Fork(Facade):
+    r"""
+    A subsystem for a fork, comprising a split and a merge.
+
+    TODO: Allow for 2...n forks. Pass pressure losses.
+    """
+    def __init__(self, label):
+        self.comps = {}
+        self.conns = {}
+        self.create_comps()
+        self.create_conns()
+
+    def create_comps(self):
+        self.comps['split'] = None
+        self.comps['merge'] = None
+
+    def create_conns(self):
+        self.conns['heat_exchanger_valve'] = None
+
+
+class DistrictHeatingPipe(Facade):
+    r"""
+    A subsystem for a district heating pipe, comprising a feed and return pipe.
+    """
+    def __init__(self, label, start, end, length, diameter, ks, kA, temp_env):
+        if not isinstance(label, str):
+            msg = 'Subsystem label must be of type str!'
+            logging.error(msg)
+            raise ValueError(msg)
+
+        elif len([x for x in [';', ', ', '.'] if x in label]) > 0:
+            msg = 'Can\'t use ' + str([';', ', ', '.']) + ' in label.'
+            logging.error(msg)
+            raise ValueError(msg)
+
+        else:
+            self.label = label
+
+        self.comps = {}
+        self.conns = {}
+        self.create_comps(temp_env, length, diameter, ks, kA)
+        self.create_conns(start, end)
+
+    def create_comps(self, temp_env, length, diameter, ks, kA):
+        self.comps['feed'] = pipe(
+            self.label + '_inlet', ks=ks, L=length, D=diameter, kA=kA, Tamb=temp_env
+        )
+        self.comps['return'] = pipe(
+            self.label + '_return', ks=ks, L=length, D=diameter, kA=kA, Tamb=temp_env
+        )
+
+    def create_conns(self, start, end):
+        self.conns['inlet_in'] = connection(start.output, 'out1', self.comps['feed'], 'in1')
+        self.conns['inlet_out'] = connection(self.comps['feed'], 'out1', end.input, 'in1')
+        self.conns['return_in'] = connection(end.output, 'out1', self.comps['return'], 'in1')
+        self.conns['return_out'] = connection(self.comps['return'], 'out1', start.input, 'in1')

examples/tespy_simulation/builder_functions.py

@@ -0,0 +1,48 @@
+from tespy.components import (
+    source,
+    sink,
+    pipe,
+)
+from tespy.connections import connection, bus
+
+from sub_consumer import lin_consum_closed, fork
+
+
+def add_producer():
+    so = source('source')
+    si = sink('sink')
+    new_producer = [so, si]
+    return new_producer
+
+
+def add_consumer(network, label):
+    new_consumer = lin_consum_closed(label, 2)
+    new_consumer.comps['consumer_0'].set_attr(Q=-5e4, pr=0.99)
+    new_consumer.comps['consumer_1'].set_attr(Q=-5e4, pr=0.99)
+    new_consumer.comps['feed_0'].set_attr(ks=7e-5, L=150, D=0.15, offdesign=['kA'])
+    network.add_subsys(new_consumer)
+
+    return new_consumer
+
+
+def add_split(network, label, number):
+    new_split = fork(label, number)
+
+    return new_split
+
+
+def add_pipe(network, label, source, target):
+    new_pipe = pipe(label, ks=7e-5, L=50, D=0.15, offdesign=['kA'])
+
+    con_source_inlet = connection(source, 'out1', new_pipe, 'in1', T=90, p=15, fluid={'water': 1})
+    con_inlet_target = connection(new_pipe, 'out1', target, 'in1', T=90, p=15, fluid={'water': 1})
+
+    con_target_return = connection(target, 'out1', new_pipe, 'in1', T=90, p=15, fluid={'water': 1})
+    con_return_source = connection(new_pipe, 'out1', target, 'in1', T=90, p=15, fluid={'water': 1})
+    network.add(con_source_inlet, con_inlet_target, con_target_return, con_return_source)
+
+    return network
+
+
+heat_losses = bus('network losses')
+heat_consumer = bus('network consumer')

examples/tespy_simulation/dhnx_simulation_example.py

@@ -0,0 +1,9 @@
+import dhnx
+
+import_dir = 'single_pipe_simulation_input'
+
+nw = dhnx.network.ThermalNetwork(import_dir)
+
+nw.simulate()
+
+print(nw.results)