Gas mixture

pandapipes/__init__.py

@@ -2,7 +2,7 @@
 # and Energy System Technology (IEE), Kassel, and University of Kassel. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
-__version__ = '0.6.1.dev_0'
+__version__ = '0.6.1.dev_1'
 
 import pandas as pd
 import os

pandapipes/component_models/abstract_models/base_component.py

@@ -5,7 +5,7 @@
 from pandapipes.component_models.component_toolbox import init_results_element
 
 try:
-    import pplog as logging
+    from pandaplan.core import pplog as logging
 except ImportError:
     import logging
 
@@ -73,11 +73,11 @@ def get_result_table(cls, net):
         raise NotImplementedError
 
     @classmethod
-    def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_lookups, options):
+    def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, branch_lookups, node_lookups, options):
         pass
 
     @classmethod
-    def adaption_after_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_lookups, options):
+    def adaption_after_derivatives_hydraulic(cls, net, branch_pit, node_pit, branch_lookups, node_lookups, options):
         pass
 
     @classmethod
@@ -138,8 +138,10 @@ def create_pit_node_entries(cls, net, node_pit):
         :type node_pit:
         :return: No Output.
         """
+
         pass
 
+
     @classmethod
     def create_pit_branch_entries(cls, net, branch_pit):
         """
@@ -153,6 +155,7 @@ def create_pit_branch_entries(cls, net, branch_pit):
         """
         pass
 
+
     @classmethod
     def calculate_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_lookups, options):
         """

pandapipes/component_models/abstract_models/branch_models.py

@@ -5,20 +5,14 @@
 import numpy as np
 
 from pandapipes.component_models.abstract_models.base_component import Component
-from pandapipes.constants import NORMAL_PRESSURE, GRAVITATION_CONSTANT, NORMAL_TEMPERATURE, \
-    P_CONVERSION
-from pandapipes.idx_branch import FROM_NODE, TO_NODE, LENGTH, D, TINIT, AREA, K, RHO, ETA, \
-    VINIT, RE, LAMBDA, LOAD_VEC_NODES, ALPHA, QEXT, TEXT, LOSS_COEFFICIENT as LC, branch_cols, \
-    T_OUT, CP, VINIT_T, FROM_NODE_T, PL, TL, \
-    JAC_DERIV_DP, JAC_DERIV_DP1, JAC_DERIV_DT, JAC_DERIV_DT1, JAC_DERIV_DT_NODE, JAC_DERIV_DV, \
-    JAC_DERIV_DV_NODE, LOAD_VEC_BRANCHES, LOAD_VEC_BRANCHES_T, LOAD_VEC_NODES_T
-from pandapipes.idx_node import PINIT, HEIGHT, TINIT as TINIT_NODE, PAMB
-from pandapipes.pf.derivative_calculation import calc_lambda, calc_der_lambda
 from pandapipes.pf.pipeflow_setup import get_table_number, get_lookup
-from pandapipes.properties.fluids import get_fluid
+from pandapipes.properties.fluids import get_mixture_density, \
+    get_mixture_viscosity, get_mixture_heat_capacity
+from pandapipes.pf.derivative_toolbox import \
+    get_derivative_density_diff, get_derivative_density_same
 
 try:
-    import pplog as logging
+    from pandaplan.core import pplog as logging
 except ImportError:
     import logging
 
@@ -95,10 +89,37 @@ def create_pit_branch_entries(cls, net, branch_pit):
             cls.get_connected_node_type().table_name()]
         from_nodes = junction_idx_lookup[net[cls.table_name()]["from_junction"].values]
         to_nodes = junction_idx_lookup[net[cls.table_name()]["to_junction"].values]
-        branch_component_pit[:, :] = np.array([branch_table_nr] + [0] * (branch_cols - 1))
-        branch_component_pit[:, VINIT] = 0.1
+        branch_component_pit[:, :] = np.array([branch_table_nr] + [0] * (net['_idx_branch']['branch_cols'] - 1))
+        branch_component_pit[:, net['_idx_branch']['VINIT']] = 0.1
         return branch_component_pit, node_pit, from_nodes, to_nodes
 
+    @classmethod
+    def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, branch_lookups, node_lookups, options):
+        if len(net._fluid) != 1:
+            f, t = branch_lookups[cls.table_name()]
+            branch_component_pit = branch_pit[f:t, :]
+            create_v_node(net, branch_pit)
+            v_from_b = branch_component_pit[:, net['_idx_branch']['V_FROM_NODE']].astype(int)
+
+            w = get_lookup(net, 'node', 'w')
+            w_branch = get_lookup(net, 'branch', 'w')
+            mf = node_pit[:, w][v_from_b]
+            branch_component_pit[:, w_branch] = mf
+
+            branch_component_pit[:, net['_idx_branch']['RHO']] = \
+                get_mixture_density(net, branch_component_pit[:, net['_idx_branch']['TINIT']], mf)
+            branch_component_pit[:, net['_idx_branch']['ETA']] = \
+                get_mixture_viscosity(net, branch_component_pit[:, net['_idx_branch']['TINIT']], mf)
+            branch_component_pit[:, net['_idx_branch']['CP']] = \
+                get_mixture_heat_capacity(net, branch_component_pit[:, net['_idx_branch']['TINIT']], mf)
+
+            der_rho_same = get_lookup(net, 'branch', 'deriv_rho_same')
+            der_rho_diff = get_lookup(net, 'branch', 'deriv_rho_diff')
+            rho = get_lookup(net, 'branch', 'rho')
+            rl = branch_component_pit[:, rho]
+            branch_component_pit[:, der_rho_same] = get_derivative_density_same(mf, rl)
+            branch_component_pit[:, der_rho_diff] = get_derivative_density_diff(mf, rl)
+
     @classmethod
     def calculate_derivatives_thermal(cls, net, branch_pit, node_pit, idx_lookups, options):
         """
@@ -118,35 +139,33 @@ def calculate_derivatives_thermal(cls, net, branch_pit, node_pit, idx_lookups, o
         """
         f, t = idx_lookups[cls.table_name()]
         branch_component_pit = branch_pit[f:t, :]
-        cp = branch_component_pit[:, CP]
-        rho = branch_component_pit[:, RHO]
-        v_init = branch_component_pit[:, VINIT_T]
-        from_nodes = branch_component_pit[:, FROM_NODE_T].astype(np.int32)
-        t_init_i = node_pit[from_nodes, TINIT_NODE]
-        t_init_i1 = branch_component_pit[:, T_OUT]
-        t_amb = branch_component_pit[:, TEXT]
-        area = branch_component_pit[:, AREA]
-        length = branch_component_pit[:, LENGTH]
-        alpha = branch_component_pit[:, ALPHA] * np.pi * branch_component_pit[:, D]
+        cp = branch_component_pit[:, net['_idx_branch']['CP']]
+        rho = branch_component_pit[:, net['_idx_branch']['RHO']]
+        v_init = branch_component_pit[:, net['_idx_branch']['VINIT_T']]
+        from_nodes = branch_component_pit[:, net['_idx_branch']['FROM_NODE_T']].astype(np.int32)
+        t_init_i = node_pit[from_nodes, net['_idx_node']['TINIT']]
+        t_init_i1 = branch_component_pit[:, net['_idx_branch']['T_OUT']]
+        t_amb = branch_component_pit[:, net['_idx_branch']['TEXT']]
+        area = branch_component_pit[:, net['_idx_branch']['AREA']]
+        length = branch_component_pit[:, net['_idx_branch']['LENGTH']]
+        alpha = branch_component_pit[:, net['_idx_branch']['ALPHA']] * np.pi * branch_component_pit[:,
+                                                                               net['_idx_branch']['D']]
         cls.calculate_temperature_lift(net, branch_component_pit, node_pit)
-        tl = branch_component_pit[:, TL]
-        qext = branch_component_pit[:, QEXT]
+        tl = branch_component_pit[:, net['_idx_branch']['TL']]
+        qext = branch_component_pit[:, net['_idx_branch']['QEXT']]
         t_m = (t_init_i1 + t_init_i) / 2
 
-        branch_component_pit[:, LOAD_VEC_BRANCHES_T] = \
+        branch_component_pit[:, net['_idx_branch']['LOAD_VEC_BRANCHES_T']] = \
             -(rho * area * cp * v_init * (-t_init_i + t_init_i1 - tl)
               - alpha * (t_amb - t_m) * length + qext)
 
-        branch_component_pit[:, JAC_DERIV_DT] = - rho * area * cp * v_init + alpha / 2 * length
-        branch_component_pit[:, JAC_DERIV_DT1] = rho * area * cp * v_init + alpha / 2 * length
+        branch_component_pit[:, net['_idx_branch']['JAC_DERIV_DT']] = - rho * area * cp * v_init + alpha / 2 * length
+        branch_component_pit[:, net['_idx_branch']['JAC_DERIV_DT1']] = rho * area * cp * v_init + alpha / 2 * length
 
-        branch_component_pit[:, JAC_DERIV_DT_NODE] = rho * v_init * branch_component_pit[:, AREA]
-        branch_component_pit[:, LOAD_VEC_NODES_T] = rho * v_init * branch_component_pit[:, AREA] \
-            * t_init_i1
-
-    @classmethod
-    def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_lookups, options):
-        pass
+        branch_component_pit[:, net['_idx_branch']['JAC_DERIV_DT_NODE']] = \
+            rho * v_init * branch_component_pit[:, net['_idx_branch']['AREA']]
+        branch_component_pit[:, net['_idx_branch']['LOAD_VEC_NODES_T']] = \
+            rho * v_init * branch_component_pit[:, net['_idx_branch']['AREA']] * t_init_i1
 
     @classmethod
     def calculate_temperature_lift(cls, net, branch_pit, node_pit):
@@ -166,3 +185,16 @@ def calculate_temperature_lift(cls, net, branch_pit, node_pit):
     @classmethod
     def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
         raise NotImplementedError
+
+
+def create_v_node(net, branch_pit):
+    v = branch_pit[:, net['_idx_branch']['VINIT']]
+    fn_w = branch_pit[v >= 0, net['_idx_branch']['FROM_NODE']]
+    tn_w = branch_pit[v < 0, net['_idx_branch']['TO_NODE']]
+    branch_pit[v >= 0, net['_idx_branch']['V_FROM_NODE']] = fn_w
+    branch_pit[v < 0, net['_idx_branch']['V_FROM_NODE']] = tn_w
+
+    tn_w = branch_pit[v >= 0, net['_idx_branch']['TO_NODE']]
+    fn_w = branch_pit[v < 0, net['_idx_branch']['FROM_NODE']]
+    branch_pit[v >= 0, net['_idx_branch']['V_TO_NODE']] = tn_w
+    branch_pit[v < 0, net['_idx_branch']['V_TO_NODE']] = fn_w

pandapipes/component_models/abstract_models/branch_w_internals_models.py

@@ -3,18 +3,14 @@
 # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
 import numpy as np
-from pandapipes.component_models.abstract_models.branch_models import BranchComponent
 from pandapipes.component_models.component_toolbox import set_entry_check_repeat
-from pandapipes.idx_branch import ACTIVE
-from pandapipes.idx_branch import FROM_NODE, TO_NODE, TINIT, RHO, ETA, \
-    CP, ELEMENT_IDX
-from pandapipes.idx_node import L, node_cols
-from pandapipes.idx_node import TINIT as TINIT_NODE
+
+from pandapipes.component_models.abstract_models.branch_models import BranchComponent
 from pandapipes.pf.pipeflow_setup import add_table_lookup, get_lookup, get_table_number
-from pandapipes.properties.fluids import get_fluid
+from pandapipes.properties.fluids import get_fluid, get_mixture_density
 
 try:
-    import pplog as logging
+    from pandaplan.core import pplog as logging
 except ImportError:
     import logging
 
@@ -97,7 +93,7 @@ def create_node_lookups(cls, net, ft_lookups, table_lookup, idx_lookups, current
             add_table_lookup(table_lookup, cls.internal_node_name(), current_table)
             ft_lookups[cls.internal_node_name()] = (current_start, end)
             return end, current_table + 1, internal_nodes, internal_pipes, int_nodes_num, \
-                int_pipes_num
+                   int_pipes_num
         else:
             return end, current_table + 1, 0, 0, 0, 0
 
@@ -142,14 +138,15 @@ def create_pit_node_entries(cls, net, node_pit):
         table_nr = get_table_number(table_lookup, cls.internal_node_name())
         if table_nr is None:
             return None, 0, 0, None, None, None
+        # TODO: should be from_to_active
         ft_lookup = get_lookup(net, "node", "from_to")
         f, t = ft_lookup[cls.internal_node_name()]
 
         int_node_pit = node_pit[f:t, :]
-        int_node_pit[:, :] = np.array([table_nr, 0, L] + [0] * (node_cols - 3))
+        int_node_pit[:, :] = np.array([table_nr, 0, net['_idx_node']['L']] + [0] * (net['_idx_node']['node_cols'] - 3))
         int_node_number = cls.get_internal_pipe_number(net) - 1
 
-        int_node_pit[:, ELEMENT_IDX] = np.arange(t - f)
+        int_node_pit[:, net['_idx_node']['ELEMENT_IDX']] = np.arange(t - f)
 
         junction_table_name = cls.get_connected_node_type().table_name()
         fj_name, tj_name = "from_" + junction_table_name, "to_" + junction_table_name
@@ -191,22 +188,42 @@ def create_pit_branch_entries(cls, net, branch_pit):
             to_nodes = np.insert(to_nodes, insert_places, pipe_nodes_idx)
 
         set_entry_check_repeat(
-            branch_w_internals_pit, ELEMENT_IDX, net[cls.table_name()].index.values,
+            branch_w_internals_pit, net['_idx_branch']['ELEMENT_IDX'], net[cls.table_name()].index.values,
             internal_pipe_number, has_internals)
         set_entry_check_repeat(
-            branch_w_internals_pit, ACTIVE, net[cls.table_name()][cls.active_identifier()].values,
+            branch_w_internals_pit, net['_idx_branch']['ACTIVE'], net[cls.table_name()][cls.active_identifier()].values,
             internal_pipe_number, has_internals)
-        branch_w_internals_pit[:, FROM_NODE] = from_nodes
-        branch_w_internals_pit[:, TO_NODE] = to_nodes
-        branch_w_internals_pit[:, TINIT] = (node_pit[from_nodes, TINIT_NODE] + node_pit[
-            to_nodes, TINIT_NODE]) / 2
-        fluid = get_fluid(net)
-        branch_w_internals_pit[:, RHO] = fluid.get_density(branch_w_internals_pit[:, TINIT])
-        branch_w_internals_pit[:, ETA] = fluid.get_viscosity(branch_w_internals_pit[:, TINIT])
-        branch_w_internals_pit[:, CP] = fluid.get_heat_capacity(branch_w_internals_pit[:, TINIT])
+        branch_w_internals_pit[:, net['_idx_branch']['FROM_NODE']] = from_nodes
+        branch_w_internals_pit[:, net['_idx_branch']['TO_NODE']] = to_nodes
+        branch_w_internals_pit[:, net['_idx_branch']['TINIT']] = \
+            (node_pit[from_nodes, net['_idx_node']['TINIT']] + node_pit[to_nodes, net['_idx_node']['TINIT']]) / 2
+
+        if len(net._fluid) == 1:
+            branch_w_internals_pit[:, net['_idx_branch']['RHO']] = \
+                get_fluid(net, net._fluid[0]).get_density(branch_w_internals_pit[:, net['_idx_branch']['TINIT']])
+            branch_w_internals_pit[:, net['_idx_branch']['ETA']] = \
+                get_fluid(net, net._fluid[0]).get_viscosity(branch_w_internals_pit[:, net['_idx_branch']['TINIT']])
+            branch_w_internals_pit[:, net['_idx_branch']['CP']] = \
+                get_fluid(net, net._fluid[0]).get_heat_capacity(branch_w_internals_pit[:, net['_idx_branch']['TINIT']])
+        else:
+            for fluid in net._fluid:
+                branch_w_internals_pit[:, net['_idx_branch'][fluid + '_RHO']] = \
+                    get_fluid(net, fluid).get_density(branch_w_internals_pit[:, net['_idx_branch']['TINIT']])
 
         return branch_w_internals_pit, internal_pipe_number
 
+    @classmethod
+    def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, branch_lookups, node_lookups, options):
+        super().adaption_before_derivatives_hydraulic(net, branch_pit, node_pit, branch_lookups, node_lookups, options)
+        internal_nodes = cls.get_internal_pipe_number(net) - 1
+        if len(net._fluid) != 1 and np.any(internal_nodes) > 0:
+            f, t = node_lookups[cls.internal_node_name()]
+            junction_pit = node_pit[f:t, :]
+            w = get_lookup(net, 'node', 'w')
+            mass_fraction = junction_pit[:, w]
+            junction_pit[:, net['_idx_node']['RHO']] = \
+                get_mixture_density(net, junction_pit[:, net['_idx_node']['TINIT']], mass_fraction=mass_fraction)
+
     @classmethod
     def get_internal_pipe_number(cls, net):
         """

pandapipes/component_models/abstract_models/branch_wo_internals_models.py

@@ -4,14 +4,11 @@
 
 from pandapipes.component_models.abstract_models.branch_models import BranchComponent
 
-from pandapipes.idx_branch import FROM_NODE, TO_NODE, TINIT, ELEMENT_IDX, RHO, ETA, CP, ACTIVE
-from pandapipes.idx_node import TINIT as TINIT_NODE
-
 from pandapipes.pf.pipeflow_setup import add_table_lookup
 from pandapipes.properties.fluids import get_fluid
 
 try:
-    import pplog as logging
+    from pandaplan.core import pplog as logging
 except ImportError:
     import logging
 
@@ -79,16 +76,23 @@ def create_pit_branch_entries(cls, net, branch_pit):
         """
         branch_wo_internals_pit, node_pit, from_nodes, to_nodes \
             = super().create_pit_branch_entries(net, branch_pit)
-        branch_wo_internals_pit[:, ELEMENT_IDX] = net[cls.table_name()].index.values
-        branch_wo_internals_pit[:, FROM_NODE] = from_nodes
-        branch_wo_internals_pit[:, TO_NODE] = to_nodes
-        branch_wo_internals_pit[:, TINIT] = (node_pit[from_nodes, TINIT_NODE]
-                                             + node_pit[to_nodes, TINIT_NODE]) / 2
-        fluid = get_fluid(net)
-        branch_wo_internals_pit[:, RHO] = fluid.get_density(branch_wo_internals_pit[:, TINIT])
-        branch_wo_internals_pit[:, ETA] = fluid.get_viscosity(branch_wo_internals_pit[:, TINIT])
-        branch_wo_internals_pit[:, CP] = fluid.get_heat_capacity(branch_wo_internals_pit[:, TINIT])
-        branch_wo_internals_pit[:, ACTIVE] = net[cls.table_name()][cls.active_identifier()].values
+        branch_wo_internals_pit[:, net['_idx_branch']['ELEMENT_IDX']] = net[cls.table_name()].index.values
+        branch_wo_internals_pit[:, net['_idx_branch']['FROM_NODE']] = from_nodes
+        branch_wo_internals_pit[:, net['_idx_branch']['TO_NODE']] = to_nodes
+        branch_wo_internals_pit[:, net['_idx_branch']['TINIT']] = (node_pit[from_nodes, net['_idx_node']['TINIT']]
+                                                                   + node_pit[to_nodes, net['_idx_node']['TINIT']]) / 2
+        branch_wo_internals_pit[:, net['_idx_branch']['ACTIVE']] = net[cls.table_name()][cls.active_identifier()].values
+        if len(net._fluid) == 1:
+            branch_wo_internals_pit[:, net['_idx_branch']['RHO']] = \
+                get_fluid(net, net._fluid[0]).get_density(branch_wo_internals_pit[:, net['_idx_branch']['TINIT']])
+            branch_wo_internals_pit[:, net['_idx_branch']['ETA']] = \
+                get_fluid(net, net._fluid[0]).get_viscosity(branch_wo_internals_pit[:, net['_idx_branch']['TINIT']])
+            branch_wo_internals_pit[:, net['_idx_branch']['CP']] = \
+                get_fluid(net, net._fluid[0]).get_heat_capacity(branch_wo_internals_pit[:, net['_idx_branch']['TINIT']])
+        else:
+            for fluid in net._fluid:
+                branch_wo_internals_pit[:, net['_idx_branch'][fluid + '_RHO']] = \
+                    get_fluid(net, fluid).get_density(branch_wo_internals_pit[:, net['_idx_branch']['TINIT']])
         return branch_wo_internals_pit
 
     @classmethod

pandapipes/component_models/abstract_models/branch_wzerolength_models.py

@@ -4,10 +4,9 @@
 
 from pandapipes.component_models.abstract_models.branch_wo_internals_models import \
     BranchWOInternalsComponent
-from pandapipes.idx_branch import LENGTH, K
 
 try:
-    import pplog as logging
+    from pandaplan.core import pplog as logging
 except ImportError:
     import logging
 
@@ -56,8 +55,8 @@ def create_pit_branch_entries(cls, net, branch_pit):
         """
         branch_wizerolength_pit = \
             super().create_pit_branch_entries(net, branch_pit)
-        branch_wizerolength_pit[:, LENGTH] = 0
-        branch_wizerolength_pit[:, K] = 1000
+        branch_wizerolength_pit[:, net['_idx_branch']['LENGTH']] = 0
+        branch_wizerolength_pit[:, net['_idx_branch']['K']] = 1000
         return branch_wizerolength_pit
 
     @classmethod